@maudecode/talaria-web 1.15.0 → 1.16.1

package/sidecar/talaria_sidecar/home.py

@@ -14,12 +14,19 @@ fall through to another profile's process environment. Agent 0.21.3 has the
 multiplex switch and secret scopes but not the launch-profile policy module, so
 the sidecar mirrors that policy for it. If the installed Agent has no secret
 scope, named-profile calls fail closed instead.
+
+Terminal policy follows the same split. Under a home override the Agent skips its
+config-to-env terminal bridge, so every call also binds the profile's complete
+``TERMINAL_*`` scope from its own ``.env`` and ``config.yaml``; the launch profile layers
+its launch-process ``TERMINAL_*`` under those files.
 """
 
 from __future__ import annotations
 
 import contextlib
+import importlib
 import os
+import sys
 import threading
 from pathlib import Path
 
@@ -47,6 +54,24 @@ def _frozen_launch_env() -> dict[str, str]:
         return dict(_LAUNCH_ENV)
 
 
+def edit_launch_env(to_set: dict[str, str], to_unset: list[str]) -> None:
+    """Carry a Web-owned ``.env`` edit into the frozen launch environments, so a removed credential stops resolving for the launch profile."""
+
+    def edit(snapshot: dict[str, str] | None) -> None:
+        if snapshot is not None:
+            for name in to_unset:
+                snapshot.pop(name, None)
+            snapshot.update(to_set)
+
+    with _LAUNCH_ENV_LOCK:
+        edit(_LAUNCH_ENV)
+    # Only an imported policy module can hold a frozen snapshot; importing it waits out a first import still running elsewhere.
+    if sys.modules.get("tui_gateway.launch_profile_policy") is not None:
+        policy = importlib.import_module("tui_gateway.launch_profile_policy")
+        with policy._lock:
+            edit(policy._snapshot)
+
+
 def _activate_multi_profile_hosting() -> None:
     """Agent 0.21.3 twin of ``tui_gateway.launch_profile_policy.activate_multi_profile_hosting``."""
     from agent.secret_scope import set_multiplex_active
@@ -99,6 +124,38 @@ def _secret_scope(home: Path):
         reset_secret_scope(scope_token)
 
 
+@contextlib.contextmanager
+def _terminal_scope(home: Path):
+    """Install ``home``'s terminal policy for the call; a policy file that cannot be read refuses terminal execution."""
+    named = _is_named_profile(home)
+    try:
+        from tools.terminal_scope import install_profile_terminal_scope, reset_terminal_scope
+    except Exception:  # noqa: BLE001 - older Agent without terminal scopes
+        if named:
+            raise RpcError(
+                "profile terminal isolation is unavailable in this Hermes Agent; named-profile calls are refused",
+                condition="agent_incompatible",
+            )
+        yield
+        return
+    if named:
+        token = install_profile_terminal_scope(home)
+    else:
+        try:
+            from agent.secret_scope import is_multiplex_active
+            from tui_gateway.launch_profile_policy import launch_terminal_env
+        except ImportError:  # Agent 0.21.3 cannot layer the launch env, so the launch profile keeps the process env
+            yield
+            return
+        # Like the launch secret scope: the live process env until multiplexing freezes it.
+        launch = launch_terminal_env() if is_multiplex_active() else {k: v for k, v in os.environ.items() if k.startswith("TERMINAL_")}
+        token = install_profile_terminal_scope(home, env_overlay=launch)
+    try:
+        yield
+    finally:
+        reset_terminal_scope(token)
+
+
 def profile_home_param(params: dict, key: str = "profile_home") -> Path:
     raw = params.get(key)
     if not isinstance(raw, str) or not raw.strip():
@@ -117,7 +174,7 @@ def scoped_home(home: Path):
     if set_hermes_home_override is not None:
         token = set_hermes_home_override(home)
         try:
-            with _secret_scope(home):
+            with _secret_scope(home), _terminal_scope(home):
                 yield home
         finally:
             reset_hermes_home_override(token)
@@ -126,7 +183,7 @@ def scoped_home(home: Path):
         previous = os.environ.get("HERMES_HOME")
         os.environ["HERMES_HOME"] = str(home)
         try:
-            with _secret_scope(home):
+            with _secret_scope(home), _terminal_scope(home):
                 yield home
         finally:
             if previous is None:

package/sidecar/talaria_sidecar/methods/__init__.py

@@ -29,9 +29,9 @@ class Registry:
 
 def build_methods(runtime: AgentRuntime) -> dict[str, Handler]:
     registry = Registry(runtime)
-    from . import aux, chat, commands, config, cron, gateway, goals, kanban, mcp, process, profiles, providers, skills, state_db, stt, text, usage, worktree  # noqa: WPS433
+    from . import aux, chat, commands, config, cron, gateway, goals, kanban, mcp, oauth, process, profiles, providers, skills, state_db, stt, text, usage, worktree  # noqa: WPS433
     from . import runtime as runtime_methods
 
-    for module in (runtime_methods, goals, commands, kanban, state_db, profiles, skills, mcp, stt, cron, providers, aux, text, process, usage, gateway, worktree, chat, config):
+    for module in (runtime_methods, goals, commands, kanban, state_db, profiles, skills, mcp, stt, cron, providers, oauth, aux, text, process, usage, gateway, worktree, chat, config):
         module.register(registry)
     return registry.methods

package/sidecar/talaria_sidecar/methods/aux.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import logging
 import threading
 import uuid
@@ -39,8 +40,10 @@ def resolve_main_runtime(hint: dict | None) -> dict | None:
 
 
 def _main_model_completion(messages: list, runtime: dict, *, task: str) -> dict:
-    """Predecessor fallback: run the main model through ``AIAgent`` with no tools when no auxiliary client answers."""
-    from .chat import _agent_class
+    """Predecessor fallback: run the main model through ``AIAgent`` with no tools when no auxiliary client answers.
+
+    The throwaway agent never touches long-term memory (the prompt is a raw git diff) and is always closed."""
+    from .chat import _agent_class, _supported
 
     AIAgent = _agent_class()
 
@@ -51,8 +54,21 @@ def _main_model_completion(messages: list, runtime: dict, *, task: str) -> dict:
     for name in ("api_mode", "acp_command", "acp_args", "credential_pool"):
         if runtime.get(name) is not None:
             kwargs[name] = runtime[name]
+    for name in ("skip_memory", "skip_background_review"):
+        if _supported(AIAgent, name):
+            kwargs[name] = True
     agent = AIAgent(**kwargs)
-    result = agent.run_conversation(user_message=user, system_message=system, conversation_history=[], task_id=kwargs["session_id"])
+    try:
+        result = agent.run_conversation(user_message=user, system_message=system, conversation_history=[], task_id=kwargs["session_id"])
+    finally:
+        with contextlib.suppress(Exception):
+            agent._end_session_on_close = False
+        close = getattr(agent, "close", None)
+        if callable(close):
+            try:
+                close()
+            except Exception:  # noqa: BLE001
+                log.debug("%s fallback agent close failed", task, exc_info=True)
     return {"model": str(runtime.get("model") or ""), "text": str((result or {}).get("final_response") or "").strip(), "usage": None}
 
 

package/sidecar/talaria_sidecar/methods/chat.py

@@ -11,6 +11,7 @@ through ``approval.respond`` / ``clarify.respond``; ``rpc.cancel`` or
 from __future__ import annotations
 
 import contextlib
+import contextvars
 import hashlib
 import inspect
 import json
@@ -372,7 +373,7 @@ def _resolve_runtime(provider: str | None, model: str) -> dict:
 def _turn_identity(session_id: str, workspace: str):
     """Bind this turn's identity to the calling context the way the predecessor's ``_set_turn_session_identity`` did:
     the approval session key (so ``register_gateway_notify`` cards reach this turn and dangerous commands are gated
-    instead of auto-approved), the gateway session vars (platform ``webui``, chat/ui session ids), and the session cwd
+    instead of auto-approved), the gateway session vars (platform ``webui``, chat/ui session ids, profile), and the session cwd
     (so terminals and AGENTS.md discovery run in the selected workspace, not the sidecar's launch directory). Every
     binding is a context variable, so concurrent turns cannot overwrite each other. Missing Agent surfaces are logged,
     not fatal."""
@@ -388,10 +389,14 @@ def _turn_identity(session_id: str, workspace: str):
         log.debug("per-turn approval session-key bind failed", exc_info=True)
     try:
         from gateway import session_context as sc
+        from hermes_cli.profiles import get_active_profile_name
+        from hermes_constants import get_hermes_home, profile_name_for_home
 
