@maudecode/talaria-web 1.14.0 → 1.16.1

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)):

package/sidecar/talaria_sidecar/methods/profiles.py

@@ -18,6 +18,7 @@ from pathlib import Path
 from ..errors import InvalidParams, RpcError
 from ..home import profile_home_param
 from ..rpc import CallContext
+from .config import yaml_parser
 
 log = logging.getLogger("talaria_sidecar.profiles")
 _PROFILE_ID_RE = re.compile(r"[a-z0-9][a-z0-9_-]{0,63}")
@@ -34,12 +35,12 @@ _TERMINAL_ENV = {
 
 
 def _yaml_load(path: Path):
-    try:
-        import yaml
-    except Exception:  # noqa: BLE001
+    """A YAML mapping, or None when the file is absent or malformed; a missing parser raises ``yaml_unavailable``."""
+    if not path.exists():
         return None
+    parser = yaml_parser()
     try:
-        data = yaml.safe_load(path.read_text(encoding="utf-8")) if path.exists() else None
+        data = parser.safe_load(path.read_text(encoding="utf-8"))
     except Exception:  # noqa: BLE001
         return None
     return data if isinstance(data, dict) else None

package/sidecar/talaria_sidecar/methods/providers.py

@@ -11,6 +11,9 @@ from __future__ import annotations
 
 import dataclasses
 import logging
+import sys
+import threading
+from pathlib import Path
 from typing import Any
 
 from ..errors import InvalidParams, RpcError
@@ -61,19 +64,176 @@ def auth_status(provider_id: str | None) -> dict:
     return _plain(status) if isinstance(status, dict) else {"logged_in": bool(status)}
 
 
+def _module_dir(module: Any) -> Path | None:
+    try:
+        return Path(module.__file__).resolve().parent
+    except Exception:  # noqa: BLE001 - namespace/builtin modules have no file
+        return None
+
+
+# The Agent's module-name prefix for provider plugins it imports from a ``$HERMES_HOME`` (``providers._import_plugin_dir``).
+_USER_PLUGIN_MODULE = "_hermes_user_provider_"
+_LOAD_LOCK = threading.Lock()
+_LOAD_ATTEMPTED: set[Path] = set()
+
+
+def _user_plugin_profiles() -> dict[int, tuple[Any, Path]]:
+    """Each registered profile a ``$HERMES_HOME`` provider plugin module holds, with that module's directory."""
+    from providers import list_providers
+    from providers.base import ProviderProfile
+
+    registered = {id(p) for p in list_providers()}
+    out: dict[int, tuple[Any, Path]] = {}
+    for name, module in list(sys.modules.items()):
+        directory = _module_dir(module) if module is not None and name.startswith(_USER_PLUGIN_MODULE) else None
+        if directory is None:
+            continue
+        for value in list(vars(module).values()):
+            if isinstance(value, ProviderProfile) and id(value) in registered:
+                out.setdefault(id(value), (value, directory))
+    return out
+
+
+def _load_plugin(root: Path) -> None:
+    """Load the scoped profile's installed plugin that the process-wide discovery (run under the launch profile) skipped.
+
+    Uses the Agent's own loader, as ``hermes plugins dev`` does, once per directory. A plugin never displaces a provider
+    that is already registered, so one profile's plugin cannot change what another profile's provider id runs.
+    """
+    import providers
+
+    with _LOAD_LOCK:
+        if root in _LOAD_ATTEMPTED:
+            return
+        _LOAD_ATTEMPTED.add(root)
+        before = {p.name: p for p in providers.list_providers()}
+        try:
+            providers._import_plugin_dir(root, "user")
+        except Exception:  # noqa: BLE001 - a broken plugin reads as not loaded
+            log.debug("loading provider plugin %s failed", root, exc_info=True)
+            return
+        after = {p.name: p for p in providers.list_providers()}
+        for name, previous in before.items():
+            if after.get(name) is not previous:
+                providers.register_provider(previous)
+
+
+def installed_plugin_profiles() -> list[tuple[str, Any]]:
+    """``(manifest name, profile | None)`` for each enabled model-provider plugin installed in the scoped home.
+
+    Bundled providers are built-ins, not plugins. The Agent keeps one provider registry per process, so a profile
+    belongs to this home only when the plugin module that registered it lives in one of this home's plugin
+    directories; a plugin the launch discovery skipped is loaded here. ``None`` means the plugin could not be loaded:
+    it failed to import, its provider id is taken by another plugin, or another profile's plugin has the same directory
+    name. ponytail: ownership is read from the plugin module's globals, so a plugin that registers an unbound inline
+    profile also reads as not loaded; track registrations in the Agent if one ever does.
+    """
+    try:
+        from hermes_cli.plugins_discovery import _get_disabled_plugins, _get_enabled_plugins, collect_directory_manifests, gate_manifest
+    except Exception as exc:  # noqa: BLE001
+        raise RpcError(f"plugin providers unavailable: {exc}", condition="plugins_unavailable") from exc
+    disabled, enabled = _get_disabled_plugins(), _get_enabled_plugins()
+    roots = {
+        Path(m.path).resolve(): str(m.name)
+        for m in collect_directory_manifests()
+        if m.kind == "model-provider" and m.source == "user" and m.path and gate_manifest(m, disabled, enabled).enabled
+    }
+    if not roots:
+        return []
+
+    def owned() -> dict[Path, list]:
+        found: dict[Path, list] = {root: [] for root in roots}
+        for profile, directory in _user_plugin_profiles().values():
+            root = next((r for r in roots if directory == r or r in directory.parents), None)
+            if root is not None:
+                found[root].append(profile)
+        return found
+
+    found = owned()
+    missing = [root for root, profiles in found.items() if not profiles]
+    if missing:
+        for root in missing:
+            _load_plugin(root)
+        found = owned()
+    return [(name, p) for root, name in roots.items() for p in (found[root] or [None])]
+
+
+def _other_profile_plugin(provider_id: str) -> bool:
+    """Whether ``provider_id`` is a plugin provider that another profile installed (the registry is process-wide)."""
+    from providers import get_provider_profile
+
+    profile = get_provider_profile(provider_id)
+    if profile is None or id(profile) not in _user_plugin_profiles():
+        return False
+    return not any(p is profile for _name, p in installed_plugin_profiles())
+
+
+def _setup_state(profile: Any) -> str:
+    """The Agent's own setup verdict for a plugin provider, without spawning its CLI or reading its credentials."""
+    try:
+        status = auth_status(profile.name)
+    except RpcError:
+        return "unavailable"
+    if status.get("error"):
+        return "unavailable"
+    if profile.auth_type == "external_process":
+        return "ready" if status.get("configured") else "missing_cli"
+    return "ready" if status.get("logged_in") or status.get("configured") else "needs_setup"
+
+
+def plugin_providers() -> list[dict]:
+    """Sanitized rows for this profile's enabled model-provider plugins: identity and setup state, no paths or secrets."""
+    rows = []
+    for manifest_name, profile in installed_plugin_profiles():
+        if profile is None:
+            rows.append({"name": manifest_name, "display_name": manifest_name, "auth_type": "", "setup": "not_loaded"})
+            continue
+        name = str(profile.name).strip().lower()
+        rows.append({"name": name, "display_name": str(profile.display_name or name).strip(), "auth_type": str(profile.auth_type), "setup": _setup_state(profile)})
+    return rows
+
+
+def _plugin_catalog(provider_id: str) -> list[str]:
+    """Discovery for an installed plugin the Agent's catalog has no fetcher for: the profile's own listing, then its fallback.
+
+    API-key plugins already get both from ``provider_model_ids`` with their key, so only keyless auth types list here.
+    """
+    for _name, profile in installed_plugin_profiles():
+        if profile is None or str(profile.name).strip().lower() != provider_id.strip().lower():
+            continue
+        try:
+            live = profile.fetch_models(timeout=8.0) if profile.supports_model_listing and profile.auth_type != "api_key" else None
+        except Exception:  # noqa: BLE001 - a broken plugin answers with its fallback catalog
+            log.debug("fetch_models(%r) failed", provider_id, exc_info=True)
+            live = None
+        return [str(m) for m in (live or profile.fallback_models or ()) if m]
+    return []
+
+
 def model_ids(provider_id: str, *, force_refresh: bool) -> list[str]:
     try:
         from hermes_cli.models import provider_model_ids
     except Exception as exc:  # noqa: BLE001
         raise RpcError(f"model catalog unavailable: {exc}", condition="providers_unavailable") from exc
+    try:
+        if _other_profile_plugin(provider_id):
+            return []
+    except Exception:  # noqa: BLE001 - no readable provider registry means no plugin to keep apart
+        log.debug("plugin ownership check for %r failed", provider_id, exc_info=True)
     try:
         ids = provider_model_ids(provider_id, force_refresh=force_refresh)
     except TypeError:
         ids = provider_model_ids(provider_id)
     except Exception:  # noqa: BLE001
         log.debug("provider_model_ids(%r) failed", provider_id, exc_info=True)
+        ids = []
+    ids = [str(m) for m in (ids or []) if m]
+    if ids:
+        return ids
+    try:
+        return _plugin_catalog(provider_id)
+    except RpcError:
         return []
-    return [str(m) for m in (ids or []) if m]
 
 
 def resolve_runtime(*, requested: str | None, api_key: str | None, base_url: str | None, target_model: str | None) -> dict:

package/sidecar/talaria_sidecar/methods/runtime.py

@@ -7,6 +7,7 @@ import re
 
 from .. import SIDECAR_RPC_VERSION
 from ..errors import InvalidParams, RpcError
+from ..home import edit_launch_env
 from ..rpc import CallContext
 
 
@@ -53,6 +54,7 @@ def register(registry) -> None:
             os.environ.pop(name, None)
         for name, value in to_set.items():
             os.environ[name] = value
+        edit_launch_env(to_set, to_unset)
         # Cached agents bound the credentials they were built with; none of them may outlive a credential change.
         from .chat import evict_all_agents
 

package/sidecar/talaria_sidecar/methods/text.py

@@ -1,28 +1,16 @@
 """``text.*``: pure helpers from the Agent that the server must match exactly
-(redaction patterns, image input routing, portal tags)."""
+(image input routing, portal tags)."""
 
 from __future__ import annotations
 
 import logging
 
-from ..errors import InvalidParams
 from ..home import profile_home_param, scoped_home
 from ..rpc import CallContext
 
 log = logging.getLogger("talaria_sidecar.text")
 
 
-def redact(text: str, *, force: bool = True) -> str:
-    try:
-        from agent.redact import redact_sensitive_text
-    except Exception:  # noqa: BLE001
-        return text
-    try:
-        return redact_sensitive_text(text, force=force)
-    except TypeError:
-        return redact_sensitive_text(text)
-
-
 def image_mode(*, provider: str, model: str, cfg: dict | None, requested_provider: str) -> dict:
     """``native`` or ``text`` for current-turn image uploads, as the Agent decides it."""
     try:
@@ -66,13 +54,6 @@ def portal_tags() -> dict:
 
 
 def register(registry) -> None:
-    @registry.method("text.redact")
-    def redact_(ctx: CallContext, params: dict) -> dict:
-        text = params.get("text")
-        if not isinstance(text, str):
-            raise InvalidParams("text must be a string")
-        return {"text": redact(text, force=bool(params.get("force", True)))}
-
     @registry.method("text.image_mode")
     def image_mode_(ctx: CallContext, params: dict) -> dict:
         cfg = params.get("cfg") if isinstance(params.get("cfg"), dict) else None

package/sidecar/talaria_sidecar/methods/usage.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import dataclasses
 import logging
+from datetime import date, datetime, timezone
 from typing import Any
 
 from ..errors import InvalidParams, RpcError
@@ -22,6 +23,10 @@ def _plain(value: Any) -> Any:
         return [_plain(v) for v in value]
     if isinstance(value, (str, int, float, bool)) or value is None:
         return value
+    if isinstance(value, datetime) and value.tzinfo is not None:
+        return value.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
+    if isinstance(value, date):
+        return value.isoformat()
     if hasattr(value, "__dict__"):
         return {k: _plain(v) for k, v in vars(value).items() if not k.startswith("_")}
     return str(value)
@@ -45,7 +50,8 @@ def account(provider: str, *, base_url: str | None, api_key: str | None) -> dict
     row.setdefault("provider", provider)
     row["windows"] = [w for w in (row.get("windows") or []) if isinstance(w, dict)]
     row["details"] = list(row.get("details") or [])
-    row["available"] = bool(row.get("available"))
+    # The Agent's `available` is a property, which `_plain` (asdict/vars) never sees; read it off the snapshot.
+    row["available"] = bool(getattr(snapshot, "available", row.get("available")))
     return row