| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115 |
- """``message_agent``'s chain gate (``agent/bot_chain.py``): resolve each target to the identity the
- receiving turn's author carries, ask the gate once per call, and dispatch what it admits.
- Runs before any transport starts. A reply to the bot whose message started this turn goes through
- #144789's notify-only path (``[no reply needed]`` marker + ``wake="none"``); a target that was
- definitely not sent hands its ask and hop back, so a retry is neither a duplicate nor a new hop.
- """
- from __future__ import annotations
- import dataclasses
- import json
- from typing import Any
- from urllib.parse import urlparse
- def recipient_key(raw_target: str, sender: Any) -> str:
- """The author id a turn started by ``raw_target`` would carry here, resolved in ``_dispatch``'s
- order: a registered peer, then a connection-qualified relay row, then a local bot (folder id,
- ``hermes``, friendly name), then any relay row."""
- from agent.turn_author import bot_author_id
- from tools.bot_mode_dm import _PEER_TARGET_RE, _resolve_local_name
- name = raw_target.strip().lstrip("@")
- peer = _PEER_TARGET_RE.match(name)
- if peer or name.lower() in sender.peers:
- peer_name, peer_profile = peer.groups() if peer else (name.lower(), None)
- return _peer_key(peer_name, peer_profile or "default", sender)
- row = _relay_row(name, sender) if "@" in name else None
- local = None if row is not None else _resolve_local_name(name, list(sender.roster_homes), sender.root)
- if local is not None and local != sender.me:
- return bot_author_id(local)
- row = row or _relay_row(name, sender)
- if row is not None:
- return bot_author_id(row["profile"], row["connection_id"])
- return f"unresolved:{name.lower()}"
- def _relay_row(name: str, sender: Any) -> dict | None:
- from pathlib import Path
- from tools.bot_relay import read_remote_roster, resolve_remote_target
- roster = read_remote_roster(Path(sender.home))
- match = resolve_remote_target(name, roster) if roster else None
- return match if isinstance(match, dict) else None
- def _peer_key(peer_name: str, peer_profile: str, sender: Any) -> str:
- """A peer's dm reaches us as ``bot:<its hostname>/<profile>``: when this turn's author is that bot
- (same profile, hostname matching the registered peer URL's host) the target is that identity;
- otherwise the peer name keeps two peers' same-named agents apart."""
- author = getattr(sender.agent, "_turn_author", None) or {}
- origin, _, profile = str(author.get("id") or "").removeprefix("bot:").rpartition("/")
- if author.get("is_bot") and origin and profile.lower() == peer_profile.lower():
- host = (urlparse(str(_peer_url(peer_name, sender))).hostname or "").lower()
- if host and origin.lower() in {host, host.split(".", 1)[0]}:
- return str(author["id"])
- return f"peer:{peer_name}/{peer_profile}".lower()
- def _peer_url(peer_name: str, sender: Any) -> str:
- from hermes_cli.config_backend import read_config_doc_readonly
- doc = read_config_doc_readonly(sender.root / "config.yaml")
- peers = doc.get("bot_peers") if isinstance(doc, dict) else None
- entry = peers.get(peer_name) if isinstance(peers, dict) else None
- return str(entry.get("url") or "") if isinstance(entry, dict) else ""
- def _definitely_not_sent(ack: dict) -> bool:
- """A refusal before anything left: an error with no in-flight status (``queued``/``ambiguous``
- keep their reservation, since the other side may already be answering)."""
- return bool(ack.get("error")) and ack.get("status") in (None, "failed")
- def send_gated(targets: list[str], reply: bool, body: str, content_for, sender: Any) -> str:
- """Gate one ``message_agent`` call, then dispatch: the shared transports keep their own rules."""
- from agent.bot_chain import admit_send
- from tools.bot_mode_dm import _dispatch, _err
- from tools.bot_mode_dm_coordination import fan_out
- keys = [recipient_key(target, sender) for target in targets]
- admission = admit_send(sender.agent, keys, body)
- if admission.refusal:
- return _err(admission.refusal)
- sender = dataclasses.replace(sender, chain=admission.envelope())
- refused = [(t, k) for t, k in zip(targets, keys) if k in admission.refused]
- notify_only = [(t, k) for t, k in zip(targets, keys) if k in admission.notify_only and reply]
- normal = [(t, k) for t, k in zip(targets, keys) if (t, k) not in refused and (t, k) not in notify_only]
- if len(targets) == 1 and refused:
- return _err(admission.refused[keys[0]])
- acks: list[tuple[str, dict]] = []
- if len(targets) == 1:
- target, key = (notify_only or normal)[0]
- wake = "none" if notify_only or not reply else "notify"
- raw = _dispatch(target, content_for(wake != "none"), sender, wake=wake)
- _release_failed(admission, [(key, json.loads(raw))])
- return raw
- for target, key in notify_only:
- acks.append((key, {"to": f"@{target}", **json.loads(
- _dispatch(target, content_for(False), sender, wake="none"))}))
- combined = json.loads(fan_out([t for t, _k in normal], content_for(reply), sender, expects_reply=reply)) \
- if normal else {"status": "queued", "fan_out": []}
- acks += list(zip([k for _t, k in normal], combined.get("fan_out", [])))
- _release_failed(admission, acks)
- combined["fan_out"] = ([{"to": f"@{t}", "error": admission.refused[k]} for t, k in refused]
- + [ack for _k, ack in acks])
- return json.dumps(combined)
- def _release_failed(admission: Any, acks: list[tuple[str, dict]]) -> None:
- for key, ack in acks:
- if _definitely_not_sent(ack):
- admission.release(key)
|