pydantic-ai-slim 1.2.1__py3-none-any.whl → 1.10.0__py3-none-any.whl

pydantic_ai/result.py

@@ -1,6 +1,6 @@
 from __future__ import annotations as _annotations
 
-from collections.abc import AsyncIterator, Awaitable, Callable, Iterable
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterable, Iterator
 from copy import deepcopy
 from dataclasses import dataclass, field
 from datetime import datetime
@@ -35,6 +35,7 @@ __all__ = (
     'OutputDataT_inv',
     'ToolOutput',
     'OutputValidatorFunc',
+    'StreamedRunResultSync',
 )
 
 
@@ -60,14 +61,26 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
 
     async def stream_output(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[OutputDataT]:
         """Asynchronously stream the (validated) agent outputs."""
+        last_response: _messages.ModelResponse | None = None
         async for response in self.stream_responses(debounce_by=debounce_by):
-            if self._raw_stream_response.final_result_event is not None:
-                try:
-                    yield await self.validate_response_output(response, allow_partial=True)
-                except ValidationError:
-                    pass
-        if self._raw_stream_response.final_result_event is not None:  # pragma: no branch
-            yield await self.validate_response_output(self.response)
+            if self._raw_stream_response.final_result_event is None or (
+                last_response and response.parts == last_response.parts
+            ):
+                continue
+            last_response = response
+
+            try:
+                yield await self.validate_response_output(response, allow_partial=True)
+            except ValidationError:
+                pass
+
+        response = self.response
+        if self._raw_stream_response.final_result_event is None or (
+            last_response and response.parts == last_response.parts
+        ):
+            return
+
+        yield await self.validate_response_output(response)
 
     async def stream_responses(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[_messages.ModelResponse]:
         """Asynchronously stream the (unvalidated) model responses for the agent."""
@@ -543,6 +556,158 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
             await self._on_complete()
 
 
+@dataclass(init=False)
+class StreamedRunResultSync(Generic[AgentDepsT, OutputDataT]):
+    """Synchronous wrapper for [`StreamedRunResult`][pydantic_ai.result.StreamedRunResult] that only exposes sync methods."""
+
+    _streamed_run_result: StreamedRunResult[AgentDepsT, OutputDataT]
+
+    def __init__(self, streamed_run_result: StreamedRunResult[AgentDepsT, OutputDataT]) -> None:
+        self._streamed_run_result = streamed_run_result
+
+    def all_messages(self, *, output_tool_return_content: str | None = None) -> list[_messages.ModelMessage]:
+        """Return the history of messages.
+
+        Args:
+            output_tool_return_content: The return content of the tool call to set in the last message.
+                This provides a convenient way to modify the content of the output tool call if you want to continue
+                the conversation and want to set the response to the output tool call. If `None`, the last message will
+                not be modified.
+
+        Returns:
+            List of messages.
+        """
+        return self._streamed_run_result.all_messages(output_tool_return_content=output_tool_return_content)
+
+    def all_messages_json(self, *, output_tool_return_content: str | None = None) -> bytes:  # pragma: no cover
+        """Return all messages from [`all_messages`][pydantic_ai.result.StreamedRunResultSync.all_messages] as JSON bytes.
+
+        Args:
+            output_tool_return_content: The return content of the tool call to set in the last message.
+                This provides a convenient way to modify the content of the output tool call if you want to continue
+                the conversation and want to set the response to the output tool call. If `None`, the last message will
+                not be modified.
+
+        Returns:
+            JSON bytes representing the messages.
+        """
+        return self._streamed_run_result.all_messages_json(output_tool_return_content=output_tool_return_content)
+
+    def new_messages(self, *, output_tool_return_content: str | None = None) -> list[_messages.ModelMessage]:
+        """Return new messages associated with this run.
+
+        Messages from older runs are excluded.
+
+        Args:
+            output_tool_return_content: The return content of the tool call to set in the last message.
+                This provides a convenient way to modify the content of the output tool call if you want to continue
+                the conversation and want to set the response to the output tool call. If `None`, the last message will
+                not be modified.
+
+        Returns:
+            List of new messages.
+        """
+        return self._streamed_run_result.new_messages(output_tool_return_content=output_tool_return_content)
+
+    def new_messages_json(self, *, output_tool_return_content: str | None = None) -> bytes:  # pragma: no cover
+        """Return new messages from [`new_messages`][pydantic_ai.result.StreamedRunResultSync.new_messages] as JSON bytes.
+
+        Args:
+            output_tool_return_content: The return content of the tool call to set in the last message.
+                This provides a convenient way to modify the content of the output tool call if you want to continue
+                the conversation and want to set the response to the output tool call. If `None`, the last message will
+                not be modified.
+
+        Returns:
+            JSON bytes representing the new messages.
+        """
+        return self._streamed_run_result.new_messages_json(output_tool_return_content=output_tool_return_content)
+
+    def stream_output(self, *, debounce_by: float | None = 0.1) -> Iterator[OutputDataT]:
+        """Stream the output as an iterable.
+
+        The pydantic validator for structured data will be called in
+        [partial mode](https://docs.pydantic.dev/dev/concepts/experimental/#partial-validation)
+        on each iteration.
+
+        Args:
+            debounce_by: by how much (if at all) to debounce/group the output chunks by. `None` means no debouncing.
+                Debouncing is particularly important for long structured outputs to reduce the overhead of
+                performing validation as each token is received.
+
+        Returns:
+            An iterable of the response data.
+        """
+        return _utils.sync_async_iterator(self._streamed_run_result.stream_output(debounce_by=debounce_by))
+
+    def stream_text(self, *, delta: bool = False, debounce_by: float | None = 0.1) -> Iterator[str]:
+        """Stream the text result as an iterable.
+
+        !!! note
+            Result validators will NOT be called on the text result if `delta=True`.
+
+        Args:
+            delta: if `True`, yield each chunk of text as it is received, if `False` (default), yield the full text
+                up to the current point.
+            debounce_by: by how much (if at all) to debounce/group the response chunks by. `None` means no debouncing.
+                Debouncing is particularly important for long structured responses to reduce the overhead of
+                performing validation as each token is received.
+        """
+        return _utils.sync_async_iterator(self._streamed_run_result.stream_text(delta=delta, debounce_by=debounce_by))
+
+    def stream_responses(self, *, debounce_by: float | None = 0.1) -> Iterator[tuple[_messages.ModelResponse, bool]]:
+        """Stream the response as an iterable of Structured LLM Messages.
+
+        Args:
+            debounce_by: by how much (if at all) to debounce/group the response chunks by. `None` means no debouncing.
+                Debouncing is particularly important for long structured responses to reduce the overhead of
+                performing validation as each token is received.
+
+        Returns:
+            An iterable of the structured response message and whether that is the last message.
+        """
+        return _utils.sync_async_iterator(self._streamed_run_result.stream_responses(debounce_by=debounce_by))
+
+    def get_output(self) -> OutputDataT:
+        """Stream the whole response, validate and return it."""
+        return _utils.get_event_loop().run_until_complete(self._streamed_run_result.get_output())
+
+    @property
+    def response(self) -> _messages.ModelResponse:
+        """Return the current state of the response."""
+        return self._streamed_run_result.response
+
+    def usage(self) -> RunUsage:
+        """Return the usage of the whole run.
+
+        !!! note
+            This won't return the full usage until the stream is finished.
+        """
+        return self._streamed_run_result.usage()
+
+    def timestamp(self) -> datetime:
+        """Get the timestamp of the response."""
+        return self._streamed_run_result.timestamp()
+
+    def validate_response_output(self, message: _messages.ModelResponse, *, allow_partial: bool = False) -> OutputDataT:
+        """Validate a structured result message."""
+        return _utils.get_event_loop().run_until_complete(
+            self._streamed_run_result.validate_response_output(message, allow_partial=allow_partial)
+        )
+
+    @property
+    def is_complete(self) -> bool:
+        """Whether the stream has all been received.
+
+        This is set to `True` when one of
+        [`stream_output`][pydantic_ai.result.StreamedRunResultSync.stream_output],
+        [`stream_text`][pydantic_ai.result.StreamedRunResultSync.stream_text],
+        [`stream_responses`][pydantic_ai.result.StreamedRunResultSync.stream_responses] or
+        [`get_output`][pydantic_ai.result.StreamedRunResultSync.get_output] completes.
+        """
+        return self._streamed_run_result.is_complete
+
+
 @dataclass(repr=False)
 class FinalResult(Generic[OutputDataT]):
     """Marker class storing the final output of an agent run and associated metadata."""

pydantic_ai/run.py

@@ -1,12 +1,14 @@
 from __future__ import annotations as _annotations
 
 import dataclasses
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Sequence
 from copy import deepcopy
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Generic, Literal, overload
 
-from pydantic_graph import End, GraphRun, GraphRunContext
+from pydantic_graph import BaseNode, End, GraphRunContext
+from pydantic_graph.beta.graph import EndMarker, GraphRun, GraphTask, JoinItem
+from pydantic_graph.beta.step import NodeStep
 
 from . import (
     _agent_graph,
@@ -112,12 +114,8 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
 
         This is the next node that will be used during async iteration, or if a node is not passed to `self.next(...)`.
         """
-        next_node = self._graph_run.next_node
-        if isinstance(next_node, End):
-            return next_node
-        if _agent_graph.is_agent_node(next_node):
-            return next_node
-        raise exceptions.AgentRunError(f'Unexpected node type: {type(next_node)}')  # pragma: no cover
+        task = self._graph_run.next_task
+        return self._task_to_node(task)
 
     @property
     def result(self) -> AgentRunResult[OutputDataT] | None:
@@ -126,13 +124,13 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
         Once the run returns an [`End`][pydantic_graph.nodes.End] node, `result` is populated
         with an [`AgentRunResult`][pydantic_ai.agent.AgentRunResult].
         """
-        graph_run_result = self._graph_run.result
-        if graph_run_result is None:
+        graph_run_output = self._graph_run.output
+        if graph_run_output is None:
             return None
         return AgentRunResult(
-            graph_run_result.output.output,
-            graph_run_result.output.tool_name,
-            graph_run_result.state,
+            graph_run_output.output,
+            graph_run_output.tool_name,
+            self._graph_run.state,
             self._graph_run.deps.new_message_index,
             self._traceparent(required=False),
         )
@@ -147,11 +145,28 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
         self,
     ) -> _agent_graph.AgentNode[AgentDepsT, OutputDataT] | End[FinalResult[OutputDataT]]:
         """Advance to the next node automatically based on the last returned node."""
-        next_node = await self._graph_run.__anext__()
-        if _agent_graph.is_agent_node(node=next_node):
-            return next_node
-        assert isinstance(next_node, End), f'Unexpected node type: {type(next_node)}'
-        return next_node
+        task = await anext(self._graph_run)
+        return self._task_to_node(task)
+
+    def _task_to_node(
+        self, task: EndMarker[FinalResult[OutputDataT]] | JoinItem | Sequence[GraphTask]
+    ) -> _agent_graph.AgentNode[AgentDepsT, OutputDataT] | End[FinalResult[OutputDataT]]:
+        if isinstance(task, Sequence) and len(task) == 1:
+            first_task = task[0]
+            if isinstance(first_task.inputs, BaseNode):  # pragma: no branch
+                base_node: BaseNode[
+                    _agent_graph.GraphAgentState,
+                    _agent_graph.GraphAgentDeps[AgentDepsT, OutputDataT],
+                    FinalResult[OutputDataT],
+                ] = first_task.inputs  # type: ignore[reportUnknownMemberType]
+                if _agent_graph.is_agent_node(node=base_node):  # pragma: no branch
+                    return base_node
+        if isinstance(task, EndMarker):
+            return End(task.value)
+        raise exceptions.AgentRunError(f'Unexpected node: {task}')  # pragma: no cover
+
+    def _node_to_task(self, node: _agent_graph.AgentNode[AgentDepsT, OutputDataT]) -> GraphTask:
+        return GraphTask(NodeStep(type(node)).id, inputs=node, fork_stack=())
 
     async def next(
         self,
@@ -222,11 +237,12 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
         """
         # Note: It might be nice to expose a synchronous interface for iteration, but we shouldn't do it
         # on this class, or else IDEs won't warn you if you accidentally use `for` instead of `async for` to iterate.
-        next_node = await self._graph_run.next(node)
-        if _agent_graph.is_agent_node(next_node):
-            return next_node
-        assert isinstance(next_node, End), f'Unexpected node type: {type(next_node)}'
-        return next_node
+        task = [self._node_to_task(node)]
+        try:
+            task = await self._graph_run.next(task)
+        except StopAsyncIteration:
+            pass
+        return self._task_to_node(task)
 
     # TODO (v2): Make this a property
     def usage(self) -> _usage.RunUsage:
@@ -234,7 +250,7 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
         return self._graph_run.state.usage
 
     def __repr__(self) -> str:  # pragma: no cover
-        result = self._graph_run.result
+        result = self._graph_run.output
         result_repr = '<run not finished>' if result is None else repr(result.output)
         return f'<{type(self).__name__} result={result_repr} usage={self.usage()}>'
 

pydantic_ai/settings.py

@@ -24,6 +24,7 @@ class ModelSettings(TypedDict, total=False):
     * Mistral
     * Bedrock
     * MCP Sampling
+    * Outlines (all providers)
     """
 
     temperature: float
@@ -43,6 +44,7 @@ class ModelSettings(TypedDict, total=False):
     * Cohere
     * Mistral
     * Bedrock
+    * Outlines (Transformers, LlamaCpp, SgLang, VLLMOffline)
     """
 
     top_p: float
@@ -61,6 +63,7 @@ class ModelSettings(TypedDict, total=False):
     * Cohere
     * Mistral
     * Bedrock
+    * Outlines (Transformers, LlamaCpp, SgLang, VLLMOffline)
     """
 
     timeout: float | Timeout
@@ -95,6 +98,7 @@ class ModelSettings(TypedDict, total=False):
     * Cohere
     * Mistral
     * Gemini
+    * Outlines (LlamaCpp, VLLMOffline)
     """
 
     presence_penalty: float
@@ -107,6 +111,7 @@ class ModelSettings(TypedDict, total=False):
     * Cohere
     * Gemini
     * Mistral
+    * Outlines (LlamaCpp, SgLang, VLLMOffline)
     """
 
     frequency_penalty: float
@@ -119,6 +124,7 @@ class ModelSettings(TypedDict, total=False):
     * Cohere
     * Gemini
     * Mistral
+    * Outlines (LlamaCpp, SgLang, VLLMOffline)
     """
 
     logit_bias: dict[str, int]
@@ -128,6 +134,7 @@ class ModelSettings(TypedDict, total=False):
 
     * OpenAI
     * Groq
+    * Outlines (Transformers, LlamaCpp, VLLMOffline)
     """
 
     stop_sequences: list[str]
@@ -162,6 +169,7 @@ class ModelSettings(TypedDict, total=False):
     * OpenAI
     * Anthropic
     * Groq
+    * Outlines (all providers)
     """
 
 

pydantic_ai/tools.py

@@ -240,16 +240,20 @@ class GenerateToolJsonSchema(GenerateJsonSchema):
         return s
 
 
+ToolAgentDepsT = TypeVar('ToolAgentDepsT', default=object, contravariant=True)
+"""Type variable for agent dependencies for a tool."""
+
+
 @dataclass(init=False)
-class Tool(Generic[AgentDepsT]):
+class Tool(Generic[ToolAgentDepsT]):
     """A tool function for an agent."""
 
-    function: ToolFuncEither[AgentDepsT]
+    function: ToolFuncEither[ToolAgentDepsT]
     takes_ctx: bool
     max_retries: int | None
     name: str
     description: str | None
-    prepare: ToolPrepareFunc[AgentDepsT] | None
+    prepare: ToolPrepareFunc[ToolAgentDepsT] | None
     docstring_format: DocstringFormat
     require_parameter_descriptions: bool
     strict: bool | None
@@ -265,13 +269,13 @@ class Tool(Generic[AgentDepsT]):
 
     def __init__(
         self,
-        function: ToolFuncEither[AgentDepsT],
+        function: ToolFuncEither[ToolAgentDepsT],
         *,
         takes_ctx: bool | None = None,
         max_retries: int | None = None,
         name: str | None = None,
         description: str | None = None,
-        prepare: ToolPrepareFunc[AgentDepsT] | None = None,
+        prepare: ToolPrepareFunc[ToolAgentDepsT] | None = None,
         docstring_format: DocstringFormat = 'auto',
         require_parameter_descriptions: bool = False,
         schema_generator: type[GenerateJsonSchema] = GenerateToolJsonSchema,
@@ -413,7 +417,7 @@ class Tool(Generic[AgentDepsT]):
             metadata=self.metadata,
         )
 
-    async def prepare_tool_def(self, ctx: RunContext[AgentDepsT]) -> ToolDefinition | None:
+    async def prepare_tool_def(self, ctx: RunContext[ToolAgentDepsT]) -> ToolDefinition | None:
         """Get the tool definition.
 
         By default, this method creates a tool definition, then either returns it, or calls `self.prepare`

pydantic_ai/toolsets/fastmcp.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+import base64
+from asyncio import Lock
+from contextlib import AsyncExitStack
+from dataclasses import KW_ONLY, dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+from pydantic import AnyUrl
+from typing_extensions import Self, assert_never
+
+from pydantic_ai import messages
+from pydantic_ai.exceptions import ModelRetry
+from pydantic_ai.tools import AgentDepsT, RunContext, ToolDefinition
+from pydantic_ai.toolsets import AbstractToolset
+from pydantic_ai.toolsets.abstract import ToolsetTool
+
+try:
+    from fastmcp.client import Client
+    from fastmcp.client.transports import ClientTransport
+    from fastmcp.exceptions import ToolError
+    from fastmcp.mcp_config import MCPConfig
+    from fastmcp.server import FastMCP
+    from mcp.server.fastmcp import FastMCP as FastMCP1Server
+    from mcp.types import (
+        AudioContent,
+        BlobResourceContents,
+        ContentBlock,
+        EmbeddedResource,
+        ImageContent,
+        ResourceLink,
+        TextContent,
+        TextResourceContents,
+        Tool as MCPTool,
+    )
+
+    from pydantic_ai.mcp import TOOL_SCHEMA_VALIDATOR
+
+except ImportError as _import_error:
+    raise ImportError(
+        'Please install the `fastmcp` package to use the FastMCP server, '
+        'you can use the `fastmcp` optional group — `pip install "pydantic-ai-slim[fastmcp]"`'
+    ) from _import_error
+
+
+if TYPE_CHECKING:
+    from fastmcp.client.client import CallToolResult
+
+
+FastMCPToolResult = messages.BinaryContent | dict[str, Any] | str | None
+
+ToolErrorBehavior = Literal['model_retry', 'error']
+
+UNKNOWN_BINARY_MEDIA_TYPE = 'application/octet-stream'
+
+
+@dataclass(init=False)
+class FastMCPToolset(AbstractToolset[AgentDepsT]):
+    """A FastMCP Toolset that uses the FastMCP Client to call tools from a local or remote MCP Server.
+
+    The Toolset can accept a FastMCP Client, a FastMCP Transport, or any other object which a FastMCP Transport can be created from.
+
+    See https://gofastmcp.com/clients/transports for a full list of transports available.
+    """
+
+    client: Client[Any]
+    """The FastMCP client to use."""
+
+    _: KW_ONLY
+
+    tool_error_behavior: Literal['model_retry', 'error']
+    """The behavior to take when a tool error occurs."""
+
+    max_retries: int
+    """The maximum number of retries to attempt if a tool call fails."""
+
+    _id: str | None
+
+    def __init__(
+        self,
+        client: Client[Any]
+        | ClientTransport
+        | FastMCP
+        | FastMCP1Server
+        | AnyUrl
+        | Path
+        | MCPConfig
+        | dict[str, Any]
+        | str,
+        *,
+        max_retries: int = 1,
+        tool_error_behavior: Literal['model_retry', 'error'] = 'model_retry',
+        id: str | None = None,
+    ) -> None:
+        if isinstance(client, Client):
+            self.client = client
+        else:
+            self.client = Client[Any](transport=client)
+
+        self._id = id
+        self.max_retries = max_retries
+        self.tool_error_behavior = tool_error_behavior
+
+        self._enter_lock: Lock = Lock()
+        self._running_count: int = 0
+        self._exit_stack: AsyncExitStack | None = None
+
+    @property
+    def id(self) -> str | None:
+        return self._id
+
+    async def __aenter__(self) -> Self:
+        async with self._enter_lock:
+            if self._running_count == 0:
+                self._exit_stack = AsyncExitStack()
+                await self._exit_stack.enter_async_context(self.client)
+
+            self._running_count += 1
+
+        return self
+
+    async def __aexit__(self, *args: Any) -> bool | None:
+        async with self._enter_lock:
+            self._running_count -= 1
+            if self._running_count == 0 and self._exit_stack:
+                await self._exit_stack.aclose()
+                self._exit_stack = None
+
+        return None
+
+    async def get_tools(self, ctx: RunContext[AgentDepsT]) -> dict[str, ToolsetTool[AgentDepsT]]:
+        async with self:
+            mcp_tools: list[MCPTool] = await self.client.list_tools()
+
+            return {
+                tool.name: _convert_mcp_tool_to_toolset_tool(toolset=self, mcp_tool=tool, retries=self.max_retries)
+                for tool in mcp_tools
+            }
+
+    async def call_tool(
+        self, name: str, tool_args: dict[str, Any], ctx: RunContext[AgentDepsT], tool: ToolsetTool[AgentDepsT]
+    ) -> Any:
+        async with self:
+            try:
+                call_tool_result: CallToolResult = await self.client.call_tool(name=name, arguments=tool_args)
+            except ToolError as e:
+                if self.tool_error_behavior == 'model_retry':
+                    raise ModelRetry(message=str(e)) from e
+                else:
+                    raise e
+
+        # If we have structured content, return that
+        if call_tool_result.structured_content:
+            return call_tool_result.structured_content
+
+        # Otherwise, return the content
+        return _map_fastmcp_tool_results(parts=call_tool_result.content)
+
+
+def _convert_mcp_tool_to_toolset_tool(
+    toolset: FastMCPToolset[AgentDepsT],
+    mcp_tool: MCPTool,
+    retries: int,
+) -> ToolsetTool[AgentDepsT]:
+    """Convert an MCP tool to a toolset tool."""
+    return ToolsetTool[AgentDepsT](
+        tool_def=ToolDefinition(
+            name=mcp_tool.name,
+            description=mcp_tool.description,
+            parameters_json_schema=mcp_tool.inputSchema,
+            metadata={
+                'meta': mcp_tool.meta,
+                'annotations': mcp_tool.annotations.model_dump() if mcp_tool.annotations else None,
+                'output_schema': mcp_tool.outputSchema or None,
+            },
+        ),
+        toolset=toolset,
+        max_retries=retries,
+        args_validator=TOOL_SCHEMA_VALIDATOR,
+    )
+
+
+def _map_fastmcp_tool_results(parts: list[ContentBlock]) -> list[FastMCPToolResult] | FastMCPToolResult:
+    """Map FastMCP tool results to toolset tool results."""
+    mapped_results = [_map_fastmcp_tool_result(part) for part in parts]
+
+    if len(mapped_results) == 1:
+        return mapped_results[0]
+
+    return mapped_results
+
+
+def _map_fastmcp_tool_result(part: ContentBlock) -> FastMCPToolResult:
+    if isinstance(part, TextContent):
+        return part.text
+    elif isinstance(part, ImageContent | AudioContent):
+        return messages.BinaryContent(data=base64.b64decode(part.data), media_type=part.mimeType)
+    elif isinstance(part, EmbeddedResource):
+        if isinstance(part.resource, BlobResourceContents):
+            return messages.BinaryContent(
+                data=base64.b64decode(part.resource.blob),
+                media_type=part.resource.mimeType or UNKNOWN_BINARY_MEDIA_TYPE,
+            )
+        elif isinstance(part.resource, TextResourceContents):
+            return part.resource.text
+        else:
+            assert_never(part.resource)
+    elif isinstance(part, ResourceLink):
+        # ResourceLink is not yet supported by the FastMCP toolset as reading resources is not yet supported.
+        raise NotImplementedError(
+            'ResourceLink is not supported by the FastMCP toolset as reading resources is not yet supported.'
+        )
+    else:
+        assert_never(part)

pydantic_ai/ui/__init__.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from ._adapter import StateDeps, StateHandler, UIAdapter
+from ._event_stream import SSE_CONTENT_TYPE, NativeEvent, OnCompleteFunc, UIEventStream
+from ._messages_builder import MessagesBuilder
+
+__all__ = [
+    'UIAdapter',
+    'UIEventStream',
+    'SSE_CONTENT_TYPE',
+    'StateDeps',
+    'StateHandler',
+    'NativeEvent',
+    'OnCompleteFunc',
+    'MessagesBuilder',
+]