@maudecode/talaria-web 1.15.0 → 1.17.2

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
 
@@ -64,5 +66,8 @@ def register(registry) -> None:
         code = params.get("exit_code", 0)
         if not isinstance(code, int):
             raise InvalidParams("exit_code must be an integer")
+        from .chat import drain_agents
+
+        drain_agents()
         ctx.server.request_shutdown(exit_code=code)
         return {"ok": True}

package/sidecar/talaria_sidecar/methods/text.py

@@ -1,34 +1,22 @@
 """``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:
         from agent.image_routing import decide_image_input_mode
     except Exception:  # noqa: BLE001
-        return {"mode": "text", "reason": "image routing unavailable"}
+        return {"mode": "text", "reason": "image routing unavailable", "supports_vision": None}
     try:
         decision = decide_image_input_mode(provider, model, cfg, requested_provider=requested_provider)
     except TypeError:
@@ -46,6 +34,18 @@ def image_mode(*, provider: str, model: str, cfg: dict | None, requested_provide
     return {"mode": str(decision or "text"), "reason": "", "supports_vision": supports_vision}
 
 
+def _profile_config() -> dict | None:
+    """The scoped profile's ``config.yaml``; None when the Agent cannot load it."""
+    try:
+        from hermes_cli.config import load_config
+
+        cfg = load_config()
+    except Exception:  # noqa: BLE001
+        log.debug("image mode config load failed", exc_info=True)
+        return None
+    return cfg if isinstance(cfg, dict) else None
+
+
 def portal_tags() -> dict:
     try:
         from agent.portal_tags import conversation_tag, hermes_client_tag, nous_portal_tags
@@ -66,17 +66,14 @@ 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
         with scoped_home(profile_home_param(params)):
+            # TAL-545: without an explicit cfg the profile's config.yaml decides, so its vision overrides
+            # (``agent.image_input_mode``, ``supports_vision``) apply as they do for the Agent's own turn.
+            if cfg is None:
+                cfg = _profile_config()
             return image_mode(provider=str(params.get("provider") or ""), model=str(params.get("model") or ""), cfg=cfg, requested_provider=str(params.get("requested_provider") or ""))
 
     @registry.method("text.portal_tags")

package/sidecar/talaria_sidecar/methods/usage.py

@@ -1,9 +1,16 @@
-"""``usage.*``: provider account usage through ``agent.account_usage``."""
+"""``usage.*``: provider account usage through ``agent.account_usage``, the credential pool's local per-entry
+state, and the key-based balance endpoints (TAL-548). Pool keys never leave the sidecar."""
 
 from __future__ import annotations
 
 import dataclasses
+import json
 import logging
+import math
+import time
+import urllib.error
+import urllib.request
+from datetime import date, datetime, timezone
 from typing import Any
 
 from ..errors import InvalidParams, RpcError
