novacode-cli 1.2.0__py3-none-any.whl

novacode_cli/agents/async_context.py

@@ -0,0 +1,303 @@
+"""Which provider and model an async-agent graph runs on, chosen per dispatch.
+
+The async graphs are built once, when the LangGraph server boots, so their model used
+to be fixed for the life of the process: changing it meant editing ``.env`` and
+recreating the container. This module makes it a per-run choice instead.
+
+The CLI attaches the stored ``async`` role to every dispatch as the run's ``context``
+(:func:`current_async_context`), and :class:`AsyncModelOverrideMiddleware` swaps that
+model in for the run. A deployment driven purely by ``docker compose`` still behaves
+exactly as before: no context on the wire means the environment wins
+(:func:`novacode_cli.config.model_create.build_async_agent_model`).
+
+Precedence, in one place: a stored ``async`` role beats the environment, because it is
+the later and more specific statement of intent -- the user picked it in ``/model``.
+The one exception is a per-graph variable such as ``PLAN_SCOUT_MODEL``, which is set
+with a single agent in mind and therefore still wins over the shared role.
+
+Models are built with :func:`novacode_cli.config.model_create.build_chat_model` rather
+than langchain's ``init_chat_model``, because the latter does not know Nova's own
+providers (``opencode``, ``nvidia``).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from langchain.agents.middleware.types import AgentMiddleware
+
+from novacode_cli.agents.model_budget import (
+    _MODEL_CALL_BUDGET,
+)
+from novacode_cli.agents.model_budget import (
+    _MODEL_REQUEST_TIMEOUT as _MODEL_REQUEST_TIMEOUT,
+)
+from novacode_cli.agents.model_budget import (
+    _bounded_model as _bounded_model,
+)
+
+if TYPE_CHECKING:
+    from langchain_core.language_models import BaseChatModel
+
+logger = logging.getLogger(__name__)
+
+#: Models already built, keyed by ``(provider, model)``. A swap happens on every model
+#: call, so building per call would rebuild a client dozens of times per run. A
+#: concurrent miss builds twice and the last write wins: one extra object, no harm.
+_MODEL_CACHE: dict[tuple[str, str], BaseChatModel] = {}
+
+#: Whether :func:`install_async_model_context` has already wrapped the factories.
+_PATCHED = False
+
+
+@dataclass
+class NovaAsyncContext:
+    """The run context the CLI attaches to every async dispatch.
+
+    Two plain fields, so the CLI and the graphs can share this without either importing
+    the other's machinery.
+    """
+
+    provider: str | None = None
+    model: str | None = None
+    #: The dispatching session's approval setting; delegates auto-approve independently.
+    auto_approve: bool = False
+    #: Host-provided owner intent; a subagent task description cannot supply consent.
+    user_request: str = ""
+
+
+def _fields(context: Any) -> tuple[str, str]:
+    """Read ``(provider, model)`` off *context*, however it arrived.
+
+    A run context is rehydrated from JSON on the server, so it may be this dataclass or
+    a plain mapping depending on how the graph was invoked. Both are accepted.
+    """
+    if context is None:
+        return "", ""
+    if isinstance(context, dict):
+        provider, model_name = context.get("provider"), context.get("model")
+    else:
+        provider = getattr(context, "provider", None)
+        model_name = getattr(context, "model", None)
+    return str(provider or "").strip(), str(model_name or "").strip()
+
+
+def build_context_model(context: Any) -> BaseChatModel | None:
+    """Return the model *context* asks for, or ``None`` to leave the graph alone.
+
+    A context that cannot be built (unknown provider, missing credentials) is logged
+    and ignored rather than raised: one bad choice must not fail a background run that
+    would otherwise have worked on the graph's own model.
+    """
+    provider, model_name = _fields(context)
+    if not provider or not model_name:
+        return None
+
+    key = (provider, model_name)
+    cached = _MODEL_CACHE.get(key)
+    if cached is not None:
+        return cached
+
+    from novacode_cli.config.model_create import build_chat_model
+
+    try:
+        built = build_chat_model(provider, model_name)
+    except Exception:  # noqa: BLE001 - any failure means "use the graph default"
+        logger.warning(
+            "Async run asked for %s:%s but it could not be built; using the graph default",
+            provider,
+            model_name,
+            exc_info=True,
+        )
+        return None
+
+    _MODEL_CACHE[key] = built
+    return built
+
+
+class AsyncModelOverrideMiddleware(AgentMiddleware):
+    """Run the graph on the run's model, for that run only.
+
+    Outermost on purpose: it has to see every model call before any provider-specific
+    middleware handles it.
+    """
+
+    def __init__(self, *, per_agent_model_var: str | None = None) -> None:
+        """Bind the middleware to one graph.
+
+        Args:
+            per_agent_model_var: An environment variable that pins this graph's model,
+                such as plan-scout's ``PLAN_SCOUT_MODEL``. When it is set the run
+                context is ignored, so a setting made for this one agent still wins over
+                the shared ``async`` role.
+        """
+        super().__init__()
+        self._per_agent_model_var = per_agent_model_var
+
+    def _model_for(self, request: Any) -> BaseChatModel | None:
+        """The model this request should use, or ``None`` to leave it as it is."""
+        var = self._per_agent_model_var
+        if var and os.environ.get(var, "").strip():
+            return None
+        return build_context_model(getattr(request.runtime, "context", None))
+
+    def wrap_model_call(self, request: Any, handler: Any) -> Any:  # noqa: ANN401
+        """Route the call to the run's model when it named one."""
+        model = self._model_for(request)
+        return handler(request if model is None else request.override(model=model))
+
+    async def awrap_model_call(self, request: Any, handler: Any) -> Any:  # noqa: ANN401
+        """Async twin of :meth:`wrap_model_call`.
+
+        The first build of a model reads Nova's settings: the working directory,
+        and each provider key through a lock file (``time.sleep``, ``os.unlink``).
+        On the server's event loop those are blocking calls, which ``langgraph
+        dev`` refuses outright, so the build failed and every run silently fell
+        back to the graph's default model. A cached model is returned inline;
+        only a miss goes to a thread.
+        """
+        key = _fields(getattr(request.runtime, "context", None))
+        if not all(key) or key in _MODEL_CACHE:  # nothing to build, or already built
+            model = self._model_for(request)
+        else:
+            model = await asyncio.to_thread(self._model_for, request)
+        from novacode_cli.agents.model_retry import NovaSubagentRetryMiddleware
+
+        routed = request if model is None else request.override(model=model)
+        return await NovaSubagentRetryMiddleware(call_budget=_MODEL_CALL_BUDGET).awrap_model_call(
+            routed, handler
+        )
+
+
+def current_async_context() -> NovaAsyncContext | None:
+    """The model async agents should run on, as a run context.
+
+    In order: the stored ``async`` role; else, when ``ASYNC_AGENT_PROVIDER`` or
+    ``ASYNC_AGENT_MODEL`` is set, ``None`` (the environment is an explicit
+    instruction, and the graphs read it themselves); else the main agent's own
+    model. That last step is what makes the agents follow whatever provider the
+    session runs on: they used to fall back to a fixed Ollama model, a leftover
+    of the container they ran in, which failed for anyone without Ollama.
+    """
+    from novacode_cli.config.nova_config import NovaConfig
+
+    role = NovaConfig().get_role_model("async") or {}
+    provider = str(role.get("provider") or "").strip()
+    model_name = str(role.get("model") or "").strip()
+    if provider and model_name:
+        return NovaAsyncContext(provider=provider, model=model_name)
+
+    if (
+        os.environ.get("ASYNC_AGENT_PROVIDER", "").strip()
+        or os.environ.get("ASYNC_AGENT_MODEL", "").strip()
+    ):
+        return None
+    try:
+        from novacode_cli.utils.model_info import get_model_info
+
+        provider, model_name, _display = get_model_info()
+    except Exception:  # noqa: BLE001 — no main model to inherit: leave it to the graphs
+        return None
+    if not provider or not model_name:
+        return None
+    return NovaAsyncContext(provider=str(provider), model=str(model_name))
+
+
+def install_async_model_context() -> None:
+    """Make every async dispatch carry the stored ``async`` role as run context.
+
+    deepagents builds the dispatch itself -- ``runs.create(thread_id, assistant_id,
+    input)`` -- and passes no ``context``, so the remote graph has no way to know which
+    model the user picked. Wrapping the client factory is the narrowest seam for that:
+    the request is otherwise left exactly as deepagents made it.
+
+    The context is read lazily, at dispatch time, so a ``/model`` change applies to the
+    very next launch rather than the next server restart. ``runs.create`` already
+    accepts ``context`` in langgraph-sdk and the graphs declare ``context_schema``, so
+    this is only the wiring in between.
+
+    Idempotent: calling it twice leaves the factories wrapped once.
+    """
+    global _PATCHED  # noqa: PLW0603 - the guard is the point
+    if _PATCHED:
+        return
+    _PATCHED = True
+
+    from deepagents.middleware import async_subagents
+
+    for name in ("get_client", "get_sync_client"):
+        factory = getattr(async_subagents, name, None)
+        if factory is None or getattr(factory, "_nova_context_bound", False):
+            continue
+
+        def wrapped(*args: Any, _factory: Any = factory, **kwargs: Any) -> Any:
+            """Bind the run context onto the client the factory just built."""
+            from novacode_cli.agents.async_task_errors import bind_run_errors
+
+            return bind_run_errors(_bind_context(_factory(*args, **kwargs)))
+
+        wrapped._nova_context_bound = True  # type: ignore[attr-defined]
+        setattr(async_subagents, name, wrapped)
+
+
+def _bind_context(client: Any) -> Any:
+    """Return *client* with ``runs.create`` defaulting ``context`` to the async role."""
+    # `getattr` with a default widens to `Any | None`, so a client that exposes no
+    # `runs` is left alone and the type is narrowed before the monkey-patch below.
+    runs: Any = getattr(client, "runs", None)
+    if runs is None:
+        return client
+
+    original = getattr(runs, "create", None)
+    if original is None or getattr(original, "_nova_context_bound", False):
+        return client
+
+    def create(*args: Any, **kwargs: Any) -> Any:
+        """Create the run, naming the async role's model unless one was given."""
+        if kwargs.get("context") is None:
+            from dataclasses import replace
+
+            from novacode_cli.tools.plan_mode_tools import _auto_approve_var
+
+            context = current_async_context()
+            from novacode_cli.security.approval_context import current_user_request
+
+            owner_request = current_user_request.get()
+            if owner_request is not None:
+                context = replace(context or NovaAsyncContext(), user_request=owner_request)
+            # Fixed at launch: the run cannot see a later toggle in this session.
+            if _auto_approve_var.get():
+                context = replace(context or NovaAsyncContext(), auto_approve=True)
+            if context is not None:
+                config = kwargs.get("config")
+                configurable = config.get("configurable") if isinstance(config, dict) else None
+                # deepagents uses this configurable only as a fallback for finding
+                # the parent. Its async launcher also puts parent_thread_id in the
+                # child thread metadata, which is the supported lookup path when a
+                # run context is present. LangGraph rejects a run containing both.
+                if isinstance(configurable, dict) and "deepagents_parent" in configurable:
+                    configurable = dict(configurable)
+                    configurable.pop("deepagents_parent", None)
+                    config = dict(config)
+                    if configurable:
+                        config["configurable"] = configurable
+                    else:
+                        config.pop("configurable", None)
+                    if config:
+                        kwargs["config"] = config
+                    else:
+                        kwargs.pop("config", None)
+                # Preserve unrelated configurable values. This run can still launch
+                # with its graph default, while avoiding the server's 400 response.
+                remaining = config.get("configurable") if isinstance(config, dict) else None
+                if not remaining:
+                    kwargs["context"] = context
+        return original(*args, **kwargs)
+
+    create._nova_context_bound = True  # type: ignore[attr-defined]
+    runs.create = create
+    return client

