pydantic-ai-slim 0.0.54__py3-none-any.whl → 0.1.0__py3-none-any.whl

pydantic_ai/result.py

@@ -1,43 +1,47 @@
 from __future__ import annotations as _annotations
 
+import warnings
 from collections.abc import AsyncIterable, AsyncIterator, Awaitable, Callable
 from copy import copy
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Generic, Union, cast
+from typing import TYPE_CHECKING, Generic, Union, cast
 
-from typing_extensions import TypeVar, assert_type
+from typing_extensions import TypeVar, assert_type, deprecated, overload
 
-from . import _result, _utils, exceptions, messages as _messages, models
+from . import _utils, exceptions, messages as _messages, models
 from .messages import AgentStreamEvent, FinalResultEvent
 from .tools import AgentDepsT, RunContext
 from .usage import Usage, UsageLimits
 
-__all__ = 'ResultDataT', 'ResultDataT_inv', 'ResultValidatorFunc'
+if TYPE_CHECKING:
+    from . import _output
+
+__all__ = 'OutputDataT', 'OutputDataT_inv', 'ToolOutput', 'OutputValidatorFunc'
 
 
 T = TypeVar('T')
 """An invariant TypeVar."""
-ResultDataT_inv = TypeVar('ResultDataT_inv', default=str)
+OutputDataT_inv = TypeVar('OutputDataT_inv', default=str)
 """
 An invariant type variable for the result data of a model.
 
-We need to use an invariant typevar for `ResultValidator` and `ResultValidatorFunc` because the result data type is used
-in both the input and output of a `ResultValidatorFunc`. This can theoretically lead to some issues assuming that types
-possessing ResultValidator's are covariant in the result data type, but in practice this is rarely an issue, and
+We need to use an invariant typevar for `OutputValidator` and `OutputValidatorFunc` because the output data type is used
+in both the input and output of a `OutputValidatorFunc`. This can theoretically lead to some issues assuming that types
+possessing OutputValidator's are covariant in the result data type, but in practice this is rarely an issue, and
 changing it would have negative consequences for the ergonomics of the library.
 
-At some point, it may make sense to change the input to ResultValidatorFunc to be `Any` or `object` as doing that would
+At some point, it may make sense to change the input to OutputValidatorFunc to be `Any` or `object` as doing that would
 resolve these potential variance issues.
 """
-ResultDataT = TypeVar('ResultDataT', default=str, covariant=True)
+OutputDataT = TypeVar('OutputDataT', default=str, covariant=True)
 """Covariant type variable for the result data type of a run."""
 