@@ -22,18 +29,246 @@ 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)
 
 
-def account(provider: str, *, base_url: str | None, api_key: str | None) -> dict | None:
+def _iso(epoch: float | None) -> str | None:
+    return None if epoch is None else datetime.fromtimestamp(epoch, tz=timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+# Python `_is_ambient_gh_cli_entry`: a seeded `gh` CLI or GitHub env token is not an account the user added.
+_AMBIENT_GH_SOURCES = frozenset({"gh_cli", "gh auth token", "env:github_token", "env:gh_token"})
+
+
+def _is_ambient(entry) -> bool:
+    return any(str((entry.get(k) if isinstance(entry, dict) else getattr(entry, k, "")) or "").strip().lower() in _AMBIENT_GH_SOURCES for k in ("source", "label", "key_source"))
+
+
+def pool_providers() -> list[str]:
+    """Providers whose persisted credential pool holds an account the user added; a read of ``auth.json`` with no seeding."""
+    try:
+        from hermes_cli.auth import read_credential_pool
+    except Exception as exc:  # noqa: BLE001
+        raise RpcError(f"credential pool unavailable: {exc}", condition="usage_unavailable") from exc
+    try:
+        pools = read_credential_pool()
+    except Exception:  # noqa: BLE001
+        log.debug("read_credential_pool() failed", exc_info=True)
+        return []
+    return sorted(str(pid) for pid, entries in (pools or {}).items()
+                  if isinstance(entries, list) and any(isinstance(e, dict) and str(e.get("id") or "").strip() and not _is_ambient(e) for e in entries))
+
+
+def _pool(provider: str) -> tuple[Any, list]:
+    """The Agent's credential pool for the scoped profile and its non-ambient entries; ``(None, [])`` when unreadable."""
+    try:
+        from agent.credential_pool import load_pool
+    except Exception as exc:  # noqa: BLE001
+        raise RpcError(f"credential pool unavailable: {exc}", condition="usage_unavailable") from exc
+    try:
+        pool = load_pool(provider)
+        entries = list(pool.entries()) if pool is not None else []
+    except Exception:  # noqa: BLE001
+        log.debug("load_pool(%r) failed", provider, exc_info=True)
+        return None, []
+    return pool, [e for e in entries if not _is_ambient(e)]
+
+
+def _entry(provider: str, credential_id: str):
+    return next((e for e in _pool(provider)[1] if str(getattr(e, "id", "") or "").strip() == credential_id), None)
+
+
+def _entry_key(entry) -> str:
+    """Python `_get_provider_api_key(provider, credential_id)`: the entry's runtime key."""
+    for name in ("runtime_api_key", "agent_key", "access_token"):
+        try:
+            value = str(getattr(entry, name, "") or "").strip()
+        except Exception:  # noqa: BLE001 - a runtime key property that cannot resolve
+            value = ""
+        if value:
+            return value
+    return ""
+
+
+def _label(entry, index: int) -> str:
+    """Python `_safe_entry_label`."""
+    label = " ".join(str(getattr(entry, "label", "") or getattr(entry, "source", "") or f"Credential {index}").split())
+    return label[:61].rstrip() + "..." if len(label) > 64 else label
+
+
+def pool(provider: str, *, api_key: str | None = None) -> list[dict]:
+    """Python `_local_pool_snapshot` rows: one per pool entry with an id, its local status, whether it holds the
+    server-resolved ``api_key``, and no secrets."""
+    agent_pool, entries = _pool(provider)
+    configured = str(api_key or "").strip()
+    try:
+        from agent.credential_pool import _exhausted_until
+    except Exception:  # noqa: BLE001 - an Agent without it cannot date an exhausted mark, so the entry reads as available
+        def _exhausted_until(entry, *, sole_credential=False):
+            return None
+    sole_fn = getattr(agent_pool, "_is_sole_credential", None)
+    sole = bool(sole_fn()) if callable(sole_fn) else len(entries) == 1
+    rows = []
+    for index, entry in enumerate(entries, start=1):
+        credential_id = str(getattr(entry, "id", "") or "").strip()
+        if not credential_id:
+            continue
+        row = {"credential_id": credential_id, "label": _label(entry, index), "status": "available", "unavailable_reason": None, "retry_after": None,
+               "matches_api_key": bool(configured) and _entry_key(entry) == configured}
+        status = str(getattr(entry, "last_status", "") or "").strip().lower()
+        until = _exhausted_until(entry, sole_credential=sole) if status == "exhausted" else None
+        if status == "dead":
+            row.update(status="dead", unavailable_reason="Credential permanently revoked or invalid.")
+        elif until is not None and time.time() < until:
+            retry_after = _iso(until)
+            code = getattr(entry, "last_error_code", None)
+            reason = "Credential pool marked this credential exhausted" + (f" after provider status {code}" if code else "") + (f"; retry after {retry_after}" if retry_after else "")
+            row.update(status="exhausted", unavailable_reason=reason + ".", retry_after=retry_after)
+        rows.append(row)
+    return rows
+
+
+_BALANCE_URLS = {
+    "openrouter": "https://openrouter.ai/api/v1/key",
+    "deepseek": "https://api.deepseek.com/user/balance",
+    "opencode-go": "https://opencode.ai/zen/go/v1/usage",
+}
+_BALANCE_TIMEOUT_SECONDS = 15.0
+_BALANCE_MAX_BYTES = 256 * 1024
+
+
+def _number(value: Any) -> int | float | None:
+    """Python `_quota_number`, finite only: a NaN or infinity is not JSON."""
+    if isinstance(value, bool) or value is None:
+        return None
+    if isinstance(value, int):
+        return value
+    try:
+        number = float(value if isinstance(value, float) else str(value).strip())
+    except (TypeError, ValueError):
+        return None
+    if not math.isfinite(number):
+        return None
+    return int(number) if number.is_integer() and not isinstance(value, float) else number
+
+
+def _openrouter(payload: Any) -> dict | None:
+    data = payload.get("data") if isinstance(payload, dict) and isinstance(payload.get("data"), dict) else payload
+    data = data if isinstance(data, dict) else {}
+    return {"quota": {k: _number(data.get(k)) for k in ("limit_remaining", "usage", "limit")}, "label": str(data.get("label") or "").strip() or None}
+
+
+def _deepseek(payload: Any) -> dict | None:
+    """Python `_sanitize_deepseek_balances`: CNY/USD rows with a total, plus the account's `is_available`."""
+    if not isinstance(payload, dict) or not isinstance(payload.get("is_available"), bool):
+        return None
+    balances = []
+    for row in payload.get("balance_infos") or []:
+        if not isinstance(row, dict):
+            continue
+        currency = str(row.get("currency") or "").strip().upper()
+        total = _number(row.get("total_balance"))
+        if currency in {"CNY", "USD"} and total is not None:
+            balances.append({"currency": currency, "total": total, "granted": _number(row.get("granted_balance")), "topped_up": _number(row.get("topped_up_balance"))})
+    return {"balances": balances, "is_available": payload["is_available"]} if balances else None
+
+
+def _opencode_go(payload: Any) -> dict | None:
+    """Python `_sanitize_opencode_go_account_limits`: all three windows, each well-formed, or nothing."""
+    usage = payload.get("usage") if isinstance(payload, dict) else None
+    if not isinstance(usage, dict):
+        return None
+    windows = []
+    for key in ("rolling", "weekly", "monthly"):
+        window = usage.get(key)
+        if not isinstance(window, dict) or window.get("status") not in {"ok", "rate-limited"}:
+            return None
+        used = _number(window.get("percent"))
+        try:
+            reset_at = datetime.fromisoformat(str(window.get("resetsAt") or "").strip().replace("Z", "+00:00"))
+        except ValueError:
+            return None
+        if used is None or not 0 <= used <= 100:
+            return None
+        reset_at = reset_at if reset_at.tzinfo else reset_at.replace(tzinfo=timezone.utc)
+        windows.append({"key": key, "used_percent": used, "reset_at": _iso(reset_at.timestamp()), "rate_limited": window["status"] == "rate-limited"})
+    return {"windows": windows}
+
+
+_BALANCE_PARSERS = {"openrouter": _openrouter, "deepseek": _deepseek, "opencode-go": _opencode_go}
+
+
+def balance(provider: str, *, credential_id: str | None, api_key: str | None) -> dict:
+    """One key-based balance read. A pool credential's key resolves here; otherwise the server passes the configured key."""
+    result = {"status": "unavailable", "http_status": None, "quota": None, "label": None, "is_available": None, "balances": [], "windows": []}
+    key = str(api_key or "").strip()
+    if credential_id:
+        entry = _entry(provider, credential_id)
+        key = _entry_key(entry) if entry is not None else ""
+    if not key:
+        return {**result, "status": "no_key"}
+    request = urllib.request.Request(_BALANCE_URLS[provider], headers={"Authorization": f"Bearer {key}", "Accept": "application/json", "User-Agent": "Talaria-Web/1.0"})
+    try:
+        with urllib.request.urlopen(request, timeout=_BALANCE_TIMEOUT_SECONDS) as response:
+            raw = response.read(_BALANCE_MAX_BYTES + 1)
+        if len(raw) > _BALANCE_MAX_BYTES:
+            raise ValueError("oversized balance response")
+        parsed = _BALANCE_PARSERS[provider](json.loads(raw.decode("utf-8")))
+    except urllib.error.HTTPError as exc:
+        return {**result, "status": "http_error", "http_status": exc.code}
+    except (OSError, ValueError):  # URLError and timeouts are OSErrors; malformed JSON or UTF-8 are ValueErrors
+        log.debug("%s balance read failed", provider, exc_info=True)
+        return result
+    return {**result, **parsed, "status": "ok"} if parsed is not None else result
+
+
+_ANTHROPIC_WINDOWS = (("five_hour", "Current session"), ("seven_day", "Current week"), ("seven_day_opus", "Opus week"), ("seven_day_sonnet", "Sonnet week"))
+
+
+def _anthropic_usage(token: str):
+    """The Agent's Anthropic account-usage read for one given token. The Agent's fetcher reads only the ambient token, so a
+    pool account would otherwise report the active account's limits."""
+    # ponytail: mirrors agent.account_usage._fetch_anthropic_account_usage on the Agent's own helpers; drop it once that
+    # fetcher honours its api_key argument.
+    from agent import account_usage as agent_usage
+
+    if not agent_usage._is_oauth_token(token):
+        return agent_usage._snapshot("anthropic", "oauth_usage_api", [], [], unavailable_reason="Anthropic account limits are only available for OAuth-backed Claude accounts.")
+    headers = {"Authorization": f"Bearer {token}", "Accept": "application/json", "Content-Type": "application/json",
+               "anthropic-beta": "oauth-2025-04-20", "User-Agent": "claude-code/2.1.0"}
+    payload = agent_usage._get_json("https://api.anthropic.com/api/oauth/usage", headers, timeout=15.0)
+    windows = agent_usage._usage_windows(payload, _ANTHROPIC_WINDOWS, "utilization", "resets_at", fraction=True)
+    extra = payload.get("extra_usage") or {}
+    used, limit = extra.get("used_credits"), extra.get("monthly_limit")
+    details = [f"Extra usage: {used:.2f} / {limit:.2f} {extra.get('currency') or 'USD'}"] if extra.get("is_enabled") and agent_usage._is_num(used) and agent_usage._is_num(limit) else []
+    return agent_usage._snapshot("anthropic", "oauth_usage_api", windows, details)
+
+
+def account(provider: str, *, base_url: str | None, api_key: str | None, credential_id: str | None = None) -> dict | None:
+    if credential_id:
+        # One pool account's usage, read with that account's own key.
+        entry = _entry(provider, credential_id)
+        if entry is None:
+            return None
+        api_key = _entry_key(entry)
+        if not api_key:
+            return {"provider": provider, "available": False, "unavailable_reason": "No runtime token available.", "windows": [], "details": []}
+        base_url = str(getattr(entry, "runtime_base_url", None) or getattr(entry, "base_url", None) or "").strip() or base_url
     try:
         from agent.account_usage import fetch_account_usage
     except Exception as exc:  # noqa: BLE001
         raise RpcError(f"account usage unavailable: {exc}", condition="usage_unavailable") from exc
     try:
-        snapshot = fetch_account_usage(provider, base_url=base_url, api_key=api_key)
+        if credential_id and provider == "anthropic":
+            snapshot = _anthropic_usage(api_key)
+        else:
+            snapshot = fetch_account_usage(provider, base_url=base_url, api_key=api_key)
     except Exception as exc:  # noqa: BLE001
         log.debug("fetch_account_usage(%r) failed", provider, exc_info=True)
         return {"provider": provider, "available": False, "unavailable_reason": f"{type(exc).__name__}: {exc}", "windows": [], "details": []}
@@ -45,7 +280,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
 
 
@@ -55,5 +291,28 @@ def register(registry) -> None:
         provider = str(params.get("provider") or "").strip()
         if not provider:
             raise InvalidParams("provider is required")
+        credential_id = str(params.get("credential_id") or "").strip() or None
+        with scoped_home(profile_home_param(params)):
+            return {"snapshot": account(provider, base_url=params.get("base_url"), api_key=params.get("api_key"), credential_id=credential_id)}
+
+    @registry.method("usage.pool")
+    def pool_(ctx: CallContext, params: dict) -> dict:
+        provider = str(params.get("provider") or "").strip()
+        if not provider:
+            raise InvalidParams("provider is required")
+        with scoped_home(profile_home_param(params)):
+            return {"entries": pool(provider, api_key=params.get("api_key"))}
+
+    @registry.method("usage.pool_providers")
+    def pool_providers_(ctx: CallContext, params: dict) -> dict:
+        with scoped_home(profile_home_param(params)):
+            return {"providers": pool_providers()}
+
+    @registry.method("usage.balance")
+    def balance_(ctx: CallContext, params: dict) -> dict:
+        provider = str(params.get("provider") or "").strip()
+        if provider not in _BALANCE_URLS:
+            raise InvalidParams(f"provider must be one of {sorted(_BALANCE_URLS)}")
+        credential_id = str(params.get("credential_id") or "").strip() or None
         with scoped_home(profile_home_param(params)):
-            return {"snapshot": account(provider, base_url=params.get("base_url"), api_key=params.get("api_key"))}
+            return balance(provider, credential_id=credential_id, api_key=params.get("api_key"))