novacode_cli/agents/async_on_demand.py

@@ -0,0 +1,52 @@
+"""Start Nova's own agent server when an async agent is first dispatched.
+
+The server used to be started while Nova booted, whether or not the session ever
+delegated anything: a second Python process holding six compiled graphs, on a
+machine that may have no memory to spare. It is now only *planned* at boot (a
+port is reserved, so the specs can name it) and started here, by the first
+``start_async_task``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from langchain.agents.middleware.types import AgentMiddleware
+from langchain_core.messages import ToolMessage
+
+#: The dispatch tool. The others (check/update/cancel/list) only make sense once
+#: something has been started, so they never trigger a launch.
+START_TOOL = "start_async_task"
+
+_FAILED = (
+    "The async agent server could not be started, so no background task was "
+    "launched. Delegate this with the `task` tool (an in-process subagent) instead."
+)
+
+
+class AsyncServerOnDemandMiddleware(AgentMiddleware):
+    """Bring the planned agent server up before the first async dispatch."""
+
+    async def awrap_tool_call(self, request: Any, handler: Any) -> Any:  # noqa: ANN401
+        call = getattr(request, "tool_call", None) or {}
+        if call.get("name") == START_TOOL:
+            from novacode_cli.agents import server_launcher
+
+            if not await server_launcher.ensure_started():
+                return ToolMessage(content=_FAILED, tool_call_id=call.get("id", ""), status="error")
+        return await handler(request)
+
+    def wrap_tool_call(self, request: Any, handler: Any) -> Any:  # noqa: ANN401
+        """Sync twin, for a subagent invoked with ``invoke``.
+
+        That runs on a worker thread with no event loop of its own, so the
+        launch gets a short-lived one.
+        """
+        call = getattr(request, "tool_call", None) or {}
+        if call.get("name") == START_TOOL:
+            from novacode_cli.agents import server_launcher
+
+            if not asyncio.run(server_launcher.ensure_started()):
+                return ToolMessage(content=_FAILED, tool_call_id=call.get("id", ""), status="error")
+        return handler(request)

novacode_cli/agents/async_task_errors.py

@@ -0,0 +1,75 @@
+# ruff: noqa: INP001 - agents uses namespace packaging
+"""Recover failed async-run diagnostics from LangGraph's checkpoint tasks."""
+
+from __future__ import annotations
+
+import inspect
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def _with_error(run: dict[str, Any], state: dict[str, Any], run_id: str) -> dict[str, Any]:
+    # A resumed thread may already have a newer checkpoint from a different run.
+    if (state.get("metadata") or {}).get("run_id") != run_id:
+        return run
+    from novacode_cli.security.prompt_injection import _credential_values, _redact
+    from novacode_cli.session.history_export import redact
+
+    secrets = _credential_values()
+    errors = []
+    for task in state.get("tasks") or []:
+        error = task.get("error")
+        if error:
+            errors.append(redact(_redact(str(error), secrets)))
+    if not errors:
+        return run
+    return {**run, "error": "\n".join(errors)[:4000]}
+
+
+def bind_run_errors(client: Any) -> Any:  # noqa: ANN401
+    """Enrich runs.get only when the server omitted a failed run's error.
+
+    LangGraph's Run schema has no error field; errors live in ThreadState.tasks.
+    Keep deepagents' normal check tool and state updates by filling that gap at
+    its existing client-factory seam. Never fetch or return child transcripts.
+    """
+    runs: Any = getattr(client, "runs", None)
+    original = getattr(runs, "get", None)
+    if original is None or getattr(original, "_nova_errors_bound", False) is True:
+        return client
+
+    def needs_error(run: dict[str, Any]) -> bool:
+        return run.get("status") == "error" and not run.get("error")
+
+    if inspect.iscoroutinefunction(original):
+
+        async def aget(thread_id: str, run_id: str, **kwargs: Any) -> Any:  # noqa: ANN401
+            run = await original(thread_id, run_id, **kwargs)
+            if needs_error(run):
+                try:
+                    state = await client.threads.get_state(thread_id=thread_id)
+                    return _with_error(run, state, run_id)
+                except Exception:  # noqa: BLE001 - status remains usable if state is unavailable
+                    logger.debug("Failed to fetch async error checkpoint for run %s", run_id)
+            return run
+
+        replacement: Any = aget
+    else:
+
+        def get(thread_id: str, run_id: str, **kwargs: Any) -> Any:  # noqa: ANN401
+            run = original(thread_id, run_id, **kwargs)
+            if needs_error(run):
+                try:
+                    state = client.threads.get_state(thread_id=thread_id)
+                    return _with_error(run, state, run_id)
+                except Exception:  # noqa: BLE001 - status remains usable if state is unavailable
+                    logger.debug("Failed to fetch async error checkpoint for run %s", run_id)
+            return run
+
+        replacement = get
+
+    replacement._nova_errors_bound = True
+    runs.get = replacement
+    return client

