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

pydantic_ai/providers/openai.py

@@ -23,7 +23,7 @@ class OpenAIProvider(Provider[AsyncOpenAI]):
 
     @property
     def name(self) -> str:
-        return 'openai'  # pragma: no cover
+        return 'openai'
 
     @property
     def base_url(self) -> str:

pydantic_ai/providers/openrouter.py

@@ -17,6 +17,7 @@ from pydantic_ai.profiles.google import google_model_profile
 from pydantic_ai.profiles.grok import grok_model_profile
 from pydantic_ai.profiles.meta import meta_model_profile
 from pydantic_ai.profiles.mistral import mistral_model_profile
+from pydantic_ai.profiles.moonshotai import moonshotai_model_profile
 from pydantic_ai.profiles.openai import OpenAIJsonSchemaTransformer, OpenAIModelProfile, openai_model_profile
 from pydantic_ai.profiles.qwen import qwen_model_profile
 from pydantic_ai.providers import Provider
@@ -57,6 +58,7 @@ class OpenRouterProvider(Provider[AsyncOpenAI]):
             'amazon': amazon_model_profile,
             'deepseek': deepseek_model_profile,
             'meta-llama': meta_model_profile,
+            'moonshotai': moonshotai_model_profile,
         }
 
         profile = None

pydantic_ai/result.py

@@ -27,7 +27,7 @@ from .output import (
     OutputDataT,
     ToolOutput,
 )