-ResultValidatorFunc = Union[
-    Callable[[RunContext[AgentDepsT], ResultDataT_inv], ResultDataT_inv],
-    Callable[[RunContext[AgentDepsT], ResultDataT_inv], Awaitable[ResultDataT_inv]],
-    Callable[[ResultDataT_inv], ResultDataT_inv],
-    Callable[[ResultDataT_inv], Awaitable[ResultDataT_inv]],
+OutputValidatorFunc = Union[
+    Callable[[RunContext[AgentDepsT], OutputDataT_inv], OutputDataT_inv],
+    Callable[[RunContext[AgentDepsT], OutputDataT_inv], Awaitable[OutputDataT_inv]],
+    Callable[[OutputDataT_inv], OutputDataT_inv],
+    Callable[[OutputDataT_inv], Awaitable[OutputDataT_inv]],
 ]
 """
 A function that always takes and returns the same type of data (which is the result type of an agent run), and:
@@ -45,15 +49,56 @@ A function that always takes and returns the same type of data (which is the res
 * may or may not take [`RunContext`][pydantic_ai.tools.RunContext] as a first argument
 * may or may not be async
 
-Usage `ResultValidatorFunc[AgentDepsT, T]`.
+Usage `OutputValidatorFunc[AgentDepsT, T]`.
 """
 
+DEFAULT_OUTPUT_TOOL_NAME = 'final_result'
+
+
+@dataclass(init=False)
+class ToolOutput(Generic[OutputDataT]):
+    """Marker class to use tools for structured outputs, and customize the tool."""
+
+    output_type: type[OutputDataT]
+    # TODO: Add `output_call` support, for calling a function to get the output
+    # output_call: Callable[..., OutputDataT] | None
+    name: str
+    description: str | None
+    max_retries: int | None
+    strict: bool | None
+
+    def __init__(
+        self,
+        *,
+        type_: type[OutputDataT],
+        # call: Callable[..., OutputDataT] | None = None,
+        name: str = 'final_result',
+        description: str | None = None,
+        max_retries: int | None = None,
+        strict: bool | None = None,
+    ):
+        self.output_type = type_
+        self.name = name
+        self.description = description
+        self.max_retries = max_retries
+        self.strict = strict
+
+        # TODO: add support for call and make type_ optional, with the following logic:
+        # if type_ is None and call is None:
+        #     raise ValueError('Either type_ or call must be provided')
+        # if call is not None:
+        #     if type_ is None:
+        #         type_ = get_type_hints(call).get('return')
+        #         if type_ is None:
+        #             raise ValueError('Unable to determine type_ from call signature; please provide it explicitly')
+        # self.output_call = call
+
 
 @dataclass
-class AgentStream(Generic[AgentDepsT, ResultDataT]):
+class AgentStream(Generic[AgentDepsT, OutputDataT]):
     _raw_stream_response: models.StreamedResponse
-    _result_schema: _result.ResultSchema[ResultDataT] | None
-    _result_validators: list[_result.ResultValidator[AgentDepsT, ResultDataT]]
+    _output_schema: _output.OutputSchema[OutputDataT] | None
+    _output_validators: list[_output.OutputValidator[AgentDepsT, OutputDataT]]
     _run_ctx: RunContext[AgentDepsT]
     _usage_limits: UsageLimits | None
 
@@ -64,7 +109,7 @@ class AgentStream(Generic[AgentDepsT, ResultDataT]):
     def __post_init__(self):
         self._initial_run_ctx_usage = copy(self._run_ctx.usage)
 
-    async def stream_output(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[ResultDataT]:
+    async def stream_output(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[OutputDataT]:
         """Asynchronously stream the (validated) agent outputs."""
         async for response in self.stream_responses(debounce_by=debounce_by):
             if self._final_result_event is not None:
@@ -96,32 +141,32 @@ class AgentStream(Generic[AgentDepsT, ResultDataT]):
         return self._initial_run_ctx_usage + self._raw_stream_response.usage()
 
     async def _validate_response(
-        self, message: _messages.ModelResponse, result_tool_name: str | None, *, allow_partial: bool = False
-    ) -> ResultDataT:
+        self, message: _messages.ModelResponse, output_tool_name: str | None, *, allow_partial: bool = False
+    ) -> OutputDataT:
         """Validate a structured result message."""
-        if self._result_schema is not None and result_tool_name is not None:
-            match = self._result_schema.find_named_tool(message.parts, result_tool_name)
+        if self._output_schema is not None and output_tool_name is not None:
+            match = self._output_schema.find_named_tool(message.parts, output_tool_name)
             if match is None:
                 raise exceptions.UnexpectedModelBehavior(
-                    f'Invalid response, unable to find tool: {self._result_schema.tool_names()}'
+                    f'Invalid response, unable to find tool: {self._output_schema.tool_names()}'
                 )
 
-            call, result_tool = match
-            result_data = result_tool.validate(call, allow_partial=allow_partial, wrap_validation_errors=False)
+            call, output_tool = match
+            result_data = output_tool.validate(call, allow_partial=allow_partial, wrap_validation_errors=False)
 
-            for validator in self._result_validators:
+            for validator in self._output_validators:
                 result_data = await validator.validate(result_data, call, self._run_ctx)
             return result_data
         else:
             text = '\n\n'.join(x.content for x in message.parts if isinstance(x, _messages.TextPart))
-            for validator in self._result_validators:
+            for validator in self._output_validators:
                 text = await validator.validate(
                     text,
                     None,
                     self._run_ctx,
                 )
-            # Since there is no result tool, we can assume that str is compatible with ResultDataT
-            return cast(ResultDataT, text)
+            # Since there is no output tool, we can assume that str is compatible with OutputDataT
+            return cast(OutputDataT, text)
 
     def __aiter__(self) -> AsyncIterator[AgentStreamEvent]:
         """Stream [`AgentStreamEvent`][pydantic_ai.messages.AgentStreamEvent]s.
@@ -134,20 +179,20 @@ class AgentStream(Generic[AgentDepsT, ResultDataT]):
             return self._agent_stream_iterator
 
         async def aiter():
-            result_schema = self._result_schema
-            allow_text_result = result_schema is None or result_schema.allow_text_result
+            output_schema = self._output_schema
+            allow_text_output = output_schema is None or output_schema.allow_text_output
 
             def _get_final_result_event(e: _messages.ModelResponseStreamEvent) -> _messages.FinalResultEvent | None:
                 """Return an appropriate FinalResultEvent if `e` corresponds to a part that will produce a final result."""
                 if isinstance(e, _messages.PartStartEvent):
                     new_part = e.part
                     if isinstance(new_part, _messages.ToolCallPart):
-                        if result_schema:
-                            for call, _ in result_schema.find_tool([new_part]):
+                        if output_schema:
+                            for call, _ in output_schema.find_tool([new_part]):
                                 return _messages.FinalResultEvent(
                                     tool_name=call.tool_name, tool_call_id=call.tool_call_id
                                 )
-                    elif allow_text_result:
+                    elif allow_text_output:
                         assert_type(e, _messages.PartStartEvent)
                         return _messages.FinalResultEvent(tool_name=None, tool_call_id=None)
 
@@ -171,7 +216,7 @@ class AgentStream(Generic[AgentDepsT, ResultDataT]):
 
 
 @dataclass
-class StreamedRunResult(Generic[AgentDepsT, ResultDataT]):
+class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
     """Result of a streamed run that returns structured data via a tool call."""
 
     _all_messages: list[_messages.ModelMessage]
@@ -179,10 +224,10 @@ class StreamedRunResult(Generic[AgentDepsT, ResultDataT]):
 
     _usage_limits: UsageLimits | None
     _stream_response: models.StreamedResponse
-    _result_schema: _result.ResultSchema[ResultDataT] | None
+    _output_schema: _output.OutputSchema[OutputDataT] | None
     _run_ctx: RunContext[AgentDepsT]
-    _result_validators: list[_result.ResultValidator[AgentDepsT, ResultDataT]]
-    _result_tool_name: str | None
+    _output_validators: list[_output.OutputValidator[AgentDepsT, OutputDataT]]
+    _output_tool_name: str | None
     _on_complete: Callable[[], Awaitable[None]]
 
     _initial_run_ctx_usage: Usage = field(init=False)
@@ -193,78 +238,118 @@ class StreamedRunResult(Generic[AgentDepsT, ResultDataT]):
     [`stream`][pydantic_ai.result.StreamedRunResult.stream],
     [`stream_text`][pydantic_ai.result.StreamedRunResult.stream_text],
     [`stream_structured`][pydantic_ai.result.StreamedRunResult.stream_structured] or
-    [`get_data`][pydantic_ai.result.StreamedRunResult.get_data] completes.
+    [`get_output`][pydantic_ai.result.StreamedRunResult.get_output] completes.
     """
 
     def __post_init__(self):
         self._initial_run_ctx_usage = copy(self._run_ctx.usage)
 
-    def all_messages(self, *, result_tool_return_content: str | None = None) -> list[_messages.ModelMessage]:
+    @overload
+    def all_messages(self, *, output_tool_return_content: str | None = None) -> list[_messages.ModelMessage]: ...
+
+    @overload
+    @deprecated('`result_tool_return_content` is deprecated, use `output_tool_return_content` instead.')
+    def all_messages(self, *, result_tool_return_content: str | None = None) -> list[_messages.ModelMessage]: ...
+
+    def all_messages(
+        self, *, output_tool_return_content: str | None = None, result_tool_return_content: str | None = None
+    ) -> list[_messages.ModelMessage]:
         """Return the history of _messages.
 
         Args:
-            result_tool_return_content: The return content of the tool call to set in the last message.
-                This provides a convenient way to modify the content of the result tool call if you want to continue
-                the conversation and want to set the response to the result tool call. If `None`, the last message will
+            output_tool_return_content: The return content of the tool call to set in the last message.
+                This provides a convenient way to modify the content of the output tool call if you want to continue
+                the conversation and want to set the response to the output tool call. If `None`, the last message will
                 not be modified.
+            result_tool_return_content: deprecated, use `output_tool_return_content` instead.
 
         Returns:
             List of messages.
         """
         # this is a method to be consistent with the other methods
-        if result_tool_return_content is not None:
-            raise NotImplementedError('Setting result tool return content is not supported for this result type.')
+        content = coalesce_deprecated_return_content(output_tool_return_content, result_tool_return_content)
+        if content is not None:
+            raise NotImplementedError('Setting output tool return content is not supported for this result type.')
         return self._all_messages
 
-    def all_messages_json(self, *, result_tool_return_content: str | None = None) -> bytes:
+    @overload
+    def all_messages_json(self, *, output_tool_return_content: str | None = None) -> bytes: ...
+
+    @overload
+    @deprecated('`result_tool_return_content` is deprecated, use `output_tool_return_content` instead.')
+    def all_messages_json(self, *, result_tool_return_content: str | None = None) -> bytes: ...
+
+    def all_messages_json(
+        self, *, output_tool_return_content: str | None = None, result_tool_return_content: str | None = None
+    ) -> bytes:  # pragma: no cover
         """Return all messages from [`all_messages`][pydantic_ai.result.StreamedRunResult.all_messages] as JSON bytes.
 
         Args:
-            result_tool_return_content: The return content of the tool call to set in the last message.
-                This provides a convenient way to modify the content of the result tool call if you want to continue
-                the conversation and want to set the response to the result tool call. If `None`, the last message will
+            output_tool_return_content: The return content of the tool call to set in the last message.
+                This provides a convenient way to modify the content of the output tool call if you want to continue
+                the conversation and want to set the response to the output tool call. If `None`, the last message will
                 not be modified.
+            result_tool_return_content: deprecated, use `output_tool_return_content` instead.
 
         Returns:
             JSON bytes representing the messages.
         """
-        return _messages.ModelMessagesTypeAdapter.dump_json(
-            self.all_messages(result_tool_return_content=result_tool_return_content)
-        )
+        content = coalesce_deprecated_return_content(output_tool_return_content, result_tool_return_content)
+        return _messages.ModelMessagesTypeAdapter.dump_json(self.all_messages(output_tool_return_content=content))
+
+    @overload
+    def new_messages(self, *, output_tool_return_content: str | None = None) -> list[_messages.ModelMessage]: ...
 
-    def new_messages(self, *, result_tool_return_content: str | None = None) -> list[_messages.ModelMessage]:
+    @overload
+    @deprecated('`result_tool_return_content` is deprecated, use `output_tool_return_content` instead.')
+    def new_messages(self, *, output_tool_return_content: str | None = None) -> list[_messages.ModelMessage]: ...
+
+    def new_messages(
+        self, *, output_tool_return_content: str | None = None, result_tool_return_content: str | None = None
+    ) -> list[_messages.ModelMessage]:  # pragma: no cover
         """Return new messages associated with this run.
 
         Messages from older runs are excluded.
 
         Args:
-            result_tool_return_content: The return content of the tool call to set in the last message.
-                This provides a convenient way to modify the content of the result tool call if you want to continue
-                the conversation and want to set the response to the result tool call. If `None`, the last message will
+            output_tool_return_content: The return content of the tool call to set in the last message.
+                This provides a convenient way to modify the content of the output tool call if you want to continue
+                the conversation and want to set the response to the output tool call. If `None`, the last message will
                 not be modified.
+            result_tool_return_content: deprecated, use `output_tool_return_content` instead.
 
         Returns:
             List of new messages.
         """
-        return self.all_messages(result_tool_return_content=result_tool_return_content)[self._new_message_index :]
+        content = coalesce_deprecated_return_content(output_tool_return_content, result_tool_return_content)
+        return self.all_messages(output_tool_return_content=content)[self._new_message_index :]
+
+    @overload
+    def new_messages_json(self, *, output_tool_return_content: str | None = None) -> bytes: ...
 
-    def new_messages_json(self, *, result_tool_return_content: str | None = None) -> bytes:
+    @overload
+    @deprecated('`result_tool_return_content` is deprecated, use `output_tool_return_content` instead.')
+    def new_messages_json(self, *, result_tool_return_content: str | None = None) -> bytes: ...
+
+    def new_messages_json(
+        self, *, output_tool_return_content: str | None = None, result_tool_return_content: str | None = None
+    ) -> bytes:  # pragma: no cover
         """Return new messages from [`new_messages`][pydantic_ai.result.StreamedRunResult.new_messages] as JSON bytes.
 
         Args:
-            result_tool_return_content: The return content of the tool call to set in the last message.
-                This provides a convenient way to modify the content of the result tool call if you want to continue
-                the conversation and want to set the response to the result tool call. If `None`, the last message will
+            output_tool_return_content: The return content of the tool call to set in the last message.
+                This provides a convenient way to modify the content of the output tool call if you want to continue
+                the conversation and want to set the response to the output tool call. If `None`, the last message will
                 not be modified.
+            result_tool_return_content: deprecated, use `output_tool_return_content` instead.
 
         Returns:
             JSON bytes representing the new messages.
         """
-        return _messages.ModelMessagesTypeAdapter.dump_json(
-            self.new_messages(result_tool_return_content=result_tool_return_content)
-        )
+        content = coalesce_deprecated_return_content(output_tool_return_content, result_tool_return_content)
+        return _messages.ModelMessagesTypeAdapter.dump_json(self.new_messages(output_tool_return_content=content))
 
-    async def stream(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[ResultDataT]:
+    async def stream(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[OutputDataT]:
         """Stream the response as an async iterable.
 
         The pydantic validator for structured data will be called in
@@ -280,8 +365,7 @@ class StreamedRunResult(Generic[AgentDepsT, ResultDataT]):
             An async iterable of the response data.
         """
         async for structured_message, is_last in self.stream_structured(debounce_by=debounce_by):
-            result = await self.validate_structured_result(structured_message, allow_partial=not is_last)
-            yield result
+            yield await self.validate_structured_output(structured_message, allow_partial=not is_last)
 
     async def stream_text(self, *, delta: bool = False, debounce_by: float | None = 0.1) -> AsyncIterator[str]:
         """Stream the text result as an async iterable.
@@ -296,7 +380,7 @@ class StreamedRunResult(Generic[AgentDepsT, ResultDataT]):
                 Debouncing is particularly important for long structured responses to reduce the overhead of
                 performing validation as each token is received.
         """
-        if self._result_schema and not self._result_schema.allow_text_result:
+        if self._output_schema and not self._output_schema.allow_text_output:
             raise exceptions.UserError('stream_text() can only be used with text responses')
 
         if delta:
@@ -304,7 +388,7 @@ class StreamedRunResult(Generic[AgentDepsT, ResultDataT]):
                 yield text
         else:
             async for text in self._stream_response_text(delta=delta, debounce_by=debounce_by):
-                combined_validated_text = await self._validate_text_result(text)
+                combined_validated_text = await self._validate_text_output(text)
                 yield combined_validated_text
         await self._marked_completed(self._stream_response.get())
 
@@ -336,7 +420,7 @@ class StreamedRunResult(Generic[AgentDepsT, ResultDataT]):
 
         await self._marked_completed(msg)
 
-    async def get_data(self) -> ResultDataT:
+    async def get_output(self) -> OutputDataT:
         """Stream the whole response, validate and return it."""
         usage_checking_stream = _get_usage_checking_stream_response(
             self._stream_response, self._usage_limits, self.usage
@@ -346,7 +430,11 @@ class StreamedRunResult(Generic[AgentDepsT, ResultDataT]):
             pass
         message = self._stream_response.get()
         await self._marked_completed(message)
-        return await self.validate_structured_result(message)
+        return await self.validate_structured_output(message)
+
+    @deprecated('`get_data` is deprecated, use `get_output` instead.')
+    async def get_data(self) -> OutputDataT:
+        return await self.get_output()
 
     def usage(self) -> Usage:
         """Return the usage of the whole run.
@@ -360,36 +448,42 @@ class StreamedRunResult(Generic[AgentDepsT, ResultDataT]):
         """Get the timestamp of the response."""
         return self._stream_response.timestamp
 
+    @deprecated('`validate_structured_result` is deprecated, use `validate_structured_output` instead.')
     async def validate_structured_result(
         self, message: _messages.ModelResponse, *, allow_partial: bool = False
-    ) -> ResultDataT:
+    ) -> OutputDataT:
+        return await self.validate_structured_output(message, allow_partial=allow_partial)
+
+    async def validate_structured_output(
+        self, message: _messages.ModelResponse, *, allow_partial: bool = False
+    ) -> OutputDataT:
         """Validate a structured result message."""
-        if self._result_schema is not None and self._result_tool_name is not None:
-            match = self._result_schema.find_named_tool(message.parts, self._result_tool_name)
+        if self._output_schema is not None and self._output_tool_name is not None:
+            match = self._output_schema.find_named_tool(message.parts, self._output_tool_name)
             if match is None:
                 raise exceptions.UnexpectedModelBehavior(
-                    f'Invalid response, unable to find tool: {self._result_schema.tool_names()}'
+                    f'Invalid response, unable to find tool: {self._output_schema.tool_names()}'
                 )
 
-            call, result_tool = match
-            result_data = result_tool.validate(call, allow_partial=allow_partial, wrap_validation_errors=False)
+            call, output_tool = match
+            result_data = output_tool.validate(call, allow_partial=allow_partial, wrap_validation_errors=False)
 
-            for validator in self._result_validators:
+            for validator in self._output_validators:
                 result_data = await validator.validate(result_data, call, self._run_ctx)
             return result_data
         else:
             text = '\n\n'.join(x.content for x in message.parts if isinstance(x, _messages.TextPart))
-            for validator in self._result_validators:
+            for validator in self._output_validators:
                 text = await validator.validate(
                     text,
                     None,
                     self._run_ctx,
                 )
-            # Since there is no result tool, we can assume that str is compatible with ResultDataT
-            return cast(ResultDataT, text)
+            # Since there is no output tool, we can assume that str is compatible with OutputDataT
+            return cast(OutputDataT, text)
 
-    async def _validate_text_result(self, text: str) -> str:
-        for validator in self._result_validators:
+    async def _validate_text_output(self, text: str) -> str:
+        for validator in self._output_validators:
             text = await validator.validate(
                 text,
                 None,
@@ -459,15 +553,20 @@ class StreamedRunResult(Generic[AgentDepsT, ResultDataT]):
 
 
 @dataclass
-class FinalResult(Generic[ResultDataT]):
-    """Marker class storing the final result of an agent run and associated metadata."""
+class FinalResult(Generic[OutputDataT]):
+    """Marker class storing the final output of an agent run and associated metadata."""
 
-    data: ResultDataT
+    output: OutputDataT
     """The final result data."""
     tool_name: str | None
-    """Name of the final result tool; `None` if the result came from unstructured text content."""
+    """Name of the final output tool; `None` if the output came from unstructured text content."""
     tool_call_id: str | None
-    """ID of the tool call that produced the final result; `None` if the result came from unstructured text content."""
+    """ID of the tool call that produced the final output; `None` if the output came from unstructured text content."""
+
+    @property
+    @deprecated('`data` is deprecated, use `output` instead.')
+    def data(self) -> OutputDataT:
+        return self.output
 
 
 def _get_usage_checking_stream_response(
@@ -485,3 +584,17 @@ def _get_usage_checking_stream_response(
         return _usage_checking_iterator()
     else:
         return stream_response
+
+
+def coalesce_deprecated_return_content(
+    output_tool_return_content: T | None, result_tool_return_content: T | None
+) -> T | None:
+    """Return the first non-None value."""
+    if output_tool_return_content is None:
+        if result_tool_return_content is not None:  # pragma: no cover
+            warnings.warn(
+                '`result_tool_return_content` is deprecated, use `output_tool_return_content` instead.',
+                DeprecationWarning,
+            )
+        return result_tool_return_content
+    return output_tool_return_content

pydantic_ai/tools.py

@@ -411,7 +411,7 @@ With PEP-728 this should be a TypedDict with `type: Literal['object']`, and `ext
 class ToolDefinition:
     """Definition of a tool passed to a model.
 
-    This is used for both function tools and result tools.
+    This is used for both function tools and output tools.
     """
 
     name: str
@@ -424,9 +424,9 @@ class ToolDefinition:
     """The JSON schema for the tool's parameters."""
 
     outer_typed_dict_key: str | None = None
-    """The key in the outer [TypedDict] that wraps a result tool.
+    """The key in the outer [TypedDict] that wraps an output tool.
 
-    This will only be set for result tools which don't have an `object` JSON schema.
+    This will only be set for output tools which don't have an `object` JSON schema.
     """
 
     strict: bool | None = None

{pydantic_ai_slim-0.0.54.dist-info → pydantic_ai_slim-0.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.54
+Version: 0.1.0
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -29,13 +29,13 @@ Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.0.54
+Requires-Dist: pydantic-graph==0.1.0
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.49.0; extra == 'anthropic'
 Provides-Extra: bedrock
-Requires-Dist: boto3>=1.34.116; extra == 'bedrock'
+Requires-Dist: boto3>=1.35.74; extra == 'bedrock'
 Provides-Extra: cli
 Requires-Dist: argcomplete>=3.5.0; extra == 'cli'
 Requires-Dist: prompt-toolkit>=3; extra == 'cli'
@@ -45,7 +45,7 @@ Requires-Dist: cohere>=5.13.11; (platform_system != 'Emscripten') and extra == '
 Provides-Extra: duckduckgo
 Requires-Dist: duckduckgo-search>=7.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.0.54; extra == 'evals'
+Requires-Dist: pydantic-evals==0.1.0; extra == 'evals'
 Provides-Extra: groq
 Requires-Dist: groq>=0.15.0; extra == 'groq'
 Provides-Extra: logfire
@@ -55,7 +55,7 @@ Requires-Dist: mcp>=1.4.1; (python_version >= '3.10') and extra == 'mcp'
 Provides-Extra: mistral
 Requires-Dist: mistralai>=1.2.5; extra == 'mistral'
 Provides-Extra: openai
-Requires-Dist: openai>=1.67.0; extra == 'openai'
+Requires-Dist: openai>=1.74.0; extra == 'openai'
 Provides-Extra: tavily
 Requires-Dist: tavily-python>=0.5.0; extra == 'tavily'
 Provides-Extra: vertexai

pydantic_ai_slim-0.1.0.dist-info/RECORD

@@ -0,0 +1,53 @@
+pydantic_ai/__init__.py,sha256=5flxyMQJVrHRMQ3MYaZf1el2ctNs0JmPClKbw2Q-Lsk,1160
+pydantic_ai/__main__.py,sha256=AW8FzscUWPFtIrQBG0QExLxTQehKtt5FnFVnOT200OE,122
+pydantic_ai/_agent_graph.py,sha256=9REW7Al14aL34Z6iL8n8wvxXVBSH_dliU4Yl5ExlJK4,33308
+pydantic_ai/_cli.py,sha256=j3uSu5lZMNKb876HHMHwVZc1nzJPn6NER5ysrDMFrvo,10730
+pydantic_ai/_griffe.py,sha256=Sf_DisE9k2TA0VFeVIK2nf1oOct5MygW86PBCACJkFA,5244
+pydantic_ai/_output.py,sha256=w_kBc5Lx5AmI0APbohxxYgpFd5VAwh6K0IjP7QIOu9U,11209
+pydantic_ai/_parts_manager.py,sha256=HIi6eth7z2g0tOn6iQYc633xMqy4d_xZ8vwka8J8150,12016
+pydantic_ai/_pydantic.py,sha256=12hX5hON88meO1QxbWrEPXSvr6RTNgr6ubKY6KRwab4,8890
+pydantic_ai/_system_prompt.py,sha256=602c2jyle2R_SesOrITBDETZqsLk4BZ8Cbo8yEhmx04,1120
+pydantic_ai/_utils.py,sha256=t0P9DFX3MulMyoqyZDRinmLCOB1q6rvRnMRqQP2MUpI,10585
+pydantic_ai/agent.py,sha256=jq8ZPlsM-P3gqP-R59W47eA9xKNep0CyiF5_rpQ6ffc,86354
+pydantic_ai/exceptions.py,sha256=gvbFsFkAzSXOo_d1nfjy09kDHUGv1j5q70Uk-wKYGi8,3167
+pydantic_ai/format_as_xml.py,sha256=IINfh1evWDphGahqHNLBArB5dQ4NIqS3S-kru35ztGg,372
+pydantic_ai/format_prompt.py,sha256=qdKep95Sjlr7u1-qag4JwPbjoURbG0GbeU_l5ODTNw4,4466
+pydantic_ai/mcp.py,sha256=wlu3GCdcjgsag75cyuTron1kdTQOWkM0j5hNJxf0JkE,8242
+pydantic_ai/messages.py,sha256=TUfs1AsogZu1YkoJjKwjbKCcaaDg-0gcbIj_wVLUW0E,29748
+pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_ai/result.py,sha256=DgoUd0LqNd9DWPab6iwculKYvZ5JZHuGvToj0kkibvs,27625
+pydantic_ai/settings.py,sha256=RMQxjsJqyiExxtxCr_L3avojAiANdFE0ME1eitLrjhk,3242
+pydantic_ai/tools.py,sha256=YIdB1CuyoBcd2oG9NvL66nwpCBR3ii6I4KqMoThHiAE,16915
+pydantic_ai/usage.py,sha256=9sqoIv_RVVUhKXQScTDqUJc074gifsuSzc9_NOt7C3g,5394
+pydantic_ai/common_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_ai/common_tools/duckduckgo.py,sha256=Iw8Dl2YQ28S483mzfa8CXs-dc-ujS8un085R2O6oOEw,2241
+pydantic_ai/common_tools/tavily.py,sha256=h8deBDrpG-8BGzydM_zXs7z1ASrhdVvUxL4-CAbncBo,2589
+pydantic_ai/models/__init__.py,sha256=R1YV2gE8l_EDlnmLhfxhdojF6gjGWMC14ocRrxiz5XM,19699
+pydantic_ai/models/_json_schema.py,sha256=5xqysWdE1uGwrztVzhkOJ8uSKgKnONBe88004ufbWqM,6319
+pydantic_ai/models/anthropic.py,sha256=gkeeIEqI0dk72EIL9zYRtvBd9ipDvT0v1-AcdMF_l20,20272
+pydantic_ai/models/bedrock.py,sha256=KSmukt2jeKb6uABVR5BRz5Sm7YGYSh56NF0Ftzk11UI,24977
+pydantic_ai/models/cohere.py,sha256=0clDIXPETo0pjfNgtI-sWqjjZWPkHqFalag_nN3HSNI,11685
+pydantic_ai/models/fallback.py,sha256=sKHyQ1P6zjWORjWgbuhaxyntOfQyDCS8km8FMrlNy3U,4998
+pydantic_ai/models/function.py,sha256=FJvTMwT7p8I_h14ZrudLAI5mmbXxF8AX-Nhz8LXy5U0,11373
+pydantic_ai/models/gemini.py,sha256=CdhlEpyyDUSEfbx82juJxP0Us0GotNnCQ-0W-RfQD6o,34330
+pydantic_ai/models/groq.py,sha256=UNyZPqmHRZ9LgtMhV5f9QI1txZ7TCMyu8Abn1ojk5lE,17034
+pydantic_ai/models/instrumented.py,sha256=_5bV2kkwCix5C25cCAblbhZy1wiKaYBUStmHso4T22g,11163
+pydantic_ai/models/mistral.py,sha256=sNujNLxpPFZA_vrh-74rDRl2syE1QTgILm6hMZNR4SI,28226
+pydantic_ai/models/openai.py,sha256=tfOOtShuPVrxgwUIg4p59Sak6gC-TEpHyEd2idrvDuc,45759
+pydantic_ai/models/test.py,sha256=_Fd7oKNA2p_1zXBMvQStnizGlx-ii-zisJx1nIEZn7c,16973
+pydantic_ai/models/wrapper.py,sha256=8wm4RF-MRZOxRVLefwMsxToopCX5Y4Xq2-Ugs5MtCK4,1710
+pydantic_ai/providers/__init__.py,sha256=lLlHq6B8qmu6Ag5biaZmJGDKELO46KjwP7-CDrz_T4Y,2592
+pydantic_ai/providers/anthropic.py,sha256=0WzWEDseBaJ5eyEatvnDXBtDZKA9-od4BuPZn9NoTPw,2812
+pydantic_ai/providers/azure.py,sha256=2tAE-bLjXY-DvVrVc4ilQe15HhoHP9neAbvwCaCx_uo,4225
+pydantic_ai/providers/bedrock.py,sha256=BV1Zi4asU4Bmcv4t7VRIy2U44Tk_Jrf26x8_mPJiYHQ,3216
+pydantic_ai/providers/cohere.py,sha256=WOFZCllgVbWciF4nNkG3pCqw4poy57VEGyux2mVntbQ,2667
+pydantic_ai/providers/deepseek.py,sha256=_5JPzDGWsyVyTBX-yYYdy5aZwUOWNCVgoWI-UoBamms,2193
+pydantic_ai/providers/google_gla.py,sha256=MJM7aRZRdP4kFlNg0ZHgC95O0wH02OQgbNiDQeK9fZo,1600
+pydantic_ai/providers/google_vertex.py,sha256=WAwPxKTARVzs8DFs2veEUOJSur0krDOo9-JWRHvfHew,9135
+pydantic_ai/providers/groq.py,sha256=DoY6qkfhuemuKB5JXhUkqG-3t1HQkxwSXoE_kHQIAK0,2788
+pydantic_ai/providers/mistral.py,sha256=fcR1uSwORo0jtevX7-wOjvcfT8ojMAaKY81uN5uYymM,2661
+pydantic_ai/providers/openai.py,sha256=ePF-QWwLkGkSE5w245gTTDVR3VoTIUqFoIhQ0TAoUiA,2866
+pydantic_ai_slim-0.1.0.dist-info/METADATA,sha256=4R4qDPDb8_150bXpKlHbSyO_uIrQVFOud2BgWCLS61k,3551
+pydantic_ai_slim-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.1.0.dist-info/entry_points.txt,sha256=KxQSmlMS8GMTkwTsl4_q9a5nJvBjj3HWeXx688wLrKg,45
+pydantic_ai_slim-0.1.0.dist-info/RECORD,,