Skip to content

Your lightweight open-source personal agent.

fix(compaction): align native lifecycle and reconcile replay notices

chengyongrube43d2a5f8bf
diff --git a/nanobot/agent/context_governance.py b/nanobot/agent/context_governance.py
index a50b0ebf3..cfb2c7622 100644
--- a/nanobot/agent/context_governance.py
+++ b/nanobot/agent/context_governance.py
@@ -43,6 +43,7 @@ from nanobot.session.summary import (
SUMMARY_CONTINUATION_TEXT,
SessionSummaryCheckpoint,
)
+from nanobot.utils.cancellation import shield_and_drain
from nanobot.utils.helpers import (
estimate_prompt_tokens_chain,
maybe_persist_tool_result,
@@ -529,6 +530,11 @@ class ContextGovernor:
if message.get("role") == "tool"
and isinstance(message.get("tool_call_id"), str)
)
+ if response.provider_compaction_event_id is None:
+ response.provider_compaction_event_id = uuid4().hex
+ await shield_and_drain(state.events.emit(ContextCompactionEvent(
+ response.provider_compaction_event_id, "succeeded",
+ )))
if (
not response.provider_compaction_applied
or response.provider_compaction_state is None
@@ -553,40 +559,18 @@ class ContextGovernor:
)
return
- compaction_id = uuid4().hex
- await state.events.emit(
- ContextCompactionEvent(compaction_id=compaction_id, phase="started"),
+ summary = await compaction.consolidate_provider_compaction(
+ response.provider_compaction_state,
+ await self.prepare_in_background(deepcopy, accepted_messages),
+ compaction.active_summary,
)
- try:
- summary = await compaction.consolidate_provider_compaction(
- response.provider_compaction_state,
- await self.prepare_in_background(deepcopy, accepted_messages),
- compaction.active_summary,
- )
- except (Exception, asyncio.CancelledError) as exc:
- await state.events.emit(
- ContextCompactionEvent(
- compaction_id=compaction_id,
- phase="cancelled" if isinstance(exc, asyncio.CancelledError) else "failed",
- ),
- )
- raise
if not summary:
- await state.events.emit(
- ContextCompactionEvent(compaction_id=compaction_id, phase="failed"),
- )
return
compaction.active_summary = summary
compaction.summary_checkpoint = SessionSummaryCheckpoint(
summary=summary,
transcript_boundary=transcript_boundary,
)
- await state.events.emit(
- ContextCompactionEvent(
- compaction_id=compaction_id,
- phase="succeeded",
- ),
- )
async def _compact_request_history(
self,
diff --git a/nanobot/providers/base.py b/nanobot/providers/base.py
index da8bbbc32..de886f772 100644
--- a/nanobot/providers/base.py
+++ b/nanobot/providers/base.py
@@ -301,6 +301,8 @@ class LLMResponse:
# True only when this response installed a new provider-native compaction
# boundary. Replaying an older compaction item does not set this flag.
provider_compaction_applied: bool = field(default=False, repr=False)
+ # Identity of the native lifecycle already reported by its operation owner.
+ provider_compaction_event_id: str | None = field(default=None, repr=False)
# State immediately after native compaction, before the normal response
# continues. An archive prompt can resume this state without replaying H.
provider_compaction_state: ProviderConversationState | None = field(
diff --git a/nanobot/providers/openai_codex_provider.py b/nanobot/providers/openai_codex_provider.py
index a65052943..e23632b3e 100644
--- a/nanobot/providers/openai_codex_provider.py
+++ b/nanobot/providers/openai_codex_provider.py
@@ -13,6 +13,7 @@ import re
import ssl
from collections.abc import Awaitable, Callable
from typing import Any, cast
+from uuid import uuid4
import httpx
from loguru import logger
@@ -21,6 +22,7 @@ from oauth_cli_kit.providers import OPENAI_CODEX_PROVIDER
from oauth_cli_kit.storage import FileTokenStorage
from nanobot import __version__
+from nanobot.events import NO_EVENTS, ContextCompactionEvent
from nanobot.providers.base import (
CONTEXT_SAFETY_BUFFER,
LLMProvider,
@@ -47,6 +49,7 @@ from nanobot.providers.openai_responses.state import (
)
from nanobot.providers.openai_responses.websocket import ResponsesWebSocketError
from nanobot.providers.registry import ProviderModelSpec, find_by_name
+from nanobot.utils.cancellation import shield_and_drain
from nanobot.utils.helpers import estimate_prompt_tokens
DEFAULT_CODEX_URL = "https://chatgpt.com/backend-api/codex/responses"
@@ -258,8 +261,18 @@ class OpenAICodexProvider(LLMProvider):
)
stage = "oauth_token"
- native_compaction_applied = False
native_compaction_state: ProviderConversationState | None = None
+ native_compaction_event_id: str | None = None
+ events = provider_context.events if provider_context is not None else NO_EVENTS
+
+ def finish_compaction(result: LLMResponse) -> LLMResponse:
+ if native_compaction_state is not None and not result.provider_compaction_applied:
+ result.provider_compaction_applied = True
+ result.provider_compaction_state = native_compaction_state
+ result.provider_compaction_scope = "prior_context"
+ result.provider_compaction_event_id = native_compaction_event_id
+ return result
+
input_budget = (
provider_context.compaction_input_budget if provider_context is not None else None
)
@@ -353,12 +366,25 @@ class OpenAICodexProvider(LLMProvider):
stage = "codex_compaction"
async def send_compaction(request: dict[str, Any]) -> LLMResponse:
- return await _send(
- request,
- emit_deltas=False,
- trace_name="codex_compaction",
- validate=responses_compaction_items,
- )
+ nonlocal native_compaction_event_id
+ compaction_id = uuid4().hex
+ try:
+ await events.emit(ContextCompactionEvent(compaction_id, "started"))
+ compacted = await _send(
+ request,
+ emit_deltas=False,
+ trace_name="codex_compaction",
+ validate=responses_compaction_items,
+ )
+ except (Exception, asyncio.CancelledError) as exc:
+ await shield_and_drain(events.emit(ContextCompactionEvent(
+ compaction_id,
+ "cancelled" if isinstance(exc, asyncio.CancelledError) else "failed",
+ )))
+ raise
+ native_compaction_event_id = compaction_id
+ await shield_and_drain(events.emit(ContextCompactionEvent(compaction_id, "succeeded")))
+ return compacted
native_compaction_state = await self._responses.compact_before_request(
body, state=sanitized_state,
@@ -369,14 +395,13 @@ class OpenAICodexProvider(LLMProvider):
max_output_tokens=max_tokens, input_budget=input_budget,
send=send_compaction,
)
- native_compaction_applied = native_compaction_state is not None
if input_budget is not None:
estimated = estimate_prompt_tokens([{
"role": "user", "content": json.dumps(body, ensure_ascii=False),
}])
if input_budget <= 0 or estimated > input_budget:
- return LLMResponse(
+ return finish_compaction(LLMResponse(
content=(
"Codex input still exceeds the local budget after native compaction "
f"({estimated}/{input_budget} estimated tokens); request not sent."
@@ -384,16 +409,10 @@ class OpenAICodexProvider(LLMProvider):
finish_reason="error", error_kind="context_window_exceeded",
error_should_retry=False,
preserve_provider_state_on_error=True,
- )
+ ))
stage = "codex_request"
result = await _send(body, emit_deltas=True, trace_name="codex_request")
- result.provider_compaction_applied = (
- result.provider_compaction_applied or native_compaction_applied
- )
- if native_compaction_state is not None:
- result.provider_compaction_state = native_compaction_state
- result.provider_compaction_scope = "prior_context"
- return result
+ return finish_compaction(result)
except Exception as e:
response = _codex_error_response(e)
if input_budget is not None and stage != "codex_request":
@@ -416,12 +435,12 @@ class OpenAICodexProvider(LLMProvider):
request_model,
request_effort,
replayed,
- native_compaction_applied,
+ native_compaction_state is not None,
getattr(e, "error_param", None),
getattr(e, "error_message", None),
getattr(e, "request_id", None),
)
- return response
+ return finish_compaction(response)
async def chat(
self,
diff --git a/tests/agent/test_runner_governance.py b/tests/agent/test_runner_governance.py
index d8c1844ce..e3ffeadd6 100644
--- a/tests/agent/test_runner_governance.py
+++ b/tests/agent/test_runner_governance.py
@@ -2,6 +2,7 @@
from __future__ import annotations
+import asyncio
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
@@ -346,6 +347,7 @@ async def test_native_compaction_uses_provider_request_boundary(
provider_compaction_applied=True,
provider_compaction_state=compacted_state,
provider_compaction_scope=scope,
+ provider_compaction_event_id="native-already-reported" if scope == "prior_context" else None,
),
LLMResponse(content="done"),
])
@@ -399,10 +401,44 @@ async def test_native_compaction_uses_provider_request_boundary(
assert result.provider_compaction_applied is True
assert any(message.get("content") == "inspect the project" for message in result.messages)
assert any(message.get("content") == "complete tool result" for message in result.messages)
- assert [event.phase for event in compaction_events] == ["started", "succeeded"]
- assert {event.compaction_id for event in compaction_events} == {
- compaction_events[0].compaction_id
- }
+ assert [event.phase for event in compaction_events] == ([] if scope == "prior_context" else ["succeeded"])
+
+
[email protected]("error", [RuntimeError("checkpoint failed"), asyncio.CancelledError()])
+async def test_native_checkpoint_failure_does_not_relabel_completed_compaction(monkeypatch, error):
+ provider = MagicMock(spec=LLMProvider)
+ provider.can_resume_conversation_state.return_value = False
+ compacted = ProviderConversationState(
+ kind="openai_responses", provider="openai:test", model="test-model", version=1,
+ payload={"items": [{"type": "compaction", "encrypted_content": "opaque"}]},
+ )
+ provider.chat_stream_with_retry = AsyncMock(return_value=LLMResponse(
+ content="done", provider_compaction_applied=True,
+ provider_compaction_state=compacted, provider_compaction_scope="current_request",
+ ))
+ tools = MagicMock()
+ tools.get_definitions.return_value = []
+ monkeypatch.setattr("nanobot.agent.context_governance.estimate_prompt_tokens_chain", lambda *_args: (100, "test-counter"))
+ notices: list[ContextCompactionEvent] = []
+
+ async def observe(event) -> None:
+ if isinstance(event, ContextCompactionEvent):
+ notices.append(event)
+
+ async def consolidate(*_args):
+ assert [notice.phase for notice in notices] == ["succeeded"]
+ raise error
+
+ with pytest.raises(type(error)):
+ await AgentRunner().run(make_run_spec(
+ provider, initial_messages=None,
+ transcript_input=TranscriptInput(history=[], current_message="question"),
+ transcript_builder=_build_transcript, consolidate_provider_compaction=consolidate,
+ tools=tools, model="test-model", context_window_tokens=1_624,
+ max_tokens=100, max_iterations=1, max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
+ events=EventSink(observe),
+ ))
+ assert [notice.phase for notice in notices] == ["succeeded"]
async def test_runner_keeps_current_tool_exchange_outside_summary(monkeypatch):
diff --git a/tests/providers/test_openai_codex_provider.py b/tests/providers/test_openai_codex_provider.py
index 580334dd5..7d0bb16c5 100644
--- a/tests/providers/test_openai_codex_provider.py
+++ b/tests/providers/test_openai_codex_provider.py
@@ -12,6 +12,7 @@ from loguru import logger
import nanobot.providers.base as provider_base
from nanobot.config.schema import Config
+from nanobot.events import ContextCompactionEvent, EventSink
from nanobot.providers.factory import make_provider
from nanobot.providers.openai_codex_provider import (
OpenAICodexProvider,
@@ -930,8 +931,9 @@ async def test_codex_replayed_tool_turn_omits_server_item_ids(monkeypatch) -> No
@pytest.mark.asyncio
[email protected]("inline_compaction", [False, True])
async def test_codex_compacts_state_at_ninety_percent_before_next_request(
- monkeypatch,
+ monkeypatch, inline_compaction,
) -> None:
_mock_codex_token(monkeypatch)
provider = OpenAICodexProvider(default_model="openai-codex/gpt-5.6-sol")
@@ -951,6 +953,16 @@ async def test_codex_compacts_state_at_ninety_percent_before_next_request(
usage=provider_base.LLMUsage.reported(input_tokens=90, output_tokens=5),
)
bodies: list[dict[str, Any]] = []
+ timeline: list[str] = []
+ notices: list[ContextCompactionEvent] = []
+
+ async def observe(event) -> None:
+ if isinstance(event, ContextCompactionEvent):
+ timeline.append(event.phase)
+ notices.append(event)
+
+ async def answer_delta(text: str) -> None:
+ timeline.append(f"answer:{text}")
async def fake_request(
url,
@@ -962,62 +974,67 @@ async def test_codex_compacts_state_at_ninety_percent_before_next_request(
on_thinking_delta=None,
on_tool_call_delta=None,
):
- _ = (
- url,
- headers,
- verify,
- proxy,
- on_content_delta,
- on_thinking_delta,
- on_tool_call_delta,
- )
+ _ = (url, headers, verify, proxy, on_thinking_delta, on_tool_call_delta)
bodies.append(body)
if body["input"][-1].get("type") == "compaction_trigger":
+ timeline.append("compact-request")
compact_item = {
"type": "compaction",
"encrypted_content": "compacted opaque state",
}
- return provider_base.LLMResponse(
- content=None,
- provider_state=build_responses_state(
- provider=state_provider,
- model="gpt-5.6-sol",
- input_items=body["input"],
- output_items=[compact_item],
- usage=provider_base.LLMUsage.reported(
- input_tokens=95,
- output_tokens=2,
- ),
- ),
- )
- return provider_base.LLMResponse(content="done")
+ async def compact_events():
+ yield {"type": "response.completed", "response": {
+ "status": "completed", "output": [compact_item],
+ "usage": {"input_tokens": 95, "output_tokens": 2},
+ }}
+
+ return await provider._responses.consume(compact_events(), provider=state_provider, body=body)
+ timeline.append("generation-request")
+
+ async def answer_events():
+ yield {"type": "response.output_text.delta", "delta": "done"}
+ yield {"type": "response.completed", "response": {
+ "status": "completed", "output": [
+ *([{"type": "compaction", "encrypted_content": "new inline state"}] if inline_compaction else []),
+ {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "done"}]},
+ ],
+ }}
+
+ return await provider._responses.consume(
+ answer_events(), provider=state_provider, body=body, on_content_delta=on_content_delta,
+ )
monkeypatch.setattr(
"nanobot.providers.openai_codex_provider._request_codex",
fake_request,
)
- response = await provider.chat_with_retry(
+ response = await provider.chat_stream_with_retry(
[
{"role": "system", "content": "system"},
{"role": "user", "content": "new question"},
],
max_tokens=5,
+ on_content_delta=answer_delta,
provider_context=provider_base.ProviderCallContext(
conversation_state=state.with_pending_messages([
{"role": "user", "content": "new question"},
]),
context_window_tokens=100,
+ events=EventSink(observe),
),
)
+ assert timeline == ["started", "compact-request", "succeeded", "generation-request", "answer:done"]
+ assert len({notice.compaction_id for notice in notices}) == 1
+ assert response.provider_compaction_event_id == (None if inline_compaction else notices[0].compaction_id)
assert response.content == "done"
assert response.provider_compaction_applied is True
assert response.provider_compaction_state is not None
- assert response.provider_compaction_scope == "prior_context"
+ assert response.provider_compaction_scope == ("current_request" if inline_compaction else "prior_context")
assert responses_state_items(response.provider_compaction_state) == [{
"type": "compaction",
- "encrypted_content": "compacted opaque state",
+ "encrypted_content": "new inline state" if inline_compaction else "compacted opaque state",
}]
assert len(bodies) == 2
assert bodies[0]["input"][-1] == {"type": "compaction_trigger"}
@@ -1065,6 +1082,11 @@ async def test_codex_disables_unsupported_native_compaction_and_continues(
usage=provider_base.LLMUsage.reported(input_tokens=90, output_tokens=5),
)
bodies: list[dict[str, Any]] = []
+ notices: list[ContextCompactionEvent] = []
+
+ async def observe(event) -> None:
+ if isinstance(event, ContextCompactionEvent):
+ notices.append(event)
async def fake_request(
url,
@@ -1107,16 +1129,73 @@ async def test_codex_disables_unsupported_native_compaction_and_continues(
{"role": "user", "content": "new"},
]),
context_window_tokens=100,
+ events=EventSink(observe),
),
)
assert response.content == "done"
+ assert [notice.phase for notice in notices] == ["started", "failed"]
+ assert len({notice.compaction_id for notice in notices}) == 1
assert len(bodies) == 2
assert bodies[0]["input"][-1] == {"type": "compaction_trigger"}
assert bodies[1]["input"][-1] != {"type": "compaction_trigger"}
assert provider.supports_native_compaction() is False
[email protected]("cancel_during", ["compaction", "terminal", "generation"])
+async def test_codex_native_compaction_terminal_survives_cancellation(monkeypatch, cancel_during) -> None:
+ _mock_codex_token(monkeypatch)
+ provider = OpenAICodexProvider(default_model="openai-codex/gpt-5.6-sol")
+ state_provider = provider._responses_state_provider()
+ state = build_responses_state(
+ provider=state_provider, model="gpt-5.6-sol",
+ input_items=[{"type": "message", "role": "user", "content": "old"}],
+ output_items=[{"type": "reasoning", "encrypted_content": "opaque"}],
+ usage=provider_base.LLMUsage.reported(input_tokens=90, output_tokens=5),
+ )
+ entered = asyncio.Event()
+ settle = asyncio.Event()
+ notices: list[ContextCompactionEvent] = []
+ requests: list[str] = []
+
+ async def observe(event) -> None:
+ if isinstance(event, ContextCompactionEvent):
+ notices.append(event)
+ if cancel_during == "terminal" and event.phase == "succeeded":
+ entered.set()
+ await settle.wait()
+
+ async def fake_request(_url, _headers, body, **_kwargs):
+ stage = "compaction" if body["input"][-1].get("type") == "compaction_trigger" else "generation"
+ requests.append(stage)
+ if stage == cancel_during:
+ entered.set()
+ await asyncio.Future()
+ return provider_base.LLMResponse(content=None, provider_state=build_responses_state(
+ provider=state_provider, model="gpt-5.6-sol", input_items=body["input"],
+ output_items=[{"type": "compaction", "encrypted_content": "compacted"}],
+ ))
+
+ monkeypatch.setattr("nanobot.providers.openai_codex_provider._request_codex", fake_request)
+ task = asyncio.create_task(provider.chat(
+ [{"role": "user", "content": "new"}], max_tokens=5,
+ provider_context=provider_base.ProviderCallContext(
+ conversation_state=state.with_pending_messages([{"role": "user", "content": "new"}]),
+ context_window_tokens=100, events=EventSink(observe),
+ ),
+ ))
+ await asyncio.wait_for(entered.wait(), timeout=2)
+ task.cancel()
+ settle.set()
+ with pytest.raises(asyncio.CancelledError):
+ await task
+ terminal = "cancelled" if cancel_during == "compaction" else "succeeded"
+ assert [notice.phase for notice in notices] == ["started", terminal]
+ assert len({notice.compaction_id for notice in notices}) == 1
+ assert requests == (["compaction", "generation"] if cancel_during == "generation" else ["compaction"])
+
+
@pytest.mark.asyncio
async def test_codex_stream_surfaces_reasoning_summary(monkeypatch) -> None:
def fake_token(**_kwargs):
diff --git a/webui/browser/history-hydration.spec.ts b/webui/browser/history-hydration.spec.ts
index 007a84b3b..c9bd39dfe 100644
--- a/webui/browser/history-hydration.spec.ts
+++ b/webui/browser/history-hydration.spec.ts
@@ -112,6 +112,10 @@ async function installBackend(page: Page) {
// The fixture's non-consuming observer acknowledges client dispatch, not a model installation.
await expect(page.getByLabel("Synthetic frame receipt")).toHaveText(`${"chat_id" in event ? event.chat_id : "-"}/${turn}/${event.event}/${sequence}`);
},
+ refreshThread() {
+ expect(socket, "The fixture must establish its WebSocket before refresh").toBeDefined();
+ socket!.send(JSON.stringify({ event: "session_updated", chat_id: A, scope: "thread" }));
+ },
async ready() {
await expect(page.getByLabel("Synthetic transport status")).toHaveText("open");
await expect.poll(() => attached.includes(A)).toBe(true);
@@ -156,6 +160,52 @@ async function expectBefore(body: Locator, first: string, second: string) {
expect(text.indexOf(second), `${second} must follow ${first}`).toBeGreaterThan(text.indexOf(first));
}
+test("idle compaction stays singular across live updates, thread refresh and cold replay", async ({ page }) => {
+ const { backend, body } = await openFixture(page);
+ const base = closedTurn("idle-completed", "Before idle compression", "Completed answer before idle compression.");
+ await backend.release(await backend.read(), history(base));
+ await expect(body.getByText("Completed answer before idle compression.", { exact: true })).toBeVisible();
+ const compaction = { event: "context_compaction" as const, chat_id: A, compaction_id: "idle-once" };
+ await backend.send({ ...compaction, phase: "started" });
+ await expect(body.locator('[data-context-compaction="started"]')).toHaveCount(1);
+ await backend.send({ ...compaction, phase: "succeeded" });
+ await expect(body.locator('[data-context-compaction="succeeded"]')).toHaveCount(1);
+
+ const completed = history([...base, { ...compaction, phase: "succeeded" }]);
+ backend.refreshThread();
+ await backend.release(await backend.read(A, null, 1), completed);
+ await expect(body.locator('[data-context-compaction="succeeded"]')).toHaveCount(1);
+ await expectBefore(body, "Completed answer before idle compression.", "Context compacted");
+ await page.reload();
+ await backend.ready();
+ await backend.release(await backend.read(A, null, 2), completed);
+ await expect(body.locator('[data-context-compaction="succeeded"]')).toHaveCount(1);
+ await expectBefore(body, "Completed answer before idle compression.", "Context compacted");
+ backend.healthy();
+});
+
+test("pre-request compaction precedes the answer in live output and history replay", async ({ page }) => {
+ const { backend, body } = await openFixture(page);
+ const base = closedTurn("before-native", "Previous question", "Previous answer.");
+ await backend.release(await backend.read(), history(base));
+ await expect(body.getByText("Previous answer.", { exact: true })).toBeVisible();
+ const question = input(TURN, "Question requiring native compression");
+ const compact: ThreadProjectionEvent = { ...at(TURN, 2, "activity"), event: "context_compaction", compaction_id: "native-before-answer", phase: "succeeded" };
+ await backend.send(question);
+ await backend.send({ event: "context_compaction", chat_id: A, compaction_id: "native-before-answer", phase: "started" });
+ await backend.send(compact);
+ await backend.send(delta(3, LIVE));
+ await backend.send(end(4, LIVE, "live-wire"));
+ const complete: ThreadProjectionEvent = { ...at(TURN, 5, "complete"), event: "turn_end" };
+ await backend.send(complete);
+ await expectBefore(body, "Context compacted", LIVE);
+ backend.refreshThread();
+ await backend.release(await backend.read(A, null, 1), history([...base, question, compact, end(4, LIVE, "live-wire"), complete]));
+ await expect(body.locator('[data-context-compaction="succeeded"]')).toHaveCount(1);
+ await expectBefore(body, "Context compacted", LIVE);
+ backend.healthy();
+});
+
for (const width of [1440, 390]) {
test(`synthetic live-first latest admits its prefix without refresh, then prepends two cursor pages (${width}px)`, async ({ page }) => {
const { backend, body } = await openFixture(page, width);
diff --git a/webui/src/lib/thread-transcript.ts b/webui/src/lib/thread-transcript.ts
index 61dd20127..741c1dbbc 100644
--- a/webui/src/lib/thread-transcript.ts
+++ b/webui/src/lib/thread-transcript.ts
@@ -178,8 +178,9 @@ export class ThreadTranscript {
registerInput(row: UIMessage, received = true): void {
if (row.role === "user" && row.turnId) this.knownTurns.add(row.turnId);
- const identity = row.sessionMessage?.message_id
- ? `input:${row.sessionMessage.message_id}` : row.role === "user" && row.turnId
+ const identity = row.kind === "compaction" && row.compaction
+ ? `compaction:${row.compaction.id}` : row.sessionMessage?.message_id
+ ? `input:${row.sessionMessage.message_id}` : row.role === "user" && row.turnId
? `user:${row.turnId}` : row.turnId && row.turnSeq !== undefined
? `fact:${row.turnId}:${row.turnSeq}` : `replay:${row.id}`;
if (this.bySource.has(identity)) return;
@@ -200,6 +201,9 @@ export class ThreadTranscript {
for (const [first, last] of receipt.ranges) addRange(ranges, first, last);
members.set(receipt.turn_id, ranges);
}
+ if (event.event === "context_compaction") {
+ return { source: `compaction:${event.compaction_id}`, members, text: null };
+ }
if (event.event === "user_message") {
return { source: event.provenance?.session_message?.message_id
? `input:${event.provenance.session_message.message_id}` : turn ? `user:${turn}` : `replay:${event.projection_id}`,
diff --git a/webui/src/tests/thread-transcript.test.ts b/webui/src/tests/thread-transcript.test.ts
index b7dc9bf3f..5657ba5c8 100644
--- a/webui/src/tests/thread-transcript.test.ts
+++ b/webui/src/tests/thread-transcript.test.ts
@@ -41,6 +41,52 @@ function receive(thread: ThreadTranscript, ...events: ThreadProjectionEvent[]):
}
describe("ThreadTranscript admission", () => {
+ it.each(["succeeded", "failed", "cancelled"] as const)("reconciles one idle compaction across live phases and history (%s)", (phase) => {
+ const thread = new ThreadTranscript();
+ const base = [
+ input("turn-before-idle", "Question"),
+ { ...at("turn-before-idle", 2), event: "stream_end" as const, stream_id: "answer-before-idle", text: "Answer" },
+ { ...at("turn-before-idle", 3), event: "turn_end" as const },
+ ];
+ const completed = { completed_turn_ids: ["turn-before-idle"] };
+ expect(thread.accept(history(base, completed), thread.begin("initial"))).toBe(true);
+ const compaction = { event: "context_compaction" as const, chat_id: "hydration-chat", compaction_id: "idle-one" };
+ receive(thread, { ...compaction, phase: "started" });
+ const staleRead = thread.begin("latest");
+ receive(thread, { ...compaction, phase });
+ expect(thread.accept(history(base, completed), staleRead)).toBe(true);
+ expect(thread.messages.map((row) => row.id).filter((id) => id === "compaction-idle-one")).toHaveLength(1);
+ expect(thread.messages.at(-1)?.compaction?.phase).toBe(phase);
+
+ const body = history([...base, { ...compaction, phase }], completed);
+ expect(thread.accept(body, thread.begin("latest"))).toBe(true);
+ expect(thread.messages.map((row) => row.content)).toEqual(["Question", "Answer", ""]);
+ expect(thread.messages[2]).toMatchObject({ id: "compaction-idle-one", compaction: { phase } });
+ const owners = thread.save().units.filter((unit) => unit.rows.has("compaction-idle-one"));
+ expect(owners).toHaveLength(1);
+ expect(thread.accept(body, thread.begin("latest"))).toBe(true);
+ const restored = new ThreadTranscript([], thread.save());
+ receive(restored, { ...compaction, phase });
+ expect(restored.accept(body, restored.begin("latest"))).toBe(true);
+ expect(restored.messages.map((row) => row.id).filter((id) => id === "compaction-idle-one")).toHaveLength(1);
+ });
+
+ it("keeps distinct native and idle compactions when history refreshes a live idle notice", () => {
+ const thread = new ThreadTranscript();
+ const native: ThreadProjectionEvent = { ...at("turn-native", 2), event: "context_compaction", compaction_id: "native", phase: "succeeded" };
+ const base: ThreadProjectionEvent[] = [
+ input("turn-native", "Question"), native,
+ { ...at("turn-native", 3), event: "stream_end", stream_id: "answer-native", text: "Answer" },
+ { ...at("turn-native", 4), event: "turn_end" },
+ ];
+ const completed = { completed_turn_ids: ["turn-native"] };
+ expect(thread.accept(history(base, completed), thread.begin("initial"))).toBe(true);
+ const idle: ThreadProjectionEvent = { event: "context_compaction", chat_id: "hydration-chat", compaction_id: "idle", phase: "succeeded" };
+ receive(thread, idle);
+ expect(thread.accept(history([...base, idle], completed), thread.begin("latest"))).toBe(true);
+ expect(thread.messages.map((row) => row.compaction?.id ?? row.content)).toEqual(["Question", "native", "Answer", "idle"]);
+ });
+
it("installs an older safe prefix without replacing or redirecting the received foreground", () => {
const thread = new ThreadTranscript();
const read = thread.begin("initial");