Skip to content

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

Improved test coverage

Alishahryar19be994340155
diff --git a/messaging/handler.py b/messaging/handler.py
index 3e17a876..ed19098d 100644
--- a/messaging/handler.py
+++ b/messaging/handler.py
@@ -139,7 +139,8 @@ class ClaudeMessageHandler:
return
# Filter out status messages (our own messages)
- if any(incoming.text.startswith(p) for p in STATUS_MESSAGE_PREFIXES):
+ text = incoming.text or ""
+ if any(text.startswith(p) for p in STATUS_MESSAGE_PREFIXES):
return
# Check if this is a reply to an existing node in a tree
@@ -392,7 +393,11 @@ class ClaudeMessageHandler:
last_ui_update = now
if status is not None:
last_status = status
- display = transcript.render(render_ctx, limit_chars=3900, status=status)
+ try:
+ display = transcript.render(render_ctx, limit_chars=3900, status=status)
+ except Exception as e:
+ logger.warning(f"Transcript render failed for node {node_id}: {e}")
+ return
if display and display != last_displayed_text:
logger.debug(
"TELEGRAM_EDIT: node_id=%s chat_id=%s msg_id=%s force=%s status=%r chars=%d",
@@ -412,9 +417,14 @@ class ClaudeMessageHandler:
if tail:
logger.debug("TELEGRAM_EDIT_PREVIEW_TAIL:\n%s", tail)
last_displayed_text = display
- await self.platform.queue_edit_message(
- chat_id, status_msg_id, display, parse_mode="MarkdownV2"
- )
+ try:
+ await self.platform.queue_edit_message(
+ chat_id, status_msg_id, display, parse_mode="MarkdownV2"
+ )
+ except Exception as e:
+ logger.warning(
+ f"Failed to update Telegram for node {node_id}: {e}"
+ )
try:
try:
diff --git a/providers/nvidia_nim/client.py b/providers/nvidia_nim/client.py
index f646e99d..45f72158 100644
--- a/providers/nvidia_nim/client.py
+++ b/providers/nvidia_nim/client.py
@@ -83,6 +83,8 @@ class NvidiaNimProvider(BaseProvider):
choice = chunk.choices[0]
delta = choice.delta
+ if delta is None:
+ continue
if choice.finish_reason:
finish_reason = choice.finish_reason
diff --git a/tests/test_event_parser.py b/tests/test_event_parser.py
index b6545876..9bdadf13 100644
--- a/tests/test_event_parser.py
+++ b/tests/test_event_parser.py
@@ -158,3 +158,35 @@ def test_parse_cli_event_result_with_content_directly():
def test_parse_cli_event_result_with_result_content_directly():
event = {"type": "result", "result": {"content": [{"type": "text", "text": "hi"}]}}
assert parse_cli_event(event) == [{"type": "text_chunk", "text": "hi"}]
+
+
+def test_parse_cli_event_content_block_unknown_type_skipped():
+ """Content block with unknown type is skipped; known blocks still parsed."""
+ event = {
+ "type": "assistant",
+ "message": {
+ "content": [
+ {"type": "text", "text": "visible"},
+ {"type": "unknown", "data": "ignored"},
+ {"type": "thinking", "thinking": "thought"},
+ ]
+ },
+ }
+ results = parse_cli_event(event)
+ assert len(results) == 2
+ assert results[0] == {"type": "text_chunk", "text": "visible"}
+ assert results[1] == {"type": "thinking_chunk", "text": "thought"}
+
+
+def test_parse_cli_event_error_non_dict():
+ """Error event with error as string (not dict) is handled."""
+ event = {"type": "error", "error": "plain string error"}
+ results = parse_cli_event(event)
+ assert results == [{"type": "error", "message": "plain string error"}]
+
+
+def test_parse_cli_event_exit_code_none():
+ """Exit event with no code defaults to success."""
+ event = {"type": "exit"}
+ results = parse_cli_event(event)
+ assert results == [{"type": "complete", "status": "success"}]
diff --git a/tests/test_handler_markdown_and_status_edges.py b/tests/test_handler_markdown_and_status_edges.py
index a5211a77..a2bef8e2 100644
--- a/tests/test_handler_markdown_and_status_edges.py
+++ b/tests/test_handler_markdown_and_status_edges.py
@@ -244,3 +244,156 @@ async def test_handle_message_reply_with_tree_but_no_parent_treated_as_new():
await handler.handle_message(incoming)
handler.tree_queue.create_tree.assert_awaited_once()
+
+
+async def test_update_ui_handles_transcript_render_exception():
+ """When transcript.render raises, update_ui catches and does not crash."""
+ platform = MagicMock()
+ platform.queue_edit_message = AsyncMock()
+ platform.fire_and_forget = MagicMock(
+ side_effect=lambda c: getattr(c, "close", lambda: None)()
+ )
+
+ cli_manager = MagicMock()
+ session_store = MagicMock()
+
+ async def _mock_start_task(*args, **kwargs):
+ yield {"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": "hi"}}
+ yield {"type": "complete", "status": "success"}
+
+ mock_session = MagicMock()
+ mock_session.start_task = _mock_start_task
+ cli_manager.get_or_create_session = AsyncMock(
+ return_value=(mock_session, "s1", False)
+ )
+ cli_manager.remove_session = AsyncMock()
+ cli_manager.get_stats.return_value = {"active_sessions": 0, "max_sessions": 10}
+
+ handler = ClaudeMessageHandler(platform, cli_manager, session_store)
+ handler.tree_queue = MagicMock()
+ handler.tree_queue.get_tree_for_node.return_value = None
+
+ incoming = IncomingMessage(
+ text="hi",
+ chat_id="c",
+ user_id="u",
+ message_id="n1",
+ platform="telegram",
+ )
+ node = MessageNode(node_id="n1", incoming=incoming, status_message_id="s1")
+
+ with patch.object(
+ handler, "_create_transcript_and_render_ctx"
+ ) as mock_create:
+ transcript = MagicMock()
+ transcript.render = MagicMock(side_effect=ValueError("render failed"))
+ render_ctx = MagicMock()
+ mock_create.return_value = (transcript, render_ctx)
+
+ await handler._process_node("n1", node)
+
+ assert transcript.render.call_count >= 1
+
+
+async def test_handle_message_incoming_text_none_safe():
+ """handle_message does not crash when incoming.text is None (e.g. malformed adapter)."""
+ platform = MagicMock()
+ platform.queue_send_message = AsyncMock(return_value="status_1")
+ platform.queue_edit_message = AsyncMock()
+
+ cli_manager = MagicMock()
+ cli_manager.get_stats.return_value = {"active_sessions": 0, "max_sessions": 10}
+
+ session_store = MagicMock()
+ handler = ClaudeMessageHandler(platform, cli_manager, session_store)
+ handler.tree_queue = MagicMock()
+ handler.tree_queue.get_tree_for_node.return_value = None
+ handler.tree_queue.resolve_parent_node_id.return_value = None
+ handler.tree_queue.create_tree = AsyncMock(
+ return_value=MagicMock(root_id="root", to_dict=MagicMock(return_value={"t": 1}))
+ )
+ handler.tree_queue.register_node = MagicMock()
+ handler.tree_queue.enqueue = AsyncMock(return_value=True)
+
+ incoming = MagicMock()
+ incoming.text = None
+ incoming.chat_id = "c"
+ incoming.user_id = "u"
+ incoming.message_id = "m1"
+ incoming.platform = "telegram"
+ incoming.reply_to_message_id = None
+ incoming.is_reply = MagicMock(return_value=False)
+
+ await handler.handle_message(incoming)
+ handler.tree_queue.create_tree.assert_awaited_once()
+
+
+async def test_process_parsed_event_malformed_content_continues():
+ """Malformed/unknown parsed event does not crash _process_parsed_event."""
+ platform = MagicMock()
+ platform.queue_edit_message = AsyncMock()
+
+ cli_manager = MagicMock()
+ session_store = MagicMock()
+ handler = ClaudeMessageHandler(platform, cli_manager, session_store)
+
+ transcript = MagicMock()
+ update_ui = AsyncMock()
+
+ last_status, had = await handler._process_parsed_event(
+ parsed={"type": "unknown_type"},
+ transcript=transcript,
+ update_ui=update_ui,
+ last_status=None,
+ had_transcript_events=False,
+ tree=None,
+ node_id="n1",
+ captured_session_id=None,
+ )
+ assert last_status is None
+ assert had is False
+
+
+async def test_handler_update_ui_edit_failure_does_not_crash():
+ """When queue_edit_message raises during streaming, _process_node continues and completes."""
+ platform = MagicMock()
+ platform.queue_edit_message = AsyncMock(side_effect=RuntimeError("Telegram API error"))
+ platform.fire_and_forget = MagicMock(
+ side_effect=lambda c: getattr(c, "close", lambda: None)()
+ )
+
+ async def _mock_start_task(*args, **kwargs):
+ yield {"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": "Hello"}}
+ yield {"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": " world"}}
+ yield {"type": "complete", "status": "success"}
+
+ mock_session = MagicMock()
+ mock_session.start_task = _mock_start_task
+ cli_manager = MagicMock()
+ cli_manager.get_or_create_session = AsyncMock(
+ return_value=(mock_session, "s1", False)
+ )
+ cli_manager.remove_session = AsyncMock()
+ cli_manager.get_stats.return_value = {"active_sessions": 0, "max_sessions": 10}
+
+ session_store = MagicMock()
+ handler = ClaudeMessageHandler(platform, cli_manager, session_store)
+ handler.tree_queue = MagicMock()
+ handler.tree_queue.get_tree_for_node.return_value = None
+
+ incoming = IncomingMessage(
+ text="hi",
+ chat_id="c",
+ user_id="u",
+ message_id="n1",
+ platform="telegram",
+ )
+ node = MessageNode(node_id="n1", incoming=incoming, status_message_id="s1")
+
+ await handler._process_node("n1", node)
+
+ cli_manager.remove_session.assert_awaited_once()
diff --git a/tests/test_limiter.py b/tests/test_limiter.py
index 3f3120bc..bcaa83de 100644
--- a/tests/test_limiter.py
+++ b/tests/test_limiter.py
@@ -239,3 +239,41 @@ class TestMessagingRateLimiter:
f"Sliding window violated at i={i}: "
f"dt={acquired[i + rate_limit] - acquired[i]:.3f}s"
)
+
+ @pytest.mark.asyncio
+ async def test_compaction_last_task_fails_all_futures_get_exception(self):
+ """When compacted task's last func fails, all futures get the exception."""
+ MessagingRateLimiter._instance = None
+ limiter = await MessagingRateLimiter.get_instance()
+
+ async def ok_task():
+ return "ok"
+
+ async def fail_task():
+ raise RuntimeError("last task failed")
+
+ future1 = asyncio.create_task(
+ limiter.enqueue(ok_task, dedup_key="fail_key")
+ )
+ future2 = asyncio.create_task(
+ limiter.enqueue(fail_task, dedup_key="fail_key")
+ )
+
+ with pytest.raises(RuntimeError, match="last task failed"):
+ await future1
+ with pytest.raises(RuntimeError, match="last task failed"):
+ await future2
+
+ @pytest.mark.asyncio
+ async def test_fire_and_forget_failure_logged(self, caplog):
+ """fire_and_forget with failing task logs error and does not re-raise."""
+ MessagingRateLimiter._instance = None
+ limiter = await MessagingRateLimiter.get_instance()
+
+ async def fail_task():
+ raise ValueError("fire_and_forget failed")
+
+ limiter.fire_and_forget(fail_task, dedup_key="fire_fail")
+ await asyncio.sleep(1.5)
+
+ assert any("fire_and_forget failed" in str(r) for r in caplog.records)
diff --git a/tests/test_reliability.py b/tests/test_reliability.py
index aafe4dd6..d947b004 100644
--- a/tests/test_reliability.py
+++ b/tests/test_reliability.py
@@ -108,3 +108,31 @@ def test_handler_build_message_hardening():
assert "Finishing..." in msg
if "```" in msg:
assert msg.count("```") % 2 == 0
+
+
+def test_render_output_never_exceeds_4096():
+ """Transcript render with various status lengths never exceeds Telegram 4096 limit."""
+ from messaging.transcript import TranscriptBuffer, RenderCtx
+ from messaging.telegram_markdown 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,
+ )
+
+ t = TranscriptBuffer()
+ t.apply({"type": "thinking_chunk", "text": "x" * 500})
+ t.apply({"type": "text_chunk", "text": "y" * 3500})
+
+ for status in [None, "Done", "✅ *Complete*", "A" * 100]:
+ msg = t.render(ctx, limit_chars=3900, status=status)
+ assert len(msg) <= 4096, f"status={status!r} produced len={len(msg)}"
diff --git a/tests/test_robust_formatting.py b/tests/test_robust_formatting.py
index fe9ee9c0..6deddf1a 100644
--- a/tests/test_robust_formatting.py
+++ b/tests/test_robust_formatting.py
@@ -68,3 +68,22 @@ def test_empty_components_with_status(handler):
t = TranscriptBuffer()
msg = t.render(_ctx(), limit_chars=3900, status=status)
assert msg == "\n\nSimple Status"
+
+
+def test_render_markdown_unclosed_markdown():
+ """Malformed markdown (e.g. unclosed *) does not crash and produces acceptable output."""
+ from messaging.telegram_markdown import render_markdown_to_mdv2
+
+ md = "*bold without close"
+ out = render_markdown_to_mdv2(md)
+ assert out is not None
+ assert "bold" in out
+
+
+def test_escape_md_v2_unicode_emoji():
+ """Unicode and emoji pass through correctly (no special char escaping needed)."""
+ from messaging.telegram_markdown import escape_md_v2, escape_md_v2_code
+
+ text = "Hello 世界 🎉 café"
+ assert escape_md_v2(text) == text
+ assert escape_md_v2_code(text) == text
diff --git a/tests/test_streaming_errors.py b/tests/test_streaming_errors.py
index e3920a6e..f93a69f8 100644
--- a/tests/test_streaming_errors.py
+++ b/tests/test_streaming_errors.py
@@ -392,3 +392,130 @@ class TestProcessToolCall:
events = list(provider._process_tool_call(tc, sse))
event_text = "".join(events)
assert "input_json_delta" in event_text
+
+
+class TestStreamChunkEdgeCases:
+ """Tests for edge cases in stream chunk handling."""
+
+ @pytest.mark.asyncio
+ async def test_stream_chunk_with_empty_choices_skipped(self):
+ """Chunk with choices=[] is skipped without crashing."""
+ provider = _make_provider()
+ request = _make_request()
+
+ empty_choices_chunk = MagicMock()
+ empty_choices_chunk.choices = []
+ empty_choices_chunk.usage = None
+
+ finish_chunk = _make_chunk(finish_reason="stop")
+ stream_mock = AsyncStreamMock([empty_choices_chunk, finish_chunk])
+
+ with patch.object(
+ provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ return_value=stream_mock,
+ ):
+ with patch.object(
+ provider._global_rate_limiter,
+ "wait_if_blocked",
+ new_callable=AsyncMock,
+ return_value=False,
+ ):
+ events = await _collect_stream(provider, request)
+
+ event_text = "".join(events)
+ assert "message_start" in event_text
+ assert "message_stop" in event_text
+ assert "[DONE]" in event_text
+
+ @pytest.mark.asyncio
+ async def test_stream_chunk_with_none_delta_handled(self):
+ """Chunk with choice.delta=None is handled defensively."""
+ provider = _make_provider()
+ request = _make_request()
+
+ none_delta_chunk = MagicMock()
+ none_delta_chunk.usage = None
+ choice = MagicMock()
+ choice.delta = None
+ choice.finish_reason = None
+ none_delta_chunk.choices = [choice]
+
+ finish_chunk = _make_chunk(finish_reason="stop")
+ stream_mock = AsyncStreamMock([none_delta_chunk, finish_chunk])
+
+ with patch.object(
+ provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ return_value=stream_mock,
+ ):
+ with patch.object(
+ provider._global_rate_limiter,
+ "wait_if_blocked",
+ new_callable=AsyncMock,
+ return_value=False,
+ ):
+ events = await _collect_stream(provider, request)
+
+ event_text = "".join(events)
+ assert "message_start" in event_text
+ assert "message_stop" in event_text
+ assert "[DONE]" in event_text
+
+ @pytest.mark.asyncio
+ async def test_stream_generator_cleanup_on_exception(self):
+ """When stream raises mid-iteration, message_stop and [DONE] still emitted."""
+ provider = _make_provider()
+ request = _make_request()
+
+ chunk1 = _make_chunk(content="Partial")
+ stream_mock = AsyncStreamMock(
+ [chunk1], error=ConnectionResetError("Connection reset")
+ )
+
+ with patch.object(
+ provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ return_value=stream_mock,
+ ):
+ with patch.object(
+ provider._global_rate_limiter,
+ "wait_if_blocked",
+ new_callable=AsyncMock,
+ return_value=False,
+ ):
+ events = await _collect_stream(provider, request)
+
+ event_text = "".join(events)
+ assert "Partial" in event_text
+ assert "Connection reset" in event_text
+ assert "message_stop" in event_text
+ assert "[DONE]" in event_text
+
+ def test_stream_malformed_tool_args_chunked(self):
+ """Chunked tool args that never form valid JSON are flushed with {}."""
+ provider = _make_provider()
+ from providers.nvidia_nim.utils import SSEBuilder
+
+ sse = SSEBuilder("msg_test", "test-model")
+ tc1 = {
+ "index": 0,
+ "id": "call_malformed",
+ "function": {"name": "Task", "arguments": '{"broken":'},
+ }
+ tc2 = {
+ "index": 0,
+ "id": "call_malformed",
+ "function": {"name": None, "arguments": ' never valid }'},
+ }
+
+ events1 = list(provider._process_tool_call(tc1, sse))
+ events2 = list(provider._process_tool_call(tc2, sse))
+ flushed = list(provider._flush_task_arg_buffers(sse))
+
+ event_text = "".join(events1 + events2 + flushed)
+ assert "tool_use" in event_text
+ assert "{}" in event_text
diff --git a/tests/test_telegram_edge_cases.py b/tests/test_telegram_edge_cases.py
index c82921ca..85ec9122 100644
--- a/tests/test_telegram_edge_cases.py
+++ b/tests/test_telegram_edge_cases.py
@@ -221,3 +221,92 @@ async def test_telegram_start_retries_on_network_error(monkeypatch):
await platform.start()
assert platform.is_connected is True
+
+
+async def test_edit_message_with_text_exceeding_4096_raises():
+ """edit_message with text > 4096 raises TelegramError (BadRequest)."""
+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):
+ from messaging.telegram import TelegramPlatform, TelegramError
+
+ platform = TelegramPlatform(bot_token="t")
+ platform._application = MagicMock()
+ platform._application.bot = AsyncMock()
+ platform._application.bot.edit_message_text = AsyncMock(
+ side_effect=TelegramError("Bad Request: message is too long")
+ )
+
+ with pytest.raises(TelegramError):
+ await platform.edit_message("c", "1", "x" * 5000)
+
+
+async def test_edit_message_empty_string():
+ """edit_message with empty string - Telegram accepts (no-op edit)."""
+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):
+ from messaging.telegram import TelegramPlatform
+
+ platform = TelegramPlatform(bot_token="t")
+ platform._application = MagicMock()
+ platform._application.bot = AsyncMock()
+ platform._application.bot.edit_message_text = AsyncMock()
+
+ await platform.edit_message("c", "1", "")
+ platform._application.bot.edit_message_text.assert_awaited_once_with(
+ chat_id="c", message_id=1, text="", parse_mode="MarkdownV2"
+ )
+
+
+async def test_send_message_empty_string():
+ """send_message with empty string - Telegram may reject; we pass through."""
+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):
+ from messaging.telegram import TelegramPlatform
+
+ platform = TelegramPlatform(bot_token="t")
+ platform._application = MagicMock()
+ mock_msg = MagicMock()
+ mock_msg.message_id = 1
+ platform._application.bot = AsyncMock()
+ platform._application.bot.send_message = AsyncMock(return_value=mock_msg)
+
+ msg_id = await platform.send_message("c", "")
+ assert msg_id == "1"
+ platform._application.bot.send_message.assert_awaited_once()
+
+
+async def test_on_telegram_message_non_text_update_ignored():
+ """Update with message.photo but no text returns early without calling handler."""
+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):
+ from messaging.telegram import TelegramPlatform
+
+ platform = TelegramPlatform(bot_token="t", allowed_user_id="123")
+ handler = AsyncMock()
+ platform.on_message(handler)
+
+ update = MagicMock()
+ update.message.text = None
+ update.message.photo = [MagicMock()]
+ update.message.message_id = 7
+ update.message.reply_to_message = None
+ update.effective_user.id = 123
+ update.effective_chat.id = 456
+
+ await platform._on_telegram_message(update, MagicMock())
+ handler.assert_not_called()
+
+
+async def test_with_retry_message_not_found_returns_none():
+ """'message to edit not found' returns None without retry."""
+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):
+ from messaging.telegram import TelegramPlatform, TelegramError
+
+ platform = TelegramPlatform(bot_token="t")
+
+ async def _f():
+ raise TelegramError("message to edit not found")
+
+ result = await platform._with_retry(_f)
+ assert result is None
diff --git a/tests/test_transcript.py b/tests/test_transcript.py
index d074e94e..2475a99b 100644
--- a/tests/test_transcript.py
+++ b/tests/test_transcript.py
@@ -135,3 +135,34 @@ def test_transcript_reused_index_closes_previous_open_block():
# Old open text should have been closed.
assert 0 not in t._open_text_by_index
assert 0 in t._open_tools_by_index
+
+
+def test_transcript_render_segment_exception_skipped():
+ """When a segment's render() raises, that segment is skipped and rest is rendered."""
+ t = TranscriptBuffer()
+ t.apply({"type": "thinking_chunk", "text": "before"})
+ t.apply({"type": "text_chunk", "text": "middle"})
+ t.apply({"type": "text_chunk", "text": "after"})
+
+ bad_segment = t._segments[1]
+ original_render = bad_segment.render
+
+ def _raising_render(ctx):
+ raise ValueError("render failed")
+
+ bad_segment.render = _raising_render
+
+ out = t.render(_ctx(), limit_chars=3900, status=None)
+ assert "before" in out
+ assert "after" in out
+ assert "middle" not in out
+
+
+def test_transcript_render_status_only_exceeds_limit():
+ """When all segments dropped, status-only output; long status returned as-is."""
+ t = TranscriptBuffer()
+ t.apply({"type": "text_chunk", "text": "x" * 5000})
+
+ long_status = "A" * 500
+ msg = t.render(_ctx(), limit_chars=100, status=long_status)
+ assert "... (truncated)" in msg or long_status in msg