chore: import upstream snapshot with attribution

agent_runtime/tool_executor.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from time import time
+from typing import Any, Callable
+
+from .models import ToolCall, ToolResult, TurnControl
+from .tools import ToolRegistry, ToolRuntimeContext
+
+
+@dataclass(slots=True)
+class ToolExecutionRecord:
+    requested_name: str
+    canonical_name: str
+    arguments_before: dict[str, Any]
+    arguments_after: dict[str, Any]
+    result: ToolResult
+    started_at: float
+    finished_at: float
+    telemetry: dict[str, Any]
+
+
+class ToolExecutor:
+    def __init__(self, registry: ToolRegistry, session_index: Any) -> None:
+        self.registry = registry
+        self.session_index = session_index
+
+    async def execute(self, call: ToolCall, control: TurnControl, progress_callback: Callable[[dict[str, Any]], None] | None = None) -> ToolExecutionRecord:
+        requested_name = call.name
+        canonical_name = self.registry.resolve_name(call.name)
+        before = deepcopy(call.arguments)
+        started_at = time()
+        validated, validation_error = self.registry.validate_arguments(canonical_name, call.arguments)
+        arguments = validated if validated is not None else call.arguments
+        runtime = ToolRuntimeContext(requested_name=requested_name, canonical_name=canonical_name, turn_id=control.turn_id, cancel_event=control.cancel_event, progress_callback=progress_callback, metadata={"cancel_reason": control.cancel_reason})
+        if validation_error:
+            result = ToolResult(canonical_name, False, validation_error, {"validation_error": True})
+        elif control.cancel_event.is_set():
+            result = ToolResult(canonical_name, False, control.cancel_reason or "Tool execution cancelled", {"cancelled": True})
+        else:
+            result = await self.registry.execute(canonical_name, arguments, runtime=runtime)
+        finished_at = time()
+        telemetry = {"duration_ms": int((finished_at - started_at) * 1000), "requested_name": requested_name, "canonical_name": canonical_name, "result_ok": result.ok}
+        self.session_index.append_log("tool_calls", {"turn_id": control.turn_id, "tool": canonical_name, "arguments_preview": str(before)[:500], "ok": result.ok, "content_preview": result.content[:500], **telemetry})
+        return ToolExecutionRecord(requested_name, canonical_name, before, deepcopy(arguments), result, started_at, finished_at, telemetry)