@maudecode/talaria-web 1.18.0 → 1.20.0

package/sidecar/talaria_sidecar/methods/config.py

@@ -1,16 +1,22 @@
-"""``config.*`` and ``models.reasoning_efforts``: a profile's ``config.yaml`` and the
-Agent's per-model reasoning capability.
+"""``config.*``, ``models.reasoning_efforts`` and ``personalities.list``: a profile's ``config.yaml`` and ``.env``,
+the Agent's per-model reasoning capability, and the personalities the Agent offers for a config.
 
 The TypeScript server owns every config.yaml *policy* (which keys mean what);
 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.
+``.env`` edits use the Agent's own line helpers under the ``<.env>.lock`` the
+gateway, CLI and plugins also take, so concurrent writers never drop a key.
 """
 
 from __future__ import annotations
 
+import contextlib
+import copy
 import importlib
+import io
 import logging
 import os
+import re
 import tempfile
 from pathlib import Path
 
@@ -69,12 +75,82 @@ def _write_target(path: Path) -> Path:
     return target
 
 
-def write_config(path: Path, config: dict) -> dict:
+def _same_config_value(left, right) -> bool:
+    """Compare decoded JSON values without treating booleans as numbers."""
+    if type(left) is not type(right):
+        return False
+    if isinstance(left, dict):
+        return left.keys() == right.keys() and all(_same_config_value(left[key], right[key]) for key in left)
+    if isinstance(left, list):
+        return len(left) == len(right) and all(_same_config_value(a, b) for a, b in zip(left, right))
+    return left == right
+
+
+def _split_config_aliases(text: str, desired: dict) -> str:
+    """Keep the Agent's round-trip document, separating aliases with different requested values."""
+    roundtrip = getattr(yaml_parser(), "roundtrip_yaml", None)
+    if roundtrip is None:
+        return text
+    parser = roundtrip()
+    document = parser.load(text)
+    seen = {}
+    changed = False
+
+    def split(node, value):
+        nonlocal changed
+        if not (isinstance(node, dict) and isinstance(value, dict) or isinstance(node, list) and isinstance(value, list)):
+            return node
+        previous = seen.get(id(node))
+        if previous is not None:
+            if _same_config_value(previous[1], value):
+                return node
+            node = copy.deepcopy(node)
+            # Copied explicit anchor names must not collide with the original subtree.
+            pending, cleared = [node], set()
+            while pending:
+                child = pending.pop()
+                if id(child) in cleared:
+                    continue
+                cleared.add(id(child))
+                if hasattr(child, "yaml_set_anchor"):
+                    child.yaml_set_anchor(None)
+                if isinstance(child, dict):
+                    pending.extend(child.values())
+                elif isinstance(child, list):
+                    pending.extend(child)
+            changed = True
+        seen[id(node)] = (node, value)
+        for key in value if isinstance(value, dict) else range(min(len(node), len(value))):
+            if not isinstance(node, dict) or key in node:
+                node[key] = split(node[key], value[key])
+        return node
+
+    split(document, desired)
+    if not changed:
+        return text
+    output = io.StringIO()
+    parser.dump(document, output)
+    return output.getvalue()
+
+
+def write_config(path: Path, config: dict, *, profile_home: Path | None = None) -> dict:
     if not isinstance(config, dict):
         raise InvalidParams("config must be an object")
+    try:
+        managed = importlib.import_module("hermes_constants").get_managed_system(profile_home)
+    except Exception as exc:  # noqa: BLE001
+        raise RpcError("Cannot verify config.yaml management policy; repair the Agent installation before saving.",
+                       condition="config_policy_unavailable") from exc
+    if managed is not None:
+        raise RpcError("config.yaml is package-managed. Update the declarative configuration instead.",
+                       condition="config_write_refused")
     target = _write_target(path)
     target.parent.mkdir(parents=True, exist_ok=True)
-    text = yaml_parser().safe_dump(config, sort_keys=False, allow_unicode=True)
+    try:
+        replace = getattr(importlib.import_module("hermes_cli.config"), "atomic_config_replace", None)
+    except Exception:  # noqa: BLE001
+        # Operator config must remain writable even when Agent imports are broken.
+        replace = None
     mode = None
     try:
         mode = target.stat().st_mode & 0o777
