agentengine-sdk-python 0.8.5__py3-none-any.whl → 0.8.6__py3-none-any.whl

ksadk/harness/native/tool_input_validation.py

@@ -0,0 +1,58 @@
+"""Pure validation of pinned tool input; never normalize or grant permission."""
+
+from __future__ import annotations
+
+import json
+
+from jsonschema import FormatChecker
+from jsonschema.exceptions import ValidationError as SchemaValidationError
+from jsonschema.validators import validator_for
+from pydantic import JsonValue
+
+from .tool_argument_feedback import argument_error
+
+
+def _reject_external_refs(value: object) -> None:
+    if isinstance(value, dict):
+        for key, child in value.items():
+            if key in {"$ref", "$dynamicRef", "$recursiveRef"}:
+                if not isinstance(child, str) or not child.startswith("#"):
+                    raise ValueError("tool schemas may only reference local fragments")
+            _reject_external_refs(child)
+    elif isinstance(value, list):
+        for child in value:
+            _reject_external_refs(child)
+
+
+class ToolInputValidator:
+    """The same detached schema and diagnostic semantics at both boundaries.
+
+    The Kernel uses this before entering a ToolPort. StrictToolExecutor keeps
+    a compiled instance alongside its pinned callback and checks again before
+    current authorization. Success is only a schema fact, never approval.
+    """
+
+    def __init__(self, parameters: dict[str, JsonValue]) -> None:
+        try:
+            self._parameters = json.loads(json.dumps(parameters, allow_nan=False))
+        except (TypeError, ValueError) as exc:
+            raise ValueError("invalid tool schema") from exc
+        _reject_external_refs(self._parameters)
+        try:
+            validator_class = validator_for(self._parameters)
+            validator_class.check_schema(self._parameters)
+            self._validator = validator_class(self._parameters, format_checker=FormatChecker())
+        except Exception as exc:
+            raise ValueError("invalid tool schema") from exc
+
+    def rejection(self, arguments: dict[str, JsonValue]) -> dict[str, JsonValue] | None:
+        try:
+            # Validate detached finite JSON without replacing the admitted
+            # arguments. Defaults and coercion never rewrite an action.
+            value = json.loads(json.dumps(arguments, allow_nan=False))
+            self._validator.validate(value)
+        except SchemaValidationError as exc:
+            return argument_error(exc, self._parameters, self._validator)
+        except Exception:
+            return {"code": "invalid_arguments"}
+        return None

ksadk/harness/native/tool_interruption.py

