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

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.
 

pydantic_ai/result.py

@@ -1,16 +1,14 @@
 from __future__ import annotations as _annotations
 
-from collections.abc import AsyncIterator, Awaitable, Callable
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterable
 from copy import copy
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Generic, cast
+from typing import Generic, cast, overload
 
 from pydantic import ValidationError
 from typing_extensions import TypeVar, deprecated
 
-from pydantic_ai._tool_manager import ToolManager
-
 from . import _utils, exceptions, messages as _messages, models
 from ._output import (
     OutputDataT_inv,
@@ -22,11 +20,14 @@ from ._output import (
     ToolOutputSchema,
 )
 from ._run_context import AgentDepsT, RunContext
+from ._tool_manager import ToolManager
 from .messages import ModelResponseStreamEvent
 from .output import (
+    DeferredToolRequests,
     OutputDataT,
     ToolOutput,
 )
+from .run import AgentRunResult
 from .usage import RunUsage, UsageLimits
 
 __all__ = (
@@ -41,7 +42,7 @@ T = TypeVar('T')
 """An invariant TypeVar."""
 
 
-@dataclass
+@dataclass(kw_only=True)
 class AgentStream(Generic[AgentDepsT, OutputDataT]):
     _raw_stream_response: models.StreamedResponse
     _output_schema: OutputSchema[OutputDataT]
@@ -155,12 +156,12 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
             return await self._tool_manager.handle_call(
                 tool_call, allow_partial=allow_partial, wrap_validation_errors=False
             )
-        elif deferred_tool_calls := self._tool_manager.get_deferred_tool_calls(message.parts):
-            if not self._output_schema.allows_deferred_tool_calls:
+        elif deferred_tool_requests := _get_deferred_tool_requests(message.parts, self._tool_manager):
+            if not self._output_schema.allows_deferred_tools:
                 raise exceptions.UserError(
-                    'A deferred tool call was present, but `DeferredToolCalls` is not among output types. To resolve this, add `DeferredToolCalls` to the list of output types for this agent.'
+                    'A deferred tool call was present, but `DeferredToolRequests` is not among output types. To resolve this, add `DeferredToolRequests` to the list of output types for this agent.'
                 )
-            return cast(OutputDataT, deferred_tool_calls)
+            return cast(OutputDataT, deferred_tool_requests)
         elif isinstance(self._output_schema, TextOutputSchema):
             text = '\n\n'.join(x.content for x in message.parts if isinstance(x, _messages.TextPart))
 
@@ -233,15 +234,17 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
         return self._agent_stream_iterator
 
 
-@dataclass
+@dataclass(init=False)
 class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
     """Result of a streamed run that returns structured data via a tool call."""
 
     _all_messages: list[_messages.ModelMessage]
     _new_message_index: int
 
-    _stream_response: AgentStream[AgentDepsT, OutputDataT]
-    _on_complete: Callable[[], Awaitable[None]]
+    _stream_response: AgentStream[AgentDepsT, OutputDataT] | None = None
+    _on_complete: Callable[[], Awaitable[None]] | None = None
+
+    _run_result: AgentRunResult[OutputDataT] | None = None
 
     is_complete: bool = field(default=False, init=False)
     """Whether the stream has all been received.
@@ -253,6 +256,39 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
     [`get_output`][pydantic_ai.result.StreamedRunResult.get_output] completes.
     """
 
+    @overload
+    def __init__(
+        self,
+        all_messages: list[_messages.ModelMessage],
+        new_message_index: int,
+        stream_response: AgentStream[AgentDepsT, OutputDataT] | None,
+        on_complete: Callable[[], Awaitable[None]] | None,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        all_messages: list[_messages.ModelMessage],
+        new_message_index: int,
+        *,
+        run_result: AgentRunResult[OutputDataT],
+    ) -> None: ...
+
+    def __init__(
+        self,
+        all_messages: list[_messages.ModelMessage],
+        new_message_index: int,
+        stream_response: AgentStream[AgentDepsT, OutputDataT] | None = None,
+        on_complete: Callable[[], Awaitable[None]] | None = None,
+        run_result: AgentRunResult[OutputDataT] | None = None,
+    ) -> None:
+        self._all_messages = all_messages
+        self._new_message_index = new_message_index
+
+        self._stream_response = stream_response
+        self._on_complete = on_complete
+        self._run_result = run_result
+
     def all_messages(self, *, output_tool_return_content: str | None = None) -> list[_messages.ModelMessage]:
         """Return the history of _messages.
 
@@ -340,9 +376,15 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
         Returns:
             An async iterable of the response data.
         """
-        async for output in self._stream_response.stream_output(debounce_by=debounce_by):
-            yield output
-        await self._marked_completed(self._stream_response.get())
+        if self._run_result is not None:
+            yield self._run_result.output
+            await self._marked_completed()
+        elif self._stream_response is not None:
+            async for output in self._stream_response.stream_output(debounce_by=debounce_by):
+                yield output
+            await self._marked_completed(self._stream_response.get())
+        else:
+            raise ValueError('No stream response or run result provided')  # pragma: no cover
 
     async def stream_text(self, *, delta: bool = False, debounce_by: float | None = 0.1) -> AsyncIterator[str]:
         """Stream the text result as an async iterable.
@@ -357,9 +399,20 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
                 Debouncing is particularly important for long structured responses to reduce the overhead of
                 performing validation as each token is received.
         """
-        async for text in self._stream_response.stream_text(delta=delta, debounce_by=debounce_by):
-            yield text
-        await self._marked_completed(self._stream_response.get())
+        if self._run_result is not None:  # pragma: no cover
+            # We can't really get here, as `_run_result` is only set in `run_stream` when `CallToolsNode` produces `DeferredToolRequests` output
+            # as a result of a tool function raising `CallDeferred` or `ApprovalRequired`.
+            # That'll change if we ever support something like `raise EndRun(output: OutputT)` where `OutputT` could be `str`.
+            if not isinstance(self._run_result.output, str):
+                raise exceptions.UserError('stream_text() can only be used with text responses')
+            yield self._run_result.output
+            await self._marked_completed()
+        elif self._stream_response is not None:
+            async for text in self._stream_response.stream_text(delta=delta, debounce_by=debounce_by):
+                yield text
+            await self._marked_completed(self._stream_response.get())
+        else:
+            raise ValueError('No stream response or run result provided')  # pragma: no cover
 
     @deprecated('`StreamedRunResult.stream_structured` is deprecated, use `stream_responses` instead.')
     async def stream_structured(
@@ -381,20 +434,34 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
         Returns:
             An async iterable of the structured response message and whether that is the last message.
         """
-        # if the message currently has any parts with content, yield before streaming
-        async for msg in self._stream_response.stream_responses(debounce_by=debounce_by):
-            yield msg, False
-
-        msg = self._stream_response.get()
-        yield msg, True
-
-        await self._marked_completed(msg)
+        if self._run_result is not None:
+            model_response = cast(_messages.ModelResponse, self.all_messages()[-1])
+            yield model_response, True
+            await self._marked_completed()
+        elif self._stream_response is not None:
+            # if the message currently has any parts with content, yield before streaming
+            async for msg in self._stream_response.stream_responses(debounce_by=debounce_by):
+                yield msg, False
+
+            msg = self._stream_response.get()
+            yield msg, True
+
+            await self._marked_completed(msg)
+        else:
+            raise ValueError('No stream response or run result provided')  # pragma: no cover
 
     async def get_output(self) -> OutputDataT:
         """Stream the whole response, validate and return it."""
-        output = await self._stream_response.get_output()
-        await self._marked_completed(self._stream_response.get())
-        return output
+        if self._run_result is not None:
+            output = self._run_result.output
+            await self._marked_completed()
+            return output
+        elif self._stream_response is not None:
+            output = await self._stream_response.get_output()
+            await self._marked_completed(self._stream_response.get())
+            return output
+        else:
+            raise ValueError('No stream response or run result provided')  # pragma: no cover
 
     def usage(self) -> RunUsage:
         """Return the usage of the whole run.
@@ -402,28 +469,45 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
         !!! note
             This won't return the full usage until the stream is finished.
         """
-        return self._stream_response.usage()
+        if self._run_result is not None:
+            return self._run_result.usage()
+        elif self._stream_response is not None:
+            return self._stream_response.usage()
+        else:
+            raise ValueError('No stream response or run result provided')  # pragma: no cover
 
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""
-        return self._stream_response.timestamp()
+        if self._run_result is not None:
+            return self._run_result.timestamp()
+        elif self._stream_response is not None:
+            return self._stream_response.timestamp()
+        else:
+            raise ValueError('No stream response or run result provided')  # pragma: no cover
 
     @deprecated('`validate_structured_output` is deprecated, use `validate_response_output` instead.')
     async def validate_structured_output(
         self, message: _messages.ModelResponse, *, allow_partial: bool = False
     ) -> OutputDataT:
-        return await self._stream_response.validate_response_output(message, allow_partial=allow_partial)
+        return await self.validate_response_output(message, allow_partial=allow_partial)
 
     async def validate_response_output(
         self, message: _messages.ModelResponse, *, allow_partial: bool = False
     ) -> OutputDataT:
         """Validate a structured result message."""
-        return await self._stream_response.validate_response_output(message, allow_partial=allow_partial)
+        if self._run_result is not None:
+            return self._run_result.output
+        elif self._stream_response is not None:
+            return await self._stream_response.validate_response_output(message, allow_partial=allow_partial)
+        else:
+            raise ValueError('No stream response or run result provided')  # pragma: no cover
 
-    async def _marked_completed(self, message: _messages.ModelResponse) -> None:
+    async def _marked_completed(self, message: _messages.ModelResponse | None = None) -> None:
         self.is_complete = True
-        self._all_messages.append(message)
-        await self._on_complete()
+        if message is not None:
+            self._all_messages.append(message)
+        if self._on_complete is not None:
+            await self._on_complete()
 
 
 @dataclass(repr=False)
@@ -432,8 +516,10 @@ class FinalResult(Generic[OutputDataT]):
 
     output: OutputDataT
     """The final result data."""
+
     tool_name: str | None = None
     """Name of the final output tool; `None` if the output came from unstructured text content."""
+
     tool_call_id: str | None = None
     """ID of the tool call that produced the final output; `None` if the output came from unstructured text content."""
 
@@ -454,9 +540,26 @@ def _get_usage_checking_stream_response(
 
         return _usage_checking_iterator()
     else:
-        # TODO: Use `return aiter(stream_response)` once we drop support for Python 3.9
-        async def _iterator():
-            async for item in stream_response:
-                yield item
+        return aiter(stream_response)
+
+
+def _get_deferred_tool_requests(
+    parts: Iterable[_messages.ModelResponsePart], tool_manager: ToolManager[AgentDepsT]
+) -> DeferredToolRequests | None:
+    """Get the deferred tool requests from the model response parts."""
+    approvals: list[_messages.ToolCallPart] = []
+    calls: list[_messages.ToolCallPart] = []
+
+    for part in parts:
+        if isinstance(part, _messages.ToolCallPart):
+            tool_def = tool_manager.get_tool_def(part.tool_name)
+            if tool_def is not None:  # pragma: no branch
+                if tool_def.kind == 'unapproved':
+                    approvals.append(part)
+                elif tool_def.kind == 'external':
+                    calls.append(part)
+
+    if not calls and not approvals:
+        return None
 
-        return _iterator()
+    return DeferredToolRequests(calls=calls, approvals=approvals)