pydantic-ai-slim 0.0.18__py3-none-any.whl → 0.0.19__py3-none-any.whl

pydantic_ai/models/test.py

@@ -2,21 +2,22 @@ from __future__ import annotations as _annotations
 
 import re
 import string
-from collections.abc import AsyncIterator, Iterable, Iterator
+from collections.abc import AsyncIterator, Iterable
 from contextlib import asynccontextmanager
-from dataclasses import dataclass, field
+from dataclasses import InitVar, dataclass, field
 from datetime import date, datetime, timedelta
 from typing import Any, Literal
 
 import pydantic_core
-from typing_extensions import assert_never
 
 from .. import _utils
 from ..messages import (
+    ArgsJson,
     ModelMessage,
     ModelRequest,
     ModelResponse,
     ModelResponsePart,
+    ModelResponseStreamEvent,
     RetryPromptPart,
     TextPart,
     ToolCallPart,
@@ -27,12 +28,10 @@ from ..settings import ModelSettings
 from ..tools import ToolDefinition
 from . import (
     AgentModel,
-    EitherStreamedResponse,
     Model,
-    StreamStructuredResponse,
-    StreamTextResponse,
+    StreamedResponse,
 )
-from .function import _estimate_string_usage, _estimate_usage  # pyright: ignore[reportPrivateUsage]
+from .function import _estimate_string_tokens, _estimate_usage  # pyright: ignore[reportPrivateUsage]
 
 
 @dataclass
@@ -141,25 +140,9 @@ class TestAgentModel(AgentModel):
     @asynccontextmanager
     async def request_stream(
         self, messages: list[ModelMessage], model_settings: ModelSettings | None
-    ) -> AsyncIterator[EitherStreamedResponse]:
-        msg = self._request(messages, model_settings)
-        usage = _estimate_usage(messages)
-
-        # TODO: Rework this once we make StreamTextResponse more general
-        texts: list[str] = []
-        tool_calls: list[ToolCallPart] = []
-        for item in msg.parts:
-            if isinstance(item, TextPart):
-                texts.append(item.content)
-            elif isinstance(item, ToolCallPart):
-                tool_calls.append(item)
-            else:
-                assert_never(item)
-
-        if texts:
-            yield TestStreamTextResponse('\n\n'.join(texts), usage)
-        else:
-            yield TestStreamStructuredResponse(msg, usage)
+    ) -> AsyncIterator[StreamedResponse]:
+        model_response = self._request(messages, model_settings)
+        yield TestStreamedResponse(model_response, messages)
 
     def gen_tool_args(self, tool_def: ToolDefinition) -> Any:
         return _JsonSchemaTestData(tool_def.parameters_json_schema, self.seed).generate()
@@ -223,58 +206,37 @@ class TestAgentModel(AgentModel):
 
 
 @dataclass
-class TestStreamTextResponse(StreamTextResponse):
-    """A text response that streams test data."""
-
-    _text: str
-    _usage: Usage
-    _iter: Iterator[str] = field(init=False)
-    _timestamp: datetime = field(default_factory=_utils.now_utc)
-    _buffer: list[str] = field(default_factory=list, init=False)
-
-    def __post_init__(self):
-        *words, last_word = self._text.split(' ')
-        words = [f'{word} ' for word in words]
-        words.append(last_word)
-        if len(words) == 1 and len(self._text) > 2:
-            mid = len(self._text) // 2
-            words = [self._text[:mid], self._text[mid:]]
-        self._iter = iter(words)
-
-    async def __anext__(self) -> None:
-        next_str = _utils.sync_anext(self._iter)
-        response_tokens = _estimate_string_usage(next_str)
-        self._usage += Usage(response_tokens=response_tokens, total_tokens=response_tokens)
-        self._buffer.append(next_str)
-
-    def get(self, *, final: bool = False) -> Iterable[str]:
-        yield from self._buffer
-        self._buffer.clear()
-
-    def usage(self) -> Usage:
-        return self._usage
-
-    def timestamp(self) -> datetime:
-        return self._timestamp
-
-
-@dataclass
-class TestStreamStructuredResponse(StreamStructuredResponse):
+class TestStreamedResponse(StreamedResponse):
     """A structured response that streams test data."""
 
     _structured_response: ModelResponse
