Surface Pydantic ValidationError to LLM in tool arg validation

Tool-argument validation failures raised as pydantic ValidationError are
now returned to the model as a clean, actionable message built from each
error's loc and msg, instead of the generic redacted text. All other
exceptions stay fully redacted.

The except branch lives here because tool arguments are deserialized via
ptype.model_validate(args) just above in the same try block, so this is
where the ValidationError originates and is the right place to catch it,
ahead of the generic redaction fallback.

Safe to surface: the invalid values are arguments the LLM itself supplied,
and validator messages are authored by tool developers. The user-facing
text is assembled from only loc + msg; the full str(exc) (including raw
input) is kept in the debug-only error field.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: idryzhov

python/copilot/tools.py

@@ -13,7 +13,7 @@
 from dataclasses import dataclass, field
 from typing import Any, Literal, TypeVar, get_type_hints, overload
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
 
 ToolResultType = Literal["success", "failure", "rejected", "denied", "timeout"]
 
@@ -224,6 +224,21 @@ async def wrapped_handler(invocation: ToolInvocation) -> ToolResult:
 
                 return _normalize_result(result)
 
+            except ValidationError as exc:
+                # Safe to surface: the invalid values are arguments the LLM itself
+                # supplied, and validator messages are authored by tool developers.
+                parts = []
+                for err in exc.errors():
+                    loc = ".".join(map(str, err["loc"]))
+                    msg = err["msg"]
+                    parts.append(f"{loc}: {msg}" if loc else msg)
+                return ToolResult(
+                    text_result_for_llm="Invalid tool arguments:\n" + "\n".join(parts),
+                    result_type="failure",
+                    error=str(exc),
+                    tool_telemetry={},
+                )
+
             except Exception as exc:
                 # Don't expose detailed error information to the LLM for security reasons.
                 # The actual error is stored in the 'error' field for debugging.

python/test_tools.py

@@ -3,7 +3,7 @@
 import json
 
 import pytest
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 from copilot import define_tool
 from copilot.tools import (
@@ -197,6 +197,62 @@ def failing_tool(params: Params, invocation: ToolInvocation) -> str:
         # But the actual error is stored internally
         assert result.error == "secret error message"
 
+    async def test_validation_error_is_surfaced_to_llm(self):
+        class Params(BaseModel):
+            username: str
+
+            @field_validator("username")
+            @classmethod
+            def check_username(cls, v: str) -> str:
+                if v == "admin":
+                    raise ValueError("username 'admin' is reserved")
+                return v
+
+        @define_tool("validate", description="A validating tool")
+        def validating_tool(params: Params) -> str:
+            return "ok"
+
+        invocation = ToolInvocation(
+            session_id="s1",
+            tool_call_id="c1",
+            tool_name="validate",
+            arguments={"username": "admin"},
+        )
+
+        result = await validating_tool.handler(invocation)
+
+        assert result.result_type == "failure"
+        assert result.text_result_for_llm.startswith("Invalid tool arguments:")
+        assert "username 'admin' is reserved" in result.text_result_for_llm
+        # Full detail is retained in the debug field.
+        assert result.error is not None
+
+    async def test_validation_error_extra_forbid_includes_field_name(self):
+        class Params(BaseModel):
+            model_config = ConfigDict(extra="forbid")
+
+            request: str
+
+        @define_tool("strict", description="A strict tool")
+        def strict_tool(params: Params) -> str:
+            return "ok"
+
+        invocation = ToolInvocation(
+            session_id="s1",
+            tool_call_id="c1",
+            tool_name="strict",
+            arguments={"request": "ok", "extra_field": "unexpected"},
+        )
+
+        result = await strict_tool.handler(invocation)
+
+        assert result.result_type == "failure"
+        assert result.text_result_for_llm.startswith("Invalid tool arguments:")
+        # The offending key name is carried in `loc` even though the generic
+        # message is "Extra inputs are not permitted".
+        assert "extra_field" in result.text_result_for_llm
+        assert result.error is not None
+
     async def test_function_style_api(self):
         class Params(BaseModel):
             value: str