mycode-cli 0.18.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

mycode_cli/runtime.py

@@ -5,26 +5,21 @@ from __future__ import annotations
 from mycode.agent import Agent
 from mycode_cli.config import ResolvedProvider, Settings
 from mycode_cli.permissions import ToolReviewCallback, build_permission_hooks
-from mycode_cli.sessions import SessionStore, sum_session_cost
+from mycode_cli.sessions import SessionStore, SessionTotals, sum_session_totals
 from mycode_cli.system_prompt import build_system_prompt
 from mycode_cli.tools import DEFAULT_TOOLS
 from mycode_cli.web_tools import build_web_tools
 from mycode_cli.workspace import CliDeps
 
 
-def sum_known_costs(*costs: float | None) -> float | None:
-    known = [cost for cost in costs if cost is not None]
-    return sum(known) if known else None
+async def load_session_totals(store: SessionStore, session_id: str) -> SessionTotals:
+    """Load the session's cumulative usage and USD cost from its raw JSONL timeline.
 
-
-async def load_session_cost(store: SessionStore, session_id: str) -> float | None:
-    """Load the session's cumulative USD cost from its raw JSONL timeline.
-
-    Counts persisted costs from tool loops, compact summaries, and turns
-    discarded by rewind. Records without a cost are skipped.
+    Counts tool loops, compact summaries, and turns discarded by rewind.
+    Records without usage or cost contribute nothing to that total.
     """
 
-    return sum_session_cost(await store.load_raw_messages(session_id))
+    return sum_session_totals(await store.load_raw_messages(session_id))
 
 
 def build_agent(

mycode_cli/server/routers/chat.py

@@ -21,7 +21,7 @@ from mycode.attachments import (
     detect_document_mime_type,
     detect_image_mime_type,
 )
-from mycode.compact import has_compactable_history
+from mycode.compact import DEFAULT_COMPACT_THRESHOLD, has_compactable_history
 from mycode.messages import (
     ConversationMessage,
     build_message,
@@ -30,6 +30,7 @@ from mycode.messages import (
     image_block,
     text_block,
 )
+from mycode.models import ModelMetadata
 from mycode_cli.config import (
     ResolvedProvider,
     get_settings,
@@ -40,19 +41,21 @@ from mycode_cli.config import (
     resolve_provider_choices,
 )
 from mycode_cli.permissions import ToolReviewDecision, ToolReviewRequest
-from mycode_cli.runtime import build_agent, load_session_cost
+from mycode_cli.runtime import build_agent, load_session_totals
 from mycode_cli.server.deps import RunManagerDep, StoreDep, resolve_workspace_cwd
-from mycode_cli.server.run_manager import ActiveRunError
+from mycode_cli.server.run_manager import ActiveRunError, RunAgent
 from mycode_cli.server.schemas import (
     CancelRunResponse,
     ChatRequest,
     ChatResponse,
     CompactRequest,
-    CompactResponse,
     DecideRequest,
+    PendingInputRequest,
     RunInfo,
+    RunResponse,
     StatusResponse,
     StreamEvent,
+    UserInputRequest,
 )
 from mycode_cli.system_prompt import build_skill_snapshot_blocks, discover_slash_skills
 from mycode_cli.workspace import resolve_path
@@ -86,7 +89,7 @@ def _read_workspace_text_attachment(rel_path: str, *, name: str | None, cwd: str
         raise HTTPException(status_code=400, detail=str(exc)) from exc
 
 
-async def _build_user_message(chat: ChatRequest, cwd: str) -> ConversationMessage:
+async def _build_user_message(chat: UserInputRequest, cwd: str) -> ConversationMessage:
     if not chat.input:
         text = str(chat.message or "").strip()
         snapshots = await asyncio.to_thread(build_skill_snapshot_blocks, text, cwd)
@@ -143,6 +146,14 @@ async def _build_user_message(chat: ChatRequest, cwd: str) -> ConversationMessag
     return build_message("user", blocks)
 
 
+def _check_input_support(message: ConversationMessage, model: ModelMetadata | RunAgent) -> None:
+    content_types = {b.get("type") for b in (message.get("content") or []) if isinstance(b, dict)}
+    if "image" in content_types and not model.supports_image_input:
+        raise HTTPException(status_code=400, detail="current model does not support image input")
+    if "document" in content_types and not model.supports_pdf_input:
+        raise HTTPException(status_code=400, detail="current model does not support PDF input")
+
+
 def _validate_rewind_request(
     *,
     session: dict[str, Any] | None,
@@ -192,11 +203,7 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep) -> ChatR
         model=resolved.model,
         model_config=model_config,
     )
-    content_types = {b.get("type") for b in (user_message.get("content") or []) if isinstance(b, dict)}
-    if "image" in content_types and not model_meta.supports_image_input:
-        raise HTTPException(status_code=400, detail="current model does not support image input")
-    if "document" in content_types and not model_meta.supports_pdf_input:
-        raise HTTPException(status_code=400, detail="current model does not support PDF input")
+    _check_input_support(user_message, model_meta)
 
     reasoning_effort = resolved.reasoning_effort
     if "reasoning_effort" in chat.model_fields_set:
@@ -274,10 +281,11 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep) -> ChatR
         try:
             run = await runs.start_run(
                 session_id=session_id,
+                cwd=cwd,
                 user_message=user_message,
                 base_messages=agent.messages,
                 agent=agent,
-                session_cost_base=await load_session_cost(store, session_id),
+                session_base=await load_session_totals(store, session_id),
             )
         except ActiveRunError as exc:
             existing = await runs.get_run(exc.run_id)
@@ -339,7 +347,7 @@ async def compact_session(
     body: CompactRequest,
     store: StoreDep,
     runs: RunManagerDep,
-) -> CompactResponse:
+) -> RunResponse:
     """Start a compact run: summarize the session and append one compact marker."""
 
     async with runs.session_operation(session_id):
@@ -372,9 +380,10 @@ async def compact_session(
         try:
             run = await runs.start_compact(
                 session_id=session_id,
+                cwd=cwd,
                 base_messages=agent.messages,
                 agent=agent,
-                session_cost_base=data["session_cost"],
+                session_base=data["totals"],
                 on_complete=store.touch,
             )
         except ActiveRunError as exc:
@@ -384,7 +393,86 @@ async def compact_session(
                 detail["run"] = existing.info()
             raise HTTPException(status_code=409, detail=detail) from exc
 
-    return CompactResponse(run=RunInfo.model_validate(run))
+    return RunResponse(run=RunInfo.model_validate(run))
+
+
+@router.post("/runs/{run_id}/steer")
+async def steer_run(
+    run_id: Annotated[str, PathParam(min_length=1)], body: PendingInputRequest, runs: RunManagerDep
+) -> RunResponse:
+    """Hand a user message to the running chat for its next step boundary."""
+
+    state = await runs.get_run(run_id)
+    if state is None:
+        raise HTTPException(status_code=404, detail="run not found")
+    message = await _build_user_message(body, state.cwd)
+    message["meta"] = {"input_id": body.input_id}
+    _check_input_support(message, state.agent)
+    if not state.agent.steer(message):
+        raise HTTPException(
+            status_code=409,
+            detail={"message": "run is not accepting steers", "run": state.info()},
+        )
+    return RunResponse(run=RunInfo.model_validate(state.info()))
+
+
+@router.post("/sessions/{session_id}/queue")
+async def queue_message(
+    session_id: Annotated[str, PathParam(min_length=1)],
+    body: PendingInputRequest,
+    store: StoreDep,
+    runs: RunManagerDep,
+) -> RunResponse:
+    """Queue a user message as the next turn of the session's running chat."""
+
+    state = await runs.get_active_run(session_id)
+    if state is None:
+        raise HTTPException(status_code=409, detail={"message": "session has no running chat to queue on"})
+    message = await _build_user_message(body, state.cwd)
+    message["meta"] = {"input_id": body.input_id}
+    _check_input_support(message, state.agent)
+    if not await runs.enqueue(state, message):
+        raise HTTPException(status_code=409, detail={"message": "session has no running chat to queue on"})
+    await store.record_user_turn(
+        session_id,
+        cwd=state.cwd,
+        text=flatten_message_text(message, include_thinking=False),
+    )
+    return RunResponse(run=RunInfo.model_validate(state.info()))
+
+
+@router.delete("/sessions/{session_id}/queue/{input_id}")
+async def remove_queued_message(
+    session_id: Annotated[str, PathParam(min_length=1)],
+    input_id: Annotated[str, PathParam(min_length=1)],
+    runs: RunManagerDep,
+) -> RunResponse:
+    """Remove a queued message that has not been delivered."""
+
+    run = await runs.remove_queued(session_id, input_id)
+    if run is None:
+        raise HTTPException(status_code=404, detail="queued message not found")
+    return RunResponse(run=RunInfo.model_validate(run))
+
+
+@router.post("/sessions/{session_id}/queue/{input_id}/steer")
+async def steer_queued_message(
+    session_id: Annotated[str, PathParam(min_length=1)],
+    input_id: Annotated[str, PathParam(min_length=1)],
+    runs: RunManagerDep,
+) -> RunResponse:
+    """Move a queued message into the current turn, keeping it as built."""
+
+    state = await runs.get_active_run(session_id)
+    moved = None if state is None else await runs.steer_queued(state, input_id)
+    if state is None or moved is None:
+        raise HTTPException(status_code=404, detail="queued message not found")
+    if not moved:
+        raise HTTPException(
+            status_code=409,
+            detail={"message": "run is not accepting steers", "run": state.info()},
+        )
+    return RunResponse(run=RunInfo.model_validate(state.info()))
 
 
 @router.get("/config")
