@maudecode/talaria-web 1.13.0 → 1.15.0

package/sidecar/talaria_sidecar/methods/process.py

@@ -4,8 +4,13 @@ routing; the sidecar drains and formats registry events."""
 
 from __future__ import annotations
 
+import json
 import logging
 import queue
+import sqlite3
+import time
+from contextlib import closing
+from pathlib import Path
 
 from ..errors import InvalidParams
 from ..home import profile_home_param, scoped_home
@@ -89,6 +94,62 @@ def mark_consumed(process_id: str) -> bool:
         return False
 
 
+def _delivery_api():
+    """The Agent's durable delivery ledger (``tools.async_delegation``), or None on an Agent without it."""
+    try:
+        from tools import async_delegation
+    except Exception:  # noqa: BLE001
+        return None
+    names = ("claim_event_delivery", "complete_event_delivery", "release_event_delivery")
+    return async_delegation if all(callable(getattr(async_delegation, n, None)) for n in names) else None
+
+
+def _ledger_event(evt: dict) -> dict:
+    return {k: v for k, v in evt.items() if k not in ("process_id", "consumed")}
+
+
+def claim_delivery(evt: dict, consumer: str) -> str | None:
+    """Claim a durable delegation completion before delivering it (TAL-459).
+
+    ``None``: another consumer holds it, or the ledger already delivered or dropped it, so do not deliver.
+    ``""``: nothing durable to acknowledge (interim notice, legacy event, or an Agent without the ledger)."""
+    api = _delivery_api()
+    if api is None:
+        return ""
+    claim_id = api.claim_event_delivery(_ledger_event(evt), consumer)
+    return None if claim_id is None else str(claim_id)
+
+
+def complete_delivery(evt: dict, claim_id: str) -> bool:
+    api = _delivery_api()
+    if api is None or not claim_id:
+        return False
+    api.complete_event_delivery(_ledger_event(evt), claim_id)
+    return True
+
+
+def release_delivery(evt: dict, claim_id: str) -> bool:
+    api = _delivery_api()
+    if api is None or not claim_id:
+        return False
+    api.release_event_delivery(_ledger_event(evt), claim_id)
+    return True
+
+
+def defer_delivery(evt: dict, claim_id: str) -> bool:
+    """Hand back a claim the target never admitted (its session was busy) without spending a delivery attempt;
+    the Agent drops a row for good after its attempt budget, so a busy session must not burn it."""
+    api = _delivery_api()
+    if api is None or not claim_id:
+        return False
+    defer = getattr(api, "defer_completion_delivery", None)
+    if not callable(defer) or evt.get("type") != "async_delegation" or not evt.get("delegation_id"):
+        api.release_event_delivery(_ledger_event(evt), claim_id)
+        return True
+    defer(str(evt["delegation_id"]), claim_id)
+    return True
+
+
 def format_notification(evt: dict) -> str:
     if evt.get("type") == "async_delegation":
         try:
@@ -122,6 +183,210 @@ def list_sessions() -> list[dict]:
     return out
 
 
