pydantic-ai-slim 0.7.2__py3-none-any.whl → 0.7.3__py3-none-any.whl

pydantic_ai/usage.py

@@ -1,67 +1,62 @@
 from __future__ import annotations as _annotations
 
+import dataclasses
 from copy import copy
-from dataclasses import dataclass
+from dataclasses import dataclass, fields
+
+from typing_extensions import deprecated, overload
 
 from . import _utils
 from .exceptions import UsageLimitExceeded
 
-__all__ = 'Usage', 'UsageLimits'
+__all__ = 'RequestUsage', 'RunUsage', 'Usage', 'UsageLimits'
 
 
 @dataclass(repr=False)
-class Usage:
-    """LLM usage associated with a request or run.
-
-    Responsibility for calculating usage is on the model; Pydantic AI simply sums the usage information across requests.
+class UsageBase:
+    input_tokens: int = 0
+    """Number of input/prompt tokens."""
 
-    You'll need to look up the documentation of the model you're using to convert usage to monetary costs.
-    """
+    cache_write_tokens: int = 0
+    """Number of tokens written to the cache."""
+    cache_read_tokens: int = 0
+    """Number of tokens read from the cache."""
 
-    requests: int = 0
-    """Number of requests made to the LLM API."""
-    request_tokens: int | None = None
-    """Tokens used in processing requests."""
-    response_tokens: int | None = None
-    """Tokens used in generating responses."""
-    total_tokens: int | None = None
-    """Total tokens used in the whole run, should generally be equal to `request_tokens + response_tokens`."""
-    details: dict[str, int] | None = None
-    """Any extra details returned by the model."""
+    output_tokens: int = 0
+    """Number of output/completion tokens."""
 
-    def incr(self, incr_usage: Usage) -> None:
-        """Increment the usage in place.
+    input_audio_tokens: int = 0
+    """Number of audio input tokens."""
+    cache_audio_read_tokens: int = 0
+    """Number of audio tokens read from the cache."""
+    output_audio_tokens: int = 0
+    """Number of audio output tokens."""
 
-        Args:
-            incr_usage: The usage to increment by.
-        """
-        for f in 'requests', 'request_tokens', 'response_tokens', 'total_tokens':
-            self_value = getattr(self, f)
-            other_value = getattr(incr_usage, f)
-            if self_value is not None or other_value is not None:
-                setattr(self, f, (self_value or 0) + (other_value or 0))
+    details: dict[str, int] = dataclasses.field(default_factory=dict)
+    """Any extra details returned by the model."""
 
-        if incr_usage.details:
-            self.details = self.details or {}
-            for key, value in incr_usage.details.items():
-                self.details[key] = self.details.get(key, 0) + value
+    @property
+    @deprecated('`request_tokens` is deprecated, use `input_tokens` instead')
+    def request_tokens(self) -> int:
+        return self.input_tokens
 
-    def __add__(self, other: Usage) -> Usage:
-        """Add two Usages together.
+    @property
+    @deprecated('`response_tokens` is deprecated, use `output_tokens` instead')
+    def response_tokens(self) -> int:
+        return self.output_tokens
 
-        This is provided so it's trivial to sum usage information from multiple requests and runs.
-        """
-        new_usage = copy(self)
-        new_usage.incr(other)
-        return new_usage
+    @property
+    def total_tokens(self) -> int:
+        """Sum of `input_tokens + output_tokens`."""
+        return self.input_tokens + self.output_tokens
 
     def opentelemetry_attributes(self) -> dict[str, int]:
-        """Get the token limits as OpenTelemetry attributes."""
+        """Get the token usage values as OpenTelemetry attributes."""
         result: dict[str, int] = {}
-        if self.request_tokens:
-            result['gen_ai.usage.input_tokens'] = self.request_tokens
-        if self.response_tokens:
-            result['gen_ai.usage.output_tokens'] = self.response_tokens
+        if self.input_tokens:
+            result['gen_ai.usage.input_tokens'] = self.input_tokens
+        if self.output_tokens:
+            result['gen_ai.usage.output_tokens'] = self.output_tokens
         details = self.details
         if details:
             prefix = 'gen_ai.usage.details.'
@@ -71,11 +66,118 @@ class Usage:
                     result[prefix + key] = value
         return result
 
+    def __repr__(self):
+        kv_pairs = (f'{f.name}={value!r}' for f in fields(self) if (value := getattr(self, f.name)))
+        return f'{self.__class__.__qualname__}({", ".join(kv_pairs)})'
+
     def has_values(self) -> bool:
         """Whether any values are set and non-zero."""
-        return bool(self.requests or self.request_tokens or self.response_tokens or self.details)
+        return any(dataclasses.asdict(self).values())
 
