| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227 |
- """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
|