The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
fix(tui): stamp a turn's reply frames beneath _emit, the same with turn isolation off and on
Tekniumbfb764d99e81
diff --git a/gateway/run_turn_runner.py b/gateway/run_turn_runner.pyindex 3d8da3a3bef..d86ad260cf5 100644--- a/gateway/run_turn_runner.py+++ b/gateway/run_turn_runner.py@@ -209,17 +209,13 @@ class TurnRunner(GatewayTurnProgressMixin, GatewaySessionAgentMixin):def _stamp_segment(self, generation, event_type, payload):"""The turn's wire identity on its reply frames (tui_gateway/stream_segments.py), so a viewer- upserts a re-sent delta or seal instead of painting a second copy (#144609)."""- if event_type not in ("message.delta", "message.interim"):- return payload+ upserts a re-sent delta or seal instead of painting a second copy (#144609). The same+ stamping rule as tui_gateway's ``_emit``, with one cursor per execution generation."""+ from tui_gateway.stream_segments import TurnSegments, stamp_reply_framesegments = getattr(self, "_segments", None)if segments is None or segments[0] != generation:- from tui_gateway.stream_segments import TurnSegmentssegments = self._segments = (generation, TurnSegments())- if event_type == "message.interim":- return {**payload, **segments[1].seal()}- text = payload.get("text")- return {**payload, **segments[1].delta(text)} if isinstance(text, str) else payload+ return stamp_reply_frame(segments[1], event_type, payload)def _publish_api_tool(self, event_type, call_id, tool_name, args, result=None):"""The retained tool payload reaches the API observers of this exact admission only;diff --git a/tests/tui_gateway/test_stream_segment_identity.py b/tests/tui_gateway/test_stream_segment_identity.pyindex c3feeb3ce2b..3507b2a2aef 100644--- a/tests/tui_gateway/test_stream_segment_identity.py+++ b/tests/tui_gateway/test_stream_segment_identity.py@@ -1,40 +1,80 @@"""A prompt turn's message.* frames carry its wire identity (tui_gateway/stream_segments.py).The desktop upserts a re-sent frame by this identity instead of painting a second copy (#144609):-every delta names its turn, segment (interim seals before it) and UTF-16 offset inside that segment,-every interim the segment it seals.+message.start names the turn, every delta its turn, segment (interim seals before it) and UTF-16+offset inside that segment, every interim the segment it seals. The stamp goes on beneath ``_emit``,+on the frame that reaches the client, so the turn's ``_emit`` calls are the same with turn isolation+off and on (test_prompt_submit_golden_transcript_matches_flag_off_and_on)."""-import contextlib-from types import SimpleNamespace+import threading+import typesimport tui_gateway.server as srv-def test_deltas_and_seals_carry_turn_segment_and_utf16_offset(monkeypatch):- events = []- monkeypatch.setattr(srv, "_emit", lambda event, _sid, payload=None: events.append((event, payload)))+class _ImmediateThread:+ def __init__(self, target=None, daemon=None, **_kwargs):+ self._target = target++ def start(self):+ self._target()+++def _submit_turns(monkeypatch, run_conversation, turns):+ """Client frames (``write_json``) of ``turns`` in-process prompt.submit turns, and the session."""+ frames = []+ monkeypatch.setattr(srv, "write_json", lambda obj: frames.append(obj["params"]) or True)+ monkeypatch.setattr(srv.threading, "Thread", _ImmediateThread)+ monkeypatch.setattr(srv, "_load_cfg", lambda: {"dashboard": {"turn_isolation": False}})monkeypatch.setattr(srv, "_load_interim_assistant_messages", lambda: True)- monkeypatch.setattr(srv, "_start_usage_ticker", lambda _sid, _agent: (SimpleNamespace(set=lambda: None), SimpleNamespace(join=lambda: None)))+ monkeypatch.setattr(srv, "_ensure_session_db_row", lambda _session: None)+ monkeypatch.setattr(srv, "_persist_branch_seed", lambda _session: None)+ monkeypatch.setattr(srv, "_session_info", lambda _agent, _session=None: {"model": "m"})+ monkeypatch.setattr(srv, "make_stream_renderer", lambda _cols: None)+ monkeypatch.setattr(srv, "render_message", lambda _raw, _cols: None)+ fake_title = types.ModuleType("agent.title_generator")+ fake_title.maybe_auto_title = lambda *args, **kwargs: None+ monkeypatch.setitem(srv.sys.modules, "agent.title_generator", fake_title)- def run_conversation(_message, **kwargs):- stream = kwargs["stream_callback"]- stream("Looking π ")- stream("now.")+ agent = types.SimpleNamespace(+ model="m", provider="p", session_id="session-key", context_compressor=None,+ clear_interrupt=lambda: None)+ agent.run_conversation = lambda prompt, **kwargs: run_conversation(agent, prompt, **kwargs)+ session = {+ "agent": agent, "session_key": "session-key", "history": [], "history_lock": threading.Lock(),+ "history_version": 0, "running": False, "attached_images": [], "image_counter": 0, "cols": 80,+ "slash_worker": None, "show_reasoning": False, "tool_progress_mode": "all",+ "model_override": {"model": "m", "provider": "p"}}+ srv._sessions["sid"] = session+ try:+ for n in range(turns):+ response = srv.handle_request(+ {"id": f"turn-{n}", "method": "prompt.submit", "params": {"session_id": "sid", "text": "ping"}})+ assert response["result"]["status"] == "streaming"+ finally:+ srv._sessions.pop("sid", None)+ return [(f["type"], f.get("payload") or {}) for f in frames if f.get("session_id") == "sid"], session+++def test_deltas_and_seals_carry_turn_segment_and_utf16_offset(monkeypatch):+ def run_conversation(agent, prompt, stream_callback=None, **_kwargs):+ stream_callback("Looking π ")+ stream_callback("now.")agent.interim_assistant_callback("Looking π now.", already_streamed=True)- stream("Done.")- return {"final_response": "Done."}+ stream_callback("Done.")+ return {"final_response": "Done.", "messages": [+ {"role": "user", "content": prompt}, {"role": "assistant", "content": "Done."}]}- agent = SimpleNamespace(_session_title_hint="Scratch", run_conversation=run_conversation)- session = {"pending_title": None, "session_key": "k", "history_lock": contextlib.nullcontext(), "agent": agent}- st = srv._TurnRun(agent=agent, one_turn_restore=None, terminal_callback=None, receipt_committed=True)- srv._invoke_agent("sid", session, st, "ping", "ping", None, [], None, None)+ frames, session = _submit_turns(monkeypatch, run_conversation, turns=2)- stamps = [(e, p.get("segment"), p.get("offset")) for e, p in events if e in {"message.delta", "message.interim"}]+ reply = [(e, p) for e, p in frames if e in {"message.start", "message.delta", "message.interim"}]+ stamps = [(e, p.get("segment"), p.get("offset")) for e, p in reply]# The eye emoji is one code point but two UTF-16 units: "Looking π " advances the offset by 11.- assert stamps == [- ("message.delta", 0, 0), ("message.delta", 0, 11), ("message.interim", 0, None), ("message.delta", 1, 0)]- turn_ids = {p["turn_id"] for e, p in events if e in {"message.delta", "message.interim"}}- assert turn_ids == {st.segments.turn_id}- assert st.segments.turn_id and srv._TurnRun(- agent=agent, one_turn_restore=None, terminal_callback=None, receipt_committed=True).segments.turn_id != st.segments.turn_id+ one_turn = [("message.start", None, None), ("message.delta", 0, 0), ("message.delta", 0, 11),+ ("message.interim", 0, None), ("message.delta", 1, 0)]+ assert stamps == one_turn * 2+ first, second = {p.get("turn_id") for _e, p in reply[:5]}, {p.get("turn_id") for _e, p in reply[5:]}+ assert len(first) == len(second) == 1 and None not in first | second and first != second+ # A finished turn leaves no cursor behind, so a later non-turn emitter's frame stays unstamped.+ assert srv.stream_segments.SESSION_KEY not in sessiondiff --git a/tui_gateway/prompt_turn.py b/tui_gateway/prompt_turn.pyindex 639552cd0c6..961e828ef3f 100644--- a/tui_gateway/prompt_turn.py+++ b/tui_gateway/prompt_turn.py@@ -12,7 +12,6 @@ from __future__ import annotationsimport dataclassesfrom .method_ctx import HandlerRegistry, bind_module-from .stream_segments import TurnSegments_registry = HandlerRegistry()@@ -506,8 +505,6 @@ class _TurnRun:prompt_text: str = ""marker_key: str = ""receipt_attempted: bool = False- #: The turn id + segment cursor stamped on this turn's message.* frames.- segments: TurnSegments = dataclasses.field(default_factory=TurnSegments)def _adopt_out_of_band_turns(session: dict) -> None:@@ -765,7 +762,7 @@ def _invoke_agent(delta, hold["held"] = hold["held"] + delta, ""with session["history_lock"]:_append_inflight_delta(session, delta)- payload = {"text": delta, **st.segments.delta(delta)}+ payload = {"text": delta}if streamer and (r := streamer.feed(delta)) is not None:payload["rendered"] = rif st.tts_queue is not None and isinstance(delta, str):@@ -777,8 +774,7 @@ def _invoke_agent(def _interim_assistant_cb(text: str, *, already_streamed: bool = False) -> None:if getattr(agent, "_mute_notification_reply", False):return- _emit("message.interim", sid,- {"text": text, "already_streamed": already_streamed, **st.segments.seal()})+ _emit("message.interim", sid, {"text": text, "already_streamed": already_streamed})agent.interim_assistant_callback = (_interim_assistant_cb if _load_interim_assistant_messages() else None)# A synthesized turn is typed at turn START so a crash persist writes a timeline event,@@ -1135,10 +1131,12 @@ def _run_prompt_submit("kind=%s chars=%s images=%d",sid, session.get("session_key") or "", getattr(agent, "session_id", "") or "",display_kind or "user", len(text) if isinstance(text, str) else "-", len(images))- from tui_gateway.stream_segments import TurnSegments # bound functions run in server's globals- segments = TurnSegments()+ # The turn's wire identity: _emit stamps its message.* frames from it (stream_segments.py), so the+ # frames are the same here and in a compute-host child; dropped in run_body's finally.+ from tui_gateway.stream_segments import SESSION_KEY, TurnSegments # bound functions run in server's globals+ session[SESSION_KEY] = segments = TurnSegments()if not muted:- _emit("message.start", sid, segments.start())+ _emit("message.start", sid)def run_body():# RPC-dispatcher ContextVars do not follow onto this thread: rebind the transport@@ -1148,7 +1146,6 @@ def _run_prompt_submit(st = _TurnRun(session["agent"], session.pop("one_turn_model_restore", None), terminal_callback,receipt_committed=terminal_callback is None)- st.segments = segmentsst.marker_key = _record_turn_marker(session, text, auto_continue=terminal_callback is None,notification_category=(display_metadata or {}).get("notification_category"))goal_followup = None@@ -1195,6 +1192,8 @@ def _run_prompt_submit(if not st.error_retained:_clear_inflight_turn(session)_release_hosted_room_turn_slot(session)+ if session.get(SESSION_KEY) is segments:+ session.pop(SESSION_KEY)# Closing bookend of "tui prompt accepted" β exactly one per accepted prompt.# agent.session_id is re-read because compression may have rotated it (an# accepted/finished pair whose id changed IS a rotation trace).@@ -1243,6 +1242,8 @@ def _run_prompt_submit(if not can_start:with session["history_lock"]:session["running"] = False+ if session.get(SESSION_KEY) is segments:+ session.pop(SESSION_KEY)return can_startdiff --git a/tui_gateway/server.py b/tui_gateway/server.pyindex 1bfbe7ad5b1..6fd63b676bd 100644--- a/tui_gateway/server.py+++ b/tui_gateway/server.py@@ -38,7 +38,7 @@ from agent.voice_turn_route import session_runtime_viewfrom agent.compaction_display import project_compaction_message_for_displayfrom agent.skill_commands import describe_skill_invocationfrom agent.conversation_loop import INTERRUPT_WAITING_FOR_MODEL_PREFIX-from tui_gateway import git_probe+from tui_gateway import git_probe, stream_segmentsfrom tui_gateway.checkpoints import (_load_checkpoints_enabled, _resolve_checkpoint_hash,resolve_checkpoints_enabled as _resolve_checkpoints_enabled)from tui_gateway._env import env_float, env_int@@ -725,7 +725,7 @@ def _emit(event: str, sid: str, payload: dict | None = None) -> bool:from agent.notification_presentation import event_presentation_mutedif event_presentation_muted(event, sid):return False- return write_json(_event_frame(event, sid, payload))+ return write_json(_event_frame(event, sid, stream_segments.stamp_session_frame(_sessions.get(sid), event, payload)))from tui_gateway import server_requests as _server_requestsdiff --git a/tui_gateway/stream_segments.py b/tui_gateway/stream_segments.pyindex 6f53f0ec207..8a6d107e6a3 100644--- a/tui_gateway/stream_segments.py+++ b/tui_gateway/stream_segments.py@@ -44,3 +44,32 @@ class TurnSegments:self.segment += 1self.offset = 0return stamp+++#: Where a tui_gateway session holds its running prompt turn's cursor (set at turn start, dropped at+#: turn end): ``server._emit`` reads it, so every road that emits a turn's frames stamps them the same.+SESSION_KEY = "_turn_segments"+++def stamp_reply_frame(segments: TurnSegments | None, event: str, payload: dict | None) -> dict | None:+ """``payload`` with ``segments``' identity when ``event`` is a reply frame; anything else unchanged.++ The one stamping rule for every emitter: tui_gateway's ``_emit`` (in-process turn, and the+ compute-host child whose frames the parent relays verbatim) and the session authority's+ ``TurnRunner``. It runs beneath the emit call, so a caller's frames are the same with and+ without turn isolation. A ``None`` delta (segment boundary) carries no text to dedupe.+ """+ if segments is None:+ return payload+ if event == "message.start":+ return {**(payload or {}), **segments.start()}+ if event == "message.interim" and payload is not None:+ return {**payload, **segments.seal()}+ if event == "message.delta" and payload is not None and isinstance(payload.get("text"), str):+ return {**payload, **segments.delta(payload["text"])}+ return payload+++def stamp_session_frame(session: dict | None, event: str, payload: dict | None) -> dict | None:+ """:func:`stamp_reply_frame` with the cursor of the prompt turn ``session`` is running, if any."""+ return stamp_reply_frame((session or {}).get(SESSION_KEY), event, payload)