@@ -0,0 +1,96 @@
+"""Bind interrupted batch dispositions to the original host transcript."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+
+from .state import (
+    CommitBatch,
+    EffectIntent,
+    EffectReceipt,
+    InterruptedToolCall,
+    RunSnapshot,
+    ToolBatchInterruption,
+)
+from .transitions import insert_event_before_terminal
+
+
+def tool_batch_digest(message: dict) -> str:
+    raw = json.dumps(message, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(raw.encode("utf-8")).hexdigest()
+
+
+def record_tool_interruption(
+    previous: RunSnapshot, batch: CommitBatch,
+    intent: EffectIntent | None = None, receipt: EffectReceipt | None = None,
+) -> CommitBatch:
+    """Keep dispatch knowledge when a host transition clears an unfinished batch.
+
+    No model/tool prose supplies execution authority. Claimed effects remain
+    unknown; only calls outside that effect, or a prepared effect, are known
+    undispatched. Original messages, receipts and admission counters stay intact.
+    Legacy/malformed histories without an exact source keep their unknown fallback.
+    """
+    if (not previous.pending_tools or batch.snapshot.pending_tools
+            or batch.snapshot.outcome is None):
+        return batch
+    pending = {call["call_id"] for call in previous.pending_tools}
+    source = next((
+        (index, message) for index, message in reversed(tuple(enumerate(previous.messages)))
+        if message.get("role") == "assistant"
+        and pending.issubset({call.get("id") for call in message.get("tool_calls", ())})
+    ), None)
+    if source is None:
+        return batch
+    index, message = source
+    completed = {item.get("tool_call_id") for item in batch.snapshot.messages[index + 1:]
+                 if item.get("role") == "tool"}
+    pending -= completed
+    if not pending:
+        return batch
+    scheduled, unknown = set(), set()
+    if intent is not None and intent.kind == "tool":
+        raw = intent.payload.get("calls")
+        raw = raw if isinstance(raw, list) else [intent.payload.get("call")]
+        scheduled = {call.get("call_id") for call in raw if isinstance(call, dict)}
+        explicitly_undispatched = (
+            receipt is not None and receipt.status == "failed"
+            and receipt.result.get("reason") == "not_dispatched"
+        )
+        if not scheduled or None in scheduled:
+            unknown = pending
+        elif not explicitly_undispatched and (receipt is not None or intent.status == "running"):
+            unknown = scheduled
+    elif intent is None:
+        if previous.pending_intent is not None:
+            unknown = pending  # Missing host dispatch evidence is never a non-execution proof.
+        elif previous.pending_interaction is not None:
+            # A paused tool/child has already entered its Port. Its nonterminal
+            # approval is not a committed execution result or rollback proof.
+            unknown = {previous.pending_tools[0]["call_id"]}
+    observation = ToolBatchInterruption(
+        source_message_index=index, source_message_digest=tool_batch_digest(message),
+        reason=batch.snapshot.reason or "interrupted_tool_batch",
+        calls=tuple(InterruptedToolCall(
+            call_id=call["call_id"],
+            execution_status="unknown" if call["call_id"] in unknown else "not_dispatched",
+            operation_key=(intent.operation_key if intent is not None
+                           and call["call_id"] in scheduled else None),
+        ) for call in previous.pending_tools if call["call_id"] in pending),
+    )
+    batch = batch.model_copy(update={"snapshot": batch.snapshot.model_copy(update={
+        "tool_batch_interruption": observation,
+    })})
+    return insert_event_before_terminal(previous, batch, (
+        "tools.interrupted", observation.model_dump(mode="json"),
+    ))
+
+
+def interrupted_tool_calls(parent: RunSnapshot, index: int, message: dict) -> dict:
+    """Use a disposition only for its exact original assistant batch."""
+    observation = parent.tool_batch_interruption
+    if (observation is None or observation.source_message_index != index
+            or observation.source_message_digest != tool_batch_digest(message)):
+        return {}
+    return {call.call_id: call for call in observation.calls}

ksadk/harness/native/tool_observation.py

@@ -0,0 +1,259 @@
+"""Separate a canonical executed receipt from its host-selected model view.
+
+Hashes detect inconsistent persisted projections, not hostile Store rewrites.
+Only the reducer creates this top-level field from a locked tool policy. Tool
+payload text cannot create it or acquire execution/verification authority.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+
+from .model import ModelImageContent, ModelTextContent
+
+VERSION = "canonical-tool-model-view/v1"
+OBSERVED_HISTORY_VERSION = "canonical-tool-model-view/v2"
+TYPED_HISTORY_VERSION = "canonical-tool-model-view/v3"
+
+
+def executed_tool_message(
+    result, *, call_id, definition=None, receipt_ref=None, goal_revision=0,
+    tool_call=0, hook_metadata=None,
+):
+    """Use the same canonical observation for a single or completed batch member."""
+    if result.model_observation is not None and (
+        definition is None or definition.result_model_policy != result.model_observation.version
+    ):
+        raise ValueError("tool_model_policy_mismatch")
+    canonical = (
+        definition is not None
+        and definition.result_archive_policy in {
+            "archived-model-view/v3", "archived-model-view/v4", "archived-model-view/v5",
+        }
+        and result.status == "ok" and result.model_content is not None
+    )
+    message = {
+        "role": "tool", "tool_call_id": call_id,
+        "content": (
+            result.model_content
+            if result.status == "ok" and result.model_content is not None and not canonical
+            else json.dumps(
+                {"status": result.status, "content": result.content}, ensure_ascii=False,
+            )
+        ),
+    }
+    if receipt_ref is not None:
+        message.update(receipt_ref=receipt_ref, receipt_goal_revision=goal_revision,
+                       receipt_tool_call=tool_call)
+    message.update(hook_metadata or {})
+    if result.artifact_refs:
+        message["artifact_refs"] = [ref.model_dump(mode="json") for ref in result.artifact_refs]
+    if result.content_blocks:
+        message["content"] = [
+            {"type": "text", "text": message["content"]},
+            *(block.model_dump(mode="json") for block in result.content_blocks),
+        ]
+    if canonical:
+        message = seal_model_view(
+            message, result.model_content,
+            observed_history=definition.result_archive_policy in {
+                "archived-model-view/v4", "archived-model-view/v5",
+            },
+        )
+    return (seal_typed_model_view(message, result.model_observation)
+            if result.model_observation is not None else message)
+
+
+def append_executed_tool_message(messages, message):
+    """Seal once, retaining declaration order independently of completion events."""
+    insertion = len(messages)
+    if message.get("receipt_ref") is not None:
+        found = []
+        for index in range(len(messages) - 1, -1, -1):
+            item = messages[index]
+            if item.get("role") == "assistant" and item.get("tool_calls"):
+                break
+            if (item.get("role") == "tool"
+                    and item.get("receipt_ref") == message["receipt_ref"]
+                    and item.get("tool_call_id") == message["tool_call_id"]):
+                found.append(item)
+            if (item.get("role") == "tool"
+                    and item.get("receipt_ref") == message["receipt_ref"]
+                    and item.get("receipt_tool_call", 0) > message.get("receipt_tool_call", 0)):
+                insertion = min(insertion, index)
+        if found:
+            if len(found) != 1 or found[0] != message:
+                raise ValueError("tool_member_observation_conflict")
+            return messages
+    return (*messages[:insertion], message, *messages[insertion:])
+
+
+def ordered_tool_artifact_refs(refs, messages, receipt_ref, baseline):
+    """Keep pre-batch references, then member attachments in declaration order."""
+    if baseline is None:
+        return refs  # An old intent does not authorize a reconstructed baseline.
+    available = {ref["uri"]: ref for ref in refs}
+    if any(uri not in available for uri in baseline):
+        raise ValueError("parallel_artifact_baseline_missing")
+    batch = []
+    for item in reversed(messages):
+        if item.get("role") == "assistant" and item.get("tool_calls"):
+            break
+        if item.get("role") == "tool" and item.get("receipt_ref") == receipt_ref:
+            batch.append(item)
+    order = dict.fromkeys((*baseline, *(
+        ref["uri"] for item in reversed(batch) for ref in item.get("artifact_refs", ())
+    ), *available))
+    return tuple(available[uri] for uri in order)
+
+
+def parallel_result_violation(result, *, delegated):
+    usage = result.resource_usage
+    return (
+        result.status in {"approval_required", "uncertain"}
+        or bool(result.workspace_changed_paths)
+        or not delegated and bool(usage.model_calls or usage.tool_calls or usage.child_run_ids)
+        or delegated and not usage.child_run_ids and bool(usage.model_calls)
+    )
+
+
+def _digest(value):
+    text = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def seal_model_view(message, content, *, observed_history=False):
+    return {
+        **message,
+        "model_view": {
+            "version": OBSERVED_HISTORY_VERSION if observed_history else VERSION,
+            "source_digest": _digest(message["content"]),
+            "view_digest": _digest(content),
+            "content": content,
+        },
+    }
+
+
+def seal_typed_model_view(message, observation):
+    content = observation.message_content()
+    return {
+        **message,
+        "model_view": {
+            "version": TYPED_HISTORY_VERSION,
+            "source_digest": _digest(message["content"]),
+            "view_digest": _digest(content),
+            "content": content,
+        },
+    }
+
+
+def _typed_model_content(content):
+    if isinstance(content, str):
+        blocks = ({"type": "text", "text": content},)
+    elif isinstance(content, list) and content:
+        blocks = tuple(content)
+    else:
+        raise ValueError("tool_model_view_invalid")
+    validated = tuple(
+        (ModelImageContent if block.get("type") == "image_url" else ModelTextContent)
+        .model_validate(block).model_dump(mode="json")
+        for block in blocks if isinstance(block, dict)
+    )
+    if len(validated) != len(blocks) or validated[0]["type"] != "text":
+        raise ValueError("tool_model_view_invalid")
+    text_bytes = sum(len(b["text"].encode()) for b in validated if b["type"] == "text")
+    images = [b for b in validated if b["type"] == "image_url"]
+    if not 0 < text_bytes <= 65536 or len(images) > 8:
+        raise ValueError("tool_model_view_invalid")
+    # Rehydration admits only the contract's absolute ceiling. Each live Run
+    # already governed media against its own (possibly smaller) pinned limit.
+    if sum(len(json.dumps(b, ensure_ascii=False, sort_keys=True,
+                          separators=(",", ":")).encode()) for b in images) > 64 * 1024 * 1024:
+        raise ValueError("tool_model_view_invalid")
+    return validated
+
+
+def model_observation_message(message):
+    """Project without I/O or mutating the authoritative receipt."""
+    copied = json.loads(json.dumps(message, ensure_ascii=False))
+    view = copied.pop("model_view", None)
+    if view is None:
+        return copied
+    if isinstance(view, dict) and view.get("version") == TYPED_HISTORY_VERSION:
+        try:
+            if (
+                copied.get("role") != "tool"
+                or set(view) != {"version", "source_digest", "view_digest", "content"}
+                or view["source_digest"] != _digest(copied.get("content"))
+                or view["view_digest"] != _digest(view["content"])
+            ):
+                raise ValueError
+            blocks = _typed_model_content(view["content"])
+            source = json.loads(copied["content"])
+            projected = json.loads(blocks[0]["text"])
+            if (
+                not isinstance(source, dict) or not isinstance(projected, dict)
+                or source.get("status") not in {"ok", "error"}
+                or projected.get("status") != source["status"]
+                or set(source) != {"status", "content"}
+                or set(projected) != {"status", "content"}
+            ):
+                raise ValueError
+        except (ValueError, TypeError, KeyError, AttributeError):
+            raise ValueError("tool_model_view_invalid") from None
+        copied["content"] = view["content"]
+        return copied
+    if (
+        copied.get("role") != "tool"
+        or not isinstance(view, dict)
+        or set(view) != {"version", "source_digest", "view_digest", "content"}
+        or view["version"] not in {VERSION, OBSERVED_HISTORY_VERSION}
+        or not isinstance(view["content"], str)
+        or not 0 < len(view["content"].encode("utf-8")) <= 65536
+        or view["source_digest"] != _digest(copied.get("content"))
+        or view["view_digest"] != _digest(view["content"])
+    ):
+        raise ValueError("tool_model_view_invalid")
+    source = copied.get("content")
+    if isinstance(source, list):
+        if not source or source[0].get("type") != "text":
+            raise ValueError("tool_model_view_invalid")
+        source = source[0].get("text")
+    try:
+        original, projected = json.loads(source), json.loads(view["content"])
+        if any(
+            not isinstance(value, dict) or value.get("status") != "ok" or "content" not in value
+            for value in (original, projected)
+        ):
+            raise ValueError
+    except (ValueError, TypeError):
+        raise ValueError("tool_model_view_invalid") from None
+    # A textual alternate view cannot resurrect auxiliary oversized text. The
+    # exact text stays canonical; explicit image blocks keep their own budget.
+    blocks = copied.get("content")
+    copied["content"] = (
+        [{"type": "text", "text": view["content"]},
+         *(block for block in blocks if block.get("type") == "image_url")]
+        if isinstance(blocks, list) else view["content"]
+    )
+    return copied
+
+
+def model_observation_messages(messages):
+    return tuple(model_observation_message(message) for message in messages)
+
+
+def history_observation_message(message):
+    """The locked receipt policy selects its historical observation consumer.
+
+    v1 deliberately quotes the canonical result. v2 quotes the complete
+    bounded model observation, including unread ranges and artifact access;
+    archiving raw text does not implicitly schedule that text for the model.
+    """
+    view = message.get("model_view")
+    return (
+        model_observation_message(message)
+        if isinstance(view, dict)
+        and view.get("version") in {OBSERVED_HISTORY_VERSION, TYPED_HISTORY_VERSION} else message
+    )