-    __repr__ = _utils.dataclasses_no_defaults_repr
+
+@dataclass(repr=False)
+class RequestUsage(UsageBase):
+    """LLM usage associated with a single request.
+
+    This is an implementation of `genai_prices.types.AbstractUsage` so it can be used to calculate the price of the
+    request using [genai-prices](https://github.com/pydantic/genai-prices).
+    """
+
+    @property
+    def requests(self):
+        return 1
+
+    def incr(self, incr_usage: RequestUsage) -> None:
+        """Increment the usage in place.
+
+        Args:
+            incr_usage: The usage to increment by.
+        """
+        return _incr_usage_tokens(self, incr_usage)
+
+    def __add__(self, other: RequestUsage) -> RequestUsage:
+        """Add two RequestUsages together.
+
+        This is provided so it's trivial to sum usage information from multiple parts of a response.
+
+        **WARNING:** this CANNOT be used to sum multiple requests without breaking some pricing calculations.
+        """
+        new_usage = copy(self)
+        new_usage.incr(other)
+        return new_usage
+
+
+@dataclass(repr=False)
+class RunUsage(UsageBase):
+    """LLM usage associated with an agent run.
+
+    Responsibility for calculating request usage is on the model; Pydantic AI simply sums the usage information across requests.
+    """
+
+    requests: int = 0
+    """Number of requests made to the LLM API."""
+
+    input_tokens: int = 0
+    """Total number of text input/prompt tokens."""
+
+    cache_write_tokens: int = 0
+    """Total number of tokens written to the cache."""
+    cache_read_tokens: int = 0
+    """Total number of tokens read from the cache."""
+
+    input_audio_tokens: int = 0
+    """Total number of audio input tokens."""
+    cache_audio_read_tokens: int = 0
+    """Total number of audio tokens read from the cache."""
+
+    output_tokens: int = 0
+    """Total number of text output/completion tokens."""
+
+    details: dict[str, int] = dataclasses.field(default_factory=dict)
+    """Any extra details returned by the model."""
+
+    def incr(self, incr_usage: RunUsage | RequestUsage) -> None:
+        """Increment the usage in place.
+
+        Args:
+            incr_usage: The usage to increment by.
+        """
+        if isinstance(incr_usage, RunUsage):
+            self.requests += incr_usage.requests
+        return _incr_usage_tokens(self, incr_usage)
+
+    def __add__(self, other: RunUsage | RequestUsage) -> RunUsage:
+        """Add two RunUsages together.
+
+        This is provided so it's trivial to sum usage information from multiple runs.
+        """
+        new_usage = copy(self)
+        new_usage.incr(other)
+        return new_usage
+
+
+def _incr_usage_tokens(slf: RunUsage | RequestUsage, incr_usage: RunUsage | RequestUsage) -> None:
+    """Increment the usage in place.
+
+    Args:
+        slf: The usage to increment.
+        incr_usage: The usage to increment by.
+    """
+    slf.input_tokens += incr_usage.input_tokens
+    slf.cache_write_tokens += incr_usage.cache_write_tokens
+    slf.cache_read_tokens += incr_usage.cache_read_tokens
+    slf.input_audio_tokens += incr_usage.input_audio_tokens
+    slf.cache_audio_read_tokens += incr_usage.cache_audio_read_tokens
+    slf.output_tokens += incr_usage.output_tokens
+
+    for key, value in incr_usage.details.items():
+        slf.details[key] = slf.details.get(key, 0) + value
+
+
+@dataclass
+@deprecated('`Usage` is deprecated, use `RunUsage` instead')
+class Usage(RunUsage):
+    """Deprecated alias for `RunUsage`."""
 
 
 @dataclass(repr=False)
@@ -90,10 +192,10 @@ class UsageLimits:
 
     request_limit: int | None = 50
     """The maximum number of requests allowed to the model."""
-    request_tokens_limit: int | None = None
-    """The maximum number of tokens allowed in requests to the model."""
-    response_tokens_limit: int | None = None
-    """The maximum number of tokens allowed in responses from the model."""
+    input_tokens_limit: int | None = None
+    """The maximum number of input/prompt tokens allowed."""
+    output_tokens_limit: int | None = None
+    """The maximum number of output/response tokens allowed."""
     total_tokens_limit: int | None = None
     """The maximum number of tokens allowed in requests and responses combined."""
     count_tokens_before_request: bool = False
