pydantic-ai-slim 1.0.11__tar.gz → 1.0.12__tar.gz

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 1.0.11
+Version: 1.0.12
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Project-URL: Homepage, https://github.com/pydantic/pydantic-ai/tree/main/pydantic_ai_slim
 Project-URL: Source, https://github.com/pydantic/pydantic-ai/tree/main/pydantic_ai_slim
@@ -33,7 +33,7 @@ Requires-Dist: genai-prices>=0.0.28
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==1.0.11
+Requires-Dist: pydantic-graph==1.0.12
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -57,7 +57,7 @@ Requires-Dist: dbos>=1.14.0; extra == 'dbos'
 Provides-Extra: duckduckgo
 Requires-Dist: ddgs>=9.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==1.0.11; extra == 'evals'
+Requires-Dist: pydantic-evals==1.0.12; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.31.0; extra == 'google'
 Provides-Extra: groq

pydantic_ai_slim-1.0.12/pydantic_ai/__init__.py

@@ -0,0 +1,215 @@
+from importlib.metadata import version as _metadata_version
+
+from .agent import (
+    Agent,
+    CallToolsNode,
+    EndStrategy,
+    InstrumentationSettings,
+    ModelRequestNode,
+    UserPromptNode,
+    capture_run_messages,
+)
+from .builtin_tools import CodeExecutionTool, UrlContextTool, WebSearchTool, WebSearchUserLocation
+from .exceptions import (
+    AgentRunError,
+    ApprovalRequired,
+    CallDeferred,
+    FallbackExceptionGroup,
+    ModelHTTPError,
+    ModelRetry,
+    UnexpectedModelBehavior,
+    UsageLimitExceeded,
+    UserError,
+)
+from .format_prompt import format_as_xml
+from .messages import (
+    AgentStreamEvent,
+    AudioFormat,
+    AudioMediaType,
+    AudioUrl,
+    BaseToolCallPart,
+    BaseToolReturnPart,
+    BinaryContent,
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
+    DocumentFormat,
+    DocumentMediaType,
+    DocumentUrl,
+    FileUrl,
+    FinalResultEvent,
+    FinishReason,
+    FunctionToolCallEvent,
+    FunctionToolResultEvent,
+    HandleResponseEvent,
+    ImageFormat,
+    ImageMediaType,
+    ImageUrl,
+    ModelMessage,
+    ModelMessagesTypeAdapter,
+    ModelRequest,
+    ModelRequestPart,
+    ModelResponse,
+    ModelResponsePart,
+    ModelResponsePartDelta,
+    ModelResponseStreamEvent,
+    MultiModalContent,
+    PartDeltaEvent,
+    PartStartEvent,
+    RetryPromptPart,
+    SystemPromptPart,
+    TextPart,
+    TextPartDelta,
+    ThinkingPart,
+    ThinkingPartDelta,
+    ToolCallPart,
+    ToolCallPartDelta,
+    ToolReturn,
+    ToolReturnPart,
+    UserContent,
+    UserPromptPart,
+    VideoFormat,
+    VideoMediaType,
+    VideoUrl,
+)
+from .output import NativeOutput, PromptedOutput, StructuredDict, TextOutput, ToolOutput
+from .profiles import (
+    DEFAULT_PROFILE,
+    InlineDefsJsonSchemaTransformer,
+    JsonSchemaTransformer,
+    ModelProfile,
+    ModelProfileSpec,
+)
+from .settings import ModelSettings
+from .tools import DeferredToolRequests, DeferredToolResults, RunContext, Tool, ToolApproved, ToolDefinition, ToolDenied
+from .toolsets import (
+    AbstractToolset,
+    ApprovalRequiredToolset,
+    CombinedToolset,
+    ExternalToolset,
+    FilteredToolset,
+    FunctionToolset,
+    PrefixedToolset,
+    PreparedToolset,
+    RenamedToolset,
+    ToolsetFunc,
+    ToolsetTool,
+    WrapperToolset,
+)
+from .usage import RequestUsage, RunUsage, UsageLimits
+
+__all__ = (
+    '__version__',
+    # agent
+    'Agent',
+    'EndStrategy',
+    'CallToolsNode',
+    'ModelRequestNode',
+    'UserPromptNode',
+    'capture_run_messages',
+    'InstrumentationSettings',
+    # exceptions
+    'AgentRunError',
+    'CallDeferred',
+    'ApprovalRequired',
+    'ModelRetry',
+    'ModelHTTPError',
+    'FallbackExceptionGroup',
+    'UnexpectedModelBehavior',
+    'UsageLimitExceeded',
+    'UserError',
+    # messages
+    'AgentStreamEvent',
+    'AudioFormat',
+    'AudioMediaType',
+    'AudioUrl',
+    'BaseToolCallPart',
+    'BaseToolReturnPart',
+    'BinaryContent',
+    'BuiltinToolCallPart',
+    'BuiltinToolReturnPart',
+    'DocumentFormat',
+    'DocumentMediaType',
+    'DocumentUrl',
+    'FileUrl',
+    'FinalResultEvent',
+    'FinishReason',
+    'FunctionToolCallEvent',
+    'FunctionToolResultEvent',
+    'HandleResponseEvent',
+    'ImageFormat',
+    'ImageMediaType',
+    'ImageUrl',
+    'ModelMessage',
+    'ModelMessagesTypeAdapter',
+    'ModelRequest',
+    'ModelRequestPart',
+    'ModelResponse',
+    'ModelResponsePart',
+    'ModelResponsePartDelta',
+    'ModelResponseStreamEvent',
+    'MultiModalContent',
+    'PartDeltaEvent',
+    'PartStartEvent',
+    'RetryPromptPart',
+    'SystemPromptPart',
+    'TextPart',
+    'TextPartDelta',
+    'ThinkingPart',
+    'ThinkingPartDelta',
+    'ToolCallPart',
+    'ToolCallPartDelta',
+    'ToolReturn',
+    'ToolReturnPart',
+    'UserContent',
+    'UserPromptPart',
+    'VideoFormat',
+    'VideoMediaType',
+    'VideoUrl',
+    # profiles
+    'ModelProfile',
+    'ModelProfileSpec',
+    'DEFAULT_PROFILE',
+    'InlineDefsJsonSchemaTransformer',
+    'JsonSchemaTransformer',
+    # tools
+    'Tool',
+    'ToolDefinition',
+    'RunContext',
+    'DeferredToolRequests',
+    'DeferredToolResults',
+    'ToolApproved',
+    'ToolDenied',
+    # toolsets
+    'AbstractToolset',
+    'ApprovalRequiredToolset',
+    'CombinedToolset',
+    'ExternalToolset',
+    'FilteredToolset',
+    'FunctionToolset',
+    'PrefixedToolset',
+    'PreparedToolset',
+    'RenamedToolset',
+    'ToolsetFunc',
+    'ToolsetTool',
+    'WrapperToolset',
+    # builtin_tools
+    'WebSearchTool',
+    'WebSearchUserLocation',
+    'UrlContextTool',
+    'CodeExecutionTool',
+    # output
+    'ToolOutput',
+    'NativeOutput',
+    'PromptedOutput',
+    'TextOutput',
+    'StructuredDict',
+    # format_prompt
+    'format_as_xml',
+    # settings
+    'ModelSettings',
+    # usage
+    'RunUsage',
+    'RequestUsage',
+    'UsageLimits',
+)
+__version__ = _metadata_version('pydantic_ai_slim')

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/_a2a.py