@@ -83,11 +159,24 @@ def write_config(path: Path, config: dict) -> dict:
     fd, tmp = tempfile.mkstemp(dir=str(target.parent), prefix=".config_", suffix=".tmp")
     try:
         with os.fdopen(fd, "w", encoding="utf-8") as handle:
-            handle.write(text)
+            if replace is not None:
+                # Stage the original document so the Agent retains comments; check the real link before committing.
+                try:
+                    handle.write(_split_config_aliases(target.read_text(encoding="utf-8"), config))
+                except FileNotFoundError:
+                    pass
+            else:
+                parser = yaml_parser()
+                handle.write(parser.safe_dump(config, sort_keys=False, allow_unicode=True,
+                                              width=getattr(parser, "ROUNDTRIP_YAML_WIDTH", 2**31 - 1)))
             handle.flush()
             os.fsync(handle.fileno())
+        if replace is not None:
+            replace(Path(tmp), config)
         if mode is not None:
             os.chmod(tmp, mode)
+        if not _same_config_value(read_config(Path(tmp))["config"], config):
+            raise RpcError("Staged config.yaml does not match the requested values", condition="config_invalid")
         # A link retargeted while the temp file was being written would otherwise send the write to the wrong file.
         if _write_target(path) != target:
             raise RpcError(f"{path} was retargeted while config.yaml was being written; retry", condition="config_changed")
@@ -101,6 +190,88 @@ def write_config(path: Path, config: dict) -> dict:
     return {"ok": True, "path": str(path)}
 
 
+_ENV_NAME = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+
+def _env_refusal(agent_config, key: str, action: str) -> str | None:
+    """The Agent's ``.env`` write-lock refusal (package-managed install or administrator-managed key)."""
+    refusal = getattr(agent_config, "env_write_refusal", None)
+    if refusal is not None:
+        return refusal(key, action)
+    # Agent 0.21.5 only reports the refusal on stderr.
+    return f"Cannot {action} {key}: this Hermes installation manages it" if agent_config._env_write_blocked(key, action) else None
+
+
+def _env_lock(agent_config, path: Path):
+    """The Agent's ``<.env>.lock`` (Agent 0.21.6+); older Agents have none to share."""
+    lock = getattr(agent_config, "_env_write_lock", None)
+    return lock(path) if lock is not None else contextlib.nullcontext()
+
+
+def env_write(home: Path, updates) -> dict:
+    """Upsert ``updates`` into ``home``'s ``.env`` (``None`` removes a key) with the Agent's own line helpers, under
+    the lock its ``save_env_value`` / ``remove_env_value`` take, in one atomic replace.
+
+    Unlike those two, nothing is published into ``os.environ``: other threads (a gateway spawn snapshotting the
+    environment) must never see another profile's key, and ``runtime.env`` alone owns this process's environment.
+    Values are trimmed and an empty one is skipped; a value the Agent would strip or quote is refused. Every key is
+    checked against the Agent's refusals before the write, and the file ends 0600.
+    """
+    if not isinstance(updates, dict) or not all(isinstance(k, str) and _ENV_NAME.match(k) and (v is None or isinstance(v, str)) for k, v in updates.items()):
+        raise InvalidParams("updates must map variable names to strings or null")
+    changes: dict[str, str | None] = {}
+    for key, value in updates.items():
+        if value is not None:
+            value = value.strip()
+            if not value:
+                continue
+            if "\n" in value or "\r" in value:
+                raise InvalidParams("API key must not contain newline characters.")
+            # The Agent would strip non-ASCII and quote the rest; refused instead, so the running process and the
+            # server's reader see exactly the bytes the file holds.
+            if any(not "!" <= c <= "~" or c in "#\"'" for c in value):
+                raise InvalidParams("API key must not contain spaces, quotes, '#' or non-ASCII characters.")
+        changes[key] = value
+    from hermes_cli import config as agent_config
+
+    with scoped_home(home):
+        for key, value in changes.items():
+            refusal = _env_refusal(agent_config, key, "remove" if value is None else "set")
+            if refusal:
+                raise RpcError(refusal, condition="env_write_refused")
+        try:
+            agent_config.ensure_hermes_home()
+            path = agent_config.get_env_path()
+            with _env_lock(agent_config, path):
+                existed = path.exists()
+                lines = agent_config._read_env_lines(path) if existed else []
+                before = list(lines)
+                for key, value in changes.items():
+                    defines = agent_config._env_line_defines_key
+                    if value is None:
+                        lines = [line for line in lines if not defines(line, key)]
+                        continue
+                    agent_config.validate_env_var_name_for_write(key)
+                    entry = f"{key}={value}\n"
+                    at = next((i for i, line in enumerate(lines) if defines(line, key)), None)
+                    if at is not None:
+                        lines[at] = entry
+                    else:
+                        if lines and not lines[-1].endswith("\n"):
+                            lines[-1] += "\n"
+                        lines.append(entry)
+                if lines != before:
+                    agent_config._write_env_lines(path, lines, preserve_mode=existed)
+        except TimeoutError as exc:
+            raise RpcError(str(exc), condition="env_locked") from exc
+        except ValueError as exc:
+            raise RpcError(str(exc), condition="env_write_refused") from exc
+        agent_config.invalidate_env_cache()
+        if path.exists():
+            os.chmod(path, 0o600)
+    return {"ok": True, "path": str(path)}
+
+
 def reasoning_efforts(model: str, provider: str) -> dict:
     """Levels the Agent would offer for ``model`` on ``provider`` (``hermes_cli.main_provider_setup``)."""
     efforts: list[str] | None = None
