pydantic-ai-slim 0.8.1__py3-none-any.whl → 1.0.0b1__py3-none-any.whl

pydantic_ai/messages.py

@@ -3,22 +3,19 @@ from __future__ import annotations as _annotations
 import base64
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
-from dataclasses import dataclass, field, replace
+from dataclasses import KW_ONLY, dataclass, field, replace
 from datetime import datetime
 from mimetypes import guess_type
-from typing import TYPE_CHECKING, Annotated, Any, Literal, Union, cast, overload
+from typing import TYPE_CHECKING, Annotated, Any, Literal, TypeAlias, cast, overload
 
 import pydantic
 import pydantic_core
 from genai_prices import calc_price, types as genai_types
 from opentelemetry._events import Event  # pyright: ignore[reportPrivateImportUsage]
-from typing_extensions import TypeAlias, deprecated
+from typing_extensions import deprecated
 
 from . import _otel_messages, _utils
-from ._utils import (
-    generate_tool_call_id as _generate_tool_call_id,
-    now_utc as _now_utc,
-)
+from ._utils import generate_tool_call_id as _generate_tool_call_id, now_utc as _now_utc
 from .exceptions import UnexpectedModelBehavior
 from .usage import RequestUsage
 
@@ -65,6 +62,8 @@ class SystemPromptPart:
     content: str
     """The content of the prompt."""
 
+    _: KW_ONLY
+
     timestamp: datetime = field(default_factory=_now_utc)
     """The timestamp of the prompt."""
 
@@ -96,6 +95,8 @@ class FileUrl(ABC):
     url: str
     """The URL of the file."""
 
+    _: KW_ONLY
+
     force_download: bool = False
     """If the model supports it:
 
@@ -153,6 +154,8 @@ class VideoUrl(FileUrl):
     url: str
     """The URL of the video."""
 
+    _: KW_ONLY
+
     kind: Literal['video-url'] = 'video-url'
     """Type identifier, this is available on all parts as a discriminator."""
 
@@ -224,6 +227,8 @@ class AudioUrl(FileUrl):
     url: str
     """The URL of the audio file."""
 
+    _: KW_ONLY
+
     kind: Literal['audio-url'] = 'audio-url'
     """Type identifier, this is available on all parts as a discriminator."""
 
@@ -282,6 +287,8 @@ class ImageUrl(FileUrl):
     url: str
     """The URL of the image."""
 
+    _: KW_ONLY
+
     kind: Literal['image-url'] = 'image-url'
     """Type identifier, this is available on all parts as a discriminator."""
 
@@ -335,6 +342,8 @@ class DocumentUrl(FileUrl):
     url: str
     """The URL of the document."""
 
+    _: KW_ONLY
+
     kind: Literal['document-url'] = 'document-url'
     """Type identifier, this is available on all parts as a discriminator."""
 
@@ -406,6 +415,8 @@ class BinaryContent:
     media_type: AudioMediaType | ImageMediaType | DocumentMediaType | str
     """The media type of the binary data."""
 
+    _: KW_ONLY
+
     identifier: str | None = None
     """Identifier for the binary content, such as a URL or unique ID.
 
@@ -462,7 +473,8 @@ class BinaryContent:
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
-UserContent: TypeAlias = 'str | ImageUrl | AudioUrl | DocumentUrl | VideoUrl | BinaryContent'
+MultiModalContent = ImageUrl | AudioUrl | DocumentUrl | VideoUrl | BinaryContent
+UserContent: TypeAlias = str | MultiModalContent
 
 
 @dataclass(repr=False)
@@ -478,17 +490,19 @@ class ToolReturn:
     return_value: Any
     """The return value to be used in the tool response."""
 
+    _: KW_ONLY
+
     content: str | Sequence[UserContent] | None = None
     """The content to be sent to the model as a UserPromptPart."""
 
     metadata: Any = None
     """Additional data that can be accessed programmatically by the application but is not sent to the LLM."""
 
