Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
Revamped telegram result display
Alishahryar1b95f2ef9c45b
diff --git a/messaging/event_parser.py b/messaging/event_parser.pyindex 5de5e348..6e748ec7 100644--- a/messaging/event_parser.py+++ b/messaging/event_parser.py@@ -1,6 +1,7 @@"""CLI event parser for Claude Code CLI output.-Extracted from cli.parser to avoid tight coupling between messaging and cli packages.+This parser emits an ordered stream of low-level events suitable for building a+Claude Code-like transcript in messaging UIs."""import logging@@ -23,12 +24,14 @@ def parse_cli_event(event: Any) -> List[Dict]:return []etype = event.get("type")- results = []+ results: List[Dict[str, Any]] = []- # 1. Handle full messages (assistant or result)+ # 1. Handle full messages (assistant/user or result)msg_obj = Noneif etype == "assistant":msg_obj = event.get("message")+ elif etype == "user":+ msg_obj = event.get("message")elif etype == "result":res = event.get("result")if isinstance(res, dict):@@ -39,40 +42,35 @@ def parse_cli_event(event: Any) -> List[Dict]:if msg_obj and isinstance(msg_obj, dict):content = msg_obj.get("content", [])if isinstance(content, list):- parts = []- thinking_parts = []- tool_calls = []+ # Preserve order exactly as content blocks appear.for c in content:if not isinstance(c, dict):continuectype = c.get("type")if ctype == "text":- parts.append(c.get("text", ""))+ results.append({"type": "text_chunk", "text": c.get("text", "")})elif ctype == "thinking":- thinking_parts.append(c.get("thinking", ""))+ results.append(+ {"type": "thinking_chunk", "text": c.get("thinking", "")}+ )elif ctype == "tool_use":- tool_calls.append(c)-- # Prioritize thinking first- if thinking_parts:- results.append({"type": "thinking", "text": "\n".join(thinking_parts)})-- # Then tools or subagents- if tool_calls:- # Check for subagents (Task tool)- subagents = [- t.get("input", {}).get("description", "Subagent")- for t in tool_calls- if t.get("name") == "Task"- ]- if subagents:- results.append({"type": "subagent_start", "tasks": subagents})- else:- results.append({"type": "tool_start", "tools": tool_calls})-- # Then text content if any- if parts:- results.append({"type": "content", "text": "".join(parts)})+ results.append(+ {+ "type": "tool_use",+ "id": c.get("id", ""),+ "name": c.get("name", ""),+ "input": c.get("input"),+ }+ )+ elif ctype == "tool_result":+ results.append(+ {+ "type": "tool_result",+ "tool_use_id": c.get("tool_use_id", ""),+ "content": c.get("content"),+ "is_error": bool(c.get("is_error", False)),+ }+ )if results:return results@@ -82,18 +80,53 @@ def parse_cli_event(event: Any) -> List[Dict]:delta = event.get("delta", {})if isinstance(delta, dict):if delta.get("type") == "text_delta":- return [{"type": "content", "text": delta.get("text", "")}]+ return [+ {+ "type": "text_delta",+ "index": event.get("index", -1),+ "text": delta.get("text", ""),+ }+ ]if delta.get("type") == "thinking_delta":- return [{"type": "thinking", "text": delta.get("thinking", "")}]+ return [+ {+ "type": "thinking_delta",+ "index": event.get("index", -1),+ "text": delta.get("thinking", ""),+ }+ ]+ if delta.get("type") == "input_json_delta":+ return [+ {+ "type": "tool_use_delta",+ "index": event.get("index", -1),+ "partial_json": delta.get("partial_json", ""),+ }+ ]# 3. Handle tool usage startif etype == "content_block_start":block = event.get("content_block", {})- if isinstance(block, dict) and block.get("type") == "tool_use":- if block.get("name") == "Task":- desc = block.get("input", {}).get("description", "Subagent")- return [{"type": "subagent_start", "tasks": [desc]}]- return [{"type": "tool_start", "tools": [block]}]+ if isinstance(block, dict):+ btype = block.get("type")+ if btype == "thinking":+ return [{"type": "thinking_start", "index": event.get("index", -1)}]+ if btype == "text":+ return [{"type": "text_start", "index": event.get("index", -1)}]+ if btype == "tool_use":+ return [+ {+ "type": "tool_use_start",+ "index": event.get("index", -1),+ "id": block.get("id", ""),+ "name": block.get("name", ""),+ "input": block.get("input"),+ }+ ]++ # 3.5 Handle block stop (to close open streaming segments)+ if etype == "content_block_stop":+ return [{"type": "block_stop", "index": event.get("index", -1)}]# 4. Handle errors and exitif etype == "error":diff --git a/messaging/handler.py b/messaging/handler.pyindex 1c5a4e85..e028266a 100644--- a/messaging/handler.py+++ b/messaging/handler.py@@ -19,6 +19,7 @@ from .models import IncomingMessagefrom .session import SessionStorefrom .tree_queue import TreeQueueManager, MessageNode, MessageState, MessageTreefrom .event_parser import parse_cli_event+from .transcript import TranscriptBuffer, RenderCtxlogger = logging.getLogger(__name__)@@ -76,7 +77,8 @@ def _normalize_gfm_tables(text: str) -> str:and _TABLE_SEP_RE.match(lines[idx + 1])):if out_lines and out_lines[-1].strip() != "":- indent = re.match(r"^(\s*)", line).group(1)+ m = re.match(r"^(\s*)", line)+ indent = m.group(1) if m else ""# A line of only whitespace counts as a blank line and preserves# list indentation contexts (tables inside list items).out_lines.append(indent)@@ -614,17 +616,18 @@ class ClaudeMessageHandler:if tree:await tree.update_state(node_id, MessageState.IN_PROGRESS)- # Components for structured display- components = {- "thinking": [],- "tools": [],- "subagents": [],- "content": [],- "errors": [],- }+ transcript = TranscriptBuffer(show_tool_results=False)+ render_ctx = RenderCtx(+ bold=mdv2_bold,+ code_inline=mdv2_code_inline,+ escape_code=escape_md_v2_code,+ escape_text=escape_md_v2,+ render_markdown=render_markdown_to_mdv2,+ )last_ui_update = 0.0last_displayed_text = None+ had_transcript_events = Falsecaptured_session_id = Nonetemp_session_id = None@@ -645,7 +648,7 @@ class ClaudeMessageHandler:returnlast_ui_update = now- display = self._build_message(components, status)+ display = transcript.render(render_ctx, limit_chars=3900, status=status)if display and display != last_displayed_text:last_displayed_text = displayawait self.platform.queue_edit_message(@@ -667,7 +670,7 @@ class ClaudeMessageHandler:else:captured_session_id = session_or_temp_idexcept RuntimeError as e:- components["errors"].append(str(e))+ transcript.apply({"type": "error", "message": str(e)})await update_ui(format_status("⏳", "Session limit reached"), force=True)@@ -718,28 +721,43 @@ class ClaudeMessageHandler:logger.debug(f"HANDLER: Parsed {len(parsed_list)} events from CLI")for parsed in parsed_list:- if parsed["type"] == "thinking":- components["thinking"].append(parsed["text"])+ ptype = parsed.get("type")+ if ptype in (+ "thinking_start",+ "thinking_delta",+ "thinking_chunk",+ "thinking_stop",+ "text_start",+ "text_delta",+ "text_chunk",+ "text_stop",+ "tool_use_start",+ "tool_use_delta",+ "tool_use_stop",+ "tool_use",+ "tool_result",+ "block_stop",+ "error",+ ):+ transcript.apply(parsed)+ had_transcript_events = True++ if ptype in ("thinking_start", "thinking_delta", "thinking_chunk"):await update_ui(format_status("🧠", "Claude is thinking..."))-- elif parsed["type"] == "content":- if parsed.get("text"):- components["content"].append(parsed["text"])+ elif ptype in ("text_start", "text_delta", "text_chunk"):await update_ui(format_status("🧠", "Claude is working..."))-- elif parsed["type"] == "tool_start":- names = [t.get("name") for t in parsed.get("tools", [])]- components["tools"].extend(names)+ elif ptype in ("tool_use_start", "tool_use_delta", "tool_use"):+ if parsed.get("name") == "Task":+ await update_ui(format_status("🤖", "Subagent working..."))+ else:+ await update_ui(format_status("⏳", "Executing tools..."))+ elif ptype == "tool_result":await update_ui(format_status("⏳", "Executing tools..."))- elif parsed["type"] == "subagent_start":- tasks = parsed.get("tasks", [])- components["subagents"].extend(tasks)- await update_ui(format_status("🤖", "Subagent working..."))-elif parsed["type"] == "complete":- if not any(components.values()):- components["content"].append("Done.")+ # If nothing happened (rare), still show a completion marker.+ if not had_transcript_events:+ transcript.apply({"type": "text_chunk", "text": "Done."})logger.info("HANDLER: Task complete, updating UI")await update_ui(format_status("✅", "Complete"), force=True)@@ -757,7 +775,6 @@ class ClaudeMessageHandler:logger.error(f"HANDLER: Error event received: {error_msg[:200]}")- components["errors"].append(error_msg)logger.info("HANDLER: Updating UI with error status")await update_ui(format_status("❌", "Error"), force=True)if tree:@@ -774,7 +791,7 @@ class ClaudeMessageHandler:if cancel_reason == "stop":await update_ui(format_status("⏹", "Stopped."), force=True)else:- components["errors"].append("Task was cancelled")+ transcript.apply({"type": "error", "message": "Task was cancelled"})await update_ui(format_status("❌", "Cancelled"), force=True)# Do not propagate cancellation to children; a reply-scoped "/stop"@@ -788,16 +805,14 @@ class ClaudeMessageHandler:f"HANDLER: Task failed with exception: {type(e).__name__}: {e}")error_msg = str(e)[:200]- components["errors"].append(error_msg)+ transcript.apply({"type": "error", "message": error_msg})await update_ui(format_status("💥", "Task Failed"), force=True)if tree:await self._propagate_error_to_children(node_id, error_msg, "Parent task failed")finally:- logger.info(- f"HANDLER: _process_node completed for node {node_id}, errors={len(components['errors'])}"- )+ logger.info(f"HANDLER: _process_node completed for node {node_id}")# Free the session-manager slot. Session IDs are persisted in the tree and# can be resumed later by ID; we don't need to keep a CLISession instance# around after this node completes.@@ -830,87 +845,6 @@ class ClaudeMessageHandler:))- def _build_message(- self,- components: dict,- status: Optional[str] = None,- ) -> str:- """- Build unified message with specific order.- Handles truncation while preserving markdown structure (closing code blocks).- """- lines = []-- # 1. Thinking- if components["thinking"]:- thinking_text = "".join(components["thinking"])- # Truncate thinking if too long, it's usually less critical than final content- if len(thinking_text) > 1000:- thinking_text = "..." + thinking_text[-995:]-- lines.append(- f"💭 {mdv2_bold('Thinking:')}\n```\n{escape_md_v2_code(thinking_text)}\n```"- )-- # 2. Tools- if components["tools"]:- unique_tools = []- seen = set()- for t in components["tools"]:- if t and t not in seen:- unique_tools.append(str(t))- seen.add(t)- if unique_tools:- lines.append(- f"🛠 {mdv2_bold('Tools:')} {mdv2_code_inline(', '.join(unique_tools))}"- )-- # 3. Subagents- if components["subagents"]:- for task in components["subagents"]:- lines.append(f"🤖 {mdv2_bold('Subagent:')} {mdv2_code_inline(task)}")-- # 4. Content- if components["content"]:- lines.append(render_markdown_to_mdv2("".join(components["content"])))-- # 5. Errors- if components["errors"]:- for err in components["errors"]:- lines.append(f"⚠️ {mdv2_bold('Error:')} {mdv2_code_inline(err)}")-- if not any(lines) and not status:- return format_status("⏳", "Claude is working...")-- # Telegram character limit is 4096. We leave buffer for status updates.- LIMIT = 3900-- # Filter out empty lines first for a clean join- lines = [l for l in lines if l]-- main_text = "\n".join(lines)- status_text = f"\n\n{status}" if status else ""-- if len(main_text) + len(status_text) <= LIMIT:- return (- main_text + status_text- if main_text + status_text- else format_status("⏳", "Claude is working...")- )-- # If too long, truncate the start of the content (keep the end)- available_limit = LIMIT - len(status_text) - 20 # 20 for truncation marker- raw_truncated = main_text[-available_limit:].lstrip()-- # Check for unbalanced code blocks- prefix = escape_md_v2("... (truncated)\n")- if raw_truncated.count("```") % 2 != 0:- prefix += "```\n"-- truncated_main = prefix + raw_truncated-- return truncated_main + status_text-def _get_initial_status(self,tree: Optional[object],diff --git a/messaging/transcript.py b/messaging/transcript.pynew file mode 100644index 00000000..99c58403--- /dev/null+++ b/messaging/transcript.py@@ -0,0 +1,402 @@+"""Ordered transcript builder for messaging UIs (Telegram, etc.).++This module maintains an ordered list of "segments" that represent what the user+should see in the chat transcript: thinking, tool calls, tool results, subagent+headers, and assistant text. It is designed for in-place message editing where+the transcript grows over time and older content must be truncated.+"""++from __future__ import annotations++import json+from dataclasses import dataclass+from typing import Any, Callable, Dict, List, Optional+++def _safe_json_dumps(obj: Any) -> str:+ try:+ return json.dumps(obj, indent=2, ensure_ascii=False, sort_keys=True)+ except Exception:+ return str(obj)+++@dataclass+class Segment:+ kind: str++ def render(self, ctx: "RenderCtx") -> str:+ raise NotImplementedError+++@dataclass+class ThinkingSegment(Segment):+ text: str = ""++ def __init__(self) -> None:+ super().__init__(kind="thinking")++ def append(self, t: str) -> None:+ if t:+ self.text += t++ def render(self, ctx: "RenderCtx") -> str:+ raw = self.text or ""+ if ctx.thinking_tail_max is not None and len(raw) > ctx.thinking_tail_max:+ raw = "..." + raw[-(ctx.thinking_tail_max - 3) :]+ inner = ctx.escape_code(raw)+ return f"💭 {ctx.bold('Thinking')}\n```\n{inner}\n```"+++@dataclass+class TextSegment(Segment):+ text: str = ""++ def __init__(self) -> None:+ super().__init__(kind="text")++ def append(self, t: str) -> None:+ if t:+ self.text += t++ def render(self, ctx: "RenderCtx") -> str:+ raw = self.text or ""+ if ctx.text_tail_max is not None and len(raw) > ctx.text_tail_max:+ raw = "..." + raw[-(ctx.text_tail_max - 3) :]+ return ctx.render_markdown(raw)+++@dataclass+class ToolCallSegment(Segment):+ tool_use_id: str+ name: str+ input_text: str = ""+ closed: bool = False++ def __init__(self, tool_use_id: str, name: str) -> None:+ super().__init__(kind="tool_call")+ self.tool_use_id = str(tool_use_id or "")+ self.name = str(name or "tool")++ def set_initial_input(self, inp: Any) -> None:+ if inp is None:+ return+ if isinstance(inp, str):+ self.input_text = inp+ else:+ self.input_text = _safe_json_dumps(inp)++ def append_input_delta(self, partial: str) -> None:+ if partial:+ self.input_text += partial++ def render(self, ctx: "RenderCtx") -> str:+ raw = self.input_text or ""+ if ctx.tool_input_tail_max is not None and len(raw) > ctx.tool_input_tail_max:+ raw = "..." + raw[-(ctx.tool_input_tail_max - 3) :]+ inner = ctx.escape_code(raw)+ name = ctx.code_inline(self.name)+ return f"🛠 {ctx.bold('Tool call:')} {name}\n```\n{inner}\n```"+++@dataclass+class ToolResultSegment(Segment):+ tool_use_id: str+ name: Optional[str]+ content_text: str+ is_error: bool = False++ def __init__(+ self,+ tool_use_id: str,+ content: Any,+ *,+ name: Optional[str] = None,+ is_error: bool = False,+ ) -> None:+ super().__init__(kind="tool_result")+ self.tool_use_id = str(tool_use_id or "")+ self.name = str(name) if name is not None else None+ self.is_error = bool(is_error)+ if isinstance(content, str):+ self.content_text = content+ else:+ self.content_text = _safe_json_dumps(content)++ def render(self, ctx: "RenderCtx") -> str:+ raw = self.content_text or ""+ if ctx.tool_output_tail_max is not None and len(raw) > ctx.tool_output_tail_max:+ raw = "..." + raw[-(ctx.tool_output_tail_max - 3) :]+ inner = ctx.escape_code(raw)+ label = "Tool error:" if self.is_error else "Tool result:"+ maybe_name = f" {ctx.code_inline(self.name)}" if self.name else ""+ return f"📤 {ctx.bold(label)}{maybe_name}\n```\n{inner}\n```"+++@dataclass+class SubagentHeaderSegment(Segment):+ description: str++ def __init__(self, description: str) -> None:+ super().__init__(kind="subagent")+ self.description = str(description or "Subagent")++ def render(self, ctx: "RenderCtx") -> str:+ return f"🤖 {ctx.bold('Subagent:')} {ctx.code_inline(self.description)}"+++@dataclass+class ErrorSegment(Segment):+ message: str++ def __init__(self, message: str) -> None:+ super().__init__(kind="error")+ self.message = str(message or "Unknown error")++ def render(self, ctx: "RenderCtx") -> str:+ return f"⚠️ {ctx.bold('Error:')} {ctx.code_inline(self.message)}"+++@dataclass+class RenderCtx:+ bold: Callable[[str], str]+ code_inline: Callable[[str], str]+ escape_code: Callable[[str], str]+ escape_text: Callable[[str], str]+ render_markdown: Callable[[str], str]++ thinking_tail_max: Optional[int] = 1000+ tool_input_tail_max: Optional[int] = 1200+ tool_output_tail_max: Optional[int] = 1600+ text_tail_max: Optional[int] = 2000+++class TranscriptBuffer:+ """Maintains an ordered, truncatable transcript of events."""++ def __init__(self, *, show_tool_results: bool = True) -> None:+ self._segments: List[Segment] = []+ self._open_thinking_by_index: Dict[int, ThinkingSegment] = {}+ self._open_text_by_index: Dict[int, TextSegment] = {}++ # content_block index -> tool call segment (for streaming tool args)+ self._open_tools_by_index: Dict[int, ToolCallSegment] = {}++ # tool_use_id -> tool name (for tool_result labeling)+ self._tool_name_by_id: Dict[str, str] = {}++ self._show_tool_results = bool(show_tool_results)++ # subagent context stack. Each entry is the Task tool_use_id we are waiting to close.+ self._subagent_stack: List[str] = []++ def _in_subagent(self) -> bool:+ return bool(self._subagent_stack)++ def _ensure_thinking(self) -> ThinkingSegment:+ seg = ThinkingSegment()+ self._segments.append(seg)+ return seg++ def _ensure_text(self) -> TextSegment:+ seg = TextSegment()+ self._segments.append(seg)+ return seg++ def apply(self, ev: Dict[str, Any]) -> None:+ """Apply a parsed event to the transcript."""+ et = ev.get("type")++ # Subagent rules: inside a Task/subagent, we only show tool calls/results.+ if self._in_subagent() and et in (+ "thinking_start",+ "thinking_delta",+ "thinking_chunk",+ "text_start",+ "text_delta",+ "text_chunk",+ ):+ return++ if et == "thinking_start":+ idx = int(ev.get("index", -1))+ seg = self._ensure_thinking()+ if idx >= 0:+ self._open_thinking_by_index[idx] = seg+ return+ if et in ("thinking_delta", "thinking_chunk"):+ idx = int(ev.get("index", -1))+ seg = self._open_thinking_by_index.get(idx)+ if seg is None:+ seg = self._ensure_thinking()+ if idx >= 0:+ self._open_thinking_by_index[idx] = seg+ seg.append(str(ev.get("text", "")))+ return+ if et == "thinking_stop":+ idx = int(ev.get("index", -1))+ if idx >= 0:+ self._open_thinking_by_index.pop(idx, None)+ return++ if et == "text_start":+ idx = int(ev.get("index", -1))+ seg = self._ensure_text()+ if idx >= 0:+ self._open_text_by_index[idx] = seg+ return+ if et in ("text_delta", "text_chunk"):+ idx = int(ev.get("index", -1))+ seg = self._open_text_by_index.get(idx)+ if seg is None:+ seg = self._ensure_text()+ if idx >= 0:+ self._open_text_by_index[idx] = seg+ seg.append(str(ev.get("text", "")))+ return+ if et == "text_stop":+ idx = int(ev.get("index", -1))+ if idx >= 0:+ self._open_text_by_index.pop(idx, None)+ return++ if et == "tool_use_start":+ idx = int(ev.get("index", -1))+ tool_id = str(ev.get("id", "") or "")+ name = str(ev.get("name", "") or "tool")+ seg = ToolCallSegment(tool_id, name)+ seg.set_initial_input(ev.get("input"))+ self._segments.append(seg)+ if idx >= 0:+ self._open_tools_by_index[idx] = seg+ if tool_id:+ self._tool_name_by_id[tool_id] = name++ # Task tool indicates subagent.+ if name == "Task":+ desc = ""+ inp = ev.get("input")+ if isinstance(inp, dict):+ desc = str(inp.get("description", "") or "")+ if not desc:+ desc = "Subagent"+ self._segments.append(SubagentHeaderSegment(desc))+ if tool_id:+ self._subagent_stack.append(tool_id)+ return++ if et == "tool_use_delta":+ idx = int(ev.get("index", -1))+ partial = str(ev.get("partial_json", "") or "")+ seg = self._open_tools_by_index.get(idx)+ if seg is not None:+ seg.append_input_delta(partial)+ return++ if et == "tool_use_stop":+ idx = int(ev.get("index", -1))+ seg = self._open_tools_by_index.pop(idx, None)+ if seg is not None:+ seg.closed = True+ return++ if et == "block_stop":+ idx = int(ev.get("index", -1))+ if idx in self._open_tools_by_index:+ self.apply({"type": "tool_use_stop", "index": idx})+ return+ if idx in self._open_thinking_by_index:+ self.apply({"type": "thinking_stop", "index": idx})+ return+ if idx in self._open_text_by_index:+ self.apply({"type": "text_stop", "index": idx})+ return+ return++ if et == "tool_use":+ tool_id = str(ev.get("id", "") or "")+ name = str(ev.get("name", "") or "tool")+ seg = ToolCallSegment(tool_id, name)+ seg.set_initial_input(ev.get("input"))+ seg.closed = True+ self._segments.append(seg)+ if tool_id:+ self._tool_name_by_id[tool_id] = name++ if name == "Task":+ desc = ""+ inp = ev.get("input")+ if isinstance(inp, dict):+ desc = str(inp.get("description", "") or "")+ if not desc:+ desc = "Subagent"+ self._segments.append(SubagentHeaderSegment(desc))+ if tool_id:+ self._subagent_stack.append(tool_id)+ return++ if et == "tool_result":+ tool_id = str(ev.get("tool_use_id", "") or "")+ name = self._tool_name_by_id.get(tool_id)++ # If this was the Task tool result, close subagent context.+ if tool_id and self._subagent_stack and self._subagent_stack[-1] == tool_id:+ self._subagent_stack.pop()++ if not self._show_tool_results:+ return++ seg = ToolResultSegment(+ tool_id,+ ev.get("content"),+ name=name,+ is_error=bool(ev.get("is_error", False)),+ )+ self._segments.append(seg)+ return++ if et == "error":+ self._segments.append(ErrorSegment(str(ev.get("message", ""))))+ return++ def render(self, ctx: RenderCtx, *, limit_chars: int, status: Optional[str]) -> str:+ """Render transcript with truncation (drop oldest segments)."""+ # Filter out empty rendered segments.+ rendered: List[str] = []+ for seg in self._segments:+ try:+ out = seg.render(ctx)+ except Exception:+ continue+ if out:+ rendered.append(out)++ status_text = f"\n\n{status}" if status else ""+ prefix_marker = ctx.escape_text("... (truncated)\n")++ def _join(parts: List[str], add_marker: bool) -> str:+ body = "\n".join(parts)+ if add_marker and body:+ body = prefix_marker + body+ return body + status_text if (body or status_text) else status_text++ # Fast path.+ candidate = _join(rendered, add_marker=False)+ if len(candidate) <= limit_chars:+ return candidate++ # Drop oldest segments until under limit.+ parts = list(rendered)+ dropped = False+ while parts:+ candidate = _join(parts, add_marker=True)+ if len(candidate) <= limit_chars:+ return candidate+ parts.pop(0)+ dropped = True++ # Nothing fits; return status only with marker if possible.+ if dropped:+ minimal = prefix_marker + status_text.lstrip("\n")+ if len(minimal) <= limit_chars:+ return minimal+ return status or ""diff --git a/tests/test_cli.py b/tests/test_cli.pyindex 30dd866c..7456ef5d 100644--- a/tests/test_cli.py+++ b/tests/test_cli.py@@ -20,7 +20,7 @@ class TestCLIParser:}result = parse_cli_event(event)assert len(result) == 1- assert result[0]["type"] == "content"+ assert result[0]["type"] == "text_chunk"assert result[0]["text"] == "Hello, world!"def test_parse_thinking_content(self):@@ -33,7 +33,7 @@ class TestCLIParser:}result = parse_cli_event(event)assert len(result) == 1- assert result[0]["type"] == "thinking"+ assert result[0]["type"] == "thinking_chunk"assert (result[0]["text"] == "Let me think...\n"or result[0]["text"] == "Let me think..."@@ -52,9 +52,9 @@ class TestCLIParser:}result = parse_cli_event(event)assert len(result) == 2- assert result[0]["type"] == "thinking"+ assert result[0]["type"] == "thinking_chunk"assert result[0]["text"] == "Thinking..."- assert result[1]["type"] == "tool_start"+ assert result[1]["type"] == "tool_use"def test_parse_tool_use(self):"""Test parsing tool use content."""@@ -72,30 +72,32 @@ class TestCLIParser:}result = parse_cli_event(event)assert len(result) == 1- assert result[0]["type"] == "tool_start"- assert len(result[0]["tools"]) == 1- assert result[0]["tools"][0]["name"] == "read_file"+ assert result[0]["type"] == "tool_use"+ assert result[0]["name"] == "read_file"+ assert result[0]["input"] == {"path": "/test"}def test_parse_text_delta(self):"""Test parsing streaming text delta."""event = {"type": "content_block_delta",+ "index": 0,"delta": {"type": "text_delta", "text": "streaming text"},}result = parse_cli_event(event)assert len(result) == 1- assert result[0]["type"] == "content"+ assert result[0]["type"] == "text_delta"assert result[0]["text"] == "streaming text"def test_parse_thinking_delta(self):"""Test parsing streaming thinking delta."""event = {"type": "content_block_delta",+ "index": 1,"delta": {"type": "thinking_delta", "thinking": "thinking..."},}result = parse_cli_event(event)assert len(result) == 1- assert result[0]["type"] == "thinking"+ assert result[0]["type"] == "thinking_delta"assert result[0]["text"] == "thinking..."def test_parse_error(self):diff --git a/tests/test_event_parser.py b/tests/test_event_parser.pyindex 0ebae82b..aa7d76d2 100644--- a/tests/test_event_parser.py+++ b/tests/test_event_parser.py@@ -13,8 +13,8 @@ def test_parse_cli_event_assistant_content():}results = parse_cli_event(event)assert len(results) == 2- assert results[0] == {"type": "thinking", "text": "Internal thought"}- assert results[1] == {"type": "content", "text": "Hello user"}+ assert results[0] == {"type": "thinking_chunk", "text": "Internal thought"}+ assert results[1] == {"type": "text_chunk", "text": "Hello user"}def test_parse_cli_event_assistant_tools():@@ -26,8 +26,9 @@ def test_parse_cli_event_assistant_tools():}results = parse_cli_event(event)assert len(results) == 1- assert results[0]["type"] == "tool_start"- assert results[0]["tools"][0]["name"] == "ls"+ assert results[0]["type"] == "tool_use"+ assert results[0]["name"] == "ls"+ assert results[0]["input"] == {"path": "."}def test_parse_cli_event_assistant_subagent():@@ -45,31 +46,37 @@ def test_parse_cli_event_assistant_subagent():}results = parse_cli_event(event)assert len(results) == 1- assert results[0]["type"] == "subagent_start"- assert results[0]["tasks"] == ["Fix bug"]+ assert results[0]["type"] == "tool_use"+ assert results[0]["name"] == "Task"+ assert results[0]["input"] == {"description": "Fix bug"}def test_parse_cli_event_content_block_delta():# Text deltaevent_text = {"type": "content_block_delta",+ "index": 0,"delta": {"type": "text_delta", "text": " more"},}results_text = parse_cli_event(event_text)- assert results_text == [{"type": "content", "text": " more"}]+ assert results_text == [{"type": "text_delta", "index": 0, "text": " more"}]# Thinking deltaevent_think = {"type": "content_block_delta",+ "index": 1,"delta": {"type": "thinking_delta", "thinking": " more thought"},}results_think = parse_cli_event(event_think)- assert results_think == [{"type": "thinking", "text": " more thought"}]+ assert results_think == [+ {"type": "thinking_delta", "index": 1, "text": " more thought"}+ ]def test_parse_cli_event_content_block_start():event = {"type": "content_block_start",+ "index": 2,"content_block": {"type": "tool_use","name": "Task",@@ -77,7 +84,15 @@ def test_parse_cli_event_content_block_start():},}results = parse_cli_event(event)- assert results == [{"type": "subagent_start", "tasks": ["deploy"]}]+ assert results == [+ {+ "type": "tool_use_start",+ "index": 2,+ "id": "",+ "name": "Task",+ "input": {"description": "deploy"},+ }+ ]def test_parse_cli_event_error():@@ -86,6 +101,31 @@ def test_parse_cli_event_error():assert results == [{"type": "error", "message": "something failed"}]+def test_parse_cli_event_user_tool_result():+ event = {+ "type": "user",+ "message": {+ "content": [+ {+ "type": "tool_result",+ "tool_use_id": "tool_1",+ "content": "ok",+ "is_error": False,+ }+ ]+ },+ }+ results = parse_cli_event(event)+ assert results == [+ {+ "type": "tool_result",+ "tool_use_id": "tool_1",+ "content": "ok",+ "is_error": False,+ }+ ]++def test_parse_cli_event_exit_success():event = {"type": "exit", "code": 0}results = parse_cli_event(event)diff --git a/tests/test_handler_format.py b/tests/test_handler_format.pyindex a7094a21..9c4d5830 100644--- a/tests/test_handler_format.py+++ b/tests/test_handler_format.py@@ -1,6 +1,13 @@import pytestfrom unittest.mock import MagicMock-from messaging.handler import ClaudeMessageHandler, escape_md_v2+from messaging.handler import escape_md_v2+from messaging.transcript import TranscriptBuffer, RenderCtx+from messaging.handler import (+ escape_md_v2_code,+ mdv2_bold,+ mdv2_code_inline,+ render_markdown_to_mdv2,+)@pytest.fixture@@ -8,21 +15,49 @@ def handler():platform = MagicMock()cli = MagicMock()store = MagicMock()- return ClaudeMessageHandler(platform, cli, store)---def test_build_message_structure(handler):- """Verify the order of message components."""- components = {- "thinking": ["Thinking process..."],- "tools": ["list_files", "read_file"],- "subagents": ["Searching codebase...", "Analyzing dependencies..."],- "content": ["Here is the file content."],- "errors": ["Some error happened"],- }- status = "✅ *Complete*"+ # Kept for backwards test structure; transcript rendering is now separate.+ return (platform, cli, store)+++def _ctx() -> RenderCtx:+ return RenderCtx(+ bold=mdv2_bold,+ code_inline=mdv2_code_inline,+ escape_code=escape_md_v2_code,+ escape_text=escape_md_v2,+ render_markdown=render_markdown_to_mdv2,+ )- msg = handler._build_message(components, status)++def test_transcript_structure_and_order(handler):+ """Verify ordered transcript rendering (thinking/tool/subagent/text/error/status)."""+ status = "✅ *Complete*"+ t = TranscriptBuffer()++ # Apply in a deliberate sequence.+ t.apply({"type": "thinking_chunk", "text": "Thinking process..."})+ t.apply(+ {"type": "tool_use", "id": "t1", "name": "list_files", "input": {"path": "."}}+ )++ # Subagent marker (Task tool).+ t.apply(+ {+ "type": "tool_use",+ "id": "task1",+ "name": "Task",+ "input": {"description": "Searching codebase..."},+ }+ )+ t.apply(+ {"type": "tool_use", "id": "t2", "name": "read_file", "input": {"path": "x.py"}}+ )+ t.apply({"type": "tool_result", "tool_use_id": "task1", "content": "done"})++ t.apply({"type": "text_chunk", "text": "Here is the file content."})+ t.apply({"type": "error", "message": "Some error happened"})++ msg = t.render(_ctx(), limit_chars=3900, status=status)print(f"Generated Message:\n{msg}")@@ -35,37 +70,32 @@ def test_build_message_structure(handler):assert "Some error happened" in msgassert "✅ *Complete*" in msg- # Check headers- assert "💭 *Thinking:*" in msg- assert "🛠 *Tools:*" in msg+ # Check headers/markers used in the transcript.+ assert "💭 *Thinking*" in msg+ assert "🛠 *Tool call:*" in msgassert "🤖 *Subagent:*" in msgassert "⚠️ *Error:*" in msg- # Check Order: Thinking -> Tools -> Subagents -> Content -> Errors -> Status+ # Check Order: Thinking -> Tool call -> Subagent -> Content -> Errors -> Statusp_thinking = msg.find("Thinking process...")- p_tools = msg.find("🛠 *Tools:*")- p_subagents = msg.find("🤖 *Subagent:*")+ p_tool_call = msg.find("🛠 *Tool call:*")+ p_subagent = msg.find("🤖 *Subagent:*")p_content = msg.find(escape_md_v2("Here is the file content."))p_errors = msg.find("⚠️ *Error:*")p_status = msg.find("✅ *Complete*")- assert p_thinking < p_tools, "Thinking should come before Tools"- assert p_tools < p_subagents, "Tools should come before Subagents"- assert p_subagents < p_content, "Subagents should come before Content"+ assert p_thinking < p_tool_call, "Thinking should come before tool calls"+ assert p_tool_call < p_subagent, "Tool calls should come before subagent marker"+ assert p_subagent < p_content, "Subagent should come before Content"assert p_content < p_errors, "Content should come before Errors"assert p_errors < p_status, "Errors should come before Status"-def test_build_message_simple(handler):- """Verify simple message with just content."""- components = {- "thinking": [],- "tools": [],- "subagents": [],- "content": ["Simple message."],- "errors": [],- }- msg = handler._build_message(components, "Ready")+def test_transcript_simple(handler):+ """Verify simple transcript with just text + status."""+ t = TranscriptBuffer()+ t.apply({"type": "text_chunk", "text": "Simple message."})+ msg = t.render(_ctx(), limit_chars=3900, status="Ready")assert escape_md_v2("Simple message.") in msgassert "Ready" in msg@@ -74,15 +104,27 @@ def test_build_message_simple(handler):def test_subagents_formatting(handler):- """Verify subagents formatting."""- components = {- "thinking": [],- "tools": [],- "subagents": ["Task 1", "Task 2"],- "content": [],- "errors": [],- }- msg = handler._build_message(components)+ """Verify subagent formatting (Task tool)."""+ t = TranscriptBuffer()+ t.apply(+ {+ "type": "tool_use",+ "id": "task_1",+ "name": "Task",+ "input": {"description": "Task 1"},+ }+ )+ t.apply({"type": "tool_result", "tool_use_id": "task_1", "content": "done"})+ t.apply(+ {+ "type": "tool_use",+ "id": "task_2",+ "name": "Task",+ "input": {"description": "Task 2"},+ }+ )++ msg = t.render(_ctx(), limit_chars=3900, status=None)assert "🤖 *Subagent:* `Task 1`" in msgassert "🤖 *Subagent:* `Task 2`" in msgdiff --git a/tests/test_reliability.py b/tests/test_reliability.pyindex 5c351e35..35d0cf23 100644--- a/tests/test_reliability.py+++ b/tests/test_reliability.py@@ -74,29 +74,37 @@ async def test_telegram_no_retry_on_bad_request(telegram_platform):def test_handler_build_message_hardening():- handler = ClaudeMessageHandler(AsyncMock(), AsyncMock(), AsyncMock())-- # Case 1: Empty components- components = {- "thinking": [],- "tools": [],- "subagents": [],- "content": [],- "errors": [],- }- msg = handler._build_message(components)- assert msg == format_status("⏳", "Claude is working...")-- # Case 2: Truncation with code block closing- long_thinking = "thought " * 200 # ~1400 chars- components["thinking"] = [long_thinking]- components["content"] = ["This is a very long message. " * 300] # ~ 8700 chars-- msg = handler._build_message(components, status="Finishing...")+ # Formatting hardening now lives in TranscriptBuffer rendering.+ from messaging.transcript import TranscriptBuffer, RenderCtx++ from messaging.handler import (+ escape_md_v2,+ escape_md_v2_code,+ mdv2_bold,+ mdv2_code_inline,+ render_markdown_to_mdv2,+ )++ ctx = RenderCtx(+ bold=mdv2_bold,+ code_inline=mdv2_code_inline,+ escape_code=escape_md_v2_code,+ escape_text=escape_md_v2,+ render_markdown=render_markdown_to_mdv2,+ )++ # Case 1: Empty transcript + no status => empty string.+ t = TranscriptBuffer()+ msg = t.render(ctx, limit_chars=3900, status=None)+ assert msg == ""++ # Case 2: Truncation with code block closing and status preserved.+ t.apply({"type": "thinking_chunk", "text": ("thought " * 200)})+ t.apply({"type": "text_chunk", "text": ("This is a very long message. " * 300)})++ msg = t.render(ctx, limit_chars=3900, status="Finishing...")assert len(msg) <= 4096- assert "truncated" in msgassert "Finishing..." in msg- # If thinking contains backticks, they should be balancedif "```" in msg:assert msg.count("```") % 2 == 0diff --git a/tests/test_robust_formatting.py b/tests/test_robust_formatting.pyindex 43d1dcb6..6fe9deac 100644--- a/tests/test_robust_formatting.py+++ b/tests/test_robust_formatting.py@@ -1,6 +1,13 @@import pytestfrom unittest.mock import MagicMock-from messaging.handler import ClaudeMessageHandler, escape_md_v2+from messaging.handler import escape_md_v2+from messaging.transcript import TranscriptBuffer, RenderCtx+from messaging.handler import (+ escape_md_v2_code,+ mdv2_bold,+ mdv2_code_inline,+ render_markdown_to_mdv2,+)@pytest.fixture@@ -8,27 +15,37 @@ def handler():platform = MagicMock()cli = MagicMock()store = MagicMock()- return ClaudeMessageHandler(platform, cli, store)+ return (platform, cli, store)+++def _ctx() -> RenderCtx:+ return RenderCtx(+ bold=mdv2_bold,+ code_inline=mdv2_code_inline,+ escape_code=escape_md_v2_code,+ escape_text=escape_md_v2,+ render_markdown=render_markdown_to_mdv2,+ )def test_truncation_closes_code_blocks(handler):"""Verify that truncation correctly closes open code blocks."""- components = {- "thinking": [- "Starting some long thinking process that will definitely cause truncation later on..."- ],- "tools": [],- "subagents": [],- "content": [- "```python\ndef very_long_function():\n # " + "A" * 4000- ], # Long content- "errors": [],- }+ t = TranscriptBuffer()+ t.apply(+ {+ "type": "thinking_chunk",+ "text": "Starting some long thinking process that will definitely cause truncation later on...",+ }+ )+ t.apply(+ {+ "type": "text_chunk",+ "text": "```python\ndef very_long_function():\n # " + ("A" * 4000),+ }+ )- msg = handler._build_message(components, "✅ *Complete*")+ msg = t.render(_ctx(), limit_chars=3900, status="✅ *Complete*")- assert escape_md_v2("... (truncated)") in msg- # The limit is 3900. Our content + thinking is > 4000.# The backtick count must be even to be a valid block.assert msg.count("```") % 2 == 0assert msg.endswith("```") or "✅ *Complete*" in msg.split("```")[-1]@@ -36,29 +53,18 @@ def test_truncation_closes_code_blocks(handler):def test_truncation_preserves_status(handler):"""Verify that status is still appended after truncation."""- components = {- "thinking": ["Thinking..."],- "tools": [],- "subagents": [],- "content": ["A" * 5000],- "errors": [],- }status = "READY_STATUS"- msg = handler._build_message(components, status)+ t = TranscriptBuffer()+ t.apply({"type": "thinking_chunk", "text": "Thinking..."})+ t.apply({"type": "text_chunk", "text": "A" * 5000})+ msg = t.render(_ctx(), limit_chars=3900, status=status)assert status in msg- assert escape_md_v2("... (truncated)") in msgdef test_empty_components_with_status(handler):"""Verify message building with just a status."""- components = {- "thinking": [],- "tools": [],- "subagents": [],- "content": [],- "errors": [],- }status = "Simple Status"- msg = handler._build_message(components, status)+ t = TranscriptBuffer()+ msg = t.render(_ctx(), limit_chars=3900, status=status)assert msg == "\n\nSimple Status"diff --git a/tests/test_transcript.py b/tests/test_transcript.pynew file mode 100644index 00000000..c4c7e0ad--- /dev/null+++ b/tests/test_transcript.py@@ -0,0 +1,84 @@+from messaging.transcript import TranscriptBuffer, RenderCtx++from messaging.handler import (+ escape_md_v2,+ escape_md_v2_code,+ mdv2_bold,+ mdv2_code_inline,+ render_markdown_to_mdv2,+)+++def _ctx() -> RenderCtx:+ return RenderCtx(+ bold=mdv2_bold,+ code_inline=mdv2_code_inline,+ escape_code=escape_md_v2_code,+ escape_text=escape_md_v2,+ render_markdown=render_markdown_to_mdv2,+ thinking_tail_max=1000,+ tool_input_tail_max=1200,+ tool_output_tail_max=1600,+ text_tail_max=2000,+ )+++def test_transcript_order_thinking_tool_text():+ t = TranscriptBuffer()+ t.apply({"type": "thinking_chunk", "text": "think1"})+ t.apply({"type": "tool_use", "id": "tool_1", "name": "ls", "input": {"path": "."}})+ t.apply({"type": "text_chunk", "text": "done"})++ out = t.render(_ctx(), limit_chars=3900, status=None)+ assert out.find("think1") < out.find("Tool call:") < out.find("done")+++def test_transcript_subagent_suppresses_thinking_and_text_inside():+ t = TranscriptBuffer()++ # Enter subagent context (Task tool call).+ t.apply(+ {+ "type": "tool_use",+ "id": "task_1",+ "name": "Task",+ "input": {"description": "Fix bug"},+ }+ )++ # These should be suppressed while inside subagent context.+ t.apply({"type": "thinking_delta", "index": -1, "text": "secret"})+ t.apply({"type": "text_chunk", "text": "visible?"})++ # Tool activity should still show.+ t.apply({"type": "tool_use", "id": "tool_2", "name": "ls", "input": {"path": "."}})+ t.apply({"type": "tool_result", "tool_use_id": "tool_2", "content": "x"})++ # Close subagent context (Task tool result).+ t.apply({"type": "tool_result", "tool_use_id": "task_1", "content": "done"})++ # Now text should show again.+ t.apply({"type": "text_chunk", "text": "after"})++ out = t.render(_ctx(), limit_chars=3900, status=None)+ assert "Subagent:" in out+ assert "secret" not in out+ assert "visible?" not in out+ assert "after" in out+++def test_transcript_truncates_by_dropping_oldest_segments():+ t = TranscriptBuffer()++ # Create many segments by opening/closing distinct text blocks.+ for i in range(60):+ t.apply({"type": "text_start", "index": i})+ t.apply(+ {"type": "text_delta", "index": i, "text": f"segment_{i} " + ("x" * 120)}+ )+ t.apply({"type": "block_stop", "index": i})++ out = t.render(_ctx(), limit_chars=600, status="status")+ assert escape_md_v2("... (truncated)") in out+ assert escape_md_v2("segment_59") in out+ assert escape_md_v2("segment_0") not in out