novacode_cli/agents/async_workspace.py

@@ -0,0 +1,27 @@
+"""The directory the async-agent graphs work in.
+
+The graphs used ``Path.cwd()`` of the server process, which is wherever
+``langgraph.json`` lives: Nova's own repo. Launched from another project they
+scouted Nova's source and reported it as findings about that project.
+
+The launcher now names the session's workspace in ``NOVA_WORKSPACE_ROOT`` and the
+graphs read it here. Without the variable (the Docker container, or a server
+someone started by hand) the server's own directory is used, as before.
+
+Resolved once, at import: ``os.getcwd()`` is a blocking call that ``langgraph
+dev`` rejects on its event loop.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+WORKSPACE_ROOT_VAR = "NOVA_WORKSPACE_ROOT"
+
+_ROOT = Path(os.environ.get(WORKSPACE_ROOT_VAR, "").strip() or os.getcwd()).resolve()
+
+
+def workspace_root() -> Path:
+    """Where the graphs read, search and run commands."""
+    return _ROOT

novacode_cli/agents/attribution.py

@@ -0,0 +1,165 @@
+"""Configurable commit and PR attribution without repository hooks or history edits."""
+# ruff: noqa: INP001 -- agents is an existing namespace package.
+
+from __future__ import annotations
+
+import asyncio
+import re
+from typing import TYPE_CHECKING
+
+from langchain.agents.middleware.types import AgentMiddleware
+from langchain_core.messages import SystemMessage
+
+from novacode_cli.config.nova_config import (
+    DEFAULT_ATTRIBUTION_EMAIL,
+    DEFAULT_ATTRIBUTION_NAME,
+    NovaConfig,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from langchain.agents.middleware.types import ModelRequest, ModelResponse, ToolCallRequest
+    from langchain_core.messages import AIMessage, ToolMessage
+    from langgraph.types import Command
+
+COAUTHOR = f"Co-Authored-By: {DEFAULT_ATTRIBUTION_NAME} <{DEFAULT_ATTRIBUTION_EMAIL}>"
+LOGO_URL = "https://raw.githubusercontent.com/Babitdor/NovaCode/main/assets/nova-attribution.png"
+PR_FOOTER = (
+    f'<img src="{LOGO_URL}" alt="NovaCode logo" width="24" height="24" /> '
+    "Generated with [NovaCode](https://github.com/Babitdor/NovaCode)"
+)
+_TRAILER = re.compile(r"^[A-Za-z0-9][A-Za-z0-9-]*\s*:")
+
+
+def commit_message(message: str, *, coauthor: str = COAUTHOR) -> str:
+    """Append a co-author once, preserving the final existing trailer block."""
+    stripped = message.rstrip()
+    lines = stripped.splitlines()
+    start = max((i + 1 for i, line in enumerate(lines) if not line.strip()), default=0)
+    tail = lines[start:]
+    trailers = bool(
+        start
+        and tail
+        and _TRAILER.match(tail[0])
+        and all(_TRAILER.match(line) or line.startswith((" ", "\t")) for line in tail)
+    )
+    if trailers and any(line.strip().casefold() == coauthor.casefold() for line in tail):
+        return message
+    separator = "\n" if trailers else "\n\n"
+    return stripped + separator + coauthor + "\n"
+
+
+def pull_request_body(body: str) -> str:
+    """Append a compact repository-hosted logo footer once."""
+    if PR_FOOTER in body:
+        return body
+    return body.rstrip() + "\n\n---\n\n" + PR_FOOTER
+
+
+def attribution_instructions(preferences: dict[str, bool], *, coauthor: str = COAUTHOR) -> str:
+    """Describe the effective preference for shell commands and other transports."""
+    commits = (
+        "For Git commits you create, append this trailer once, in the final trailer block:\n"
+        f"{coauthor}\n"
+        "Use git commit --trailer or a commit-message file so quoting is correct "
+        "for the current shell."
+        if preferences["commits"]
+        else "Do not add automatic NovaCode co-author trailers to commits."
+    )
+    prs = (
+        "For pull requests you create, append this exact logo footer once after the description:\n"
+        f"{PR_FOOTER}\n"
+        "For gh pr create, prefer --body-file with UTF-8 Markdown."
+        if preferences["pullRequests"]
+        else "Do not add automatic NovaCode text, logos or generated-by footers to pull requests."
+    )
+    return (
+        "<nova_attribution>\n" + commits + "\n" + prs + "\n"
+        "These preferences do not authorize commits, pushes or PR creation. Preserve the human "
+        "author, existing co-authors and user-supplied content. Do not install Git hooks, change "
+        "global Git identity, amend history or create extra commits for attribution. "
+        "A co-author trailer credits a commit; it does not establish line-level provenance.\n"
+        "</nova_attribution>"
+    )
+
+
+class AttributionMiddleware(AgentMiddleware):
+    """Apply live preferences to requests and structured creation tool payloads."""
+
+    @staticmethod
+    def prepare(request: ModelRequest) -> ModelRequest:
+        """Append preferences without editing stored history or the base prompt."""
+        config = NovaConfig()
+        identity = config.get_attribution_identity()
+        coauthor = f"Co-Authored-By: {identity['name']} <{identity['email']}>"
+        note = attribution_instructions(config.get_attribution(), coauthor=coauthor)
+        original = request.system_message
+        content = original.content if original else ""
+        content = (
+            content + "\n\n" + note
+            if isinstance(content, str)
+            else [*content, {"type": "text", "text": note}]
+        )
+        system = (
+            original.model_copy(update={"content": content})
+            if original
+            else SystemMessage(content=content)
+        )
+        return request.override(system_message=system)
+
+    @staticmethod
+    def prepare_tool(request: ToolCallRequest) -> ToolCallRequest:
+        """Normalize supported structured payloads; never rewrite shell command strings."""
+        name = request.tool_call["name"].lower()
+        actions = ("create_pull_request", "git_commit", "create_or_update_file", "push_files")
+        action = next((a for a in actions if name == a or name.endswith("_" + a)), None)
+        if action is None:
+            return request
+        config = NovaConfig()
+        preferences = config.get_attribution()
+        args = dict(request.tool_call.get("args") or {})
+        if action == "create_pull_request" and preferences["pullRequests"]:
+            if "body" not in args:
+                schema = request.tool.args if request.tool else {}
+                if "body" not in schema:
+                    return request
+            body = args.get("body", "")
+            if not isinstance(body, str):
+                return request  # Leave malformed arguments for normal schema validation.
+            args["body"] = pull_request_body(body)
+        elif action != "create_pull_request" and preferences["commits"]:
+            if not isinstance(args.get("message"), str):
+                return request
+            identity = config.get_attribution_identity()
+            coauthor = f"Co-Authored-By: {identity['name']} <{identity['email']}>"
+            args["message"] = commit_message(args["message"], coauthor=coauthor)
+        else:
+            return request
+        return request.override(tool_call={**request.tool_call, "args": args})
+
+    def wrap_model_call(
+        self, request: ModelRequest, handler: Callable[[ModelRequest], ModelResponse]
+    ) -> ModelResponse | AIMessage:
+        """Supply attribution preferences to synchronous model calls."""
+        return handler(self.prepare(request))
+
+    async def awrap_model_call(
+        self, request: ModelRequest, handler: Callable[[ModelRequest], Awaitable[ModelResponse]]
+    ) -> ModelResponse | AIMessage:
+        """Supply preferences without blocking the event loop on config reads."""
+        return await handler(await asyncio.to_thread(self.prepare, request))
+
+    def wrap_tool_call(
+        self, request: ToolCallRequest, handler: Callable[[ToolCallRequest], ToolMessage | Command]
+    ) -> ToolMessage | Command:
+        """Normalize supported synchronous tool calls before execution."""
+        return handler(self.prepare_tool(request))
+
+    async def awrap_tool_call(
+        self,
+        request: ToolCallRequest,
+        handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]],
+    ) -> ToolMessage | Command:
+        """Normalize supported async tool calls without blocking config reads."""
+        return await handler(await asyncio.to_thread(self.prepare_tool, request))