@@ -601,6 +601,7 @@ def to_function_tool(
                 mcp_server_name=get_mcp_server_log_name(server.name),
             ),
         )
+        function_tool._mcp_annotations = copy.deepcopy(tool.annotations)
         function_tool._mcp_tool_binding = (get_mcp_server_log_name(server.name), tool.name, None)
         return function_tool
 
 
@@ -86,6 +86,7 @@
 from .util._types import MaybeAwaitable
 
 if TYPE_CHECKING:
+    from mcp.types import ToolAnnotations
     from typing_extensions import dataclass_transform
 
     from .agent import Agent, AgentBase
@@ -594,6 +595,22 @@ class FunctionTool:
     )
     """Original MCP server name, raw tool name, and configured server position for resume."""
 
+    _mcp_annotations: ToolAnnotations | None = field(default=None, kw_only=True, repr=False)
+
+    @property
+    def mcp_annotations(self) -> ToolAnnotations | None:
+        """Return a copy of the MCP annotations captured when this tool was converted.
+
+        Returns None for non-MCP tools and MCP tools without annotations. The value uses
+        the installed MCP SDK's ToolAnnotations type and attribute names. Omitted hints
+        remain omitted; callers must apply MCP defaults when interpreting them.
+
+        These are server-provided hints, not proof of side effects, successful execution,
+        or safe retries. Trust decisions belong to the application. This runtime metadata
+        is not included in tool origin serialization.
+        """
+        return copy.deepcopy(self._mcp_annotations)
+
     @property
     def qualified_name(self) -> str:
         """Return the public qualified name used to identify this function tool."""
 
@@ -3059,6 +3059,38 @@ def test_to_function_tool_preserves_mcp_title_metadata():
     assert function_tool._mcp_title == "Search Docs"
 
 
+def test_mcp_annotations_are_isolated_discovery_metadata():
+    server = FakeMCPServer()
+    tool = MCPTool(name="search", inputSchema={}, annotations={"readOnlyHint": True})
+    function_tool = MCPUtil.to_function_tool(tool, server, convert_schemas_to_strict=False)
+    annotations = function_tool.mcp_annotations
+    assert annotations is not None
+    assert annotations.model_dump(by_alias=True, exclude_none=True) == {"readOnlyHint": True}
+    assert annotations is not tool.annotations
+
+    # Consumers and later discovery updates cannot rewrite the converted tool's snapshot.
+    annotations.title = "consumer edit"
+    assert tool.annotations is not None
+    tool.annotations.title = "server edit"
+    snapshot = function_tool.mcp_annotations
+    assert snapshot is not None
+    assert snapshot.model_dump(by_alias=True, exclude_none=True) == {"readOnlyHint": True}
+    assert function_tool.needs_approval is False
+    assert function_tool._tool_origin is not None
+    assert function_tool._tool_origin.to_json_dict() == {
+        "type": "mcp",
+        "mcp_server_name": server.name,
+    }
+
+
+def test_non_mcp_function_tool_has_no_mcp_annotations():
+    async def invoke(context, arguments):
+        return "done"
+
+    tool = FunctionTool("ordinary", "", {}, invoke)
+    assert tool.mcp_annotations is None
+
+
 def test_to_function_tool_description_falls_back_to_mcp_title():
     server = FakeMCPServer()
     tool = MCPTool(
 
@@ -9,7 +9,9 @@
     FunctionTool,
     ModelBehaviorError,
     RunContextWrapper,
+    RunHooks,
     Runner,
+    Tool,
     ToolGuardrailFunctionOutput,
     ToolInputGuardrailData,
     ToolOutputGuardrailData,
@@ -23,6 +25,7 @@
 
 from ..test_responses import get_function_tool_call, get_text_message
 from .helpers import FakeMCPServer
+from .model_compat import Tool as MCPTool
 
 
 def _model_tool_outputs(model: ScriptedModel) -> list[Any]:
@@ -36,6 +39,68 @@ def _model_tool_outputs(model: ScriptedModel) -> list[Any]:
     return values
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("streaming", [False, True])
+async def test_runner_hooks_can_read_mcp_annotations(streaming: bool):
+    hints = {
+        "readOnlyHint": False,
+        "destructiveHint": True,
+        "idempotentHint": False,
+        "openWorldHint": False,
+    }
+    server = FakeMCPServer(
+        tools=[
+            MCPTool(name="write_record", inputSchema={}, annotations=hints),
+            MCPTool(name="unclassified", inputSchema={}),
+        ]
+    )
+    observed: list[tuple[str, str, dict[str, Any] | None]] = []
+
+    class Hooks(RunHooks):
+        def record(self, event: str, tool: Tool) -> None:
+            assert isinstance(tool, FunctionTool)
+            annotations = tool.mcp_annotations
+            observed.append(
+                (
+                    event,
+                    tool.name,
+                    annotations.model_dump(by_alias=True, exclude_none=True)
+                    if annotations is not None
+                    else None,
+                )
+            )
+
+        async def on_tool_start(self, context, agent, tool):
+            self.record("start", tool)
+
+        async def on_tool_end(self, context, agent, tool, result):
+            self.record("end", tool)
+
+    model = ScriptedModel(
+        [
+            [get_function_tool_call("write_record", "{}")],
+            [get_function_tool_call("unclassified", "{}", call_id="unclassified_call")],
+            [get_text_message("done")],
+        ]
+    )
+    agent = Agent(name="test", model=model, mcp_servers=[server])
+    if streaming:
+        result = Runner.run_streamed(agent, input="user_message", hooks=Hooks())
+        async for _ in result.stream_events():
+            pass
+    else:
+        result = await Runner.run(agent, input="user_message", hooks=Hooks())
+
+    assert result.final_output == "done"
+    assert server.tool_calls == ["write_record", "unclassified"]
+    assert observed == [
+        ("start", "write_record", hints),
+        ("end", "write_record", hints),
+        ("start", "unclassified", None),
+        ("end", "unclassified", None),
+    ]
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize("streaming", [False, True])
 async def test_runner_calls_mcp_tool(streaming: bool):
Original file line number	Diff line number	Diff line change
`@@ -601,6 +601,7 @@ def to_function_tool(`
`601`	`601`	`mcp_server_name=get_mcp_server_log_name(server.name),`
`602`	`602`	`),`
`603`	`603`	`)`
	`604`	`+ function_tool._mcp_annotations = copy.deepcopy(tool.annotations)`
`604`	`605`	`function_tool._mcp_tool_binding = (get_mcp_server_log_name(server.name), tool.name, None)`
`605`	`606`	`return function_tool`
`606`	`607`