pydantic-ai-slim 0.0.6a3__py3-none-any.whl → 0.0.7__py3-none-any.whl

pydantic_ai/messages.py

@@ -55,7 +55,7 @@ json_ta: TypeAdapter[JsonData] = TypeAdapter(JsonData)
 
 @dataclass
 class ToolReturn:
-    """A tool return message, this encodes the result of running a retriever."""
+    """A tool return message, this encodes the result of running a tool."""
 
     tool_name: str
     """The name of the "tool" was called."""
@@ -89,10 +89,10 @@ class RetryPrompt:
 
     This can be sent for a number of reasons:
 
-    * Pydantic validation of retriever arguments failed, here content is derived from a Pydantic
+    * Pydantic validation of tool arguments failed, here content is derived from a Pydantic
       [`ValidationError`][pydantic_core.ValidationError]
-    * a retriever raised a [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] exception
-    * no retriever was found for the tool name
+    * a tool raised a [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] exception
+    * no tool was found for the tool name
     * the model returned plain text when a structured response was expected
     * Pydantic validation of a structured response failed, here content is derived from a Pydantic
       [`ValidationError`][pydantic_core.ValidationError]
@@ -144,8 +144,8 @@ class ArgsJson:
 
 
 @dataclass
-class ArgsObject:
-    args_object: dict[str, Any]
+class ArgsDict:
+    args_dict: dict[str, Any]
     """A python dictionary of arguments."""
 
 
@@ -155,7 +155,7 @@ class ToolCall:
 
     tool_name: str
     """The name of the tool to call."""
-    args: ArgsJson | ArgsObject
+    args: ArgsJson | ArgsDict
     """The arguments to pass to the tool.
 
     Either as JSON or a Python dictionary depending on how data was returned.
@@ -168,12 +168,12 @@ class ToolCall:
         return cls(tool_name, ArgsJson(args_json), tool_id)
 
     @classmethod
-    def from_object(cls, tool_name: str, args_object: dict[str, Any]) -> ToolCall:
-        return cls(tool_name, ArgsObject(args_object))
+    def from_dict(cls, tool_name: str, args_dict: dict[str, Any]) -> ToolCall:
+        return cls(tool_name, ArgsDict(args_dict))
 
     def has_content(self) -> bool:
-        if isinstance(self.args, ArgsObject):
-            return any(self.args.args_object.values())
+        if isinstance(self.args, ArgsDict):
+            return any(self.args.args_dict.values())
         else:
             return bool(self.args.args_json)
 
@@ -182,7 +182,7 @@ class ToolCall:
 class ModelStructuredResponse:
     """A structured response from a model.
 
-    This is used either to call a retriever or to return a structured response from an agent run.
+    This is used either to call a tool or to return a structured response from an agent run.
     """
 
     calls: list[ToolCall]

pydantic_ai/models/__init__.py

@@ -63,7 +63,7 @@ class Model(ABC):
     @abstractmethod
     async def agent_model(
         self,
-        retrievers: Mapping[str, AbstractToolDefinition],
+        function_tools: Mapping[str, AbstractToolDefinition],
         allow_text_result: bool,
         result_tools: Sequence[AbstractToolDefinition] | None,
     ) -> AgentModel:
@@ -72,7 +72,7 @@ class Model(ABC):
         This is async in case slow/async config checks need to be performed that can't be done in `__init__`.
 
         Args:
-            retrievers: The retrievers available to the agent.
+            function_tools: The tools available to the agent.
             allow_text_result: Whether a plain text final response/result is permitted.
             result_tools: Tool definitions for the final result tool(s), if any.
 
@@ -259,7 +259,7 @@ def infer_model(model: Model | KnownModelName) -> Model:
 class AbstractToolDefinition(Protocol):
     """Abstract definition of a function/tool.
 