-    _usage: Usage
-    _iter: Iterator[None] = field(default_factory=lambda: iter([None]))
-    _timestamp: datetime = field(default_factory=_utils.now_utc, init=False)
-
-    async def __anext__(self) -> None:
-        return _utils.sync_anext(self._iter)
+    _messages: InitVar[Iterable[ModelMessage]]
 
-    def get(self, *, final: bool = False) -> ModelResponse:
-        return self._structured_response
+    _timestamp: datetime = field(default_factory=_utils.now_utc, init=False)
 
-    def usage(self) -> Usage:
-        return self._usage
+    def __post_init__(self, _messages: Iterable[ModelMessage]):
+        self._usage = _estimate_usage(_messages)
+
+    async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
+        for i, part in enumerate(self._structured_response.parts):
+            if isinstance(part, TextPart):
+                text = part.content
+                *words, last_word = text.split(' ')
+                words = [f'{word} ' for word in words]
+                words.append(last_word)
+                if len(words) == 1 and len(text) > 2:
+                    mid = len(text) // 2
+                    words = [text[:mid], text[mid:]]
+                self._usage += _get_string_usage('')
+                yield self._parts_manager.handle_text_delta(vendor_part_id=i, content='')
+                for word in words:
+                    self._usage += _get_string_usage(word)
+                    yield self._parts_manager.handle_text_delta(vendor_part_id=i, content=word)
+            else:
+                args = part.args.args_json if isinstance(part.args, ArgsJson) else part.args.args_dict
+                yield self._parts_manager.handle_tool_call_part(
+                    vendor_part_id=i, tool_name=part.tool_name, args=args, tool_call_id=part.tool_call_id
+                )
 
     def timestamp(self) -> datetime:
         return self._timestamp
@@ -434,3 +396,8 @@ class _JsonSchemaTestData:
             rem //= chars
         s += _chars[self.seed % chars]
         return s
+
+
+def _get_string_usage(text: str) -> Usage:
+    response_tokens = _estimate_string_tokens(text)
+    return Usage(response_tokens=response_tokens, total_tokens=response_tokens)

pydantic_ai/result.py

@@ -1,7 +1,7 @@
 from __future__ import annotations as _annotations
 
 from abc import ABC, abstractmethod
-from collections.abc import AsyncIterator, Awaitable, Callable
+from collections.abc import AsyncIterable, AsyncIterator, Awaitable, Callable
 from copy import deepcopy
 from dataclasses import dataclass, field
 from datetime import datetime
@@ -169,7 +169,7 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
     """Result of a streamed run that returns structured data via a tool call."""
 
     _usage_limits: UsageLimits | None
-    _stream_response: models.EitherStreamedResponse
+    _stream_response: models.StreamedResponse
     _result_schema: _result.ResultSchema[ResultData] | None
     _run_ctx: RunContext[AgentDeps]
     _result_validators: list[_result.ResultValidator[AgentDeps, ResultData]]
@@ -200,20 +200,13 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
         Returns:
             An async iterable of the response data.
         """
-        if isinstance(self._stream_response, models.StreamTextResponse):
-            async for text in self.stream_text(debounce_by=debounce_by):
-                yield cast(ResultData, text)
-        else:
-            async for structured_message, is_last in self.stream_structured(debounce_by=debounce_by):
-                yield await self.validate_structured_result(structured_message, allow_partial=not is_last)
+        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
 
     async def stream_text(self, *, delta: bool = False, debounce_by: float | None = 0.1) -> AsyncIterator[str]:
         """Stream the text result as an async iterable.
 
-        !!! note
-            This method will fail if the response is structured,
-            e.g. if [`is_structured`][pydantic_ai.result.StreamedRunResult.is_structured] returns `True`.
-
         !!! note
             Result validators will NOT be called on the text result if `delta=True`.
 
@@ -224,54 +217,65 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
                 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:
+            raise exceptions.UserError('stream_text() can only be used with text responses')
+
         usage_checking_stream = _get_usage_checking_stream_response(
             self._stream_response, self._usage_limits, self.usage
         )
 
