"""Exact-retry receipts for a viewer's pick on a messaging chat (gateway/session_messaging_picks.py). A messaging chat has no frozen policy for ``apply_action`` to write: its pick is the chat's own ``/model`` / ``/reasoning`` override. It still answers ``session.mutate`` like a LOCAL pick: the same ``gateway.mutation.v1.*`` receipt key and digest (``mutation_receipt_key``), checked before the override is applied so an exact retry never re-applies it, and committed with the revision bump in one fenced transaction. """ import json from hermes_state_runtime import ( RuntimeStoreError, _epoch, _json, _text, mutation_receipt_key, replay_mutation_receipt, ) def chat_pick_key(principal_id, session_id, params): """``(key, digest)`` of the pick *params* on *session_id* (the mount the fences name).""" for value in (principal_id, session_id, params['request_id']): _text(value) for fence in (params['expected_revision'], params.get('expected_generation')): if type(fence) is not int or fence < 0: raise RuntimeStoreError('invalid_params') payload = json.loads(_json(params['payload'])) key, digest = mutation_receipt_key( principal_id, session_id, params['request_id'], operation=params['operation'], payload=payload, expected_revision=params['expected_revision'], expected_generation=params['expected_generation']) return key, digest def _fenced_row(conn, session_id, params): row = conn.execute('SELECT * FROM sessions WHERE id=?', (session_id,)).fetchone() if row is None: raise RuntimeStoreError('not_found') if row['runtime_revision'] != params['expected_revision']: raise RuntimeStoreError('revision_conflict') if row['runtime_generation'] != params['expected_generation']: raise RuntimeStoreError('stale_generation') return row def prepare_chat_pick(db, *, epoch, key, digest, session_id, params): """The stored receipt of an exact retry (``{'receipt': ...}``), else the fenced mount row (``{'row': ...}``); a reused request id with another payload refuses ``admission_conflict``.""" with db._read_ctx() as conn: _epoch(conn, epoch) replay = replay_mutation_receipt(conn, key, digest) if replay is not None: return {'receipt': replay} return {'row': dict(_fenced_row(conn, session_id, params))} def commit_chat_pick(db, *, epoch, key, digest, session_id, params, result): """Bump the mount's revision and store *result* (plus the new revision) as the receipt, in one write that re-checks the fences. Returns the committed receipt result.""" def write(conn): _epoch(conn, epoch) replay = replay_mutation_receipt(conn, key, digest) if replay is not None: return replay _fenced_row(conn, session_id, params) conn.execute('UPDATE sessions SET runtime_revision=runtime_revision+1 WHERE id=?', (session_id,)) revision = conn.execute('SELECT runtime_revision FROM sessions WHERE id=?', (session_id,)).fetchone()[0] committed = {**result, 'revision': revision} conn.execute('INSERT INTO state_meta(key,value) VALUES(?,?)', (key, _json({'digest': digest, 'result': committed}))) return committed return db._execute_write(write)