@@ -122,6 +293,16 @@ def reasoning_efforts(model: str, provider: str) -> dict:
     return {"efforts": [str(e) for e in (efforts or [])], "supports_reasoning": supports_reasoning}
 
 
+def personalities(config) -> list[dict]:
+    """TAL-901: ``config``'s personalities as the Agent offers them (``hermes_cli.personality``), with its list preview
+    and rendered prompt."""
+    from hermes_cli.personality import available_personalities, describe_personality, render_personality_prompt
+
+    if not isinstance(config, dict):
+        raise InvalidParams("config must be a mapping")
+    return [{"name": name, "description": describe_personality(value), "prompt": render_personality_prompt(value)} for name, value in available_personalities(config).items()]
+
+
 def register(registry) -> None:
     @registry.method("config.get", requires_agent=False)
     def get(ctx: CallContext, params: dict) -> dict:
@@ -129,9 +310,17 @@ def register(registry) -> None:
 
     @registry.method("config.set", requires_agent=False)
     def set_(ctx: CallContext, params: dict) -> dict:
-        return write_config(config_path_param(params), params.get("config"))
+        return write_config(config_path_param(params), params.get("config"), profile_home=profile_home_param(params))
+
+    @registry.method("config.env_write")
+    def env_write_(ctx: CallContext, params: dict) -> dict:
+        return env_write(profile_home_param(params), params.get("updates"))
 
     @registry.method("models.reasoning_efforts")
     def efforts(ctx: CallContext, params: dict) -> dict:
         with scoped_home(profile_home_param(params)):
             return reasoning_efforts(str(params.get("model") or ""), str(params.get("provider") or ""))
+
+    @registry.method("personalities.list")
+    def personalities_(ctx: CallContext, params: dict) -> dict:
+        return {"personalities": personalities(params.get("config"))}

package/sidecar/talaria_sidecar/methods/connectors.py