+        # Define a "merged" version of the iterator that will yield items that have already been retrieved
+        # and items that we receive while streaming. We define a dedicated async iterator for this so we can
+        # pass the combined stream to the group_by_temporal function within `_stream_text_deltas` below.
+        async def _stream_text_deltas_ungrouped() -> AsyncIterator[tuple[str, int]]:
+            # if the response currently has any parts with content, yield those before streaming
+            msg = self._stream_response.get()
+            for i, part in enumerate(msg.parts):
+                if isinstance(part, _messages.TextPart) and part.content:
+                    yield part.content, i
+
+            async for event in usage_checking_stream:
+                if (
+                    isinstance(event, _messages.PartStartEvent)
+                    and isinstance(event.part, _messages.TextPart)
+                    and event.part.content
+                ):
+                    yield event.part.content, event.index
+                elif (
+                    isinstance(event, _messages.PartDeltaEvent)
+                    and isinstance(event.delta, _messages.TextPartDelta)
+                    and event.delta.content_delta
+                ):
+                    yield event.delta.content_delta, event.index
+
+        async def _stream_text_deltas() -> AsyncIterator[str]:
+            async with _utils.group_by_temporal(_stream_text_deltas_ungrouped(), debounce_by) as group_iter:
+                async for items in group_iter:
+                    yield ''.join([content for content, _ in items])
+
         with _logfire.span('response stream text') as lf_span:
-            if isinstance(self._stream_response, models.StreamStructuredResponse):
-                raise exceptions.UserError('stream_text() can only be used with text responses')
             if delta:
-                async with _utils.group_by_temporal(usage_checking_stream, debounce_by) as group_iter:
-                    async for _ in group_iter:
-                        yield ''.join(self._stream_response.get())
-                final_delta = ''.join(self._stream_response.get(final=True))
-                if final_delta:
-                    yield final_delta
+                async for text in _stream_text_deltas():
+                    yield text
             else:
                 # a quick benchmark shows it's faster to build up a string with concat when we're
                 # yielding at each step
-                chunks: list[str] = []
-                combined = ''
-                async with _utils.group_by_temporal(usage_checking_stream, debounce_by) as group_iter:
-                    async for _ in group_iter:
-                        new = False
-                        for chunk in self._stream_response.get():
-                            chunks.append(chunk)
-                            new = True
-                        if new:
-                            combined = await self._validate_text_result(''.join(chunks))
-                            yield combined
-
-                new = False
-                for chunk in self._stream_response.get(final=True):
-                    chunks.append(chunk)
-                    new = True
-                if new:
-                    combined = await self._validate_text_result(''.join(chunks))
-                    yield combined
-                lf_span.set_attribute('combined_text', combined)
-                await self._marked_completed(_messages.ModelResponse.from_text(combined))
+                deltas: list[str] = []
+                combined_validated_text = ''
+                async for text in _stream_text_deltas():
+                    deltas.append(text)
+                    combined_text = ''.join(deltas)
+                    combined_validated_text = await self._validate_text_result(combined_text)
+                    yield combined_validated_text
+
+                lf_span.set_attribute('combined_text', combined_validated_text)
+                await self._marked_completed(_messages.ModelResponse.from_text(combined_validated_text))
 
     async def stream_structured(
         self, *, debounce_by: float | None = 0.1
     ) -> AsyncIterator[tuple[_messages.ModelResponse, bool]]:
         """Stream the response as an async iterable of Structured LLM Messages.
 
-        !!! note
-            This method will fail if the response is text,
-            e.g. if [`is_structured`][pydantic_ai.result.StreamedRunResult.is_structured] returns `False`.
-
         Args:
             debounce_by: by how much (if at all) to debounce/group the response chunks by. `None` means no debouncing.
                 Debouncing is particularly important for long structured responses to reduce the overhead of
@@ -285,24 +289,20 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
         )
 
         with _logfire.span('response stream structured') as lf_span:
-            if isinstance(self._stream_response, models.StreamTextResponse):
-                raise exceptions.UserError('stream_structured() can only be used with structured responses')
-            else:
-                # we should already have a message at this point, yield that first if it has any content
+            # if the message currently has any parts with content, yield before streaming
+            msg = self._stream_response.get()
+            for part in msg.parts:
+                if part.has_content():
+                    yield msg, False
+                    break
+
+            async with _utils.group_by_temporal(usage_checking_stream, debounce_by) as group_iter:
+                async for _events in group_iter:
+                    msg = self._stream_response.get()
+                    yield msg, False
                 msg = self._stream_response.get()
-                for item in msg.parts:
-                    if isinstance(item, _messages.ToolCallPart) and item.has_content():
-                        yield msg, False
-                        break
-                async with _utils.group_by_temporal(usage_checking_stream, debounce_by) as group_iter:
-                    async for _ in group_iter:
-                        msg = self._stream_response.get()
-                        for item in msg.parts:
-                            if isinstance(item, _messages.ToolCallPart) and item.has_content():
-                                yield msg, False
-                                break
-                msg = self._stream_response.get(final=True)
                 yield msg, True
+                # TODO: Should this now be `final_response` instead of `structured_response`?
                 lf_span.set_attribute('structured_response', msg)
                 await self._marked_completed(msg)
 
@@ -314,21 +314,9 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
 
         async for _ in usage_checking_stream:
             pass
-
-        if isinstance(self._stream_response, models.StreamTextResponse):
-            text = ''.join(self._stream_response.get(final=True))
-            text = await self._validate_text_result(text)
-            await self._marked_completed(_messages.ModelResponse.from_text(text))
-            return cast(ResultData, text)
-        else:
-            message = self._stream_response.get(final=True)
-            await self._marked_completed(message)
-            return await self.validate_structured_result(message)
-
-    @property
-    def is_structured(self) -> bool:
-        """Return whether the stream response contains structured data (as opposed to text)."""
-        return isinstance(self._stream_response, models.StreamStructuredResponse)
+        message = self._stream_response.get()
+        await self._marked_completed(message)
+        return await self.validate_structured_result(message)
 
     def usage(self) -> Usage:
         """Return the usage of the whole run.
