hermes_state_mutation_prepared.py 9.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166
  1. """Optimistic preparation snapshots revalidated inside the receipt transaction."""
  2. import json
  3. from hermes_state_local import POLICY_PREFIX
  4. from hermes_state_local_lineage import validate_local_lineage
  5. from hermes_state_mutation_guards import require_target_advanceable
  6. from hermes_state_runtime import RuntimeStoreError
  7. # A model pick made while a turn ran, committed at the next turn boundary (gateway/session_deferred_pick.py).
  8. DEFERRED_PICK_PREFIX = 'gateway.deferred_pick.v1.'
  9. def local_snapshot(db, conn, session_id):
  10. row = conn.execute('SELECT value FROM state_meta WHERE key=?', (POLICY_PREFIX + session_id,)).fetchone()
  11. if row is None:
  12. raise RuntimeStoreError('runtime_coordination_required')
  13. saved = json.loads(row[0])
  14. target = validate_local_lineage(conn, saved)
  15. require_target_advanceable(db, conn, list({session_id, target}))
  16. revision = conn.execute('SELECT runtime_revision FROM sessions WHERE id=?', (target,)).fetchone()[0]
  17. return {'receipt': saved, 'target': target, 'target_revision': revision}
  18. def validate_prepared(db, conn, session_id, prepared):
  19. if not isinstance(prepared, dict) or 'snapshot' not in prepared:
  20. raise RuntimeStoreError('runtime_coordination_required')
  21. current = local_snapshot(db, conn, session_id)
  22. if current != prepared['snapshot']:
  23. raise RuntimeStoreError('revision_conflict')
  24. return current
  25. def _commit_policy(db, conn, session_id, prepared):
  26. """Write the prepared policy over the snapshot it was derived from and bump the generation."""
  27. from hermes_state_runtime import _json
  28. snapshot = validate_prepared(db, conn, session_id, prepared)
  29. saved = snapshot['receipt']
  30. saved['policy'] = prepared['policy']
  31. conn.execute('UPDATE state_meta SET value=? WHERE key=?', (_json(saved), POLICY_PREFIX + session_id))
  32. conn.execute('UPDATE sessions SET runtime_generation=runtime_generation+1 WHERE id=?', (session_id,))
  33. generation = conn.execute('SELECT runtime_generation FROM sessions WHERE id=?', (session_id,)).fetchone()[0]
  34. return snapshot, generation
  35. def model_in_transaction(db, conn, session_id, payload, prepared):
  36. from hermes_state_runtime import _json
  37. snapshot, generation = _commit_policy(db, conn, session_id, prepared)
  38. model = prepared['policy']['model']
  39. config = json.loads(prepared['policy']['config_json'])['model']
  40. target = snapshot['target']
  41. # Keep the transcript and cached prompt byte-stable; the explicit model switch
  42. # is a client/provider boundary, not an implicit reload of launch defaults.
  43. row = conn.execute('SELECT model_config FROM sessions WHERE id=?', (target,)).fetchone()
  44. model_config = json.loads(row[0] or '{}')
  45. model_config['provider'] = config['provider']
  46. conn.execute('UPDATE sessions SET model=?,model_config=? WHERE id=?', (model, _json(model_config), target))
  47. # This selection is newer than any model pick still waiting for a turn boundary: that pick is superseded.
  48. # A level deferred beside it stays unless this selection carries its own, as defer_pick keeps it.
  49. key = DEFERRED_PICK_PREFIX + session_id
  50. row = conn.execute('SELECT value FROM state_meta WHERE key=?', (key,)).fetchone()
  51. level = json.loads(row[0]).get('reasoning') if row is not None and 'reasoning' not in payload else None
  52. if level is None:
  53. conn.execute('DELETE FROM state_meta WHERE key=?', (key,))
  54. else:
  55. conn.execute('UPDATE state_meta SET value=? WHERE key=?', (_json({'reasoning': level}), key))
  56. return {session_id, target}, {'model': model, 'provider': config['provider'], 'execution_generation': generation,
  57. **({'effort': payload['reasoning']} if 'reasoning' in payload else {})}
  58. def reasoning_in_transaction(db, conn, session_id, payload, prepared):
  59. from hermes_state_runtime import _json
  60. snapshot, generation = _commit_policy(db, conn, session_id, prepared)
  61. # This level is newer than any still waiting for a turn boundary, beside or inside a deferred model pick.
  62. key = DEFERRED_PICK_PREFIX + session_id
  63. row = conn.execute('SELECT value FROM state_meta WHERE key=?', (key,)).fetchone()
  64. if row is not None:
  65. pick = json.loads(row[0])
  66. pick.pop('reasoning', None)
  67. pick.get('payload', {}).pop('reasoning', None)
  68. if 'application_id' in pick:
  69. conn.execute('UPDATE state_meta SET value=? WHERE key=?', (_json(pick), key))
  70. else:
  71. conn.execute('DELETE FROM state_meta WHERE key=?', (key,))
  72. return {session_id, snapshot['target']}, {'effort': payload['effort'], 'execution_generation': generation}
  73. def workspace_in_transaction(db, conn, session_id, payload, prepared):
  74. """The policy (execution cwd + TERMINAL_CWD) and every row of the conversation move together:
  75. the sidebar groups by the row's cwd/git identity, which a move REPLACES (main's update_session_cwd
  76. with replace_git_meta), never merges."""
  77. from hermes_state_local import local_conversation_ids
  78. snapshot, generation = _commit_policy(db, conn, session_id, prepared)
  79. cwd, git = prepared['policy']['cwd'], prepared['git']
  80. rows = list(dict.fromkeys([*local_conversation_ids(conn, session_id), snapshot['target']]))
  81. conn.executemany('UPDATE sessions SET cwd=?, git_branch=?, git_repo_root=?, '
  82. 'git_metadata_generation=COALESCE(git_metadata_generation, 0)+1 WHERE id=?',
  83. [(cwd, git['branch'] or None, git['root'] or None, sid) for sid in rows])
  84. return {session_id, snapshot['target']}, {'cwd': cwd, 'branch': git['branch'] or None,
  85. 'git_repo_root': git['root'] or None, 'execution_generation': generation}
  86. def editor_mcp_in_transaction(db, conn, session_id, payload, prepared):
  87. snapshot, generation = _commit_policy(db, conn, session_id, prepared)
  88. return {session_id, snapshot['target']}, {'tools_changed': prepared['tools_changed'],
  89. 'mcp_servers': prepared['mcp_servers'], 'execution_generation': generation}
  90. def edit_policy_in_transaction(db, conn, session_id, payload, prepared):
  91. snapshot, generation = _commit_policy(db, conn, session_id, prepared)
  92. return {session_id, snapshot['target']}, {'edit_approval_policy': payload['policy'],
  93. 'execution_generation': generation}
  94. POLICY_HANDLERS = {'model': model_in_transaction, 'reasoning': reasoning_in_transaction,
  95. 'workspace': workspace_in_transaction, 'editor_mcp': editor_mcp_in_transaction,
  96. 'edit_policy': edit_policy_in_transaction}
  97. _RECEIPTS = "FROM state_meta WHERE key GLOB 'gateway.mutation.v1.*' AND json_valid(value) "
  98. def picks_on(conn, session_id, before=None):
  99. """The policy edits (``model``, ``reasoning``, ``workspace``) a ``session.mutate`` committed for *session_id* (below
  100. revision *before*): their receipts (kept for exact retries, also past deletion) are the durable record of
  101. the user's pick. A deferred ``/model`` (``status: deferred``) is only a request until a turn boundary
  102. applies it under a receipt of its own, so it is no pick. A branch copied its parent's policy, picks
  103. included, under its own id: its local receipt's ``picks``; a branch stored before that field has its
  104. parent's as they stood at its branch."""
  105. bound = '' if before is None else " AND json_extract(value, '$.result.revision')<?"
  106. picked = {row[0] for row in conn.execute(
  107. "SELECT DISTINCT json_extract(value, '$.result.operation') " + _RECEIPTS +
  108. "AND json_extract(value, '$.result.operation') IN ('model', 'reasoning', 'workspace') "
  109. "AND COALESCE(json_extract(value, '$.result.status'), '') != 'deferred' "
  110. "AND json_extract(value, '$.result.session_id')=?" + bound, (session_id, *(() if before is None else (before,))))}
  111. saved = conn.execute('SELECT value FROM state_meta WHERE key=?', (POLICY_PREFIX + session_id,)).fetchone()
  112. if saved is None:
  113. return picked
  114. if 'picks' in (receipt := json.loads(saved[0])):
  115. return picked | set(receipt['picks'])
  116. # The parent's branch receipt names this session and the parent's revision the branch committed at.
  117. branched = conn.execute(
  118. "SELECT json_extract(value, '$.result.session_id'), json_extract(value, '$.result.revision') " + _RECEIPTS +
  119. "AND json_extract(value, '$.result.operation')='branch' "
  120. "AND json_extract(value, '$.result.branched_session_id')=?", (session_id,)).fetchone()
  121. return picked | picks_on(conn, *branched) if branched else picked
  122. def policy_picks(db, session_id):
  123. with db._read_ctx() as conn:
  124. return picks_on(conn, session_id)
  125. def commit_refreshed_policy(db, *, epoch, session_id, old, new, generation):
  126. """The owner's config refresh of an idle session: *new* replaces exactly *old* at *generation* (a
  127. concurrent mutation or turn wins) and opens the next policy generation. Returns that generation."""
  128. from hermes_state_mutation_guards import require_idle
  129. from hermes_state_runtime import _epoch
  130. def write(conn):
  131. _epoch(conn, epoch)
  132. snapshot = local_snapshot(db, conn, session_id)
  133. require_idle(db, conn, list({session_id, snapshot['target']}))
  134. current = conn.execute('SELECT runtime_generation FROM sessions WHERE id=?', (session_id,)).fetchone()
  135. if snapshot['receipt']['policy'] != old or current is None or current[0] != generation:
  136. raise RuntimeStoreError('revision_conflict')
  137. return _commit_policy(db, conn, session_id, {'snapshot': snapshot, 'policy': new})[1]
  138. return db._execute_write(write)