The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Closed delegation-ledger operations in the existing worker receipt transaction.
The caller must supply the verified registration's execution/PID/birth, never
operation payload identity. No handler opens a database or commits independently.
"""
from functools import partial
import json
import math
import time
from hermes_state_runtime import RuntimeStoreError
_TASK_KEYS = {'goal', 'goals', 'context', 'toolsets', 'role', 'model', 'is_batch', 'task_indexes'}
_ROUTE = {'session_key': 'origin_session', 'parent_session_id': 'parent_session_id',
'origin_ui_session_id': 'origin_ui_session_id', 'origin_session_id': 'origin_session_id'}
_EVENT_KEYS = _TASK_KEYS | set(_ROUTE) | {
'type', 'delegation_id', 'status', 'completed_at', 'dispatched_at', 'summary', 'error',
'api_calls', 'duration_seconds', 'total_duration_seconds', 'results', 'live_transcripts',
'group', 'exit_reason', 'stalled_after_quiet_seconds', 'stall_threshold_seconds',
'stall_phase', 'stall_grace_seconds'}
def _shape(payload, keys):
if not isinstance(payload, dict) or set(payload) != set(keys):
raise RuntimeStoreError('invalid_params')
def _text(value):
if not isinstance(value, str) or not value or len(value) > 512:
raise RuntimeStoreError('invalid_params')
def _number(value):
if type(value) not in (int, float) or not math.isfinite(value) or value < 0:
raise RuntimeStoreError('invalid_params')
def _owned(conn, session_id, execution_id, delegation_id):
_text(delegation_id)
row = conn.execute('SELECT * FROM async_delegations WHERE delegation_id=?', (delegation_id,)).fetchone()
if row is None:
raise RuntimeStoreError('not_found')
if row['parent_session_id'] != session_id or row['owner_execution_id'] != execution_id:
raise RuntimeStoreError('permission_denied')
return row
def _dispatch(db, conn, session_id, payload, *, execution_id, worker_pid, worker_birth):
_shape(payload, {'delegation_id', 'task', 'dispatched_at', *_ROUTE})
_text(payload['delegation_id'])
_number(payload['dispatched_at'])
if not isinstance(payload['task'], dict) or set(payload['task']) - _TASK_KEYS:
raise RuntimeStoreError('invalid_params')
session = conn.execute('SELECT source,session_key FROM sessions WHERE id=?', (session_id,)).fetchone()
# Only compute registrations are currently enabled. Native/child origins need
# an owner-reserved source envelope, not worker-selected transport identities.
if session is None or session['source'] not in ('cli', 'tui', 'gui', 'tool', 'oneshot'):
raise RuntimeStoreError('unsupported_producer')
if (payload['parent_session_id'] != session_id
or payload['session_key'] != (session['session_key'] or '')
or payload['origin_ui_session_id'] not in ('', session_id)
or payload['origin_session_id'] not in ('', session_id)):
raise RuntimeStoreError('permission_denied')
old = conn.execute('SELECT 1 FROM async_delegations WHERE delegation_id=?', (payload['delegation_id'],)).fetchone()
if old is not None:
_owned(conn, session_id, execution_id, payload['delegation_id'])
# Exact network retries are resolved by worker_receipts before this handler.
raise RuntimeStoreError('admission_conflict')
import psutil
from gateway.status import get_process_start_time
try:
from hermes_cli import process_identity
if process_identity.worker_birth(psutil.Process(worker_pid)) != worker_birth:
raise RuntimeStoreError('permission_denied')
owner_started_at = get_process_start_time(worker_pid)
except psutil.Error as exc:
raise RuntimeStoreError('worker_not_live') from exc
now = time.time()
conn.execute('''INSERT INTO async_delegations
(delegation_id,origin_session,origin_ui_session_id,parent_session_id,state,dispatched_at,
updated_at,owner_pid,owner_started_at,task_json,origin_session_id,owner_execution_id)
VALUES(?,?,?,?,'running',?,?,?,?,?,?,?)''',
(payload['delegation_id'], payload['session_key'], payload['origin_ui_session_id'], session_id,
payload['dispatched_at'], now, worker_pid, owner_started_at, json.dumps(payload['task']),
payload['origin_session_id'], execution_id))
return {'value': None}
def _complete(db, conn, session_id, payload, *, execution_id):
_shape(payload, {'event', 'result'})
event = payload['event']
if (not isinstance(event, dict) or set(event) - _EVENT_KEYS
or not isinstance(payload['result'], dict) or event.get('type') != 'async_delegation'
or event.get('status') not in ('completed', 'success', 'error', 'interrupted', 'stalled', 'unknown')):
raise RuntimeStoreError('invalid_params')
row = _owned(conn, session_id, execution_id, event.get('delegation_id'))
if any(event.get(key, '') != (row[column] or '') for key, column in _ROUTE.items()):
raise RuntimeStoreError('permission_denied')
_number(event.get('completed_at'))
if row['state'] != 'running':
raise RuntimeStoreError('admission_conflict')
conn.execute('''UPDATE async_delegations SET state=?,completed_at=?,updated_at=?,event_json=?,result_json=?
WHERE delegation_id=?''', (event['status'], event['completed_at'], time.time(),
json.dumps(event), json.dumps(payload['result']), event['delegation_id']))
return {'value': None}
def _child(db, conn, session_id, payload, *, execution_id):
_shape(payload, {'delegation_id', 'entry'})
row = _owned(conn, session_id, execution_id, payload['delegation_id'])
entry = payload['entry']
if not isinstance(entry, dict) or type(entry.get('task_index')) is not int or entry['task_index'] < 0:
raise RuntimeStoreError('invalid_params')
if row['state'] != 'running':
return {'value': None}
previous = json.loads(row['result_json'] or '{}')
results = [item for item in previous.get('results', []) if item.get('task_index') != entry['task_index']]
results.append(entry)
conn.execute('UPDATE async_delegations SET result_json=?,updated_at=? WHERE delegation_id=?',
(json.dumps({'results': results, 'partial': True}), time.time(), payload['delegation_id']))
return {'value': None}
def _read(db, conn, session_id, payload, *, execution_id):
_shape(payload, {'delegation_id'})
row = _owned(conn, session_id, execution_id, payload['delegation_id'])
return {'value': {key: row[key] for key in ('delegation_id', 'origin_session', 'state', 'dispatched_at',
'completed_at', 'delivery_state', 'delivery_attempts', 'origin_session_id')} |
{'result': json.loads(row['result_json']) if row['result_json'] else None}}
def _claim(db, conn, session_id, payload, *, execution_id):
_shape(payload, {'delegation_id', 'claim_id'})
row = _owned(conn, session_id, execution_id, payload['delegation_id'])
_text(payload['claim_id'])
now = time.time()
if row['state'] in ('running', 'finalizing'):
return {'value': False}
changed = conn.execute('''UPDATE async_delegations SET delivery_claim=?,delivery_claimed_at=?,
delivery_attempts=delivery_attempts+1,updated_at=? WHERE delegation_id=? AND delivery_state='pending'
AND (delivery_claim IS NULL OR delivery_claimed_at < ?)''',
(payload['claim_id'], now, now, payload['delegation_id'], now - 300)).rowcount
return {'value': changed == 1}
_DELIVERY_UPDATES = {
'ack': "delivery_state='delivered',delivered_at=:now",
'drop': "delivery_state='dropped'",
'defer': 'delivery_attempts=MAX(0,delivery_attempts-1)',
'release': "delivery_state=CASE WHEN delivery_attempts>=:cap THEN 'dropped' ELSE delivery_state END",
}
def _delivery(db, conn, session_id, payload, *, execution_id, action):
from tools.async_delegation import _MAX_DELIVERY_ATTEMPTS
_shape(payload, {'delegation_id', 'claim_id'})
_owned(conn, session_id, execution_id, payload['delegation_id'])
_text(payload['claim_id'])
# Only constant, closed statement fragments enter this query.
changed = conn.execute('UPDATE async_delegations SET ' + _DELIVERY_UPDATES[action] +
",updated_at=:now,delivery_claim=NULL,delivery_claimed_at=NULL WHERE delegation_id=:delegation_id "
"AND delivery_state='pending' AND delivery_claim=:claim_id",
payload | {'now': time.time(), 'cap': _MAX_DELIVERY_ATTEMPTS}).rowcount
return {'value': changed == 1}
def _unscheduled(db, conn, session_id, payload, *, execution_id):
_shape(payload, {'delegation_id'})
row = _owned(conn, session_id, execution_id, payload['delegation_id'])
if row['state'] != 'running' or row['result_json'] is not None:
raise RuntimeStoreError('admission_conflict')
conn.execute('DELETE FROM async_delegations WHERE delegation_id=?', (payload['delegation_id'],))
return {'value': None}
def worker_delegation_handlers(execution_id, worker_pid, worker_birth):
"""Register these handlers only after gateway worker identity verification."""
_text(execution_id)
if type(worker_pid) is not int or worker_pid <= 0:
raise RuntimeStoreError('invalid_params')
_number(worker_birth)
handlers = {name: partial(fn, execution_id=execution_id) for name, fn in {
'complete': _complete, 'child': _child, 'read': _read, 'claim': _claim,
'unscheduled': _unscheduled}.items()}
handlers['dispatch'] = partial(_dispatch, execution_id=execution_id, worker_pid=worker_pid, worker_birth=worker_birth)
handlers.update({name: partial(_delivery, execution_id=execution_id, action=name) for name in _DELIVERY_UPDATES})
return {'delegation.' + name: handler for name, handler in handlers.items()}
def persist_worker_delegation(db, *, epoch, execution_id, session_id, generation,
sequence, operation, payload, worker_pid, worker_birth):
"""Closed ledger sibling of mutate_worker_execution, sharing its receipt stream.
Gateway calls this ONLY after its ordinary worker claim verification. The
verified process identity is deliberately separate from the operation payload.
"""
from hermes_state_runtime import apply_worker_receipt
handlers = worker_delegation_handlers(execution_id, worker_pid, worker_birth)
return apply_worker_receipt(db, epoch=epoch, execution_id=execution_id, session_id=session_id,
generation=generation, sequence=sequence, operation=operation,
payload=payload, handlers=handlers)
async def worker_delegation_request(connection, ref, params):
"""worker.persist delegation-family hook; all authentication stays mandatory."""
import asyncio
from gateway.session_worker import _SCOPE, _claim, _verify
if set(params) != _SCOPE | {'epoch', 'sequence', 'operation', 'payload'}:
raise RuntimeStoreError('invalid_params')
claim = _claim(connection, ref, params)
authority = connection.authority
if 'worker:adopt' not in connection.actor.capabilities:
raise RuntimeStoreError('permission_denied')
_verify(connection, ref, params, claim)
def persist_and_publish():
result = persist_worker_delegation(authority.db,
**{key: params[key] for key in ('epoch', 'execution_id', 'session_id', 'generation',
'sequence', 'operation', 'payload')},
worker_pid=params['pid'], worker_birth=params['birth'])
if params['operation'] == 'delegation.complete':
with authority.db._read_ctx() as conn:
row = _owned(conn, ref.session_id, params['execution_id'], params['payload']['event']['delegation_id'])
event = json.loads(row['event_json']) if row['delivery_state'] == 'pending' else None
if event is not None:
from tools.process_registry import process_registry
# Queueing after commit can repeat after a lost ACK. Existing
# token-guarded claims arbitrate delivery; never ACK at publication.
process_registry.completion_queue.put(event | {'restored': True})
return result
return await asyncio.to_thread(persist_and_publish)