-    This is used for both retrievers and result tools.
+    This is used for both tools and result tools.
     """
 
     name: str

pydantic_ai/models/function.py

@@ -1,11 +1,3 @@
-"""A model controlled by a local function.
-
-[FunctionModel][pydantic_ai.models.function.FunctionModel] is similar to [TestModel][pydantic_ai.models.test.TestModel],
-but allows greater control over the model's behavior.
-
-It's primary use case for more advanced unit testing than is possible with `TestModel`.
-"""
-
 from __future__ import annotations as _annotations
 
 import inspect
@@ -67,13 +59,13 @@ class FunctionModel(Model):
 
     async def agent_model(
         self,
-        retrievers: Mapping[str, AbstractToolDefinition],
+        function_tools: Mapping[str, AbstractToolDefinition],
         allow_text_result: bool,
         result_tools: Sequence[AbstractToolDefinition] | None,
     ) -> AgentModel:
         result_tools = list(result_tools) if result_tools is not None else None
         return FunctionAgentModel(
-            self.function, self.stream_function, AgentInfo(retrievers, allow_text_result, result_tools)
+            self.function, self.stream_function, AgentInfo(function_tools, allow_text_result, result_tools)
         )
 
     def name(self) -> str:
@@ -89,11 +81,15 @@ class FunctionModel(Model):
 class AgentInfo:
     """Information about an agent.
 
