The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""``cron/bot_chat_pending``: Bot Chat outputs whose target owner was not running yet.
``defer`` parks one (a cross-profile target whose gateway is down or still starting), and
the retired CLI lane left records of the same shape behind. Each still-``queued`` record is handed,
under its own id, to the target profile's live owner through the canonical
``tools.bot_live_delivery.deliver_to_live_owner`` door (idempotent per id). Records are
never deleted: they keep their final status as evidence, exactly as the old drain did.
A ``claimed`` record was an uncertain CLI turn and is never resent.
"""
from __future__ import annotations
import json
import logging
from pathlib import Path
from hermes_dir_acl import make_user_dir
from hermes_constants import get_hermes_home
from utils import atomic_json_write
logger = logging.getLogger(__name__)
_warned: set[Path] = set()
def defer(key: str, job: dict, content: str, home: Path, *, for_failure: bool) -> None:
"""Park one never-admitted output under its delivery id; a later tick hands it to the owner."""
import time
root = get_hermes_home().resolve() / "cron" / "bot_chat_pending"
make_user_dir(root, parents=True, exist_ok=True, mode=0o700)
path = root / f"{key}.json"
if not path.exists(): # an existing record (queued or already transferred) keeps its status
atomic_json_write(path, dict(
id=key, status="queued", job={k: job[k] for k in ("id", "name") if k in job}, content=content,
home=str(home), for_failure=for_failure, sequence=time.time_ns()), fsync_dir=True, mode=0o600)
def _queued(root: Path) -> list[tuple[Path, dict]]:
found = []
for path in root.glob("*.json"):
try:
record = json.loads(path.read_text(encoding="utf-8-sig"))
if not isinstance(record, dict):
raise ValueError(f"expected a JSON object, got {type(record).__name__}")
except (OSError, ValueError) as exc:
if path not in _warned:
_warned.add(path)
logger.error("Unreadable legacy Bot Chat pending record %s kept as evidence: %s", path, exc)
continue
if record.get("status") == "queued":
found.append((path, record))
return sorted(found, key=lambda item: (item[1].get("sequence", 0), item[0].name))
def _malformed(record: dict) -> str:
"""Why *record* can never be handed off (empty when its required fields are usable)."""
missing = [key for key in ("id", "home", "content")
if not isinstance(record.get(key), str) or not record.get(key)]
if missing:
return f"malformed legacy bot-chat record (missing {', '.join(missing)}); not delivered"
if not isinstance(record.get("job") or {}, dict):
return "malformed legacy bot-chat record (job is not an object); not delivered"
return ""
def _dispose(path: Path, record: dict) -> bool:
"""Decide one queued record in place; False leaves it queued for a later tick."""
from cron.scheduler_delivery import BOT_CHAT_POLICY_PLATFORM, bot_chat_message
from gateway.warning_notifications import warning_notifications_enabled
from hermes_cli.config_effective import load_user_config_effective
from tools.bot_live_delivery import deliver_to_live_owner, find_canonical_live_owner
if reason := _malformed(record):
record.update(status="ambiguous", error=reason)
return True
home = Path(record["home"]).resolve()
for_failure = bool(record.get("for_failure"))
if not (home / "state.db").is_file():
record.update(status="ambiguous", error=f"bot-chat delivery target no longer exists: {home}")
elif for_failure and not warning_notifications_enabled(
BOT_CHAT_POLICY_PLATFORM, load_user_config_effective(home / "config.yaml")):
record.update(status="suppressed", error=None)
else:
try:
owner = find_canonical_live_owner(home)
except ValueError:
return False # Owner not ready: discovery uncertainty is not a disposition.
if owner is None:
return False
try:
receipt = deliver_to_live_owner(
home, owner, bot_chat_message(record.get("job") or {}, record["content"]),
delivery_id=record["id"], notification_category="diagnostic" if for_failure else "result")
except Exception as exc:
# The door is idempotent per id (a replay returns the existing receipt), so the
# record stays queued for the next tick; log loudly once, quietly after.
logger.log(logging.DEBUG if path in _warned else logging.WARNING,
"Legacy Bot Chat pending record %s not handed off yet: %s", path, exc, exc_info=True)
_warned.add(path)
return False
receipt_status = receipt.get("status") if isinstance(receipt, dict) else None
record.update(status="transferred", error=None, receipt_status=receipt_status)
return True
def drain_legacy_pending() -> None:
"""Admit queued legacy records to their live owner; an absent owner leaves them for a later tick.
Each record is isolated: a malformed one is kept as ``ambiguous`` evidence and an
unexpected failure leaves only that record queued, so one bad file never stops cron.
"""
root = get_hermes_home().resolve() / "cron" / "bot_chat_pending"
if not root.is_dir():
return
for path, record in _queued(root):
try:
if not _dispose(path, record):
continue
atomic_json_write(path, record, fsync_dir=True, mode=0o600)
except Exception as exc:
logger.log(logging.DEBUG if path in _warned else logging.WARNING,
"Legacy Bot Chat pending record %s left queued: %s", path, exc, exc_info=True)
_warned.add(path)
continue
logger.info("Legacy Bot Chat pending record %s -> %s", path.name, record["status"])