| 12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879 |
- """``active-work`` control verb: what a stop/restart of this gateway would interrupt, answered live.
- ``gateway_state.json`` names each unit only while draining and its ``active_agents`` total leaves out
- async delegations, so a CLI asking "may I stop this gateway?" could not see a background subagent
- that ``stop()`` interrupts (``tools.async_delegation.interrupt_all``). The verb answers from the
- running process instead: the same units the drain report publishes plus every live delegation.
- """
- from __future__ import annotations
- import os
- import threading
- import time
- from typing import Any, Callable
- def _delegation_units(now: float) -> list[dict[str, Any]]:
- from tools.async_delegation import _LIVE_STATES, list_async_delegations
- units = []
- for record in list_async_delegations():
- if record.get("status") not in _LIVE_STATES:
- continue
- unit: dict[str, Any] = {"kind": "delegation", "delegation_id": record.get("delegation_id"),
- "goal": str(record.get("goal") or "")[:80], "pid": os.getpid()}
- if record.get("dispatched_at"):
- unit["elapsed_s"] = round(now - float(record["dispatched_at"]), 1)
- units.append(unit)
- return units
- def _profile_units(runner, profile: str, units: list[dict[str, Any]]) -> list[dict[str, Any]]:
- """What an ``unserve-profile`` of *profile* stops (``stop_authority_work``): its chat turns (session
- keys in its namespace) plus its authority's managed turns and cron runs. Delegations survive it."""
- from gateway.session import _session_key_namespace
- prefix = _session_key_namespace(profile) + ":"
- mine = [u for u in units if u.get("kind") == "chat" and str(u.get("session") or "").startswith(prefix)]
- home = (getattr(runner, "_served_profile_homes", None) or {}).get(profile)
- registry = getattr(runner, "session_authorities", None)
- authority = registry.for_home(home) if registry is not None and home is not None else None
- from gateway.session_runtime_workers import side_agents
- managed = sum(not w.closed.is_set() for w in getattr(authority, "_managed_workers", {}).values())
- crons = len(getattr(authority, "_cron_cancellations", None) or {})
- sides = len(side_agents(authority)) if authority is not None else 0
- pid = os.getpid()
- return (mine + [{"kind": "managed", "pid": pid}] * managed + [{"kind": "cron", "job_id": "?", "pid": pid}] * crons
- + [{"kind": "side_agent", "pid": pid}] * sides)
- def active_work_verb(runner, loop) -> Callable[[], dict[str, Any]]:
- """Handler for the control socket: runs on its executor thread, reads the runner on the loop."""
- def _handler(params: dict[str, Any]) -> dict[str, Any]:
- profile = params.get("profile")
- scoped = isinstance(profile, str) and bool(profile)
- box: list[dict[str, Any]] = []
- done = threading.Event()
- def _collect() -> None:
- # Everything that reads live authority state runs here, on the loop: a read on the socket
- # thread can race a worker being added and raise, and an error reads as "no work".
- try:
- units = list(runner._describe_active_work()) + _delegation_units(time.time())
- if scoped:
- units = _profile_units(runner, profile, units)
- box.append({"active_agents": len(units), "active_work": units, "profile": profile})
- else:
- box.append({"active_agents": runner._active_work_count(), "active_work": units})
- finally:
- done.set()
- loop.call_soon_threadsafe(_collect)
- if not done.wait(timeout=5.0) or not box:
- raise RuntimeError("active-work: the gateway loop did not answer")
- return {**box[0], "pid": os.getpid()}
- return _handler
|