adk-code-mode 0.1.0__py3-none-any.whl

adk_code_mode/tools/catalog.py

@@ -0,0 +1,95 @@
+# SPDX-FileCopyrightText: 2025-present A2A Net <hello@a2anet.com>
+#
+# SPDX-License-Identifier: Apache-2.0
+"""Render the tool catalog string injected into the model's system prompt.
+
+The catalog is grouped by module: ``# tools.<namespace>`` sections (sorted),
+then ``# tools`` for any top-level tools. Each section opens with an import
+line and is followed by ``.pyi``-style function definitions (signature +
+docstring + ``...`` body). The callback
+(``adk_code_mode.callback.code_mode_before_model_callback``) wraps the result
+in ``<tools>`` / ``</tools>`` tags before appending it to the system prompt;
+this module returns just the inner content.
+"""
+
+from __future__ import annotations
+
+from adk_code_mode.tools.namespacing import NamespacedTool
+from adk_code_mode.tools.stubs import RenderedTool, render_tool
+
+
+def _render_entry(rt: RenderedTool) -> str:
+    """One ``.pyi``-style entry: signature + docstring + ``...`` placeholder."""
+    return f"{rt.signature_for('catalog')}\n    {rt.docstring}\n    ...\n"
+
+
+def _render_module_section(*, header: str, import_line: str, entries: list[str]) -> str:
+    blocks = "\n".join(entries)
+    return f"# {header}\n\n{import_line}\n\n{blocks}"
+
+
+def render_catalog(namespaced: list[NamespacedTool]) -> str:
+    """Render the full tool catalog (without ``<tools>`` wrapper).
+
+    Namespaced sections come first in namespace-sorted order, then top-level
+    tools. Tools within a section are sorted by attribute name for
+    determinism.
+    """
+    grouped: dict[str | None, list[NamespacedTool]] = {}
+    for nt in namespaced:
+        grouped.setdefault(nt.namespace, []).append(nt)
+
+    sections: list[str] = []
+
+    for ns in sorted(n for n in grouped if n is not None):
+        tools = sorted(grouped[ns], key=lambda t: t.attribute)
+        rendered = [render_tool(t) for t in tools]
+        names = ", ".join(rt.attribute for rt in rendered)
+        entries = [_render_entry(rt) for rt in rendered]
+        sections.append(
+            _render_module_section(
+                header=f"tools.{ns}",
+                import_line=f"from tools.{ns} import {names}",
+                entries=entries,
+            )
+        )
+
+    top_level = sorted(grouped.get(None, []), key=lambda t: t.attribute)
+    if top_level:
+        rendered = [render_tool(t) for t in top_level]
+        names = ", ".join(rt.attribute for rt in rendered)
+        entries = [_render_entry(rt) for rt in rendered]
+        sections.append(
+            _render_module_section(
+                header="tools",
+                import_line=f"from tools import {names}",
+                entries=entries,
+            )
+        )
+
+    return "\n".join(sections)
+
+
+_OVERFLOW_PROSE = (
+    "A `tools` package is available in the sandbox. List `/tools/` with "
+    "`pathlib.Path('/tools').iterdir()`. Each entry is either a `.py` file "
+    "(a top-level tool, importable as `from tools import <name>`) or a "
+    "subdirectory (a namespace, with tools importable as "
+    "`from tools.<namespace> import <name>`). To see a tool's signature and "
+    "docstring, read its `.py` file with `open(...).read()`."
+)
+
+
+def render_overflow_catalog() -> str:
+    """Catalog body used when the full catalog exceeds ``max_catalog_chars``.
+
+    Drops every tool section in favour of a prose explanation of how the
+    model can navigate ``/tools/`` from Python.
+    """
+    return _OVERFLOW_PROSE
+
+
+__all__ = [
+    "render_catalog",
+    "render_overflow_catalog",
+]

adk_code_mode/tools/dispatcher.py

