File size: 24,950 Bytes
691dc7c
e99df76
691dc7c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
from __future__ import annotations
"""Conversation rules and staged transcript values, without runtime I/O."""

import uuid
from collections.abc import Mapping, Sequence
from dataclasses import dataclass
from types import MappingProxyType
from typing import Literal, get_args

from free_claude_code.core.json_types import JsonObject

from .models import (
    ACTIVE_RUN_STATUSES,
    CodeCatalog,
    CodeConflictError,
    CodeItem,
    CodeMode,
    CodeNotFoundError,
    CodePrompt,
    CodeRun,
    CodeSession,
    CodeUnavailableError,
    CodeValidationError,
    HarnessEvent,
    ItemUpdate,
    NativeThread,
    NativeTurn,
    PromptRequest,
    RunStatus,
    now_ms,
)


@dataclass(frozen=True, slots=True)
class SessionProgress:
    """Candidate records saved together by the existing progress transaction."""

    session: CodeSession
    run: CodeRun | None = None
    items: tuple[CodeItem, ...] = ()
    prompts: tuple[CodePrompt, ...] = ()


class SessionState:
    def __init__(
        self,
        session: CodeSession,
        run: CodeRun | None,
        items: Sequence[CodeItem],
        prompts: Sequence[CodePrompt],
        runs: Sequence[CodeRun],
        *,
        sequence: int = 0,
    ) -> None:
        self._session = session
        self._run = run
        self._items = {item.id: item for item in items}
        self._prompts = {prompt.id: prompt for prompt in prompts}
        self._runs = {run.id: run for run in runs}
        self._sequence = max(
            sequence, max((item.sequence for item in items), default=0)
        )
        self._dirty: set[str] = set()
        self._dirty_characters = 0
        self._review_generations: dict[str, str] = {}

    @property
    def session(self) -> CodeSession:
        return self._session

    @property
    def run(self) -> CodeRun | None:
        return self._run

    @property
    def items(self) -> Mapping[str, CodeItem]:
        return MappingProxyType(self._items)

    @property
    def prompts(self) -> Mapping[str, CodePrompt]:
        return MappingProxyType(self._prompts)

    @property
    def runs(self) -> Mapping[str, CodeRun]:
        return MappingProxyType(self._runs)

    @property
    def busy(self) -> bool:
        return self._run is not None and self._run.status in ACTIVE_RUN_STATUSES

    @property
    def pending(self) -> bool:
        return any(
            prompt.status in {"pending", "answering"}
            for prompt in self._prompts.values()
        )

    @property
    def pending_items(self) -> tuple[CodeItem, ...]:
        return tuple(self._items[item_id] for item_id in self._dirty)

    @property
    def dirty_characters(self) -> int:
        return self._dirty_characters

    def active_review_ids(self, generation: str | None) -> tuple[str, ...]:
        return tuple(
            item_id
            for item_id, observed in self._review_generations.items()
            if observed == generation
        )

    def clear_review_liveness(self) -> bool:
        changed = bool(self._review_generations)
        self._review_generations.clear()
        return changed

    def accept_session(self, session: CodeSession) -> None:
        self._session = session

    def accept_admission(
        self, session: CodeSession, run: CodeRun, item: CodeItem
    ) -> None:
        self._session, self._run = session, run
        self._runs[run.id] = run
        self._items[item.id] = item
        self._sequence = item.sequence

    def accept_prompt(self, prompt: CodePrompt) -> None:
        self._prompts[prompt.id] = prompt

    def apply_progress(self, progress: SessionProgress) -> None:
        """Install acknowledged records; pending transcript writes stay explicit."""
        self._session = progress.session
        if (run := progress.run) is not None:
            self._runs[run.id] = run
            if self._run is not None and self._run.id == run.id:
                self._run = run
        for item in progress.items:
            self._items[item.id] = item
            self._sequence = max(self._sequence, item.sequence)
        self._prompts.update((prompt.id, prompt) for prompt in progress.prompts)

    def acknowledge_flush(self) -> None:
        """The caller holds serialization through saving the complete pending set."""
        self._dirty.clear()
        self._dirty_characters = 0

    def remember_items(
        self, items: Sequence[CodeItem], runs: Sequence[CodeRun]
    ) -> None:
        """Load durable identities needed by one serialized operation."""
        for item in items:
            self._items.setdefault(item.id, item)
        for run in runs:
            self._runs.setdefault(run.id, run)

    def prune(self) -> None:
        """Release acknowledged history after its events have been published."""
        self._prompts = {
            key: prompt
            for key, prompt in self._prompts.items()
            if prompt.status in {"pending", "answering"}
        }
        pinned = self._dirty | self._prompts.keys() | self._review_generations.keys()
        self._items = {
            key: item
            for key, item in self._items.items()
            if key in pinned
            or (self.busy and self._run and item.run_id == self._run.id)
        }
        run_ids = {item.run_id for item in self._items.values()}
        if self._run is not None:
            run_ids.add(self._run.id)
        self._runs = {key: run for key, run in self._runs.items() if key in run_ids}

    def discard_deleted_history(self) -> None:
        self._items.clear()
        self._prompts.clear()
        self._run = None
        self._runs.clear()

    def check_revision(self, revision: int) -> None:
        if self._session.revision != revision:
            raise CodeConflictError(
                "This session changed. Refresh its state and try again."
            )

    def check_editable(self, revision: int) -> None:
        if self._session.status != "ready":
            raise CodeConflictError(
                "This session changed. Refresh its state and try again."
            )
        self.check_revision(revision)

    @staticmethod
    def validate_settings_fields(changes: JsonObject) -> None:
        if not changes or changes.keys() - {
            "title",
            "model",
            "reasoning_effort",
            "mode",
        }:
            raise CodeValidationError(
                "Choose a title, model, effort or mode to update."
            )

    def settings_updates(self, changes: JsonObject) -> dict[str, object]:
        """Validate local rules before the application obtains model inventory."""
        updates: dict[str, object] = dict(changes)
        if "title" in changes:
            title = changes["title"]
            if not isinstance(title, str) or not title.strip() or len(title) > 200:
                raise CodeValidationError("Enter a title of at most 200 characters.")
            updates.update(title=title.strip(), auto_title=False)
        if changes.keys() & {"model", "reasoning_effort", "mode"} and (
            self.busy or self.pending
        ):
            raise CodeConflictError(
                "Finish this turn and its prompts before changing settings."
            )
        if "mode" in changes and changes["mode"] not in get_args(CodeMode.__value__):
            raise CodeValidationError("Choose an available permission mode.")
        return updates

    def prepare_settings(
        self, updates: dict[str, object], catalog: CodeCatalog | None
    ) -> CodeSession:
        updates = dict(updates)
        if updates.keys() & {"model", "reasoning_effort"}:
            assert catalog is not None
            model = updates.get("model", self._session.model)
            entry = next((entry for entry in catalog.models if entry.id == model), None)
            if entry is None:
                raise CodeValidationError(
                    "This model is unavailable. Choose another model."
                )
            effort = updates.get("reasoning_effort", self._session.reasoning_effort)
            if (
                "reasoning_effort" not in updates
                and model != self._session.model
                and effort not in entry.reasoning_efforts
            ):
                effort = None
            if effort is not None and effort not in entry.reasoning_efforts:
                raise CodeValidationError(
                    "This effort is unavailable. Choose another effort."
                )
            updates.update(model=model, reasoning_effort=effort)
        return _revision(self._session, **updates)

    def check_receipt(self, previous: CodeRun, text: str) -> None:
        if previous.session_id != self._session.id or previous.text != text:
            raise CodeConflictError(
                "This Send ID was already used for a different message."
            )

    def check_can_send(self) -> None:
        if self.busy or self.pending:
            raise CodeConflictError("This session is busy. Your draft has been kept.")

    def prepare_admission(
        self,
        operation_id: str,
        text: str,
        model: str,
        reasoning_effort: str | None,
        mode: CodeMode,
    ) -> tuple[CodeSession, CodeRun, CodeItem]:
        self.check_can_send()
        run = CodeRun(
            id=operation_id,
            session_id=self._session.id,
            text=text,
            model=model,
            reasoning_effort=reasoning_effort,
            mode=mode,
        )
        title = (
            " ".join(text.split())[:80]
            if self._session.auto_title
            else self._session.title
        )
        session = _revision(self._session, title=title, auto_title=False, error=None)
        item = CodeItem(
            id=operation_id,
            session_id=self._session.id,
            sequence=self._sequence + 1,
            run_id=operation_id,
            kind="user",
            text=text,
            complete=True,
        )
        return session, run, item

    def active_run(self, run_id: str) -> CodeRun | None:
        return self._run if self._run and self._run.id == run_id and self.busy else None

    def request_stop(self) -> SessionProgress | None:
        run = self._run
        if run is None or run.stop_requested:
            return None
        return SessionProgress(
            self._session,
            run=run.model_copy(update={"stop_requested": True, "status": "stopping"}),
        )

    def attach_thread(
        self, thread_id: str, permission_defaults: JsonObject | None = None
    ) -> SessionProgress:
        return SessionProgress(
            self._session.model_copy(
                update={
                    "native_thread_id": thread_id,
                    "native_permission_defaults": self._session.native_permission_defaults
                    if self._session.native_permission_defaults is not None
                    else permission_defaults,
                }
            )
        )

    def prepare_submission(self) -> SessionProgress:
        assert self._run is not None
        if self._session.native_permission_defaults is None:
            raise CodeUnavailableError(
                "The harness did not return its permission settings. Your input was not sent."
            )
        return SessionProgress(
            self._session.model_copy(update={"native_may_have_input": True}),
            run=self._run.model_copy(update={"submission_started": True}),
        )

    def bind_turn(self, turn_id: str) -> SessionProgress:
        run = self._run
        assert run is not None
        if run.native_turn_id not in {None, turn_id}:
            raise CodeUnavailableError("Codex returned a different turn identity.")
        return SessionProgress(
            self._session,
            run=run.model_copy(
                update={
                    "native_turn_id": turn_id,
                    "status": "stopping" if run.stop_requested else "running",
                }
            ),
        )

    def accepts_event(self, event: HarnessEvent) -> bool:
        return self._session.status == "ready" and event.thread_id in {
            None,
            self._session.native_thread_id,
        }

    def matches_turn(self, event: HarnessEvent, *, known_turn: bool) -> bool:
        run = self._run
        return bool(
            run is not None
            and self.busy
            and run.submission_started
            and event.turn_id is not None
            and (
                run.native_turn_id == event.turn_id
                or (
                    run.native_turn_id is None
                    and event.kind == "turn_started"
                    and not known_turn
                )
            )
        )

    def context_usage(self, used_tokens: int | None) -> SessionProgress | None:
        if used_tokens is None or used_tokens == self._session.context_used_tokens:
            return None
        return SessionProgress(
            self._session.model_copy(update={"context_used_tokens": used_tokens})
        )

    def match_history(
        self, native: NativeThread, runs: Sequence[CodeRun]
    ) -> tuple[tuple[NativeTurn, CodeRun], ...]:
        saved = {run.id: run for run in runs}
        mapped: dict[str, CodeRun] = {}
        for turn in native.turns:
            identities = {
                item.client_id
                for item in turn.items
                if item.kind == "user" and item.client_id
            }
            candidates = [
                run
                for run in saved.values()
                if run.native_turn_id == turn.id or run.id in identities
            ]
            if len(candidates) > 1 or any(
                identity not in saved for identity in identities
            ):
                raise CodeUnavailableError(
                    "Codex history contains conflicting turn identities. Saved history was retained."
                )
            if candidates:
                run = candidates[0]
                if (
                    not run.submission_started
                    or run.native_turn_id not in {None, turn.id}
                    or run.id in {value.id for value in mapped.values()}
                ):
                    raise CodeUnavailableError(
                        "Codex history could not be matched to its saved turns."
                    )
                mapped[turn.id] = run
        unmatched = [turn for turn in native.turns if turn.id not in mapped]
        pending = [
            run
            for run in saved.values()
            if run.submission_started
            and run.native_turn_id is None
            and run.id not in {value.id for value in mapped.values()}
        ]
        if unmatched:
            if len(unmatched) != 1 or len(pending) != 1:
                raise CodeUnavailableError(
                    "Codex history could not be matched to its saved turns. No input was resent."
                )
            mapped[unmatched[0].id] = pending[0]
        # Recovery fills content and diagnostics, preserving outcomes already settled
        # by restart or connection loss.
        return tuple(
            (
                turn,
                mapped[turn.id].model_copy(
                    update={
                        "native_turn_id": turn.id,
                        "error": mapped[turn.id].error or turn.error,
                        "error_details": mapped[turn.id].error_details
                        or turn.error_details,
                    }
                ),
            )
            for turn in native.turns
        )

    def native_item(self, update: ItemUpdate) -> CodeItem | None:
        return next(
            (
                item
                for item in self._items.values()
                if item.native_turn_id == update.turn_id
                and item.native_item_id == update.item_id
            ),
            None,
        )

    def stage_item(
        self, update: ItemUpdate, run: CodeRun, *, historical: bool = False
    ) -> tuple[CodeItem, bool]:
        existing = self.native_item(update)
        if existing is None and update.kind == "user":
            if update.client_id is not None and update.client_id != run.id:
                raise CodeUnavailableError(
                    "Codex returned a different message identity."
                )
            existing = self._items.get(run.id)
        if existing is not None and existing.run_id != run.id:
            raise CodeUnavailableError(
                "Codex returned output belonging to another turn."
            )
        if existing is None:
            self._sequence += 1
        preserve = bool(historical and existing and existing.complete)
        raw = _merge_source(existing.raw if existing else {}, update.raw, preserve)
        text, detail = update.text, update.detail
        if historical and existing:
            text = (existing.text or text) if preserve else (text or existing.text)
            detail = (
                (existing.detail or detail) if preserve else (detail or existing.detail)
            )
        item = CodeItem(
            id=existing.id if existing else str(uuid.uuid4()),
            session_id=self._session.id,
            sequence=existing.sequence if existing else self._sequence,
            run_id=run.id,
            native_turn_id=update.turn_id,
            native_item_id=update.item_id,
            kind=update.kind,
            title=update.title or (existing.title if existing else ""),
            text=text,
            detail=detail,
            raw=raw,
            complete=update.complete or bool(existing and existing.complete),
        )
        if item == existing:
            return existing, False
        self._items[item.id] = item
        self._dirty.add(item.id)
        self._dirty_characters += abs(
            len(item.text) - (len(existing.text) if existing else 0)
        ) + abs(len(item.detail) - (len(existing.detail) if existing else 0))
        return item, True

    def stage_review(
        self, update: ItemUpdate, generation: str
    ) -> tuple[CodeItem | None, bool]:
        if self._run is None:
            return None, False
        existing = self.native_item(update)
        if existing is not None and existing.complete and not update.complete:
            return None, False
        target = self._runs[existing.run_id] if existing else self._run
        item, changed = self.stage_item(update, target)
        previous = self._review_generations.get(item.id)
        if item.complete:
            self._review_generations.pop(item.id, None)
        else:
            self._review_generations[item.id] = generation
        if previous != self._review_generations.get(item.id):
            # The saved row is reannounced when its connection liveness changes.
            self._dirty.add(item.id)
        return item, changed

    def has_prompt(self, request: PromptRequest, generation: str) -> bool:
        return any(
            prompt.generation == generation and prompt.request_id == request.request_id
            for prompt in self._prompts.values()
        )

    def prepare_prompt(
        self, request: PromptRequest, generation: str
    ) -> SessionProgress:
        if self._run is None:
            raise CodeUnavailableError("Codex returned a prompt without a saved turn.")
        prompt = CodePrompt(
            id=str(uuid.uuid4()),
            session_id=self._session.id,
            generation=generation,
            request_id=request.request_id,
            native_turn_id=request.turn_id,
            native_item_id=request.item_id,
            kind=request.kind,
            form=request.form,
            raw=request.raw,
        )
        item = CodeItem(
            id=prompt.id,
            session_id=self._session.id,
            run_id=self._run.id,
            sequence=self._sequence + 1,
            kind="prompt",
            complete=True,
        )
        return SessionProgress(self._session, items=(item,), prompts=(prompt,))

    def answerable_prompt(
        self, prompt_id: str, response_id: str, generation: str | None
    ) -> CodePrompt:
        prompt = self._prompts.get(prompt_id)
        if prompt is None:
            raise CodeNotFoundError("This prompt no longer exists.")
        if prompt.response_id == response_id:
            return prompt
        if prompt.status != "pending" or prompt.generation != generation:
            raise CodeConflictError(
                "This prompt was already answered or is no longer active."
            )
        return prompt

    def pending_answer(
        self, prompt_id: str, generation: str | None
    ) -> CodePrompt | None:
        current = self._prompts.get(prompt_id)
        return (
            current
            if current is not None
            and current.status == "answering"
            and current.generation == generation
            else None
        )

    def resolve_answer(
        self, prompt_id: str, generation: str | None
    ) -> CodePrompt | None:
        current = self.pending_answer(prompt_id, generation)
        return current.model_copy(update={"status": "resolved"}) if current else None

    def expire_answer(self, prompt_id: str) -> CodePrompt | None:
        current = self._prompts.get(prompt_id)
        return (
            current.model_copy(update={"status": "expired"})
            if current and current.status == "answering"
            else None
        )

    def resolve_request(
        self, request_id: str | int | None, generation: str
    ) -> tuple[CodePrompt, ...]:
        return tuple(
            prompt.model_copy(update={"status": "resolved"})
            for prompt in self._prompts.values()
            if prompt.generation == generation
            and prompt.request_id == request_id
            and prompt.status in {"pending", "answering"}
        )

    def expire_prompts(self) -> tuple[CodePrompt, ...]:
        return tuple(
            prompt.model_copy(update={"status": "expired"})
            for prompt in self._prompts.values()
            if prompt.status in {"pending", "answering"}
        )

    def prepare_notice(self, event: HarnessEvent) -> CodeItem:
        assert self._run is not None
        message = event.message or "Codex reported an error."
        if event.kind == "error" and event.will_retry:
            message = f"Retrying… {message}"
        return CodeItem(
            id=str(uuid.uuid4()),
            session_id=self._session.id,
            sequence=self._sequence + 1,
            run_id=self._run.id,
            kind="notice",
            title="Notice",
            text=message,
            complete=True,
            raw=event.raw,
        )

    def prepare_finish(
        self,
        status: RunStatus,
        message: str | None = None,
        error_details: JsonObject | None = None,
    ) -> SessionProgress | None:
        if self._run is None or not self.busy:
            return None
        run = self._run.model_copy(
            update={
                "status": status,
                "error": message,
                "error_details": error_details or {},
                "finished_at": now_ms(),
            }
        )
        prompts = tuple(
            prompt.model_copy(update={"status": "expired"})
            for prompt in self._prompts.values()
            if prompt.status in {"pending", "answering"}
            and prompt.native_turn_id is not None
            and prompt.native_turn_id == run.native_turn_id
        )
        return SessionProgress(
            _revision(self._session, error=None),
            run=run,
            items=self.pending_items,
            prompts=prompts,
        )

    def prepare_delete(self) -> SessionProgress:
        if self.busy or self.pending:
            raise CodeConflictError(
                "Stop the session and finish its prompts before deleting it."
            )
        return SessionProgress(_revision(self._session, status="deleting", error=None))

    def deletion_failed(
        self, status: Literal["ready", "delete_uncertain"], message: str
    ) -> SessionProgress:
        return SessionProgress(_revision(self._session, status=status, error=message))


def _merge_source(
    previous: JsonObject, current: JsonObject, preserve: bool
) -> JsonObject:
    merged = dict(previous)
    for key, value in current.items():
        existing = merged.get(key)
        if isinstance(existing, dict) and isinstance(value, dict):
            merged[key] = _merge_source(existing, value, preserve)
        elif not preserve or existing in (None, "", [], {}):
            merged[key] = value
    return merged


def _revision(session: CodeSession, **updates: object) -> CodeSession:
    return session.model_copy(
        update={"revision": session.revision + 1, "updated_at": now_ms(), **updates}
    )