@@ -454,6 +542,10 @@ async def get_config(cwd: Annotated[str | None, Query()] = None) -> dict[str, An
         "cwd_exists": os.path.isdir(resolved_cwd),
         "project": settings.project,
         "config_paths": settings.config_paths,
+        # Effective for this cwd; 0 disables automatic compaction.
+        "compact_threshold": (
+            settings.compact_threshold if settings.compact_threshold is not None else DEFAULT_COMPACT_THRESHOLD
+        ),
         "skills": [{"name": skill.name, "description": skill.description} for skill in skills],
         "setup_error": setup_error,
     }

mycode_cli/server/routers/sessions.py

@@ -11,6 +11,7 @@ from fastapi import Path as PathParam
 from mycode.messages import ConversationMessage
 from mycode_cli.server.deps import RunManagerDep, StoreDep, resolve_workspace_cwd
 from mycode_cli.server.schemas import SessionCreateRequest, StatusResponse
+from mycode_cli.sessions import SessionTotals
 
 router = APIRouter(prefix="/sessions", tags=["sessions"])
 
@@ -50,6 +51,21 @@ async def list_sessions(
     return {"sessions": sessions}
 
 
+@router.get("/search")
+async def search_sessions(
+    store: StoreDep,
+    runs: RunManagerDep,
+    q: Annotated[str, Query(min_length=1)],
+    cwd: Annotated[str | None, Query()] = None,
+    limit: Annotated[int, Query(ge=1)] = 50,
+) -> dict[str, Any]:
+    results = await store.search_sessions(q, cwd=cwd, limit=limit)
+    for result in results:
+        session = result["session"]
+        session["is_running"] = await runs.has_active_run(str(session["id"]))
+    return {"results": results}
+
+
 @router.get("/{session_id}")
 async def load_session(
     session_id: Annotated[str, PathParam(min_length=1)], store: StoreDep, runs: RunManagerDep
@@ -62,22 +78,31 @@ async def load_session(
             return {
                 "session": await store.load_metadata(session_id),
                 "messages": _redact_document_data(active["messages"]),
-                "session_cost": active["session_cost"],
+                **active["totals"].payload(),
                 "active_run": active["run"],
                 "pending_events": active["pending_events"],
+                "pending": {kind: _redact_document_data(messages) for kind, messages in active["pending"].items()},
             }
 
         data = await store.load_session(session_id)
 
     if data is None:
-        return {"session": None, "messages": [], "session_cost": None, "active_run": None, "pending_events": []}
+        return {
+            "session": None,
+            "messages": [],
+            **SessionTotals().payload(),
+            "active_run": None,
+            "pending_events": [],
+            "pending": {"steers": [], "queue": []},
+        }
 
     return {
         "session": data["session"],
         "messages": _redact_document_data(data["messages"]),
-        "session_cost": data["session_cost"],
+        **data["totals"].payload(),
         "active_run": None,
         "pending_events": [],
+        "pending": {"steers": [], "queue": []},
     }
 
 
@@ -90,14 +115,3 @@ async def delete_session(
             raise HTTPException(status_code=409, detail="session has a running task")
         await store.delete_session(session_id)
     return StatusResponse(status="ok")
-
-
-@router.post("/{session_id}/clear")
-async def clear_session(
-    session_id: Annotated[str, PathParam(min_length=1)], store: StoreDep, runs: RunManagerDep
-) -> StatusResponse:
-    async with runs.session_operation(session_id):
-        if await runs.has_active_run(session_id):
-            raise HTTPException(status_code=409, detail="session has a running task")
-        await store.clear_session(session_id)
-    return StatusResponse(status="ok")

mycode_cli/server/run_manager.py

@@ -8,15 +8,15 @@ import time
 from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable
 from contextlib import aclosing, asynccontextmanager
 from dataclasses import dataclass, field
+from functools import partial
 from typing import Any, Literal, Protocol
 from uuid import uuid4
 from weakref import WeakValueDictionary
 
-from mycode.agent import Event
-from mycode.messages import ConversationMessage
+from mycode.agent import Event, PersistCallback
+from mycode.messages import ConversationMessage, merge_user_messages
 from mycode_cli.permissions import ToolReviewDecision
-from mycode_cli.runtime import sum_known_costs
-from mycode_cli.sessions import sum_session_cost
+from mycode_cli.sessions import SessionTotals, sum_session_totals
 
 RunStatus = Literal["running", "completed", "failed", "cancelled"]
 RunKind = Literal["chat", "compact"]
@@ -44,10 +44,18 @@ class ActiveRunError(RuntimeError):
 class RunAgent(Protocol):
     model: str
     context_window: int
+    supports_image_input: bool
+    supports_pdf_input: bool
 
     def cancel(self) -> None: ...
 
-    def achat(self, user_input: str | ConversationMessage) -> AsyncGenerator[Event, None]: ...
+    def steer(self, message: ConversationMessage) -> bool: ...
+
+    def pending_steers(self) -> list[ConversationMessage]: ...
+
+    def achat(
+        self, user_input: str | ConversationMessage, *, on_persist: PersistCallback | None = None
+    ) -> AsyncGenerator[Event, None]: ...
 
     def acompact(self) -> Awaitable[ConversationMessage]: ...
 
@@ -58,13 +66,25 @@ class RunState:
 
     id: str
     session_id: str
+    cwd: str
     base_messages: list[ConversationMessage]
     agent: RunAgent
     kind: RunKind = "chat"
     user_message: ConversationMessage | None = None
-    # Fixed history cost, combined with cumulative turn costs on each update.
-    session_cost_base: float | None = None
-    session_cost: float | None = None
+    # Queued messages the current turn continues from, until their merged
+    # message is announced; snapshots list them as still queued.
+    delivering: list[ConversationMessage] = field(default_factory=list)
+    # Messages for the next turn of a chat run, each carrying ``meta.input_id``.
+    queue: list[ConversationMessage] = field(default_factory=list)
+    # Messages the run committed, and how far snapshots return them as history:
+    # through the last committed user message, whose events end at
+    # ``history_seq``. The events after it rebuild the rest, as on the live stream.
+    committed: list[ConversationMessage] = field(default_factory=list)
+    history_len: int = 0
+    history_seq: int = 0
+    # Pre-run history totals, combined with the cumulative turn totals on each update.
+    session_base: SessionTotals = field(default_factory=SessionTotals)
+    session_totals: SessionTotals = field(default_factory=SessionTotals)
     on_complete: RunCompletionCallback | None = None
     status: RunStatus = "running"
     error: str | None = None
@@ -105,36 +125,40 @@ class RunManager:
         self,
         *,
         session_id: str,
+        cwd: str,
         user_message: ConversationMessage,
         base_messages: list[ConversationMessage],
         agent: RunAgent,
-        session_cost_base: float | None = None,
+        session_base: SessionTotals | None = None,
     ) -> dict[str, Any]:
         return await self._start(
             session_id=session_id,
+            cwd=cwd,
             kind="chat",
             user_message=user_message,
             base_messages=base_messages,
             agent=agent,
-            session_cost_base=session_cost_base,
+            session_base=session_base,
         )
 
     async def start_compact(
         self,
         *,
         session_id: str,
+        cwd: str,
         base_messages: list[ConversationMessage],
         agent: RunAgent,
-        session_cost_base: float | None = None,
+        session_base: SessionTotals | None = None,
         on_complete: RunCompletionCallback | None = None,
     ) -> dict[str, Any]:
         return await self._start(
             session_id=session_id,
+            cwd=cwd,
             kind="compact",
             user_message=None,
             base_messages=base_messages,
             agent=agent,
-            session_cost_base=session_cost_base,
+            session_base=session_base,
             on_complete=on_complete,
         )
 
@@ -142,14 +166,16 @@ class RunManager:
         self,
         *,
         session_id: str,
+        cwd: str,
         kind: RunKind,
         user_message: ConversationMessage | None,
         base_messages: list[ConversationMessage],
         agent: RunAgent,
-        session_cost_base: float | None = None,
+        session_base: SessionTotals | None = None,
         on_complete: RunCompletionCallback | None = None,
     ) -> dict[str, Any]:
         await self._prune_finished_runs()
+        session_base = session_base or SessionTotals()
 
         async with self._lock:
             existing = self._active_by_session.get(session_id)
@@ -159,10 +185,11 @@ class RunManager:
             state = RunState(
                 id=uuid4().hex,
                 session_id=session_id,
+                cwd=cwd,
                 kind=kind,
                 user_message=copy.deepcopy(user_message),
-                session_cost_base=session_cost_base,
-                session_cost=session_cost_base,
+                session_base=session_base,
+                session_totals=session_base,
                 base_messages=copy.deepcopy(base_messages),
                 agent=agent,
                 on_complete=on_complete,
@@ -177,6 +204,52 @@ class RunManager:
         async with self._lock:
             return self._runs_by_id.get(run_id)
 
+    async def get_active_run(self, session_id: str) -> RunState | None:
+        async with self._lock:
+            return self._active_by_session.get(session_id)
+
+    async def enqueue(self, state: RunState, message: ConversationMessage) -> bool:
+        """Queue a message for the next turn of an active chat run."""
+
+        async with self._lock:
+            if (
+                state.kind != "chat"
+                or state.cancel_requested
+                or self._active_by_session.get(state.session_id) is not state
+            ):
+                return False
+            state.queue.append(copy.deepcopy(message))
+            return True
+
+    async def remove_queued(self, session_id: str, input_id: str) -> dict[str, Any] | None:
+        """Remove one pending queued message; returns the run, or ``None`` when it is not pending."""
+
+        async with self._lock:
+            state = self._active_by_session.get(session_id)
+            if state is None:
+                return None
+            for index, message in enumerate(state.queue):
+                if (message.get("meta") or {}).get("input_id") == input_id:
+                    del state.queue[index]
+                    return state.info()
+            return None
+
+    async def steer_queued(self, state: RunState, input_id: str) -> bool | None:
+        """Move one queued message to the run's steers.
+
+        Returns ``None`` when it is not pending, ``False`` when the run is not
+        accepting steers (the message stays queued).
+        """
+
+        async with self._lock:
+            for index, message in enumerate(state.queue):
+                if (message.get("meta") or {}).get("input_id") == input_id:
+                    if not state.agent.steer(message):
+                        return False
+                    del state.queue[index]
+                    return True
+            return None
+
     async def snapshot_session(self, session_id: str) -> dict[str, Any] | None:
         """Return a reconnect snapshot for the active session."""
 
@@ -189,14 +262,19 @@ class RunManager:
         async with state.condition:
             if state.status != "running":
                 return None
-            messages = copy.deepcopy(state.base_messages)
-            if state.user_message is not None:
-                messages.append(copy.deepcopy(state.user_message))
+            history = state.committed[: state.history_len]
+            if not history and state.user_message is not None:
+                # Not committed yet: the input still leads the turn.
+                history = [state.user_message]
             return {
                 "run": state.info(),
-                "messages": messages,
-                "pending_events": list(state.events),
-                "session_cost": state.session_cost,
+                "messages": copy.deepcopy(state.base_messages + history),
+                "pending_events": [event for event in state.events if event["seq"] > state.history_seq],
+                "pending": {
+                    "steers": copy.deepcopy(state.agent.pending_steers()),
+                    "queue": copy.deepcopy(state.delivering + state.queue),
+                },
+                "totals": state.session_totals,
             }
 
     @asynccontextmanager
@@ -371,20 +449,49 @@ class RunManager:
                 if state.on_complete is not None:
                     await state.on_complete(state.session_id)
                 await self._append_event(
-                    state, Event("compact", {"trigger": "manual"}), compact_cost=sum_session_cost([marker])
+                    state, Event("compact", {"trigger": "manual"}), compact_totals=sum_session_totals([marker])
                 )
             else:
                 assert state.user_message is not None
-                async with aclosing(state.agent.achat(state.user_message)) as stream:
-                    async for event in stream:
-                        if event.type == "retry":
-                            continue
-                        if event.type == "error":
-                            last_error = str(event.data.get("message") or "unknown error")
-                        elif event.type == "cancelled":
-                            cancelled = True
-                            continue
-                        await self._append_event(state, event)
+                message = state.user_message
+                on_persist = partial(self._record_commit, state)
+                while True:
+                    async with aclosing(state.agent.achat(message, on_persist=on_persist)) as stream:
+                        async for event in stream:
+                            # achat() commits its user message before its first
+                            # event, so a queued turn is announced only once it
+                            # is in the session; a failed commit reaches the
+                            # client as an error with nothing delivered.
+                            if state.delivering:
+                                await self._append_event(state, Event("user_message", {"message": message}))
+                                state.delivering = []
+                            if event.type == "retry":
+                                continue
+                            if event.type == "error":
+                                last_error = str(event.data.get("message") or "unknown error")
+                            elif event.type == "cancelled":
+                                cancelled = True
+                                continue
+                            await self._append_event(state, event)
+                    if last_error is not None or cancelled:
+                        break
+                    # Stop requests and enqueue() run on this loop, so they land
+                    # either before this hold or once the next achat() has its
+                    # run: a stop after the take still ends the queued turn.
+                    async with self._lock:
+                        queued, state.queue = state.queue, []
+                        # A stop drops the queue; the client restores its items.
+                        if state.cancel_requested:
+                            break
+                        if not queued:
+                            # Leaving the active map with the final take means
+                            # no later enqueue is accepted and then dropped.
+                            if self._active_by_session.get(state.session_id) is state:
+                                del self._active_by_session[state.session_id]
+                            break
+                        # The queued turn continues on the same agent and model.
+                        state.delivering = queued
+                        message = merge_user_messages(queued, steer=False)
         except asyncio.CancelledError:
             # Manual compaction and external task cancellation both end the run.
             cancelled = True
@@ -405,23 +512,37 @@ class RunManager:
 
         await self._finish_run(state, status="completed")
 
-    async def _append_event(self, state: RunState, event: Event, *, compact_cost: float | None = None) -> None:
+    async def _record_commit(self, state: RunState, message: ConversationMessage) -> None:
+        async with state.condition:
+            state.committed.append(message)
+            # A steer or queued message enters history with its user_message
+            # event, which clients apply as the start of its segment.
+            if message.get("role") == "user" and "input_ids" not in (message.get("meta") or {}):
+                state.history_len = len(state.committed)
+                state.history_seq = state.next_seq - 1
+
+    async def _append_event(
+        self, state: RunState, event: Event, *, compact_totals: SessionTotals | None = None
+    ) -> None:
         async with state.condition:
-            if event.type == "usage":
-                turn_cost = event.data.get("turn_cost")
-                turn_total = turn_cost.get("total") if isinstance(turn_cost, dict) else None
-                state.session_cost = sum_known_costs(state.session_cost_base, turn_total)
+            if event.type == "user_message":
+                # A delivered steer or queued turn starts a new usage segment.
+                state.session_base = state.session_totals
+                state.history_len = len(state.committed)
+                state.history_seq = state.next_seq
+            elif event.type == "usage":
+                state.session_totals = state.session_base.add(event.data.get("turn_usage"), event.data.get("turn_cost"))
                 event = Event(
                     "usage",
                     {
                         **event.data,
                         "context_window": state.agent.context_window,
                         "model": state.agent.model,
-                        "session_cost": state.session_cost,
+                        **state.session_totals.payload(),
                     },
                 )
-            elif event.type == "compact" and state.kind == "compact":
-                state.session_cost = sum_known_costs(state.session_cost_base, compact_cost)
+            elif event.type == "compact" and compact_totals is not None:
+                state.session_totals = state.session_base.add(compact_totals.usage, compact_totals.cost)
 
             if event.type == "tool_done":
                 tool_use_id = event.data.get("tool_use_id")