pydantic-ai-slim 0.0.12__py3-none-any.whl → 0.0.13__py3-none-any.whl

pydantic_ai/result.py

@@ -1,14 +1,14 @@
 from __future__ import annotations as _annotations
 
 from abc import ABC, abstractmethod
-from collections.abc import AsyncIterator, Callable
+from collections.abc import AsyncIterator, Awaitable, Callable
 from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Generic, TypeVar, cast
 
 import logfire_api
 
-from . import _result, _utils, exceptions, messages, models
+from . import _result, _utils, exceptions, messages as _messages, models
 from .tools import AgentDeps
 
 __all__ = (
@@ -71,19 +71,19 @@ class _BaseRunResult(ABC, Generic[ResultData]):
     You should not import or use this type directly, instead use its subclasses `RunResult` and `StreamedRunResult`.
     """
 
-    _all_messages: list[messages.Message]
+    _all_messages: list[_messages.ModelMessage]
     _new_message_index: int
 
-    def all_messages(self) -> list[messages.Message]:
-        """Return the history of messages."""
+    def all_messages(self) -> list[_messages.ModelMessage]:
+        """Return the history of _messages."""
         # this is a method to be consistent with the other methods
         return self._all_messages
 
     def all_messages_json(self) -> bytes:
-        """Return all messages from [`all_messages`][..all_messages] as JSON bytes."""
-        return messages.MessagesTypeAdapter.dump_json(self.all_messages())
+        """Return all messages from [`all_messages`][pydantic_ai.result._BaseRunResult.all_messages] as JSON bytes."""
+        return _messages.ModelMessagesTypeAdapter.dump_json(self.all_messages())
 
-    def new_messages(self) -> list[messages.Message]:
+    def new_messages(self) -> list[_messages.ModelMessage]:
         """Return new messages associated with this run.
 
         System prompts and any messages from older runs are excluded.
@@ -91,8 +91,8 @@ class _BaseRunResult(ABC, Generic[ResultData]):
         return self.all_messages()[self._new_message_index :]
 
     def new_messages_json(self) -> bytes:
-        """Return new messages from [`new_messages`][..new_messages] as JSON bytes."""
-        return messages.MessagesTypeAdapter.dump_json(self.new_messages())
+        """Return new messages from [`new_messages`][pydantic_ai.result._BaseRunResult.new_messages] as JSON bytes."""
+        return _messages.ModelMessagesTypeAdapter.dump_json(self.new_messages())
 
     @abstractmethod
     def cost(self) -> Cost:
@@ -122,7 +122,8 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
     _result_schema: _result.ResultSchema[ResultData] | None
     _deps: AgentDeps
     _result_validators: list[_result.ResultValidator[AgentDeps, ResultData]]
-    _on_complete: Callable[[list[messages.Message]], None]
+    _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.
 
@@ -205,11 +206,11 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
                     combined = await self._validate_text_result(''.join(chunks))
                     yield combined
                 lf_span.set_attribute('combined_text', combined)
-                self._marked_completed(text=combined)
+                await self._marked_completed(_messages.ModelResponse.from_text(combined))
 
     async def stream_structured(
         self, *, debounce_by: float | None = 0.1
-    ) -> AsyncIterator[tuple[messages.ModelStructuredResponse, bool]]:
+    ) -> AsyncIterator[tuple[_messages.ModelResponse, bool]]:
         """Stream the response as an async iterable of Structured LLM Messages.
 
         !!! note
@@ -230,17 +231,21 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
             else:
                 # we should already have a message at this point, yield that first if it has any content
                 msg = self._stream_response.get()
-                if any(call.has_content() for call in msg.calls):
-                    yield msg, False
+                for item in msg.parts:
+                    if isinstance(item, _messages.ToolCallPart) and item.has_content():
+                        yield msg, False
+                        break
                 async with _utils.group_by_temporal(self._stream_response, debounce_by) as group_iter:
                     async for _ in group_iter:
                         msg = self._stream_response.get()
-                        if any(call.has_content() for call in msg.calls):
-                            yield msg, False
+                        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
                 lf_span.set_attribute('structured_response', msg)
-                self._marked_completed(structured_message=msg)
+                await self._marked_completed(msg)
 
     async def get_data(self) -> ResultData:
         """Stream the whole response, validate and return it."""
@@ -249,12 +254,12 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
         if isinstance(self._stream_response, models.StreamTextResponse):
             text = ''.join(self._stream_response.get(final=True))
             text = await self._validate_text_result(text)
-            self._marked_completed(text=text)
+            await self._marked_completed(_messages.ModelResponse.from_text(text))
             return cast(ResultData, text)
         else:
-            structured_message = self._stream_response.get(final=True)
-            self._marked_completed(structured_message=structured_message)
-            return await self.validate_structured_result(structured_message)
+            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:
@@ -274,11 +279,12 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
         return self._stream_response.timestamp()
 
     async def validate_structured_result(
-        self, message: messages.ModelStructuredResponse, *, allow_partial: bool = False
+        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'
-        match = self._result_schema.find_tool(message)
+        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()}'
@@ -288,7 +294,7 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
         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, self._deps, 0, call)
+            result_data = await validator.validate(result_data, self._deps, 0, call, self._all_messages)
         return result_data
 
     async def _validate_text_result(self, text: str) -> str:
@@ -298,19 +304,11 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
                 self._deps,
                 0,
                 None,
+                self._all_messages,
             )
         return text
 
-    def _marked_completed(
-        self, *, text: str | None = None, structured_message: messages.ModelStructuredResponse | None = None
-    ) -> None:
+    async def _marked_completed(self, message: _messages.ModelResponse) -> None:
         self.is_complete = True
-        if text is not None:
-            assert structured_message is None, 'Either text or structured_message should provided, not both'
-            self._all_messages.append(
-                messages.ModelTextResponse(content=text, timestamp=self._stream_response.timestamp())
-            )
-        else:
-            assert structured_message is not None, 'Either text or structured_message should provided, not both'
-            self._all_messages.append(structured_message)
-        self._on_complete(self._all_messages)
+        self._all_messages.append(message)
+        await self._on_complete()

pydantic_ai/settings.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from httpx import Timeout
+from typing_extensions import TypedDict
+
+
+class ModelSettings(TypedDict, total=False):
+    """Settings to configure an LLM.
+
+    Here we include only settings which apply to multiple models / model providers.
+    """
+
+    max_tokens: int
+    """The maximum number of tokens to generate before stopping.
+
+    Supported by:
+    * Gemini
+    * Anthropic
+    * OpenAI
+    * Groq
+    """
+
+    temperature: float
+    """Amount of randomness injected into the response.
+
+    Use `temperature` closer to `0.0` for analytical / multiple choice, and closer to a model's
+    maximum `temperature` for creative and generative tasks.
+
+    Note that even with `temperature` of `0.0`, the results will not be fully deterministic.
+
+    Supported by:
+    * Gemini
+    * Anthropic
+    * OpenAI
+    * Groq
+    """
+
+    top_p: float
+    """An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass.
+
+    So 0.1 means only the tokens comprising the top 10% probability mass are considered.
+
+    You should either alter `temperature` or `top_p`, but not both.
+
+    Supported by:
+    * Gemini
+    * Anthropic
+    * OpenAI
+    * Groq
+    """
+
+    timeout: float | Timeout
+    """Override the client-level default timeout for a request, in seconds.
+
+    Supported by:
+    * Gemini
+    * Anthropic
+    * OpenAI
+    * Groq
+    """
+
+
+def merge_model_settings(base: ModelSettings | None, overrides: ModelSettings | None) -> ModelSettings | None:
+    """Merge two sets of model settings, preferring the overrides.
+
+    A common use case is: merge_model_settings(<agent settings>, <run settings>)
+    """
+    # Note: we may want merge recursively if/when we add non-primitive values
+    if base and overrides:
+        return base | overrides
+    else:
+        return base or overrides

pydantic_ai/tools.py

@@ -9,7 +9,7 @@ from pydantic import ValidationError
 from pydantic_core import SchemaValidator
 from typing_extensions import Concatenate, ParamSpec, TypeAlias
 
-from . import _pydantic, _utils, messages
+from . import _pydantic, _utils, messages as _messages
 from .exceptions import ModelRetry, UnexpectedModelBehavior
 
 if TYPE_CHECKING:
@@ -45,7 +45,9 @@ class RunContext(Generic[AgentDeps]):
     """Dependencies for the agent."""
     retry: int
     """Number of retries so far."""
-    tool_name: str | None = None
+    messages: list[_messages.ModelMessage]
+    """Messages exchanged in the conversation so far."""
+    tool_name: str | None
     """Name of the tool being called."""
 
 
@@ -87,7 +89,7 @@ ToolFuncPlain = Callable[ToolParams, Any]
 Usage `ToolPlainFunc[ToolParams]`.
 """
 ToolFuncEither = Union[ToolFuncContext[AgentDeps, ToolParams], ToolFuncPlain[ToolParams]]