@@ -0,0 +1,290 @@
+# SPDX-FileCopyrightText: 2025-present A2A Net <hello@a2anet.com>
+#
+# SPDX-License-Identifier: Apache-2.0
+"""Host-side tool dispatcher for code-mode calls.
+
+Replicates the before/after/on-error callback chain from
+``google.adk.flows.llm_flows.functions._execute_single_function_call_async``
+using only public attributes on ``InvocationContext`` and ``LlmAgent``. This
+insulates us from private-API drift.
+
+Call sequence matches ADK's own flow:
+
+1. ``plugin_manager.run_before_tool_callback``
+2. ``agent.canonical_before_tool_callbacks`` (first non-``None`` wins)
+3. ``tool.run_async(args=..., tool_context=...)``
+4. On exception: ``plugin_manager.run_on_tool_error_callback`` →
+   ``agent.canonical_on_tool_error_callbacks``. If no replacement, re-raise.
+5. ``plugin_manager.run_after_tool_callback``
+6. ``agent.canonical_after_tool_callbacks`` (first non-``None`` replaces result)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import copy
+import inspect
+from dataclasses import dataclass
+from typing import Any
+
+from google.adk.agents.invocation_context import InvocationContext
+from google.adk.events.event_actions import EventActions
+from google.adk.tools.base_tool import BaseTool
+from google.adk.tools.tool_context import ToolContext
+from google.genai import types as genai_types
+
+from adk_code_mode.tools.namespacing import Registry
+
+
+def _deep_merge_dicts(d1: dict[str, Any], d2: dict[str, Any]) -> dict[str, Any]:
+    """Recursively merge ``d2`` into ``d1``. Mirrors ADK's ``deep_merge_dicts``."""
+    for key, value in d2.items():
+        if key in d1 and isinstance(d1[key], dict) and isinstance(value, dict):
+            d1[key] = _deep_merge_dicts(d1[key], value)
+        else:
+            d1[key] = value
+    return d1
+
+
+@dataclass(frozen=True)
+class DispatchResult:
+    """Result of a single tool call."""
+
+    ok: bool
+    value: Any = None
+    error_type: str | None = None
+    error_message: str | None = None
+
+
+class UnsupportedToolActionError(RuntimeError):
+    """Raised when a tool requests ADK actions code mode cannot surface."""
+
+
+class Dispatcher:
+    """Dispatches host-side tool calls on behalf of the sandbox."""
+
+    def __init__(
+        self,
+        *,
+        invocation_context: InvocationContext,
+        registry: Registry,
+        execution_id: str,
+        per_tool_timeout_seconds: float | None = None,
+    ) -> None:
+        self._ctx = invocation_context
+        self._registry = registry
+        self._execution_id = execution_id
+        self._counter = 0
+        self._per_tool_timeout = per_tool_timeout_seconds
+        self._merge_lock = asyncio.Lock()
+        self._artifact_delta: dict[str, int] = {}
+
+    @property
+    def artifact_delta(self) -> dict[str, int]:
+        return dict(self._artifact_delta)
+
+    def _next_call_id(self) -> str:
+        self._counter += 1
+        return f"code_mode-{self._execution_id}-{self._counter}"
+
+    def _agent(self, invocation_context: InvocationContext | Any) -> Any:
+        """Return the invocation's agent if it carries ADK callback attributes.
+
+        Duck-typed so custom agent subclasses and test doubles work without
+        needing to inherit from ``LlmAgent``.
+        """
+        agent = invocation_context.agent
+        if agent is None:
+            return None
+        if (
+            hasattr(agent, "canonical_before_tool_callbacks")
+            or hasattr(agent, "canonical_after_tool_callbacks")
+            or hasattr(agent, "canonical_on_tool_error_callbacks")
+        ):
+            return agent
+        return None
+
+    def _new_tool_context(
+        self, invocation_context: InvocationContext | Any, call_id: str
+    ) -> ToolContext:
+        synthetic_call = genai_types.FunctionCall(id=call_id, name="code_mode")
+        return ToolContext(
+            invocation_context=invocation_context,
+            function_call_id=synthetic_call.id,
+        )
+
+    async def dispatch(
+        self, name: str, args: dict[str, Any], timeout: float | None = None
+    ) -> DispatchResult:
+        """Resolve and run one tool call. Never raises."""
+        try:
+            nt = self._registry.resolve_call(name)
+        except KeyError as exc:
+            return DispatchResult(ok=False, error_type="ToolNotFound", error_message=str(exc))
+
+        tool = nt.resolved.tool
+        call_args = copy.deepcopy(args)
+        # Clamp, don't override: the per-call wire timeout is attacker-controllable
+        # (sandbox code can call _rpc_client.call directly with any value), so the
+        # host's per_tool_timeout_seconds must remain a true ceiling.
+        if timeout is None:
+            effective_timeout = self._per_tool_timeout
+        elif self._per_tool_timeout is None:
+            effective_timeout = timeout
+        else:
+            effective_timeout = min(timeout, self._per_tool_timeout)
+        try:
+            call = self._run_and_merge(tool, call_args)
+            if effective_timeout is not None:
+                result = await asyncio.wait_for(call, timeout=effective_timeout)
+            else:
+                result = await call
+            return DispatchResult(ok=True, value=result)
+        except asyncio.TimeoutError:
+            return DispatchResult(
+                ok=False,
+                error_type="TimeoutError",
+                error_message=f"tool {tool.name!r} exceeded timeout of {effective_timeout}s",
+            )
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            return DispatchResult(
+                ok=False,
+                error_type=type(exc).__name__,
+                error_message=str(exc),
+            )
+
+    async def _run_and_merge(self, tool: BaseTool, args: dict[str, Any]) -> Any:
+        # Mirrors ADK's handle_function_calls_async: tools share live session.state
+        # for reads, write to per-call state_delta, then deltas deep-merge back in.
+        response, tool_context = await self._run_with_callbacks(
+            invocation_context=self._ctx,
+            tool=tool,
+            args=args,
+        )
+        async with self._merge_lock:
+            _deep_merge_dicts(self._ctx.session.state, tool_context.actions.state_delta)
+            self._artifact_delta.update(tool_context.actions.artifact_delta)
+        return response
+
+    async def _run_with_callbacks(
+        self,
+        *,
+        invocation_context: InvocationContext | Any,
+        tool: BaseTool,
+        args: dict[str, Any],
+    ) -> tuple[Any, ToolContext]:
+        call_id = self._next_call_id()
+        tool_context = self._new_tool_context(invocation_context, call_id)
+        plugin_manager = invocation_context.plugin_manager
+        agent = self._agent(invocation_context)
+
+        response: Any = await plugin_manager.run_before_tool_callback(
+            tool=tool, tool_args=args, tool_context=tool_context
+        )
+
+        if response is None and agent is not None:
+            for callback in getattr(agent, "canonical_before_tool_callbacks", []):
+                response = callback(tool=tool, args=args, tool_context=tool_context)
+                if inspect.isawaitable(response):
+                    response = await response
+                if response:
+                    break
+
+        if response is None:
+            try:
+                response = await tool.run_async(args=args, tool_context=tool_context)
+            except BaseException as tool_error:
+                override = await self._run_on_error(
+                    invocation_context, tool, args, tool_context, tool_error
+                )
+                if override is not None:
+                    response = override
+                else:
+                    raise
+
+        altered = await plugin_manager.run_after_tool_callback(
+            tool=tool, tool_args=args, tool_context=tool_context, result=response
+        )
+        if altered is None and agent is not None:
+            for callback in getattr(agent, "canonical_after_tool_callbacks", []):
+                altered = callback(
+                    tool=tool, args=args, tool_context=tool_context, tool_response=response
+                )
+                if inspect.isawaitable(altered):
+                    altered = await altered
+                if altered:
+                    break
+        if altered is not None:
+            response = altered
+
+        self._ensure_supported_actions(tool.name, tool_context.actions)
+
+        if tool.is_long_running and not response:
+            # ADK's normal flow keeps a pending function call open and resumes when the
+            # async result arrives. Code mode has no such resume path — the sandbox is
+            # blocked waiting for a synchronous tool result.
+            raise UnsupportedToolActionError(
+                f"tool {tool.name!r} is long-running and returned no immediate response; "
+                "long-running tools that yield asynchronously are not supported in code mode"
+            )
+        return response, tool_context
+
+    async def _run_on_error(
+        self,
+        invocation_context: InvocationContext | Any,
+        tool: BaseTool,
+        args: dict[str, Any],
+        tool_context: ToolContext,
+        error: BaseException,
+    ) -> Any:
+        plugin_manager = invocation_context.plugin_manager
+        # Plugin hook only accepts ``Exception``; promote other ``BaseException``
+        # subclasses (e.g. ``KeyboardInterrupt``) without trying to hand them off.
+        if not isinstance(error, Exception):
+            return None
+        error_response = await plugin_manager.run_on_tool_error_callback(
+            tool=tool, tool_args=args, tool_context=tool_context, error=error
+        )
+        if error_response is not None:
+            return error_response
+        agent = self._agent(invocation_context)
+        if agent is None:
+            return None
+        for callback in getattr(agent, "canonical_on_tool_error_callbacks", []):
+            error_response = callback(tool=tool, args=args, tool_context=tool_context, error=error)
+            if inspect.isawaitable(error_response):
+                error_response = await error_response
+            if error_response is not None:
+                return error_response
+        return None
+
+    def _ensure_supported_actions(self, tool_name: str, actions: EventActions) -> None:
+        unsupported: list[str] = []
+        if actions.requested_tool_confirmations:
+            unsupported.append("tool confirmations")
+        if actions.requested_auth_configs:
+            unsupported.append("credential requests")
+        if actions.render_ui_widgets:
+            unsupported.append("UI widgets")
+        if actions.transfer_to_agent:
+            unsupported.append("agent transfer")
+        if actions.escalate:
+            unsupported.append("escalation")
+        if actions.compaction is not None:
+            unsupported.append("event compaction")
+        if actions.end_of_agent:
+            unsupported.append("end_of_agent")
+        if actions.agent_state is not None:
+            unsupported.append("agent state")
+        if actions.rewind_before_invocation_id is not None:
+            unsupported.append("rewind")
+        if unsupported:
+            joined = ", ".join(unsupported)
+            raise UnsupportedToolActionError(
+                f"tool {tool_name!r} requested unsupported ADK actions in code mode: {joined}"
+            )
+
+
+__all__ = ["Dispatcher", "DispatchResult", "UnsupportedToolActionError"]