@@ -0,0 +1,375 @@
+"""``connectors.*``: Nous tool-gateway apps over the Agent's portal client (TAL-818).
+
+The page's reads and writes (catalog, accounts, remove, tools, policy) call ``PortalConnectorClient``; a connect
+runs the Agent's account-owned operation (``tools.connectors.account``), and a chat's ``manage_connections`` card
+registers its session operation here through ``remember_chat_operation``. Every call runs under the profile's
+``scoped_home``; the server composes what the page and card show.
+"""
+
+from __future__ import annotations
+
+import inspect
+import json
+import logging
+import threading
+from collections import OrderedDict
+from pathlib import Path
+from types import SimpleNamespace
+
+from ..errors import InvalidParams, RpcError
+from ..home import profile_home_param, scoped_home
+from ..rpc import CallContext
+
+log = logging.getLogger("talaria_sidecar.connectors")
+
+# Operations the page or a chat card may still read, by (profile home, op_id). The Agent's ``live`` registry drops an
+# operation once it settles, so its final state is kept here for the next poll. Only settled operations age out (oldest
+# first, past 64): an open one is someone's card, and the Agent bounds those (one per session, settled by its deadline).
+_OPS: OrderedDict[tuple[str, str], object] = OrderedDict()
+_OPS_CAP = 64
+_OPS_LOCK = threading.Lock()
+
+
+def available() -> bool:
+    try:
+        from tools.connectors import connectors_available
+    except Exception:  # noqa: BLE001 - an Agent without connectors
+        return False
+    return bool(connectors_available())
+
+
+def _open(*, creates_guest: bool = False) -> None:
+    """Only explicit Connect may provision; every other page action is noncreating."""
+    if not available():
+        raise RpcError("Connectors are not available.", condition="connectors_unavailable")
+    if not creates_guest:
+        return
+    try:
+        from tools.connectors import ensure_guest_identity
+    except Exception:  # noqa: BLE001 - an Agent before guest identities
+        return
+    if failure := ensure_guest_identity():
+        raise RpcError(failure, condition="connectors_failed")
+
+
+def _portal(*, refresh_auth: bool = False):
+    from tools.connectors.portal.client import PortalConnectorClient
+
+    # Explicit writes retain native refresh; reads never acquire that authority.
+    if refresh_auth:
+        return PortalConnectorClient()
+    from tools.managed_tool_gateway import peek_nous_access_token
+
+    # The normal token reader may refresh and replace a dead guest. Page reads must never own auth writes.
+    def headers(_url):
+        token = peek_nous_access_token()
+        return {"Authorization": f"Bearer {token}"} if token else {}
+
+    return PortalConnectorClient(header_provider=headers)
+
+
+def _authenticated(client) -> bool:
+    from tools.connectors.gateway.errors import GatewayAuthError
+
+    try:
+        client.require_authentication()
+    except GatewayAuthError as exc:
+        if getattr(exc, "code", None) == "NO_TOKEN":
+            return False
+        raise
+    return True
+
+
+def _failure(exc: Exception) -> RpcError:
+    """The Agent's connector errors as RPC conditions (its desktop RPC's reasons)."""
+    from tools.connectors.gateway.errors import GatewayAuthError
+
+    code = getattr(exc, "code", None)
+    if isinstance(exc, GatewayAuthError):
+        if code in {"no_access", "ORG_ACCESS_DENIED", "forbidden"}:
+            return RpcError("This account cannot manage connectors.", condition="connectors_forbidden")
+        return RpcError("Sign in to Nous Portal to use connectors.", condition="connectors_sign_in")
+    if code == "policy_changed":
+        return RpcError("Connector rules changed. Refresh and try again.", condition="policy_conflict")
+    if code == "org_required":
+        return RpcError("Select an organization to manage connector rules.", condition="connectors_org_required")
+    if code in {"forbidden", "no_access"}:
+        return RpcError("Connector rules cannot be changed for this account.", condition="connectors_forbidden")
+    if code == "invalid_connector_policy" or (code == "HTTP_400" and getattr(exc, "status", None) == 400):
+        return RpcError("Connector rule change is invalid.", condition="policy_invalid")
+    if code == "connection_not_found":
+        return RpcError("Connector account not found.", condition="connection_not_found")
+    log.warning("connector request failed: %s", type(exc).__name__)
+    return RpcError("Connector request failed.", condition="connectors_failed")
+
+
+def _slug(params: dict, key: str = "connector") -> str:
+    raw = params.get(key)
+    from tools.connectors.portal.client import validate_slug
+    from tools.connectors.portal.errors import InvalidConnectorSlug
+
+    try:
+        validate_slug(raw if isinstance(raw, str) else "")
+    except InvalidConnectorSlug as exc:
+        raise InvalidParams(f"{key} must be a connector slug") from exc
+    return raw
+
+
+def catalog() -> dict:
+    client = _portal()
+    if _authenticated(client):
+        rows = client.catalog().connectors
+    elif callable(public_catalog := getattr(client, "public_catalog", None)):
+        rows = public_catalog().connectors
+    else:
+        raise RpcError("Sign in to Nous Portal to use connectors.", condition="connectors_sign_in")
+    return {"connectors": [row.model_dump(mode="json") for row in rows]}
+
+
+def accounts() -> dict:
+    client = _portal()
+    if not _authenticated(client):
+        return {"accounts": []}
+    return {"accounts": [{
+        "connection_id": row["connectionId"], "connector": row["connector"], "status": row["status"],
+        "status_reason": row.get("statusReason"), "label": row["label"], "alias": row.get("alias"),
+        "active": bool(row["active"]), "disabled": bool(row.get("disabled")), "created_at": row["createdAt"],
+    } for row in client.list_accounts()]}
+
+
+def remove(connection_id: str) -> dict:
+    removed = _portal(refresh_auth=True).delete_account(connection_id)
+    return {"connection_id": removed["connectionId"], "connector": removed["connector"], "status": removed["status"]}
+
+
+def tools(slug: str, *, refresh: bool) -> dict:
+    from tools.connectors.gateway.errors import GatewayUnavailable
+    from tools.connectors.portal.tools_cache import read_tools
+
+    client = _portal()
+    client.require_authentication()
+    try:
+        listing = read_tools(slug, client=client, refresh=refresh)
+    except GatewayUnavailable as exc:
+        raise RpcError("Connector not found.", condition="connector_not_found") from exc
+    keep = ("slug", "name", "description", "facet", "hints", "categories", "deprecated")
+    return {"connector": listing.connector, "tools": [{k: v for k, v in tool.model_dump(mode="json").items() if k in keep} for tool in listing.tools]}
+
+
+def policy() -> dict:
+    client = _portal()
+    client.require_authentication()
+    current = client.policy()
+    return {
+        "layers": [{"kind": layer.kind, "revision": layer.revision, "body": layer.body.model_dump(mode="json", exclude_none=True)} for layer in current.layers],
+        "effective": current.effective.model_dump(mode="json", exclude_none=True, exclude={"version", "issued_at_ms"}),
+    }
+
+
+def set_policy(connector: str, expected_revision: str, *, enabled: bool | None = None, tool: str | None = None, tool_enabled: bool | None = None) -> dict:
+    """One member-layer change on top of the portal's current member rules: an app on or off, or one of its tools.
+    The portal refuses the write when ``expected_revision`` is no longer its member revision."""
+    from tools.connectors.portal.policy import InvalidMemberPolicy, compose_connector_write, compose_tools_write
+
+    client = _portal(refresh_auth=True)
+    client.require_authentication()
+    member = next((layer.body for layer in client.policy().layers if layer.kind == "member"), None)
+    try:
+        if tool is None:
+            body = compose_connector_write(member, SimpleNamespace(connector=connector, enabled=bool(enabled)))
+        else:
+            rule = (getattr(member, "tools", None) or {}).get(connector)
+            disabled = [name for name in (rule.disable if rule else []) if name != tool] + ([] if tool_enabled else [tool])
+            body = compose_tools_write(member, SimpleNamespace(connector=connector, disabled_tools=disabled))
+    except InvalidMemberPolicy as exc:
+        raise RpcError("Connector rule change is invalid.", condition="policy_invalid") from exc
+    body["expectedRevision"] = expected_revision
+    return {"revision": client.set_policy(body).revision}
+
+
+def _remember(home: Path, operation) -> None:
+    with _OPS_LOCK:
+        _OPS[(str(home), operation.op_id)] = operation
+        _OPS.move_to_end((str(home), operation.op_id))
+        settled = [key for key, op in _OPS.items() if op.settled]
+        for key in settled[:max(0, len(_OPS) - _OPS_CAP)]:
+            del _OPS[key]
+
+
+def _operation(home: Path, op_id: str):
+    with _OPS_LOCK:
+        operation = _OPS.get((str(home), op_id))
+    if operation is None:
+        raise RpcError("No connection operation with that id.", condition="operation_not_found")
+    return operation
+
+
+def operation_view(operation) -> dict:
+    """The operation as the sidecar reports it: every target's state, the vendor's text, the authorization link while
+    the target waits on it (the Agent keeps a used link on a connected target), and the credentials an MCP install
+    still asks for."""
+    snapshot = operation.snapshot()
+    return {
+        "op_id": snapshot["op_id"],
+        "settled": snapshot.get("settled_at") is not None,
+        # The Connectors page's own operations are account-owned; a chat's carry the tool call that opened the card.
+        "owner": "account" if operation.session_key.startswith("account:") else "session",
+        "tool_call_id": operation.tool_call_id,
+        "targets": [{
+            "name": target["name"], "kind": target["kind"], "state": target["state"], "detail": target.get("detail") or "",
+            "connect_url": target.get("connect_url") if target["state"] == "initiated" else None,
+            "required_env": [{
+                "name": str(field.get("name") or ""), "prompt": str(field.get("prompt") or ""), "required": bool(field.get("required")),
+                "secret": bool(field.get("secret", True)),
+            } for field in target.get("required_env") or [] if isinstance(field, dict) and field.get("name")],
+        } for target in snapshot["targets"]],
+    }
+
+
+def connect(home: Path, connector: str) -> dict:
+    """Start (or rejoin) the account-owned connect for ``connector`` and wait for its authorization link."""
+    from tools.connectors import account
+    from tools.connectors.contract import TargetState
+    from tools.connectors.run import reissue
+
+    # The gateway attributes each link to who asked; the Agent names its Connectors page ``desktop_page`` (v0.22.0).
+    page = {"initiator": "desktop_page"} if "initiator" in inspect.signature(account.find_or_start_operation).parameters else {}
+    start = account.find_or_start_operation([connector], action="connect", profile_home=str(home), **page)
+    _remember(home, start.operation)
+    if not start.started:
+        target = start.operation.target(connector)
+        if target is not None and target.state in (TargetState.failed, TargetState.expired) and reissue(start.operation, [connector], **page):
+            raise RpcError("This connection cannot be started again.", condition="operation_refused")
+        return operation_view(start.operation)
+    if account.wait_for_prepare(start) and start.failed:
+        raise RpcError("Connector request failed.", condition="connectors_failed")
+    return operation_view(start.operation)
+
+
+def respond(home: Path, op_id: str, action: str, target: str | None, env: dict) -> dict:
+    """The card's move: Skip or Retry one target, Approve an MCP install with its credentials, or Continue."""
+    from tools.connectors.contract import SettleReason
+    from tools.connectors.operation import IllegalTransition
+    from tools.connectors.run import apply_answer, reissue
+
+    operation = _operation(home, op_id)
+    if operation.settled:
+        raise RpcError("The connection operation has settled.", condition="operation_settled")
+    row = operation.target(target) if target else None
+    if action != "continue" and row is None:
+        raise InvalidParams("target must name a target of the operation")
+    try:
+        if action == "continue":
+            apply_answer(operation, json.dumps({"settled_by": SettleReason.continue_.value}))
+        elif action == "retry" and row.kind == "connector":
+            if reissue(operation, [row.name]):
+                raise RpcError("This target cannot be run again.", condition="operation_refused")
+        else:
+            status = "skipped" if action == "skip" else "approved"
+            apply_answer(operation, json.dumps({"targets": [{"name": row.name, "status": status, "env": env}]}))
+    except IllegalTransition as exc:
+        # The operation moved between the server's check and this answer (the watcher connected the target meanwhile).
+        raise RpcError("That move is no longer open on this connection.", condition="operation_refused") from exc
+    operation.settle_if_all_resolved()
+    return operation_view(operation)
+
+
+def remember_chat_operation(home: Path, payload: dict) -> dict | None:
+    """A chat's ``manage_connections`` card opened: keep its operation for the card's reads and moves, and answer the
+    frame the turn streams. None when the Agent's registry no longer holds it."""
+    from tools.connectors import live
+
+    op_id = payload.get("op_id") if isinstance(payload, dict) else None
+    operation = live.get_by_op_id(op_id, profile_home=str(home)) if isinstance(op_id, str) else None
+    if operation is None:
+        return None
+    _remember(home, operation)
+    return operation_view(operation)
+
+
+def register(registry_) -> None:
+    def page(params: dict, read, *, creates_guest: bool = False):
+        with scoped_home(profile_home_param(params)):
+            _open(creates_guest=creates_guest)
+            try:
+                return read()
+            except RpcError:
+                raise
+            except Exception as exc:  # noqa: BLE001 - the Agent's gateway errors become RPC conditions
+                raise _failure(exc) from exc
+
+    @registry_.method("connectors.available")
+    def available_(ctx: CallContext, params: dict) -> dict:
+        with scoped_home(profile_home_param(params)):
+            return {"available": available()}
+
+    @registry_.method("connectors.catalog")
+    def catalog_(ctx: CallContext, params: dict) -> dict:
+        return page(params, catalog)
+
+    @registry_.method("connectors.accounts")
+    def accounts_(ctx: CallContext, params: dict) -> dict:
+        return page(params, accounts)
+
+    @registry_.method("connectors.remove")
+    def remove_(ctx: CallContext, params: dict) -> dict:
+        connection_id = params.get("connection_id")
+        if not isinstance(connection_id, str) or not connection_id:
+            raise InvalidParams("connection_id is required")
+        return page(params, lambda: remove(connection_id))
+
+    @registry_.method("connectors.tools")
+    def tools_(ctx: CallContext, params: dict) -> dict:
+        slug = _slug(params)
+        return page(params, lambda: tools(slug, refresh=params.get("refresh") is True))
+
+    @registry_.method("connectors.policy.get")
+    def policy_(ctx: CallContext, params: dict) -> dict:
+        return page(params, policy)
+
+    @registry_.method("connectors.policy.set")
+    def set_policy_(ctx: CallContext, params: dict) -> dict:
+        slug = _slug(params)
+        revision = params.get("expected_revision")
+        if not isinstance(revision, str) or not revision:
+            raise InvalidParams("expected_revision is required")
+        tool = params.get("tool")
+        if tool is None:
+            if not isinstance(params.get("enabled"), bool):
+                raise InvalidParams("enabled is required")
+            return page(params, lambda: set_policy(slug, revision, enabled=params["enabled"]))
+        if not isinstance(tool, str) or not tool or not isinstance(params.get("tool_enabled"), bool):
+            raise InvalidParams("tool and tool_enabled are required together")
+        return page(params, lambda: set_policy(slug, revision, tool=tool, tool_enabled=params["tool_enabled"]))
+
+    @registry_.method("connectors.connect")
+    def connect_(ctx: CallContext, params: dict) -> dict:
+        slug = _slug(params)
+        home = profile_home_param(params)
+        return page(params, lambda: connect(home, slug), creates_guest=True)
+
+    def gated() -> None:
+        # Reads and moves on an operation pass the availability gate too, without creating an identity.
+        if not available():
+            raise RpcError("Connectors are not available.", condition="connectors_unavailable")
+
+    @registry_.method("connectors.operation")
+    def operation_(ctx: CallContext, params: dict) -> dict:
+        home = profile_home_param(params)
+        with scoped_home(home):
+            gated()
+            return operation_view(_operation(home, str(params.get("op_id") or "")))
+
+    @registry_.method("connectors.respond")
+    def respond_(ctx: CallContext, params: dict) -> dict:
+        home = profile_home_param(params)
+        action = params.get("action")
+        if action not in ("skip", "retry", "approve", "continue"):
+            raise InvalidParams("action must be skip, retry, approve or continue")
+        target = params.get("target")
+        env = params.get("env") or {}
+        if not isinstance(env, dict) or not all(isinstance(k, str) and isinstance(v, str) for k, v in env.items()):
+            raise InvalidParams("env must map names to strings")
+        with scoped_home(home):
+            gated()
+            return respond(home, str(params.get("op_id") or ""), action, target if isinstance(target, str) else None, env)