pydantic-ai-slim 0.0.24__py3-none-any.whl → 0.0.25__py3-none-any.whl

pydantic_ai/result.py

@@ -1,8 +1,7 @@
 from __future__ import annotations as _annotations
 
-from abc import ABC, abstractmethod
 from collections.abc import AsyncIterable, AsyncIterator, Awaitable, Callable
-from copy import deepcopy
+from copy import copy
 from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Generic, Union, cast
@@ -14,7 +13,7 @@ from . import _result, _utils, exceptions, messages as _messages, models
 from .tools import AgentDepsT, RunContext
 from .usage import Usage, UsageLimits
 
-__all__ = 'ResultDataT', 'ResultDataT_inv', 'ResultValidatorFunc', 'RunResult', 'StreamedRunResult'
+__all__ = 'ResultDataT', 'ResultDataT_inv', 'ResultValidatorFunc'
 
 
 T = TypeVar('T')
@@ -53,15 +52,34 @@ _logfire = logfire_api.Logfire(otel_scope='pydantic-ai')
 
 
 @dataclass
-class _BaseRunResult(ABC, Generic[ResultDataT]):
-    """Base type for results.
-
-    You should not import or use this type directly, instead use its subclasses `RunResult` and `StreamedRunResult`.
-    """
+class StreamedRunResult(Generic[AgentDepsT, ResultDataT]):
+    """Result of a streamed run that returns structured data via a tool call."""
 
     _all_messages: list[_messages.ModelMessage]
     _new_message_index: int
 
