hermes_state_local_lineage.py 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193
  1. """Local physical-target handoff inside the existing publication transaction.
  2. The creation ID remains the admission/execution owner. Transcript rotation must
  3. not re-key idempotency digests, queued inputs, subscribers or uncertain claims.
  4. """
  5. import json
  6. import time
  7. from hermes_state_local import POLICY_PREFIX
  8. from hermes_state_runtime import RuntimeStoreError, _epoch, _json
  9. import itertools
  10. def validate_local_lineage(conn, receipt):
  11. from hermes_state_compression import _CHAIN_STEP_SQL
  12. from hermes_state_keys import local_identity
  13. if ('legacy_session_id' not in receipt and
  14. receipt['session_id'] != local_identity(receipt['profile_id'], receipt['principal_id'], receipt['request_id'])):
  15. raise RuntimeStoreError('storage_unavailable')
  16. from hermes_state_local_migration import legacy_lineage_root
  17. root = legacy_lineage_root(conn, receipt)
  18. lineage = receipt.get('lineage', [root])
  19. if (not isinstance(lineage, list) or not lineage or len(set(lineage)) != len(lineage)
  20. or lineage[0] != root or lineage[-1] != receipt['entry']['session_id']):
  21. raise RuntimeStoreError('storage_unavailable')
  22. for parent_id, child_id in itertools.pairwise(lineage):
  23. parent = conn.execute('SELECT end_reason FROM sessions WHERE id=?', (parent_id,)).fetchone()
  24. child = conn.execute('SELECT parent_session_id,model_config FROM sessions WHERE id=?', (child_id,)).fetchone()
  25. if parent is None or child is None or child['parent_session_id'] != parent_id:
  26. raise RuntimeStoreError('storage_unavailable')
  27. if parent['end_reason'] == 'session_reset':
  28. valid = json.loads(child['model_config'] or '{}').get('_reset_from') == parent_id
  29. else:
  30. tip = conn.execute(_CHAIN_STEP_SQL, (parent_id,)).fetchone()
  31. valid = parent['end_reason'] == 'compression' and tip is not None and tip['id'] == child_id
  32. if not valid:
  33. raise RuntimeStoreError('storage_unavailable')
  34. if conn.execute(_CHAIN_STEP_SQL, (lineage[-1],)).fetchone() is not None:
  35. raise RuntimeStoreError('storage_unavailable')
  36. return lineage[-1]
  37. def local_physical_target(conn, session_id):
  38. """Resolve a local owner's current transcript on the caller's transaction."""
  39. saved = conn.execute('SELECT value FROM state_meta WHERE key=?',
  40. (POLICY_PREFIX + session_id,)).fetchone()
  41. if saved is None:
  42. return session_id
  43. receipt = json.loads(saved[0])
  44. if receipt['session_id'] != session_id:
  45. raise RuntimeStoreError('storage_unavailable')
  46. return validate_local_lineage(conn, receipt)
  47. def _routed_entry(conn, route, tip):
  48. """*route*'s routing entry while it still targets *tip*, else None."""
  49. row = conn.execute("SELECT entry_json FROM gateway_routing WHERE scope='' AND session_key=?", (route,)).fetchone()
  50. routed = json.loads(row[0]) if row else None
  51. return routed if routed is not None and routed['session_id'] == tip else None
  52. def _commit_local_target(conn, receipt, routed):
  53. """Store *receipt* and its route's entry *routed* and bump the logical revision, in one transaction."""
  54. conn.execute("UPDATE gateway_routing SET entry_json=? WHERE scope='' AND session_key=?",
  55. (_json(routed), receipt['route']))
  56. conn.execute('UPDATE state_meta SET value=? WHERE key=?', (_json(receipt), POLICY_PREFIX + receipt['session_id']))
  57. conn.execute('UPDATE sessions SET runtime_revision=runtime_revision+1 WHERE id=?', (receipt['session_id'],))
  58. def advance_local_target(conn, parent_session_id, child_session_id, *, entry=None):
  59. parent = conn.execute('SELECT * FROM sessions WHERE id=?', (parent_session_id,)).fetchone()
  60. logical_id = parent['chat_id'] if parent else None
  61. if not logical_id:
  62. return
  63. key = POLICY_PREFIX + logical_id
  64. raw = conn.execute('SELECT value FROM state_meta WHERE key=?', (key,)).fetchone()
  65. if raw is None:
  66. from hermes_state_local_migration import LEGACY_PREFIX
  67. legacy = conn.execute('SELECT 1 FROM state_meta WHERE key=?', (LEGACY_PREFIX + logical_id,)).fetchone()
  68. if logical_id.startswith('local-') or legacy:
  69. raise RuntimeStoreError('storage_unavailable')
  70. return
  71. try:
  72. receipt = json.loads(raw[0])
  73. if (receipt['session_id'] != logical_id or receipt['entry']['session_id'] != parent_session_id
  74. or receipt['principal_id'] != parent['user_id'] or receipt['route'] != parent['session_key']):
  75. raise RuntimeStoreError('storage_unavailable')
  76. routed = _routed_entry(conn, receipt['route'], parent_session_id)
  77. if routed is None:
  78. raise RuntimeStoreError('admission_conflict')
  79. candidate = dict(entry or routed, session_id=child_session_id)
  80. receipt['entry'] = candidate
  81. receipt['lineage'] = [*receipt.get('lineage', [logical_id]), child_session_id]
  82. validate_local_lineage(conn, receipt)
  83. except (KeyError, TypeError, ValueError) as exc:
  84. if isinstance(exc, RuntimeStoreError):
  85. raise
  86. raise RuntimeStoreError('storage_unavailable') from exc
  87. _commit_local_target(conn, receipt, candidate)
  88. def _untracked_steps(conn, tip, lineage):
  89. """Every compression step past *tip*, in order; None when the chain leads back into itself.
  90. One ``_walk_compression_chain`` stops after ``_CHAIN_CAP`` steps, which is not the end of the
  91. chain: walk on from the last step until a walk finds nothing more. Each batch only adds ids never
  92. seen, so the walk ends; a step back into the lineage or an earlier batch is a cycle.
  93. """
  94. from hermes_state_compression import _CHAIN_STEP_SQL, _walk_compression_chain
  95. steps, seen, current = [], {*lineage, tip}, tip
  96. while True:
  97. batch = _walk_compression_chain(current, lambda sid: conn.execute(_CHAIN_STEP_SQL, (sid,)).fetchone())[1:]
  98. if not batch:
  99. return steps
  100. if seen.intersection(batch):
  101. return None
  102. seen.update(batch)
  103. steps.extend(batch)
  104. current = batch[-1]
  105. def adoptable_compression(conn, receipt):
  106. """``(steps, routed)``: the untracked compression steps *receipt* would adopt and its route's
  107. entry, else None. Read-only; ``adopt_untracked_compression`` repeats it inside its write."""
  108. tip = receipt['entry']['session_id']
  109. children = _untracked_steps(conn, tip, receipt.get('lineage', [receipt['session_id']]))
  110. if not children:
  111. return None
  112. identity = (receipt['route'], receipt['session_id'], receipt['principal_id'])
  113. for child_id in children:
  114. child = conn.execute('SELECT session_key,chat_id,user_id FROM sessions WHERE id=?', (child_id,)).fetchone()
  115. if tuple(child) != identity:
  116. return None
  117. routed = _routed_entry(conn, receipt['route'], tip)
  118. return (children, routed) if routed is not None else None
  119. def adopt_untracked_compression(db, *, epoch, session_id, expected):
  120. """Record, once, compression steps a receipt-unaware build published past the receipt's tip.
  121. 0.22.2 (the classic line) resumes a 0.22.1 local session by id. Its compaction ends the tip with
  122. ``compression`` and copies the parent's route columns onto the child, but never advances the
  123. receipt, so ``validate_local_lineage`` refused the session forever (#140060). On this owner a
  124. compaction advances the receipt in its own transaction, so such a step comes only from an older
  125. writer. A child carrying the receipt's own route, owner and principal is that session's
  126. continuation: append it to the lineage and move the receipt's and the routing entry's target to
  127. it, nothing else. The stored receipt must still be *expected*, the copy the caller checked
  128. against its owner. Anything else is left for validation to refuse, unchanged.
  129. """
  130. def write(conn):
  131. _epoch(conn, epoch)
  132. saved = conn.execute('SELECT value FROM state_meta WHERE key=?', (POLICY_PREFIX + session_id,)).fetchone()
  133. receipt = json.loads(saved[0])
  134. if receipt != expected:
  135. return
  136. adoptable = adoptable_compression(conn, receipt)
  137. if adoptable is None:
  138. return
  139. children, routed = adoptable
  140. receipt['entry'] = dict(receipt['entry'], session_id=children[-1])
  141. receipt['lineage'] = [*receipt.get('lineage', [session_id]), *children]
  142. validate_local_lineage(conn, receipt)
  143. _commit_local_target(conn, receipt, dict(routed, session_id=children[-1]))
  144. db._execute_write(write)
  145. def reset_local_target(db, *, epoch, parent_session_id, entry):
  146. def write(conn):
  147. _epoch(conn, epoch)
  148. parent = conn.execute('SELECT * FROM sessions WHERE id=?', (parent_session_id,)).fetchone()
  149. if parent is None or parent['end_reason'] == 'compression':
  150. raise RuntimeStoreError('admission_conflict')
  151. saved = conn.execute('SELECT value FROM state_meta WHERE key=?',
  152. (POLICY_PREFIX + parent['chat_id'],)).fetchone()
  153. if saved is None:
  154. raise RuntimeStoreError('storage_unavailable')
  155. receipt = json.loads(saved[0])
  156. logical_id = receipt['session_id']
  157. if validate_local_lineage(conn, receipt) != parent_session_id:
  158. raise RuntimeStoreError('admission_conflict')
  159. from hermes_state_mutation_guards import require_not_executing
  160. require_not_executing(conn, list({logical_id, parent_session_id}))
  161. policy = receipt['policy']
  162. db._publish_child_session_row(conn, parent, parent_session_id=parent_session_id,
  163. child_session_id=entry['session_id'], source=policy['source'], model=policy['model'],
  164. model_config={'_reset_from': parent_session_id}, system_prompt=None,
  165. cwd=policy['cwd'], profile_name=parent['profile_name'])
  166. conn.execute("UPDATE sessions SET ended_at=?,end_reason='session_reset' WHERE id=?",
  167. (time.time(), parent_session_id))
  168. db._bump_conversation_generation(conn, parent_session_id, 'session_reset')
  169. advance_local_target(conn, parent_session_id, entry['session_id'], entry=entry)
  170. conn.execute('UPDATE sessions SET runtime_generation=runtime_generation+1 WHERE id=?', (logical_id,))
  171. db._execute_write(write)