@@ -10,7 +10,7 @@ from typing import Any, Generic, TypeVar
 from pydantic import TypeAdapter
 from typing_extensions import assert_never
 
-from pydantic_ai.messages import (
+from pydantic_ai import (
     AudioUrl,
     BinaryContent,
     DocumentUrl,

{pydantic_ai_slim-1.0.11/pydantic_ai/profiles → pydantic_ai_slim-1.0.12/pydantic_ai}/_json_schema.py

@@ -6,7 +6,7 @@ from copy import deepcopy
 from dataclasses import dataclass
 from typing import Any, Literal
 
-from pydantic_ai.exceptions import UserError
+from .exceptions import UserError
 
 JsonSchema = dict[str, Any]
 
@@ -54,14 +54,14 @@ class JsonSchemaTransformer(ABC):
         if not self.prefer_inlined_defs and self.defs:
             handled['$defs'] = {k: self._handle(v) for k, v in self.defs.items()}
 
-        elif self.recursive_refs:  # pragma: no cover
+        elif self.recursive_refs:
             # If we are preferring inlined defs and there are recursive refs, we _have_ to use a $defs+$ref structure
             # We try to use whatever the original root key was, but if it is already in use,
             # we modify it to avoid collisions.
             defs = {key: self.defs[key] for key in self.recursive_refs}
             root_ref = self.schema.get('$ref')
             root_key = None if root_ref is None else re.sub(r'^#/\$defs/', '', root_ref)
-            if root_key is None:
+            if root_key is None:  # pragma: no cover
                 root_key = self.schema.get('title', 'root')
                 while root_key in defs:
                     # Modify the root key until it is not already in use
@@ -77,6 +77,8 @@ class JsonSchemaTransformer(ABC):
         if self.prefer_inlined_defs:
             while ref := schema.get('$ref'):
                 key = re.sub(r'^#/\$defs/', '', ref)
+                if key in self.recursive_refs:
+                    break
                 if key in self.refs_stack:
                     self.recursive_refs.add(key)
                     break  # recursive ref can't be unpacked

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/_thinking_part.py

@@ -1,6 +1,6 @@
 from __future__ import annotations as _annotations
 
-from pydantic_ai.messages import TextPart, ThinkingPart
+from pydantic_ai import TextPart, ThinkingPart
 
 
 def split_content_into_text_and_thinking(content: str, thinking_tags: tuple[str, str]) -> list[ThinkingPart | TextPart]:

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/_utils.py

@@ -6,7 +6,7 @@ import inspect
 import re
 import time
 import uuid
-from collections.abc import AsyncIterable, AsyncIterator, Awaitable, Callable, Iterator
+from collections.abc import AsyncIterable, AsyncIterator, Awaitable, Callable, Iterable, Iterator
 from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass, fields, is_dataclass
 from datetime import datetime, timezone
@@ -70,16 +70,33 @@ def check_object_json_schema(schema: JsonSchemaValue) -> ObjectJsonSchema:
 
     if schema.get('type') == 'object':
         return schema
-    elif schema.get('$ref') is not None:
-        maybe_result = schema.get('$defs', {}).get(schema['$ref'][8:])  # This removes the initial "#/$defs/".
-
-        if "'$ref': '#/$defs/" in str(maybe_result):
-            return schema  # We can't remove the $defs because the schema contains other references
-        return maybe_result
+    elif ref := schema.get('$ref'):
+        prefix = '#/$defs/'
+        # Return the referenced schema unless it contains additional nested references.
+        if (
+            ref.startswith(prefix)
+            and (resolved := schema.get('$defs', {}).get(ref[len(prefix) :]))
+            and resolved.get('type') == 'object'
+            and not _contains_ref(resolved)
+        ):
+            return resolved
+        return schema
     else:
         raise UserError('Schema must be an object')
 
 
+def _contains_ref(obj: JsonSchemaValue | list[JsonSchemaValue]) -> bool:
+    """Recursively check if an object contains any $ref keys."""
+    items: Iterable[JsonSchemaValue]
+    if isinstance(obj, dict):
+        if '$ref' in obj:
+            return True
+        items = obj.values()
+    else:
+        items = obj
+    return any(isinstance(item, dict | list) and _contains_ref(item) for item in items)  # pyright: ignore[reportUnknownArgumentType]
+
+
 T = TypeVar('T')
 
 

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/agent/__init__.py

@@ -1206,8 +1206,7 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
 
         Example:
         ```python
-        from pydantic_ai import Agent, RunContext
-        from pydantic_ai.toolsets import AbstractToolset, FunctionToolset
+        from pydantic_ai import AbstractToolset, Agent, FunctionToolset, RunContext
 
         agent = Agent('test', deps_type=str)
 

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/builtin_tools.py

@@ -6,7 +6,14 @@ from typing import Literal
 
 from typing_extensions import TypedDict
 
-__all__ = ('AbstractBuiltinTool', 'WebSearchTool', 'WebSearchUserLocation', 'CodeExecutionTool', 'UrlContextTool')
+__all__ = (
+    'AbstractBuiltinTool',
+    'WebSearchTool',
+    'WebSearchUserLocation',
+    'CodeExecutionTool',
+    'UrlContextTool',
+    'MemoryTool',
+)
 
 
 @dataclass(kw_only=True)
@@ -133,3 +140,15 @@ class UrlContextTool(AbstractBuiltinTool):
 
     kind: str = 'url_context'
     """The kind of tool."""
+
+
+class MemoryTool(AbstractBuiltinTool):
+    """A builtin tool that allows your agent to use memory.
+
+    Supported by:
+
+    * Anthropic
+    """
+
+    kind: str = 'memory'
+    """The kind of tool."""

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/common_tools/duckduckgo.py

@@ -4,7 +4,7 @@ from dataclasses import KW_ONLY, dataclass
 import anyio
 import anyio.to_thread
 from pydantic import TypeAdapter
-from typing_extensions import TypedDict
+from typing_extensions import Any, TypedDict
 
 from pydantic_ai.tools import Tool
 
@@ -69,7 +69,7 @@ def duckduckgo_search_tool(duckduckgo_client: DDGS | None = None, max_results: i
         duckduckgo_client: The DuckDuckGo search client.
         max_results: The maximum number of results. If None, returns results only from the first response.
     """
-    return Tool(
+    return Tool[Any](
         DuckDuckGoSearchTool(client=duckduckgo_client or DDGS(), max_results=max_results).__call__,
         name='duckduckgo_search',
         description='Searches DuckDuckGo for the given query and returns the results.',

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/common_tools/tavily.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 from typing import Literal
 
 from pydantic import TypeAdapter
-from typing_extensions import TypedDict
+from typing_extensions import Any, TypedDict
 
 from pydantic_ai.tools import Tool
 
@@ -74,7 +74,7 @@ def tavily_search_tool(api_key: str):
 
             You can get one by signing up at [https://app.tavily.com/home](https://app.tavily.com/home).
     """
-    return Tool(
+    return Tool[Any](
         TavilySearchTool(client=AsyncTavilyClient(api_key)).__call__,
         name='tavily_search',
         description='Searches Tavily for the given query and returns the results.',

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/direct.py

@@ -44,8 +44,8 @@ async def model_request(
     """Make a non-streamed request to a model.
 
     ```py title="model_request_example.py"
+    from pydantic_ai import ModelRequest
     from pydantic_ai.direct import model_request
-    from pydantic_ai.messages import ModelRequest
 
 
     async def main():
@@ -99,8 +99,8 @@ def model_request_sync(
     `loop.run_until_complete(...)`. You therefore can't use this method inside async code or if there's an active event loop.
 
     ```py title="model_request_sync_example.py"
+    from pydantic_ai import ModelRequest
     from pydantic_ai.direct import model_request_sync
-    from pydantic_ai.messages import ModelRequest
 
     model_response = model_request_sync(
         'anthropic:claude-3-5-haiku-latest',
@@ -153,8 +153,8 @@ def model_request_stream(
 
     ```py {title="model_request_stream_example.py"}
 
+    from pydantic_ai import ModelRequest
     from pydantic_ai.direct import model_request_stream
-    from pydantic_ai.messages import ModelRequest
 
 
     async def main():
@@ -212,8 +212,8 @@ def model_request_stream_sync(
 
     ```py {title="model_request_stream_sync_example.py"}
 
+    from pydantic_ai import ModelRequest
     from pydantic_ai.direct import model_request_stream_sync
-    from pydantic_ai.messages import ModelRequest
 
     messages = [ModelRequest.user_text_prompt('Who was Albert Einstein?')]
     with model_request_stream_sync('openai:gpt-4.1-mini', messages) as stream:

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/durable_exec/dbos/_agent.py

@@ -8,6 +8,7 @@ from dbos import DBOS, DBOSConfiguredInstance
 from typing_extensions import Never
 
 from pydantic_ai import (
+    AbstractToolset,
     _utils,
     messages as _messages,
     models,
@@ -26,7 +27,6 @@ from pydantic_ai.tools import (
     Tool,
     ToolFuncEither,
 )
-from pydantic_ai.toolsets import AbstractToolset
 
 from ._model import DBOSModel
 from ._utils import StepConfig

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/durable_exec/dbos/_mcp_server.py

@@ -7,9 +7,8 @@ from typing import TYPE_CHECKING, Any
 from dbos import DBOS
 from typing_extensions import Self
 
+from pydantic_ai import AbstractToolset, ToolsetTool, WrapperToolset
 from pydantic_ai.tools import AgentDepsT, RunContext
-from pydantic_ai.toolsets.abstract import AbstractToolset, ToolsetTool
-from pydantic_ai.toolsets.wrapper import WrapperToolset
 
 from ._utils import StepConfig
 

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/durable_exec/dbos/_model.py

@@ -7,12 +7,12 @@ from typing import Any
 
 from dbos import DBOS
 
-from pydantic_ai.agent import EventStreamHandler
-from pydantic_ai.messages import (
+from pydantic_ai import (
     ModelMessage,
     ModelResponse,
     ModelResponseStreamEvent,
 )
+from pydantic_ai.agent import EventStreamHandler
 from pydantic_ai.models import Model, ModelRequestParameters, StreamedResponse
 from pydantic_ai.models.wrapper import WrapperModel
 from pydantic_ai.settings import ModelSettings

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/durable_exec/temporal/_agent.py

@@ -16,6 +16,7 @@ from temporalio.workflow import ActivityConfig
 from typing_extensions import Never
 
 from pydantic_ai import (
+    AbstractToolset,
     _utils,
     messages as _messages,
     models,
@@ -34,7 +35,6 @@ from pydantic_ai.tools import (
     Tool,
     ToolFuncEither,
 )
-from pydantic_ai.toolsets import AbstractToolset
 
 from ._model import TemporalModel
 from ._run_context import TemporalRunContext

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/durable_exec/temporal/_function_toolset.py

@@ -8,9 +8,9 @@ from pydantic import ConfigDict, Discriminator, with_config
 from temporalio import activity, workflow
 from temporalio.workflow import ActivityConfig
 
+from pydantic_ai import FunctionToolset, ToolsetTool
 from pydantic_ai.exceptions import ApprovalRequired, CallDeferred, ModelRetry, UserError
 from pydantic_ai.tools import AgentDepsT, RunContext
-from pydantic_ai.toolsets import FunctionToolset, ToolsetTool
 from pydantic_ai.toolsets.function import FunctionToolsetTool
 
 from ._run_context import TemporalRunContext

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/durable_exec/temporal/_mcp_server.py

@@ -9,10 +9,10 @@ from temporalio import activity, workflow
 from temporalio.workflow import ActivityConfig
 from typing_extensions import Self
 
+from pydantic_ai import ToolsetTool
 from pydantic_ai.exceptions import UserError
 from pydantic_ai.mcp import MCPServer, ToolResult
 from pydantic_ai.tools import AgentDepsT, RunContext, ToolDefinition
-from pydantic_ai.toolsets.abstract import ToolsetTool
 
 from ._run_context import TemporalRunContext
 from ._toolset import TemporalWrapperToolset

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/durable_exec/temporal/_model.py

@@ -10,13 +10,13 @@ from pydantic import ConfigDict, with_config
 from temporalio import activity, workflow
 from temporalio.workflow import ActivityConfig
 
-from pydantic_ai.agent import EventStreamHandler
-from pydantic_ai.exceptions import UserError
-from pydantic_ai.messages import (
+from pydantic_ai import (
     ModelMessage,
     ModelResponse,
     ModelResponseStreamEvent,
 )
+from pydantic_ai.agent import EventStreamHandler
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import Model, ModelRequestParameters, StreamedResponse
 from pydantic_ai.models.wrapper import WrapperModel
 from pydantic_ai.settings import ModelSettings

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/durable_exec/temporal/_toolset.py

@@ -6,10 +6,8 @@ from typing import Any, Literal
 
 from temporalio.workflow import ActivityConfig
 
+from pydantic_ai import AbstractToolset, FunctionToolset, WrapperToolset
 from pydantic_ai.tools import AgentDepsT
-from pydantic_ai.toolsets.abstract import AbstractToolset
-from pydantic_ai.toolsets.function import FunctionToolset
-from pydantic_ai.toolsets.wrapper import WrapperToolset
 
 from ._run_context import TemporalRunContext
 

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/ext/aci.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 from collections.abc import Sequence
 from typing import Any
 
+from pydantic_ai import FunctionToolset
 from pydantic_ai.tools import Tool
-from pydantic_ai.toolsets.function import FunctionToolset
 
 try:
     from aci import ACI

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/ext/langchain.py

@@ -4,8 +4,8 @@ from typing import Any, Protocol
 
 from pydantic.json_schema import JsonSchemaValue
 
+from pydantic_ai import FunctionToolset
 from pydantic_ai.tools import Tool
-from pydantic_ai.toolsets.function import FunctionToolset
 
 
 class LangChainTool(Protocol):

{pydantic_ai_slim-1.0.11 → pydantic_ai_slim-1.0.12}/pydantic_ai/mcp.py

@@ -225,13 +225,27 @@ class MCPServer(AbstractToolset[Any], ABC):
             except McpError as e:
                 raise exceptions.ModelRetry(e.error.message)
 
-        content = [await self._map_tool_result_part(part) for part in result.content]
-
         if result.isError:
-            text = '\n'.join(str(part) for part in content)
-            raise exceptions.ModelRetry(text)
-        else:
-            return content[0] if len(content) == 1 else content
+            message: str | None = None
+            if result.content:  # pragma: no branch
+                text_parts = [part.text for part in result.content if isinstance(part, mcp_types.TextContent)]
+                message = '\n'.join(text_parts)
+
+            raise exceptions.ModelRetry(message or 'MCP tool call failed')
+
+        # Prefer structured content if there are only text parts, which per the docs would contain the JSON-encoded structured content for backward compatibility.
+        # See https://github.com/modelcontextprotocol/python-sdk#structured-output
+        if (structured := result.structuredContent) and not any(
+            not isinstance(part, mcp_types.TextContent) for part in result.content
+        ):
+            # The MCP SDK wraps primitives and generic types like list in a `result` key, but we want to use the raw value returned by the tool function.
+            # See https://github.com/modelcontextprotocol/python-sdk#structured-output
+            if isinstance(structured, dict) and len(structured) == 1 and 'result' in structured:
+                return structured['result']
+            return structured
+
+        mapped = [await self._map_tool_result_part(part) for part in result.content]
+        return mapped[0] if len(mapped) == 1 else mapped
 
     async def call_tool(
         self,