ksadk/harness/native/tool_progress.py

@@ -0,0 +1,223 @@
+"""Warn once per unchanged tool streak, only after complete protocol batches.
+
+Reference: OpenCode fe3f3a41 processor.ts:29,358-379 uses a threshold of
+three repeated inputs; ZCode 872ad960 turn-tool-warnings.ts:52-79 injects
+anomaly reminders. This independent adaptation also requires unchanged results
+and only emits an observation: it never approves, stops, retries, or resets a
+budget. Actual result payload timestamps remain meaningful; envelope identities,
+timestamps and usage do not contribute to the comparison.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass, field
+from typing import Literal
+
+from pydantic import JsonValue
+
+from .model import ModelToolCall
+from .ports import ToolResult
+from .state import Contract
+
+REPEATED_TOOL_THRESHOLD = 3
+Messages = tuple[dict[str, JsonValue], ...]
+_OBSERVATIONS = {
+    "tool_loop_observation",
+    "model_recovery_observation",
+    "verification_observation",
+    "continuation_observation",
+    "background_child_observation",
+}
+
+
+class ToolLoopWarning(Contract):
+    reason: Literal["repeated_tool_no_progress"] = "repeated_tool_no_progress"
+    threshold: Literal[3] = REPEATED_TOOL_THRESHOLD
+    observed_count: int
+    signature: str
+
+
+class ToolProgressFeedback(Contract):
+    messages: Messages
+    warning: ToolLoopWarning | None = None
+
+
+def _canonical(value: object) -> str:
+    return json.dumps(
+        value, sort_keys=True, ensure_ascii=False, separators=(",", ":"), allow_nan=False
+    )
+
+
+def _calls(message: dict) -> tuple[ModelToolCall, ...]:
+    parsed = []
+    for raw in message["tool_calls"]:
+        function = raw["function"]
+        arguments = function["arguments"]
+        parsed.append(
+            ModelToolCall(
+                call_id=raw["id"],
+                name=function["name"],
+                arguments=json.loads(arguments) if isinstance(arguments, str) else arguments,
+            )
+        )
+    if not parsed or len({c.call_id for c in parsed}) != len(parsed):
+        raise ValueError("invalid tool batch")
+    return tuple(parsed)
+
+
+def _observation(message: dict) -> str | None:
+    value = message.get("content")
+    blocks = []
+    if isinstance(value, list) and value and value[0].get("type") == "text":
+        blocks, value = value[1:], value[0].get("text")
+    if isinstance(value, str):
+        try:
+            value = json.loads(value)
+        except ValueError:
+            pass
+    if isinstance(value, dict) and "status" in value:
+        if value["status"] not in {"ok", "error"}:
+            return None  # Missing, uncertain or superseded results do not prove repetition.
+        value = {"status": value["status"], "content": value.get("content")}
+    return _canonical({"result": value, "blocks": blocks})
+
+
+@dataclass
+class _Progress:
+    signature: str = ""
+    count: int = 0
+    warned: bool = False
+    valid: bool = True
+    pending: tuple[ModelToolCall, ...] = ()
+    results: dict[str, str | None] = field(default_factory=dict)
+    last_error: bool = False
+
+    def reset(self) -> None:
+        self.signature, self.count, self.warned = "", 0, False
+        self.last_error = False
+
+    def record(self, call: ModelToolCall, observation: str | None) -> None:
+        if observation is None:
+            self.reset()
+            return
+        signature = hashlib.sha256(
+            _canonical([call.name, call.arguments, observation]).encode()
+        ).hexdigest()
+        projected = json.loads(observation).get("result")
+        self.last_error = isinstance(projected, dict) and projected.get("status") == "error"
+        if signature == self.signature:
+            self.count += 1
+        else:
+            self.signature, self.count, self.warned = signature, 1, False
+
+
+def _scan(messages: Messages) -> _Progress:
+    progress = _Progress()
+    try:
+        for message in messages:
+            role = message.get("role")
+            if role == "tool":
+                call_id = message.get("tool_call_id")
+                if (
+                    call_id not in {c.call_id for c in progress.pending}
+                    or call_id in progress.results
+                ):
+                    raise ValueError("orphan or duplicate tool result")
+                progress.results[call_id] = _observation(message)
+                if len(progress.results) == len(progress.pending):
+                    for call in progress.pending:
+                        progress.record(call, progress.results[call.call_id])
+                    progress.pending, progress.results = (), {}
+                continue
+            if progress.pending:
+                raise ValueError("interleaved tool batch")
+            if role == "assistant" and message.get("tool_calls"):
+                progress.pending = _calls(message)
+            elif role == "user":
+                if message.get("kind") not in _OBSERVATIONS:
+                    progress.reset()
+                elif (
+                    message.get("kind") == "tool_loop_observation"
+                    and message.get("tool_progress_signature") == progress.signature
+                    and progress.count >= REPEATED_TOOL_THRESHOLD
+                ):
+                    progress.warned = True
+    except (KeyError, TypeError, ValueError, AttributeError):
+        progress.valid = False
+    return progress
+
+
+def repeated_error_streak(messages: Messages) -> int:
+    """Count identical, completed tool errors since the last changed observation."""
+    progress = _scan(messages)
+    if not progress.valid or progress.pending or not progress.last_error:
+        return 0
+    return progress.count
+
+
+def _append_result(messages: Messages, call: ModelToolCall, result: ToolResult) -> Messages:
+    progress = _scan(messages)
+    if (
+        not progress.valid
+        or call not in progress.pending
+        or call.call_id in progress.results
+        or result.status not in {"ok", "error"}
+    ):
+        raise ValueError("tool_progress_invalid_pending_result")
+    content = json.dumps({"status": result.status, "content": result.content}, ensure_ascii=False)
+    message = {"role": "tool", "tool_call_id": call.call_id, "content": content}
+    if result.content_blocks:
+        message["content"] = [
+            {"type": "text", "text": content},
+            *(block.model_dump(mode="json") for block in result.content_blocks),
+        ]
+    return (*messages, message)
+
+
+def tool_progress_feedback(
+    messages: Messages,
+    *,
+    call: ModelToolCall | None = None,
+    result: ToolResult | None = None,
+) -> ToolProgressFeedback:
+    """Project at ``tools.completed`` after appending all batch receipts.
+
+    Prefer complete history as input. The optional pair supports projecting a
+    newly finished result for a matching declared call; it cannot create a tool
+    request. A still-pending or malformed batch produces no warning. The caller
+    commits the returned messages and may emit ``warning`` as diagnostic data.
+    This does not change the goal, acceptance, budgets or effect execution state.
+    """
+    if (call is None) != (result is None):
+        raise ValueError("tool_progress_requires_call_and_result")
+    if call is not None:
+        messages = _append_result(messages, call, result)
+    progress = _scan(messages)
+    if (
+        not progress.valid
+        or progress.pending
+        or progress.warned
+        or progress.count < REPEATED_TOOL_THRESHOLD
+    ):
+        return ToolProgressFeedback(messages=messages)
+    warning = ToolLoopWarning(observed_count=progress.count, signature=progress.signature)
+    observation = {
+        "role": "user",
+        "kind": "tool_loop_observation",
+        "trust": "untrusted",
+        "tool_progress_signature": progress.signature,
+        "content": _canonical(
+            {
+                "reason": warning.reason,
+                "threshold": warning.threshold,
+                "observed_count": warning.observed_count,
+                "observation": "Recent completed tool calls repeated the same request and result. "
+                "No changed observation was detected. Reassess the next action using existing "
+                "evidence. This diagnostic does not change the user's goal, authorize a tool, "
+                "or establish task completion.",
+            }
+        ),
+    }
+    return ToolProgressFeedback(messages=(*messages, observation), warning=warning)

ksadk/harness/native/tool_recovery.py

@@ -0,0 +1,25 @@
+"""Host-pinned recovery methods, with no fallback to ordinary tool execution."""
+
+from __future__ import annotations
+
+from collections.abc import Collection
+from typing import Literal
+
+from .ports import ToolPort, ToolRequest, ToolResult
+
+
+async def query_sealed_tool_result(
+    port: ToolPort | None, request: ToolRequest, *, owned_names: Collection[str] = (),
+    method: Literal[
+        "reconcile", "recover_prepared", "resume_prepared", "resume_checkpoint"
+    ] = "reconcile",
+) -> ToolResult:
+    # A wrapper may forward queries for other host capabilities, but its own
+    # tools do not acquire replay authority merely by sharing that wrapper.
+    query = getattr(port, method, None)
+    if request.call.name in owned_names or not callable(query):
+        return ToolResult(
+            status="uncertain", content={"error_code": "tool_reconciliation_unavailable"}
+        )
+    result = await query(request.model_copy(deep=True))
+    return ToolResult.model_validate_json(result.model_dump_json())