-    This is passed as the second to functions.
+    This is passed as the second to functions used within [`FunctionModel`][pydantic_ai.models.function.FunctionModel].
     """
 
-    retrievers: Mapping[str, AbstractToolDefinition]
-    """The retrievers available on this agent."""
+    function_tools: Mapping[str, AbstractToolDefinition]
+    """The function tools available on this agent.
+
+    These are the tools registered via the [`tool`][pydantic_ai.Agent.tool] and
+    [`tool_plain`][pydantic_ai.Agent.tool_plain] decorators.
+    """
     allow_text_result: bool
     """Whether a plain text result is allowed."""
     result_tools: list[AbstractToolDefinition] | None
@@ -254,7 +250,7 @@ def _estimate_cost(messages: Iterable[Message]) -> result.Cost:
                 if isinstance(call.args, ArgsJson):
                     args_str = call.args.args_json
                 else:
-                    args_str = pydantic_core.to_json(call.args.args_object).decode()
+                    args_str = pydantic_core.to_json(call.args.args_dict).decode()
 
                 response_tokens += 1 + _string_cost(args_str)
         else:

pydantic_ai/models/gemini.py

@@ -1,25 +1,3 @@
-"""Custom interface to the `generativelanguage.googleapis.com` API using [HTTPX] and [Pydantic].
-
-The Google SDK for interacting with the `generativelanguage.googleapis.com` API
-[`google-generativeai`](https://ai.google.dev/gemini-api/docs/quickstart?lang=python) reads like it was written by a
-Java developer who thought they knew everything about OOP, spent 30 minutes trying to learn Python,
-gave up and decided to build the library to prove how horrible Python is. It also doesn't use httpx for HTTP requests,
-and tries to implement tool calling itself, but doesn't use Pydantic or equivalent for validation.
-
-We could also use the Google Vertex SDK,
-[`google-cloud-aiplatform`](https://cloud.google.com/vertex-ai/docs/python-sdk/use-vertex-ai-python-sdk)
-which uses the `*-aiplatform.googleapis.com` API, but that requires a service account for authentication
-which is a faff to set up and manage.
-
-Both APIs claim compatibility with OpenAI's API, but that breaks down with even the simplest of requests,
-hence this custom interface.
-
-Despite these limitations, the Gemini model is actually quite powerful and very fast.
-
-[HTTPX]: https://www.python-httpx.org/
-[Pydantic]: https://docs.pydantic.dev/latest/
-"""
-
 from __future__ import annotations as _annotations
 
 import os
@@ -38,7 +16,7 @@ from typing_extensions import NotRequired, TypedDict, TypeGuard, assert_never
 
 from .. import UnexpectedModelBehavior, _pydantic, _utils, exceptions, result
 from ..messages import (
-    ArgsObject,
+    ArgsDict,
     Message,
     ModelAnyResponse,
     ModelStructuredResponse,
@@ -112,7 +90,7 @@ class GeminiModel(Model):
 
     async def agent_model(
         self,
-        retrievers: Mapping[str, AbstractToolDefinition],
+        function_tools: Mapping[str, AbstractToolDefinition],
         allow_text_result: bool,
         result_tools: Sequence[AbstractToolDefinition] | None,
     ) -> GeminiAgentModel:
@@ -121,7 +99,7 @@ class GeminiModel(Model):
             model_name=self.model_name,
             auth=self.auth,
             url=self.url,
-            retrievers=retrievers,
+            function_tools=function_tools,
             allow_text_result=allow_text_result,
             result_tools=result_tools,
         )
@@ -160,12 +138,12 @@ class GeminiAgentModel(AgentModel):
         model_name: GeminiModelName,
         auth: AuthProtocol,
         url: str,
-        retrievers: Mapping[str, AbstractToolDefinition],
+        function_tools: Mapping[str, AbstractToolDefinition],
         allow_text_result: bool,
         result_tools: Sequence[AbstractToolDefinition] | None,
     ):
         check_allow_model_requests()
-        tools = [_function_from_abstract_tool(t) for t in retrievers.values()]
+        tools = [_function_from_abstract_tool(t) for t in function_tools.values()]
         if result_tools is not None:
             tools += [_function_from_abstract_tool(t) for t in result_tools]
 
@@ -442,15 +420,15 @@ class _GeminiFunctionCallPart(TypedDict):
 
 
 def _function_call_part_from_call(tool: ToolCall) -> _GeminiFunctionCallPart:
-    assert isinstance(tool.args, ArgsObject), f'Expected ArgsObject, got {tool.args}'
-    return _GeminiFunctionCallPart(function_call=_GeminiFunctionCall(name=tool.tool_name, args=tool.args.args_object))
+    assert isinstance(tool.args, ArgsDict), f'Expected ArgsObject, got {tool.args}'
+    return _GeminiFunctionCallPart(function_call=_GeminiFunctionCall(name=tool.tool_name, args=tool.args.args_dict))
 
 
 def _structured_response_from_parts(
     parts: list[_GeminiFunctionCallPart], timestamp: datetime | None = None
 ) -> ModelStructuredResponse:
     return ModelStructuredResponse(
-        calls=[ToolCall.from_object(part['function_call']['name'], part['function_call']['args']) for part in parts],
+        calls=[ToolCall.from_dict(part['function_call']['name'], part['function_call']['args']) for part in parts],
         timestamp=timestamp or _utils.now_utc(),
     )
 

pydantic_ai/models/groq.py

@@ -109,12 +109,12 @@ class GroqModel(Model):
 
     async def agent_model(
         self,
-        retrievers: Mapping[str, AbstractToolDefinition],
+        function_tools: Mapping[str, AbstractToolDefinition],
         allow_text_result: bool,
         result_tools: Sequence[AbstractToolDefinition] | None,
     ) -> AgentModel:
         check_allow_model_requests()
-        tools = [self._map_tool_definition(r) for r in retrievers.values()]
+        tools = [self._map_tool_definition(r) for r in function_tools.values()]
         if result_tools is not None:
             tools += [self._map_tool_definition(r) for r in result_tools]
         return GroqAgentModel(

pydantic_ai/models/openai.py

@@ -89,12 +89,12 @@ class OpenAIModel(Model):
 
     async def agent_model(
         self,
-        retrievers: Mapping[str, AbstractToolDefinition],
+        function_tools: Mapping[str, AbstractToolDefinition],
         allow_text_result: bool,
         result_tools: Sequence[AbstractToolDefinition] | None,
     ) -> AgentModel:
         check_allow_model_requests()
-        tools = [self._map_tool_definition(r) for r in retrievers.values()]
+        tools = [self._map_tool_definition(r) for r in function_tools.values()]
         if result_tools is not None:
             tools += [self._map_tool_definition(r) for r in result_tools]
         return OpenAIAgentModel(

pydantic_ai/models/test.py

@@ -1,5 +1,3 @@
-"""Utilities for testing apps built with PydanticAI."""
-
 from __future__ import annotations as _annotations
 
 import re
@@ -7,7 +5,7 @@ import string
 from collections.abc import AsyncIterator, Iterable, Iterator, Mapping, Sequence
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import date, datetime, timedelta
 from typing import Any, Literal
 
 import pydantic_core
@@ -45,10 +43,10 @@ UnSet = UnSetType()
 class TestModel(Model):
     """A model specifically for testing purposes.
 
-    This will (by default) call all retrievers in the agent model, then return a tool response if possible,
+    This will (by default) call all tools in the agent, then return a tool response if possible,
     otherwise a plain response.
 
-    How useful this function will be is unknown, it may be useless, it may require significant changes to be useful.
+    How useful this model is will vary significantly.
 
     Apart from `__init__` derived by the `dataclass` decorator, all methods are private or match those
     of the base class.
@@ -57,8 +55,8 @@ class TestModel(Model):
     # NOTE: Avoid test discovery by pytest.
     __test__ = False
 
-    call_retrievers: list[str] | Literal['all'] = 'all'
-    """List of retrievers to call. If `'all'`, all retrievers will be called."""
+    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."""
     custom_result_args: Any | None = None
@@ -66,25 +64,25 @@ class TestModel(Model):
     seed: int = 0
     """Seed for generating random data."""
     # these fields are set when the model is called by the agent
-    agent_model_retrievers: Mapping[str, AbstractToolDefinition] | None = field(default=None, init=False)
+    agent_model_tools: Mapping[str, AbstractToolDefinition] | None = field(default=None, init=False)
     agent_model_allow_text_result: bool | None = field(default=None, init=False)
     agent_model_result_tools: list[AbstractToolDefinition] | None = field(default=None, init=False)
 
     async def agent_model(
         self,
-        retrievers: Mapping[str, AbstractToolDefinition],
+        function_tools: Mapping[str, AbstractToolDefinition],
         allow_text_result: bool,
         result_tools: Sequence[AbstractToolDefinition] | None,
     ) -> AgentModel:
-        self.agent_model_retrievers = retrievers
+        self.agent_model_tools = function_tools
         self.agent_model_allow_text_result = allow_text_result
         self.agent_model_result_tools = list(result_tools) if result_tools is not None else None
 
-        if self.call_retrievers == 'all':
-            retriever_calls = [(r.name, r) for r in retrievers.values()]
+        if self.call_tools == 'all':
+            tool_calls = [(r.name, r) for r in function_tools.values()]
         else:
-            retrievers_to_call = (retrievers[name] for name in self.call_retrievers)
-            retriever_calls = [(r.name, r) for r in retrievers_to_call]
+            tools_to_call = (function_tools[name] for name in self.call_tools)
+            tool_calls = [(r.name, r) for r in tools_to_call]
 
         if self.custom_result_text is not None:
             assert allow_text_result, 'Plain response not allowed, but `custom_result_text` is set.'
@@ -104,7 +102,7 @@ class TestModel(Model):
             result = _utils.Either(right=None)
         else:
             result = _utils.Either(left=None)
-        return TestAgentModel(retriever_calls, result, self.agent_model_result_tools, self.seed)
+        return TestAgentModel(tool_calls, result, self.agent_model_result_tools, self.seed)
 
     def name(self) -> str:
         return 'test-model'
@@ -117,7 +115,7 @@ class TestAgentModel(AgentModel):
     # NOTE: Avoid test discovery by pytest.
     __test__ = False
 
-    retriever_calls: list[tuple[str, AbstractToolDefinition]]
+    tool_calls: list[tuple[str, AbstractToolDefinition]]
     # left means the text is plain text; right means it's a function call
     result: _utils.Either[str | None, Any | None]
     result_tools: list[AbstractToolDefinition] | None
@@ -137,12 +135,12 @@ class TestAgentModel(AgentModel):
         else:
             yield TestStreamStructuredResponse(msg, cost)
 
-    def gen_retriever_args(self, tool_def: AbstractToolDefinition) -> Any:
+    def gen_tool_args(self, tool_def: AbstractToolDefinition) -> Any:
         return _JsonSchemaTestData(tool_def.json_schema, self.seed).generate()
 
     def _request(self, messages: list[Message]) -> ModelAnyResponse:
-        if self.step == 0 and self.retriever_calls:
-            calls = [ToolCall.from_object(name, self.gen_retriever_args(args)) for name, args in self.retriever_calls]
+        if self.step == 0 and self.tool_calls:
+            calls = [ToolCall.from_dict(name, self.gen_tool_args(args)) for name, args in self.tool_calls]
             self.step += 1
             self.last_message_count = len(messages)
             return ModelStructuredResponse(calls=calls)
@@ -152,8 +150,8 @@ class TestAgentModel(AgentModel):
         new_retry_names = {m.tool_name for m in new_messages if isinstance(m, RetryPrompt)}
         if new_retry_names:
             calls = [
-                ToolCall.from_object(name, self.gen_retriever_args(args))
-                for name, args in self.retriever_calls
+                ToolCall.from_dict(name, self.gen_tool_args(args))
+                for name, args in self.tool_calls
                 if name in new_retry_names
             ]
             self.step += 1
@@ -162,7 +160,7 @@ class TestAgentModel(AgentModel):
             if response_text := self.result.left:
                 self.step += 1
                 if response_text.value is None:
-                    # build up details of retriever responses
+                    # build up details of tool responses
                     output: dict[str, Any] = {}
                     for message in messages:
                         if isinstance(message, ToolReturn):
@@ -170,7 +168,7 @@ class TestAgentModel(AgentModel):
                     if output:
                         return ModelTextResponse(content=pydantic_core.to_json(output).decode())
                     else:
-                        return ModelTextResponse(content='success (no retriever calls)')
+                        return ModelTextResponse(content='success (no tool calls)')
                 else:
                     return ModelTextResponse(content=response_text.value)
             else:
@@ -179,11 +177,11 @@ class TestAgentModel(AgentModel):
                 result_tool = self.result_tools[self.seed % len(self.result_tools)]
                 if custom_result_args is not None:
                     self.step += 1
-                    return ModelStructuredResponse(calls=[ToolCall.from_object(result_tool.name, custom_result_args)])
+                    return ModelStructuredResponse(calls=[ToolCall.from_dict(result_tool.name, custom_result_args)])
                 else:
-                    response_args = self.gen_retriever_args(result_tool)
+                    response_args = self.gen_tool_args(result_tool)
                     self.step += 1
-                    return ModelStructuredResponse(calls=[ToolCall.from_object(result_tool.name, response_args)])
+                    return ModelStructuredResponse(calls=[ToolCall.from_dict(result_tool.name, response_args)])
 
 
 @dataclass
@@ -320,8 +318,12 @@ class _JsonSchemaTestData:
 
         if schema.get('maxLength') == 0:
             return ''
-        else:
-            return self._char()
+
+        if fmt := schema.get('format'):
+            if fmt == 'date':
+                return (date(2024, 1, 1) + timedelta(days=self.seed)).isoformat()
+
+        return self._char()
 
     def _int_gen(self, schema: dict[str, Any]) -> int:
         """Generate an integer from a JSON Schema integer."""

pydantic_ai/models/vertexai.py

@@ -1,60 +1,3 @@
-"""Custom interface to the `*-aiplatform.googleapis.com` API for Gemini models.
-
-This model uses [`GeminiAgentModel`][pydantic_ai.models.gemini.GeminiAgentModel] with just the URL and auth method
-changed from the default `GeminiModel`, it relies on the VertexAI
-[`generateContent` function endpoint](https://cloud.google.com/vertex-ai/docs/reference/rest/v1/projects.locations.endpoints/generateContent)
-and `streamGenerateContent` function endpoints
-having the same schemas as the equivalent [Gemini endpoints][pydantic_ai.models.gemini.GeminiModel].
-
-There are four advantages of using this API over the `generativelanguage.googleapis.com` API which
-[`GeminiModel`][pydantic_ai.models.gemini.GeminiModel] uses, and one big disadvantage.
-
-Advantages:
-
-1. The VertexAI API seems to be less flakey, less likely to occasionally return a 503 response.
-2. You can
-   [purchase provisioned throughput](https://cloud.google.com/vertex-ai/generative-ai/docs/provisioned-throughput#purchase-provisioned-throughput)
-   with VertexAI.
-3. If you're running PydanticAI inside GCP, you don't need to set up authentication, it should "just work".
-4. You can decide which region to use, which might be important from a regulatory perspective,
-   and might improve latency.
-
-Disadvantage:
-
-1. When authorization doesn't just work, it's much more painful to set up than an API key.
-
-## Example Usage
-
-With the default google project already configured in your environment:
-
-```py title="vertex_example_env.py"
-from pydantic_ai import Agent
-from pydantic_ai.models.vertexai import VertexAIModel
-
-model = VertexAIModel('gemini-1.5-flash')
-agent = Agent(model)
-result = agent.run_sync('Tell me a joke.')
-print(result.data)
-#> Did you hear about the toothpaste scandal? They called it Colgate.
-```
-
-Or using a service account JSON file:
-
-```py title="vertex_example_service_account.py"
-from pydantic_ai import Agent
-from pydantic_ai.models.vertexai import VertexAIModel
-
-model = VertexAIModel(
-    'gemini-1.5-flash',
-    service_account_file='path/to/service-account.json',
-)
-agent = Agent(model)
-result = agent.run_sync('Tell me a joke.')
-print(result.data)
-#> Did you hear about the toothpaste scandal? They called it Colgate.
-```
-"""
-
 from __future__ import annotations as _annotations
 
 from collections.abc import Mapping, Sequence
@@ -166,7 +109,7 @@ class VertexAIModel(Model):
 
     async def agent_model(
         self,
-        retrievers: Mapping[str, AbstractToolDefinition],
+        function_tools: Mapping[str, AbstractToolDefinition],
         allow_text_result: bool,
         result_tools: Sequence[AbstractToolDefinition] | None,
     ) -> GeminiAgentModel:
@@ -176,7 +119,7 @@ class VertexAIModel(Model):
             model_name=self.model_name,
             auth=auth,
             url=url,
-            retrievers=retrievers,
+            function_tools=function_tools,
             allow_text_result=allow_text_result,
             result_tools=result_tools,
         )

{pydantic_ai_slim-0.0.6a3.dist-info → pydantic_ai_slim-0.0.7.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.3
 Name: pydantic-ai-slim
-Version: 0.0.6a3
-Summary: Agent Framework / shim to use Pydantic with LLMs
+Version: 0.0.7
+Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License: MIT
 Classifier: Development Status :: 4 - Beta
@@ -40,10 +40,14 @@ Requires-Dist: google-auth>=2.36.0; extra == 'vertexai'
 Requires-Dist: requests>=2.32.3; extra == 'vertexai'
 Description-Content-Type: text/markdown
 
-# Coming soon
+# PydanticAI Slim
 
 [![CI](https://github.com/pydantic/pydantic-ai/actions/workflows/ci.yml/badge.svg?event=push)](https://github.com/pydantic/pydantic-ai/actions/workflows/ci.yml?query=branch%3Amain)
 [![Coverage](https://coverage-badge.samuelcolvin.workers.dev/pydantic/pydantic-ai.svg)](https://coverage-badge.samuelcolvin.workers.dev/redirect/pydantic/pydantic-ai)
 [![PyPI](https://img.shields.io/pypi/v/pydantic-ai.svg)](https://pypi.python.org/pypi/pydantic-ai)
 [![versions](https://img.shields.io/pypi/pyversions/pydantic-ai.svg)](https://github.com/pydantic/pydantic-ai)
 [![license](https://img.shields.io/github/license/pydantic/pydantic-ai.svg?v)](https://github.com/pydantic/pydantic-ai/blob/main/LICENSE)
+
+PydanticAI core logic with minimal required dependencies.
+
+For more information on how to use this package see [ai.pydantic.dev/install](https://ai.pydantic.dev/install/).

pydantic_ai_slim-0.0.7.dist-info/RECORD

@@ -0,0 +1,23 @@
+pydantic_ai/__init__.py,sha256=KaTzG8uBSEpfxk_y2a_O_R2Xa53GXYfiigjWtD4PCeI,317
+pydantic_ai/_griffe.py,sha256=pRjCJ6B1hhx6k46XJgl9zF6aRYxRmqEZKFok8unp4Iw,3449
+pydantic_ai/_pydantic.py,sha256=j1kObPIUDwn1VOHbJBwMFbWLxHM_OYRH7GFAda68ZC0,8010
+pydantic_ai/_result.py,sha256=cAqfPipK39cz-p-ftlJ83Q5_LI1TRb3-HH-iivb5rEM,9674
+pydantic_ai/_system_prompt.py,sha256=63egOej8zHsDVOInPayn0EEEDXKd0HVAbbrqXUTV96s,1092
+pydantic_ai/_tool.py,sha256=5Q9XaGOEXbyOLS644osB1AA5EMoJkr4eYK60MVZo0Z8,4528
+pydantic_ai/_utils.py,sha256=eNb7f3-ZQC8WDEa87iUcXGQ-lyuutFQG-5yBCMD4Vvs,8227
+pydantic_ai/agent.py,sha256=RhLl6tf6kogtauqQr3U1ufg712k-g002YPcio9-BPB4,34242
+pydantic_ai/dependencies.py,sha256=EHvD68AFkItxMnfHzJLG7T_AD1RGI2MZOfzm1v89hGQ,2399
+pydantic_ai/exceptions.py,sha256=ko_47M0k6Rhg9mUC9P1cj7N4LCH6cC0pEsF65A2vL-U,1561
+pydantic_ai/messages.py,sha256=tyBs2ucqIrKjjMIX2bvjMaZ6BMxim4VBkmCzTbeH-AI,7493
+pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_ai/result.py,sha256=Gs2ZjuFJgONGJm8M5R2mGph5-lUFLBg7FxVrs2CVDPs,13525
+pydantic_ai/models/__init__.py,sha256=Cx8PjEsi5gkNOVQic32sf4CmM-A3pRu1LcjpM6poiBI,10138
+pydantic_ai/models/function.py,sha256=Mzc-zXnb2RayWAA8N9NS7KGF49do1S-VW3U9fkc661o,10045
+pydantic_ai/models/gemini.py,sha256=2mD5MJT7qaiMAWrySLjeUFSVoMYhYOS4V7ueTOxzkdA,26472
+pydantic_ai/models/groq.py,sha256=Tx2yU3ysmPLBmWGsjzES-XcumzrsoBtB7spCnJBlLiM,14947
+pydantic_ai/models/openai.py,sha256=5ihH25CrS0tnZNW-BZw4GyPe8V-IxIHWw3B9ulPVjQE,14931
+pydantic_ai/models/test.py,sha256=HOS3_u0n3nYWJmBFPsAFpZ9gfHiZLauz24o825q3e9M,14443
+pydantic_ai/models/vertexai.py,sha256=xHatvwRn7_vyqmp3aDtHqryYAq8NoeXgXVATkj7yHuw,9088
+pydantic_ai_slim-0.0.7.dist-info/METADATA,sha256=UeP3i7vUZv1MCKG-VGLZUwEO8kbcCzzLpD6RsAN_Vbs,2561
+pydantic_ai_slim-0.0.7.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+pydantic_ai_slim-0.0.7.dist-info/RECORD,,

pydantic_ai_slim-0.0.6a3.dist-info/RECORD

@@ -1,23 +0,0 @@
-pydantic_ai/__init__.py,sha256=ghn5MI2Ygw6azR3i7RTw54B041pllt1E520ILK1kM5Y,319
-pydantic_ai/_griffe.py,sha256=pRjCJ6B1hhx6k46XJgl9zF6aRYxRmqEZKFok8unp4Iw,3449
-pydantic_ai/_pydantic.py,sha256=JslSZjj8Ni98oGfrmbS3RGM0B0_PdNZynvgAW2CnXeU,8056
-pydantic_ai/_result.py,sha256=_qVaq_gmQyPWlyFn_9unafPqOiwSgoa23qxvUwMypo8,9683
-pydantic_ai/_retriever.py,sha256=HxYDfpvcOrhv9gq_1CKRIRAFyLs0qquJGDO9LAWy8ok,4638
-pydantic_ai/_system_prompt.py,sha256=PfNCuG45mM65HtoTiYKz6pWv_CQ9dtxPjl-u8BEn2z4,1094
-pydantic_ai/_utils.py,sha256=7tPzgiiDUWAZGH6zmBZ91CUN3aFSv0szEkw0RDbPLJg,8128
-pydantic_ai/agent.py,sha256=nFwHI3w8JpCqze5UX5TAxiZsSSyavsyKo2W5ITNke1g,34454
-pydantic_ai/dependencies.py,sha256=6IawVRoLSefOtO6oCsxB3kndJRVEP1-DHSE9-2T3ZW8,2509
-pydantic_ai/exceptions.py,sha256=bcde_Xg2yCnSYduhTbbtH3_9kQR6UuKqWJNEzfxiKyw,1566
-pydantic_ai/messages.py,sha256=tmZOFCGVIEmSk8YYQ9qiyb6Q-6DTiqOzfWiryCHVQpY,7536
-pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/result.py,sha256=Gs2ZjuFJgONGJm8M5R2mGph5-lUFLBg7FxVrs2CVDPs,13525
-pydantic_ai/models/__init__.py,sha256=gAH9jbSk6ezqwJpCoVHbdMwULz9mu5VuguARUqKfN8w,10140
-pydantic_ai/models/function.py,sha256=dv1a1RhfdXqwXMFI_y8QzPWJj_YW6Q7twvKvO98JVUE,10124
-pydantic_ai/models/gemini.py,sha256=vHg91s9UzqU3teNnvOJLXkYI8Gu9Wt1vhEu6zB3Ttd8,27677
-pydantic_ai/models/groq.py,sha256=7zKpFg3Fvc-S2n_EroQg5AAD5cOj4y7SKQ7VjMiNSUs,14939
-pydantic_ai/models/openai.py,sha256=_XZ0eDbk3Q3_V2MlMMaZArzYGSm2VuBR47lv4TmFgjY,14923
-pydantic_ai/models/test.py,sha256=T53NKS7pQbCgzo7QIFGdObt3zbDs5t-tjSlkDNsKCuo,14523
-pydantic_ai/models/vertexai.py,sha256=YiYB82WOB5Kp4NjYhweN0ZNjE39-dnpDseMyoyf6Evk,11294
-pydantic_ai_slim-0.0.6a3.dist-info/METADATA,sha256=TeguKgNtjlIP01cF8_IUO3w20nDpAPs4i9u1FyBZBmY,2372
-pydantic_ai_slim-0.0.6a3.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-pydantic_ai_slim-0.0.6a3.dist-info/RECORD,,