+        # The persistent Docker sandbox is keyed by the profile name; unbound, every profile reuses "default".
+        profile = profile_name_for_home(get_hermes_home()) or get_active_profile_name()
         pairs = [
             (sc._SESSION_KEY, session_id), (sc._SESSION_UI_SESSION_ID, session_id), (sc._SESSION_PLATFORM, "webui"),
-            (sc._SESSION_CHAT_ID, session_id), (sc._SESSION_ID, session_id),
+            (sc._SESSION_CHAT_ID, session_id), (sc._SESSION_ID, session_id), (sc._SESSION_PROFILE, profile),
         ]
         for var, value in pairs:
             tok = var.set(value)
@@ -415,6 +420,63 @@ def _turn_identity(session_id: str, workspace: str):
                 log.debug("per-turn identity reset failed", exc_info=True)
 
 
+#: Older configs named the CLI composite ``hermes``; the Agent registers it split in two (predecessor
+#: ``_LEGACY_CLI_TOOLSET_ALIASES``).
+_LEGACY_TOOLSET_ALIASES = {"hermes": ("hermes-cli", "hermes-api-server")}
+
+
+def _turn_toolsets(toolsets) -> list[str]:
+    """The session's override as sent, else the profile's configured toolsets. ``None`` would hand the Agent every
+    registered toolset."""
+    return toolsets if isinstance(toolsets, list) else _profile_toolsets()
+
+
+def _profile_toolsets() -> list[str]:
+    """The profile's ``platform_toolsets.cli`` through the Agent's own resolver (default-off toolsets stay off), like
+    ``hermes chat``. Runs under the call's ``scoped_home``."""
+    from hermes_cli.config import load_config
+    from hermes_cli.tools_config import _get_platform_tools
+
+    resolved = sorted(_get_platform_tools(load_config() or {}, "cli"))
+    return list(dict.fromkeys(name for raw in resolved for name in _LEGACY_TOOLSET_ALIASES.get(raw, (raw,))))
+
+
+def _discover_mcp_tools(run: _Run) -> None:
+    """Connect the profile's MCP servers before the turn's agent snapshots its tools, like the predecessor's turn start.
+    The Agent keys connections by profile scope and skips live ones, so later turns are cheap. Runs under the call's
+    ``scoped_home``; a failure leaves the turn without MCP tools rather than failing it. A Stop does not wait for a slow
+    server: the turn moves on to its cancelled end while the connect finishes in the background."""
+    from .commands import retire_unscoped_launch_mcp_servers
+
+    done = threading.Event()
+
+    def discover() -> None:
+        try:
+            from tools.mcp_tool_discovery import discover_mcp_tools
+
+            retire_unscoped_launch_mcp_servers()
+            discover_mcp_tools()
+        except Exception:  # noqa: BLE001
+            log.warning("MCP discovery failed", exc_info=True)
+        finally:
+            done.set()
+
+    # The copied context carries the turn's home override and secret scope into the worker.
+    threading.Thread(target=contextvars.copy_context().run, args=(discover,), daemon=True, name=f"chat-mcp-{run.stream_id[:8]}").start()
+    while not done.wait(0.25):
+        if run.cancel.is_set() or run.ctx.cancelled:
+            return
+
+
+def _profile_fallback_chain() -> list[dict] | None:
+    """The profile's fallback routes (``fallback_providers`` first, then legacy ``fallback_model``, deduplicated)
+    through the Agent's own resolver, like the CLI and gateway. Runs under the call's ``scoped_home``."""
+    from hermes_cli.config import load_config
+    from hermes_cli.fallback_config import get_fallback_chain
+
+    return get_fallback_chain(load_config() or {}) or None
+
+
 def _agent_signature(model: str, provider, runtime: dict, toolsets, home: str, kwargs: dict) -> str:
     """Cache identity of an ``AIAgent``: everything its constructor bound from the resolved runtime, so a rotated key,
     a different API mode, ACP command, or credential pool never reuses an agent built for the old bundle. The key
@@ -430,6 +492,8 @@ def _agent_signature(model: str, provider, runtime: dict, toolsets, home: str, k
         "max_iterations": kwargs.get("max_iterations"), "max_tokens": kwargs.get("max_tokens"),
         # Bound at construction too: a reasoning-effort change from the composer must build a fresh agent.
         "reasoning_config": kwargs.get("reasoning_config"),
+        # Entries may carry their own ``api_key``.
+        "fallback_model": hashlib.sha256(json.dumps(kwargs.get("fallback_model"), sort_keys=True, default=str).encode("utf-8")).hexdigest()[:16],
     }
     return json.dumps(bundle, sort_keys=True, default=str)
 
@@ -472,6 +536,34 @@ def _supported(cls, name: str) -> bool:
     return name in parameters or any(p.kind is inspect.Parameter.VAR_KEYWORD for p in parameters.values())
 
 
+def _approval_notifier(session_id: str, emit):
+    """The Agent's gateway notify callback for one turn: emits each parked approval, then ``approval_resolved``
+    (id plus the Agent's reason) once its wait ends by any path, an ``approvals.timeout`` expiry included (TAL-514)."""
+    try:
+        from tools.approval import register_gateway_settle
+    except Exception:  # noqa: BLE001
+        register_gateway_settle = None
+
+    def notify(data):
+        payload = dict(data or {})
+        payload.setdefault("session_id", session_id)
+        payload.setdefault("approval_id", str(payload.get("request_id") or uuid.uuid4().hex))
+        emit("approval", payload)
+        request_id = str(payload.get("request_id") or "")
+        if register_gateway_settle is None or not request_id:
+            return
+        approval_id = payload["approval_id"]
+
+        def settle(reason):
+            emit("approval_resolved", {"approval_id": approval_id, "session_id": session_id, "reason": str(reason or "")})
+
+        # False: the wait already ended between the emit and this registration.
+        if not register_gateway_settle(session_id, request_id, settle):
+            settle("resolved")
+
+    return notify
+
+
 def start(ctx: CallContext, params: dict) -> dict:  # noqa: PLR0915 - one turn, one function
     session_id = str(params.get("session_id") or "").strip()
     stream_id = str(params.get("stream_id") or "").strip()
@@ -487,7 +579,7 @@ def start(ctx: CallContext, params: dict) -> dict:  # noqa: PLR0915 - one turn,
         history = []
     if not isinstance(history, list):
         raise InvalidParams("conversation_history must be a list")
-    toolsets = params.get("enabled_toolsets")
+    toolsets = _turn_toolsets(params.get("enabled_toolsets"))
     system_message = params.get("system_message")
     run = _Run(stream_id, session_id, ctx)
     with _RUNS_LOCK:
@@ -510,6 +602,7 @@ def start(ctx: CallContext, params: dict) -> dict:  # noqa: PLR0915 - one turn,
                 raw_emit("steer_pending", {"text": pending})
         raw_emit(event, data)
     try:
+        _discover_mcp_tools(run)
         runtime = _resolve_runtime(provider, model)
         resolved_model = model or str(runtime.get("model") or "")
         resolved_provider = provider or runtime.get("provider")
@@ -626,15 +719,7 @@ def start(ctx: CallContext, params: dict) -> dict:  # noqa: PLR0915 - one turn,
             from tools.approval import register_gateway_notify, unregister_gateway_notify
         except Exception:  # noqa: BLE001
             register_gateway_notify = unregister_gateway_notify = None
-        if register_gateway_notify is not None:
-            def _approval_cb(data):
-                payload = dict(data or {})
-                payload.setdefault("session_id", session_id)
-                payload.setdefault("approval_id", str(payload.get("request_id") or uuid.uuid4().hex))
-                emit("approval", payload)
-            approval_cb = _approval_cb
-        else:
-            approval_cb = None
+        approval_cb = _approval_notifier(session_id, emit) if register_gateway_notify is not None else None
 
         kwargs: dict = dict(
             model=resolved_model,
@@ -643,7 +728,7 @@ def start(ctx: CallContext, params: dict) -> dict:  # noqa: PLR0915 - one turn,
             api_key=runtime.get("api_key"),
             platform="webui",
             quiet_mode=True,
-            enabled_toolsets=toolsets if isinstance(toolsets, list) else None,
+            enabled_toolsets=toolsets,
             session_id=session_id,
             stream_delta_callback=on_token,
             reasoning_callback=on_reasoning,
@@ -671,6 +756,9 @@ def start(ctx: CallContext, params: dict) -> dict:  # noqa: PLR0915 - one turn,
         reasoning_config = params.get("reasoning_config")
         if isinstance(reasoning_config, dict) and _supported(AIAgent, "reasoning_config"):
             kwargs["reasoning_config"] = reasoning_config
+        fallback_chain = _profile_fallback_chain()
+        if fallback_chain and _supported(AIAgent, "fallback_model"):
+            kwargs["fallback_model"] = fallback_chain
         signature = _agent_signature(resolved_model, resolved_provider, runtime, toolsets, str(params.get("profile_home")), kwargs)
         agent = None
         if not session_busy:
@@ -772,14 +860,22 @@ def start(ctx: CallContext, params: dict) -> dict:  # noqa: PLR0915 - one turn,
             error = str(last_error)
         if not error and isinstance(result.get("error"), str) and result.get("error"):
             error = str(result["error"])
-        status = "cancelled" if cancelled else ("error" if error and not result.get("messages") else "completed")
+        # The Agent ends a failed turn with ``failed``/``partial`` (never ``status``), often after text streamed and with
+        # the turn's messages; a failed turn is an error whatever it carries.
+        failed = bool(result.get("failed"))
+        partial = bool(result.get("partial"))
+        if not error and failed and result.get("final_response"):
+            error = str(result["final_response"])
+        status = "cancelled" if cancelled else ("error" if failed or (error and not result.get("messages")) else "completed")
         pending_steer = str(result.get("pending_steer") or "") if isinstance(result, dict) else ""
         return {
             "status": status,
             "messages": [m for m in (result.get("messages") or []) if isinstance(m, dict)],
             "final_response": str(result.get("final_response") or ""),
             "error": error,
-            "result_status": str(result.get("status") or result.get("state") or ""),
+            "failed": failed,
+            "partial": partial,
+            "compression_exhausted": bool(result.get("compression_exhausted")),
             "tool_limit_reached": bool(result.get("tool_limit_reached") or result.get("max_iterations_reached")),
             "usage": _usage(agent),
             "context": _context_length(agent),
@@ -861,7 +957,7 @@ def compress(ctx: CallContext, params: dict) -> dict:
     model = str(params.get("model") or "").strip()
     provider = str(params.get("model_provider") or "").strip() or None
     focus_topic = str(params.get("focus_topic") or "").strip()[:500] or None
-    toolsets = params.get("enabled_toolsets")
+    toolsets = _turn_toolsets(params.get("enabled_toolsets"))
     runtime = _resolve_runtime(provider, model)
     if not runtime.get("api_key"):
         raise RpcError("No provider configured -- cannot compress.", condition="credential_missing")
@@ -875,7 +971,7 @@ def compress(ctx: CallContext, params: dict) -> dict:
         api_key=runtime.get("api_key"),
         platform="webui",
         quiet_mode=True,
-        enabled_toolsets=toolsets if isinstance(toolsets, list) else None,
+        enabled_toolsets=toolsets,
         session_id=session_id,
     )
     for name, value in (
@@ -1017,14 +1113,22 @@ def register(registry) -> None:
 
     @registry.method("chat.evict_agent", requires_agent=False)
     def evict_(ctx: CallContext, params: dict) -> dict:
+        """Drop a session's cached agent. Only delete/clear (``clear_session``) end its approval grants, parked
+        approvals and kernels; a model switch, truncate or compress leaves a running turn's agent in place."""
         session_id = str(params.get("session_id") or "").strip()
+        end_session = params.get("clear_session") is True
         with _AGENT_CACHE_LOCK:
+            with _RUNS_LOCK:
+                run = _RUNS.get(_RUNS_BY_SESSION.get(session_id) or "")
+            if not end_session and run is not None and not run.finished.is_set():
+                return {"evicted": False}
             evicted = _AGENT_CACHE.pop(session_id, None) is not None
-        try:
-            from tools.approval import clear_session
-            clear_session(session_id)
-        except Exception:  # noqa: BLE001
-            pass
+        if end_session:
+            try:
+                from tools.approval import clear_session
+                clear_session(session_id)
+            except Exception:  # noqa: BLE001
+                pass
         return {"evicted": evicted}
 
     @registry.method("chat.commit_memory", requires_agent=False)
@@ -1101,7 +1205,9 @@ def register(registry) -> None:
         except Exception as exc:  # noqa: BLE001
             raise RpcError(f"approval module unavailable: {exc}", condition="agent_unavailable") from exc
         (enable_session_yolo if enabled else disable_session_yolo)(session_id)
-        released = resolve_gateway_approval(session_id, "session", resolve_all=True) if enabled else 0
+        # Parked approvals are released `once`: a `session` or `always` grant would keep their patterns approved after
+        # YOLO turns off, whatever choice the card that enabled it carried.
+        released = resolve_gateway_approval(session_id, "once", resolve_all=True) if enabled else 0
         return {"yolo_enabled": bool(is_session_yolo_enabled(session_id)), "released": int(released or 0)}
 
     @registry.method("clarify.respond", requires_agent=False)

package/sidecar/talaria_sidecar/methods/commands.py

@@ -7,8 +7,9 @@ import threading
 from typing import Any
 
 from ..errors import InvalidParams, RpcError
-from ..home import profile_home_param, scoped_home
+from ..home import _is_named_profile, profile_home_param, scoped_home
 from ..rpc import CallContext
+from .providers import plugin_providers
 
 log = logging.getLogger("talaria_sidecar.commands")
 
@@ -60,19 +61,54 @@ def list_commands() -> list[dict[str, Any]]:
     return out
 
 
+def retire_unscoped_launch_mcp_servers() -> set[str]:
+    """Close the launch profile's connections opened before multiplexing started; returns their server names.
+
+    Until the first named-profile call, the launch profile's connections and tools are unscoped (process-wide). Once
+    multiplexing is active, a scoped shutdown never selects them and scoped discovery opens duplicates beside them, so
+    the launch profile's own calls close them first and its scope reconnects them from the current config."""
+    from agent.secret_scope import is_multiplex_active
+    from hermes_constants import get_hermes_home
+    from tools.mcp_tool import _lock, _servers
+    from tools.mcp_tool_lifecycle import shutdown_mcp_servers
+    from tools.mcp_tool_scope import _key_name, _key_scope
+
+    if not is_multiplex_active() or _is_named_profile(get_hermes_home()):
+        return set()
+    with _lock:
+        names = {_key_name(key) for key in _servers if _key_scope(key) is None}
+    if names:
+        shutdown_mcp_servers(scope=None, names=names)
+    return names
+
+
 def _reload_mcp() -> str:
     with _RELOAD_MCP_LOCK:
         try:
-            from tools.mcp_tool import _lock, _servers, discover_mcp_tools, shutdown_mcp_servers
+            from agent.secret_scope import is_multiplex_active
+            from tools.mcp_tool import _lock, _mcp_tool_server_names, _server_visible_in_scope, _servers
+            from tools.mcp_tool_discovery import discover_mcp_tools
+            from tools.mcp_tool_lifecycle import shutdown_mcp_servers
+            from tools.mcp_tool_scope import _key_name
+            from tools.registry import registry
         except Exception as exc:  # noqa: BLE001
             raise RpcError("MCP runtime unavailable", condition="mcp_unavailable") from exc
-        try:
-            with _lock:
-                old = set(_servers.keys())
-            shutdown_mcp_servers()
-            tools = discover_mcp_tools()
+        # Like the gateway's ``_execute_mcp_reload``: under multiplexing only this profile's connections go down and
+        # come back. The bare shutdown is the process-wide wildcard, which would drop every other profile's servers.
+        scope = registry.current_scope_key() if is_multiplex_active() else None
+
+        def server_names() -> set[str]:
             with _lock:
-                connected = set(_servers.keys())
+                return {_key_name(key) for key in _servers if _server_visible_in_scope(key, scope)}
+
+        try:
+            old = server_names() | retire_unscoped_launch_mcp_servers()
+            shutdown_mcp_servers(scope=scope)
+            tools = discover_mcp_tools() or []
+            connected = server_names()
+            if scope is not None:
+                with _lock:
+                    tools = [name for name in tools if _mcp_tool_server_names.get(name) in connected]
         except Exception as exc:  # noqa: BLE001
             log.warning("Failed to reload MCP servers", exc_info=True)
             raise RpcError("Failed to reload MCP servers", condition="mcp_reload_failed") from exc
@@ -84,7 +120,7 @@ def _reload_mcp() -> str:
         lines.append(f"Added: {', '.join(sorted(added))}")
     if removed:
         lines.append(f"Removed: {', '.join(sorted(removed))}")
-    lines.append(f"{len(tools or [])} tool(s) available across {len(connected)} server(s)" if connected else "No MCP servers connected")
+    lines.append(f"{len(tools)} tool(s) available across {len(connected)} server(s)" if connected else "No MCP servers connected")
     if not reconnected and not added and not removed:
         lines.append("Tooling state was already current")
     return "\n".join(lines)
@@ -230,27 +266,6 @@ def resolve_moa_config(preset: str | None) -> dict:
     return resolved
 
 
-def plugin_provider_profiles() -> list[dict]:
-    """Model-provider plugins registered with the Agent's provider registry."""
-    try:
-        from providers import list_providers
-    except Exception:  # noqa: BLE001
-        return []
-    out = []
-    try:
-        for profile in list_providers():
-            name = str(getattr(profile, "name", "") or "").strip().lower()
-            if not name:
-                continue
-            env_vars = [str(v) for v in (getattr(profile, "env_vars", ()) or ())]
-            api_key_env = next((v for v in env_vars if not v.upper().endswith(("_BASE_URL", "_URL", "_FOLDER_ID"))), None)
-            out.append({"name": name, "display_name": str(getattr(profile, "display_name", "") or name).strip(), "env_vars": env_vars, "api_key_env": api_key_env})
-    except Exception:  # noqa: BLE001
-        log.debug("Failed to enumerate model-provider plugins", exc_info=True)
-        return []
-    return out
-
-
 PLUGIN_VISIBILITY_HOOKS = ("pre_tool_call", "post_tool_call", "pre_llm_call", "post_llm_call")
 
 
@@ -332,7 +347,7 @@ def register(registry) -> None:
     @registry.method("plugins.providers")
     def providers(ctx: CallContext, params: dict) -> dict:
         with scoped_home(profile_home_param(params)):
-            return {"providers": plugin_provider_profiles()}
+            return {"providers": plugin_providers()}
 
     @registry.method("plugins.list")
     def list_(ctx: CallContext, params: dict) -> dict:

package/sidecar/talaria_sidecar/methods/config.py

@@ -2,12 +2,13 @@
 Agent's per-model reasoning capability.
 
 The TypeScript server owns every config.yaml *policy* (which keys mean what);
-the sidecar only parses and serialises YAML with the Agent's PyYAML so the Node
-side needs no YAML dependency. Writes are atomic and keep the file's mode.
+the sidecar only parses and serialises YAML with the Agent's own parser so the
+Node side needs no YAML dependency. Writes are atomic and keep the file's mode.
 """
 
 from __future__ import annotations
 
+import importlib
 import logging
 import os
 import tempfile
@@ -20,12 +21,15 @@ from ..rpc import CallContext
 log = logging.getLogger("talaria_sidecar.config")
 
 
-def _yaml():
-    try:
-        import yaml
-    except Exception as exc:  # noqa: BLE001
-        raise RpcError(f"PyYAML unavailable: {exc}", condition="yaml_unavailable") from exc
-    return yaml
+def yaml_parser():
+    """The Agent's YAML module: ``hermes_yaml`` on Agents that ship it, PyYAML on released Agents."""
+    failures = []
+    for name in ("hermes_yaml", "yaml"):
+        try:
+            return importlib.import_module(name)
+        except Exception as exc:  # noqa: BLE001
+            failures.append(f"{name}: {exc}")
+    raise RpcError(f"No YAML parser available ({'; '.join(failures)})", condition="yaml_unavailable")
 
 
 def config_path_param(params: dict) -> Path:
@@ -45,7 +49,7 @@ def read_config(path: Path) -> dict:
     if not path.exists():
         return {"path": str(path), "exists": False, "config": {}}
     try:
-        data = _yaml().safe_load(path.read_text(encoding="utf-8"))
+        data = yaml_parser().safe_load(path.read_text(encoding="utf-8"))
     except RpcError:
         raise
     except Exception as exc:  # noqa: BLE001
@@ -70,7 +74,7 @@ def write_config(path: Path, config: dict) -> dict:
         raise InvalidParams("config must be an object")
     target = _write_target(path)
     target.parent.mkdir(parents=True, exist_ok=True)
-    text = _yaml().safe_dump(config, sort_keys=False, allow_unicode=True)
+    text = yaml_parser().safe_dump(config, sort_keys=False, allow_unicode=True)
     mode = None
     try:
         mode = target.stat().st_mode & 0o777