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

pydantic_ai/agent.py

@@ -275,7 +275,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         """
         if infer_name and self.name is None:
             self._infer_name(inspect.currentframe())
-        model_used = await self._get_model(model)
+        model_used = self._get_model(model)
 
         deps = self._get_deps(deps)
         new_message_index = len(message_history) if message_history else 0
@@ -520,7 +520,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
             # f_back because `asynccontextmanager` adds one frame
             if frame := inspect.currentframe():  # pragma: no branch
                 self._infer_name(frame.f_back)
-        model_used = await self._get_model(model)
+        model_used = self._get_model(model)
 
         deps = self._get_deps(deps)
         new_message_index = len(message_history) if message_history else 0
@@ -971,7 +971,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
 
         self._function_tools[tool.name] = tool
 
-    async def _get_model(self, model: models.Model | models.KnownModelName | None) -> models.Model:
+    def _get_model(self, model: models.Model | models.KnownModelName | None) -> models.Model:
         """Create a model configured for this agent.
 
         Args:

pydantic_ai/models/__init__.py

@@ -54,6 +54,8 @@ KnownModelName = Literal[
     'google-gla:gemini-2.0-flash-exp',
     'google-gla:gemini-2.0-flash-thinking-exp-01-21',
     'google-gla:gemini-exp-1206',
+    'google-gla:gemini-2.0-flash',
+    'google-gla:gemini-2.0-flash-lite-preview-02-05',
     'google-vertex:gemini-1.0-pro',
     'google-vertex:gemini-1.5-flash',
     'google-vertex:gemini-1.5-flash-8b',
@@ -61,6 +63,8 @@ KnownModelName = Literal[
     'google-vertex:gemini-2.0-flash-exp',
     'google-vertex:gemini-2.0-flash-thinking-exp-01-21',
     'google-vertex:gemini-exp-1206',
+    'google-vertex:gemini-2.0-flash',
+    'google-vertex:gemini-2.0-flash-lite-preview-02-05',
     'gpt-3.5-turbo',
     'gpt-3.5-turbo-0125',
     'gpt-3.5-turbo-0301',
@@ -173,9 +177,6 @@ class ModelRequestParameters:
 class Model(ABC):
     """Abstract class for a model."""
 
-    _model_name: str
-    _system: str | None
-
     @abstractmethod
     async def request(
         self,
@@ -201,24 +202,25 @@ class Model(ABC):
         yield  # pragma: no cover
 
     @property
+    @abstractmethod
     def model_name(self) -> str:
         """The model name."""
-        return self._model_name
+        raise NotImplementedError()
 
     @property
+    @abstractmethod
     def system(self) -> str | None:
         """The system / model provider, ex: openai."""
-        return self._system
+        raise NotImplementedError()
 
 
 @dataclass
 class StreamedResponse(ABC):
     """Streamed response from an LLM when calling a tool."""
 
-    _model_name: str
-    _usage: Usage = field(default_factory=Usage, init=False)
     _parts_manager: ModelResponsePartsManager = field(default_factory=ModelResponsePartsManager, init=False)
     _event_iterator: AsyncIterator[ModelResponseStreamEvent] | None = field(default=None, init=False)
+    _usage: Usage = field(default_factory=Usage, init=False)
 
     def __aiter__(self) -> AsyncIterator[ModelResponseStreamEvent]:
         """Stream the response as an async iterable of [`ModelResponseStreamEvent`][pydantic_ai.messages.ModelResponseStreamEvent]s."""
@@ -240,17 +242,20 @@ class StreamedResponse(ABC):
     def get(self) -> ModelResponse:
         """Build a [`ModelResponse`][pydantic_ai.messages.ModelResponse] from the data received from the stream so far."""
         return ModelResponse(
-            parts=self._parts_manager.get_parts(), model_name=self._model_name, timestamp=self.timestamp()
+            parts=self._parts_manager.get_parts(), model_name=self.model_name, timestamp=self.timestamp
         )
 
-    def model_name(self) -> str:
-        """Get the model name of the response."""
-        return self._model_name
-
     def usage(self) -> Usage:
         """Get the usage of the response so far. This will not be the final usage until the stream is exhausted."""
         return self._usage
 
+    @property
+    @abstractmethod
+    def model_name(self) -> str:
+        """Get the model name of the response."""
+        raise NotImplementedError()
+
+    @property
     @abstractmethod
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""

pydantic_ai/models/anthropic.py

@@ -162,6 +162,16 @@ class AnthropicModel(Model):
         async with response:
             yield await self._process_streamed_response(response)
 
+    @property
+    def model_name(self) -> AnthropicModelName:
+        """The model name."""
+        return self._model_name
+
+    @property
+    def system(self) -> str | None:
+        """The system / model provider."""
+        return self._system
+
     @overload
     async def _messages_create(
         self,
@@ -236,7 +246,7 @@ class AnthropicModel(Model):
                     )
                 )
 
-        return ModelResponse(items, model_name=self._model_name)
+        return ModelResponse(items, model_name=response.model)
 
     async def _process_streamed_response(self, response: AsyncStream[RawMessageStreamEvent]) -> StreamedResponse:
         peekable_response = _utils.PeekableAsyncStream(response)
@@ -362,6 +372,7 @@ def _map_usage(message: AnthropicMessage | RawMessageStreamEvent) -> usage.Usage
 class AnthropicStreamedResponse(StreamedResponse):
     """Implementation of `StreamedResponse` for Anthropic models."""
 
+    _model_name: AnthropicModelName
     _response: AsyncIterable[RawMessageStreamEvent]
     _timestamp: datetime
 
@@ -414,5 +425,12 @@ class AnthropicStreamedResponse(StreamedResponse):
             elif isinstance(event, (RawContentBlockStopEvent, RawMessageStopEvent)):
                 current_block = None
 
+    @property
+    def model_name(self) -> AnthropicModelName:
+        """Get the model name of the response."""
+        return self._model_name
+
+    @property
     def timestamp(self) -> datetime:
+        """Get the timestamp of the response."""
         return self._timestamp

pydantic_ai/models/cohere.py

@@ -136,6 +136,16 @@ class CohereModel(Model):
         response = await self._chat(messages, cast(CohereModelSettings, model_settings or {}), model_request_parameters)
         return self._process_response(response), _map_usage(response)
 
+    @property
+    def model_name(self) -> CohereModelName:
+        """The model name."""
+        return self._model_name
+
+    @property
+    def system(self) -> str | None:
+        """The system / model provider."""
+        return self._system
+
     async def _chat(
         self,
         messages: list[ModelMessage],

pydantic_ai/models/function.py

@@ -121,6 +121,16 @@ class FunctionModel(Model):
 
         yield FunctionStreamedResponse(_model_name=f'function:{self.stream_function.__name__}', _iter=response_stream)
 
+    @property
+    def model_name(self) -> str:
+        """The model name."""
+        return self._model_name
+
+    @property
+    def system(self) -> str | None:
+        """The system / model provider."""
+        return self._system
+
 
 @dataclass(frozen=True)
 class AgentInfo:
@@ -178,6 +188,7 @@ E.g. you need to yield all text or all `DeltaToolCalls`, not mix them.
 class FunctionStreamedResponse(StreamedResponse):
     """Implementation of `StreamedResponse` for [FunctionModel][pydantic_ai.models.function.FunctionModel]."""
 
+    _model_name: str
     _iter: AsyncIterator[str | DeltaToolCalls]
     _timestamp: datetime = field(default_factory=_utils.now_utc)
 
@@ -205,7 +216,14 @@ class FunctionStreamedResponse(StreamedResponse):
                     if maybe_event is not None:
                         yield maybe_event
 
+    @property
+    def model_name(self) -> str:
+        """Get the model name of the response."""
+        return self._model_name
+
+    @property
     def timestamp(self) -> datetime:
+        """Get the timestamp of the response."""
         return self._timestamp
 
 

pydantic_ai/models/gemini.py

@@ -47,6 +47,8 @@ LatestGeminiModelNames = Literal[
     'gemini-2.0-flash-exp',
     'gemini-2.0-flash-thinking-exp-01-21',
     'gemini-exp-1206',
+    'gemini-2.0-flash',
+    'gemini-2.0-flash-lite-preview-02-05',
 ]
 """Latest Gemini models."""
 
@@ -147,6 +149,16 @@ class GeminiModel(Model):
         ) as http_response:
             yield await self._process_streamed_response(http_response)
 
+    @property
+    def model_name(self) -> GeminiModelName:
+        """The model name."""
+        return self._model_name
+
+    @property
+    def system(self) -> str | None:
+        """The system / model provider."""
+        return self._system
+
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> _GeminiTools | None:
         tools = [_function_from_abstract_tool(t) for t in model_request_parameters.function_tools]
         if model_request_parameters.result_tools:
@@ -231,7 +243,7 @@ class GeminiModel(Model):
             else:
                 raise UnexpectedModelBehavior('Content field missing from Gemini response', str(response))
         parts = response['candidates'][0]['content']['parts']
-        return _process_response_from_parts(parts, model_name=self._model_name)
+        return _process_response_from_parts(parts, model_name=response.get('model_version', self._model_name))
 
     async def _process_streamed_response(self, http_response: HTTPResponse) -> StreamedResponse:
         """Process a streamed response, and prepare a streaming response to return."""
@@ -313,6 +325,7 @@ class ApiKeyAuth:
 class GeminiStreamedResponse(StreamedResponse):
     """Implementation of `StreamedResponse` for the Gemini model."""
 
+    _model_name: GeminiModelName
     _content: bytearray
     _stream: AsyncIterator[bytes]
     _timestamp: datetime = field(default_factory=_utils.now_utc, init=False)
@@ -376,7 +389,14 @@ class GeminiStreamedResponse(StreamedResponse):
             self._usage += _metadata_as_usage(r)
             yield r
 
+    @property
+    def model_name(self) -> GeminiModelName:
+        """Get the model name of the response."""
+        return self._model_name
+
+    @property
     def timestamp(self) -> datetime:
+        """Get the timestamp of the response."""
         return self._timestamp
 
 
@@ -608,6 +628,7 @@ class _GeminiResponse(TypedDict):
     # usageMetadata appears to be required by both APIs but is omitted when streaming responses until the last response
     usage_metadata: NotRequired[Annotated[_GeminiUsageMetaData, pydantic.Field(alias='usageMetadata')]]
     prompt_feedback: NotRequired[Annotated[_GeminiPromptFeedback, pydantic.Field(alias='promptFeedback')]]
+    model_version: NotRequired[Annotated[str, pydantic.Field(alias='modelVersion')]]
 
 
 class _GeminiCandidates(TypedDict):

pydantic_ai/models/groq.py

@@ -146,6 +146,16 @@ class GroqModel(Model):
         async with response:
             yield await self._process_streamed_response(response)
 
+    @property
+    def model_name(self) -> GroqModelName:
+        """The model name."""
+        return self._model_name
+
+    @property
+    def system(self) -> str | None:
+        """The system / model provider."""
+        return self._system
+
     @overload
     async def _completions_create(
         self,
@@ -212,7 +222,7 @@ class GroqModel(Model):
         if choice.message.tool_calls is not None:
             for c in choice.message.tool_calls:
                 items.append(ToolCallPart(tool_name=c.function.name, args=c.function.arguments, tool_call_id=c.id))
-        return ModelResponse(items, model_name=self._model_name, timestamp=timestamp)
+        return ModelResponse(items, model_name=response.model, timestamp=timestamp)
 
     async def _process_streamed_response(self, response: AsyncStream[ChatCompletionChunk]) -> GroqStreamedResponse:
         """Process a streamed response, and prepare a streaming response to return."""
@@ -305,6 +315,7 @@ class GroqModel(Model):
 class GroqStreamedResponse(StreamedResponse):
     """Implementation of `StreamedResponse` for Groq models."""
 
+    _model_name: GroqModelName
     _response: AsyncIterable[ChatCompletionChunk]
     _timestamp: datetime
 
@@ -333,7 +344,14 @@ class GroqStreamedResponse(StreamedResponse):
                 if maybe_event is not None:
                     yield maybe_event
 
+    @property
+    def model_name(self) -> GroqModelName:
+        """Get the model name of the response."""
+        return self._model_name
+
+    @property
     def timestamp(self) -> datetime:
+        """Get the timestamp of the response."""
         return self._timestamp
 
 

pydantic_ai/models/mistral.py

@@ -165,6 +165,16 @@ class MistralModel(Model):
         async with response:
             yield await self._process_streamed_response(model_request_parameters.result_tools, response)
 
+    @property
+    def model_name(self) -> MistralModelName:
+        """The model name."""
+        return self._model_name
+
+    @property
+    def system(self) -> str | None:
+        """The system / model provider."""
+        return self._system
+
     async def _completions_create(
         self,
         messages: list[ModelMessage],
@@ -296,7 +306,7 @@ class MistralModel(Model):
                 tool = self._map_mistral_to_pydantic_tool_call(tool_call=tool_call)
                 parts.append(tool)
 
-        return ModelResponse(parts, model_name=self._model_name, timestamp=timestamp)
+        return ModelResponse(parts, model_name=response.model, timestamp=timestamp)
 
     async def _process_streamed_response(
         self,
@@ -461,6 +471,7 @@ MistralToolCallId = Union[str, None]
 class MistralStreamedResponse(StreamedResponse):
     """Implementation of `StreamedResponse` for Mistral models."""
 
+    _model_name: MistralModelName
     _response: AsyncIterable[MistralCompletionEvent]
     _timestamp: datetime
     _result_tools: dict[str, ToolDefinition]
@@ -502,7 +513,14 @@ class MistralStreamedResponse(StreamedResponse):
                     vendor_part_id=index, tool_name=dtc.function.name, args=dtc.function.arguments, tool_call_id=dtc.id
                 )
 
+    @property
+    def model_name(self) -> MistralModelName:
+        """Get the model name of the response."""
+        return self._model_name
+
+    @property
     def timestamp(self) -> datetime:
+        """Get the timestamp of the response."""
         return self._timestamp
 
     @staticmethod

pydantic_ai/models/openai.py

@@ -122,7 +122,8 @@ class OpenAIModel(Model):
         # openai compatible models do not always need an API key.
         if api_key is None and 'OPENAI_API_KEY' not in os.environ and base_url is not None and openai_client is None:
             api_key = ''
-        elif openai_client is not None:
+
+        if openai_client is not None:
             assert http_client is None, 'Cannot provide both `openai_client` and `http_client`'
             assert base_url is None, 'Cannot provide both `openai_client` and `base_url`'
             assert api_key is None, 'Cannot provide both `openai_client` and `api_key`'
@@ -163,6 +164,16 @@ class OpenAIModel(Model):
         async with response:
             yield await self._process_streamed_response(response)
 
+    @property
+    def model_name(self) -> OpenAIModelName:
+        """The model name."""
+        return self._model_name
+
+    @property
+    def system(self) -> str | None:
+        """The system / model provider."""
+        return self._system
+
     @overload
     async def _completions_create(
         self,
@@ -232,7 +243,7 @@ class OpenAIModel(Model):
         if choice.message.tool_calls is not None:
             for c in choice.message.tool_calls:
                 items.append(ToolCallPart(c.function.name, c.function.arguments, c.id))
-        return ModelResponse(items, model_name=self._model_name, timestamp=timestamp)
+        return ModelResponse(items, model_name=response.model, timestamp=timestamp)
 
     async def _process_streamed_response(self, response: AsyncStream[ChatCompletionChunk]) -> OpenAIStreamedResponse:
         """Process a streamed response, and prepare a streaming response to return."""
@@ -331,6 +342,7 @@ class OpenAIModel(Model):
 class OpenAIStreamedResponse(StreamedResponse):
     """Implementation of `StreamedResponse` for OpenAI models."""
 
+    _model_name: OpenAIModelName
     _response: AsyncIterable[ChatCompletionChunk]
     _timestamp: datetime
 
@@ -358,7 +370,14 @@ class OpenAIStreamedResponse(StreamedResponse):
                 if maybe_event is not None:
                     yield maybe_event
 
+    @property
+    def model_name(self) -> OpenAIModelName:
+        """Get the model name of the response."""
+        return self._model_name
+
+    @property
     def timestamp(self) -> datetime:
+        """Get the timestamp of the response."""
         return self._timestamp
 
 

pydantic_ai/models/test.py

@@ -107,6 +107,16 @@ class TestModel(Model):
             _model_name=self._model_name, _structured_response=model_response, _messages=messages
         )
 
+    @property
+    def model_name(self) -> str:
+        """The model name."""
+        return self._model_name
+
+    @property
+    def system(self) -> str | None:
+        """The system / model provider."""
+        return self._system
+
     def gen_tool_args(self, tool_def: ToolDefinition) -> Any:
         return _JsonSchemaTestData(tool_def.parameters_json_schema, self.seed).generate()
 
@@ -221,9 +231,9 @@ class TestModel(Model):
 class TestStreamedResponse(StreamedResponse):
     """A structured response that streams test data."""
 
+    _model_name: str
     _structured_response: ModelResponse
     _messages: InitVar[Iterable[ModelMessage]]
-
     _timestamp: datetime = field(default_factory=_utils.now_utc, init=False)
 
     def __post_init__(self, _messages: Iterable[ModelMessage]):
@@ -249,7 +259,14 @@ class TestStreamedResponse(StreamedResponse):
                     vendor_part_id=i, tool_name=part.tool_name, args=part.args, tool_call_id=part.tool_call_id
                 )
 
+    @property
+    def model_name(self) -> str:
+        """Get the model name of the response."""
+        return self._model_name
+
+    @property
     def timestamp(self) -> datetime:
+        """Get the timestamp of the response."""
         return self._timestamp
 
 

pydantic_ai/models/vertexai.py

@@ -161,6 +161,16 @@ class VertexAIModel(GeminiModel):
         async with super().request_stream(messages, model_settings, model_request_parameters) as value:
             yield value
 
+    @property
+    def model_name(self) -> GeminiModelName:
+        """The model name."""
+        return self._model_name
+
+    @property
+    def system(self) -> str | None:
+        """The system / model provider."""
+        return self._system
+
 
 # pyright: reportUnknownMemberType=false
 def _creds_from_file(service_account_file: str | Path) -> ServiceAccountCredentials:

pydantic_ai/result.py

@@ -286,7 +286,7 @@ class StreamedRunResult(_BaseRunResult[ResultDataT], Generic[AgentDepsT, ResultD
                 await self._marked_completed(
                     _messages.ModelResponse(
                         parts=[_messages.TextPart(combined_validated_text)],
-                        model_name=self._stream_response.model_name(),
+                        model_name=self._stream_response.model_name,
                     )
                 )
 
@@ -347,7 +347,7 @@ class StreamedRunResult(_BaseRunResult[ResultDataT], Generic[AgentDepsT, ResultD
 
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""
-        return self._stream_response.timestamp()
+        return self._stream_response.timestamp
 
     async def validate_structured_result(
         self, message: _messages.ModelResponse, *, allow_partial: bool = False

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.23
+Version: 0.0.24
 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.23
+Requires-Dist: pydantic-graph==0.0.24
 Requires-Dist: pydantic>=2.10
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.40.0; extra == 'anthropic'

{pydantic_ai_slim-0.0.23.dist-info → pydantic_ai_slim-0.0.24.dist-info}/RECORD

@@ -6,25 +6,25 @@ 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=1jTnra4feBI0cMq-uR9NPVMkoQv9KRd7AVZsy8R1OAs,44918
+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=0beXiUfiSb2kVc68iqLeg2qFQW6-mnTC8TFtiQayPDQ,18394
+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=m5iGkMQQOmzV1j4wzuskIxXP3kbSM002A29kPEDusKI,13001
-pydantic_ai/models/anthropic.py,sha256=nt7vuoQw_O5rBmEkncTPAd_RQ23j40I2pIoXWChIrJ4,17260
-pydantic_ai/models/cohere.py,sha256=Nn7KbhSzWGR1a5ot2PtCEd0fZajhv5eL9qvTHJwUnps,10772
-pydantic_ai/models/function.py,sha256=JuqULRz0TmhEqmPrbLeN6iqFrpP_k85B6rTgeeE7Tcg,9887
-pydantic_ai/models/gemini.py,sha256=wXMtgjK9yepoBNb5LpFfD4eVyDejYlP9slrRFPXz98g,30181
-pydantic_ai/models/groq.py,sha256=Or2CDLWDn-DCxeOdKZAXSbQLe7l_uLdPQZE7Iwo_QL4,14138
-pydantic_ai/models/mistral.py,sha256=2lsTIoC3FhrYSyKS88yXQ4mZNu8LAqRQzKITp0EvzmY,25385
-pydantic_ai/models/openai.py,sha256=1px0ykE-4xCHSaQJkfiudQkFTw0PHtjmlpidevDTTok,16682
-pydantic_ai/models/test.py,sha256=eoenx_2RfcVCsao6RMDCGk0AtNBq7GIoSXi02Wep-k8,16428
-pydantic_ai/models/vertexai.py,sha256=4SuVviOFgxcnOe6CjA_z8X0Hzozs6fcMUo5PvafYc68,9279
-pydantic_ai_slim-0.0.23.dist-info/METADATA,sha256=XWCt3p_Ib1xE-2UABp0RVREc_e_WXXC0tdfjWiCrKbg,2839
-pydantic_ai_slim-0.0.23.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.0.23.dist-info/RECORD,,
+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,,