@@ -346,20 +334,29 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
         self, message: _messages.ModelResponse, *, allow_partial: bool = False
     ) -> ResultData:
         """Validate a structured result message."""
-        assert self._result_schema is not None, 'Expected _result_schema to not be None'
-        assert self._result_tool_name is not None, 'Expected _result_tool_name to not be None'
-        match = self._result_schema.find_named_tool(message.parts, self._result_tool_name)
-        if match is None:
-            raise exceptions.UnexpectedModelBehavior(
-                f'Invalid message, unable to find tool: {self._result_schema.tool_names()}'
-            )
-
-        call, result_tool = match
-        result_data = result_tool.validate(call, allow_partial=allow_partial, wrap_validation_errors=False)
-
-        for validator in self._result_validators:
-            result_data = await validator.validate(result_data, call, self._run_ctx)
-        return result_data
+        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 match is None:
+                raise exceptions.UnexpectedModelBehavior(
+                    f'Invalid response, unable to find tool: {self._result_schema.tool_names()}'
+                )
+
+            call, result_tool = match
+            result_data = result_tool.validate(call, allow_partial=allow_partial, wrap_validation_errors=False)
+
+            for validator in self._result_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:
+                text = await validator.validate(
+                    text,  # pyright: ignore[reportArgumentType]
+                    None,
+                    self._run_ctx,
+                )
+            # Since there is no result tool, we can assume that str is compatible with ResultData
+            return cast(ResultData, text)
 
     async def _validate_text_result(self, text: str) -> str:
         for validator in self._result_validators:
@@ -377,8 +374,10 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
 
 
 def _get_usage_checking_stream_response(
-    stream_response: AsyncIterator[ResultData], limits: UsageLimits | None, get_usage: Callable[[], Usage]
-) -> AsyncIterator[ResultData]:
+    stream_response: AsyncIterable[_messages.ModelResponseStreamEvent],
+    limits: UsageLimits | None,
+    get_usage: Callable[[], Usage],
+) -> AsyncIterable[_messages.ModelResponseStreamEvent]:
     if limits is not None and limits.has_token_limits():
 
         async def _usage_checking_iterator():

pydantic_ai/tools.py

@@ -4,7 +4,7 @@ import dataclasses
 import inspect
 from collections.abc import Awaitable
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Callable, Generic, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, Generic, Literal, Union, cast
 
 from pydantic import ValidationError
 from pydantic_core import SchemaValidator
