hermes_state_worker_compression.py 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477
  1. """Closed compression operations on the worker receipt's connection.
  2. No handler opens a connection or invokes a self-committing SessionDB method.
  3. """
  4. from typing import Any, Dict, List, Optional
  5. import json
  6. from functools import partial
  7. import math
  8. import time
  9. from hermes_state_runtime import RuntimeStoreError, _text
  10. from hermes_state_compression import _claim_lease_row
  11. def _fields(payload, required, optional=()):
  12. if not isinstance(payload, dict) or set(payload) - set(required) - set(optional) or set(required) - set(payload):
  13. raise RuntimeStoreError('invalid_params')
  14. def _number(value):
  15. if type(value) not in (int, float) or not math.isfinite(value):
  16. raise RuntimeStoreError('invalid_params')
  17. return value
  18. def worker_compression_lock(db, conn, sid, payload, *, action):
  19. if action == 'holder':
  20. _fields(payload, ())
  21. row = conn.execute('SELECT holder FROM compression_locks WHERE session_id=? AND expires_at>?',
  22. (sid, time.time())).fetchone()
  23. return {'value': row[0] if row else None}
  24. _fields(payload, ('holder',), () if action == 'release' else ('ttl_seconds',))
  25. holder = _text(payload['holder'])
  26. now = time.time()
  27. ttl = _number(payload.get('ttl_seconds', 300.0))
  28. if not 0.1 <= ttl <= 3600:
  29. raise RuntimeStoreError('invalid_params')
  30. if action == 'acquire':
  31. from hermes_state import _compression_lock_holder_process_is_dead
  32. value = _claim_lease_row(conn, 'compression_locks', 'session_id', sid, holder, now, now + ttl,
  33. lambda h, e: e < now or _compression_lock_holder_process_is_dead(h))[0]
  34. elif action == 'renew':
  35. value = conn.execute('UPDATE compression_locks SET expires_at=? WHERE session_id=? AND holder=?',
  36. (now + ttl, sid, holder)).rowcount > 0
  37. else:
  38. conn.execute('DELETE FROM compression_locks WHERE session_id=? AND holder=?', (sid, holder))
  39. value = None
  40. return {'value': value}
  41. def worker_cooldown_record(db, conn, sid, payload):
  42. _fields(payload, ('cooldown_until', 'error'))
  43. deadline = _number(payload['cooldown_until'])
  44. error = payload['error']
  45. if error is not None and not isinstance(error, str):
  46. raise RuntimeStoreError('invalid_params')
  47. conn.execute('UPDATE sessions SET compression_failure_cooldown_until = CASE '
  48. 'WHEN compression_failure_cooldown_until IS NOT NULL AND compression_failure_cooldown_until > ? '
  49. 'THEN compression_failure_cooldown_until ELSE ? END, compression_failure_error=? WHERE id=?',
  50. (deadline, deadline, error, sid))
  51. return {'value': None}
  52. def worker_cooldown_restore(db, conn, sid, payload):
  53. _fields(payload, ('snapshot',))
  54. snapshot = payload['snapshot']
  55. _fields(snapshot, ('session_exists', 'cooldown_until', 'error'))
  56. if type(snapshot['session_exists']) is not bool:
  57. raise RuntimeStoreError('invalid_params')
  58. if not snapshot['session_exists']:
  59. raise RuntimeError('cannot restore absent compression cooldown row: session now exists')
  60. deadline, error = snapshot['cooldown_until'], snapshot['error']
  61. if deadline is not None:
  62. _number(deadline)
  63. if error is not None and not isinstance(error, str):
  64. raise RuntimeStoreError('invalid_params')
  65. conn.execute('UPDATE sessions SET compression_failure_cooldown_until=?, compression_failure_error=? WHERE id=?',
  66. (deadline, error, sid))
  67. actual = conn.execute('SELECT compression_failure_cooldown_until,compression_failure_error FROM sessions WHERE id=?',
  68. (sid,)).fetchone()
  69. if actual is None or tuple(actual) != (deadline, error):
  70. raise RuntimeError('compression cooldown rollback verification failed')
  71. return {'value': None}
  72. def worker_cooldown_clear(db, conn, sid, payload):
  73. _fields(payload, ())
  74. return worker_cooldown_restore(db, conn, sid, {'snapshot': {
  75. 'session_exists': True, 'cooldown_until': None, 'error': None}})
  76. def worker_compression_counter(db, conn, sid, payload, *, column):
  77. _fields(payload, ('value',))
  78. value = payload['value']
  79. if value is not None:
  80. _number(value)
  81. if column != 'compression_recovery_deadline' and (type(value) is not int or value < 0):
  82. raise RuntimeStoreError('invalid_params')
  83. conn.execute(f'UPDATE sessions SET {column}=? WHERE id=?', (value, sid))
  84. return {'value': None}
  85. class CompressionSnapshot:
  86. """Reuse production read algorithms on the receipt connection, never a second handle.
  87. Only read primitives are provided; this object cannot start/commit a write.
  88. Wire handlers below select concrete projections, not caller-named methods.
  89. """
  90. from hermes_state_compression import SessionCompressionMixin as _C
  91. from hermes_state_messages import SessionMessagesMixin as _M
  92. from hermes_state_sessions import SessionSessionsMixin as _S
  93. get_compression_chain = _C.get_compression_chain
  94. get_compression_tip = _C.get_compression_tip
  95. get_compression_lineage = _C.get_compression_lineage
  96. _is_compression_child_row = _C._is_compression_child_row
  97. _session_lineage_root_to_tip = _S._session_lineage_root_to_tip
  98. _is_explicit_branch_session = _S._is_explicit_branch_session
  99. declared_scope_identity = _S.declared_scope_identity
  100. _resume_lineage_ids = _M._resume_lineage_ids
  101. get_conversation_root = _M.get_conversation_root
  102. resolve_resume_session_id = _M.resolve_resume_session_id
  103. latest_conversation_boundary = _M.latest_conversation_boundary
  104. _is_explicit_fork_child_row = _M._is_explicit_fork_child_row
  105. def __init__(self, db, conn):
  106. self.db, self.conn = db, conn
  107. def _read_ctx(self):
  108. from contextlib import nullcontext
  109. return nullcontext(self.conn)
  110. def _read_one(self, sql, params=()):
  111. return self.conn.execute(sql, params).fetchone()
  112. def _read_all(self, sql, params=()):
  113. return self.conn.execute(sql, params).fetchall()
  114. def get_session(self, sid):
  115. from hermes_state_worker_context import worker_context
  116. return worker_context(self.db, self.conn, sid, {})['session']
  117. def authorize(self, assigned, target):
  118. _text(target)
  119. # Attribution ancestry is readable; unrelated siblings and foreign trees are not.
  120. allowed = self._session_lineage_root_to_tip(assigned)
  121. allowed += self.get_compression_chain(assigned)
  122. if target not in allowed:
  123. raise RuntimeStoreError('permission_denied')
  124. def worker_lineage_context(db, conn, sid, payload):
  125. _fields(payload, ('target',))
  126. view = CompressionSnapshot(db, conn)
  127. target = payload['target']
  128. view.authorize(sid, target)
  129. return {'session': view.get_session(target)}
  130. def worker_lineage(db, conn, sid, payload):
  131. _fields(payload, ('target',))
  132. view = CompressionSnapshot(db, conn)
  133. target = payload['target']
  134. view.authorize(sid, target)
  135. return {'readable_ids': view._session_lineage_root_to_tip(sid) + view.get_compression_chain(sid),
  136. 'lineage': view.get_compression_lineage(target),
  137. 'root': view.get_conversation_root(target),
  138. 'tip': view.get_compression_tip(target),
  139. 'resume': view.resolve_resume_session_id(target),
  140. 'identity': view.declared_scope_identity(target)}
  141. def worker_boundary(db, conn, sid, payload):
  142. _fields(payload, ('session_key', 'source'))
  143. view = CompressionSnapshot(db, conn)
  144. row = view.get_session(sid)
  145. if (row['session_key'], row['source']) != (payload['session_key'], payload['source']):
  146. raise RuntimeStoreError('permission_denied')
  147. return {'value': view.latest_conversation_boundary(payload['session_key'], payload['source'])}
  148. def worker_history(db, conn, sid, payload):
  149. _fields(payload, ('target', 'include_ancestors', 'include_inactive', 'repair_alternation',
  150. 'include_row_ids', 'include_compacted'))
  151. if any(type(v) is not bool for k, v in payload.items() if k != 'target'):
  152. raise RuntimeStoreError('invalid_params')
  153. view = CompressionSnapshot(db, conn)
  154. target = payload['target']
  155. view.authorize(sid, target)
  156. ids = view._resume_lineage_ids(target) if payload['include_ancestors'] else [target]
  157. active = db._active_clause(payload['include_inactive'], payload['include_compacted'])
  158. display = payload['include_compacted'] and not payload['include_inactive']
  159. rows = conn.execute(f'SELECT {"session_id, compacted, display_order, " if display else ""}{db._CONVERSATION_ROW_COLUMNS} FROM messages '
  160. f'WHERE session_id IN ({",".join("?" for _ in ids)}){active} ORDER BY id', ids).fetchall()
  161. if display: # the owner's display reads' rule: a message whose newest copy was removed stays hidden
  162. from hermes_state_messages import SessionMessagesMixin
  163. rows = SessionMessagesMixin._with_removed_identities(view, rows, ids)
  164. if payload['include_compacted']:
  165. rows = db._dedupe_display_generations(rows, drop_removed=display)
  166. return {'messages': db._rows_to_conversation(rows, session_id=target,
  167. include_ancestors=payload['include_ancestors'], repair_alternation=payload['repair_alternation'],
  168. include_row_ids=payload['include_row_ids'])}
  169. def archive_on_connection(db, conn, session_id: str, compacted_messages: list[dict[str, Any]], model_config_patch: Optional[dict[str, Any]]=None, watermark: Optional[int]=None, lock_holder: Optional[str]=None, tail_count: int=0, carried_messages: Optional[list[dict[str, Any]]]=None, covered_ids: Optional[list[int]]=None, unresolved_held: Optional[list[dict[str, Any]]]=None, held_for_cas: Optional[list[dict[str, Any]]]=None):
  170. # The owner's in-place compaction body, on this receipt's connection: one implementation, so
  171. # main's coverage/merge/timestamp/display-order fixes reach worker and mutation verbs too.
  172. return db._archive_and_compact_on_conn(conn, session_id, compacted_messages,
  173. model_config_patch=model_config_patch, watermark=watermark, lock_holder=lock_holder,
  174. tail_count=tail_count, carried_messages=carried_messages, covered_ids=covered_ids,
  175. unresolved_held=unresolved_held, held_for_cas=held_for_cas)
  176. def publish_on_connection(db, conn, *, parent_session_id: str, child_session_id: str, source: str, messages: list[dict[str, Any]], model: str | None=None, model_config: dict[str, Any] | None=None, system_prompt: str | None=None, cwd: str | None=None, profile_name: str | None=None, compression_lock_holder: str | None=None, require_compression_lease: bool=True, require_lease_refresh: bool=False, lease_ttl_seconds: float=300.0, watermark: Optional[int]=None, watermark_ceiling: Optional[int]=None):
  177. # The owner's rotation body (lease, closure, child row, timestamps, tail clone, local target,
  178. # auto-archive lift) on this receipt's connection, so the two paths cannot drift.
  179. db._publish_compression_child_on_conn(conn, parent_session_id=parent_session_id,
  180. child_session_id=child_session_id, source=source, messages=messages, model=model,
  181. model_config=model_config, system_prompt=system_prompt, cwd=cwd, profile_name=profile_name,
  182. compression_lock_holder=compression_lock_holder, require_compression_lease=require_compression_lease,
  183. require_lease_refresh=require_lease_refresh, lease_ttl_seconds=lease_ttl_seconds,
  184. watermark=watermark, watermark_ceiling=watermark_ceiling)
  185. def worker_watermark(db, conn, sid, payload):
  186. _fields(payload, ())
  187. return {'value': conn.execute('SELECT COALESCE(MAX(id),0) FROM messages WHERE session_id=? AND active=1',
  188. (sid,)).fetchone()[0]}
  189. def _handoff_messages(conn, sid, messages):
  190. from hermes_state_runtime import HANDOFF_MESSAGE_FIELDS
  191. if not isinstance(messages, list) or len(messages) > 1000:
  192. raise RuntimeStoreError('invalid_params')
  193. for msg in messages:
  194. if not isinstance(msg, dict) or set(msg) - HANDOFF_MESSAGE_FIELDS or msg.get('role') not in ('user', 'assistant', 'system', 'tool'):
  195. raise RuntimeStoreError('invalid_params')
  196. if '_row_id' in msg and not conn.execute('SELECT 1 FROM messages WHERE session_id=? AND id=?',
  197. (sid, msg['_row_id'])).fetchone():
  198. raise RuntimeStoreError('permission_denied')
  199. def _watermarks(payload):
  200. for field in ('watermark', 'watermark_ceiling'):
  201. value = payload.get(field)
  202. if value is not None and (type(value) is not int or value < 0):
  203. raise RuntimeStoreError('invalid_params')
  204. def worker_archive(db, conn, sid, payload):
  205. from hermes_state_worker_context import SIDECAR_KEYS
  206. _fields(payload, ('messages', 'model_config_patch', 'watermark', 'lock_holder', 'tail_count'),
  207. optional=('carried_messages', 'covered_ids', 'unresolved_held', 'held_for_cas'))
  208. _handoff_messages(conn, sid, payload['messages'])
  209. carried = payload.get('carried_messages') or []
  210. if not isinstance(carried, list) or any(not isinstance(m, dict) for m in carried):
  211. raise RuntimeStoreError('invalid_params')
  212. covered = payload.get('covered_ids')
  213. if covered is not None and (not isinstance(covered, list)
  214. or any(type(i) is not int or i <= 0 for i in covered)):
  215. raise RuntimeStoreError('invalid_params')
  216. unresolved = payload.get('unresolved_held')
  217. if unresolved is not None and (not isinstance(unresolved, list)
  218. or any(not isinstance(m, dict) for m in unresolved)):
  219. raise RuntimeStoreError('invalid_params')
  220. # The lease-less CAS fence (#124102): dicts projected to the closed handoff fields plus the
  221. # persistence marker the owner's compare reads; validated like the other held-row payloads.
  222. cas = payload.get('held_for_cas')
  223. if cas is not None and (not isinstance(cas, list)
  224. or any(not isinstance(m, dict) for m in cas)):
  225. raise RuntimeStoreError('invalid_params')
  226. _watermarks(payload)
  227. # Micro-compaction and proactive prune archive in place without a lease, like the owner path.
  228. if payload['lock_holder'] is not None:
  229. _text(payload['lock_holder'])
  230. patch = payload['model_config_patch']
  231. if patch is not None and (not isinstance(patch, dict) or set(patch) - SIDECAR_KEYS):
  232. raise RuntimeStoreError('invalid_params')
  233. if type(payload['tail_count']) is not int or payload['tail_count'] < 0:
  234. raise RuntimeStoreError('invalid_params')
  235. value = archive_on_connection(db, conn, sid, payload['messages'], model_config_patch=patch,
  236. watermark=payload['watermark'], lock_holder=payload['lock_holder'], tail_count=payload['tail_count'],
  237. carried_messages=carried, covered_ids=covered, unresolved_held=unresolved, held_for_cas=cas)
  238. from hermes_state_runtime import row_annotations
  239. return {'value': value, 'annotations': row_annotations(payload['messages'])}
  240. def _migrate_worker_automation(db, conn, parent, child):
  241. from hermes_cli.goals import GoalState
  242. from hermes_cli.heartbeat import HeartbeatState
  243. from hermes_cli.loops import LoopState
  244. for family, state_type in (('goal', GoalState), ('heartbeat', HeartbeatState), ('loop', LoopState)):
  245. old_key, new_key = f'{family}:{parent}', f'{family}:{child}'
  246. row = conn.execute('SELECT value FROM state_meta WHERE key=?', (old_key,)).fetchone()
  247. if row is None:
  248. continue
  249. state = state_type.from_json(row[0])
  250. if state.status == 'cleared':
  251. continue
  252. prior = conn.execute('SELECT value FROM state_meta WHERE key=?', (new_key,)).fetchone()
  253. if prior is not None and (family != 'heartbeat' or state_type.from_json(prior[0]).status != 'cleared'):
  254. continue
  255. db.set_meta(new_key, state.to_json(), cursor=conn)
  256. state.status = 'cleared'
  257. db.set_meta(old_key, state.to_json(), cursor=conn)
  258. def worker_publish(db, conn, sid, payload):
  259. from hermes_state_sessions import _parse_model_config
  260. _fields(payload, ('child_session_id', 'source', 'messages', 'model', 'model_config', 'system_prompt',
  261. 'cwd', 'profile_name', 'compression_lock_holder', 'require_compression_lease',
  262. 'require_lease_refresh', 'lease_ttl_seconds', 'watermark', 'watermark_ceiling'))
  263. child = _text(payload['child_session_id'])
  264. _text(payload['compression_lock_holder'])
  265. _watermarks(payload)
  266. if payload['require_compression_lease'] is not True or type(payload['require_lease_refresh']) is not bool:
  267. raise RuntimeStoreError('invalid_params')
  268. if not 0.1 <= _number(payload['lease_ttl_seconds']) <= 3600:
  269. raise RuntimeStoreError('invalid_params')
  270. _handoff_messages(conn, sid, payload['messages'])
  271. parent = CompressionSnapshot(db, conn).get_session(sid)
  272. for key in ('source', 'cwd', 'profile_name'):
  273. if payload[key] is not None and payload[key] != parent[key]:
  274. raise RuntimeStoreError('permission_denied')
  275. for key in ('model', 'system_prompt'):
  276. if payload[key] is not None and not isinstance(payload[key], str):
  277. raise RuntimeStoreError('invalid_params')
  278. cfg = payload['model_config']
  279. if cfg is not None and not isinstance(cfg, dict):
  280. raise RuntimeStoreError('invalid_params')
  281. cfg = dict(cfg or {})
  282. prior = _parse_model_config(parent['model_config'])
  283. for key in ('_branched_from', '_delegate_from', '_reset_from'):
  284. if key in cfg and cfg[key] != prior.get(key):
  285. raise RuntimeStoreError('permission_denied')
  286. if key in prior:
  287. cfg[key] = prior[key]
  288. if conn.execute('SELECT 1 FROM sessions WHERE id=?', (child,)).fetchone():
  289. raise RuntimeStoreError('permission_denied')
  290. worker = conn.execute("SELECT * FROM worker_executions WHERE session_id=? AND status IN ('registered','running')", (sid,)).fetchone()
  291. if worker is None:
  292. raise RuntimeStoreError('stale_generation')
  293. publish_on_connection(db, conn, parent_session_id=sid, **dict(payload, model_config=cfg))
  294. _migrate_worker_automation(db, conn, sid, child)
  295. conn.execute('UPDATE sessions SET runtime_generation=? WHERE id=?', (worker['generation'], child))
  296. conn.execute('UPDATE worker_executions SET session_id=? WHERE execution_id=?', (child, worker['execution_id']))
  297. # The FIFO/retry key is immutable; only physical lineage follows rotation.
  298. conn.execute("UPDATE session_admissions SET lineage_json=json_insert(lineage_json,'$[#]',?) "
  299. "WHERE json_extract(lineage_json,'$[#-1]')=? AND generation=? AND owner_epoch=? "
  300. "AND status IN ('started','unknown')",
  301. (child, sid, worker['generation'], worker['owner_epoch']))
  302. from hermes_state_runtime import row_annotations
  303. return {'value': None, 'worker_assignment': {'parent': sid, 'session_id': child},
  304. 'annotations': row_annotations(payload['messages'])}
  305. def worker_receipt_assignment(conn, execution_id, session_id, generation, sequence, digest):
  306. """Only an identical already-committed publication can retry its old assignment."""
  307. from hermes_state_runtime import _worker_assignment
  308. receipt = conn.execute('SELECT payload_digest,result_json FROM worker_receipts WHERE execution_id=? AND sequence=?',
  309. (execution_id, sequence)).fetchone()
  310. if receipt and receipt['payload_digest'] == digest:
  311. assignment = json.loads(receipt['result_json']).get('worker_assignment')
  312. if assignment and assignment['parent'] == session_id:
  313. current = conn.execute('SELECT session_id FROM worker_executions WHERE execution_id=?', (execution_id,)).fetchone()
  314. return _worker_assignment(conn, execution_id, current['session_id'], generation)
  315. return _worker_assignment(conn, execution_id, session_id, generation)
  316. def worker_claim_origin(db, params):
  317. """Keep the producer claim bound to its original identity after physical rotation."""
  318. with db._read_ctx() as conn:
  319. row = conn.execute("SELECT result_json FROM worker_receipts WHERE execution_id=? "
  320. "AND json_extract(result_json,'$.worker_assignment.parent') IS NOT NULL ORDER BY sequence LIMIT 1",
  321. (params['execution_id'],)).fetchone()
  322. return json.loads(row[0])['worker_assignment']['parent'] if row else params['session_id']
  323. def worker_retry_target(db, params):
  324. """Transport verification accepts old targets only for exact publication replay."""
  325. from hermes_state_keys import admission_fingerprint
  326. if params.get('operation') != 'compression.publish':
  327. return params['session_id']
  328. digest = admission_fingerprint(canonical_target=params['session_id'],
  329. payload={'operation': params['operation'], 'payload': params['payload']})
  330. with db._read_ctx() as conn:
  331. row = worker_receipt_assignment(conn, params['execution_id'], params['session_id'],
  332. params['generation'], params['sequence'], digest)
  333. return row['session_id']
  334. from hermes_state_common import _COMPRESSION_LOCK_ROW_SQL as _LOCK_ROW_SQL, _ENDED_ROW_SQL, _ended_by_compression
  335. def reopen_on_connection(db, conn, session_id):
  336. if not _ended_by_compression(conn.execute(_ENDED_ROW_SQL, (session_id,)).fetchone()):
  337. return False
  338. child = conn.execute('\n SELECT 1\n FROM sessions\n WHERE parent_session_id = ?\n ' + db._NON_CONTINUATION_CHILD_FILTER_SQL.format(alias='') + '\n LIMIT 1\n ', (session_id,) * 4).fetchone()
  339. if child is not None:
  340. return False
  341. now = time.time()
  342. lock_row = conn.execute(_LOCK_ROW_SQL, (session_id,)).fetchone()
  343. if lock_row is not None:
  344. expires_at = lock_row['expires_at']
  345. if expires_at is None or float(expires_at) >= now:
  346. return False
  347. deleted = conn.execute('DELETE FROM compression_locks WHERE session_id = ? AND holder = ? AND expires_at = ?', (session_id, lock_row['holder'], expires_at))
  348. if deleted.rowcount != 1:
  349. return False
  350. updated = conn.execute("UPDATE sessions SET ended_at = NULL, end_reason = NULL WHERE id = ? AND ended_at IS NOT NULL AND end_reason = 'compression'", (session_id,))
  351. return updated.rowcount == 1
  352. def worker_reopen(db, conn, sid, payload):
  353. _fields(payload, ())
  354. return {'value': reopen_on_connection(db, conn, sid)}
  355. def worker_compression_cleanup(db, conn, sid, payload):
  356. _fields(payload, ('target', 'holder'))
  357. target = _text(payload['target'])
  358. holder = _text(payload['holder'])
  359. view = CompressionSnapshot(db, conn)
  360. view.authorize(sid, target)
  361. if db._session_turn_lease_key_on_conn(conn, sid) != db._session_turn_lease_key_on_conn(conn, target):
  362. raise RuntimeStoreError('permission_denied')
  363. conn.execute('DELETE FROM compression_locks WHERE session_id=? AND holder=?', (target, holder))
  364. return {'value': None}
  365. def worker_compression_append(db, conn, sid, payload):
  366. _fields(payload, ('messages', 'compression_lock_holder', 'turn_lease_holder', 'turn_lease_ttl_seconds'))
  367. _handoff_messages(conn, sid, payload['messages'])
  368. for key in ('compression_lock_holder', 'turn_lease_holder'):
  369. if payload[key] is not None:
  370. _text(payload[key])
  371. if not 0.1 <= _number(payload['turn_lease_ttl_seconds']) <= 3600:
  372. raise RuntimeStoreError('invalid_params')
  373. count = db._append_messages_in_transaction(conn, sid, **payload)
  374. from hermes_state_runtime import row_annotations
  375. return {'count': count, 'annotations': row_annotations(payload['messages'])}
  376. def worker_turn_cleanup(db, conn, sid, payload):
  377. _fields(payload, ('target', 'holder'))
  378. target = _text(payload['target'])
  379. holder = _text(payload['holder'])
  380. CompressionSnapshot(db, conn).authorize(sid, target)
  381. key = db._session_turn_lease_key_on_conn(conn, sid)
  382. if key != db._session_turn_lease_key_on_conn(conn, target):
  383. raise RuntimeStoreError('permission_denied')
  384. conn.execute('DELETE FROM session_turn_leases WHERE conversation_id=? AND holder=?', (key, holder))
  385. return {'released': True}
  386. WORKER_COMPRESSION_HANDLERS = {
  387. 'turn.cleanup': worker_turn_cleanup,
  388. 'compression.append': worker_compression_append,
  389. 'compression.reopen': worker_reopen,
  390. 'compression.cleanup': worker_compression_cleanup,
  391. 'compression.watermark': worker_watermark,
  392. 'compression.archive': worker_archive,
  393. 'compression.publish': worker_publish,
  394. 'compression.context': worker_lineage_context,
  395. 'compression.lineage': worker_lineage,
  396. 'compression.boundary': worker_boundary,
  397. 'compression.history': worker_history,
  398. **{'compression.lock.' + action: partial(worker_compression_lock, action=action)
  399. for action in ('acquire', 'renew', 'release', 'holder')},
  400. 'compression.cooldown.record': worker_cooldown_record,
  401. 'compression.cooldown.restore': worker_cooldown_restore,
  402. 'compression.cooldown.clear': worker_cooldown_clear,
  403. **{'compression.' + name: partial(worker_compression_counter, column=column)
  404. for name, column in (('fallback', 'compression_fallback_streak'),
  405. ('ineffective', 'compression_ineffective_count'),
  406. ('recovery', 'compression_recovery_deadline'))},
  407. }