-"""Either kind of tool function.
+"""Either part_kind of tool function.
 
 This is just a union of [`ToolFuncContext`][pydantic_ai.tools.ToolFuncContext] and
 [`ToolFuncPlain`][pydantic_ai.tools.ToolFuncPlain].
@@ -97,11 +99,11 @@ Usage `ToolFuncEither[AgentDeps, ToolParams]`.
 ToolPrepareFunc: TypeAlias = 'Callable[[RunContext[AgentDeps], ToolDefinition], Awaitable[ToolDefinition | None]]'
 """Definition of a function that can prepare a tool definition at call time.
 
-See [tool docs](../agents.md#tool-prepare) for more information.
+See [tool docs](../tools.md#tool-prepare) for more information.
 
 Example — here `only_if_42` is valid as a `ToolPrepareFunc`:
 
-```py
+```python {lint="not-imports"}
 from typing import Union
 
 from pydantic_ai import RunContext, Tool
@@ -157,7 +159,7 @@ class Tool(Generic[AgentDeps]):
 
         Example usage:
 
-        ```py
+        ```python {lint="not-imports"}
         from pydantic_ai import Agent, RunContext, Tool
 
         async def my_tool(ctx: RunContext[int], x: int, y: int) -> str:
@@ -168,7 +170,7 @@ class Tool(Generic[AgentDeps]):
 
         or with a custom prepare method:
 
-        ```py
+        ```python {lint="not-imports"}
         from typing import Union
 
         from pydantic_ai import Agent, RunContext, Tool
@@ -235,17 +237,19 @@ class Tool(Generic[AgentDeps]):
         else:
             return tool_def
 
-    async def run(self, deps: AgentDeps, message: messages.ToolCall) -> messages.Message:
+    async def run(
+        self, deps: AgentDeps, message: _messages.ToolCallPart, conv_messages: list[_messages.ModelMessage]
+    ) -> _messages.ModelRequestPart:
         """Run the tool function asynchronously."""
         try:
-            if isinstance(message.args, messages.ArgsJson):
+            if isinstance(message.args, _messages.ArgsJson):
                 args_dict = self._validator.validate_json(message.args.args_json)
             else:
                 args_dict = self._validator.validate_python(message.args.args_dict)
         except ValidationError as e:
             return self._on_error(e, message)
 
-        args, kwargs = self._call_args(deps, args_dict, message)
+        args, kwargs = self._call_args(deps, args_dict, message, conv_messages)
         try:
             if self._is_async:
                 function = cast(Callable[[Any], Awaitable[str]], self.function)
@@ -257,19 +261,23 @@ class Tool(Generic[AgentDeps]):
             return self._on_error(e, message)
 
         self.current_retry = 0
-        return messages.ToolReturn(
+        return _messages.ToolReturnPart(
             tool_name=message.tool_name,
             content=response_content,
-            tool_id=message.tool_id,
+            tool_call_id=message.tool_call_id,
         )
 
     def _call_args(
-        self, deps: AgentDeps, args_dict: dict[str, Any], message: messages.ToolCall
+        self,
+        deps: AgentDeps,
+        args_dict: dict[str, Any],
+        message: _messages.ToolCallPart,
+        conv_messages: list[_messages.ModelMessage],
     ) -> tuple[list[Any], dict[str, Any]]:
         if self._single_arg_name:
             args_dict = {self._single_arg_name: args_dict}
 
-        args = [RunContext(deps, self.current_retry, message.tool_name)] if self.takes_ctx else []
+        args = [RunContext(deps, self.current_retry, conv_messages, message.tool_name)] if self.takes_ctx else []
         for positional_field in self._positional_fields:
             args.append(args_dict.pop(positional_field))
         if self._var_positional_field:
@@ -277,7 +285,9 @@ class Tool(Generic[AgentDeps]):
 
         return args, args_dict
 
-    def _on_error(self, exc: ValidationError | ModelRetry, call_message: messages.ToolCall) -> messages.RetryPrompt:
+    def _on_error(
+        self, exc: ValidationError | ModelRetry, call_message: _messages.ToolCallPart
+    ) -> _messages.RetryPromptPart:
         self.current_retry += 1
         if self.max_retries is None or self.current_retry > self.max_retries:
             raise UnexpectedModelBehavior(f'Tool exceeded max retries count of {self.max_retries}') from exc
@@ -286,10 +296,10 @@ class Tool(Generic[AgentDeps]):
                 content = exc.errors(include_url=False)
             else:
                 content = exc.message
-            return messages.RetryPrompt(
+            return _messages.RetryPromptPart(
                 tool_name=call_message.tool_name,
                 content=content,
-                tool_id=call_message.tool_id,
+                tool_call_id=call_message.tool_call_id,
             )
 
 
@@ -298,7 +308,7 @@ ObjectJsonSchema: TypeAlias = dict[str, Any]
 
 This type is used to define tools parameters (aka arguments) in [ToolDefinition][pydantic_ai.tools.ToolDefinition].
 
-With PEP-728 this should be a TypedDict with `type: Literal['object']`, and `extra_items=Any`
+With PEP-728 this should be a TypedDict with `type: Literal['object']`, and `extra_parts=Any`
 """
 
 

