Skip to content

The agent that grows with you

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.py
index 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_frame
segments = getattr(self, "_segments", None)
if segments is None or segments[0] != generation:
- from tui_gateway.stream_segments import TurnSegments
segments = 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.py
index 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 types
import 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 session
diff --git a/tui_gateway/prompt_turn.py b/tui_gateway/prompt_turn.py
index 639552cd0c6..961e828ef3f 100644
--- a/tui_gateway/prompt_turn.py
+++ b/tui_gateway/prompt_turn.py
@@ -12,7 +12,6 @@ from __future__ import annotations
import dataclasses
from .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"] = r
if 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 = segments
st.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_start
diff --git a/tui_gateway/server.py b/tui_gateway/server.py
index 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_view
from agent.compaction_display import project_compaction_message_for_display
from agent.skill_commands import describe_skill_invocation
from agent.conversation_loop import INTERRUPT_WAITING_FOR_MODEL_PREFIX
-from tui_gateway import git_probe
+from tui_gateway import git_probe, stream_segments
from 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_muted
if 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_requests
diff --git a/tui_gateway/stream_segments.py b/tui_gateway/stream_segments.py
index 6f53f0ec207..8a6d107e6a3 100644
--- a/tui_gateway/stream_segments.py
+++ b/tui_gateway/stream_segments.py
@@ -44,3 +44,32 @@ class TurnSegments:
self.segment += 1
self.offset = 0
return 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)