adk_code_mode/tools/namespacing.py

@@ -0,0 +1,200 @@
+# SPDX-FileCopyrightText: 2025-present A2A Net <hello@a2anet.com>
+#
+# SPDX-License-Identifier: Apache-2.0
+"""Group normalised tools into dotted Python namespaces.
+
+``slack_send_message`` → ``tools.slack.send_message``. The model writes
+``from tools.slack import send_message``; the dispatcher looks up the original
+``BaseTool.name`` via the registry built here.
+"""
+
+from __future__ import annotations
+
+import keyword
+import re
+from dataclasses import dataclass
+
+from google.adk.tools.base_toolset import BaseToolset
+
+from adk_code_mode.tools.normaliser import ResolvedTool
+
+_IDENT_STRIP = re.compile(r"[^a-zA-Z0-9_]")
+
+
+class ToolSurfaceError(ValueError):
+    """Raised when tools cannot be mapped to a safe/generated Python surface."""
+
+
+class DuplicateToolNameError(ToolSurfaceError):
+    """Raised when two resolved tools share the same raw ADK tool name."""
+
+
+class NamespaceCollisionError(ToolSurfaceError):
+    """Raised when two toolsets collapse onto the same generated namespace."""
+
+
+class PythonNameCollisionError(ToolSurfaceError):
+    """Raised when generated Python identifiers collide."""
+
+
+@dataclass(frozen=True)
+class NamespacedTool:
+    """A resolved tool with a chosen dotted path."""
+
+    resolved: ResolvedTool
+    namespace: str | None
+    """The module name the tool lives in, e.g. ``"slack"``. ``None`` for top-level."""
+    attribute: str
+    """The Python identifier used for the tool function inside its module."""
+
+    @property
+    def dotted_path(self) -> str:
+        if self.namespace:
+            return f"{self.namespace}.{self.attribute}"
+        return self.attribute
+
+    @property
+    def tool_name(self) -> str:
+        return self.resolved.tool.name
+
+
+def _sanitise_identifier(raw: str, *, fallback: str = "tool") -> str:
+    cleaned = _IDENT_STRIP.sub("_", raw).strip("_").lower()
+    if not cleaned:
+        cleaned = fallback
+    if cleaned[0].isdigit():
+        cleaned = f"_{cleaned}"
+    if keyword.iskeyword(cleaned):
+        cleaned = f"{cleaned}_"
+    return cleaned
+
+
+def _toolset_namespace(toolset: BaseToolset) -> str:
+    """Pick a stable module name for a toolset."""
+    name_attr = getattr(toolset, "name", None)
+    if isinstance(name_attr, str) and name_attr.strip():
+        return _sanitise_identifier(name_attr)
+    type_name = type(toolset).__name__
+    for suffix in ("Toolset", "ToolSet", "Tools"):
+        if type_name.endswith(suffix):
+            type_name = type_name[: -len(suffix)]
+            break
+    return _sanitise_identifier(type_name, fallback="toolset")
+
+
+def build(tools: list[ResolvedTool]) -> list[NamespacedTool]:
+    """Assign a dotted path to every tool and resolve all collisions.
+
+    Stable / deterministic: tools from the same toolset share a namespace; bare
+    tools live at the top level. Any ambiguity in the generated Python surface
+    is rejected up front.
+    """
+    out: list[NamespacedTool] = []
+    seen_attributes: set[tuple[str | None, str]] = set()
+    seen_raw_names: dict[str, NamespacedTool] = {}
+    namespace_sources: dict[str, BaseToolset] = {}
+    bare_attributes: dict[str, NamespacedTool] = {}
+    for resolved in tools:
+        namespace = _toolset_namespace(resolved.toolset) if resolved.toolset else None
+        if resolved.tool.name in seen_raw_names:
+            other = seen_raw_names[resolved.tool.name]
+            candidate = (
+                f"{namespace}.{_sanitise_identifier(resolved.tool.name, fallback='tool')}"
+                if namespace
+                else _sanitise_identifier(resolved.tool.name, fallback="tool")
+            )
+            raise DuplicateToolNameError(
+                f"Duplicate ADK tool name {resolved.tool.name!r} is not supported; this would "
+                f"make host dispatch ambiguous between {other.dotted_path!r} (from "
+                f"{_origin(other.resolved)}) and {candidate!r} (from {_origin(resolved)}). "
+                "Rename one of the tools or apply distinct ``tool_name_prefix`` values."
+            )
+        if namespace is not None and resolved.toolset is not None:
+            existing_source = namespace_sources.get(namespace)
+            if existing_source is not None and existing_source is not resolved.toolset:
+                raise NamespaceCollisionError(
+                    f"Toolsets {type(existing_source).__name__!r} and "
+                    f"{type(resolved.toolset).__name__!r} both map to generated namespace "
+                    f"{namespace!r}. Override ``BaseToolset.name`` on one of them so the "
+                    "generated import paths stay unique."
+                )
+            namespace_sources[namespace] = resolved.toolset
+        attribute = _sanitise_identifier(resolved.tool.name, fallback="tool")
+        if namespace is not None and namespace in bare_attributes:
+            colliding_bare = bare_attributes[namespace]
+            raise PythonNameCollisionError(
+                f"Top-level tool {colliding_bare.tool_name!r} (Python name {namespace!r}) "
+                f"collides with namespace {namespace!r} generated from "
+                f"{type(resolved.toolset).__name__ if resolved.toolset else 'tool'}. "
+                "Rename the bare tool or override the toolset's ``name`` so the surfaces don't share an identifier."
+            )
+        key = (namespace, attribute)
+        if key in seen_attributes:
+            dotted = f"{namespace}.{attribute}" if namespace else attribute
+            raise PythonNameCollisionError(
+                f"Generated Python identifier collision for {dotted!r}: ADK tool names "
+                f"would sanitise to the same identifier. Rename one of the tools so the "
+                "import surface is unique."
+            )
+        seen_attributes.add(key)
+        nt = NamespacedTool(resolved=resolved, namespace=namespace, attribute=attribute)
+        seen_raw_names[resolved.tool.name] = nt
+        if namespace is None:
+            bare_attributes[attribute] = nt
+        out.append(nt)
+
+    namespace_names = set(namespace_sources.keys())
+    for bare, nt in bare_attributes.items():
+        if bare in namespace_names:
+            source = namespace_sources[bare]
+            raise PythonNameCollisionError(
+                f"Top-level tool {nt.tool_name!r} (Python name {bare!r}) collides with "
+                f"namespace {bare!r} generated from {type(source).__name__}. "
+                "Rename the bare tool or override the toolset's ``name``."
+            )
+    return out
+
+
+def _origin(resolved: ResolvedTool) -> str:
+    """Human-readable origin of a resolved tool, for error messages."""
+    if resolved.toolset is not None:
+        return f"toolset {type(resolved.toolset).__name__}"
+    return "top-level tools"
+
+
+class Registry:
+    """Bidirectional lookup: dotted path ↔ ``BaseTool.name``."""
+
+    def __init__(self, tools: list[NamespacedTool]) -> None:
+        self._by_path: dict[str, NamespacedTool] = {t.dotted_path: t for t in tools}
+        by_tool_name: dict[str, NamespacedTool] = {}
+        for tool in tools:
+            existing = by_tool_name.get(tool.tool_name)
+            if existing is not None:
+                raise DuplicateToolNameError(
+                    "Duplicate ADK tool name "
+                    f"{tool.tool_name!r} is not supported; use unique tool names."
+                )
+            by_tool_name[tool.tool_name] = tool
+        self._by_tool_name = by_tool_name
+        self._tools = list(tools)
+
+    @property
+    def tools(self) -> list[NamespacedTool]:
+        return list(self._tools)
+
+    def by_dotted_path(self, path: str) -> NamespacedTool | None:
+        return self._by_path.get(path)
+
+    def by_tool_name(self, tool_name: str) -> NamespacedTool | None:
+        return self._by_tool_name.get(tool_name)
+
+    def resolve_call(self, name: str) -> NamespacedTool:
+        """Accept either the dotted path or the original ``BaseTool.name``."""
+        hit = self._by_path.get(name) or self._by_tool_name.get(name)
+        if hit is None:
+            raise KeyError(f"no tool registered for {name!r}")
+        return hit
+
+
+__all__ = ["NamespacedTool", "Registry", "build"]