{pydantic_ai_slim-0.0.12.dist-info → pydantic_ai_slim-0.0.13.dist-info}/METADATA

@@ -1,9 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.12
+Version: 0.0.13
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
-License: MIT
+License-Expression: MIT
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Environment :: MacOS X
@@ -29,10 +29,15 @@ Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27.2
 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: groq
 Requires-Dist: groq>=0.12.0; extra == 'groq'
 Provides-Extra: logfire
 Requires-Dist: logfire>=2.3; extra == 'logfire'
+Provides-Extra: mistral
+Requires-Dist: json-repair>=0.30.3; extra == 'mistral'
+Requires-Dist: mistralai>=1.2.5; extra == 'mistral'
 Provides-Extra: openai
 Requires-Dist: openai>=1.54.3; extra == 'openai'
 Provides-Extra: vertexai

pydantic_ai_slim-0.0.13.dist-info/RECORD

@@ -0,0 +1,26 @@
+pydantic_ai/__init__.py,sha256=a29NqQz0JyW4BoCjcRh23fBBfwY17_n57moE4QrFWM4,324
+pydantic_ai/_griffe.py,sha256=pRjCJ6B1hhx6k46XJgl9zF6aRYxRmqEZKFok8unp4Iw,3449
+pydantic_ai/_pydantic.py,sha256=qXi5IsyiYOHeg_-qozCdxkfeqw2z0gBTjqgywBCiJWo,8125
+pydantic_ai/_result.py,sha256=LycNJR_Whc9P7sz2uD-Ce5bs9kQBU6eYqQxCUDNiNxU,10453
+pydantic_ai/_system_prompt.py,sha256=2Ui7fYAXxR_aZZLJdwMnOAecBOIbrKwx1yV4Qz523WQ,1089
+pydantic_ai/_utils.py,sha256=skWNgm89US_x1EpxdRy5wCkghBrm1XgxFCiEh6wAkAo,8753
+pydantic_ai/agent.py,sha256=sDQE20lQXyWO-SrodqSNlzzGwtaLNSkla6NgyJXPKTU,48568
+pydantic_ai/exceptions.py,sha256=ko_47M0k6Rhg9mUC9P1cj7N4LCH6cC0pEsF65A2vL-U,1561
+pydantic_ai/messages.py,sha256=Qa9H5kf9qeI1NqB-XgRjPJ-wwgVKvDZxqam7gnsLtrc,8106
+pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_ai/result.py,sha256=ZhaYArCiVl9JlrTllaeFIl2vU2foiIgpQYGby55G4cQ,13664
+pydantic_ai/settings.py,sha256=3sUaDMVMBX9Pku4Bh7lpv6VizX1utenHd5kVIRJvHyY,1908
+pydantic_ai/tools.py,sha256=hhhe5_ELeyYpaRoETMLjml83FAbMY7cpo5us7qwbOWg,11532
+pydantic_ai/models/__init__.py,sha256=y1tkHgWjIGLhZX95dIeOXcljSiAiRGma2T55hNi8EwA,10897
+pydantic_ai/models/anthropic.py,sha256=YBqiYjvOVqsSHPNT2Vt2aMaAAa8nMK57IMPONrtBCyc,13430
+pydantic_ai/models/function.py,sha256=i54ce97lqmy1p7Vqc162EiF_72oA3khc7z2uBGZbuWg,10731
+pydantic_ai/models/gemini.py,sha256=3oy0FVHLOP8SEOvpvoWtlUhRCJpddRj4-J_IPXaEkLE,28277
+pydantic_ai/models/groq.py,sha256=dorqZk8xbZ4ZDzZothJoWbUkoD8TWHb6lftdkNDlsu0,15821
+pydantic_ai/models/mistral.py,sha256=S0K73J5AGKwJc0UU0ifCrPmcxR2QMvVS6L1Cq19xDrk,26793
+pydantic_ai/models/ollama.py,sha256=i3mMXkXu9xL6f4c52Eyx3j4aHKfYoloFondlGHPtkS4,3971
+pydantic_ai/models/openai.py,sha256=fo3ocIOylD8YTuJMTJR1eXcRAQDGFKWFIYYrSOQS1C0,16569
+pydantic_ai/models/test.py,sha256=mBQ0vJYjEMHv01A3yyHR2porkxekpmqIUBkK-W8d-L8,15530
+pydantic_ai/models/vertexai.py,sha256=DBCBfpvpIhZaMG7cKvRl5rugCZqJqqEFm74uBc45weo,9259
+pydantic_ai_slim-0.0.13.dist-info/METADATA,sha256=57JLefiQcRnSOVvkDHcik6wQ24FZ3HOmPrfCaBUe4X8,2785
+pydantic_ai_slim-0.0.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.0.13.dist-info/RECORD,,

