iCode-TUI 0.29.1__py3-none-any.whl

chrys/service/context/compaction/current_turn_drop.py

@@ -0,0 +1,458 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Current-turn drop round execution and cancellation-drained spilling."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import replace
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from chrys.foundation.models.turns import is_continuation_message
+from chrys.foundation.trajectory.metadata import read_analytics_item_id
+from chrys.kernel import Message, annotate_token_counts, included_token_count, set_excluded
+
+from .breaker import DropBreakerController
+from .events import _REASON_CURRENT_TURN_DROP, CompactionInfo
+from .exclusions import ExclusionLedger
+from .groups import _tool_call_name
+from .last_words import LastWordsSpendBudgetExceeded
+from .last_words_state import LastWordsState, ManifestEntry
+from .scoped import ScopedGroup, build_scoped_group_timeline
+from .spill import SpillBatchResult, SpillManifestItem, SpillQuota, turn_directory_name, write_spill_batch
+from .turns import _resolve_turns
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from chrys.kernel import CompactionCallContext
+
+    from .strategy import LastWordsGeneratorLike, UnifiedContextStrategy
+
+_log = logging.getLogger(__name__)
+
+
+def _consumed_item_ids(groups: Sequence[ScopedGroup]) -> list[str]:
+    """Return the ordered unique stable ids represented by Phase-4 groups."""
+    seen: set[str] = set()
+    ordered: list[str] = []
+    for group in groups:
+        for message in group.messages:
+            candidates = [
+                read_analytics_item_id(message.additional_properties),
+                *(read_analytics_item_id(content.additional_properties) for content in message.contents),
+            ]
+            for item_id in candidates:
+                if item_id is not None and item_id not in seen:
+                    seen.add(item_id)
+                    ordered.append(item_id)
+    return ordered
+
+
+async def _write_spill_batch_in_worker(
+    session_root: Path | None,
+    quota: SpillQuota | None,
+    groups: Sequence[ScopedGroup],
+    *,
+    record_dir: Path,
+    absolute_turn: int,
+    round_number: int,
+    session_id: str,
+    superseded_note: str | None = None,
+) -> SpillBatchResult:
+    """Run one spill batch without letting cancellation orphan its writes.
+
+    ``asyncio.to_thread`` cannot stop a thread when its awaiting task is
+    cancelled. Drain the owned worker before propagating cancellation so a
+    session reset/restore cannot replace the quota lock or mutate the session
+    directory while the old batch is still running.
+    """
+    worker = asyncio.create_task(
+        asyncio.to_thread(
+            write_spill_batch,
+            session_root,
+            quota,
+            groups,
+            record_dir=record_dir,
+            absolute_turn=absolute_turn,
+            round_number=round_number,
+            session_id=session_id,
+            superseded_note=superseded_note,
+        )
+    )
+    try:
+        return await asyncio.shield(worker)
+    except asyncio.CancelledError:
+        # Repeated interrupts must not detach the same worker. Each shield is
+        # a fresh waiter; the underlying task remains owned until it settles.
+        while not worker.done():
+            try:
+                await asyncio.shield(worker)
+            except asyncio.CancelledError:
+                continue
+            except Exception:
+                break
+        if not worker.cancelled():
+            try:
+                worker.result()
+            except Exception:
+                _log.debug("Spill worker failed while its caller was cancelled", exc_info=True)
+        raise
+
+
+class CurrentTurnDropRound:
+    """Execute the final current-turn drop stage against live strategy state."""
+
+    def __init__(
+        self,
+        strategy: UnifiedContextStrategy,
+        breaker: DropBreakerController,
+        ledger: ExclusionLedger,
+    ) -> None:
+        self._strategy = strategy
+        self._breaker = breaker
+        self._ledger = ledger
+
+    async def _generate_last_words(
+        self,
+        timeline_groups: list[ScopedGroup],
+        previous: str | None,
+        *,
+        degraded_opener: bool,
+        has_continuation_nudges: bool,
+        context: CompactionCallContext | None,
+        generator: LastWordsGeneratorLike,
+        last_words: LastWordsState,
+    ) -> str:
+        # max() folds the retained legacy ``tool_definition_tokens`` spelling.
+        request_overhead_tokens = (
+            max(context.request_overhead_tokens, context.tool_definition_tokens) if context is not None else 0
+        )
+        failure_recorded = False
+        try:
+            new_last_words = await generator.generate(
+                timeline_groups,
+                previous,
+                degraded_opener=degraded_opener,
+                has_continuation_nudges=has_continuation_nudges,
+                completer=context.last_words_completer if context is not None else None,
+                tokenizer=self._strategy.tokenizer,
+                system_overhead_tokens=self._strategy.system_overhead_tokens,
+                request_overhead_tokens=request_overhead_tokens,
+                calibration_ratio=self._strategy.calibration_ratio,
+                spend_side_call_tokens=self._breaker.spend_side_call_tokens,
+            )
+        except LastWordsSpendBudgetExceeded:
+            breaker = self._breaker.record_no_progress("side_call_budget")
+            if breaker is not None and not breaker.disabled:
+                disabled = replace(breaker, disabled=True)
+                last_words.set_drop_round_breaker(disabled)
+                self._breaker.emit_context_pressure("side_call_budget", disabled)
+            failure_recorded = True
+            _log.warning("Phase 4 side-call spend budget exhausted; retaining current-turn groups")
+            new_last_words = ""
+        except Exception:
+            self._breaker.record_no_progress("generation_failure")
+            raise
+        if not new_last_words and not failure_recorded:
+            self._breaker.record_no_progress("generation_failure")
+        return new_last_words
+
+    async def _spill_drop_groups(
+        self,
+        drop_groups: list[ScopedGroup],
+        *,
+        absolute_turn: int,
+        round_number: int,
+        previous: str | None,
+    ) -> tuple[SpillBatchResult, bool]:
+        record_dir = self._strategy._spill_record_dir / turn_directory_name(absolute_turn)
+        spill_result = await _write_spill_batch_in_worker(
+            self._strategy._spill_root,
+            self._strategy._spill_quota,
+            drop_groups,
+            record_dir=record_dir,
+            absolute_turn=absolute_turn,
+            round_number=round_number,
+            session_id=self._strategy._spill_session_id,
+            # The merge that authorized this drop replaces
+            # ``previous``; archive that pre-merge original
+            # verbatim alongside the round's group records.
+            superseded_note=previous or None,
+        )
+        spill_permitted = True
+        if spill_result.unexpected_io_failure:
+            spill_permitted = False
+            if self._strategy._persist_recovery_now is not None:
+                try:
+                    spill_permitted = (await self._strategy._persist_recovery_now()) is True
+                except Exception:
+                    _log.warning(
+                        "Phase 4 recovery persistence failed after spill I/O error",
+                        exc_info=True,
+                    )
+            if not spill_permitted:
+                self._breaker.record_no_progress("spill_abort")
+                _log.warning("Phase 4 spill I/O failure was not durably checkpointed; retaining groups")
+        return spill_result, spill_permitted
+
+    async def run(
+        self,
+        messages: list[Message],
+        context: CompactionCallContext | None,
+    ) -> bool:
+        """Run one Phase-4 pipeline stage."""
+        changed = False
+
+        # ---- Phase 4: Drop ALL current-turn tool calls + inline agent text ----
+        # One shot: collect every current-turn group that is still included,
+        # hand them to the LAST_WORDS LLM summariser, exclude them, and set
+        # the updated note on the LAST_WORDS state, whose reminder is appended
+        # to the user message on every subsequent LLM call until the turn ends.
+        # Generator failures (SDK error, empty response) are retried inside
+        # the generator against the same LAST_WORDS prompt — we never drop
+        # current-turn work without a note in hand.
+        p4_count = 0
+        p4_tool_names: list[str] = []
+        p4_consumed_item_ids: list[str] = []
+        p4_last_words_generated = False
+        p4_tokens_before = included_token_count(messages)
+
+        if self._strategy._usage_pct(p4_tokens_before) > self._strategy.target_pct:
+            # Resolve fresh at this call site against the post-P3 lists.
+            resolved = _resolve_turns(messages, self._strategy._state)
+            current_span = resolved.current
+            current_turn = (current_span.start, current_span.end) if current_span is not None else (0, len(messages))
+            timeline = build_scoped_group_timeline(
+                messages,
+                span_start=current_turn[0],
+                span_end=current_turn[1],
+                degraded=resolved.degraded,
+            )
+            current_groups = [group.group_id for group in timeline.groups if group.kind not in ("user", "system")]
+
+            # Phase 4 only fires when there is at least one tool-call group
+            # to drop — otherwise there is nothing meaningful to summarise
+            # and dropping plain assistant text alone would lose content
+            # without replacing it.
+            has_tool_call = any(group.kind == "tool_call" for group in timeline.groups)
+
+            if current_groups and has_tool_call:
+                reminder_middleware = self._strategy._reminder_middleware
+                last_words_state = self._strategy._last_words_state
+                last_words_generator = self._strategy._last_words_generator
+                if last_words_generator is None or reminder_middleware is None or last_words_state is None:
+                    _log.warning(
+                        "Phase 4 SKIPPED drop: fresh-note collaborators unbound "
+                        "(reminder_middleware=%s, last_words_state=%s, last_words_generator=%s)",
+                        "bound" if reminder_middleware is not None else "None",
+                        "bound" if last_words_state is not None else "None",
+                        "bound" if last_words_generator is not None else "None",
+                    )
+                else:
+                    # Step 1: synchronous entry check and attempt count, before
+                    # hooks, preflight, or either side-call path.
+                    breaker_at_entry, trip_reason = self._breaker.enter_round()
+                    if breaker_at_entry is None:
+                        await self._breaker.publish_trip(trip_reason)
+                    else:
+                        entry_usage_pct = self._strategy._usage_pct(p4_tokens_before)
+                        await self._strategy._fire_pre_compact(
+                            "phase4",
+                            usage_pct=entry_usage_pct,
+                            tokens_before=p4_tokens_before,
+                        )
+                        drop_groups = [group for group in timeline.groups if group.kind not in ("user", "system")]
+                        p4_consumed_item_ids = _consumed_item_ids(drop_groups)
+                        for group in drop_groups:
+                            if group.kind == "tool_call":
+                                p4_tool_names.extend(
+                                    tool_name
+                                    for message in group.messages
+                                    for content in message.contents
+                                    if (tool_name := _tool_call_name(content))
+                                )
+
+                        # Step 2: only a non-empty note produced by THIS round
+                        # authorizes the later drop. A stale note is inherited
+                        # input, never authorization for a new delta.
+                        previous = last_words_state.get_last_words()
+                        has_continuation_nudges = any(
+                            is_continuation_message(message) for group in timeline.groups for message in group.messages
+                        )
+                        new_last_words = await self._generate_last_words(
+                            list(timeline.groups),
+                            previous,
+                            degraded_opener=timeline.degraded_opener,
+                            has_continuation_nudges=has_continuation_nudges,
+                            context=context,
+                            generator=last_words_generator,
+                            last_words=last_words_state,
+                        )
+
+                        if new_last_words:
+                            # Step 3: worker-thread spill, including catalog
+                            # append+flush and catalog-only manifest projection.
+                            absolute_turn = current_span.absolute_number if current_span is not None else 1
+                            spill_result, spill_permitted = await self._spill_drop_groups(
+                                drop_groups,
+                                absolute_turn=absolute_turn,
+                                round_number=breaker_at_entry.attempts,
+                                previous=previous,
+                            )
+
+                            if spill_permitted:
+                                manifest_entries = [self._manifest_entry(item) for item in spill_result.entries]
+
+                                # Steps 4-5: synchronous commit through
+                                # exclusion and the post-round usage sample.
+                                # Do not insert an await anywhere in this block.
+                                last_words_state.mark_manifest_records_unavailable(spill_result.evicted_relative_paths)
+                                last_words_state.set_last_words(new_last_words)
+                                last_words_state.append_manifest(manifest_entries)
+                                p4_last_words_generated = True
+                                reminder_middleware.refresh_last_words_reminder(messages)
+                                annotate_token_counts(
+                                    messages,
+                                    tokenizer=self._strategy.tokenizer,
+                                    force_retokenize=True,
+                                )
+                                changed = True
+
+                                for group in drop_groups:
+                                    any_changed = False
+                                    for message in group.messages:
+                                        any_changed = (
+                                            set_excluded(
+                                                message,
+                                                excluded=True,
+                                                reason=_REASON_CURRENT_TURN_DROP,
+                                            )
+                                            or any_changed
+                                        )
+                                    if any_changed:
+                                        self._ledger._removed_group_ids.add(group.group_id)
+                                        p4_count += 1
+                                post_p4_tokens = included_token_count(messages)
+                                self._breaker.record_progress(
+                                    entry_usage_pct,
+                                    self._strategy._usage_pct(post_p4_tokens),
+                                )
+                                # Anchor/token bookkeeping must also land
+                                # inside the synchronous commit: the awaits
+                                # that follow (committed publish,
+                                # on_compaction) honor cancellation, and an
+                                # interrupt that observed exclusions without
+                                # anchors would resume retaining both the
+                                # original history and the note.
+                                self._strategy._last_included_tokens = post_p4_tokens
+                                self._ledger.snapshot_excluded_anchors(messages)
+                                # The round is now durably applied; tell
+                                # observers that count real compactions
+                                # (the finished-ok signal fired pre-commit
+                                # and can belong to an abandoned round).
+                                try:
+                                    await last_words_generator.publish_committed()
+                                except asyncio.CancelledError:
+                                    # The commit above is durable, but the
+                                    # end-of-pass on_compaction notification
+                                    # (ToolCompacted for the main agent)
+                                    # would be skipped by the cancellation —
+                                    # deliver it on a detached task before
+                                    # propagating, covering the rounds
+                                    # committed so far this pass.
+                                    self._schedule_detached_on_compaction(
+                                        CompactionInfo(
+                                            compacted_groups=p4_count,
+                                            phase="phase4",
+                                            turn_numbers=[current_span.absolute_number]
+                                            if current_span is not None
+                                            else [],
+                                            tool_names=p4_tool_names,
+                                            tokens_before=p4_tokens_before,
+                                            tokens_after=post_p4_tokens,
+                                            last_words_generated=True,
+                                            consumed_item_ids=p4_consumed_item_ids,
+                                        )
+                                    )
+                                    raise
+
+            if p4_count > 0 or p4_last_words_generated:
+                # The rounds this reports are already durably committed, so
+                # the delivery itself must survive cancellation for the
+                # whole await window, not just inside publish_committed
+                # above: run it as an anchored task behind a shield —
+                # cancellation still propagates to the caller, but the
+                # ToolCompacted delivery finishes detached.
+                delivery = self._schedule_detached_on_compaction(
+                    CompactionInfo(
+                        compacted_groups=p4_count,
+                        phase="phase4",
+                        turn_numbers=[current_span.absolute_number] if current_span is not None else [],
+                        tool_names=p4_tool_names,
+                        tokens_before=p4_tokens_before,
+                        tokens_after=included_token_count(messages),
+                        last_words_generated=p4_last_words_generated,
+                        consumed_item_ids=p4_consumed_item_ids,
+                    )
+                )
+                await asyncio.shield(delivery)
+
+        return changed
+
+    @staticmethod
+    def _manifest_entry(item: SpillManifestItem) -> ManifestEntry:
+        return ManifestEntry(
+            record_id=item.record_id,
+            group_id=item.group_id,
+            record_dir=item.record_dir,
+            relative_path=item.relative_path,
+            turn=item.turn,
+            round=item.round,
+            sequence=item.sequence,
+            tool=item.tool,
+            display_argument=item.display_argument,
+            outcome=item.outcome,
+            size_chars=item.size_chars,
+            assistant_text=item.assistant_text,
+            available=item.available,
+            no_record_reason=item.no_record_reason,
+        )
+
+    def _schedule_detached_on_compaction(self, info: CompactionInfo) -> asyncio.Future:
+        """Record the phase now; hand the observer callback to a detached task.
+
+        The pass around this call can close its run before a task started here
+        gets to write — it may not have run at all yet, or be waiting on the
+        ack of the phase's opening line while the pass unwinds — and the phase
+        (or the tail of a segmented one) would land behind the run's own
+        terminal marker. Queued here it cannot.
+        """
+        run = self._strategy._trajectory_run
+        if run is not None:
+            run.phase_finished_soon(
+                phase=info.phase,
+                groups_compacted=info.compacted_groups,
+                turn_numbers=info.turn_numbers,
+                tool_names=info.tool_names,
+                tokens_before=info.tokens_before,
+                tokens_after=info.tokens_after,
+                last_words_generated=info.last_words_generated,
+                consumed_item_ids=info.consumed_item_ids,
+            )
+        # No run: the phase above already carries it, and only the observer
+        # callback is left to deliver.
+        task = asyncio.ensure_future(self._strategy._notify_compaction_for_run(info, None))
+        self._strategy._detached_deliveries.add(task)
+        task.add_done_callback(self._discard_detached_delivery)
+        return task
+
+    def _discard_detached_delivery(self, task: asyncio.Future) -> None:
+        self._strategy._detached_deliveries.discard(task)
+        if task.cancelled():
+            return
+        exc = task.exception()
+        if exc is not None:
+            _log.debug("Detached on_compaction delivery failed", exc_info=exc)

