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

pydantic_ai/models/test.py

@@ -2,7 +2,7 @@ from __future__ import annotations as _annotations
 
 import re
 import string
-from collections.abc import AsyncIterator, Iterable, Iterator, Mapping, Sequence
+from collections.abc import AsyncIterator, Iterable, Iterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import date, datetime, timedelta
@@ -21,8 +21,8 @@ from ..messages import (
     ToolReturn,
 )
 from ..result import Cost
+from ..tools import ToolDefinition
 from . import (
-    AbstractToolDefinition,
     AgentModel,
     EitherStreamedResponse,
     Model,
@@ -55,25 +55,38 @@ class TestModel(Model):
     """If set, these args will be passed to the result tool."""
     seed: int = 0
     """Seed for generating random data."""
-    # these fields are set when the model is called by the agent
-    agent_model_tools: Mapping[str, AbstractToolDefinition] | None = field(default=None, init=False)
+    agent_model_function_tools: list[ToolDefinition] | None = field(default=None, init=False)
+    """Definition of function tools passed to the model.
+
+    This is set when the model is called, so will reflect the function tools from the last step of the last run.
+    """
     agent_model_allow_text_result: bool | None = field(default=None, init=False)
-    agent_model_result_tools: list[AbstractToolDefinition] | None = field(default=None, init=False)
+    """Whether plain text responses from the model are allowed.
+
+    This is set when the model is called, so will reflect the value from the last step of the last run.
+    """
+    agent_model_result_tools: list[ToolDefinition] | None = field(default=None, init=False)
+    """Definition of result tools passed to the model.
+
+    This is set when the model is called, so will reflect the result tools from the last step of the last run.
+    """
 
     async def agent_model(
         self,
-        function_tools: Mapping[str, AbstractToolDefinition],
+        *,
+        function_tools: list[ToolDefinition],
         allow_text_result: bool,
-        result_tools: Sequence[AbstractToolDefinition] | None,
+        result_tools: list[ToolDefinition],
     ) -> AgentModel:
-        self.agent_model_tools = function_tools
+        self.agent_model_function_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
+        self.agent_model_result_tools = result_tools
 
         if self.call_tools == 'all':
-            tool_calls = [(r.name, r) for r in function_tools.values()]
+            tool_calls = [(r.name, r) for r in function_tools]
         else:
-            tools_to_call = (function_tools[name] for name in self.call_tools)
+            function_tools_lookup = {t.name: t for t in function_tools}
+            tools_to_call = (function_tools_lookup[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:
@@ -90,11 +103,12 @@ class TestModel(Model):
                 result = _utils.Either(right=self.custom_result_args)
         elif allow_text_result:
             result = _utils.Either(left=None)
-        elif result_tools is not None:
+        elif result_tools:
             result = _utils.Either(right=None)
         else:
             result = _utils.Either(left=None)
-        return TestAgentModel(tool_calls, result, self.agent_model_result_tools, self.seed)
+
+        return TestAgentModel(tool_calls, result, result_tools, self.seed)
 
     def name(self) -> str:
         return 'test-model'
@@ -107,13 +121,11 @@ class TestAgentModel(AgentModel):
     # NOTE: Avoid test discovery by pytest.
     __test__ = False
 
-    tool_calls: list[tuple[str, AbstractToolDefinition]]
+    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_tools: list[AbstractToolDefinition] | None
+    result_tools: list[ToolDefinition]
     seed: int
-    step: int = 0
-    last_message_count: int = 0
 
     async def request(self, messages: list[Message]) -> tuple[ModelAnyResponse, Cost]:
         return self._request(messages), Cost()
@@ -127,18 +139,19 @@ class TestAgentModel(AgentModel):
         else:
             yield TestStreamStructuredResponse(msg, cost)
 
-    def gen_tool_args(self, tool_def: AbstractToolDefinition) -> Any:
-        return _JsonSchemaTestData(tool_def.json_schema, self.seed).generate()
+    def gen_tool_args(self, tool_def: ToolDefinition) -> Any:
+        return _JsonSchemaTestData(tool_def.parameters_json_schema, self.seed).generate()
 
     def _request(self, messages: list[Message]) -> ModelAnyResponse:
-        if self.step == 0 and self.tool_calls:
+        # if there are tools, the first thing we want to do is call all of them
+        if self.tool_calls and not any(m.role == 'model-structured-response' for m in messages):
             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)
 
-        new_messages = messages[self.last_message_count :]
-        self.last_message_count = len(messages)
+        # get messages since the last model response
+        new_messages = _get_new_messages(messages)
+
+        # check if there are any retry prompts, if so retry them
         new_retry_names = {m.tool_name for m in new_messages if isinstance(m, RetryPrompt)}
         if new_retry_names:
             calls = [
@@ -146,34 +159,42 @@ class TestAgentModel(AgentModel):
                 for name, args in self.tool_calls
                 if name in new_retry_names
             ]
-            self.step += 1
             return ModelStructuredResponse(calls=calls)
-        else:
-            if response_text := self.result.left:
-                self.step += 1
-                if response_text.value is None:
-                    # build up details of tool responses
-                    output: dict[str, Any] = {}
-                    for message in messages:
-                        if isinstance(message, ToolReturn):
-                            output[message.tool_name] = message.content
-                    if output:
-                        return ModelTextResponse(content=pydantic_core.to_json(output).decode())
-                    else:
-                        return ModelTextResponse(content='success (no tool calls)')
+
+        if response_text := self.result.left:
+            if response_text.value is None:
+                # build up details of tool responses
+                output: dict[str, Any] = {}
+                for message in messages:
+                    if isinstance(message, ToolReturn):
+                        output[message.tool_name] = message.content
+                if output:
+                    return ModelTextResponse(content=pydantic_core.to_json(output).decode())
                 else:
-                    return ModelTextResponse(content=response_text.value)
+                    return ModelTextResponse(content='success (no tool calls)')
             else:
-                assert self.result_tools is not None, 'No result tools provided'
-                custom_result_args = self.result.right
-                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_dict(result_tool.name, custom_result_args)])
-                else:
-                    response_args = self.gen_tool_args(result_tool)
-                    self.step += 1
-                    return ModelStructuredResponse(calls=[ToolCall.from_dict(result_tool.name, response_args)])
+                return ModelTextResponse(content=response_text.value)
+        else:
+            assert self.result_tools, 'No result tools provided'
+            custom_result_args = self.result.right
+            result_tool = self.result_tools[self.seed % len(self.result_tools)]
+            if custom_result_args is not None:
+                return ModelStructuredResponse(calls=[ToolCall.from_dict(result_tool.name, custom_result_args)])
+            else:
+                response_args = self.gen_tool_args(result_tool)
+                return ModelStructuredResponse(calls=[ToolCall.from_dict(result_tool.name, response_args)])
+
+
+def _get_new_messages(messages: list[Message]) -> list[Message]:
+    last_model_index = None
+    for i, m in enumerate(messages):
+        if m.role in ('model-structured-response', 'model-text-response'):
+            last_model_index = i
+
+    if last_model_index is not None:
+        return messages[last_model_index + 1 :]
+    else:
+        return []
 
 
 @dataclass