{pydantic_ai_slim-0.0.12.dist-info → pydantic_ai_slim-0.0.13.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.26.3
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

pydantic_ai_slim-0.0.12.dist-info/RECORD

@@ -1,23 +0,0 @@
-pydantic_ai/__init__.py,sha256=a29NqQz0JyW4BoCjcRh23fBBfwY17_n57moE4QrFWM4,324
-pydantic_ai/_griffe.py,sha256=pRjCJ6B1hhx6k46XJgl9zF6aRYxRmqEZKFok8unp4Iw,3449
-pydantic_ai/_pydantic.py,sha256=0rrns3p6BY8reGT0CVrYpq7VSiO5lDrCyugbMEZyvx8,8600
-pydantic_ai/_result.py,sha256=X8sk5Z_JFXBrs7dJQpT0N3U7KhhKnfVsQBJX9qHOsHU,9732
-pydantic_ai/_system_prompt.py,sha256=l9YD3SU3eu34ibTvLPDGbPsMz62yK4KTaOc3ORcDtKU,1079
-pydantic_ai/_utils.py,sha256=LnPjvL79gsC2vCcwdVdPt0N5bRVz9lr-ypRMYSwcQbg,8349
-pydantic_ai/agent.py,sha256=v_32DqnRKZpMrOvCb-uGveD6lMSr1Ssm5M67HpH55qU,40480
-pydantic_ai/exceptions.py,sha256=ko_47M0k6Rhg9mUC9P1cj7N4LCH6cC0pEsF65A2vL-U,1561
-pydantic_ai/messages.py,sha256=eyZfgk1yNomyEOji-1Z72UH2KeFlu6BK2_QRtUCH8_U,7190
-pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/result.py,sha256=UB3vFOcDAceeNLXh_f_3PKy2J0A6FIHdgDFJxPH6OJk,13651
-pydantic_ai/tools.py,sha256=o26Nbbn4P6DA6DBzOGm60ghnjGBjR6jBRmq-Of9MO7c,11105
-pydantic_ai/models/__init__.py,sha256=OSBkwXhZCN6I0ofRACkU-D4RHswJqcAZyu94Na5yK44,10056
-pydantic_ai/models/function.py,sha256=oNalT5TyL5Kd-QVtV3ZePw6xqD-pnh3Ycg8-5YIkPzg,9873
-pydantic_ai/models/gemini.py,sha256=qqkAHmlawKSeMAD12mlmunIxdhj783GmfmQSAJblzhA,26517
-pydantic_ai/models/groq.py,sha256=AqqFCwTntdifEhys4GQDE6GEnqz9dzMjJC9mdoIVsa0,14661
-pydantic_ai/models/ollama.py,sha256=nlxI4HNS6mmHointSc-xHa-dMwfzblAiv4hyy8_ZPXA,3966
-pydantic_ai/models/openai.py,sha256=XPsjkiDst8v46FONeVQ-hgC3yt74bQCYVRrtu1POkwQ,14971
-pydantic_ai/models/test.py,sha256=p99eMjzZeBhVdkHQx5pdnBlOnG__hcZnDHfedPut9jI,15042
-pydantic_ai/models/vertexai.py,sha256=DctkdayyIBXvolGWpWUG0YZRDb8M9U-cmZxRWq7ydzI,9126
-pydantic_ai_slim-0.0.12.dist-info/METADATA,sha256=MIZtH_6kLJj81yi7QrT-vtSteGH6gh5sXkoeKVbNTP0,2562
-pydantic_ai_slim-0.0.12.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-pydantic_ai_slim-0.0.12.dist-info/RECORD,,