| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224 |
- """Peer turns into the canonical Bot Chat under session authority.
- ``hermes peer dm`` (``/api/sessions/{id}/chat[/stream]``) and ``hermes peer run`` (``/v1/runs``)
- aim at the profile's Bot Chat. Under session authority that chat is a LOCAL session whose only
- writer is the authority FIFO — a Desktop showing it is a viewer, never a lease-holding executor —
- so the API edge admits the turn through the same door as ``bot_relay.deliver``
- (``gateway/session_bot.py``) and reads the reply from that admission's receipt. Binding the
- session as an API conversation (``run_api_turn``) would be a second writer and is refused
- (``permission_denied``) by design. Without an authority the legacy live-owner mailbox applies.
- """
- import asyncio
- import logging
- from pathlib import Path
- from types import SimpleNamespace
- import uuid
- from gateway.session_contract import SessionActor
- from hermes_state_runtime import RuntimeStoreError
- logger = logging.getLogger(__name__)
- _PENDING = ('queued', 'claimed')
- # Owner of a Bot Chat the gateway mints for a peer's create-if-missing (no native client asked).
- _PEER_SUBJECT = 'api-peer'
- # The whole body ``hermes peer dm`` sends (``hermes_cli/subcommands/peer.py::_ensure_bot_chat``).
- _PEER_CREATE_FIELDS = frozenset({'title', 'source'})
- def _authority(runner):
- from gateway.session_authorities import active_authority
- return active_authority(runner) if getattr(runner, 'session_authority', None) is not None else None
- async def create_peer_bot_chat(adapter, body):
- """``POST /api/sessions`` titled "Bot Chat" (``hermes peer dm``'s create-if-missing) under session
- authority: the owner mints the chat through the step a first ``bot_relay.deliver`` takes
- (``session_bot._create_bot_chat``), so a headless gateway's Bot Chat is a LOCAL session its FIFO
- owns, not an API row no remote sender can ever bind (#139370). None when the ordinary handler
- answers: no authority, another title, an explicit id, or the chat exists (its title conflict).
- The owner mints on the profile's own policy, so a create carrying anything else (a model
- lock, route, options, system prompt) is refused by name before anything is written."""
- from tools.bot_mode_probe import BOT_CHAT_TITLE
- authority = _authority(adapter.gateway_runner)
- if (authority is None or str(body.get('title') or '').strip() != BOT_CHAT_TITLE
- or body.get('id') or body.get('session_id')):
- return None
- from aiohttp import web
- from gateway.platforms.api_server import _error_response
- if unsupported := sorted(set(body) - _PEER_CREATE_FIELDS):
- return _error_response(
- f"Bot Chat creation refused: bot_chat_parameters_unsupported ({', '.join(unsupported)}); "
- "the Bot Chat is created with the profile's own model and prompt", 400,
- code='bot_chat_parameters_unsupported')
- from gateway.session_bot import _create_bot_chat
- from gateway.session_runtime_workers import track_mutation
- actor = SessionActor(_PEER_SUBJECT, authority.profile_id,
- frozenset({'session:create', 'session:read', 'session:submit'}), 'api-peer-dm')
- try:
- authority._require_admission_open()
- ref = await asyncio.shield(track_mutation(authority, _create_bot_chat(authority, actor)))
- except RuntimeStoreError as exc:
- return _error_response(f'Bot Chat creation refused: {exc.reason}', 503, code=exc.reason)
- if ref is None:
- return None
- row = await asyncio.to_thread(authority.db.get_session, ref.session_id)
- return web.json_response({'object': 'hermes.session', 'session': adapter._session_response(row)}, status=201)
- def _refusal(authority, tip, exc):
- """``(reason, error)`` for a refused peer turn. A ``not_found`` on a Bot Chat that is no local
- chat is named: a remote sender never binds unowned history, so a bare code would leave the
- peer nothing to act on. The full clause stays in gateway.log."""
- reason = exc.reason
- if reason == 'not_found' and not str(tip.get('chat_id') or '').startswith('local-'):
- from hermes_state_local_migration import validate_legacy_row
- try:
- validate_legacy_row(authority.db, tip)
- reason, hint = 'bot_chat_unbound', 'open it once with `hermes chat -c "Bot Chat"` on that host'
- except RuntimeStoreError:
- from gateway.session_bot import displaceable_bot_chat
- reason = 'bot_chat_not_local'
- if displaceable_bot_chat(authority, tip) is not None:
- hint = "it is a conversation the gateway cannot own; it is moved aside as 'Bot Chat (<source> <id>)' on the next delivery"
- else: # local history a peer may not adopt (a served remote login's Desktop row, another profile's): never moved
- hint = 'it is local history owned by another login or profile; open or rename it from the client that owns it'
- logger.warning('Peer DM into Bot Chat %s refused: %s (not_found: field=%s detail=%s)',
- tip['id'], reason, exc.field, exc.detail)
- return reason, f"Bot Chat admission refused: {reason} (this profile's 'Bot Chat' is not a local chat; {hint})"
- return reason, f'Bot Chat admission refused: {reason}'
- async def reset_local_title_owner(db, title, include_hidden, source=None):
- """``[row]`` for the exact-title lookup of a LOCAL conversation that was reset (``/new``, the
- compression-exhaustion auto-reset), else ``[]``. The listing shows a reset lineage as its latest,
- untitled segment, so ``hermes peer dm`` stopped finding its Bot Chat and its create collided
- with the title. The titled creation id still owns the FIFO and is what the chat door admits.
- It applies the listing's own filters: hidden only with ``include_hidden``, never an archived
- row (a deliberate archive stays put; the reaper-archive resurrection is the caller's), and
- ``source`` when one is given."""
- return await asyncio.to_thread(_reset_local_title_owner, db, title, include_hidden, source) if title else []
- def _reset_local_title_owner(db, title, include_hidden, source=None):
- row = db.get_session_by_title(title)
- if (row is None or row.get('end_reason') != 'session_reset' or row.get('archived')
- or (row.get('hidden') and not include_hidden) or (source and row.get('source') != source)):
- return []
- from hermes_state_local import local_receipt
- try:
- lineage = local_receipt(db, row['id']).get('lineage') or []
- except RuntimeStoreError:
- return []
- return [row] if len(lineage) > 1 else []
- def bot_chat_tip(authority, session_id):
- """The canonical Bot Chat's tip row when *session_id* is in its lineage, else None."""
- db = authority.db
- row = db.get_session_by_title('Bot Chat')
- if row is None:
- return None
- tip = db.get_compression_tip(row['id'])
- if not tip or db.get_compression_tip(session_id) != tip:
- return None
- return db.get_session(tip)
- async def admit_peer_turn(runner, session_id, message, author):
- """``(profile home, receipt)`` when *session_id* is the Bot Chat and the turn was admitted to its
- FIFO; None when the target is any other session (the caller runs it as an API turn)."""
- from gateway.session_authorities import served_profile_name
- from gateway.session_bot import deliver
- authority = _authority(runner)
- if authority is None:
- return None
- tip = bot_chat_tip(authority, session_id)
- if tip is None:
- return None
- home = Path(authority.db.db_path).parent.resolve()
- from gateway.session_bot import displaceable_bot_chat
- if displaceable_bot_chat(authority, authority.db.get_session_by_title('Bot Chat') or tip) is not None:
- # The title is held by an API conversation no FIFO can own (#140769, MSG-21): the owner
- # moves it aside and mints the local Bot Chat for the peer, as ``create_peer_bot_chat`` does.
- actor = SessionActor(_PEER_SUBJECT, authority.profile_id,
- frozenset({'session:create', 'session:read', 'session:submit'}), 'api-peer-dm')
- else:
- # The API key already authenticated the peer; the turn enters the chat as its owner's own
- # input, the way owner recovery re-admits queued deliveries (``recover_bot_deliveries``).
- actor = SessionActor(tip['user_id'], authority.profile_id,
- frozenset({'session:submit', 'session:read'}), 'api-peer-dm')
- key = uuid.uuid4().hex
- params = dict(id=key, profile=served_profile_name(home), message=message)
- if author is not None:
- params['author'] = dict(author)
- try:
- record = await deliver(SimpleNamespace(authority=authority, actor=actor), params)
- except RuntimeStoreError as exc:
- reason, error = _refusal(authority, tip, exc)
- record = {'status': 'failed', 'delivery_id': key, 'reason': reason, 'error': error}
- return home, record
- async def await_live_delivery(adapter, home, record, timeout, *, should_stop=None):
- """Wait for a live Bot Chat receipt through whichever door admitted it: the authority FIFO
- (in-process waiter) or the legacy owner mailbox (``await_delivery_async``)."""
- authority = _authority(adapter.gateway_runner)
- if authority is not None and record.get('admission_id'):
- return await await_peer_receipt(authority, record, timeout, should_stop=should_stop)
- from tools.bot_live_delivery import await_delivery_async
- return await await_delivery_async(home, record['delivery_id'], timeout, should_stop=should_stop) or record
- async def await_peer_receipt(authority, record, timeout, *, should_stop=None):
- """The delivery's receipt after it settles for good, *timeout* lapses, or *should_stop* says so.
- Each pass re-reads which admission is live (``peer_wait_admission``): after a transient failure
- the owner admits ONE retry, whose id is the only future that fires again; the original's interim
- ``failed`` (retry still eligible) reads as pending, never as the answer."""
- from gateway.session_bot import peer_wait_admission
- if record['status'] not in _PENDING:
- return record
- loop = asyncio.get_running_loop()
- deadline = None if timeout is None else loop.time() + timeout
- while True:
- live, interim = await asyncio.to_thread(peer_wait_admission, authority, record)
- # Register the waiter BEFORE re-reading: a settle between the two either shows in the read
- # or resolves this future; a settle before both would otherwise leave a future nobody pops.
- waiter = None if live is None or interim else authority.waiters.setdefault(live, loop.create_future())
- current = _receipt(authority, record)
- if live is None and current['status'] in _PENDING:
- continue # The derived retry committed while the receipt was being read.
- if live == record['admission_id'] and not interim and current['status'] == 'failed' \
- and not current.get('retry_admission_id'):
- continue # The original settled failed after the live read: re-derive (its retry may be owed).
- if interim:
- current['status'] = 'claimed' # the retry is being admitted
- if live is None or current['status'] not in _PENDING:
- await _owner_published(authority, record, deadline)
- return current
- if should_stop is not None and should_stop():
- return current
- remaining = None if deadline is None else deadline - loop.time()
- if remaining is not None and remaining <= 0:
- return current
- tick = 0.05 if interim else (0.5 if should_stop is not None else remaining)
- if waiter is None:
- await asyncio.sleep(tick if remaining is None else min(tick, remaining))
- else:
- await asyncio.wait([waiter], timeout=tick if remaining is None else min(tick, remaining))
- async def _owner_published(authority, record, deadline):
- """Answer only once the owner's reply watcher published the outcome this waiter read from the
- FIFO: its receipt write runs off-loop, and a re-read of the delivery must not say ``queued``
- after the sender already holds the reply."""
- watcher = getattr(authority, '_bot_reply_watchers', {}).get(record['delivery_id'])
- if watcher is not None and not watcher[1].done():
- remaining = None if deadline is None else max(0.0, deadline - asyncio.get_running_loop().time())
- await asyncio.wait([watcher[1]], timeout=remaining)
- def _receipt(authority, record):
- from gateway.session_bot import _result
- return {**record, **_result(authority, record)}
|