The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""A stalled ``send_text`` must have a bounded lifetime (#106369).
``_safe_send_many`` awaits the socket while holding the connection-wide ``_send_lock``. Without a
deadline, one send parked by socket backpressure trapped every later event and RPC reply behind the
lock on an apparently open connection, so reconnect recovery never started.
"""
from __future__ import annotations
import asyncio
import json
from tui_gateway.ws import WSTransport
class _StalledWS:
"""``send_text`` never completes (kernel backpressure); ``close`` is observable."""
def __init__(self) -> None:
self.closed_with: list[int] = []
self._release = asyncio.Event()
async def send_text(self, line: str) -> None:
await self._release.wait()
async def close(self, code: int = 1000) -> None:
self.closed_with.append(code)
self._release.set()
class _FastWS:
def __init__(self) -> None:
self.sent: list[str] = []
async def send_text(self, line: str) -> None:
self.sent.append(line)
def test_stalled_send_closes_socket_and_releases_queued_reply(monkeypatch):
# raising=False: on a base without the deadline the test must fail on the SYMPTOM (sends never terminate).
monkeypatch.setattr("tui_gateway.ws._WS_SEND_DEADLINE_S", 0.05, raising=False)
async def _run() -> None:
ws = _StalledWS()
transport = WSTransport(ws, asyncio.get_running_loop(), peer="127.0.0.1:1")
progress = asyncio.create_task(transport.write_async({"method": "event", "params": {"type": "tool.progress"}}))
await asyncio.sleep(0) # progress is now inside send_text, holding _send_lock
reply = asyncio.create_task(transport.write_async({"id": "submit", "result": {"status": "streaming"}}))
# The loop stays responsive; both sends must still terminate within the deadline (not the 2s cap).
results = await asyncio.wait_for(asyncio.gather(progress, reply), timeout=2.0)
assert results == [False, False], "a send that missed the deadline must report failure, not success"
assert transport.closed, "the transport must latch closed so handle_ws teardown/reconnect can run"
await asyncio.sleep(0) # let the scheduled close task run
assert ws.closed_with == [1011], "the stalled socket must be closed, not left half-open"
asyncio.run(_run())
def test_progress_then_final_ordering_preserved_on_healthy_socket():
async def _run() -> None:
ws = _FastWS()
transport = WSTransport(ws, asyncio.get_running_loop(), peer="127.0.0.1:1")
assert await transport.write_async({"method": "event", "params": {"type": "tool.progress"}})
assert await transport.write_async({"method": "event", "params": {"type": "message.complete"}})
assert await transport.write_async({"id": "submit", "result": {"status": "done"}})
assert not transport.closed
assert [json.loads(s).get("params", {}).get("type", "reply") for s in ws.sent] == [
"tool.progress", "message.complete", "reply",
]
asyncio.run(_run())