+    kind: Literal['tool-return'] = 'tool-return'
+
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
-# Ideally this would be a Union of types, but Python 3.9 requires it to be a string, and strings don't work with `isinstance``.
-MultiModalContentTypes = (ImageUrl, AudioUrl, DocumentUrl, VideoUrl, BinaryContent)
 _document_format_lookup: dict[str, DocumentFormat] = {
     'application/pdf': 'pdf',
     'text/plain': 'txt',
@@ -536,6 +550,8 @@ class UserPromptPart:
     content: str | Sequence[UserContent]
     """The content of the prompt."""
 
+    _: KW_ONLY
+
     timestamp: datetime = field(default_factory=_now_utc)
     """The timestamp of the prompt."""
 
@@ -562,7 +578,7 @@ class UserPromptPart:
                 parts.append(
                     _otel_messages.TextPart(type='text', **({'content': part} if settings.include_content else {}))
                 )
-            elif isinstance(part, (ImageUrl, AudioUrl, DocumentUrl, VideoUrl)):
+            elif isinstance(part, ImageUrl | AudioUrl | DocumentUrl | VideoUrl):
                 parts.append(
                     _otel_messages.MediaUrlPart(
                         type=part.kind,
@@ -599,6 +615,8 @@ class BaseToolReturnPart:
     tool_call_id: str
     """The tool call identifier, this is used by some models including OpenAI."""
 
+    _: KW_ONLY
+
     metadata: Any = None
     """Additional data that can be accessed programmatically by the application but is not sent to the LLM."""
 
@@ -654,6 +672,8 @@ class BaseToolReturnPart:
 class ToolReturnPart(BaseToolReturnPart):
     """A tool return message, this encodes the result of running a tool."""
 
+    _: KW_ONLY
+
     part_kind: Literal['tool-return'] = 'tool-return'
     """Part type identifier, this is available on all parts as a discriminator."""
 
@@ -662,6 +682,8 @@ class ToolReturnPart(BaseToolReturnPart):
 class BuiltinToolReturnPart(BaseToolReturnPart):
     """A tool return message from a built-in tool."""
 
+    _: KW_ONLY
+
     provider_name: str | None = None
     """The name of the provider that generated the response."""
 
@@ -695,6 +717,8 @@ class RetryPromptPart:
     error details.
     """
 
+    _: KW_ONLY
+
     tool_name: str | None = None
     """The name of the tool that was called, if any."""
 
@@ -753,7 +777,7 @@ class RetryPromptPart:
 
 
 ModelRequestPart = Annotated[
-    Union[SystemPromptPart, UserPromptPart, ToolReturnPart, RetryPromptPart], pydantic.Discriminator('part_kind')
+    SystemPromptPart | UserPromptPart | ToolReturnPart | RetryPromptPart, pydantic.Discriminator('part_kind')
 ]
 """A message part sent by Pydantic AI to a model."""
 
@@ -765,6 +789,8 @@ class ModelRequest:
     parts: list[ModelRequestPart]
     """The parts of the user message."""
 
+    _: KW_ONLY
+
     instructions: str | None = None
     """The instructions for the model."""
 
@@ -786,6 +812,8 @@ class TextPart:
     content: str
     """The text content of the response."""
 
+    _: KW_ONLY
+
     part_kind: Literal['text'] = 'text'
     """Part type identifier, this is available on all parts as a discriminator."""
 
@@ -803,6 +831,8 @@ class ThinkingPart:
     content: str
     """The thinking content of the response."""
 
+    _: KW_ONLY
+
     id: str | None = None
     """The identifier of the thinking part."""
 
@@ -881,6 +911,8 @@ class BaseToolCallPart:
 class ToolCallPart(BaseToolCallPart):
     """A tool call from a model."""
 
+    _: KW_ONLY
+
     part_kind: Literal['tool-call'] = 'tool-call'
     """Part type identifier, this is available on all parts as a discriminator."""
 
@@ -889,6 +921,8 @@ class ToolCallPart(BaseToolCallPart):
 class BuiltinToolCallPart(BaseToolCallPart):
     """A tool call to a built-in tool."""
 
+    _: KW_ONLY
+
     provider_name: str | None = None
     """The name of the provider that generated the response."""
 
@@ -897,7 +931,7 @@ class BuiltinToolCallPart(BaseToolCallPart):
 
 
 ModelResponsePart = Annotated[
-    Union[TextPart, ToolCallPart, BuiltinToolCallPart, BuiltinToolReturnPart, ThinkingPart],
+    TextPart | ToolCallPart | BuiltinToolCallPart | BuiltinToolReturnPart | ThinkingPart,
     pydantic.Discriminator('part_kind'),
 ]
 """A message part returned by a model."""
@@ -910,6 +944,8 @@ class ModelResponse:
     parts: list[ModelResponsePart]
     """The parts of the model message."""
 
+    _: KW_ONLY
+
     usage: RequestUsage = field(default_factory=RequestUsage)
     """Usage information for the request.
 
@@ -970,14 +1006,14 @@ class ModelResponse:
                 body.setdefault('tool_calls', []).append(
                     {
                         'id': part.tool_call_id,
-                        'type': 'function',  # TODO https://github.com/pydantic/pydantic-ai/issues/888
+                        'type': 'function',
                         'function': {
                             'name': part.tool_name,
                             **({'arguments': part.args} if settings.include_content else {}),
                         },
                     }
                 )
-            elif isinstance(part, (TextPart, ThinkingPart)):
+            elif isinstance(part, TextPart | ThinkingPart):
                 kind = part.part_kind
                 body.setdefault('content', []).append(
                     {'kind': kind, **({'text': part.content} if settings.include_content else {})}
@@ -1038,7 +1074,7 @@ class ModelResponse:
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
-ModelMessage = Annotated[Union[ModelRequest, ModelResponse], pydantic.Discriminator('kind')]
+ModelMessage = Annotated[ModelRequest | ModelResponse, pydantic.Discriminator('kind')]
 """Any message sent to or returned by a model."""
 
 ModelMessagesTypeAdapter = pydantic.TypeAdapter(
@@ -1054,6 +1090,8 @@ class TextPartDelta:
     content_delta: str
     """The incremental text content to add to the existing `TextPart` content."""
 
+    _: KW_ONLY
+
     part_delta_kind: Literal['text'] = 'text'
     """Part delta type identifier, used as a discriminator."""
 
@@ -1076,7 +1114,7 @@ class TextPartDelta:
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
-@dataclass(repr=False)
+@dataclass(repr=False, kw_only=True)
 class ThinkingPartDelta:
     """A partial update (delta) for a `ThinkingPart` to append new thinking content."""
 
@@ -1128,7 +1166,7 @@ class ThinkingPartDelta:
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
-@dataclass(repr=False)
+@dataclass(repr=False, kw_only=True)
 class ToolCallPartDelta:
     """A partial update (delta) for a `ToolCallPart` to modify tool name, arguments, or tool call ID."""
 
@@ -1248,12 +1286,12 @@ class ToolCallPartDelta:
 
 
 ModelResponsePartDelta = Annotated[
-    Union[TextPartDelta, ThinkingPartDelta, ToolCallPartDelta], pydantic.Discriminator('part_delta_kind')
+    TextPartDelta | ThinkingPartDelta | ToolCallPartDelta, pydantic.Discriminator('part_delta_kind')
 ]
 """A partial update (delta) for any model response part."""
 
 
-@dataclass(repr=False)
+@dataclass(repr=False, kw_only=True)
 class PartStartEvent:
     """An event indicating that a new part has started.
 
@@ -1273,7 +1311,7 @@ class PartStartEvent:
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
-@dataclass(repr=False)
+@dataclass(repr=False, kw_only=True)
 class PartDeltaEvent:
     """An event indicating a delta update for an existing part."""
 
@@ -1289,7 +1327,7 @@ class PartDeltaEvent:
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
-@dataclass(repr=False)
+@dataclass(repr=False, kw_only=True)
 class FinalResultEvent:
     """An event indicating the response to the current model request matches the output schema and will produce a result."""
 
@@ -1304,7 +1342,7 @@ class FinalResultEvent:
 
 
 ModelResponseStreamEvent = Annotated[
-    Union[PartStartEvent, PartDeltaEvent, FinalResultEvent], pydantic.Discriminator('event_kind')
+    PartStartEvent | PartDeltaEvent | FinalResultEvent, pydantic.Discriminator('event_kind')
 ]
 """An event in the model response stream, starting a new part, applying a delta to an existing one, or indicating the final result."""
 
@@ -1315,6 +1353,9 @@ class FunctionToolCallEvent:
 
     part: ToolCallPart
     """The (function) tool call to make."""
+
+    _: KW_ONLY
+
     event_kind: Literal['function_tool_call'] = 'function_tool_call'
     """Event type identifier, used as a discriminator."""
 
@@ -1338,6 +1379,9 @@ class FunctionToolResultEvent:
 
     result: ToolReturnPart | RetryPromptPart
     """The result of the call to the function tool."""
+
+    _: KW_ONLY
+
     event_kind: Literal['function_tool_result'] = 'function_tool_result'
     """Event type identifier, used as a discriminator."""
 
@@ -1356,6 +1400,8 @@ class BuiltinToolCallEvent:
     part: BuiltinToolCallPart
     """The built-in tool call to make."""
 
+    _: KW_ONLY
+
     event_kind: Literal['builtin_tool_call'] = 'builtin_tool_call'
     """Event type identifier, used as a discriminator."""
 
@@ -1367,15 +1413,17 @@ class BuiltinToolResultEvent:
     result: BuiltinToolReturnPart
     """The result of the call to the built-in tool."""
 
+    _: KW_ONLY
+
     event_kind: Literal['builtin_tool_result'] = 'builtin_tool_result'
     """Event type identifier, used as a discriminator."""
 
 
 HandleResponseEvent = Annotated[
-    Union[FunctionToolCallEvent, FunctionToolResultEvent, BuiltinToolCallEvent, BuiltinToolResultEvent],
+    FunctionToolCallEvent | FunctionToolResultEvent | BuiltinToolCallEvent | BuiltinToolResultEvent,
     pydantic.Discriminator('event_kind'),
 ]
 """An event yielded when handling a model response, indicating tool calls and results."""
 
-AgentStreamEvent = Annotated[Union[ModelResponseStreamEvent, HandleResponseEvent], pydantic.Discriminator('event_kind')]
+AgentStreamEvent = Annotated[ModelResponseStreamEvent | HandleResponseEvent, pydantic.Discriminator('event_kind')]
 """An event in the agent stream: model response stream events and response-handling events."""

pydantic_ai/models/__init__.py

@@ -14,10 +14,10 @@ from contextlib import asynccontextmanager, contextmanager
 from dataclasses import dataclass, field, replace
 from datetime import datetime
 from functools import cache, cached_property
-from typing import Any, Generic, TypeVar, overload
+from typing import Any, Generic, Literal, TypeVar, overload
 
 import httpx
-from typing_extensions import Literal, TypeAliasType, TypedDict
+from typing_extensions import TypeAliasType, TypedDict
 
 from .. import _utils
 from .._output import OutputObjectDefinition
@@ -367,7 +367,7 @@ KnownModelName = TypeAliasType(
 """
 
 
-@dataclass(repr=False)
+@dataclass(repr=False, kw_only=True)
 class ModelRequestParameters:
     """Configuration for an agent's request to a model, specifically related to tools and output handling."""
 
@@ -552,6 +552,7 @@ class StreamedResponse(ABC):
     """Streamed response from an LLM when calling a tool."""
 
     model_request_parameters: ModelRequestParameters
+
     final_result_event: FinalResultEvent | None = field(default=None, init=False)
 
     _parts_manager: ModelResponsePartsManager = field(default_factory=ModelResponsePartsManager, init=False)
@@ -920,5 +921,5 @@ def _get_final_result_event(e: ModelResponseStreamEvent, params: ModelRequestPar
         elif isinstance(new_part, ToolCallPart) and (tool_def := params.tool_defs.get(new_part.tool_name)):
             if tool_def.kind == 'output':
                 return FinalResultEvent(tool_name=new_part.tool_name, tool_call_id=new_part.tool_call_id)
-            elif tool_def.kind == 'deferred':
+            elif tool_def.defer:
                 return FinalResultEvent(tool_name=None, tool_call_id=None)

pydantic_ai/models/anthropic.py

@@ -6,7 +6,7 @@ from collections.abc import AsyncGenerator, AsyncIterable, AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from typing import Any, Literal, Union, cast, overload
+from typing import Any, Literal, cast, overload
 
 from typing_extensions import assert_never
 
@@ -99,7 +99,7 @@ except ImportError as _import_error:
 LatestAnthropicModelNames = ModelParam
 """Latest Anthropic models."""
 
-AnthropicModelName = Union[str, LatestAnthropicModelNames]
+AnthropicModelName = str | LatestAnthropicModelNames
 """Possible Anthropic model names.
 
 Since Anthropic supports a variety of date-stamped models, we explicitly list the latest models but
@@ -290,7 +290,7 @@ class AnthropicModel(Model):
         for item in response.content:
             if isinstance(item, BetaTextBlock):
                 items.append(TextPart(content=item.text))
-            elif isinstance(item, (BetaWebSearchToolResultBlock, BetaCodeExecutionToolResultBlock)):
+            elif isinstance(item, BetaWebSearchToolResultBlock | BetaCodeExecutionToolResultBlock):
                 items.append(
                     BuiltinToolReturnPart(
                         provider_name='anthropic',
@@ -327,7 +327,7 @@ class AnthropicModel(Model):
                 )
 
         return ModelResponse(
-            items,
+            parts=items,
             usage=_map_usage(response),
             model_name=response.model,
             provider_response_id=response.id,
@@ -654,7 +654,7 @@ class AnthropicStreamedResponse(StreamedResponse):
             elif isinstance(event, BetaRawMessageDeltaEvent):
                 pass
 
-            elif isinstance(event, (BetaRawContentBlockStopEvent, BetaRawMessageStopEvent)):  # pragma: no branch
+            elif isinstance(event, BetaRawContentBlockStopEvent | BetaRawMessageStopEvent):  # pragma: no branch
                 current_block = None
 
     @property

pydantic_ai/models/bedrock.py

@@ -8,7 +8,7 @@ from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime
 from itertools import count
-from typing import TYPE_CHECKING, Any, Generic, Literal, Union, cast, overload
+from typing import TYPE_CHECKING, Any, Generic, Literal, cast, overload
 
 import anyio
 import anyio.to_thread
@@ -125,7 +125,7 @@ LatestBedrockModelNames = Literal[
 ]
 """Latest Bedrock models."""
 
-BedrockModelName = Union[str, LatestBedrockModelNames]
+BedrockModelName = str | LatestBedrockModelNames
 """Possible Bedrock model names.
 
 Since Bedrock supports a variety of date-stamped models, we explicitly list the latest models but allow any name in the type hints.
@@ -303,7 +303,7 @@ class BedrockConverseModel(Model):
         )
         response_id = response.get('ResponseMetadata', {}).get('RequestId', None)
         return ModelResponse(
-            items,
+            parts=items,
             usage=u,
             model_name=self.model_name,
             provider_response_id=response_id,
@@ -490,7 +490,7 @@ class BedrockConverseModel(Model):
                         else:
                             # NOTE: We don't pass the thinking part to Bedrock for models other than Claude since it raises an error.
                             pass
-                    elif isinstance(item, (BuiltinToolCallPart, BuiltinToolReturnPart)):
+                    elif isinstance(item, BuiltinToolCallPart | BuiltinToolReturnPart):
                         pass
                     else:
                         assert isinstance(item, ToolCallPart)
@@ -546,7 +546,7 @@ class BedrockConverseModel(Model):
                         content.append({'video': {'format': format, 'source': {'bytes': item.data}}})
                     else:
                         raise NotImplementedError('Binary content is not supported yet.')
-                elif isinstance(item, (ImageUrl, DocumentUrl, VideoUrl)):
+                elif isinstance(item, ImageUrl | DocumentUrl | VideoUrl):
                     downloaded_item = await download_item(item, data_format='bytes', type_format='extension')
                     format = downloaded_item['data_type']
                     if item.kind == 'image-url':
@@ -610,60 +610,62 @@ class BedrockStreamedResponse(StreamedResponse):
         chunk: ConverseStreamOutputTypeDef
         tool_id: str | None = None
         async for chunk in _AsyncIteratorWrapper(self._event_stream):
-            # TODO(Marcelo): Switch this to `match` when we drop Python 3.9 support.
-            if 'messageStart' in chunk:
-                continue
-            if 'messageStop' in chunk:
-                continue
-            if 'metadata' in chunk:
-                if 'usage' in chunk['metadata']:  # pragma: no branch
-                    self._usage += self._map_usage(chunk['metadata'])
-                continue
-            if 'contentBlockStart' in chunk:
-                index = chunk['contentBlockStart']['contentBlockIndex']
-                start = chunk['contentBlockStart']['start']
-                if 'toolUse' in start:  # pragma: no branch
-                    tool_use_start = start['toolUse']
-                    tool_id = tool_use_start['toolUseId']
-                    tool_name = tool_use_start['name']
-                    maybe_event = self._parts_manager.handle_tool_call_delta(
-                        vendor_part_id=index,
-                        tool_name=tool_name,
-                        args=None,
-                        tool_call_id=tool_id,
-                    )
-                    if maybe_event:  # pragma: no branch
-                        yield maybe_event
-            if 'contentBlockDelta' in chunk:
-                index = chunk['contentBlockDelta']['contentBlockIndex']
-                delta = chunk['contentBlockDelta']['delta']
-                if 'reasoningContent' in delta:
-                    if text := delta['reasoningContent'].get('text'):
-                        yield self._parts_manager.handle_thinking_delta(
+            match chunk:
+                case {'messageStart': _}:
+                    continue
+                case {'messageStop': _}:
+                    continue
+                case {'metadata': metadata}:
+                    if 'usage' in metadata:  # pragma: no branch
+                        self._usage += self._map_usage(metadata)
+                    continue
+                case {'contentBlockStart': content_block_start}:
+                    index = content_block_start['contentBlockIndex']
+                    start = content_block_start['start']
+                    if 'toolUse' in start:  # pragma: no branch
+                        tool_use_start = start['toolUse']
+                        tool_id = tool_use_start['toolUseId']
+                        tool_name = tool_use_start['name']
+                        maybe_event = self._parts_manager.handle_tool_call_delta(
                             vendor_part_id=index,
-                            content=text,
-                            signature=delta['reasoningContent'].get('signature'),
+                            tool_name=tool_name,
+                            args=None,
+                            tool_call_id=tool_id,
                         )
-                    else:  # pragma: no cover
-                        warnings.warn(
-                            f'Only text reasoning content is supported yet, but you got {delta["reasoningContent"]}. '
-                            'Please report this to the maintainers.',
-                            UserWarning,
+                        if maybe_event:  # pragma: no branch
+                            yield maybe_event
+                case {'contentBlockDelta': content_block_delta}:
+                    index = content_block_delta['contentBlockIndex']
+                    delta = content_block_delta['delta']
+                    if 'reasoningContent' in delta:
+                        if text := delta['reasoningContent'].get('text'):
+                            yield self._parts_manager.handle_thinking_delta(
+                                vendor_part_id=index,
+                                content=text,
+                                signature=delta['reasoningContent'].get('signature'),
+                            )
+                        else:  # pragma: no cover
+                            warnings.warn(
+                                f'Only text reasoning content is supported yet, but you got {delta["reasoningContent"]}. '
+                                'Please report this to the maintainers.',
+                                UserWarning,
+                            )
+                    if 'text' in delta:
+                        maybe_event = self._parts_manager.handle_text_delta(vendor_part_id=index, content=delta['text'])
+                        if maybe_event is not None:  # pragma: no branch
+                            yield maybe_event
+                    if 'toolUse' in delta:
+                        tool_use = delta['toolUse']
+                        maybe_event = self._parts_manager.handle_tool_call_delta(
+                            vendor_part_id=index,
+                            tool_name=tool_use.get('name'),
+                            args=tool_use.get('input'),
+                            tool_call_id=tool_id,
                         )
-                if 'text' in delta:
-                    maybe_event = self._parts_manager.handle_text_delta(vendor_part_id=index, content=delta['text'])
-                    if maybe_event is not None:  # pragma: no branch
-                        yield maybe_event
-                if 'toolUse' in delta:
-                    tool_use = delta['toolUse']
-                    maybe_event = self._parts_manager.handle_tool_call_delta(
-                        vendor_part_id=index,
-                        tool_name=tool_use.get('name'),
-                        args=tool_use.get('input'),
-                        tool_call_id=tool_id,
-                    )
-                    if maybe_event:  # pragma: no branch
-                        yield maybe_event
+                        if maybe_event:  # pragma: no branch
+                            yield maybe_event
+                case _:
+                    pass  # pyright wants match statements to be exhaustive
 
     @property
     def model_name(self) -> str:

pydantic_ai/models/cohere.py

@@ -2,7 +2,7 @@ from __future__ import annotations as _annotations
 
 from collections.abc import Iterable
 from dataclasses import dataclass, field
-from typing import Literal, Union, cast
+from typing import Literal, cast
 
 from typing_extensions import assert_never
 
@@ -72,7 +72,7 @@ LatestCohereModelNames = Literal[
 ]
 """Latest Cohere models."""
 
-CohereModelName = Union[str, LatestCohereModelNames]
+CohereModelName = str | LatestCohereModelNames
 """Possible Cohere model names.
 
 Since Cohere supports a variety of date-stamped models, we explicitly list the latest models but
@@ -228,7 +228,7 @@ class CohereModel(Model):
                         pass
                     elif isinstance(item, ToolCallPart):
                         tool_calls.append(self._map_tool_call(item))
-                    elif isinstance(item, (BuiltinToolCallPart, BuiltinToolReturnPart)):  # pragma: no cover
+                    elif isinstance(item, BuiltinToolCallPart | BuiltinToolReturnPart):  # pragma: no cover
                         # This is currently never returned from cohere
                         pass
                     else:

pydantic_ai/models/fallback.py

@@ -1,9 +1,9 @@
 from __future__ import annotations as _annotations
 
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Callable
 from contextlib import AsyncExitStack, asynccontextmanager, suppress
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 from opentelemetry.trace import get_current_span