@@ -18,6 +18,7 @@ if TYPE_CHECKING:
 
 __all__ = (
     'AgentDeps',
+    'DocstringFormat',
     'RunContext',
     'SystemPromptFunc',
     'ToolFuncContext',
@@ -106,7 +107,7 @@ See [tool docs](../tools.md#tool-prepare) for more information.
 
 Example — here `only_if_42` is valid as a `ToolPrepareFunc`:
 
-```python {lint="not-imports"}
+```python {noqa="I001"}
 from typing import Union
 
 from pydantic_ai import RunContext, Tool
@@ -127,6 +128,15 @@ hitchhiker = Tool(hitchhiker, prepare=only_if_42)
 Usage `ToolPrepareFunc[AgentDeps]`.
 """
 
+DocstringFormat = Literal['google', 'numpy', 'sphinx', 'auto']
+"""Supported docstring formats.
+
+* `'google'` — [Google-style](https://google.github.io/styleguide/pyguide.html#381-docstrings) docstrings.
+* `'numpy'` — [Numpy-style](https://numpydoc.readthedocs.io/en/latest/format.html) docstrings.
+* `'sphinx'` — [Sphinx-style](https://sphinx-rtd-tutorial.readthedocs.io/en/latest/docstrings.html#the-sphinx-docstring-format) docstrings.
+* `'auto'` — Automatically infer the format based on the structure of the docstring.
+"""
+
 A = TypeVar('A')
 
 
@@ -140,6 +150,8 @@ class Tool(Generic[AgentDeps]):
     name: str
     description: str
     prepare: ToolPrepareFunc[AgentDeps] | None
+    docstring_format: DocstringFormat
+    require_parameter_descriptions: bool
     _is_async: bool = field(init=False)
     _single_arg_name: str | None = field(init=False)
     _positional_fields: list[str] = field(init=False)
@@ -157,12 +169,14 @@ class Tool(Generic[AgentDeps]):
         name: str | None = None,
         description: str | None = None,
         prepare: ToolPrepareFunc[AgentDeps] | None = None,
+        docstring_format: DocstringFormat = 'auto',
+        require_parameter_descriptions: bool = False,
     ):
         """Create a new tool instance.
 
         Example usage:
 
-        ```python {lint="not-imports"}
+        ```python {noqa="I001"}
         from pydantic_ai import Agent, RunContext, Tool
 
         async def my_tool(ctx: RunContext[int], x: int, y: int) -> str:
@@ -173,7 +187,7 @@ class Tool(Generic[AgentDeps]):
 
         or with a custom prepare method:
 
-        ```python {lint="not-imports"}
+        ```python {noqa="I001"}
         from typing import Union
 
         from pydantic_ai import Agent, RunContext, Tool
@@ -203,17 +217,22 @@ class Tool(Generic[AgentDeps]):
             prepare: custom method to prepare the tool definition for each step, return `None` to omit this
                 tool from a given step. This is useful if you want to customise a tool at call time,
                 or omit it completely from a step. See [`ToolPrepareFunc`][pydantic_ai.tools.ToolPrepareFunc].
+            docstring_format: The format of the docstring, see [`DocstringFormat`][pydantic_ai.tools.DocstringFormat].
+                Defaults to `'auto'`, such that the format is inferred from the structure of the docstring.
+            require_parameter_descriptions: If True, raise an error if a parameter description is missing. Defaults to False.
         """
         if takes_ctx is None:
             takes_ctx = _pydantic.takes_ctx(function)
 
-        f = _pydantic.function_schema(function, takes_ctx)
+        f = _pydantic.function_schema(function, takes_ctx, docstring_format, require_parameter_descriptions)
         self.function = function
         self.takes_ctx = takes_ctx
         self.max_retries = max_retries
         self.name = name or function.__name__
         self.description = description or f['description']
         self.prepare = prepare
+        self.docstring_format = docstring_format
+        self.require_parameter_descriptions = require_parameter_descriptions
         self._is_async = inspect.iscoroutinefunction(self.function)
         self._single_arg_name = f['single_arg_name']
         self._positional_fields = f['positional_fields']

{pydantic_ai_slim-0.0.18.dist-info → pydantic_ai_slim-0.0.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.18
+Version: 0.0.19
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -31,6 +31,8 @@ Requires-Dist: logfire-api>=1.2.0
 Requires-Dist: pydantic>=2.10
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.40.0; extra == 'anthropic'
+Provides-Extra: graph
+Requires-Dist: pydantic-graph==0.0.19; extra == 'graph'
 Provides-Extra: groq
 Requires-Dist: groq>=0.12.0; extra == 'groq'
 Provides-Extra: logfire

pydantic_ai_slim-0.0.19.dist-info/RECORD

@@ -0,0 +1,29 @@
+pydantic_ai/__init__.py,sha256=FbYetEgT6OO25u2KF5ZnFxKpz5DtnSpfckRXP4mjl8E,489
+pydantic_ai/_griffe.py,sha256=RYRKiLbgG97QxnazbAwlnc74XxevGHLQet-FGfq9qls,3960
+pydantic_ai/_parts_manager.py,sha256=pMDZs6BGC8EmaNa-73QvuptmxdG2MhBrBLIydCOl-gM,11886
+pydantic_ai/_pydantic.py,sha256=Zvjd2te6EzPrFnz--oDSdqwZuPw3vCiflTHriRhpNsY,8698
+pydantic_ai/_result.py,sha256=cUSugZQV0n5Z4fFHiMqua-2xs_0S6m-rr-yd6QS3nFE,10317
+pydantic_ai/_system_prompt.py,sha256=Fsl1K6GdQP0WhWBzvJxCc5uTqCD06lHjJlTADah-PI0,1116
+pydantic_ai/_utils.py,sha256=EHW866W6ZpGJLCWtoEAcwIPeWo9OQFhnD5el2DwVcwc,10949
+pydantic_ai/agent.py,sha256=Z_79gw4BIJooBIqJwPbnDHvmBcCXp2dbNd_832tc_do,62500
+pydantic_ai/exceptions.py,sha256=eGDKX6bGhgVxXBzu81Sk3iiAkXr0GUtgT7bD5Rxlqpg,2028
+pydantic_ai/format_as_xml.py,sha256=QE7eMlg5-YUMw1_2kcI3h0uKYPZZyGkgXFDtfZTMeeI,4480
+pydantic_ai/messages.py,sha256=b4RpaXogREquE8WHlGPMm0UGTNx2QtePV5GYk-9EscY,18185
+pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_ai/result.py,sha256=93ZLxr2jPx0cZeslHgphJ6XJnQMEybktzQ_LUT47h3Q,17429
+pydantic_ai/settings.py,sha256=oTk8ZfYuUsNxpJMWLvSrO1OH_0ur7VKgDNTMQG0tPyM,1974
+pydantic_ai/tools.py,sha256=iwa2PyhnKmvh_njy4aMfRIh7AP5igDIZ1ZPvgvvn6bM,13018
+pydantic_ai/usage.py,sha256=60d9f6M7YEYuKMbqDGDogX4KsA73fhDtWyDXYXoIPaI,4948
+pydantic_ai/models/__init__.py,sha256=Q4_fHy48szaA_TrIW3LZhRXiDUlhPAYf8LkhinSP3s8,10883
+pydantic_ai/models/anthropic.py,sha256=MkFqy2F7SPb_qAbgzc04iZWmVuoEBgn30v1HY1Wjadc,13543
+pydantic_ai/models/function.py,sha256=iT4XT8VEaJbNwYJAWtrI_jbRAb2tZO6UL93ErR4RYhM,9629
+pydantic_ai/models/gemini.py,sha256=3RTVQBAI1jWL3Xx_hi7qdy_6H-kTeuAOTPELnlVtPp4,27498
+pydantic_ai/models/groq.py,sha256=kzQSFT-04WmQmdRaB6Wj0mxHeAXIgyrryZkptNiA4Ng,13211
+pydantic_ai/models/mistral.py,sha256=qyYOLBpOdI5iPBmQxf5jp1d17sxqa1r8GJ7tb4yE45U,24549
+pydantic_ai/models/ollama.py,sha256=aHI8pNw7fqOOgvlEWcTnTYTmhf0cGg41x-p5sUQr2_k,4200
+pydantic_ai/models/openai.py,sha256=FzV6OCuK4Sr_J2GTuM-6Vu9NbDyZPxllwQPmssdOtbQ,13774
+pydantic_ai/models/test.py,sha256=0m2Pdn0xJMjvAVekVIoADQL0aSkOnGZJct9k4WvImrQ,15880
+pydantic_ai/models/vertexai.py,sha256=dHGrmLMgekWAEOZkLsO5rwDtQ6mjPixvn0umlvWAZok,9323
+pydantic_ai_slim-0.0.19.dist-info/METADATA,sha256=lnGlda0-tCapsWI72DyzGV9Sppm5I7koWbb7-xEpWcU,2808
+pydantic_ai_slim-0.0.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.0.19.dist-info/RECORD,,

pydantic_ai_slim-0.0.18.dist-info/RECORD

@@ -1,28 +0,0 @@
-pydantic_ai/__init__.py,sha256=FbYetEgT6OO25u2KF5ZnFxKpz5DtnSpfckRXP4mjl8E,489
-pydantic_ai/_griffe.py,sha256=407vemPed1Eeao-8sqAeC5cHGa-5SK55OzQwWk72Sl8,3795
-pydantic_ai/_pydantic.py,sha256=qXi5IsyiYOHeg_-qozCdxkfeqw2z0gBTjqgywBCiJWo,8125
-pydantic_ai/_result.py,sha256=cUSugZQV0n5Z4fFHiMqua-2xs_0S6m-rr-yd6QS3nFE,10317
-pydantic_ai/_system_prompt.py,sha256=Fsl1K6GdQP0WhWBzvJxCc5uTqCD06lHjJlTADah-PI0,1116
-pydantic_ai/_utils.py,sha256=skWNgm89US_x1EpxdRy5wCkghBrm1XgxFCiEh6wAkAo,8753
-pydantic_ai/agent.py,sha256=n6yu8gHhMWknalru1tTEfNWkOt_qqqD9zMLjVeHWJ7U,61593
-pydantic_ai/exceptions.py,sha256=eGDKX6bGhgVxXBzu81Sk3iiAkXr0GUtgT7bD5Rxlqpg,2028
-pydantic_ai/format_as_xml.py,sha256=Gm65687GL8Z6A_lPiJWL1O_E3ovHEBn2O1DKhn1CDnA,4472
-pydantic_ai/messages.py,sha256=RCtzsJFkhKBwIXNYOVAcNx0Kmnd0iAjSvwpnHmaAQt0,9211
-pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/result.py,sha256=-dpaaD24E1Ns7fxz5Gn7SKou-A8Cag4LjEyCBJbrHzY,17597
-pydantic_ai/settings.py,sha256=oTk8ZfYuUsNxpJMWLvSrO1OH_0ur7VKgDNTMQG0tPyM,1974
-pydantic_ai/tools.py,sha256=G4lwAb7QIowtSHk7w5cH8WQFIFqwMPn0J6Nqhgz7ubA,11757
-pydantic_ai/usage.py,sha256=60d9f6M7YEYuKMbqDGDogX4KsA73fhDtWyDXYXoIPaI,4948
-pydantic_ai/models/__init__.py,sha256=nAsE9pcqAW68pluxX332Z7sVomhVWEaU20F4Oi57ojs,11754
-pydantic_ai/models/anthropic.py,sha256=VyhLeNc585xann5we3obOWKUjIv6cKF6wYzhGHAAmvo,13466
-pydantic_ai/models/function.py,sha256=i7qkS_31aHrTbYVh6OzQ7Cwucz44F5PjT2EJK3GMphw,10573
-pydantic_ai/models/gemini.py,sha256=xvwPGYlZhQUYunu3LpWWbDfp_97Q4foLMaaLzYgyLFM,28745
-pydantic_ai/models/groq.py,sha256=ZoPkuWJrf78JPnTRfZhi7v0ETgxJKNN5dH8BLWagGGk,15770
-pydantic_ai/models/mistral.py,sha256=xGVI6-b8-9vnFickPPI2cRaHEWLc0jKKUM_vMjipf-U,25894
-pydantic_ai/models/ollama.py,sha256=ELqxhcNcnvQBnadd3gukS01zprUp6v8N_h1P5K-uf6c,4188
-pydantic_ai/models/openai.py,sha256=qFFInL3NbgfGcsAWigxMP5mscp76hC-jJimHc9woU6Y,16518
-pydantic_ai/models/test.py,sha256=u2pdZd9OLXQ_jI6CaVt96udXuIcv0Hfnfqd3pFGmeJM,16514
-pydantic_ai/models/vertexai.py,sha256=dHGrmLMgekWAEOZkLsO5rwDtQ6mjPixvn0umlvWAZok,9323
-pydantic_ai_slim-0.0.18.dist-info/METADATA,sha256=jdEPVU8__Zt4lmd3KYV3MLW7LLUrMxNvqbGJ761F6C0,2730
-pydantic_ai_slim-0.0.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.0.18.dist-info/RECORD,,