| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778 |
- """Messaging ``/retry`` under a session authority: the transcript rewrite commits in the re-sent
- turn's own admission transaction (#139257 step 2, MSG-11).
- ``/retry`` drops the last exchange and re-sends its user text. Rewriting first and admitting
- afterwards loses the turn whenever admission refuses (a drain or retirement that begins after the
- pre-check, a full FIFO). Here the handler only PLANS the rewrite: it reads the transcript, pins the
- active row ids it read, and binds the plan to the re-send. ``admit_native`` takes the binding and
- runs the rewrite as a write guard after its own admission gate and queue cap, in the same
- ``BEGIN IMMEDIATE`` that inserts the row. A refusal rolls both back; a transcript that changed since
- the read refuses both (``RetryRewriteRefused``).
- """
- from __future__ import annotations
- import sqlite3
- from contextvars import ContextVar
- from dataclasses import dataclass, field
- from typing import Any, Callable, Optional
- from hermes_state_runtime import RuntimeStoreError
- _bound: ContextVar[Optional[RetryRewrite]] = ContextVar('retry_rewrite', default=None)
- class RetryRewriteRefused(RuntimeError):
- """The planned rewrite no longer applies (the transcript changed since the read, a turn lease is
- live, the session closed): the re-send was refused with it and nothing was written."""
- @dataclass
- class RetryRewrite:
- """One ``/retry`` rewrite, applied at most once inside the re-send's admission write."""
- db: Any
- session_id: str
- source: Any # the re-send's own SessionSource object: only that admission takes the binding
- write: Callable[[Any], None] # (conn) -> None, inside the admission transaction
- on_commit: Callable[[], None] # on the loop, once the admission that applied it committed
- applied: bool = False
- taken: bool = field(default=False, repr=False)
- def guard(self, conn):
- self.applied = False # the writer may retry the whole transaction
- try:
- self.write(conn)
- except (RuntimeStoreError, sqlite3.OperationalError):
- raise # gate refusals and writer contention keep their own handling
- except Exception as exc:
- raise RetryRewriteRefused(str(exc)) from exc
- self.applied = True
- def bind(rewrite: RetryRewrite):
- return _bound.set(rewrite)
- def unbind(token) -> None:
- _bound.reset(token)
- def take(event, db) -> Optional[RetryRewrite]:
- """The bound rewrite for this native admission, once, and only for the re-send itself (the same
- source object on the same store). A drain task inheriting the context never takes it."""
- rewrite = _bound.get()
- if (rewrite is None or rewrite.taken or getattr(event, 'source', None) is not rewrite.source
- or rewrite.db is not db):
- return None
- rewrite.taken = True
- return rewrite
- def compose(rewrite: Optional[RetryRewrite], authorize):
- """``authorize`` (the admission gate) first, then the rewrite, in one write transaction."""
- if rewrite is None:
- return authorize
- def guard(conn):
- authorize(conn)
- rewrite.guard(conn)
- return guard
|