+    _usage_limits: UsageLimits | None
+    _stream_response: models.StreamedResponse
+    _result_schema: _result.ResultSchema[ResultDataT] | None
+    _run_ctx: RunContext[AgentDepsT]
+    _result_validators: list[_result.ResultValidator[AgentDepsT, ResultDataT]]
+    _result_tool_name: str | None
+    _on_complete: Callable[[], Awaitable[None]]
+
+    _initial_run_ctx_usage: Usage = field(init=False)
+    is_complete: bool = field(default=False, init=False)
+    """Whether the stream has all been received.
+
+    This is set to `True` when one of
+    [`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.
+    """
+
+    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]:
         """Return the history of _messages.
 
@@ -80,7 +98,7 @@ class _BaseRunResult(ABC, Generic[ResultDataT]):
         return self._all_messages
 
     def all_messages_json(self, *, result_tool_return_content: str | None = None) -> bytes:
-        """Return all messages from [`all_messages`][pydantic_ai.result._BaseRunResult.all_messages] as JSON bytes.
+        """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.
@@ -112,7 +130,7 @@ class _BaseRunResult(ABC, Generic[ResultDataT]):
         return self.all_messages(result_tool_return_content=result_tool_return_content)[self._new_message_index :]
 
     def new_messages_json(self, *, result_tool_return_content: str | None = None) -> bytes:
-        """Return new messages from [`new_messages`][pydantic_ai.result._BaseRunResult.new_messages] as JSON bytes.
+        """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.
@@ -127,78 +145,6 @@ class _BaseRunResult(ABC, Generic[ResultDataT]):
             self.new_messages(result_tool_return_content=result_tool_return_content)
         )
 
-    @abstractmethod
-    def usage(self) -> Usage:
-        raise NotImplementedError()
-
-
-@dataclass
-class RunResult(_BaseRunResult[ResultDataT]):
-    """Result of a non-streamed run."""
-
-    data: ResultDataT
-    """Data from the final response in the run."""
-    _result_tool_name: str | None
-    _usage: Usage
-
-    def usage(self) -> Usage:
-        """Return the usage of the whole run."""
-        return self._usage
-
-    def all_messages(self, *, 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
-                not be modified.
-
-        Returns:
-            List of messages.
-        """
-        if result_tool_return_content is not None:
-            return self._set_result_tool_return(result_tool_return_content)
-        else:
-            return self._all_messages
-
-    def _set_result_tool_return(self, return_content: str) -> list[_messages.ModelMessage]:
-        """Set return content for the result tool.
-
-        Useful if you want to continue the conversation and want to set the response to the result tool call.
-        """
-        if not self._result_tool_name:
-            raise ValueError('Cannot set result tool return content when the return type is `str`.')
-        messages = deepcopy(self._all_messages)
-        last_message = messages[-1]
-        for part in last_message.parts:
-            if isinstance(part, _messages.ToolReturnPart) and part.tool_name == self._result_tool_name:
-                part.content = return_content
-                return messages
-        raise LookupError(f'No tool call found with tool name {self._result_tool_name!r}.')
-
-
-@dataclass
-class StreamedRunResult(_BaseRunResult[ResultDataT], Generic[AgentDepsT, ResultDataT]):
-    """Result of a streamed run that returns structured data via a tool call."""
-
-    _usage_limits: UsageLimits | None
-    _stream_response: models.StreamedResponse
-    _result_schema: _result.ResultSchema[ResultDataT] | None
-    _run_ctx: RunContext[AgentDepsT]
-    _result_validators: list[_result.ResultValidator[AgentDepsT, ResultDataT]]
-    _result_tool_name: str | None
-    _on_complete: Callable[[], Awaitable[None]]
-    is_complete: bool = field(default=False, init=False)
-    """Whether the stream has all been received.
-
-    This is set to `True` when one of
-    [`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.
-    """
-
     async def stream(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[ResultDataT]:
         """Stream the response as an async iterable.
 
@@ -234,61 +180,17 @@ class StreamedRunResult(_BaseRunResult[ResultDataT], Generic[AgentDepsT, ResultD
         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 delta:
-                async for text in _stream_text_deltas():
+                async for text in self._stream_response_text(delta=delta, debounce_by=debounce_by):
                     yield text
             else:
-                # a quick benchmark shows it's faster to build up a string with concat when we're
-                # yielding at each step
-                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)
+                async for text in self._stream_response_text(delta=delta, debounce_by=debounce_by):
+                    combined_validated_text = await self._validate_text_result(text)
                     yield combined_validated_text
-
                 lf_span.set_attribute('combined_text', combined_validated_text)
-                await self._marked_completed(
-                    _messages.ModelResponse(
-                        parts=[_messages.TextPart(combined_validated_text)],
-                        model_name=self._stream_response.model_name,
-                    )
-                )
+            await self._marked_completed(self._stream_response.get())
 
     async def stream_structured(
         self, *, debounce_by: float | None = 0.1
@@ -303,10 +205,6 @@ class StreamedRunResult(_BaseRunResult[ResultDataT], Generic[AgentDepsT, ResultD
         Returns:
             An async iterable of the structured response message and whether that is the last message.
         """
-        usage_checking_stream = _get_usage_checking_stream_response(
-            self._stream_response, self._usage_limits, self.usage
-        )
-
         with _logfire.span('response stream structured') as lf_span:
             # if the message currently has any parts with content, yield before streaming
             msg = self._stream_response.get()
@@ -315,15 +213,14 @@ class StreamedRunResult(_BaseRunResult[ResultDataT], Generic[AgentDepsT, ResultD
                     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()
-                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)
+            async for msg in self._stream_response_structured(debounce_by=debounce_by):
+                yield msg, False
+
+            msg = self._stream_response.get()
+            yield msg, True
+
+            lf_span.set_attribute('structured_response', msg)
+            await self._marked_completed(msg)
 
     async def get_data(self) -> ResultDataT:
         """Stream the whole response, validate and return it."""
@@ -343,7 +240,7 @@ class StreamedRunResult(_BaseRunResult[ResultDataT], Generic[AgentDepsT, ResultD
         !!! note
             This won't return the full usage until the stream is finished.
         """
-        return self._run_ctx.usage + self._stream_response.usage()
+        return self._initial_run_ctx_usage + self._stream_response.usage()
 
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""
@@ -391,6 +288,71 @@ class StreamedRunResult(_BaseRunResult[ResultDataT], Generic[AgentDepsT, ResultD
         self._all_messages.append(message)
         await self._on_complete()
 
+    async def _stream_response_structured(
+        self, *, debounce_by: float | None = 0.1
+    ) -> AsyncIterator[_messages.ModelResponse]:
+        async with _utils.group_by_temporal(self._stream_response, debounce_by) as group_iter:
+            async for _items in group_iter:
+                yield self._stream_response.get()
+
+    async def _stream_response_text(
+        self, *, delta: bool = False, debounce_by: float | None = 0.1
+    ) -> AsyncIterator[str]:
+        """Stream the response as an async iterable of text."""
+
+        # 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]]:
+            # yields tuples of (text_content, part_index)
+            # we don't currently make use of the part_index, but in principle this may be useful
+            # so we retain it here for now to make possible future refactors simpler
+            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 self._stream_response:
+                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:
+                    # Note: we are currently just dropping the part index on the group here
+                    yield ''.join([content for content, _ in items])
+
+        if 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
+            deltas: list[str] = []
+            async for text in _stream_text_deltas():
+                deltas.append(text)
+                yield ''.join(deltas)
+
+
+@dataclass
+class FinalResult(Generic[ResultDataT]):
+    """Marker class storing the final result of an agent run and associated metadata."""
+
+    data: ResultDataT
+    """The final result data."""
+    tool_name: str | None
+    """Name of the final result tool; `None` if the result came from unstructured text content."""
+
 
 def _get_usage_checking_stream_response(
     stream_response: AsyncIterable[_messages.ModelResponseStreamEvent],

{pydantic_ai_slim-0.0.24.dist-info → pydantic_ai_slim-0.0.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.24
+Version: 0.0.25
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -28,7 +28,7 @@ Requires-Dist: eval-type-backport>=0.2.0
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: logfire-api>=1.2.0
-Requires-Dist: pydantic-graph==0.0.24
+Requires-Dist: pydantic-graph==0.0.25
 Requires-Dist: pydantic>=2.10
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.40.0; extra == 'anthropic'

pydantic_ai_slim-0.0.25.dist-info/RECORD

@@ -0,0 +1,32 @@
+pydantic_ai/__init__.py,sha256=2Sc-fnJ3OtqFrIZ47PsVVBE_TWPHWuKbik9upnFQw_4,647
+pydantic_ai/_agent_graph.py,sha256=ihtYxeh59G6BR8piOp7eZyNoB4nLb3XhFnoDuwna1G4,28789
+pydantic_ai/_griffe.py,sha256=RYRKiLbgG97QxnazbAwlnc74XxevGHLQet-FGfq9qls,3960
+pydantic_ai/_parts_manager.py,sha256=ARfDQY1_5AIY5rNl_M2fAYHEFCe03ZxdhgjHf9qeIKw,11872
+pydantic_ai/_pydantic.py,sha256=dROz3Hmfdi0C2exq88FhefDRVo_8S3rtkXnoUHzsz0c,8753
+pydantic_ai/_result.py,sha256=tN1pVulf_EM4bkBvpNUWPnUXezLY-sBrJEVCFdy2nLU,10264
+pydantic_ai/_system_prompt.py,sha256=602c2jyle2R_SesOrITBDETZqsLk4BZ8Cbo8yEhmx04,1120
+pydantic_ai/_utils.py,sha256=w9BYSfFZiaX757fRtMRclOL1uYzyQnxV_lxqbU2WTPs,9435
+pydantic_ai/agent.py,sha256=MGVvvccxcD2g9t-Tjd1uyff0CwGk4D7--KWIRgB9Gxo,63361
+pydantic_ai/exceptions.py,sha256=eGDKX6bGhgVxXBzu81Sk3iiAkXr0GUtgT7bD5Rxlqpg,2028
+pydantic_ai/format_as_xml.py,sha256=QE7eMlg5-YUMw1_2kcI3h0uKYPZZyGkgXFDtfZTMeeI,4480
+pydantic_ai/messages.py,sha256=RGzYX58M1plN-y2BmoGLA9m3r-tcha60OmzqOuiMLbk,18218
+pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_ai/result.py,sha256=Rqbog6efO1l_bFJSuAd-_ZZLoQa_rz4motOGeR_5N3I,16803
+pydantic_ai/settings.py,sha256=ntuWnke9UA18aByDxk9OIhN0tAgOaPdqCEkRf-wlp8Y,3059
+pydantic_ai/tools.py,sha256=lhupwm815lPlFFS79B0P61AyhUYtepA62LbZOCJrPEY,13205
+pydantic_ai/usage.py,sha256=60d9f6M7YEYuKMbqDGDogX4KsA73fhDtWyDXYXoIPaI,4948
+pydantic_ai/models/__init__.py,sha256=Qw_g58KzGUmuDKOBa2u3yFrNbgCXkdRSNtkhseLC1VM,13758
+pydantic_ai/models/anthropic.py,sha256=9kyWzt81Vrx9NUUZVXLRuGB0cJ3jPVNVCo9jgX89tPI,17752
+pydantic_ai/models/cohere.py,sha256=Rotl0F8O3fz7hvR269j-JGves42WieNDWU046XbIpWk,11000
+pydantic_ai/models/function.py,sha256=YU2Y3t5Olw0tBzWXUr0DkjtxtyVXUtlOhbmoRdtKx84,10333
+pydantic_ai/models/gemini.py,sha256=vTN3lRTTXfVHFAUJJQN2IRH24iabUWe5feYu8syV5Lc,31433
+pydantic_ai/models/groq.py,sha256=M7P-9LrH1lm4wyIMiytsHf28bwkukOyVzw3S7F9sbic,14612
+pydantic_ai/models/instrumented.py,sha256=cvjHgQE_gJOH-YVQyvx9tBpGNB_Iuc8N8THn0TL0Rjk,8791
+pydantic_ai/models/mistral.py,sha256=yUJj9MT8iaujMrD7dMOOAWHfAJJQEuWGNLtChHdyakg,25795
+pydantic_ai/models/openai.py,sha256=B6kn8xP5J5Pjfwyq5zJStpCWph8ZU8B6-NuNgNMXdLQ,17151
+pydantic_ai/models/test.py,sha256=Ux20cmuJFkhvI9L1N7ItHNFcd-j284TBEsrM53eWRag,16873
+pydantic_ai/models/vertexai.py,sha256=9Kp_1KMBlbP8_HRJTuFnrkkFmlJ7yFhADQYjxOgIh9Y,9523
+pydantic_ai/models/wrapper.py,sha256=Zr3fgiUBpt2N9gXds6iSwaMEtEsFKr9WwhpHjSoHa7o,1410
+pydantic_ai_slim-0.0.25.dist-info/METADATA,sha256=VbDk3sx1LMYhOxZaouy_IcVSlFvOzE00ph8NSm-Wdyo,2839
+pydantic_ai_slim-0.0.25.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.0.25.dist-info/RECORD,,

pydantic_ai_slim-0.0.24.dist-info/RECORD

@@ -1,30 +0,0 @@
-pydantic_ai/__init__.py,sha256=FbYetEgT6OO25u2KF5ZnFxKpz5DtnSpfckRXP4mjl8E,489
-pydantic_ai/_agent_graph.py,sha256=_uCNK12sEXmzB-Vk1OaCR-AMARYzEoInjKXZyx7ODjA,33136
-pydantic_ai/_griffe.py,sha256=RYRKiLbgG97QxnazbAwlnc74XxevGHLQet-FGfq9qls,3960
-pydantic_ai/_parts_manager.py,sha256=ARfDQY1_5AIY5rNl_M2fAYHEFCe03ZxdhgjHf9qeIKw,11872
-pydantic_ai/_pydantic.py,sha256=dROz3Hmfdi0C2exq88FhefDRVo_8S3rtkXnoUHzsz0c,8753
-pydantic_ai/_result.py,sha256=tN1pVulf_EM4bkBvpNUWPnUXezLY-sBrJEVCFdy2nLU,10264
-pydantic_ai/_system_prompt.py,sha256=602c2jyle2R_SesOrITBDETZqsLk4BZ8Cbo8yEhmx04,1120
-pydantic_ai/_utils.py,sha256=zfuY3NiPPsSM5J1q2JElfbfIa8S1ONGOlC7M-iyBVso,9430
-pydantic_ai/agent.py,sha256=q9nc_bTUuwxYVrzmUb5NkwOUWQm2XIsxpTuyyAuVdpU,44900
-pydantic_ai/exceptions.py,sha256=eGDKX6bGhgVxXBzu81Sk3iiAkXr0GUtgT7bD5Rxlqpg,2028
-pydantic_ai/format_as_xml.py,sha256=QE7eMlg5-YUMw1_2kcI3h0uKYPZZyGkgXFDtfZTMeeI,4480
-pydantic_ai/messages.py,sha256=kzXn4ZjlX9Sy2KXgFHWYbbwPk7TzTPdztzOJLWEONwU,17101
-pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/result.py,sha256=HYTkmb-6fzbxXRlsPOyVic_EexEGN4JLfZfVBKpJtfM,18390
-pydantic_ai/settings.py,sha256=ntuWnke9UA18aByDxk9OIhN0tAgOaPdqCEkRf-wlp8Y,3059
-pydantic_ai/tools.py,sha256=lhupwm815lPlFFS79B0P61AyhUYtepA62LbZOCJrPEY,13205
-pydantic_ai/usage.py,sha256=60d9f6M7YEYuKMbqDGDogX4KsA73fhDtWyDXYXoIPaI,4948
-pydantic_ai/models/__init__.py,sha256=WCvo5bI2dWJbKPhdGWID-HFGrZGo3jvtHhgwaDuY75s,13219
-pydantic_ai/models/anthropic.py,sha256=lArkCv0oZQeG1SqyEHlqKUyrcEYzYrS5fkW_ICKlikU,17749
-pydantic_ai/models/cohere.py,sha256=yLUA3bTQg-4NNjpvD2DXkUIMluia8vETChsjYYN13lg,11016
-pydantic_ai/models/function.py,sha256=5AWAFo-AZ0UyX8wBAYc5nd6U6XpOFvnsYr8vVfatEXQ,10333
-pydantic_ai/models/gemini.py,sha256=CGaHve4wQxkGEa1hArgldvOBk79blGdOqdeLxMH_NQM,30846
-pydantic_ai/models/groq.py,sha256=M7P-9LrH1lm4wyIMiytsHf28bwkukOyVzw3S7F9sbic,14612
-pydantic_ai/models/mistral.py,sha256=1DA1AX-V46p7dI75-4aRwQ8TrQxdh5ZQaoMYZO7VRkI,25868
-pydantic_ai/models/openai.py,sha256=kUV13suTp1ueibH2uYWaRCX832GApImdxSiGqNyfWo4,17161
-pydantic_ai/models/test.py,sha256=6X0r78biqnvakiH1nFKYQFNOs4dWrS-yqe0RFBrKW0s,16873
-pydantic_ai/models/vertexai.py,sha256=9Kp_1KMBlbP8_HRJTuFnrkkFmlJ7yFhADQYjxOgIh9Y,9523
-pydantic_ai_slim-0.0.24.dist-info/METADATA,sha256=kSbEzpXrgMTSHX0ojDw-Mtf8QQFCFE5fIJTRZihLe1w,2839
-pydantic_ai_slim-0.0.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.0.24.dist-info/RECORD,,