pydantic-ai-slim 0.0.20__py3-none-any.whl → 0.0.21__py3-none-any.whl

pydantic_ai/models/test.py

@@ -12,7 +12,6 @@ import pydantic_core
 
 from .. import _utils
 from ..messages import (
-    ArgsJson,
     ModelMessage,
     ModelRequest,
     ModelResponse,
@@ -34,6 +33,20 @@ from . import (
 from .function import _estimate_string_tokens, _estimate_usage  # pyright: ignore[reportPrivateUsage]
 
 
+@dataclass
+class _TextResult:
+    """A private wrapper class to tag a result that came from the custom_result_text field."""
+
+    value: str | None
+
+
+@dataclass
+class _FunctionToolResult:
+    """A wrapper class to tag a result that came from the custom_result_args field."""
+
+    value: Any | None
+
+
 @dataclass
 class TestModel(Model):
     """A model specifically for testing purposes.
@@ -53,7 +66,7 @@ class TestModel(Model):
     call_tools: list[str] | Literal['all'] = 'all'
     """List of tools to call. If `'all'`, all tools will be called."""
     custom_result_text: str | None = None
-    """If set, this text is return as the final result."""
+    """If set, this text is returned as the final result."""
     custom_result_args: Any | None = None
     """If set, these args will be passed to the result tool."""
     seed: int = 0
@@ -95,21 +108,21 @@ class TestModel(Model):
         if self.custom_result_text is not None:
             assert allow_text_result, 'Plain response not allowed, but `custom_result_text` is set.'
             assert self.custom_result_args is None, 'Cannot set both `custom_result_text` and `custom_result_args`.'
-            result: _utils.Either[str | None, Any | None] = _utils.Either(left=self.custom_result_text)
+            result: _TextResult | _FunctionToolResult = _TextResult(self.custom_result_text)
         elif self.custom_result_args is not None:
             assert result_tools is not None, 'No result tools provided, but `custom_result_args` is set.'
             result_tool = result_tools[0]
 
             if k := result_tool.outer_typed_dict_key:
-                result = _utils.Either(right={k: self.custom_result_args})
+                result = _FunctionToolResult({k: self.custom_result_args})
             else:
-                result = _utils.Either(right=self.custom_result_args)
+                result = _FunctionToolResult(self.custom_result_args)
         elif allow_text_result:
-            result = _utils.Either(left=None)
+            result = _TextResult(None)
         elif result_tools:
-            result = _utils.Either(right=None)
+            result = _FunctionToolResult(None)
         else:
-            result = _utils.Either(left=None)
+            result = _TextResult(None)
 
         return TestAgentModel(tool_calls, result, result_tools, self.seed)
 
@@ -126,7 +139,7 @@ class TestAgentModel(AgentModel):
 
     tool_calls: list[tuple[str, ToolDefinition]]
     # left means the text is plain text; right means it's a function call
-    result: _utils.Either[str | None, Any | None]
+    result: _TextResult | _FunctionToolResult
     result_tools: list[ToolDefinition]
     seed: int
     model_name: str = 'test'
@@ -152,7 +165,7 @@ class TestAgentModel(AgentModel):
         # if there are tools, the first thing we want to do is call all of them
         if self.tool_calls and not any(isinstance(m, ModelResponse) for m in messages):
             return ModelResponse(
-                parts=[ToolCallPart.from_raw_args(name, self.gen_tool_args(args)) for name, args in self.tool_calls],
+                parts=[ToolCallPart(name, self.gen_tool_args(args)) for name, args in self.tool_calls],
                 model_name=self.model_name,
             )
 
@@ -166,7 +179,7 @@ class TestAgentModel(AgentModel):
                 # Handle retries for both function tools and result tools
                 # Check function tools first
                 retry_parts: list[ModelResponsePart] = [
-                    ToolCallPart.from_raw_args(name, self.gen_tool_args(args))
+                    ToolCallPart(name, self.gen_tool_args(args))
                     for name, args in self.tool_calls
                     if name in new_retry_names
                 ]
@@ -174,15 +187,20 @@ class TestAgentModel(AgentModel):
                 if self.result_tools:
                     retry_parts.extend(
                         [
-                            ToolCallPart.from_raw_args(tool.name, self.gen_tool_args(tool))
+                            ToolCallPart(
+                                tool.name,
+                                self.result.value
+                                if isinstance(self.result, _FunctionToolResult) and self.result.value is not None
+                                else self.gen_tool_args(tool),
+                            )
                             for tool in self.result_tools
                             if tool.name in new_retry_names
                         ]
                     )
                 return ModelResponse(parts=retry_parts, model_name=self.model_name)
 
-        if response_text := self.result.left:
-            if response_text.value is None:
+        if isinstance(self.result, _TextResult):
+            if (response_text := self.result.value) is None:
                 # build up details of tool responses
                 output: dict[str, Any] = {}
                 for message in messages:
@@ -197,20 +215,18 @@ class TestAgentModel(AgentModel):
                 else:
                     return ModelResponse(parts=[TextPart('success (no tool calls)')], model_name=self.model_name)
             else:
-                return ModelResponse(parts=[TextPart(response_text.value)], model_name=self.model_name)
+                return ModelResponse(parts=[TextPart(response_text)], model_name=self.model_name)
         else:
             assert self.result_tools, 'No result tools provided'
-            custom_result_args = self.result.right
+            custom_result_args = self.result.value
             result_tool = self.result_tools[self.seed % len(self.result_tools)]
             if custom_result_args is not None:
                 return ModelResponse(
-                    parts=[ToolCallPart.from_raw_args(result_tool.name, custom_result_args)], model_name=self.model_name
+                    parts=[ToolCallPart(result_tool.name, custom_result_args)], model_name=self.model_name
                 )
             else:
                 response_args = self.gen_tool_args(result_tool)
-                return ModelResponse(
-                    parts=[ToolCallPart.from_raw_args(result_tool.name, response_args)], model_name=self.model_name
-                )
+                return ModelResponse(parts=[ToolCallPart(result_tool.name, response_args)], model_name=self.model_name)
 
 
 @dataclass
@@ -241,9 +257,8 @@ class TestStreamedResponse(StreamedResponse):
                     self._usage += _get_string_usage(word)
                     yield self._parts_manager.handle_text_delta(vendor_part_id=i, content=word)
             else:
-                args = part.args.args_json if isinstance(part.args, ArgsJson) else part.args.args_dict
                 yield self._parts_manager.handle_tool_call_part(
-                    vendor_part_id=i, tool_name=part.tool_name, args=args, tool_call_id=part.tool_call_id
+                    vendor_part_id=i, tool_name=part.tool_name, args=part.args, tool_call_id=part.tool_call_id
                 )
 
     def timestamp(self) -> datetime:

pydantic_ai/result.py

@@ -46,7 +46,7 @@ A function that always takes and returns the same type of data (which is the res
 * may or may not take [`RunContext`][pydantic_ai.tools.RunContext] as a first argument
 * may or may not be async
 
-Usage `ResultValidatorFunc[AgentDeps, T]`.
+Usage `ResultValidatorFunc[AgentDepsT, T]`.
 """
 
 _logfire = logfire_api.Logfire(otel_scope='pydantic-ai')

pydantic_ai/settings.py

@@ -80,11 +80,51 @@ class ModelSettings(TypedDict, total=False):
     """Whether to allow parallel tool calls.
 
     Supported by:
-    * OpenAI
+    * OpenAI (some models, not o1)
     * Groq
     * Anthropic
     """
 
+    seed: int
+    """The random seed to use for the model, theoretically allowing for deterministic results.
+
+    Supported by:
+    * OpenAI
+    * Groq
+    * Cohere
+    * Mistral
+    """
+
+    presence_penalty: float
+    """Penalize new tokens based on whether they have appeared in the text so far.
+
+    Supported by:
+    * OpenAI
+    * Groq
+    * Cohere
+    * Gemini
+    * Mistral
+    """
+
+    frequency_penalty: float
+    """Penalize new tokens based on their existing frequency in the text so far.
+
+    Supported by:
+    * OpenAI
+    * Groq
+    * Cohere
+    * Gemini
+    * Mistral
+    """
+
+    logit_bias: dict[str, int]
+    """Modify the likelihood of specified tokens appearing in the completion.
+
+    Supported by:
+    * OpenAI
+    * Groq
+    """
+
 
 def merge_model_settings(base: ModelSettings | None, overrides: ModelSettings | None) -> ModelSettings | None:
     """Merge two sets of model settings, preferring the overrides.

pydantic_ai/tools.py

@@ -79,13 +79,13 @@ SystemPromptFunc = Union[
 ]
 """A function that may or maybe not take `RunContext` as an argument, and may or may not be async.
 
-Usage `SystemPromptFunc[AgentDeps]`.
+Usage `SystemPromptFunc[AgentDepsT]`.
 """
 
 ToolFuncContext = Callable[Concatenate[RunContext[AgentDepsT], ToolParams], Any]
 """A tool function that takes `RunContext` as the first argument.
 
-Usage `ToolContextFunc[AgentDeps, ToolParams]`.
+Usage `ToolContextFunc[AgentDepsT, ToolParams]`.
 """
 ToolFuncPlain = Callable[ToolParams, Any]
 """A tool function that does not take `RunContext` as the first argument.
@@ -98,7 +98,7 @@ ToolFuncEither = Union[ToolFuncContext[AgentDepsT, ToolParams], ToolFuncPlain[To
 This is just a union of [`ToolFuncContext`][pydantic_ai.tools.ToolFuncContext] and
 [`ToolFuncPlain`][pydantic_ai.tools.ToolFuncPlain].
 
-Usage `ToolFuncEither[AgentDeps, ToolParams]`.
+Usage `ToolFuncEither[AgentDepsT, ToolParams]`.
 """
 ToolPrepareFunc: TypeAlias = 'Callable[[RunContext[AgentDepsT], ToolDefinition], Awaitable[ToolDefinition | None]]'
 """Definition of a function that can prepare a tool definition at call time.
@@ -125,7 +125,7 @@ def hitchhiker(ctx: RunContext[int], answer: str) -> str:
 hitchhiker = Tool(hitchhiker, prepare=only_if_42)
 ```
 
-Usage `ToolPrepareFunc[AgentDeps]`.
+Usage `ToolPrepareFunc[AgentDepsT]`.
 """
 
 DocstringFormat = Literal['google', 'numpy', 'sphinx', 'auto']
@@ -158,6 +158,9 @@ class Tool(Generic[AgentDepsT]):
     _var_positional_field: str | None = field(init=False)
     _validator: SchemaValidator = field(init=False, repr=False)
     _parameters_json_schema: ObjectJsonSchema = field(init=False)
+
+    # TODO: Move this state off the Tool class, which is otherwise stateless.
+    #   This should be tracked inside a specific agent run, not the tool.
     current_retry: int = field(default=0, init=False)
 
     def __init__(
@@ -261,13 +264,13 @@ class Tool(Generic[AgentDepsT]):
 
     async def run(
         self, message: _messages.ToolCallPart, run_context: RunContext[AgentDepsT]
-    ) -> _messages.ModelRequestPart:
+    ) -> _messages.ToolReturnPart | _messages.RetryPromptPart:
         """Run the tool function asynchronously."""
         try:
-            if isinstance(message.args, _messages.ArgsJson):
-                args_dict = self._validator.validate_json(message.args.args_json)
+            if isinstance(message.args, str):
+                args_dict = self._validator.validate_json(message.args)
             else:
-                args_dict = self._validator.validate_python(message.args.args_dict)
+                args_dict = self._validator.validate_python(message.args)
         except ValidationError as e:
             return self._on_error(e, message)
 

{pydantic_ai_slim-0.0.20.dist-info → pydantic_ai_slim-0.0.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.20
+Version: 0.0.21
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -34,7 +34,7 @@ Requires-Dist: anthropic>=0.40.0; extra == 'anthropic'
 Provides-Extra: cohere
 Requires-Dist: cohere>=5.13.11; extra == 'cohere'
 Provides-Extra: graph
-Requires-Dist: pydantic-graph==0.0.20; extra == 'graph'
+Requires-Dist: pydantic-graph==0.0.21; extra == 'graph'
 Provides-Extra: groq
 Requires-Dist: groq>=0.12.0; extra == 'groq'
 Provides-Extra: logfire

pydantic_ai_slim-0.0.21.dist-info/RECORD

@@ -0,0 +1,29 @@
+pydantic_ai/__init__.py,sha256=FbYetEgT6OO25u2KF5ZnFxKpz5DtnSpfckRXP4mjl8E,489
+pydantic_ai/_griffe.py,sha256=RYRKiLbgG97QxnazbAwlnc74XxevGHLQet-FGfq9qls,3960
+pydantic_ai/_parts_manager.py,sha256=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=7o7yfatFPBDkrpSi2t0A4xivX7lzlNbOhtIMEJQpLKc,63620
+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/settings.py,sha256=QSqs4_l_Gs2v4oixYNwKQhPiec_m9pn6XEAeUMFxt24,3054
+pydantic_ai/tools.py,sha256=lhupwm815lPlFFS79B0P61AyhUYtepA62LbZOCJrPEY,13205
+pydantic_ai/usage.py,sha256=60d9f6M7YEYuKMbqDGDogX4KsA73fhDtWyDXYXoIPaI,4948
+pydantic_ai/models/__init__.py,sha256=XgZAhiSVVX0TbePHXSxVnDIbG38jQG9g3WRMlA_EHDY,13063
+pydantic_ai/models/anthropic.py,sha256=v2m6zjaezLjtkHO2Rx67rmoN1iOqDeAp9fswJcqRMBA,16967
+pydantic_ai/models/cohere.py,sha256=wyjtD2uwkYYbsXLKwr-flmXSng_Atd-0jqtVDxDie14,10611
+pydantic_ai/models/function.py,sha256=jv2aw5K4KrMIRPFSTiGbBHcv16UZtGEe_1irjTudLg0,9826
+pydantic_ai/models/gemini.py,sha256=espBJbEMZjdzT5fC_rKOHoo_5o5xH-Y1Ea-RZR4JaPs,28222
+pydantic_ai/models/groq.py,sha256=W-uosi9PtvgXp8yoF6w8QZxPtrVjX1fmRQDjQQ10meE,13603
+pydantic_ai/models/mistral.py,sha256=RuRlxTBPGXIpcwTdjX2596uN2tgHBvCDQCWieWa1A_Q,24793
+pydantic_ai/models/openai.py,sha256=6ymsBzyu9WJVewbn3345jt_JoXpUpCLYOQERYJJlyRY,15228
+pydantic_ai/models/test.py,sha256=D_wBpRtrPcikopd5LBYjdAp3q-1gvuB9WnuopBQiRME,16659
+pydantic_ai/models/vertexai.py,sha256=bQZ5W8n4521AH3jTiyP1fOYxtNgCgkhjCbBeASv5Ap8,9388
+pydantic_ai_slim-0.0.21.dist-info/METADATA,sha256=EeGz0ZJG_g_o7xKu-2XiXN2zZsBhGZLwL39QaQGZQdc,2879
+pydantic_ai_slim-0.0.21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.0.21.dist-info/RECORD,,

pydantic_ai/models/ollama.py

@@ -1,123 +0,0 @@
-from __future__ import annotations as _annotations
-
-from dataclasses import dataclass
-from typing import Literal, Union
-
-from httpx import AsyncClient as AsyncHTTPClient
-
-from ..tools import ToolDefinition
-from . import (
-    AgentModel,
-    Model,
-    cached_async_http_client,
-    check_allow_model_requests,
-)
-
-try:
-    from openai import AsyncOpenAI
-except ImportError as e:
-    raise ImportError(
-        'Please install `openai` to use the OpenAI model, '
-        "you can use the `openai` optional group — `pip install 'pydantic-ai-slim[openai]'`"
-    ) from e
-
-
-from .openai import OpenAIModel
-
-CommonOllamaModelNames = Literal[
-    'codellama',
-    'deepseek-r1',
-    'gemma',
-    'gemma2',
-    'llama3',
-    'llama3.1',
-    'llama3.2',
-    'llama3.2-vision',
-    'llama3.3',
-    'mistral',
-    'mistral-nemo',
-    'mixtral',
-    'phi3',
-    'phi4',
-    'qwq',
-    'qwen',
-    'qwen2',
-    'qwen2.5',
-    'starcoder2',
-]
-"""This contains just the most common ollama models.
-
-For a full list see [ollama.com/library](https://ollama.com/library).
-"""
-OllamaModelName = Union[CommonOllamaModelNames, str]
-"""Possible ollama models.
-
-Since Ollama supports hundreds of models, we explicitly list the most models but
-allow any name in the type hints.
-"""
-
-
-@dataclass(init=False)
-class OllamaModel(Model):
-    """A model that implements Ollama using the OpenAI API.
-
-    Internally, this uses the [OpenAI Python client](https://github.com/openai/openai-python) to interact with the Ollama server.
-
-    Apart from `__init__`, all methods are private or match those of the base class.
-    """
-
-    model_name: OllamaModelName
-    openai_model: OpenAIModel
-
-    def __init__(
-        self,
-        model_name: OllamaModelName,
-        *,
-        base_url: str | None = 'http://localhost:11434/v1/',
-        api_key: str = 'ollama',
-        openai_client: AsyncOpenAI | None = None,
-        http_client: AsyncHTTPClient | None = None,
-    ):
-        """Initialize an Ollama model.
-
-        Ollama has built-in compatability for the OpenAI chat completions API ([source](https://ollama.com/blog/openai-compatibility)), so we reuse the
-        [`OpenAIModel`][pydantic_ai.models.openai.OpenAIModel] here.
-
-        Args:
-            model_name: The name of the Ollama model to use. List of models available [here](https://ollama.com/library)
-                You must first download the model (`ollama pull <MODEL-NAME>`) in order to use the model
-            base_url: The base url for the ollama requests. The default value is the ollama default
-            api_key: The API key to use for authentication. Defaults to 'ollama' for local instances,
-                but can be customized for proxy setups that require authentication
-            openai_client: An existing
-                [`AsyncOpenAI`](https://github.com/openai/openai-python?tab=readme-ov-file#async-usage)
-                client to use, if provided, `base_url` and `http_client` must be `None`.
-            http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
-        """
-        self.model_name = model_name
-        if openai_client is not None:
-            assert base_url is None, 'Cannot provide both `openai_client` and `base_url`'
-            assert http_client is None, 'Cannot provide both `openai_client` and `http_client`'
-            self.openai_model = OpenAIModel(model_name=model_name, openai_client=openai_client)
-        else:
-            # API key is not required for ollama but a value is required to create the client
-            http_client_ = http_client or cached_async_http_client()
-            oai_client = AsyncOpenAI(base_url=base_url, api_key=api_key, http_client=http_client_)
-            self.openai_model = OpenAIModel(model_name=model_name, openai_client=oai_client)
-
-    async def agent_model(
-        self,
-        *,
-        function_tools: list[ToolDefinition],
-        allow_text_result: bool,
-        result_tools: list[ToolDefinition],
-    ) -> AgentModel:
-        check_allow_model_requests()
-        return await self.openai_model.agent_model(
-            function_tools=function_tools,
-            allow_text_result=allow_text_result,
-            result_tools=result_tools,
-        )
-
-    def name(self) -> str:
-        return f'ollama:{self.model_name}'

pydantic_ai_slim-0.0.20.dist-info/RECORD

@@ -1,30 +0,0 @@
-pydantic_ai/__init__.py,sha256=FbYetEgT6OO25u2KF5ZnFxKpz5DtnSpfckRXP4mjl8E,489
-pydantic_ai/_griffe.py,sha256=RYRKiLbgG97QxnazbAwlnc74XxevGHLQet-FGfq9qls,3960
-pydantic_ai/_parts_manager.py,sha256=pMDZs6BGC8EmaNa-73QvuptmxdG2MhBrBLIydCOl-gM,11886
-pydantic_ai/_pydantic.py,sha256=dROz3Hmfdi0C2exq88FhefDRVo_8S3rtkXnoUHzsz0c,8753
-pydantic_ai/_result.py,sha256=zlkI82g78DeLW4zTCP3OgWeMUUOqxeDdu0nxLKYsv9c,10381
-pydantic_ai/_system_prompt.py,sha256=602c2jyle2R_SesOrITBDETZqsLk4BZ8Cbo8yEhmx04,1120
-pydantic_ai/_utils.py,sha256=EHW866W6ZpGJLCWtoEAcwIPeWo9OQFhnD5el2DwVcwc,10949
-pydantic_ai/agent.py,sha256=EwaH207k4LcU_M-DYom8ZFiKMVaHJ2ZobxU2WjjsrSk,63500
-pydantic_ai/exceptions.py,sha256=eGDKX6bGhgVxXBzu81Sk3iiAkXr0GUtgT7bD5Rxlqpg,2028
-pydantic_ai/format_as_xml.py,sha256=QE7eMlg5-YUMw1_2kcI3h0uKYPZZyGkgXFDtfZTMeeI,4480
-pydantic_ai/messages.py,sha256=V6JwFuADF21wKfszqT1CNgiYUeSAuJzjsngD-BJo3Y4,17841
-pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/result.py,sha256=uubCdc51fYeZwkGGy1E9x2H9WP8FKoeqNQDaL0vzD1s,18393
-pydantic_ai/settings.py,sha256=Yn4cXoESeJouFktfWqY1o0Exlf6yHfsvf6Uw6iMkuZQ,2278
-pydantic_ai/tools.py,sha256=IrFeIxYQcpRUCrIv9p_4-hqmpjmUNC3dVwvr0gXf-1w,13057
-pydantic_ai/usage.py,sha256=60d9f6M7YEYuKMbqDGDogX4KsA73fhDtWyDXYXoIPaI,4948
-pydantic_ai/models/__init__.py,sha256=-tsz2kKwqvLXhTXk2WvdxB-PoMcaA043sQhkhzM9OFU,11715
-pydantic_ai/models/anthropic.py,sha256=xhTTSq7wniIf4IlTyIAIGSmXpuXUvVOF9I6TRJLfmeo,16645
-pydantic_ai/models/cohere.py,sha256=fGuXNpHUXfhfQ9AyG-Bo-Zet2njuNhjcpELmsCjhsvo,9933
-pydantic_ai/models/function.py,sha256=jv2aw5K4KrMIRPFSTiGbBHcv16UZtGEe_1irjTudLg0,9826
-pydantic_ai/models/gemini.py,sha256=nixBvW4YEtzURAj1qQrVEHKabFN13SUV1QgA1lm_eWo,27595
-pydantic_ai/models/groq.py,sha256=6V_b4Gj63Uask8CfZLO1RjCNdv2FYd8SVjcRtMLMvgo,13355
-pydantic_ai/models/mistral.py,sha256=8kyZiHeAOaZdcJCwFF_xgS_dJkq_e9xwjFOv9IE3YPY,24766
-pydantic_ai/models/ollama.py,sha256=CEgcMW6KliaS7h5Fakx80EmSgm4rDLNjofBOCwM15lM,4288
-pydantic_ai/models/openai.py,sha256=MV7S6hxW6PTOAWNmKBLTZ-e6vkYMByQXT16t4KK54DA,14776
-pydantic_ai/models/test.py,sha256=SKtWqfjc8cb-U2gXJD1U43POxQnHFj_bEx734tCMov0,16328
-pydantic_ai/models/vertexai.py,sha256=bQZ5W8n4521AH3jTiyP1fOYxtNgCgkhjCbBeASv5Ap8,9388
-pydantic_ai_slim-0.0.20.dist-info/METADATA,sha256=3Z-xQLFaAP-JStPOVeiZFwU8ZkIbXzUCkBh8TkLEbuQ,2879
-pydantic_ai_slim-0.0.20.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.0.20.dist-info/RECORD,,