The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Responses retries observe their original admission before resolving mutable conversation names."""
from functools import partial
import hashlib
import logging
import uuid
from hermes_state_runtime import RuntimeStoreError
def request_binding(adapter, request, durable_key):
from gateway.platforms.api_server import _make_request_fingerprint
return _make_request_fingerprint({'request': durable_key[1],
'declared_session_key': adapter._parse_session_key_header(request)[0]},
keys=('request', 'declared_session_key'))
def _request_admission_rows(db, request_id):
"""A lost derivative pointer cannot erase accepted identity on retirement."""
from hermes_state_terminal import terminal_api_admissions
with db._read_ctx() as conn:
rows = [dict(row) for row in conn.execute(
"SELECT * FROM session_admissions WHERE principal_id='api' AND request_id=?", (request_id,))]
rows.extend(terminal_api_admissions(conn, request_id))
return rows
def _lookup_admission(authority, store, durable_key, request_id):
"""Scope comes from authenticated profile/key identity, never a caller-supplied session id.
-> ``(authority, ref, row)`` or None. Store and state.db reads only (plus the pointer repair):
run it under ``store.atomically`` in a worker, never on the loop, whose wait on the store lock
would last for a concurrent response's whole persistence.
The compact pointer survives response-cache eviction and transcript retirement. A process
loss between the authority commit and pointer commit is repaired from that exact request id.
"""
from gateway.session_contract import SessionRef
from hermes_state_runtime import get_session_admission, _row
admission_id = store.request_admission(durable_key[0])
if admission_id:
row = get_session_admission(authority.db, admission_id=admission_id)
if row is None:
# The admission's deletion tombstone aged out: the key is spent, never a new request.
raise RuntimeStoreError('admission_conflict')
else:
rows = _request_admission_rows(authority.db, request_id)
if len(rows) > 1:
raise RuntimeStoreError('admission_conflict')
if not rows:
return None
row = _row(rows[0])
if row['principal_id'] != 'api' or row['request_id'] != request_id:
raise RuntimeStoreError('permission_denied')
if store.request_created_at(durable_key[0]) is None:
# An older admission with no wire fingerprint cannot authorize a changed request just
# because its caller reused the same key. Existing completed cache records still replay.
raise RuntimeStoreError('admission_conflict')
store.bind_request_admission(durable_key[0], row['admission_id'])
return authority, SessionRef(authority.profile_id, row['target_session_id']), row
def _restore_admitted(found):
"""The owner-loop half of a found admission: a live one's session is restored and checked."""
if found is not None and found[2]['status'] in {'queued', 'started'}:
from gateway.session_api import restore_api_session
from gateway.session_api_turn import check_api_turn
authority, ref, row = found
restore_api_session(authority, ref.session_id)
check_api_turn(authority, ref, row['payload'])
return found
def _lookup_call(adapter, durable_key, request_id):
"""-> ``(store, call)``: ``store.atomically(*call)`` is one ``_lookup_admission`` unit."""
from gateway.session_authorities import require_active_authority
authority = require_active_authority(adapter.gateway_runner, lambda: adapter._ensure_session_db())
store = adapter._current_response_store()
return store, (_lookup_admission, authority, store, durable_key, request_id)
async def find_admission(adapter, durable_key, request_id):
"""``_lookup_admission`` off the loop, then the session restore on it."""
store, call = _lookup_call(adapter, durable_key, request_id)
return _restore_admitted(await store.off_loop(*call))
def admitted_context(admitted, *, replay=False):
from gateway.session_api_turn import observe_api_turn
_, ref, row = admitted
payload = row['payload']
data = payload.get('api_turn_v1', {})
from gateway.session_api_media import rehydrate_api_images
return dict(session_id=ref.session_id, user_message=rehydrate_api_images(payload.get('text', ''), data.get('media')),
conversation_history=data.get('history') or [],
instructions=data.get('settings', {}).get('ephemeral_system_prompt'),
run_kwargs={}, run_agent=partial(observe_api_turn, admitted),
terminal_replay=replay or row['status'] == 'terminal')
def _admit_steps(adapter, durable_key, request_id, binding, run_kwargs, model):
"""The final lookup and the admission are one API admission drive (``run_steps_off_loop``
serializes them per authority): simultaneous observers converge on one admission. Every
store call is a yielded step, so a worker runs it: only the session restore stays on the loop."""
from gateway.session_api_turn import admit_api_steps
store, lookup = _lookup_call(adapter, durable_key, request_id)
if not (yield partial(store.bind_request_key, durable_key[0], binding, model=model)):
raise RuntimeStoreError('admission_conflict')
admitted = _restore_admitted((yield partial(store.atomically, *lookup)))
if admitted is not None:
return (*admitted, True)
try:
admitted = yield from admit_api_steps(adapter, request_id=request_id,
**{'route_source': 'global', 'confirmed_runtime_lock': False,
'session_history_delivery': '', **run_kwargs})
except Exception:
# A definite pre-admission refusal does not reserve a poisoned identity. If storage
# cannot prove absence, leave the binding intact for later recovery.
if _restore_admitted((yield partial(store.atomically, *lookup))) is None:
yield partial(store.forget_unadmitted_request, durable_key[0])
raise
yield partial(store.bind_request_admission, durable_key[0], admitted[2]['admission_id'])
return (*admitted, False)
async def _admit(adapter, durable_key, request_id, binding, run_kwargs, model):
from gateway.session_api_turn import admit_api_turn_async
*admitted, replay = await admit_api_turn_async(
adapter, _admit_steps(adapter, durable_key, request_id, binding, run_kwargs, model))
return admitted_context(tuple(admitted), replay=replay)
def _stored_owner(adapter, session_id):
"""A stored response keeps the physical transcript tip its turn ended on, which is a
compression child after an out-of-place compression. The canonical admission owner is
the lineage root (the API binding, route and FIFO stay there), so a chained turn admits
on that root; the legacy in-process path still continues the physical tip itself."""
from gateway.session_authorities import active_authority
authority = active_authority(adapter.gateway_runner) if session_id else None
return authority.logical_owner(session_id) if authority is not None else session_id
async def _bind_successor(adapter, session_id, run_kwargs):
"""Bind the session a chain moved to before any response starts. A streaming request has
answered 200 by the time its turn admits, so the bind's retryable ``chain_moved`` refusal must
happen here to reach the caller as a 503. The admission's own bind then finds this binding."""
from gateway.session_api import bind_api_steps, run_steps_off_loop
from gateway.session_authorities import active_authority
authority = active_authority(adapter.gateway_runner)
if authority is not None:
try:
await run_steps_off_loop(authority, bind_api_steps(
authority, session_id, walked_from=run_kwargs['walked_from'],
caller_key=run_kwargs['gateway_session_key']))
except RuntimeStoreError:
raise
except Exception as exc:
# A busy writer or I/O error: the caller maps store refusals only, and anything else
# would reach the client as aiohttp's bare 500 instead of the retryable 503.
logging.getLogger(__name__).warning('pre-stream bind of %s failed', session_id, exc_info=True)
raise RuntimeStoreError('storage_unavailable') from exc
async def prepare_context(adapter, request, body, gateway_session_key, durable_key, scope, key):
"""Validate first-time requests; exact retries use the accepted payload and result only."""
import asyncio
from gateway.platforms.api_server import (
_auto_truncate_response_history, _content_has_visible_payload, _error_response)
from gateway.platforms.api_server_openai_routes import _parse_responses_input, _parse_conversation_history
request_id = f'responses:{scope}:{key}' if durable_key else None
if durable_key:
admitted = await find_admission(adapter, durable_key, request_id)
if admitted is not None:
return admitted_context(admitted, replay=True), None
previous = body.get('previous_response_id')
response_store = adapter._current_response_store()
if body.get('conversation'):
previous = await response_store.off_loop(response_store.get_conversation, body['conversation'])
messages, error = _parse_responses_input(body['input'])
if error is not None:
return None, error
history = []
if body.get('conversation_history'):
history, error = _parse_conversation_history(body['conversation_history'])
if error is not None:
return None, error
stored_session_id = chain_root = None
instructions = body.get('instructions')
if not history and previous:
stored = await response_store.off_loop(response_store.get, previous)
if stored is None:
return None, _error_response(f'Previous response not found: {previous}', 404)
history = list(stored.get('conversation_history', []))
chain_root = await asyncio.to_thread(_stored_owner, adapter, stored.get('session_id'))
from gateway.platforms.api_server_authority_runs import continued_session
stored_session_id, error = await continued_session(adapter, chain_root, request_id)
if error is not None:
return None, error
if instructions is None:
instructions = stored.get('instructions')
history.extend(messages[:-1])
user_message = messages[-1].get('content', '') if messages else ''
if not _content_has_visible_payload(user_message):
return None, _error_response('No user message found in input', 400)
if body.get('truncation') == 'auto':
history = _auto_truncate_response_history(history)
declared_selected = not stored_session_id and bool(gateway_session_key)
session_id = stored_session_id or await asyncio.to_thread(
adapter._declared_conversation_session, gateway_session_key) or str(uuid.uuid4())
if durable_key and not stored_session_id and not gateway_session_key:
session_id = 'response-' + hashlib.sha256(f'{scope}\0{key}'.encode()).hexdigest()
route, overrides, error = adapter._select_request_route(body, session_id=session_id,
gateway_session_key=gateway_session_key, model_alias=body.get('model'))
if error is not None:
return None, error
from gateway.platforms.api_server import _request_relay_metadata
run_kwargs = dict(user_message=user_message, conversation_history=history,
ephemeral_system_prompt=instructions, session_id=session_id,
gateway_session_key=gateway_session_key, bind_declared_conversation=declared_selected,
**overrides, route=route, relay_metadata=_request_relay_metadata(body))
if stored_session_id and stored_session_id != chain_root:
run_kwargs['walked_from'] = chain_root # the chain moved past its swept stored session
if durable_key:
return await _admit(adapter, durable_key, request_id, request_binding(adapter, request, durable_key),
run_kwargs, body.get('model', adapter._model_name)), None
if 'walked_from' in run_kwargs:
await _bind_successor(adapter, session_id, run_kwargs)
return dict(session_id=session_id, user_message=user_message, conversation_history=history,
instructions=instructions, run_kwargs=run_kwargs, run_agent=adapter._run_agent), None