@@ -101,6 +203,69 @@ class UsageLimits:
     to enforce `request_tokens_limit` ahead of time. This may incur additional overhead
     (from calling the model's `count_tokens` API before making the actual request) and is disabled by default."""
 
+    @property
+    @deprecated('`request_tokens_limit` is deprecated, use `input_tokens_limit` instead')
+    def request_tokens_limit(self) -> int | None:
+        return self.input_tokens_limit
+
+    @property
+    @deprecated('`response_tokens_limit` is deprecated, use `output_tokens_limit` instead')
+    def response_tokens_limit(self) -> int | None:
+        return self.output_tokens_limit
+
+    @overload
+    def __init__(
+        self,
+        *,
+        request_limit: int | None = 50,
+        input_tokens_limit: int | None = None,
+        output_tokens_limit: int | None = None,
+        total_tokens_limit: int | None = None,
+        count_tokens_before_request: bool = False,
+    ) -> None:
+        self.request_limit = request_limit
+        self.input_tokens_limit = input_tokens_limit
+        self.output_tokens_limit = output_tokens_limit
+        self.total_tokens_limit = total_tokens_limit
+        self.count_tokens_before_request = count_tokens_before_request
+
+    @overload
+    @deprecated(
+        'Use `input_tokens_limit` instead of `request_tokens_limit` and `output_tokens_limit` and `total_tokens_limit`'
+    )
+    def __init__(
+        self,
+        *,
+        request_limit: int | None = 50,
+        request_tokens_limit: int | None = None,
+        response_tokens_limit: int | None = None,
+        total_tokens_limit: int | None = None,
+        count_tokens_before_request: bool = False,
+    ) -> None:
+        self.request_limit = request_limit
+        self.input_tokens_limit = request_tokens_limit
+        self.output_tokens_limit = response_tokens_limit
+        self.total_tokens_limit = total_tokens_limit
+        self.count_tokens_before_request = count_tokens_before_request
+
+    def __init__(
+        self,
+        *,
+        request_limit: int | None = 50,
+        input_tokens_limit: int | None = None,
+        output_tokens_limit: int | None = None,
+        total_tokens_limit: int | None = None,
+        count_tokens_before_request: bool = False,
+        # deprecated:
+        request_tokens_limit: int | None = None,
+        response_tokens_limit: int | None = None,
+    ):
+        self.request_limit = request_limit
+        self.input_tokens_limit = input_tokens_limit or request_tokens_limit
+        self.output_tokens_limit = output_tokens_limit or response_tokens_limit
+        self.total_tokens_limit = total_tokens_limit
+        self.count_tokens_before_request = count_tokens_before_request
+
     def has_token_limits(self) -> bool:
         """Returns `True` if this instance places any limits on token counts.
 
@@ -110,43 +275,40 @@ class UsageLimits:
         If there are no limits, we can skip that processing in the streaming response iterator.
         """
         return any(
-            limit is not None
-            for limit in (self.request_tokens_limit, self.response_tokens_limit, self.total_tokens_limit)
+            limit is not None for limit in (self.input_tokens_limit, self.output_tokens_limit, self.total_tokens_limit)
         )
 
-    def check_before_request(self, usage: Usage) -> None:
+    def check_before_request(self, usage: RunUsage) -> None:
         """Raises a `UsageLimitExceeded` exception if the next request would exceed any of the limits."""
         request_limit = self.request_limit
         if request_limit is not None and usage.requests >= request_limit:
             raise UsageLimitExceeded(f'The next request would exceed the request_limit of {request_limit}')
 
-        request_tokens = usage.request_tokens or 0
-        if self.request_tokens_limit is not None and request_tokens > self.request_tokens_limit:
+        input_tokens = usage.input_tokens
+        if self.input_tokens_limit is not None and input_tokens > self.input_tokens_limit:
             raise UsageLimitExceeded(
-                f'The next request would exceed the request_tokens_limit of {self.request_tokens_limit} ({request_tokens=})'
+                f'The next request would exceed the input_tokens_limit of {self.input_tokens_limit} ({input_tokens=})'
             )
 
-        total_tokens = usage.total_tokens or 0
+        total_tokens = usage.total_tokens
         if self.total_tokens_limit is not None and total_tokens > self.total_tokens_limit:
             raise UsageLimitExceeded(
                 f'The next request would exceed the total_tokens_limit of {self.total_tokens_limit} ({total_tokens=})'
             )
 
-    def check_tokens(self, usage: Usage) -> None:
+    def check_tokens(self, usage: RunUsage) -> None:
         """Raises a `UsageLimitExceeded` exception if the usage exceeds any of the token limits."""
-        request_tokens = usage.request_tokens or 0
-        if self.request_tokens_limit is not None and request_tokens > self.request_tokens_limit:
-            raise UsageLimitExceeded(
-                f'Exceeded the request_tokens_limit of {self.request_tokens_limit} ({request_tokens=})'
-            )
+        input_tokens = usage.input_tokens
+        if self.input_tokens_limit is not None and input_tokens > self.input_tokens_limit:
+            raise UsageLimitExceeded(f'Exceeded the input_tokens_limit of {self.input_tokens_limit} ({input_tokens=})')
 
-        response_tokens = usage.response_tokens or 0
-        if self.response_tokens_limit is not None and response_tokens > self.response_tokens_limit:
+        output_tokens = usage.output_tokens
+        if self.output_tokens_limit is not None and output_tokens > self.output_tokens_limit:
             raise UsageLimitExceeded(
-                f'Exceeded the response_tokens_limit of {self.response_tokens_limit} ({response_tokens=})'
+                f'Exceeded the output_tokens_limit of {self.output_tokens_limit} ({output_tokens=})'
             )
 
-        total_tokens = usage.total_tokens or 0
+        total_tokens = usage.total_tokens
         if self.total_tokens_limit is not None and total_tokens > self.total_tokens_limit:
             raise UsageLimitExceeded(f'Exceeded the total_tokens_limit of {self.total_tokens_limit} ({total_tokens=})')
 

{pydantic_ai_slim-0.7.2.dist-info → pydantic_ai_slim-0.7.3.dist-info}/METADATA

@@ -1,7 +1,11 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.7.2
+Version: 0.7.3
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
+Project-URL: Homepage, https://github.com/pydantic/pydantic-ai/tree/main/pydantic_ai_slim
+Project-URL: Source, https://github.com/pydantic/pydantic-ai/tree/main/pydantic_ai_slim
+Project-URL: Documentation, https://ai.pydantic.dev/install/#slim-install
+Project-URL: Changelog, https://github.com/pydantic/pydantic-ai/releases
 Author-email: Samuel Colvin <samuel@pydantic.dev>, Marcelo Trylesinski <marcelotryle@gmail.com>, David Montague <david@pydantic.dev>, Alex Hall <alex@pydantic.dev>, Douwe Maan <douwe@pydantic.dev>
 License-Expression: MIT
 License-File: LICENSE
@@ -27,10 +31,11 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Requires-Dist: eval-type-backport>=0.2.0
 Requires-Dist: exceptiongroup; python_version < '3.11'
+Requires-Dist: genai-prices>=0.0.22
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.7.2
+Requires-Dist: pydantic-graph==0.7.3
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -45,13 +50,14 @@ Requires-Dist: boto3>=1.39.0; extra == 'bedrock'
 Provides-Extra: cli
 Requires-Dist: argcomplete>=3.5.0; extra == 'cli'
 Requires-Dist: prompt-toolkit>=3; extra == 'cli'
+Requires-Dist: pyperclip>=1.9.0; extra == 'cli'
 Requires-Dist: rich>=13; extra == 'cli'
 Provides-Extra: cohere
 Requires-Dist: cohere>=5.16.0; (platform_system != 'Emscripten') and extra == 'cohere'
 Provides-Extra: duckduckgo
 Requires-Dist: ddgs>=9.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.7.2; extra == 'evals'
+Requires-Dist: pydantic-evals==0.7.3; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.28.0; extra == 'google'
 Provides-Extra: groq
@@ -71,7 +77,7 @@ Requires-Dist: tenacity>=8.2.3; extra == 'retries'
 Provides-Extra: tavily
 Requires-Dist: tavily-python>=0.5.0; extra == 'tavily'
 Provides-Extra: temporal
-Requires-Dist: temporalio>=1.15.0; extra == 'temporal'
+Requires-Dist: temporalio==1.15.0; extra == 'temporal'
 Provides-Extra: vertexai
 Requires-Dist: google-auth>=2.36.0; extra == 'vertexai'
 Requires-Dist: requests>=2.32.2; extra == 'vertexai'

{pydantic_ai_slim-0.7.2.dist-info → pydantic_ai_slim-0.7.3.dist-info}/RECORD

@@ -1,66 +1,66 @@
 pydantic_ai/__init__.py,sha256=Uy0J4BgX4CXsa0sUUb5K0FC4uUWGIwBici93QHLkNsk,1478
 pydantic_ai/__main__.py,sha256=Q_zJU15DUA01YtlJ2mnaLCoId2YmgmreVEERGuQT-Y0,132
 pydantic_ai/_a2a.py,sha256=wux52DmJQceLJwF71qxb0Uqupk3aS61m005-NmuWZIw,12164
-pydantic_ai/_agent_graph.py,sha256=QB6J-UI-gUUXPhk1ud39yCWw3U04Ea28HWfIN74iO6M,38488
-pydantic_ai/_cli.py,sha256=nr3hW7Y4vHzk7oXpfOCupwuJ6Z2SmZLz2dYS6ljCpuc,13281
+pydantic_ai/_agent_graph.py,sha256=W6bdFC_LtROBkU7ZpWqWL-sTSKD17tYyeBI9nWzVL5k,38484
+pydantic_ai/_cli.py,sha256=YNqV2Kb3KYpof0lD4wwnULM2sCxzsvBzsh-oPd6lJN8,13959
 pydantic_ai/_function_schema.py,sha256=YFHxb6bKfhgeY6rNdbuYXgndGCDanveUx2258xkSNlQ,11233
 pydantic_ai/_griffe.py,sha256=Ugft16ZHw9CN_6-lW0Svn6jESK9zHXO_x4utkGBkbBI,5253
 pydantic_ai/_mcp.py,sha256=PuvwnlLjv7YYOa9AZJCrklevBug99zGMhwJCBGG7BHQ,5626
 pydantic_ai/_output.py,sha256=6Vxlw8F9nRWCkjy4qvFF8tmDi2xZn7Dq72T6s4C5kAM,37640
 pydantic_ai/_parts_manager.py,sha256=zrra5yDpAX8cFB_eK0btAp9d6NAR979V1Rmepm83l1w,17980
-pydantic_ai/_run_context.py,sha256=pqb_HPXytE1Z9zZRRuBboRYes_tVTC75WGTpZgnb2Ko,1691
+pydantic_ai/_run_context.py,sha256=uSjR0a9QJ7KifqJsu7buGpK4wqexO7ldZMzWsBOboDI,1697
 pydantic_ai/_system_prompt.py,sha256=lUSq-gDZjlYTGtd6BUm54yEvTIvgdwBmJ8mLsNZZtYU,1142
 pydantic_ai/_thinking_part.py,sha256=x80-Vkon16GOyq3W6f2qzafTVPC5dCgF7QD3k8ZMmYU,1304
 pydantic_ai/_tool_manager.py,sha256=WPMXgHBzyn7UgRKIuqU-oV2GpsAOW0nF2RsxPCKOp7U,9655
 pydantic_ai/_utils.py,sha256=Ge9rtu8NJvsfSFjx1MduITPr0-9b_I0emDFSpwJbYes,16372
-pydantic_ai/ag_ui.py,sha256=2cKSSvl1j0pxVNCFQO82l7LVtkJMt0HUaEXGwy3y558,26463
+pydantic_ai/ag_ui.py,sha256=bd-RJYFFmcw2xkAWj-7N0ZLRMa1dam3LEhlgoNo1l9I,26475
 pydantic_ai/builtin_tools.py,sha256=mwIq-7m0ZSbCZp1zxswjRfQM648QE01IDfifvqDGxUQ,3023
-pydantic_ai/direct.py,sha256=mduSzkCapSAuzV90da1aARy9n-Jwj6papgbMWGbWIkQ,14943
+pydantic_ai/direct.py,sha256=ym1Lb7oCPDU2eMmN8LXzN7Dp_IUJIPmlyKgmxxBUxsc,14905
 pydantic_ai/exceptions.py,sha256=vHRH_b6JpMi5p5EGhz2O4FSeKGJv3WMD291Y1FjHYFc,3528
 pydantic_ai/format_prompt.py,sha256=Or-Ytq55RQb1UJqy2HKIyPpZ-knWXfdDP3Z6tNc6Orw,4244
 pydantic_ai/mcp.py,sha256=n9_ECHmFE-eOZmb1bDh94oy81caefdtSGo1oH2KKWMo,31162
-pydantic_ai/messages.py,sha256=kLw3yBtUEoRQ43zZ43PpasgC6EeVbSQi4Fl0PB1tQwA,45700
+pydantic_ai/messages.py,sha256=fPIicZ2J149x4cGSBbgeVahaDlnK6ChbMZ8gsZLPPfg,46099
 pydantic_ai/output.py,sha256=54Cwd1RruXlA5hucZ1h-SxFrzKHJuLvYvLtH9iyg2GI,11988
 pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/result.py,sha256=2Z5-wJXO5Iw_qHFoMcshTjiUHFdcT1aycNWt26kyLuY,19785
+pydantic_ai/result.py,sha256=gUVJIyoM1FewRFLj7ezuXr7M2RSaQL4AytoIpBMmDy8,19800
 pydantic_ai/retries.py,sha256=Xkj-gZAd3wc12CVsIErVYx2EIdIwD5yJOL4Ou6jDQ2s,10498
-pydantic_ai/run.py,sha256=VSZEadgzRc_tytnHt2Gemdv9z05e6aEJTNPQ7DmuUck,15130
+pydantic_ai/run.py,sha256=acyyTDH8qP1W-gbUA8TBBcOqte-7ICyoelJRjO_ojeo,14879
 pydantic_ai/settings.py,sha256=yuUZ7-GkdPB-Gbx71kSdh8dSr6gwM9gEwk84qNxPO_I,3552
 pydantic_ai/tools.py,sha256=1_4kt4HGfpHH4XnYy0lQRzm5Io5SzOjk3AJxa-LJLmE,14821
-pydantic_ai/usage.py,sha256=UddLBMmytzKBmsLzyGHHbJAnr4VQkMA8-vSjCeifz3w,6801
-pydantic_ai/agent/__init__.py,sha256=IB67d_jxZ3LpIdt5X7ng06CUV84dlzyBMse628PQttk,59319
-pydantic_ai/agent/abstract.py,sha256=m83vk00sV7q3MqIHucExkMsiEF52dANHptGl8TNEkbw,42035
-pydantic_ai/agent/wrapper.py,sha256=cVIpfPWF63oTD1jeWdFY-OS_ty2nwbeSwsI7upd30Kw,9155
+pydantic_ai/usage.py,sha256=znjemyBOSUo5h0kQwQGEzTBlPGu4qUy69T-mciMUndE,12126
+pydantic_ai/agent/__init__.py,sha256=6qe2t2TRr4yjwClHYaVRCSWFnDD8_7_0LhSfqF1L1ac,59255
+pydantic_ai/agent/abstract.py,sha256=2B00V-SmKlFkrkVW2KQ4e0K_glr9cQL6Llq2OYLqlgg,42000
+pydantic_ai/agent/wrapper.py,sha256=sE_9rA1PNF5v0qAMhRYw0W8bIhLT4RP17S3TSLz0k5w,9084
 pydantic_ai/common_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/common_tools/duckduckgo.py,sha256=aQsm7zKuoRNgPM8ltbdyj8dPkREEkQenimsf_laF6kc,2245
 pydantic_ai/common_tools/tavily.py,sha256=Q1xxSF5HtXAaZ10Pp-OaDOHXwJf2mco9wScGEQXD7E4,2495
 pydantic_ai/durable_exec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/durable_exec/temporal/__init__.py,sha256=kzUnYUOmHNIsn6UzAa3-vEZx0VpIDZiY84iaRm6z-Qs,3356
-pydantic_ai/durable_exec/temporal/_agent.py,sha256=hKJW-oCU5W83sofQ-1f40IQe1FS-qrcmq4Dr-KcSy2c,32864
+pydantic_ai/durable_exec/temporal/_agent.py,sha256=H1oHoZC9wOuAN79LG7Qb3DNtK2XFCLXB-6NRLv97dTI,32820
 pydantic_ai/durable_exec/temporal/_function_toolset.py,sha256=qKTs7T6YcJ2LBOvrlYBRUHd9zn86TuUaY0Qw5TPGSmE,3848
 pydantic_ai/durable_exec/temporal/_logfire.py,sha256=_dsvVIdpYJEUyoFUIDYQjCO6TjTITqvlJHwNy_Fi2cw,1866
 pydantic_ai/durable_exec/temporal/_mcp_server.py,sha256=J7CC4gRDhM4uQo3_kNKV7e4uiWC0He0AgS7bdq9Pt4o,6005
-pydantic_ai/durable_exec/temporal/_model.py,sha256=3EN9NuTjmWsB57Y9ukvo4hFf3bw-xF90QNSJ18y1iRk,6631
+pydantic_ai/durable_exec/temporal/_model.py,sha256=7_-f-n1JEg4YsJ8NGoB9RXpaAB-mWZZBR0wtGqa3NgE,6645
 pydantic_ai/durable_exec/temporal/_run_context.py,sha256=5NTomzWBAlFcXeVw-4mqa76Rmrc8b3G1bB5ElVsAyCY,2310
 pydantic_ai/durable_exec/temporal/_toolset.py,sha256=XlQx7NGSKR9n-mjNWaTn-i3HW9X4z5fZUAM9DwDTBwY,2865
 pydantic_ai/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/ext/aci.py,sha256=sUllKDNO-LOMurbFgxwRHuzNlBkSa3aVBqXfEm-A_vo,2545
 pydantic_ai/ext/langchain.py,sha256=iLVEZv1kcLkdIHo3us2yfdi0kVqyJ6qTaCt9BoLWm4k,2335
-pydantic_ai/models/__init__.py,sha256=PQcyiPaSj72mt9kjPgg69eboqHqRl0JlBHTS3eCO5uY,34611
-pydantic_ai/models/anthropic.py,sha256=8wLXYWzGxD2tEf0V9cy0iApZStZHgup6TUlMjd8pQp4,30019
-pydantic_ai/models/bedrock.py,sha256=IzVpH0rpj63fWnQSwYf13sZ4VFAVn0wzSWW4HRgRaSw,30840
-pydantic_ai/models/cohere.py,sha256=ZbRvCPgPjDLItUj-r08VPmR8D8e6ARbUiRd8rsZ-1sY,13094
-pydantic_ai/models/fallback.py,sha256=8d5C2MDbVBQ1NFHIciaIAJd8-DGzpTbMzIPIR1Dj4Xc,5514
-pydantic_ai/models/function.py,sha256=CKSy_xA__n92BnOzfI9BXRsRVy3WjvuRyzibU26I8Js,14299
-pydantic_ai/models/gemini.py,sha256=SWeahyDS_8STbofWJoIDvayBIGv-d4CYUuIBERPZkpI,38676
-pydantic_ai/models/google.py,sha256=xiAbIT0WkfdwwvjGY5WzOgTpkpxXI7-A2cvnyxwmI8s,29636
-pydantic_ai/models/groq.py,sha256=iLgei6osGzLSrtxCPlDUR3Qz2sYa6qmeWJfJPrfc-c4,20942
-pydantic_ai/models/huggingface.py,sha256=CMGpAzzaJ-xtDlNAM0IAx97fUagyEO84MMAncBYnwa0,20256
-pydantic_ai/models/instrumented.py,sha256=vVHO2sHkZnH7kcFr2iozOOuacfwGQYORhSgUtvDYZEU,16315
-pydantic_ai/models/mcp_sampling.py,sha256=0pAMCTkzmhQuyhik8KG2ZUYGVh4tofjdZBf6WdR78ik,3490
-pydantic_ai/models/mistral.py,sha256=-nB6VoHvNveLZHRCmXQaX9EFUJlFHXXt7nRyFtI2SIE,32251
-pydantic_ai/models/openai.py,sha256=Ozry-an08lai0aI-PmTuOA2dwpMwnFs3VG9xgaEu7EU,61246
-pydantic_ai/models/test.py,sha256=XKfJOwjnaMAuGpQwMT-H99vIicFymdJDpAtr0PU0Zoo,19151
+pydantic_ai/models/__init__.py,sha256=h29lgKzOx8fHV0wXHMmaaawn8xGpAuFFxQwZJx4ihvU,34637
+pydantic_ai/models/anthropic.py,sha256=WO-PGqtXZaFV9Oz9aHr-ADMc2qSr8TVep4tPmhWL_DI,30122
+pydantic_ai/models/bedrock.py,sha256=z-qs8RikRxClbhDNsbRcuZ1GsPlb-GjoV88QD6vXOtE,30723
+pydantic_ai/models/cohere.py,sha256=jZPMuFvNv9JTVCbC_p7_1Uxuc5WGn6RVFpH_pwG7iO0,13009
+pydantic_ai/models/fallback.py,sha256=ftcYhl0oSOer0vYbLkaf7dfgI_3h0hk7hp07i1Wh9rI,5526
+pydantic_ai/models/function.py,sha256=dY1aCUwcVXot5e2jWApWMAMnKWkSeEH4vqoe6mTBBZ0,14139
+pydantic_ai/models/gemini.py,sha256=2KoN-sf5skHOkVcvbV5Zw4jGYanZX4n_K4jhyJVYK4U,39151
+pydantic_ai/models/google.py,sha256=dMp1zJOWQFPH2unHDsuVEPoAAjER5u-iSHew0t9lD7o,30498
+pydantic_ai/models/groq.py,sha256=kqegrHbeabp__jNwuib3k0vQTVpra7Gy3D_dwbH9vv8,20960
+pydantic_ai/models/huggingface.py,sha256=JcYDfZbkYsQ9KUlDwfraiWq7dbg8Q0FRKkx8Lv9IWjg,20182
+pydantic_ai/models/instrumented.py,sha256=wzdnuIIIgpMJ7zqhMf-S--ffg9YYEgn5WRkJE2cCwao,16307
+pydantic_ai/models/mcp_sampling.py,sha256=iXIjwTP5Jszn0Iz-5MZiCk_BdUYE7IAxCnC5yIrGIu0,3436
+pydantic_ai/models/mistral.py,sha256=jNkzlEgqD1n0Fb3Yy9CFnlQ-Oi7pe7ixhXokqfrQFqg,32208
+pydantic_ai/models/openai.py,sha256=B6a2zDskBJITszwwmjncQLw4g9qAgZc5HgnlVhtGr7A,62939
+pydantic_ai/models/test.py,sha256=7J9bZOBwqQ3X0f5PT0_JakMPSB5UmIZ5ZFlX8hH45NU,19089
 pydantic_ai/models/wrapper.py,sha256=9MeHW7mXPsEK03IKL0rtjeX6QgXyZROOOzLh72GiX2k,2148
 pydantic_ai/profiles/__init__.py,sha256=AdwFrK50_20qJBA_eMXXsV1vdGOvPxLVW82hMQvzXU0,3285
 pydantic_ai/profiles/_json_schema.py,sha256=CthOGmPSjgEZRRglfvg31zyQ9vjHDdacXoFpmba93dE,7206
@@ -74,7 +74,7 @@ pydantic_ai/profiles/groq.py,sha256=5jLNnOuxq3HTrbY-cizJyGa1hIluW7sCPLmDP1C1unc,
 pydantic_ai/profiles/meta.py,sha256=JdZcpdRWx8PY1pU9Z2i_TYtA0Cpbg23xyFrV7eXnooY,309
 pydantic_ai/profiles/mistral.py,sha256=ll01PmcK3szwlTfbaJLQmfd0TADN8lqjov9HpPJzCMQ,217
 pydantic_ai/profiles/moonshotai.py,sha256=e1RJnbEvazE6aJAqfmYLYGNtwNwg52XQDRDkcLrv3fU,272
-pydantic_ai/profiles/openai.py,sha256=YIzZAeJWO8dhmeHcOQk-Kyh6DUd5b0I5EQSTcK0-qy4,7564
+pydantic_ai/profiles/openai.py,sha256=lSPM1tDiWVxQH45YzD_GjYsnkBzLankRFu5JRGfx81I,8112
 pydantic_ai/profiles/qwen.py,sha256=K4_nJ_oN5NS_9W0Fl-dFgC4emVRTHPXFTtiJ_nycKHo,373
 pydantic_ai/providers/__init__.py,sha256=-jb9Vl4gE7z0katqwLPaKt5UileuPp0Brq0ZueBVJys,4246
 pydantic_ai/providers/anthropic.py,sha256=D35UXxCPXv8yIbD0fj9Zg2FvNyoMoJMeDUtVM8Sn78I,3046
@@ -94,7 +94,7 @@ pydantic_ai/providers/huggingface.py,sha256=MLAv-Z99Kii5Faolq97_0Ir1LUKH9CwRmJFa
 pydantic_ai/providers/mistral.py,sha256=EIUSENjFuGzBhvbdrarUTM4VPkesIMnZrzfnEKHOsc4,3120
 pydantic_ai/providers/moonshotai.py,sha256=3BAE9eC9QaD3kblVwxtQWEln0-PhgK7bRvrYTCEYXbY,3471
 pydantic_ai/providers/ollama.py,sha256=GNrrjK02fRCv-3l09N2rl6tFTnGVbdDtfbu5j4Wggv8,4629
-pydantic_ai/providers/openai.py,sha256=7iGij0EaFylab7dTZAZDgXr78tr-HsZrn9EI9AkWBNQ,3091
+pydantic_ai/providers/openai.py,sha256=xCpR2c7QnYQukiJJKiFTSaGSewPFht7ekTasJDjSimA,3071
 pydantic_ai/providers/openrouter.py,sha256=rSJwc_efQlOaGSxN5hjuemg-8llVCEGf5uZaeFwoQm8,4182
 pydantic_ai/providers/together.py,sha256=zFVSMSm5jXbpkNouvBOTjWrPmlPpCp6sQS5LMSyVjrQ,3482
 pydantic_ai/providers/vercel.py,sha256=wFIfyfD2RCAVRWtveDDMjumOkP8v9AHy94KV1HXF180,4285
@@ -109,8 +109,8 @@ pydantic_ai/toolsets/prefixed.py,sha256=0KwcDkW8OM36ZUsOLVP5h-Nj2tPq78L3_E2c-1Fb
 pydantic_ai/toolsets/prepared.py,sha256=Zjfz6S8In6PBVxoKFN9sKPN984zO6t0awB7Lnq5KODw,1431
 pydantic_ai/toolsets/renamed.py,sha256=JuLHpi-hYPiSPlaTpN8WiXLiGsywYK0axi2lW2Qs75k,1637
 pydantic_ai/toolsets/wrapper.py,sha256=mMuMPdko9PJUdcsexlRXbwViSwKKJfv6JE58d8HK3ds,1646
-pydantic_ai_slim-0.7.2.dist-info/METADATA,sha256=ibQxHaOvu0py9dGB6ALtmaIOpK23YHDxXINvJ92bjDE,4252
-pydantic_ai_slim-0.7.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.7.2.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
-pydantic_ai_slim-0.7.2.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
-pydantic_ai_slim-0.7.2.dist-info/RECORD,,
+pydantic_ai_slim-0.7.3.dist-info/METADATA,sha256=mfpWSZ9tg3qLymgDpn5XJmX25DYIU9id6c0fMSpHeBc,4661
+pydantic_ai_slim-0.7.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.7.3.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
+pydantic_ai_slim-0.7.3.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_slim-0.7.3.dist-info/RECORD,,