-from .usage import Usage, UsageLimits
+from .usage import RunUsage, UsageLimits
 
 __all__ = (
     'OutputDataT',
@@ -52,7 +52,7 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
     _tool_manager: ToolManager[AgentDepsT]
 
     _agent_stream_iterator: AsyncIterator[AgentStreamEvent] | None = field(default=None, init=False)
-    _initial_run_ctx_usage: Usage = field(init=False)
+    _initial_run_ctx_usage: RunUsage = field(init=False)
 
     def __post_init__(self):
         self._initial_run_ctx_usage = copy(self._run_ctx.usage)
@@ -110,7 +110,7 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
         """Get the current state of the response."""
         return self._raw_stream_response.get()
 
-    def usage(self) -> Usage:
+    def usage(self) -> RunUsage:
         """Return the usage of the whole run.
 
         !!! note
@@ -196,7 +196,7 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
                     and isinstance(event.part, _messages.TextPart)
                     and event.part.content
                 ):
-                    yield event.part.content, event.index
+                    yield event.part.content, event.index  # pragma: no cover
                 elif (  # pragma: no branch
                     isinstance(event, _messages.PartDeltaEvent)
                     and isinstance(event.delta, _messages.TextPartDelta)
@@ -382,7 +382,7 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
         await self._marked_completed(self._stream_response.get())
         return output
 
-    def usage(self) -> Usage:
+    def usage(self) -> RunUsage:
         """Return the usage of the whole run.
 
         !!! note
@@ -425,7 +425,7 @@ class FinalResult(Generic[OutputDataT]):
 def _get_usage_checking_stream_response(
     stream_response: models.StreamedResponse,
     limits: UsageLimits | None,
-    get_usage: Callable[[], Usage],
+    get_usage: Callable[[], RunUsage],
 ) -> AsyncIterator[AgentStreamEvent]:
     if limits is not None and limits.has_token_limits():
 

pydantic_ai/run.py

@@ -66,9 +66,7 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
             CallToolsNode(
                 model_response=ModelResponse(
                     parts=[TextPart(content='The capital of France is Paris.')],
-                    usage=Usage(
-                        requests=1, request_tokens=56, response_tokens=7, total_tokens=63
-                    ),
+                    usage=RequestUsage(input_tokens=56, output_tokens=7),
                     model_name='gpt-4o',
                     timestamp=datetime.datetime(...),
                 )
@@ -203,12 +201,7 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
                     CallToolsNode(
                         model_response=ModelResponse(
                             parts=[TextPart(content='The capital of France is Paris.')],
-                            usage=Usage(
-                                requests=1,
-                                request_tokens=56,
-                                response_tokens=7,
-                                total_tokens=63,
-                            ),
+                            usage=RequestUsage(input_tokens=56, output_tokens=7),
                             model_name='gpt-4o',
                             timestamp=datetime.datetime(...),
                         )
@@ -235,7 +228,7 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
         assert isinstance(next_node, End), f'Unexpected node type: {type(next_node)}'
         return next_node
 
-    def usage(self) -> _usage.Usage:
+    def usage(self) -> _usage.RunUsage:
         """Get usage statistics for the run so far, including token usage, model requests, and so on."""
         return self._graph_run.state.usage
 
@@ -352,6 +345,6 @@ class AgentRunResult(Generic[OutputDataT]):
             self.new_messages(output_tool_return_content=output_tool_return_content)
         )
 
-    def usage(self) -> _usage.Usage:
+    def usage(self) -> _usage.RunUsage:
         """Return the usage of the whole run."""
         return self._state.usage

pydantic_ai/tools.py

@@ -31,7 +31,7 @@ __all__ = (
 ToolParams = ParamSpec('ToolParams', default=...)
 """Retrieval function param spec."""
 
-SystemPromptFunc = Union[
+SystemPromptFunc: TypeAlias = Union[
     Callable[[RunContext[AgentDepsT]], str],
     Callable[[RunContext[AgentDepsT]], Awaitable[str]],
     Callable[[], str],
@@ -42,17 +42,17 @@ SystemPromptFunc = Union[
 Usage `SystemPromptFunc[AgentDepsT]`.
 """
 
-ToolFuncContext = Callable[Concatenate[RunContext[AgentDepsT], ToolParams], Any]
+ToolFuncContext: TypeAlias = Callable[Concatenate[RunContext[AgentDepsT], ToolParams], Any]
 """A tool function that takes `RunContext` as the first argument.
 
 Usage `ToolContextFunc[AgentDepsT, ToolParams]`.
 """
-ToolFuncPlain = Callable[ToolParams, Any]
+ToolFuncPlain: TypeAlias = Callable[ToolParams, Any]
 """A tool function that does not take `RunContext` as the first argument.
 
 Usage `ToolPlainFunc[ToolParams]`.
 """
-ToolFuncEither = Union[ToolFuncContext[AgentDepsT, ToolParams], ToolFuncPlain[ToolParams]]
+ToolFuncEither: TypeAlias = Union[ToolFuncContext[AgentDepsT, ToolParams], ToolFuncPlain[ToolParams]]
 """Either kind of tool function.
 
 This is just a union of [`ToolFuncContext`][pydantic_ai.tools.ToolFuncContext] and
@@ -60,7 +60,7 @@ This is just a union of [`ToolFuncContext`][pydantic_ai.tools.ToolFuncContext] a
 
 Usage `ToolFuncEither[AgentDepsT, ToolParams]`.
 """
-ToolPrepareFunc: TypeAlias = 'Callable[[RunContext[AgentDepsT], ToolDefinition], Awaitable[ToolDefinition | None]]'
+ToolPrepareFunc: TypeAlias = Callable[[RunContext[AgentDepsT], 'ToolDefinition'], Awaitable['ToolDefinition | None']]
 """Definition of a function that can prepare a tool definition at call time.
 
 See [tool docs](../tools.md#tool-prepare) for more information.
@@ -88,9 +88,9 @@ hitchhiker = Tool(hitchhiker, prepare=only_if_42)
 Usage `ToolPrepareFunc[AgentDepsT]`.
 """
 
-ToolsPrepareFunc: TypeAlias = (
-    'Callable[[RunContext[AgentDepsT], list[ToolDefinition]], Awaitable[list[ToolDefinition] | None]]'
-)
+ToolsPrepareFunc: TypeAlias = Callable[
+    [RunContext[AgentDepsT], list['ToolDefinition']], Awaitable['list[ToolDefinition] | None']
+]
 """Definition of a function that can prepare the tool definition of all tools for each step.
 This is useful if you want to customize the definition of multiple tools or you want to register
 a subset of tools for a given step.
@@ -118,7 +118,7 @@ agent = Agent('openai:gpt-4o', prepare_tools=turn_on_strict_if_openai)
 Usage `ToolsPrepareFunc[AgentDepsT]`.
 """
 
-DocstringFormat = Literal['google', 'numpy', 'sphinx', 'auto']
+DocstringFormat: TypeAlias = Literal['google', 'numpy', 'sphinx', 'auto']
 """Supported docstring formats.
 
 * `'google'` — [Google-style](https://google.github.io/styleguide/pyguide.html#381-docstrings) docstrings.

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.1.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.1
+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.1
+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.1; 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'