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

pydantic_ai/models/mistral.py

@@ -5,7 +5,7 @@ from collections.abc import AsyncIterable, AsyncIterator, Iterable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Any, Literal, Union, cast
+from typing import Any, Literal, cast
 
 import pydantic_core
 from httpx import Timeout
@@ -79,7 +79,7 @@ try:
     from mistralai.models.usermessage import UserMessage as MistralUserMessage
     from mistralai.types.basemodel import Unset as MistralUnset
     from mistralai.utils.eventstreaming import EventStreamAsync as MistralEventStreamAsync
-except ImportError as e:  # pragma: no cover
+except ImportError as e:
     raise ImportError(
         'Please install `mistral` to use the Mistral model, '
         'you can use the `mistral` optional group — `pip install "pydantic-ai-slim[mistral]"`'
@@ -90,7 +90,7 @@ LatestMistralModelNames = Literal[
 ]
 """Latest  Mistral models."""
 
-MistralModelName = Union[str, LatestMistralModelNames]
+MistralModelName = str | LatestMistralModelNames
 """Possible Mistral model names.
 
 Since Mistral supports a variety of date-stamped models, we explicitly list the most popular models but
@@ -117,7 +117,7 @@ class MistralModel(Model):
     """
 
     client: Mistral = field(repr=False)
-    json_mode_schema_prompt: str = """Answer in JSON Object, respect the format:\n```\n{schema}\n```\n"""
+    json_mode_schema_prompt: str
 
     _model_name: MistralModelName = field(repr=False)
     _provider: Provider[Mistral] = field(repr=False)
@@ -348,11 +348,11 @@ class MistralModel(Model):
                 parts.append(tool)
 
         return ModelResponse(
-            parts,
+            parts=parts,
             usage=_map_usage(response),
             model_name=response.model,
             timestamp=timestamp,
-            provider_request_id=response.id,
+            provider_response_id=response.id,
             provider_name=self._provider.name,
         )
 
@@ -515,7 +515,7 @@ class MistralModel(Model):
                         pass
                     elif isinstance(part, ToolCallPart):
                         tool_calls.append(self._map_tool_call(part))
-                    elif isinstance(part, (BuiltinToolCallPart, BuiltinToolReturnPart)):  # pragma: no cover
+                    elif isinstance(part, BuiltinToolCallPart | BuiltinToolReturnPart):  # pragma: no cover
                         # This is currently never returned from mistral
                         pass
                     else:
@@ -576,7 +576,7 @@ class MistralModel(Model):
         return MistralUserMessage(content=content)
 
 
-MistralToolCallId = Union[str, None]
+MistralToolCallId = str | None
 
 
 @dataclass

pydantic_ai/models/openai.py

@@ -6,7 +6,7 @@ from collections.abc import AsyncIterable, AsyncIterator, Sequence
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Any, Literal, Union, cast, overload
+from typing import Any, Literal, cast, overload
 
 from pydantic import ValidationError
 from typing_extensions import assert_never, deprecated
@@ -90,7 +90,7 @@ __all__ = (
     'OpenAIModelName',
 )
 
-OpenAIModelName = Union[str, AllModels]
+OpenAIModelName = str | AllModels
 """
 Possible OpenAI model names.
 
@@ -409,13 +409,6 @@ class OpenAIChatModel(Model):
         for setting in unsupported_model_settings:
             model_settings.pop(setting, None)
 
-        # TODO(Marcelo): Deprecate this in favor of `openai_unsupported_model_settings`.
-        sampling_settings = (
-            model_settings
-            if OpenAIModelProfile.from_profile(self.profile).openai_supports_sampling_settings
-            else OpenAIChatModelSettings()
-        )
-
         try:
             extra_headers = model_settings.get('extra_headers', {})
             extra_headers.setdefault('User-Agent', get_user_agent())
@@ -437,13 +430,13 @@ class OpenAIChatModel(Model):
                 web_search_options=web_search_options or NOT_GIVEN,
                 service_tier=model_settings.get('openai_service_tier', NOT_GIVEN),
                 prediction=model_settings.get('openai_prediction', NOT_GIVEN),
-                temperature=sampling_settings.get('temperature', NOT_GIVEN),
-                top_p=sampling_settings.get('top_p', NOT_GIVEN),
-                presence_penalty=sampling_settings.get('presence_penalty', NOT_GIVEN),
-                frequency_penalty=sampling_settings.get('frequency_penalty', NOT_GIVEN),
-                logit_bias=sampling_settings.get('logit_bias', NOT_GIVEN),
-                logprobs=sampling_settings.get('openai_logprobs', NOT_GIVEN),
-                top_logprobs=sampling_settings.get('openai_top_logprobs', NOT_GIVEN),
+                temperature=model_settings.get('temperature', NOT_GIVEN),
+                top_p=model_settings.get('top_p', NOT_GIVEN),
+                presence_penalty=model_settings.get('presence_penalty', NOT_GIVEN),
+                frequency_penalty=model_settings.get('frequency_penalty', NOT_GIVEN),
+                logit_bias=model_settings.get('logit_bias', NOT_GIVEN),
+                logprobs=model_settings.get('openai_logprobs', NOT_GIVEN),
+                top_logprobs=model_settings.get('openai_top_logprobs', NOT_GIVEN),
                 extra_headers=extra_headers,
                 extra_body=model_settings.get('extra_body'),
             )
@@ -512,12 +505,12 @@ class OpenAIChatModel(Model):
                 part.tool_call_id = _guard_tool_call_id(part)
                 items.append(part)
         return ModelResponse(
-            items,
+            parts=items,
             usage=_map_usage(response),
             model_name=response.model,
             timestamp=timestamp,
             provider_details=vendor_details,
-            provider_request_id=response.id,
+            provider_response_id=response.id,
             provider_name=self._provider.name,
         )
 
@@ -582,7 +575,7 @@ class OpenAIChatModel(Model):
                     elif isinstance(item, ToolCallPart):
                         tool_calls.append(self._map_tool_call(item))
                     # OpenAI doesn't return built-in tool calls
-                    elif isinstance(item, (BuiltinToolCallPart, BuiltinToolReturnPart)):  # pragma: no cover
+                    elif isinstance(item, BuiltinToolCallPart | BuiltinToolReturnPart):  # pragma: no cover
                         pass
                     else:
                         assert_never(item)
@@ -828,10 +821,10 @@ class OpenAIResponsesModel(Model):
             elif item.type == 'function_call':
                 items.append(ToolCallPart(item.name, item.arguments, tool_call_id=item.call_id))
         return ModelResponse(
-            items,
+            parts=items,
             usage=_map_usage(response),
             model_name=response.model,
-            provider_request_id=response.id,
+            provider_response_id=response.id,
             timestamp=timestamp,
             provider_name=self._provider.name,
         )
@@ -918,11 +911,9 @@ class OpenAIResponsesModel(Model):
             text = text or {}
             text['verbosity'] = verbosity
 
-        sampling_settings = (
-            model_settings
-            if OpenAIModelProfile.from_profile(self.profile).openai_supports_sampling_settings
-            else OpenAIResponsesModelSettings()
-        )
+        unsupported_model_settings = OpenAIModelProfile.from_profile(self.profile).openai_unsupported_model_settings
+        for setting in unsupported_model_settings:
+            model_settings.pop(setting, None)
 
         try:
             extra_headers = model_settings.get('extra_headers', {})
@@ -936,8 +927,8 @@ class OpenAIResponsesModel(Model):
                 tool_choice=tool_choice or NOT_GIVEN,
                 max_output_tokens=model_settings.get('max_tokens', NOT_GIVEN),
                 stream=stream,
-                temperature=sampling_settings.get('temperature', NOT_GIVEN),
-                top_p=sampling_settings.get('top_p', NOT_GIVEN),
+                temperature=model_settings.get('temperature', NOT_GIVEN),
+                top_p=model_settings.get('top_p', NOT_GIVEN),
                 truncation=model_settings.get('openai_truncation', NOT_GIVEN),
                 timeout=model_settings.get('timeout', NOT_GIVEN),
                 service_tier=model_settings.get('openai_service_tier', NOT_GIVEN),
@@ -1049,7 +1040,7 @@ class OpenAIResponsesModel(Model):
                     elif isinstance(item, ToolCallPart):
                         openai_messages.append(self._map_tool_call(item))
                     # OpenAI doesn't return built-in tool calls
-                    elif isinstance(item, (BuiltinToolCallPart, BuiltinToolReturnPart)):
+                    elif isinstance(item, BuiltinToolCallPart | BuiltinToolReturnPart):
                         pass
                     elif isinstance(item, ThinkingPart):
                         # NOTE: We don't send ThinkingPart to the providers yet. If you are unsatisfied with this,

pydantic_ai/models/test.py

@@ -195,7 +195,10 @@ class TestModel(Model):
         # if there are tools, the first thing we want to do is call all of them
         if tool_calls and not any(isinstance(m, ModelResponse) for m in messages):
             return ModelResponse(
-                parts=[ToolCallPart(name, self.gen_tool_args(args)) for name, args in tool_calls],
+                parts=[
+                    ToolCallPart(name, self.gen_tool_args(args), tool_call_id=f'pyd_ai_tool_call_id__{name}')
+                    for name, args in tool_calls
+                ],
                 model_name=self._model_name,
             )
 
@@ -220,6 +223,7 @@ class TestModel(Model):
                                 output_wrapper.value
                                 if isinstance(output_wrapper, _WrappedToolOutput) and output_wrapper.value is not None
                                 else self.gen_tool_args(tool),
+                                tool_call_id=f'pyd_ai_tool_call_id__{tool.name}',
                             )
                             for tool in output_tools
                             if tool.name in new_retry_names
@@ -250,11 +254,27 @@ class TestModel(Model):
             output_tool = output_tools[self.seed % len(output_tools)]
             if custom_output_args is not None:
                 return ModelResponse(
-                    parts=[ToolCallPart(output_tool.name, custom_output_args)], model_name=self._model_name
+                    parts=[
+                        ToolCallPart(
+                            output_tool.name,
+                            custom_output_args,
+                            tool_call_id=f'pyd_ai_tool_call_id__{output_tool.name}',
+                        )
+                    ],
+                    model_name=self._model_name,
                 )
             else:
                 response_args = self.gen_tool_args(output_tool)
-                return ModelResponse(parts=[ToolCallPart(output_tool.name, response_args)], model_name=self._model_name)
+                return ModelResponse(
+                    parts=[
+                        ToolCallPart(
+                            output_tool.name,
+                            response_args,
+                            tool_call_id=f'pyd_ai_tool_call_id__{output_tool.name}',
+                        )
+                    ],
+                    model_name=self._model_name,
+                )
 
 
 @dataclass
@@ -293,7 +313,7 @@ class TestStreamedResponse(StreamedResponse):
                 yield self._parts_manager.handle_tool_call_part(
                     vendor_part_id=i, tool_name=part.tool_name, args=part.args, tool_call_id=part.tool_call_id
                 )
-            elif isinstance(part, (BuiltinToolCallPart, BuiltinToolReturnPart)):  # pragma: no cover
+            elif isinstance(part, BuiltinToolCallPart | BuiltinToolReturnPart):  # pragma: no cover
                 # NOTE: These parts are not generated by TestModel, but we need to handle them for type checking
                 assert False, f'Unexpected part type in TestModel: {type(part).__name__}'
             elif isinstance(part, ThinkingPart):  # pragma: no cover

pydantic_ai/output.py

@@ -1,17 +1,17 @@
 from __future__ import annotations
 
-from collections.abc import Awaitable, Sequence
+from collections.abc import Awaitable, Callable, Sequence
 from dataclasses import dataclass
-from typing import Any, Callable, Generic, Literal, Union
+from typing import Any, Generic, Literal
 
 from pydantic import GetCoreSchemaHandler, GetJsonSchemaHandler
 from pydantic.json_schema import JsonSchemaValue
 from pydantic_core import core_schema
-from typing_extensions import TypeAliasType, TypeVar
+from typing_extensions import TypeAliasType, TypeVar, deprecated
 
 from . import _utils
 from .messages import ToolCallPart
-from .tools import RunContext, ToolDefinition
+from .tools import DeferredToolRequests, RunContext, ToolDefinition
 
 __all__ = (
     # classes
@@ -42,7 +42,7 @@ StructuredOutputMode = Literal['tool', 'native', 'prompted']
 
 
 OutputTypeOrFunction = TypeAliasType(
-    'OutputTypeOrFunction', Union[type[T_co], Callable[..., Union[Awaitable[T_co], T_co]]], type_params=(T_co,)
+    'OutputTypeOrFunction', type[T_co] | Callable[..., Awaitable[T_co] | T_co], type_params=(T_co,)
 )
 """Definition of an output type or function.
 
@@ -54,10 +54,7 @@ See [output docs](../output.md) for more information.
 
 TextOutputFunc = TypeAliasType(
     'TextOutputFunc',
-    Union[
-        Callable[[RunContext, str], Union[Awaitable[T_co], T_co]],
-        Callable[[str], Union[Awaitable[T_co], T_co]],
-    ],
+    Callable[[RunContext, str], Awaitable[T_co] | T_co] | Callable[[str], Awaitable[T_co] | T_co],
     type_params=(T_co,),
 )
 """Definition of a function that will be called to process the model's plain text output. The function must take a single string argument.
@@ -135,10 +132,9 @@ class NativeOutput(Generic[OutputDataT]):
 
     Example:
     ```python {title="native_output.py" requires="tool_output.py"}
-    from tool_output import Fruit, Vehicle
-
     from pydantic_ai import Agent, NativeOutput
 
+    from tool_output import Fruit, Vehicle
 
     agent = Agent(
         'openai:gpt-4o',
@@ -184,10 +180,11 @@ class PromptedOutput(Generic[OutputDataT]):
     Example:
     ```python {title="prompted_output.py" requires="tool_output.py"}
     from pydantic import BaseModel
-    from tool_output import Vehicle
 
     from pydantic_ai import Agent, PromptedOutput
 
+    from tool_output import Vehicle
+
 
     class Device(BaseModel):
         name: str
@@ -286,18 +283,17 @@ def StructuredDict(
     ```python {title="structured_dict.py"}
     from pydantic_ai import Agent, StructuredDict
 
-
     schema = {
-        "type": "object",
-        "properties": {
-            "name": {"type": "string"},
-            "age": {"type": "integer"}
+        'type': 'object',
+        'properties': {
+            'name': {'type': 'string'},
+            'age': {'type': 'integer'}
         },
-        "required": ["name", "age"]
+        'required': ['name', 'age']
     }
 
     agent = Agent('openai:gpt-4o', output_type=StructuredDict(schema))
-    result = agent.run_sync("Create a person")
+    result = agent.run_sync('Create a person')
     print(result.output)
     #> {'name': 'John Doe', 'age': 30}
     ```
@@ -333,16 +329,13 @@ def StructuredDict(
 
 _OutputSpecItem = TypeAliasType(
     '_OutputSpecItem',
-    Union[OutputTypeOrFunction[T_co], ToolOutput[T_co], NativeOutput[T_co], PromptedOutput[T_co], TextOutput[T_co]],
+    OutputTypeOrFunction[T_co] | ToolOutput[T_co] | NativeOutput[T_co] | PromptedOutput[T_co] | TextOutput[T_co],
     type_params=(T_co,),
 )
 
 OutputSpec = TypeAliasType(
     'OutputSpec',
-    Union[
-        _OutputSpecItem[T_co],
-        Sequence['OutputSpec[T_co]'],
-    ],
+    _OutputSpecItem[T_co] | Sequence['OutputSpec[T_co]'],
     type_params=(T_co,),
 )
 """Specification of the agent's output data.
@@ -359,12 +352,14 @@ See [output docs](../output.md) for more information.
 """
 
 
-@dataclass
-class DeferredToolCalls:
-    """Container for calls of deferred tools. This can be used as an agent's `output_type` and will be used as the output of the agent run if the model called any deferred tools.
-
-    See [deferred toolset docs](../toolsets.md#deferred-toolset) for more information.
-    """
+@deprecated('`DeferredToolCalls` is deprecated, use `DeferredToolRequests` instead')
+class DeferredToolCalls(DeferredToolRequests):  # pragma: no cover
+    @property
+    @deprecated('`DeferredToolCalls.tool_calls` is deprecated, use `DeferredToolRequests.calls` instead')
+    def tool_calls(self) -> list[ToolCallPart]:
+        return self.calls
 
-    tool_calls: list[ToolCallPart]
-    tool_defs: dict[str, ToolDefinition]
+    @property
+    @deprecated('`DeferredToolCalls.tool_defs` is deprecated')
+    def tool_defs(self) -> dict[str, ToolDefinition]:
+        return {}

pydantic_ai/profiles/__init__.py

@@ -1,8 +1,8 @@
 from __future__ import annotations as _annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass, fields, replace
 from textwrap import dedent
-from typing import Callable, Union
 
 from typing_extensions import Self
 
@@ -18,7 +18,7 @@ __all__ = [
 ]
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ModelProfile:
     """Describes how requests to and responses from specific models or families of models need to be constructed and processed to get the best results, independent of the model and provider classes used."""
 
@@ -75,6 +75,6 @@ class ModelProfile:
         return replace(self, **non_default_attrs)
 
 
-ModelProfileSpec = Union[ModelProfile, Callable[[str], Union[ModelProfile, None]]]
+ModelProfileSpec = ModelProfile | Callable[[str], ModelProfile | None]
 
 DEFAULT_PROFILE = ModelProfile()

pydantic_ai/profiles/groq.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from . import ModelProfile
 
 
-@dataclass
+@dataclass(kw_only=True)
 class GroqModelProfile(ModelProfile):
     """Profile for models used with GroqModel.
 

pydantic_ai/profiles/openai.py

@@ -1,6 +1,7 @@
 from __future__ import annotations as _annotations
 
 import re
+import warnings
 from collections.abc import Sequence
 from dataclasses import dataclass
 from typing import Any, Literal
@@ -11,7 +12,7 @@ from ._json_schema import JsonSchema, JsonSchemaTransformer
 OpenAISystemPromptRole = Literal['system', 'developer', 'user']
 
 
-@dataclass
+@dataclass(kw_only=True)
 class OpenAIModelProfile(ModelProfile):
     """Profile for models used with `OpenAIChatModel`.
 
@@ -21,7 +22,6 @@ class OpenAIModelProfile(ModelProfile):
     openai_supports_strict_tool_definition: bool = True
     """This can be set by a provider or user if the OpenAI-"compatible" API doesn't support strict tool definitions."""
 
-    # TODO(Marcelo): Deprecate this in favor of `openai_unsupported_model_settings`.
     openai_supports_sampling_settings: bool = True
     """Turn off to don't send sampling settings like `temperature` and `top_p` to models that don't support them, like OpenAI's o-series reasoning models."""
 
@@ -38,6 +38,14 @@ class OpenAIModelProfile(ModelProfile):
     openai_system_prompt_role: OpenAISystemPromptRole | None = None
     """The role to use for the system prompt message. If not provided, defaults to `'system'`."""
 
+    def __post_init__(self):  # pragma: no cover
+        if not self.openai_supports_sampling_settings:
+            warnings.warn(
+                'The `openai_supports_sampling_settings` has no effect, and it will be removed in future versions. '
+                'Use `openai_unsupported_model_settings` instead.',
+                DeprecationWarning,
+            )
+
 
 def openai_model_profile(model_name: str) -> ModelProfile:
     """Get the model profile for an OpenAI model."""
@@ -46,6 +54,19 @@ def openai_model_profile(model_name: str) -> ModelProfile:
     # We leave it in here for all models because the `default_structured_output_mode` is `'tool'`, so `native` is only used
     # when the user specifically uses the `NativeOutput` marker, so an error from the API is acceptable.
 
+    if is_reasoning_model:
+        openai_unsupported_model_settings = (
+            'temperature',
+            'top_p',
+            'presence_penalty',
+            'frequency_penalty',
+            'logit_bias',
+            'logprobs',
+            'top_logprobs',
+        )
+    else:
+        openai_unsupported_model_settings = ()
+
     # The o1-mini model doesn't support the `system` role, so we default to `user`.
     # See https://github.com/pydantic/pydantic-ai/issues/974 for more details.
     openai_system_prompt_role = 'user' if model_name.startswith('o1-mini') else None
@@ -54,7 +75,7 @@ def openai_model_profile(model_name: str) -> ModelProfile:
         json_schema_transformer=OpenAIJsonSchemaTransformer,
         supports_json_schema_output=True,
         supports_json_object_output=True,
-        openai_supports_sampling_settings=not is_reasoning_model,
+        openai_unsupported_model_settings=openai_unsupported_model_settings,
         openai_system_prompt_role=openai_system_prompt_role,
     )
 
@@ -89,7 +110,7 @@ _STRICT_COMPATIBLE_STRING_FORMATS = [
 _sentinel = object()
 
 
-@dataclass
+@dataclass(init=False)
 class OpenAIJsonSchemaTransformer(JsonSchemaTransformer):
     """Recursively handle the schema to make it compatible with OpenAI strict mode.
 

pydantic_ai/providers/anthropic.py

@@ -1,10 +1,9 @@
 from __future__ import annotations as _annotations
 
 import os
-from typing import Union, overload
+from typing import TypeAlias, overload
 
 import httpx
-from typing_extensions import TypeAlias
 
 from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
@@ -21,7 +20,7 @@ except ImportError as _import_error:
     ) from _import_error
 
 
-AsyncAnthropicClient: TypeAlias = Union[AsyncAnthropic, AsyncAnthropicBedrock]
+AsyncAnthropicClient: TypeAlias = AsyncAnthropic | AsyncAnthropicBedrock
 
 
 class AnthropicProvider(Provider[AsyncAnthropicClient]):

pydantic_ai/providers/bedrock.py

@@ -2,8 +2,9 @@ from __future__ import annotations as _annotations
 
 import os
 import re
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Callable, Literal, overload
+from typing import Literal, overload
 
 from pydantic_ai.exceptions import UserError
 from pydantic_ai.profiles import ModelProfile
@@ -27,7 +28,7 @@ except ImportError as _import_error:
     ) from _import_error
 
 
-@dataclass
+@dataclass(kw_only=True)
 class BedrockModelProfile(ModelProfile):
     """Profile for models used with BedrockModel.