pydantic-ai-slim 0.0.29__py3-none-any.whl → 0.0.31__py3-none-any.whl

pydantic_ai/models/instrumented.py

@@ -1,26 +1,21 @@
 from __future__ import annotations
 
-from collections.abc import AsyncIterator, Iterator
+import json
+from collections.abc import AsyncIterator, Iterator, Mapping
 from contextlib import asynccontextmanager, contextmanager
 from dataclasses import dataclass, field
-from functools import partial
 from typing import Any, Callable, Literal
 
 import logfire_api
 from opentelemetry._events import Event, EventLogger, EventLoggerProvider, get_event_logger_provider
-from opentelemetry.trace import Tracer, TracerProvider, get_tracer_provider
+from opentelemetry.trace import Span, Tracer, TracerProvider, get_tracer_provider
+from opentelemetry.util.types import AttributeValue
+from pydantic import TypeAdapter
 
 from ..messages import (
     ModelMessage,
     ModelRequest,
-    ModelRequestPart,
     ModelResponse,
-    RetryPromptPart,
-    SystemPromptPart,
-    TextPart,
-    ToolCallPart,
-    ToolReturnPart,
-    UserPromptPart,
 )
 from ..settings import ModelSettings
 from ..usage import Usage
@@ -46,40 +41,44 @@ MODEL_SETTING_ATTRIBUTES: tuple[
     'frequency_penalty',
 )
 
-NOT_GIVEN = object()
+ANY_ADAPTER = TypeAdapter[Any](Any)
 
 
 @dataclass
 class InstrumentedModel(WrapperModel):
-    """Model which is instrumented with logfire."""
+    """Model which is instrumented with OpenTelemetry."""
 
     tracer: Tracer = field(repr=False)
     event_logger: EventLogger = field(repr=False)
+    event_mode: Literal['attributes', 'logs'] = 'attributes'
 
     def __init__(
         self,
         wrapped: Model | KnownModelName,
         tracer_provider: TracerProvider | None = None,
         event_logger_provider: EventLoggerProvider | None = None,
+        event_mode: Literal['attributes', 'logs'] = 'attributes',
     ):
         super().__init__(wrapped)
         tracer_provider = tracer_provider or get_tracer_provider()
         event_logger_provider = event_logger_provider or get_event_logger_provider()
         self.tracer = tracer_provider.get_tracer('pydantic-ai')
         self.event_logger = event_logger_provider.get_event_logger('pydantic-ai')
+        self.event_mode = event_mode
 
     @classmethod
     def from_logfire(
         cls,
         wrapped: Model | KnownModelName,
         logfire_instance: logfire_api.Logfire = logfire_api.DEFAULT_LOGFIRE_INSTANCE,
+        event_mode: Literal['attributes', 'logs'] = 'attributes',
     ) -> InstrumentedModel:
         if hasattr(logfire_instance.config, 'get_event_logger_provider'):
             event_provider = logfire_instance.config.get_event_logger_provider()
         else:
             event_provider = None
         tracer_provider = logfire_instance.config.get_tracer_provider()
