runtime_session_compression.py 8.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159
  1. """Concrete worker compression APIs; scope and receipts stay in RuntimeSessionStore."""
  2. def _handoff_rows(messages):
  3. """Project live compaction dicts onto the owner's closed handoff fields.
  4. Micro-compaction and proactive prune hand over the live list, whose dicts carry worker-local
  5. bookkeeping (``_db_persisted``, ``_micro_compact_marker``, a tool row's wire ``name``, risk tags)
  6. that SessionDB's insert simply never reads. The owner's boundary stays closed; sending those keys
  7. would fail the receipt and leave the journal stuck pending, refusing every later write.
  8. """
  9. from hermes_state_runtime import HANDOFF_MESSAGE_FIELDS
  10. return [{k: v for k, v in m.items() if k in HANDOFF_MESSAGE_FIELDS} if isinstance(m, dict) else m
  11. for m in messages]
  12. class RuntimeSessionCompressionMixin:
  13. def _append_compression_messages(self, session_id, messages, compression_lock_holder,
  14. turn_lease_holder, turn_lease_ttl_seconds):
  15. self._session(session_id)
  16. result = self._apply('compression.append', dict(messages=messages,
  17. compression_lock_holder=compression_lock_holder, turn_lease_holder=turn_lease_holder,
  18. turn_lease_ttl_seconds=turn_lease_ttl_seconds))
  19. from agent.runtime_session_store import apply_row_annotations
  20. apply_row_annotations(messages, result['annotations'])
  21. return result['count']
  22. def get_session(self, session_id):
  23. if session_id != self.scope['session_id']:
  24. from agent.runtime_session_store import WorkerPersistenceError
  25. ids = self._apply('compression.lineage', {'target': self.scope['session_id']})['readable_ids']
  26. if session_id not in ids:
  27. raise WorkerPersistenceError('permission_denied')
  28. return self._apply('compression.context', {'target': session_id})['session']
  29. def get_compression_lineage(self, session_id):
  30. return self._apply('compression.lineage', {'target': session_id})['lineage']
  31. def get_conversation_root(self, session_id):
  32. return self._apply('compression.lineage', {'target': session_id})['root']
  33. def get_compression_tip(self, session_id):
  34. return self._apply('compression.lineage', {'target': session_id})['tip']
  35. def resolve_resume_session_id(self, session_id):
  36. return self._apply('compression.lineage', {'target': session_id})['resume']
  37. def declared_scope_identity(self, session_id):
  38. return tuple(self._apply('compression.lineage', {'target': session_id})['identity'])
  39. def is_explicit_fork_child(self, session_id):
  40. return self.declared_scope_identity(session_id)[0]
  41. def latest_conversation_boundary(self, session_key, source):
  42. return self._apply('compression.boundary', {'session_key': session_key, 'source': source})['value']
  43. def get_messages_as_conversation(self, session_id, include_ancestors=False, include_inactive=False,
  44. repair_alternation=False, include_row_ids=False, include_compacted=False):
  45. return self._apply('compression.history', dict(target=session_id, include_ancestors=include_ancestors,
  46. include_inactive=include_inactive, repair_alternation=repair_alternation,
  47. include_row_ids=include_row_ids, include_compacted=include_compacted))['messages']
  48. def get_active_message_watermark(self, session_id):
  49. self._session(session_id)
  50. return self._apply('compression.watermark', {})['value']
  51. def archive_and_compact(self, session_id, compacted_messages, model_config_patch=None,
  52. watermark=None, lock_holder=None, tail_count=0, carried_messages=None,
  53. covered_ids=None, unresolved_held=None, held_for_cas=None):
  54. self._session(session_id)
  55. # A carried message names an exact durable original (its _row_id) to rewind rather than
  56. # archive (#118900); the owner resolves identities against its own store. Held-row
  57. # coverage travels the same way: the owner proves it inside the commit transaction.
  58. carried = [dict(m) for m in carried_messages or [] if isinstance(m, dict)]
  59. unresolved = None if unresolved_held is None else [dict(m) for m in unresolved_held if isinstance(m, dict)]
  60. # The lease-less staleness fence (#124102): the owner re-verifies the caller's held rows
  61. # inside its commit transaction. The projection keeps the closed handoff fields plus the
  62. # persistence marker the CAS compare reads; anything else stays worker-local.
  63. from hermes_state_runtime import HANDOFF_MESSAGE_FIELDS
  64. cas = None if held_for_cas is None else [
  65. {k: v for k, v in m.items()
  66. if k in HANDOFF_MESSAGE_FIELDS or k == '_db_persisted'}
  67. for m in held_for_cas if isinstance(m, dict)]
  68. result = self._apply('compression.archive', dict(messages=_handoff_rows(compacted_messages),
  69. model_config_patch=model_config_patch, watermark=watermark, lock_holder=lock_holder,
  70. tail_count=tail_count, carried_messages=carried, covered_ids=covered_ids,
  71. unresolved_held=unresolved, held_for_cas=cas))
  72. from agent.runtime_session_store import apply_row_annotations
  73. apply_row_annotations(compacted_messages, result['annotations'])
  74. return result['value']
  75. def publish_compression_child(self, *, parent_session_id, child_session_id, source, messages,
  76. model=None, model_config=None, system_prompt=None, cwd=None, profile_name=None,
  77. compression_lock_holder=None, require_compression_lease=True, require_lease_refresh=False,
  78. lease_ttl_seconds=300.0, watermark=None, watermark_ceiling=None):
  79. self._session(parent_session_id)
  80. result = self._apply('compression.publish', dict(child_session_id=child_session_id, source=source,
  81. messages=_handoff_rows(messages), model=model, model_config=model_config, system_prompt=system_prompt,
  82. cwd=cwd, profile_name=profile_name, compression_lock_holder=compression_lock_holder,
  83. require_compression_lease=require_compression_lease, require_lease_refresh=require_lease_refresh,
  84. lease_ttl_seconds=lease_ttl_seconds, watermark=watermark, watermark_ceiling=watermark_ceiling))
  85. from agent.runtime_session_store import apply_row_annotations
  86. apply_row_annotations(messages, result['annotations'])
  87. def _compression_receipt_journal(self, candidate, result):
  88. assignment = result.get('worker_assignment')
  89. if assignment:
  90. from agent.runtime_session_store import WorkerPersistenceError
  91. if assignment['parent'] != self.scope['session_id']:
  92. raise WorkerPersistenceError('outbox_scope_mismatch')
  93. candidate = dict(candidate, scope=dict(self.scope, session_id=assignment['session_id']))
  94. return candidate
  95. def try_acquire_compression_lock(self, session_id, holder, ttl_seconds=300.0):
  96. self._session(session_id)
  97. return self._apply('compression.lock.acquire', {'holder': holder, 'ttl_seconds': ttl_seconds})['value']
  98. def refresh_compression_lock(self, session_id, holder, ttl_seconds=300.0):
  99. self._session(session_id)
  100. return self._apply('compression.lock.renew', {'holder': holder, 'ttl_seconds': ttl_seconds})['value']
  101. def reopen_orphaned_compression_session(self, session_id):
  102. self._session(session_id)
  103. return self._apply('compression.reopen', {})['value']
  104. def release_compression_lock(self, session_id, holder):
  105. self._apply('compression.cleanup', {'target': session_id, 'holder': holder})
  106. def get_compression_lock_holder(self, session_id):
  107. self._session(session_id)
  108. return self._apply('compression.lock.holder', {})['value']
  109. def record_compression_failure_cooldown(self, session_id, cooldown_until, error=None):
  110. self._session(session_id)
  111. self._apply('compression.cooldown.record', {'cooldown_until': cooldown_until, 'error': error})
  112. def restore_compression_failure_cooldown_row(self, session_id, snapshot):
  113. self._session(session_id)
  114. self._apply('compression.cooldown.restore', {'snapshot': snapshot})
  115. def clear_compression_failure_cooldown(self, session_id):
  116. self._session(session_id)
  117. self._apply('compression.cooldown.clear', {})
  118. def set_compression_fallback_streak(self, session_id, streak):
  119. self._session(session_id)
  120. self._apply('compression.fallback', {'value': max(0, int(streak))})
  121. def set_compression_ineffective_count(self, session_id, count):
  122. self._session(session_id)
  123. self._apply('compression.ineffective', {'value': max(0, int(count))})
  124. def set_compression_recovery_deadline(self, session_id, deadline):
  125. self._session(session_id)
  126. try:
  127. value = max(0.0, float(deadline or 0.0))
  128. except (TypeError, ValueError):
  129. value = 0.0
  130. self._apply('compression.recovery', {'value': value or None})