+_LEDGER_COLUMNS = "delegation_id, origin_ui_session_id, state, dispatched_at, completed_at, updated_at, task_json, result_json, event_json IS NOT NULL"
+_LEDGER_LIMIT = 200
+
+
+def _json(text) -> dict:
+    try:
+        value = json.loads(text) if text else {}
+    except (TypeError, ValueError):
+        return {}
+    return value if isinstance(value, dict) else {}
+
+
+def _unit_goals(task: dict) -> list[str]:
+    goals = task.get("goals") if isinstance(task.get("goals"), list) else None
+    indexes = task.get("task_indexes") if isinstance(task.get("task_indexes"), list) else None
+    if goals and indexes:
+        return [str(goals[i]) for i in indexes if isinstance(i, int) and 0 <= i < len(goals)]
+    if goals:
+        return [str(g) for g in goals]
+    return [str(task.get("goal") or "")]
+
+
+def _child_statuses(result: dict) -> list[str]:
+    """Per-subagent outcome of a finished unit: a batch carries ``results``, a single task is its own result."""
+    if isinstance(result.get("results"), list):
+        return [str(r.get("status") or "") for r in result["results"] if isinstance(r, dict)]
+    return [str(result.get("status") or "")] if result else []
+
+
+def _ledger_rows(home: Path, session_ids: list[str]) -> list[dict]:
+    db_path = home / "state.db"
+    if not db_path.exists() or not session_ids:
+        return []
+    marks = ",".join("?" * len(session_ids))
+    with closing(sqlite3.connect(f"{db_path.resolve().as_uri()}?mode=ro", uri=True, timeout=5)) as conn:
+        try:
+            rows = conn.execute(f"SELECT {_LEDGER_COLUMNS} FROM async_delegations WHERE origin_ui_session_id IN ({marks}) ORDER BY dispatched_at DESC LIMIT ?", [*session_ids, _LEDGER_LIMIT]).fetchall()
+        except sqlite3.OperationalError:  # an Agent that never delegated has no ledger table yet
+            return []
+    out = []
+    for delegation_id, origin, state, dispatched_at, completed_at, updated_at, task_json, result_json, has_event in rows:
+        task, result = _json(task_json), _json(result_json)
+        goals = _unit_goals(task)
+        out.append({
+            "delegation_id": delegation_id, "origin_ui_session_id": origin, "state": state, "dispatched_at": dispatched_at,
+            "completed_at": completed_at, "updated_at": updated_at, "goals": goals,
+            "child_statuses": _child_statuses(result), "has_result": bool(has_event),
+        })
+    return out
+
+
+def _live_delegations() -> dict[str, dict]:
+    try:
+        from tools.async_delegation import list_async_delegations
+        items = list_async_delegations()
+    except Exception:  # noqa: BLE001 - an Agent without the live registry reports from the ledger alone
+        return {}
+    return {str(i.get("delegation_id")): {"status": str(i.get("status") or "")} for i in items if isinstance(i, dict) and i.get("delegation_id")}
+
+
+def _owned_processes(session_ids: set[str]) -> list[dict]:
+    """Notified or watched processes a WebUI session started (``session_key`` is the WebUI session id)."""
+    registry = _registry()
+    if registry is None:
+        return []
+    try:
+        with registry._lock:
+            sessions = [*registry._running.values(), *registry._finished.values()]
+    except Exception:  # noqa: BLE001
+        return []
+    out = []
+    for proc in sessions:
+        if str(getattr(proc, "session_key", "") or "") not in session_ids:
+            continue
+        watched = bool(getattr(proc, "watch_patterns", None))
+        if not (getattr(proc, "notify_on_complete", False) or watched):
+            continue
+        exited = bool(getattr(proc, "exited", False))
+        out.append({
+            "process_id": str(proc.id), "session_key": str(proc.session_key), "command": str(getattr(proc, "command", "") or "")[:200],
+            "started_at": float(getattr(proc, "started_at", 0) or 0) or None, "exited": exited,
+            "exited_at": float(getattr(proc, "exited_at", 0) or 0) or None, "exit_code": getattr(proc, "exit_code", None),
+            "completion_reason": str(getattr(proc, "completion_reason", "") or ""), "watched": watched,
+        })
+    return out
+
+
+_CHILD_WINDOW_S = 5
+
+
+def _live_children() -> list[dict]:
+    """Running subagents from the Agent's in-process registry: the only place a child's session id sits next to its
+    delegation id. An Agent without the registry reports none."""
+    try:
+        from tools.delegate_tool_registry import _active_subagents, _active_subagents_lock
+        with _active_subagents_lock:
+            records = list(_active_subagents.values())
+    except Exception:  # noqa: BLE001
+        return []
+    out = []
+    for r in records:
+        sid = getattr(r.get("agent"), "session_id", None)
+        if isinstance(sid, str) and sid:
+            out.append({"delegation_id": str(r.get("delegation_id") or ""), "goal": str(r.get("goal") or ""), "owner": str(r.get("owner_agent_session_id") or ""), "session_id": sid})
+    return out
+
+
+def _ledger_children(home: Path, owners: list[str]) -> list[dict]:
+    """Finished subagents' own sessions in state.db: ``source = subagent`` rows tagged ``_delegate_from`` with their
+    parent's session, each with its start time and first user message (the child's goal, sent verbatim)."""
+    db_path = home / "state.db"
+    if not db_path.exists() or not owners:
+        return []
+    marks = ",".join("?" * len(owners))
+    with closing(sqlite3.connect(f"{db_path.resolve().as_uri()}?mode=ro", uri=True, timeout=5)) as conn:
+        try:
+            # Only these chats' children: a long-lived profile keeps every subagent session it ever ran.
+            rows = conn.execute(
+                "SELECT s.id, s.model_config, s.started_at, (SELECT m.content FROM messages m WHERE m.session_id = s.id AND m.role = 'user' ORDER BY m.id LIMIT 1)"
+                f" FROM sessions s WHERE s.source = 'subagent' AND json_extract(s.model_config, '$._delegate_from') IN ({marks})", owners).fetchall()
+        except sqlite3.OperationalError:
+            return []
+    out = []
+    for sid, model_config, started_at, first in rows:
+        owner = _json(model_config).get("_delegate_from")
+        goal = _goal_text(first)
+        if owner in owners and goal:
+            out.append({"owner": owner, "session_id": sid, "started_at": started_at, "goal": goal})
+    return out
+
+
+_CONTENT_JSON_PREFIX = "\x00json:"
+_IMAGE_HINTS = "\n\n[Image attached"
+
+
+def _goal_text(content) -> str:
+    """The goal a child was sent, from its stored first message: a task with images is stored as multimodal parts
+    (native image input; the goal is the text part) or as the goal followed by image hints (text input)."""
+    if not isinstance(content, str):
+        return ""
+    if content.startswith(_CONTENT_JSON_PREFIX):
+        try:
+            parts = json.loads(content[len(_CONTENT_JSON_PREFIX):])
+        except ValueError:
+            return ""
+        texts = [p.get("text") for p in parts if isinstance(p, dict) and p.get("type") == "text"] if isinstance(parts, list) else []
+        return str(texts[0]) if texts and texts[0] else ""
+    return content.split(_IMAGE_HINTS, 1)[0]
+
+
+def unit_children(unit: dict, owner: str, live: list[dict], finished: list[dict], now: float) -> list[dict]:
+    """The subagent sessions one delegation unit ran, as ``{goal, session_id}`` per task, in task order. A live registry
+    record is exact (same owner, the unit's call id, the task's goal) and is used once. Without one, finished sessions
+    of that owner whose goal matches, started in the unit's window, count only when there are exactly as many as tasks
+    with that goal; anything else stays unlinked rather than guessed."""
+    unit_id, goals = unit["delegation_id"], [g for g in unit["goals"] if g]
+    pool = [r for r in live if r["owner"] == owner and r["delegation_id"] and (unit_id == r["delegation_id"] or unit_id.startswith(f"{r['delegation_id']}-"))]
+    linked: list[str | None] = []
+    used: set[str] = set()
+    for goal in goals:
+        record = next((r for r in pool if r["goal"] == goal and r["session_id"] not in used), None)
+        if record:
+            used.add(record["session_id"])
+        linked.append(record["session_id"] if record else None)
+    start = (unit.get("dispatched_at") or 0) - _CHILD_WINDOW_S
+    end = (unit.get("completed_at") or now) + _CHILD_WINDOW_S
+    for goal in {g for g, sid in zip(goals, linked) if sid is None}:
+        slots = [i for i, (g, sid) in enumerate(zip(goals, linked)) if g == goal and sid is None]
+        matches = sorted((c for c in finished if c["owner"] == owner and c["goal"] == goal and c["session_id"] not in used and start <= (c["started_at"] or 0) <= end), key=lambda c: c["started_at"] or 0)
+        if len(matches) == len(slots):
+            for i, c in zip(slots, matches):
+                linked[i] = c["session_id"]
+    return [{"goal": g, "session_id": sid} for g, sid in zip(goals, linked) if sid]
+
+
+def background_list(home: Path, session_ids: list[str]) -> dict:
+    """TAL-372: what the Agent knows about the background work of these WebUI sessions: delegations from the durable
+    ledger (with the live registry's status while they run) and notified processes from the process registry.
+    TAL-494: each delegation also names the subagent sessions it ran."""
+    live = _live_delegations()
+    delegations = _ledger_rows(home, session_ids)
+    live_children = _live_children()
+    finished = _ledger_children(home, session_ids) if delegations else []
+    now = time.time()
+    for row in delegations:
+        row["live_status"] = live.get(row["delegation_id"], {}).get("status")
+        row["children"] = unit_children(row, row["origin_ui_session_id"], live_children, finished, now)
+    return {"delegations": delegations, "processes": _owned_processes(set(session_ids))}
+
+
+def delegation_result(home: Path, session_id: str, delegation_id: str) -> str:
+    """The full result of a finished delegation unit, as the Agent words it for its own notification."""
+    db_path = home / "state.db"
+    if not db_path.exists():
+        return ""
+    with closing(sqlite3.connect(f"{db_path.resolve().as_uri()}?mode=ro", uri=True, timeout=5)) as conn:
+        try:
+            row = conn.execute("SELECT event_json FROM async_delegations WHERE delegation_id = ? AND origin_ui_session_id = ?", (delegation_id, session_id)).fetchone()
+        except sqlite3.OperationalError:
+            return ""
+    event = _json(row[0]) if row else {}
+    return format_notification(event) if event else ""
+
+
 def register(registry_) -> None:
     @registry_.method("process.drain")
     def drain_(ctx: CallContext, params: dict) -> dict:
@@ -142,6 +407,39 @@ def register(registry_) -> None:
             raise InvalidParams("process_id is required")
         return {"ok": mark_consumed(process_id)}
 
+    def _delivery_params(params: dict) -> dict:
+        evt = params.get("event")
+        if not isinstance(evt, dict):
+            raise InvalidParams("event must be an object")
+        return evt
+
+    @registry_.method("process.claim_delivery")
+    def claim_(ctx: CallContext, params: dict) -> dict:
+        evt = _delivery_params(params)
+        consumer = str(params.get("consumer") or "").strip()
+        if not consumer:
+            raise InvalidParams("consumer is required")
+        with scoped_home(profile_home_param(params)):
+            return {"claim_id": claim_delivery(evt, consumer)}
+
+    @registry_.method("process.complete_delivery")
+    def complete_(ctx: CallContext, params: dict) -> dict:
+        evt = _delivery_params(params)
+        with scoped_home(profile_home_param(params)):
+            return {"ok": complete_delivery(evt, str(params.get("claim_id") or ""))}
+
+    @registry_.method("process.release_delivery")
+    def release_(ctx: CallContext, params: dict) -> dict:
+        evt = _delivery_params(params)
+        with scoped_home(profile_home_param(params)):
+            return {"ok": release_delivery(evt, str(params.get("claim_id") or ""))}
+
+    @registry_.method("process.defer_delivery")
+    def defer_(ctx: CallContext, params: dict) -> dict:
+        evt = _delivery_params(params)
+        with scoped_home(profile_home_param(params)):
+            return {"ok": defer_delivery(evt, str(params.get("claim_id") or ""))}
+
     @registry_.method("process.format_notification")
     def format_(ctx: CallContext, params: dict) -> dict:
         evt = params.get("event")
@@ -149,6 +447,26 @@ def register(registry_) -> None:
             raise InvalidParams("event must be an object")
         return {"text": format_notification(evt)}
 
+    def _session_ids(params: dict) -> list[str]:
+        ids = params.get("session_ids")
+        if not isinstance(ids, list) or not all(isinstance(i, str) and i for i in ids):
+            raise InvalidParams("session_ids must be a list of session ids")
+        return ids
+
+    @registry_.method("process.background_list")
+    def background_list_(ctx: CallContext, params: dict) -> dict:
+        ids = _session_ids(params)
+        with scoped_home(profile_home_param(params)) as home:
+            return background_list(home, ids)
+
+    @registry_.method("process.delegation_result")
+    def delegation_result_(ctx: CallContext, params: dict) -> dict:
+        sid, did = str(params.get("session_id") or ""), str(params.get("delegation_id") or "")
+        if not sid or not did:
+            raise InvalidParams("session_id and delegation_id are required")
+        with scoped_home(profile_home_param(params)) as home:
+            return {"text": delegation_result(home, sid, did)}
+
     @registry_.method("process.list")
     def list_(ctx: CallContext, params: dict) -> dict:
         with scoped_home(profile_home_param(params)):