-        return cls(wrapped, tracer_provider, event_provider)
+        return cls(wrapped, tracer_provider, event_provider, event_mode)
 
     async def request(
         self,
@@ -126,7 +125,7 @@ class InstrumentedModel(WrapperModel):
         #  - server.port: to parse from the base_url
         #  - error.type: unclear if we should do something here or just always rely on span exceptions
         #  - gen_ai.request.stop_sequences/top_k: model_settings doesn't include these
-        attributes: dict[str, Any] = {
+        attributes: dict[str, AttributeValue] = {
             'gen_ai.operation.name': operation,
             'gen_ai.system': system,
             'gen_ai.request.model': model_name,
@@ -134,92 +133,85 @@ class InstrumentedModel(WrapperModel):
 
         if model_settings:
             for key in MODEL_SETTING_ATTRIBUTES:
-                if (value := model_settings.get(key, NOT_GIVEN)) is not NOT_GIVEN:
+                if isinstance(value := model_settings.get(key), (float, int)):
                     attributes[f'gen_ai.request.{key}'] = value
 
-        emit_event = partial(self._emit_event, system)
-
         with self.tracer.start_as_current_span(span_name, attributes=attributes) as span:
-            if span.is_recording():
-                for message in messages:
-                    if isinstance(message, ModelRequest):
-                        for part in message.parts:
-                            event_name, body = _request_part_body(part)
-                            if event_name:
-                                emit_event(event_name, body)
-                    elif isinstance(message, ModelResponse):
-                        for body in _response_bodies(message):
-                            emit_event('gen_ai.assistant.message', body)
 
             def finish(response: ModelResponse, usage: Usage):
                 if not span.is_recording():
                     return
 
-                for response_body in _response_bodies(response):
-                    if response_body:
-                        emit_event(
+                events = self.messages_to_otel_events(messages)
+                for event in self.messages_to_otel_events([response]):
+                    events.append(
+                        Event(
                             'gen_ai.choice',
-                            {
+                            body={
                                 # TODO finish_reason
                                 'index': 0,
-                                'message': response_body,
+                                'message': event.body,
                             },
                         )
+                    )
                 span.set_attributes(
                     {
-                        k: v
-                        for k, v in {
-                            # TODO finish_reason (https://github.com/open-telemetry/semantic-conventions/issues/1277), id
-                            #  https://github.com/pydantic/pydantic-ai/issues/886
-                            'gen_ai.response.model': response.model_name or model_name,
-                            'gen_ai.usage.input_tokens': usage.request_tokens,
-                            'gen_ai.usage.output_tokens': usage.response_tokens,
-                        }.items()
-                        if v is not None
+                        # TODO finish_reason (https://github.com/open-telemetry/semantic-conventions/issues/1277), id
+                        #  https://github.com/pydantic/pydantic-ai/issues/886
+                        'gen_ai.response.model': response.model_name or model_name,
+                        **usage.opentelemetry_attributes(),
                     }
                 )
+                self._emit_events(system, span, events)
 
             yield finish
 
-    def _emit_event(self, system: str, event_name: str, body: dict[str, Any]) -> None:
-        self.event_logger.emit(Event(event_name, body=body, attributes={'gen_ai.system': system}))
-
-
-def _request_part_body(part: ModelRequestPart) -> tuple[str, dict[str, Any]]:
-    if isinstance(part, SystemPromptPart):
-        return 'gen_ai.system.message', {'content': part.content, 'role': 'system'}
-    elif isinstance(part, UserPromptPart):
-        return 'gen_ai.user.message', {'content': part.content, 'role': 'user'}
-    elif isinstance(part, ToolReturnPart):
-        return 'gen_ai.tool.message', {'content': part.content, 'role': 'tool', 'id': part.tool_call_id}
-    elif isinstance(part, RetryPromptPart):
-        if part.tool_name is None:
-            return 'gen_ai.user.message', {'content': part.model_response(), 'role': 'user'}
+    def _emit_events(self, system: str, span: Span, events: list[Event]) -> None:
+        for event in events:
+            event.attributes = {'gen_ai.system': system, **(event.attributes or {})}
+        if self.event_mode == 'logs':
+            for event in events:
+                self.event_logger.emit(event)
         else:
-            return 'gen_ai.tool.message', {'content': part.model_response(), 'role': 'tool', 'id': part.tool_call_id}
-    else:
-        return '', {}
-
-
-def _response_bodies(message: ModelResponse) -> list[dict[str, Any]]:
-    body: dict[str, Any] = {'role': 'assistant'}
-    result = [body]
-    for part in message.parts:
-        if isinstance(part, ToolCallPart):
-            body.setdefault('tool_calls', []).append(
+            attr_name = 'events'
+            span.set_attributes(
                 {
-                    'id': part.tool_call_id,
-                    'type': 'function',  # TODO https://github.com/pydantic/pydantic-ai/issues/888
-                    'function': {
-                        'name': part.tool_name,
-                        'arguments': part.args,
-                    },
+                    attr_name: json.dumps([self.event_to_dict(event) for event in events]),
+                    'logfire.json_schema': json.dumps(
+                        {
+                            'type': 'object',
+                            'properties': {attr_name: {'type': 'array'}},
+                        }
+                    ),
                 }
             )
-        elif isinstance(part, TextPart):
-            if body.get('content'):
-                body = {'role': 'assistant'}
-                result.append(body)
-            body['content'] = part.content
 
-    return result
+    @staticmethod
+    def event_to_dict(event: Event) -> dict[str, Any]:
+        if not event.body:
+            body = {}
+        elif isinstance(event.body, Mapping):
+            body = event.body  # type: ignore
+        else:
+            body = {'body': event.body}
+        return {**body, **(event.attributes or {})}
+
+    @staticmethod
+    def messages_to_otel_events(messages: list[ModelMessage]) -> list[Event]:
+        result: list[Event] = []
+        for message in messages:
+            if isinstance(message, ModelRequest):
+                for part in message.parts:
+                    if hasattr(part, 'otel_event'):
+                        result.append(part.otel_event())
+            elif isinstance(message, ModelResponse):
+                result.extend(message.otel_events())
+        for event in result:
+            try:
+                event.body = ANY_ADAPTER.dump_python(event.body, mode='json')
+            except Exception:
+                try:
+                    event.body = str(event.body)
+                except Exception:
+                    event.body = 'Unable to serialize event body'
+        return result

pydantic_ai/result.py

@@ -7,9 +7,10 @@ from datetime import datetime
 from typing import Generic, Union, cast
 
 import logfire_api
-from typing_extensions import TypeVar
+from typing_extensions import TypeVar, assert_type
 
 from . import _result, _utils, exceptions, messages as _messages, models
+from .messages import AgentStreamEvent, FinalResultEvent
 from .tools import AgentDepsT, RunContext
 from .usage import Usage, UsageLimits
 
@@ -51,6 +52,127 @@ Usage `ResultValidatorFunc[AgentDepsT, T]`.
 _logfire = logfire_api.Logfire(otel_scope='pydantic-ai')
 
 
+@dataclass
+class AgentStream(Generic[AgentDepsT, ResultDataT]):
+    _raw_stream_response: models.StreamedResponse
+    _result_schema: _result.ResultSchema[ResultDataT] | None
+    _result_validators: list[_result.ResultValidator[AgentDepsT, ResultDataT]]
+    _run_ctx: RunContext[AgentDepsT]
+    _usage_limits: UsageLimits | None
+
+    _agent_stream_iterator: AsyncIterator[AgentStreamEvent] | None = field(default=None, init=False)
+    _final_result_event: FinalResultEvent | None = field(default=None, init=False)
+    _initial_run_ctx_usage: Usage = field(init=False)
+
+    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]:
+        """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:
+                yield await self._validate_response(response, self._final_result_event.tool_name, allow_partial=True)
+        if self._final_result_event is not None:
+            yield await self._validate_response(
+                self._raw_stream_response.get(), self._final_result_event.tool_name, allow_partial=False
+            )
+
+    async def stream_responses(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[_messages.ModelResponse]:
+        """Asynchronously stream the (unvalidated) model responses for the agent."""
+        # if the message currently has any parts with content, yield before streaming
+        msg = self._raw_stream_response.get()
+        for part in msg.parts:
+            if part.has_content():
+                yield msg
+                break
+
+        async with _utils.group_by_temporal(self, debounce_by) as group_iter:
+            async for _items in group_iter:
+                yield self._raw_stream_response.get()  # current state of the response
+
+    def usage(self) -> Usage:
+        """Return the usage of the whole run.
+
+        !!! note
+            This won't return the full usage until the stream is finished.
+        """
+        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:
+        """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 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,
+                    None,
+                    self._run_ctx,
+                )
+            # Since there is no result tool, we can assume that str is compatible with ResultDataT
+            return cast(ResultDataT, text)
+
+    def __aiter__(self) -> AsyncIterator[AgentStreamEvent]:
+        """Stream [`AgentStreamEvent`][pydantic_ai.messages.AgentStreamEvent]s.
+
+        This proxies the _raw_stream_response and sends all events to the agent stream, while also checking for matches
+        on the result schema and emitting a [`FinalResultEvent`][pydantic_ai.messages.FinalResultEvent] if/when the
+        first match is found.
+        """
+        if self._agent_stream_iterator is not None:
+            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
+
+            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]):
+                                return _messages.FinalResultEvent(
+                                    tool_name=call.tool_name, tool_call_id=call.tool_call_id
+                                )
+                    elif allow_text_result:
+                        assert_type(e, _messages.PartStartEvent)
+                        return _messages.FinalResultEvent(tool_name=None, tool_call_id=None)
+
+            usage_checking_stream = _get_usage_checking_stream_response(
+                self._raw_stream_response, self._usage_limits, self.usage
+            )
+            async for event in usage_checking_stream:
+                yield event
+                if (final_result_event := _get_final_result_event(event)) is not None:
+                    self._final_result_event = final_result_event
+                    yield final_result_event
+                    break
+
+            # If we broke out of the above loop, we need to yield the rest of the events
+            # If we didn't, this will just be a no-op
+            async for event in usage_checking_stream:
+                yield event
+
+        self._agent_stream_iterator = aiter()
+        return self._agent_stream_iterator
+
+
 @dataclass
 class StreamedRunResult(Generic[AgentDepsT, ResultDataT]):
     """Result of a streamed run that returns structured data via a tool call."""
@@ -352,6 +474,8 @@ class FinalResult(Generic[ResultDataT]):
     """The final result data."""
     tool_name: str | None
     """Name of the final result tool; `None` if the result 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."""
 
 
 def _get_usage_checking_stream_response(

pydantic_ai/usage.py

@@ -56,6 +56,16 @@ class Usage:
         new_usage.incr(other)
         return new_usage
 
+    def opentelemetry_attributes(self) -> dict[str, int]:
+        """Get the token limits as OpenTelemetry attributes."""
+        result = {
+            'gen_ai.usage.input_tokens': self.request_tokens,
+            'gen_ai.usage.output_tokens': self.response_tokens,
+        }
+        for key, value in (self.details or {}).items():
+            result[f'gen_ai.usage.details.{key}'] = value
+        return {k: v for k, v in result.items() if v is not None}
+
 
 @dataclass
 class UsageLimits:

{pydantic_ai_slim-0.0.29.dist-info → pydantic_ai_slim-0.0.31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.29
+Version: 0.0.31
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -29,7 +29,8 @@ Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: logfire-api>=1.2.0
-Requires-Dist: pydantic-graph==0.0.29
+Requires-Dist: opentelemetry-api>=1.28.0
+Requires-Dist: pydantic-graph==0.0.31
 Requires-Dist: pydantic>=2.10
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.40.0; extra == 'anthropic'
@@ -44,7 +45,7 @@ Requires-Dist: logfire>=2.3; extra == 'logfire'
 Provides-Extra: mistral
 Requires-Dist: mistralai>=1.2.5; extra == 'mistral'
 Provides-Extra: openai
-Requires-Dist: openai>=1.61.0; extra == 'openai'
+Requires-Dist: openai>=1.65.1; extra == 'openai'
 Provides-Extra: tavily
 Requires-Dist: tavily-python>=0.5.0; extra == 'tavily'
 Provides-Extra: vertexai

{pydantic_ai_slim-0.0.29.dist-info → pydantic_ai_slim-0.0.31.dist-info}/RECORD

@@ -1,36 +1,36 @@
-pydantic_ai/__init__.py,sha256=Rmpjmorf8YY1PtlkXRRNN-J3ZoQDSh7chaibVGyqY0k,937
-pydantic_ai/_agent_graph.py,sha256=lNKTtUyVY14M0WODP5K1NUaE9zJA716-9rZutapSg8A,29042
+pydantic_ai/__init__.py,sha256=xrSDxkBwpUVInbPtTVhReEecStk-mWZMttAPUAQR0Ic,927
+pydantic_ai/_agent_graph.py,sha256=vvhV051rjVcPPRZ_TeL4pWwX-DptEzWgBBJnhybmIWg,30510
 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/_result.py,sha256=mqj3YrUzr5OT00h0KfGJglwQZ6_7nV7355Pvucd08ak,10276
 pydantic_ai/_system_prompt.py,sha256=602c2jyle2R_SesOrITBDETZqsLk4BZ8Cbo8yEhmx04,1120
-pydantic_ai/_utils.py,sha256=w9BYSfFZiaX757fRtMRclOL1uYzyQnxV_lxqbU2WTPs,9435
-pydantic_ai/agent.py,sha256=wCXvGwPykn-cYf1_4bR4XqYofqwI6X2lj4L-0-MbMp4,63685
+pydantic_ai/_utils.py,sha256=nx4Suswk2qjLvzphx8uQntKzFi-IzvhX_H1L7t_kJlQ,9579
+pydantic_ai/agent.py,sha256=jHQ99M-kwUrUSWHPjBDmWG2AepbDS9H3YUE1NugaWGg,65625
 pydantic_ai/exceptions.py,sha256=1ujJeB3jDDQ-pH5ydBYrgStvR35-GlEW0bYGTGEr4ME,3127
 pydantic_ai/format_as_xml.py,sha256=QE7eMlg5-YUMw1_2kcI3h0uKYPZZyGkgXFDtfZTMeeI,4480
-pydantic_ai/messages.py,sha256=U-RgeRsMR-Ew6IoeBDrnQVONX9AwxyVd0aTnAxEA7EM,20918
+pydantic_ai/messages.py,sha256=Yny2hIuExXfw9fvHDSPgbvfN91IOdcLaDEAmaCAoTBs,23751
 pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/result.py,sha256=Rqbog6efO1l_bFJSuAd-_ZZLoQa_rz4motOGeR_5N3I,16803
+pydantic_ai/result.py,sha256=Q--JTwDfPeJw1_Mk5EhI7R9V7GusG-oAx1m9pDH50zQ,23014
 pydantic_ai/settings.py,sha256=ntuWnke9UA18aByDxk9OIhN0tAgOaPdqCEkRf-wlp8Y,3059
 pydantic_ai/tools.py,sha256=IPZuZJCSQUppz1uyLVwpfFLGoMirB8YtKWXIDQGR444,13414
-pydantic_ai/usage.py,sha256=60d9f6M7YEYuKMbqDGDogX4KsA73fhDtWyDXYXoIPaI,4948
+pydantic_ai/usage.py,sha256=VmpU_o_RjFI65J81G1wfCwDIAYBclMjeWfLtslntFOw,5406
 pydantic_ai/common_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/common_tools/duckduckgo.py,sha256=-kSa1gGn5-NIYvtxFWrFcX2XdmfEmGxI3_wAqrb6jLI,2230
 pydantic_ai/common_tools/tavily.py,sha256=Lz35037ggkdWKa_Stj0yXBkiN_hygDefEevoRDUclF0,2560
-pydantic_ai/models/__init__.py,sha256=Qw_g58KzGUmuDKOBa2u3yFrNbgCXkdRSNtkhseLC1VM,13758
+pydantic_ai/models/__init__.py,sha256=2A3CpdMnvllnVVX8PmlUcBs0HMGcG4RurOXsRKl0BPc,13886
 pydantic_ai/models/anthropic.py,sha256=bFtE6hku9L4l4pKJg8XER37T2ST2htArho5lPjEohAk,20637
 pydantic_ai/models/cohere.py,sha256=6F6eWPGVT7mpMXlRugbVbR-a8Q1zmb1SKS_fWOoBL80,11514
 pydantic_ai/models/fallback.py,sha256=smHwNIpxu19JsgYYjY0nmzl3yox7yQRJ0Ir08zdhnk0,4207
-pydantic_ai/models/function.py,sha256=EMlASu436RE-XzOTuHGkIqkS8J4WItUvwwaL08LLkX8,10948
+pydantic_ai/models/function.py,sha256=THIwVJ8qI3efYLNlYXlYze_J8hc7MHB-NMb3kpknq0g,11373
 pydantic_ai/models/gemini.py,sha256=2hDTMIMf899dp-MS0tLT7m1GkXsL9KIRMBklGM0VLB4,34223
 pydantic_ai/models/groq.py,sha256=Z4sZJDu5Yxa2tZiAPp9EjSVMz4uwLhS3fW7kFSc09gI,16406
-pydantic_ai/models/instrumented.py,sha256=cvjHgQE_gJOH-YVQyvx9tBpGNB_Iuc8N8THn0TL0Rjk,8791
+pydantic_ai/models/instrumented.py,sha256=npufEZJrR9m0_ZQB1inWFcuK3Nu5_2GdY1YtTYaIj3s,8366
 pydantic_ai/models/mistral.py,sha256=ZJ4xPcL9wJIQ5io34yP2fPyXy8GZrSvsW4itZiKPYFw,27448
 pydantic_ai/models/openai.py,sha256=koIcK_pDHmV-JFq_-VIzU-edAqGKOOzkSk5QSYWvfoc,20156
 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.29.dist-info/METADATA,sha256=f7eLYpKWzEGmzTC8U29ZO5T4aTYMTW0Shmqa1zuEtG0,3062
-pydantic_ai_slim-0.0.29.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.0.29.dist-info/RECORD,,
+pydantic_ai_slim-0.0.31.dist-info/METADATA,sha256=dgkUKEU7r9OqgIkt3enzpISWt73KVAYL8gC2APlnpWg,3103
+pydantic_ai_slim-0.0.31.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.0.31.dist-info/RECORD,,