pydantic_ai/models/vertexai.py

@@ -1,6 +1,5 @@
 from __future__ import annotations as _annotations
 
-from collections.abc import Mapping, Sequence
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
 from pathlib import Path
@@ -10,7 +9,8 @@ from httpx import AsyncClient as AsyncHTTPClient
 
 from .._utils import run_in_executor
 from ..exceptions import UserError
-from . import AbstractToolDefinition, Model, cached_async_http_client
+from ..tools import ToolDefinition
+from . import Model, cached_async_http_client
 from .gemini import GeminiAgentModel, GeminiModelName
 
 try:
@@ -18,11 +18,11 @@ try:
     from google.auth.credentials import Credentials as BaseCredentials
     from google.auth.transport.requests import Request
     from google.oauth2.service_account import Credentials as ServiceAccountCredentials
-except ImportError as e:
+except ImportError as _import_error:
     raise ImportError(
         'Please install `google-auth` to use the VertexAI model, '
         "you can use the `vertexai` optional group — `pip install 'pydantic-ai[vertexai]'`"
-    ) from e
+    ) from _import_error
 
 VERTEX_AI_URL_TEMPLATE = (
     'https://{region}-aiplatform.googleapis.com/v1'
@@ -109,9 +109,10 @@ class VertexAIModel(Model):
 
     async def agent_model(
         self,
-        function_tools: Mapping[str, AbstractToolDefinition],
+        *,
+        function_tools: list[ToolDefinition],
         allow_text_result: bool,
-        result_tools: Sequence[AbstractToolDefinition] | None,
+        result_tools: list[ToolDefinition],
     ) -> GeminiAgentModel:
         url, auth = await self._ainit()
         return GeminiAgentModel(

pydantic_ai/tools.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, Any, Callable, Generic, TypeVar, Union, cast
 
 from pydantic import ValidationError
 from pydantic_core import SchemaValidator
-from typing_extensions import Concatenate, ParamSpec, final
+from typing_extensions import Concatenate, ParamSpec, TypeAlias
 
 from . import _pydantic, _utils, messages
 from .exceptions import ModelRetry, UnexpectedModelBehavior
@@ -27,7 +27,10 @@ __all__ = (
     'ToolFuncPlain',
     'ToolFuncEither',
     'ToolParams',
+    'ToolPrepareFunc',
     'Tool',
+    'ObjectJsonSchema',
+    'ToolDefinition',
 )
 
 AgentDeps = TypeVar('AgentDeps')
@@ -42,7 +45,7 @@ class RunContext(Generic[AgentDeps]):
     """Dependencies for the agent."""
     retry: int
     """Number of retries so far."""
-    tool_name: str | None
+    tool_name: str | None = None
     """Name of the tool being called."""
 
 
@@ -91,11 +94,37 @@ This is just a union of [`ToolFuncContext`][pydantic_ai.tools.ToolFuncContext] a
 
 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.
+
+Example — here `only_if_42` is valid as a `ToolPrepareFunc`:
+
+```py
+from typing import Union
+
+from pydantic_ai import RunContext, Tool
+from pydantic_ai.tools import ToolDefinition
+
+async def only_if_42(
+    ctx: RunContext[int], tool_def: ToolDefinition
+) -> Union[ToolDefinition, None]:
+    if ctx.deps == 42:
+        return tool_def
+
+def hitchhiker(ctx: RunContext[int], answer: str) -> str:
+    return f'{ctx.deps} {answer}'
+
+hitchhiker = Tool(hitchhiker, prepare=only_if_42)
+```
+
+Usage `ToolPrepareFunc[AgentDeps]`.
+"""
 
 A = TypeVar('A')
 
 
-@final
 @dataclass(init=False)
 class Tool(Generic[AgentDeps]):
     """A tool function for an agent."""
@@ -105,22 +134,24 @@ class Tool(Generic[AgentDeps]):
     max_retries: int | None
     name: str
     description: str
+    prepare: ToolPrepareFunc[AgentDeps] | None
     _is_async: bool = field(init=False)
     _single_arg_name: str | None = field(init=False)
     _positional_fields: list[str] = field(init=False)
     _var_positional_field: str | None = field(init=False)
     _validator: SchemaValidator = field(init=False, repr=False)
-    _json_schema: _utils.ObjectJsonSchema = field(init=False)
-    _current_retry: int = field(default=0, init=False)
+    _parameters_json_schema: ObjectJsonSchema = field(init=False)
+    current_retry: int = field(default=0, init=False)
 
     def __init__(
         self,
         function: ToolFuncEither[AgentDeps, ...],
-        takes_ctx: bool,
         *,
+        takes_ctx: bool | None = None,
         max_retries: int | None = None,
         name: str | None = None,
         description: str | None = None,
+        prepare: ToolPrepareFunc[AgentDeps] | None = None,
     ):
         """Create a new tool instance.
 
@@ -132,47 +163,77 @@ class Tool(Generic[AgentDeps]):
         async def my_tool(ctx: RunContext[int], x: int, y: int) -> str:
             return f'{ctx.deps} {x} {y}'
 
-        agent = Agent('test', tools=[Tool(my_tool, True)])
+        agent = Agent('test', tools=[Tool(my_tool)])
+        ```
+
+        or with a custom prepare method:
+
+        ```py
+        from typing import Union
+
+        from pydantic_ai import Agent, RunContext, Tool
+        from pydantic_ai.tools import ToolDefinition
+
+        async def my_tool(ctx: RunContext[int], x: int, y: int) -> str:
+            return f'{ctx.deps} {x} {y}'
+
+        async def prep_my_tool(
+            ctx: RunContext[int], tool_def: ToolDefinition
+        ) -> Union[ToolDefinition, None]:
+            # only register the tool if `deps == 42`
+            if ctx.deps == 42:
+                return tool_def
+
+        agent = Agent('test', tools=[Tool(my_tool, prepare=prep_my_tool)])
         ```
 
+
         Args:
             function: The Python function to call as the tool.
-            takes_ctx: Whether the function takes a [`RunContext`][pydantic_ai.tools.RunContext] first argument.
+            takes_ctx: Whether the function takes a [`RunContext`][pydantic_ai.tools.RunContext] first argument,
+                this is inferred if unset.
             max_retries: Maximum number of retries allowed for this tool, set to the agent default if `None`.
             name: Name of the tool, inferred from the function if `None`.
             description: Description of the tool, inferred from the function if `None`.
+            prepare: custom method to prepare the tool definition for each step, return `None` to omit this
+                tool from a given step. This is useful if you want to customise a tool at call time,
+                or omit it completely from a step. See [`ToolPrepareFunc`][pydantic_ai.tools.ToolPrepareFunc].
         """
+        if takes_ctx is None:
+            takes_ctx = _pydantic.takes_ctx(function)
+
         f = _pydantic.function_schema(function, takes_ctx)
         self.function = function
         self.takes_ctx = takes_ctx
         self.max_retries = max_retries
         self.name = name or function.__name__
         self.description = description or f['description']
+        self.prepare = prepare
         self._is_async = inspect.iscoroutinefunction(self.function)
         self._single_arg_name = f['single_arg_name']
         self._positional_fields = f['positional_fields']
         self._var_positional_field = f['var_positional_field']
         self._validator = f['validator']
-        self._json_schema = f['json_schema']
+        self._parameters_json_schema = f['json_schema']
 
-    @staticmethod
-    def infer(function: ToolFuncEither[A, ...] | Tool[A]) -> Tool[A]:
-        """Create a tool from a pure function, inferring whether it takes `RunContext` as its first argument.
+    async def prepare_tool_def(self, ctx: RunContext[AgentDeps]) -> ToolDefinition | None:
+        """Get the tool definition.
 
-        Args:
-            function: The tool function to wrap; or for convenience, a `Tool` instance.
+        By default, this method creates a tool definition, then either returns it, or calls `self.prepare`
+        if it's set.
 
         Returns:
-            A new `Tool` instance.
+            return a `ToolDefinition` or `None` if the tools should not be registered for this run.
         """
-        if isinstance(function, Tool):
-            return function
+        tool_def = ToolDefinition(
+            name=self.name,
+            description=self.description,
+            parameters_json_schema=self._parameters_json_schema,
+        )
+        if self.prepare is not None:
+            return await self.prepare(ctx, tool_def)
         else:
-            return Tool(function, takes_ctx=_pydantic.takes_ctx(function))
-
-    def reset(self) -> None:
-        """Reset the current retry count."""
-        self._current_retry = 0
+            return tool_def
 
     async def run(self, deps: AgentDeps, message: messages.ToolCall) -> messages.Message:
         """Run the tool function asynchronously."""
@@ -195,28 +256,20 @@ class Tool(Generic[AgentDeps]):
         except ModelRetry as e:
             return self._on_error(e, message)
 
-        self._current_retry = 0
+        self.current_retry = 0
         return messages.ToolReturn(
             tool_name=message.tool_name,
             content=response_content,
             tool_id=message.tool_id,
         )
 
-    @property
-    def json_schema(self) -> _utils.ObjectJsonSchema:
-        return self._json_schema
-
-    @property
-    def outer_typed_dict_key(self) -> str | None:
-        return None
-
     def _call_args(
         self, deps: AgentDeps, args_dict: dict[str, Any], message: messages.ToolCall
     ) -> 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, 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:
@@ -225,8 +278,8 @@ class Tool(Generic[AgentDeps]):
         return args, args_dict
 
     def _on_error(self, exc: ValidationError | ModelRetry, call_message: messages.ToolCall) -> messages.RetryPrompt:
-        self._current_retry += 1
-        if self.max_retries is None or self._current_retry > self.max_retries:
+        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
         else:
             if isinstance(exc, ValidationError):
@@ -238,3 +291,35 @@ class Tool(Generic[AgentDeps]):
                 content=content,
                 tool_id=call_message.tool_id,
             )
+
+
+ObjectJsonSchema: TypeAlias = dict[str, Any]
+"""Type representing JSON schema of an object, e.g. where `"type": "object"`.
+
+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`
+"""
+
+
+@dataclass
+class ToolDefinition:
+    """Definition of a tool passed to a model.
+
+    This is used for both function tools result tools.
+    """
+
+    name: str
+    """The name of the tool."""
+
+    description: str
+    """The description of the tool."""
+
+    parameters_json_schema: ObjectJsonSchema
+    """The JSON schema for the tool's parameters."""
+
+    outer_typed_dict_key: str | None = None
+    """The key in the outer [TypedDict] that wraps a result tool.
+
+    This will only be set for result tools which don't have an `object` JSON schema.
+    """

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pydantic-ai-slim
-Version: 0.0.10
+Version: 0.0.12
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License: MIT

pydantic_ai_slim-0.0.12.dist-info/RECORD

@@ -0,0 +1,23 @@
+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,,

pydantic_ai_slim-0.0.10.dist-info/RECORD

@@ -1,22 +0,0 @@
-pydantic_ai/__init__.py,sha256=a29NqQz0JyW4BoCjcRh23fBBfwY17_n57moE4QrFWM4,324
-pydantic_ai/_griffe.py,sha256=pRjCJ6B1hhx6k46XJgl9zF6aRYxRmqEZKFok8unp4Iw,3449
-pydantic_ai/_pydantic.py,sha256=oFfcHDv_wuL1NQ7mCzVHvP1HBaVzyvb7xS-_Iiri_tA,8491
-pydantic_ai/_result.py,sha256=wzcfwDpr_sro1Vkn3DkyIhCXMHTReDxL_ZYm50JzdRI,9667
-pydantic_ai/_system_prompt.py,sha256=vFT0y9Wykl5veGMgLLkGRYiHQrgdW2BZ1rwMn4izjjo,1085
-pydantic_ai/_utils.py,sha256=eNb7f3-ZQC8WDEa87iUcXGQ-lyuutFQG-5yBCMD4Vvs,8227
-pydantic_ai/agent.py,sha256=dB2_JshYBjK04fmzJP79wmoKJwMuEBaLmjIRVdwrISM,36854
-pydantic_ai/exceptions.py,sha256=ko_47M0k6Rhg9mUC9P1cj7N4LCH6cC0pEsF65A2vL-U,1561
-pydantic_ai/messages.py,sha256=I0_CPXDIGGSy-PXHuKq540oAXYOO9uyylpsfSsE4vLs,7032
-pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/result.py,sha256=UB3vFOcDAceeNLXh_f_3PKy2J0A6FIHdgDFJxPH6OJk,13651
-pydantic_ai/tools.py,sha256=rzchmsEPYtUzBBFoeeJKC1ct36iqOxFOY6kfKqItCCs,8210
-pydantic_ai/models/__init__.py,sha256=_Mz_32WGlAf4NlxXfdQ-EAaY_bDOk10gIc5HmTAO_ts,10318
-pydantic_ai/models/function.py,sha256=Mzc-zXnb2RayWAA8N9NS7KGF49do1S-VW3U9fkc661o,10045
-pydantic_ai/models/gemini.py,sha256=ruO4tnnpDDuHThg7jUOphs8I_KXBJH7gfDMluliED8E,26606
-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=q1wch_E7TSb4qx9PCcP1YyBGZx567MGlAQhlAlON0S8,14463
-pydantic_ai/models/vertexai.py,sha256=5wI8y2YjeRgSE51uKy5OtevQkks65uEbxIUAs5EGBaI,9161
-pydantic_ai_slim-0.0.10.dist-info/METADATA,sha256=2-sEVelPFDeLZwYC4o8ZgGvyXvJsVXZIkj3Mx3wXs6g,2562
-pydantic_ai_slim-0.0.10.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-pydantic_ai_slim-0.0.10.dist-info/RECORD,,