adk_code_mode/tools/normaliser.py

@@ -0,0 +1,69 @@
+# SPDX-FileCopyrightText: 2025-present A2A Net <hello@a2anet.com>
+#
+# SPDX-License-Identifier: Apache-2.0
+"""Normalise heterogeneous tool inputs into a flat ``list[BaseTool]``.
+
+Accepts any mix of:
+
+- plain Python callables (wrapped as ``FunctionTool``)
+- ``BaseTool`` instances (kept as-is)
+- ``BaseToolset`` instances (expanded via ``get_tools_with_prefix``)
+
+Toolsets are async. We collect their tools inside the caller's event loop.
+Each resolved tool remembers the toolset it came from (if any) so namespacing
+can group them later.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, Sequence
+
+from google.adk.agents.readonly_context import ReadonlyContext
+from google.adk.tools.base_tool import BaseTool
+from google.adk.tools.base_toolset import BaseToolset
+from google.adk.tools.function_tool import FunctionTool
+
+ToolInput = BaseTool | BaseToolset | Callable[..., Any]
+
+
+@dataclass(frozen=True)
+class ResolvedTool:
+    """A single tool with provenance for namespacing."""
+
+    tool: BaseTool
+    toolset: BaseToolset | None
+
+
+async def resolve(
+    inputs: Sequence[ToolInput],
+    readonly_context: ReadonlyContext,
+) -> list[ResolvedTool]:
+    """Flatten the given inputs into a list of ``ResolvedTool``.
+
+    Args:
+        inputs: The mixed sequence passed to ``CodeModeCodeExecutor(tools=...)``.
+        readonly_context: Forwarded to ``BaseToolset.get_tools_with_prefix``.
+
+    Returns:
+        A flat list preserving input order. Toolset tools appear in the order
+        the toolset returned them.
+    """
+    resolved: list[ResolvedTool] = []
+    for item in inputs:
+        if isinstance(item, BaseTool):
+            resolved.append(ResolvedTool(tool=item, toolset=None))
+        elif isinstance(item, BaseToolset):
+            tools = await item.get_tools_with_prefix(readonly_context)
+            for tool in tools:
+                resolved.append(ResolvedTool(tool=tool, toolset=item))
+        elif callable(item):
+            resolved.append(ResolvedTool(tool=FunctionTool(item), toolset=None))
+        else:
+            raise TypeError(
+                f"Unsupported tool input {item!r}: expected BaseTool, BaseToolset, or callable"
+            )
+    return resolved
+
+
+__all__ = ["ResolvedTool", "ToolInput", "resolve"]