pydantic-ai-slim 0.0.6a4__py3-none-any.whl → 0.0.8__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]
@@ -139,13 +139,17 @@ class ModelTextResponse:
 
 @dataclass
 class ArgsJson:
+    """Tool arguments as a JSON string."""
+
     args_json: str
     """A JSON string of arguments."""
 
 
 @dataclass
-class ArgsObject:
-    args_object: dict[str, Any]
+class ArgsDict:
+    """Tool arguments as a Python dictionary."""
+
+    args_dict: dict[str, Any]
     """A python dictionary of arguments."""
 
 
@@ -155,7 +159,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 +172,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 +186,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,
         )
@@ -131,11 +109,15 @@ class GeminiModel(Model):
 
 
 class AuthProtocol(Protocol):
+    """Abstract definition for Gemini authentication."""
+
     async def headers(self) -> dict[str, str]: ...
 
 
 @dataclass
 class ApiKeyAuth:
+    """Authentication using an API key for the `X-Goog-Api-Key` header."""
+
     api_key: str
 
     async def headers(self) -> dict[str, str]:
@@ -160,12 +142,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 +424,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
@@ -33,22 +31,14 @@ from . import (
 )
 
 
-class UnSetType:
-    def __repr__(self):
-        return 'UnSet'
-
-
-UnSet = UnSetType()
-
-
 @dataclass
 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 +47,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 +56,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 +94,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 +107,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 +127,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 +142,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 +152,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 +160,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,15 +169,17 @@ 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
 class TestStreamTextResponse(StreamTextResponse):
+    """A text response that streams test data."""
+
     _text: str
     _cost: Cost
     _iter: Iterator[str] = field(init=False)
@@ -219,6 +211,8 @@ class TestStreamTextResponse(StreamTextResponse):
 
 @dataclass
 class TestStreamStructuredResponse(StreamStructuredResponse):
+    """A structured response that streams test data."""
+
     _structured_response: ModelStructuredResponse
     _cost: Cost
     _iter: Iterator[None] = field(default_factory=lambda: iter([None]))
@@ -320,8 +314,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,
         )
@@ -239,6 +182,8 @@ MAX_TOKEN_AGE = timedelta(seconds=3000)
 
 @dataclass
 class BearerTokenAuth:
+    """Authentication using a bearer token generated by google-auth."""
+
     credentials: BaseCredentials | ServiceAccountCredentials
     token_created: datetime | None = field(default=None, init=False)
 

pydantic_ai/result.py

@@ -1,8 +1,8 @@
 from __future__ import annotations as _annotations
 
 from abc import ABC, abstractmethod
-from collections.abc import AsyncIterator
-from dataclasses import dataclass
+from collections.abc import AsyncIterator, Callable
+from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Generic, TypeVar, cast
 
@@ -49,11 +49,11 @@ class Cost:
         This is provided so it's trivial to sum costs from multiple requests and runs.
         """
         counts: dict[str, int] = {}
-        for field in 'request_tokens', 'response_tokens', 'total_tokens':
-            self_value = getattr(self, field)
-            other_value = getattr(other, field)
+        for f in 'request_tokens', 'response_tokens', 'total_tokens':
+            self_value = getattr(self, f)
+            other_value = getattr(other, f)
             if self_value is not None or other_value is not None:
-                counts[field] = (self_value or 0) + (other_value or 0)
+                counts[f] = (self_value or 0) + (other_value or 0)
 
         details = self.details.copy() if self.details is not None else None
         if other.details is not None:
@@ -122,7 +122,8 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
     _result_schema: _result.ResultSchema[ResultData] | None
     _deps: AgentDeps
     _result_validators: list[_result.ResultValidator[AgentDeps, ResultData]]
-    is_complete: bool = False
+    _on_complete: Callable[[list[messages.Message]], None]
+    is_complete: bool = field(default=False, init=False)
     """Whether the stream has all been received.
 
     This is set to `True` when one of
@@ -312,3 +313,4 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
         else:
             assert structured_message is not None, 'Either text or structured_message should provided, not both'
             self._all_messages.append(structured_message)
+        self._on_complete(self._all_messages)

{pydantic_ai_slim-0.0.6a4.dist-info → pydantic_ai_slim-0.0.8.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.3
 Name: pydantic-ai-slim
-Version: 0.0.6a4
-Summary: Agent Framework / shim to use Pydantic with LLMs
+Version: 0.0.8
+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.8.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=r5DI4ZBqYE67GOMEEu-LXrTa5ty2AchW4szotwm5Qis,34338
+pydantic_ai/dependencies.py,sha256=EHvD68AFkItxMnfHzJLG7T_AD1RGI2MZOfzm1v89hGQ,2399
+pydantic_ai/exceptions.py,sha256=ko_47M0k6Rhg9mUC9P1cj7N4LCH6cC0pEsF65A2vL-U,1561
+pydantic_ai/messages.py,sha256=FFTQ9Bo2Ct4bLuyJF-M9xkeraw05I--NC_ieR6oGtTM,7587
+pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_ai/result.py,sha256=qsanb7v4qJ4pJdkdsqpy68kuZ1WNCpQB5jcXeTwGpe0,13658
+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=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.8.dist-info/METADATA,sha256=CmpvlEAUyaWaPbdRCbFuypVLJ8yNC3TwZ0jgvlR9yps,2561
+pydantic_ai_slim-0.0.8.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+pydantic_ai_slim-0.0.8.dist-info/RECORD,,