chrys/service/context/compaction/events.py

@@ -0,0 +1,201 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Compaction event payloads, shared value types, and exclusion reasons."""
+
+from __future__ import annotations
+
+import logging
+import weakref
+from dataclasses import dataclass, field
+from typing import Any
+
+from chrys.kernel import Message
+from chrys.kernel.identity import WeakIdentityRegistry
+
+_log = logging.getLogger(__name__)
+
+# Exclude reasons set by this compaction strategy's _compact_group (Phase 1)
+# and _remove_group (Phase 2/3).  Used to recognise flags that were persisted
+# from a prior session and should not be cleared on session restore.
+_REASON_COMPACTION = "budget_tool_compaction"
+_REASON_REMOVAL = "budget_tool_removal"
+_REASON_CURRENT_TURN_DROP = "current_turn_drop"
+_REASON_COMPRESSION = "cross_turn_compression"
+_COMPACTION_EXCLUDE_REASONS = frozenset(
+    {_REASON_COMPACTION, _REASON_REMOVAL, _REASON_CURRENT_TURN_DROP, _REASON_COMPRESSION}
+)
+
+# ---------------------------------------------------------------------------
+# Compaction info
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class CompactionInfo:
+    """Details about an intra-turn compaction round, passed to the on_compaction callback."""
+
+    compacted_groups: int
+    """Number of tool-call groups that were compacted."""
+
+    phase: str = ""
+    """Which phase: ``"phase1"`` to ``"phase4"`` (see module docstring)."""
+
+    turn_numbers: list[int] = field(default_factory=list)
+    """Absolute turn numbers affected (phases 1/2: compacted previous
+    turns; phase 4: the current turn)."""
+
+    tool_names: list[str] = field(default_factory=list)
+    """Tool names from compacted groups (may contain duplicates across groups)."""
+
+    tokens_before: int = 0
+    """Estimated included token count before compaction."""
+
+    tokens_after: int = 0
+    """Estimated included token count after compaction."""
+
+    last_words_generated: bool = False
+    """True when phase 4 produced/updated a LAST_WORDS progress note."""
+
+    consumed_item_ids: list[str] = field(default_factory=list)
+    """Stable item ids folded into the Phase-4 note before the next wire request."""
+
+
+@dataclass(frozen=True)
+class PreCompactInfo:
+    """Details about a compaction phase before it mutates context."""
+
+    trigger: str
+    """Which phase is about to run: ``"phase1"`` to ``"phase4"``, or ``"force"``."""
+
+    usage_pct: float
+    """Estimated context usage fraction at the phase boundary."""
+
+    tokens_before: int = 0
+    """Estimated included token count before the phase runs."""
+
+    trajectory_operation_id: str | None = None
+    """Compaction container targeted by blocking hooks, when already open."""
+
+
+@dataclass(frozen=True)
+class CompressInfo:
+    """Details about a cross-turn context compression, passed to the on_compress callback."""
+
+    compressed_context_id: str
+    """Unique identifier for the compressed block."""
+
+    summary: str = ""
+    """Agent-provided summary of the compressed content."""
+
+    freed_messages: int = 0
+    """Number of messages that were folded into the compressed block."""
+
+    turn_range: tuple[int, int] = (0, 0)
+    """Inclusive backend turn range folded into the compressed block."""
+
+    source: str = "agent"
+    """What initiated the compression: ``"agent"`` (LLM called compress_context) or ``"auto"`` (platform)."""
+
+
+def _compressed_turn_range(state: dict[str, Any] | None, compressed_context_id: str) -> tuple[int, int]:
+    """Return the persisted turn range for a just-created compressed block."""
+    if state is None:
+        return (0, 0)
+    compressed_blocks = state.get("compressed_msgs")
+    if not isinstance(compressed_blocks, list):
+        return (0, 0)
+
+    from chrys.service.context.providers.history import CompressedBlock
+
+    for block in reversed(compressed_blocks):
+        if isinstance(block, CompressedBlock) and block.compressed_context_id == compressed_context_id:
+            return block.turn_range
+    return (0, 0)
+
+
+@dataclass
+class PendingCompression:
+    """A queued cross-turn compression request from the ``compress_context`` tool.
+
+    Created by :meth:`UnifiedContextStrategy.queue_compression`, processed
+    inside :meth:`UnifiedContextStrategy.__call__` on FunctionInvocationLayer's message list.
+    """
+
+    compressed_context_id: str
+    """Pre-generated ID, returned to the tool caller immediately."""
+
+    marker_id: str
+    """The turn marker to fold up to."""
+
+    summary_text: str
+    """Agent-provided summary."""
+
+    freed_count: int = 0
+    """Pre-computed count of messages in the fold range."""
+
+
+@dataclass(frozen=True)
+class CachedSummary:
+    """A Phase 1 tool-result summary, cached for defensive re-injection.
+
+    The active tool loop keeps inserted summaries on its message list.
+    Chrys still caches summaries so copied or replayed lists that retain
+    ``_summarized_by_summary_id`` on excluded originals can be reconstructed.
+    Stored in :attr:`UnifiedContextStrategy._summary_cache`, keyed by
+    a unique occurrence ``summary_id`` (``"tool_summary_<item_id>"``),
+    independent of positional group and message IDs.
+    """
+
+    summary_text: str
+    """The compacted summary text shown in place of the full tool result."""
+
+    original_ids: list[str]
+    """Message IDs of the original tool-call group members being summarised."""
+
+    group_id: str
+    """ID of the tool-call group this summary replaces."""
+
+    item_id: str
+    """Stable occurrence identity shared by wire, stored and re-injected summaries."""
+
+    message: Message
+    """Summary contents and write-through metadata, without retaining original messages."""
+
+
+@dataclass(frozen=True)
+class CachedCompressedContextSummary:
+    """A cross-turn compressed-context summary cached for same-run re-injection.
+
+    Identity snapshots are WEAK registries held across calls: an entry lives
+    exactly as long as its object, so a garbage-collected original simply
+    stops matching — its recycled id can never false-match fresh wire
+    content — and the cache never keeps the folded originals alive.
+    """
+
+    summary_message: Message
+    """The compressed-context summary inserted into state."""
+
+    folded_contents: WeakIdentityRegistry
+    """Weak identities of the original folded messages' contents lists."""
+
+    folded_summary_ids: frozenset[str]
+    """Stable summary occurrence references belonging to folded messages."""
+
+    folded_content_objects: WeakIdentityRegistry
+    """Weak identities of the folded messages' content OBJECTS.
+
+    Matches the kernel wire's per-call message views, whose fresh contents
+    lists defeat ``folded_contents``; the content objects stay shared.
+    Usage contents are deliberately included — fold evidence must keep
+    seeing them.
+    """
+
+    folded_messages: tuple[weakref.ref[Message], ...]
+    """Weak references to the folded state messages themselves.
+
+    Matches the reminder middleware's enriched user messages, which carry
+    fresh contents and share only the original's ``additional_properties``
+    dict. A plain dict can't be weakly referenced, so the dicts are read off
+    the still-live originals at match time; their ids are therefore always
+    those of live objects.
+    """