pydantic-ai-slim 0.4.3__py3-none-any.whl → 0.4.5__py3-none-any.whl

pydantic_ai/toolsets/function.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Sequence
+from dataclasses import dataclass, field, replace
+from typing import Any, Callable, overload
+
+from pydantic.json_schema import GenerateJsonSchema
+
+from .._run_context import AgentDepsT, RunContext
+from ..exceptions import UserError
+from ..tools import (
+    DocstringFormat,
+    GenerateToolJsonSchema,
+    Tool,
+    ToolFuncEither,
+    ToolParams,
+    ToolPrepareFunc,
+)
+from .abstract import AbstractToolset, ToolsetTool
+
+
+@dataclass
+class _FunctionToolsetTool(ToolsetTool[AgentDepsT]):
+    """A tool definition for a function toolset tool that keeps track of the function to call."""
+
+    call_func: Callable[[dict[str, Any], RunContext[AgentDepsT]], Awaitable[Any]]
+
+
+@dataclass(init=False)
+class FunctionToolset(AbstractToolset[AgentDepsT]):
+    """A toolset that lets Python functions be used as tools.
+
+    See [toolset docs](../toolsets.md#function-toolset) for more information.
+    """
+
+    max_retries: int = field(default=1)
+    tools: dict[str, Tool[Any]] = field(default_factory=dict)
+
+    def __init__(self, tools: Sequence[Tool[AgentDepsT] | ToolFuncEither[AgentDepsT, ...]] = [], max_retries: int = 1):
+        """Build a new function toolset.
+
+        Args:
+            tools: The tools to add to the toolset.
+            max_retries: The maximum number of retries for each tool during a run.
+        """
+        self.max_retries = max_retries
+        self.tools = {}
+        for tool in tools:
+            if isinstance(tool, Tool):
+                self.add_tool(tool)
+            else:
+                self.add_function(tool)
+
+    @overload
+    def tool(self, func: ToolFuncEither[AgentDepsT, ToolParams], /) -> ToolFuncEither[AgentDepsT, ToolParams]: ...
+
+    @overload
+    def tool(
+        self,
+        /,
+        *,
+        name: str | None = None,
+        retries: int | None = None,
+        prepare: ToolPrepareFunc[AgentDepsT] | None = None,
+        docstring_format: DocstringFormat = 'auto',
+        require_parameter_descriptions: bool = False,
+        schema_generator: type[GenerateJsonSchema] = GenerateToolJsonSchema,
+        strict: bool | None = None,
+    ) -> Callable[[ToolFuncEither[AgentDepsT, ToolParams]], ToolFuncEither[AgentDepsT, ToolParams]]: ...
+
+    def tool(
+        self,
+        func: ToolFuncEither[AgentDepsT, ToolParams] | None = None,
+        /,
+        *,
+        name: str | None = None,
+        retries: int | None = None,
+        prepare: ToolPrepareFunc[AgentDepsT] | None = None,
+        docstring_format: DocstringFormat = 'auto',
+        require_parameter_descriptions: bool = False,
+        schema_generator: type[GenerateJsonSchema] = GenerateToolJsonSchema,
+        strict: bool | None = None,
+    ) -> Any:
+        """Decorator to register a tool function which takes [`RunContext`][pydantic_ai.tools.RunContext] as its first argument.
+
+        Can decorate a sync or async functions.
+
+        The docstring is inspected to extract both the tool description and description of each parameter,
+        [learn more](../tools.md#function-tools-and-schema).
+
+        We can't add overloads for every possible signature of tool, since the return type is a recursive union
+        so the signature of functions decorated with `@toolset.tool` is obscured.
+
+        Example:
+        ```python
+        from pydantic_ai import Agent, RunContext
+        from pydantic_ai.toolsets.function import FunctionToolset
+
+        toolset = FunctionToolset()
+
+        @toolset.tool
+        def foobar(ctx: RunContext[int], x: int) -> int:
+            return ctx.deps + x
+
+        @toolset.tool(retries=2)
+        async def spam(ctx: RunContext[str], y: float) -> float:
+            return ctx.deps + y
+
+        agent = Agent('test', toolsets=[toolset], deps_type=int)
+        result = agent.run_sync('foobar', deps=1)
+        print(result.output)
+        #> {"foobar":1,"spam":1.0}
+        ```
+
+        Args:
+            func: The tool function to register.
+            name: The name of the tool, defaults to the function name.
+            retries: The number of retries to allow for this tool, defaults to the agent's default retries,
+                which defaults to 1.
+            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].
+            docstring_format: The format of the docstring, see [`DocstringFormat`][pydantic_ai.tools.DocstringFormat].
+                Defaults to `'auto'`, such that the format is inferred from the structure of the docstring.
+            require_parameter_descriptions: If True, raise an error if a parameter description is missing. Defaults to False.
+            schema_generator: The JSON schema generator class to use for this tool. Defaults to `GenerateToolJsonSchema`.
+            strict: Whether to enforce JSON schema compliance (only affects OpenAI).
+                See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info.
+        """
+
+        def tool_decorator(
+            func_: ToolFuncEither[AgentDepsT, ToolParams],
+        ) -> ToolFuncEither[AgentDepsT, ToolParams]:
+            # noinspection PyTypeChecker
+            self.add_function(
+                func_,
+                None,
+                name,
+                retries,
+                prepare,
+                docstring_format,
+                require_parameter_descriptions,
+                schema_generator,
+                strict,
+            )
+            return func_
+
+        return tool_decorator if func is None else tool_decorator(func)
+
+    def add_function(
+        self,
+        func: ToolFuncEither[AgentDepsT, ToolParams],
+        takes_ctx: bool | None = None,
+        name: str | None = None,
+        retries: int | None = None,
+        prepare: ToolPrepareFunc[AgentDepsT] | None = None,
+        docstring_format: DocstringFormat = 'auto',
+        require_parameter_descriptions: bool = False,
+        schema_generator: type[GenerateJsonSchema] = GenerateToolJsonSchema,
+        strict: bool | None = None,
+    ) -> None:
+        """Add a function as a tool to the toolset.
+
+        Can take a sync or async function.
+
+        The docstring is inspected to extract both the tool description and description of each parameter,
+        [learn more](../tools.md#function-tools-and-schema).
+
+        Args:
+            func: The tool function to register.
+            takes_ctx: Whether the function takes a [`RunContext`][pydantic_ai.tools.RunContext] as its first argument. If `None`, this is inferred from the function signature.
+            name: The name of the tool, defaults to the function name.
+            retries: The number of retries to allow for this tool, defaults to the agent's default retries,
+                which defaults to 1.
+            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].
+            docstring_format: The format of the docstring, see [`DocstringFormat`][pydantic_ai.tools.DocstringFormat].
+                Defaults to `'auto'`, such that the format is inferred from the structure of the docstring.
+            require_parameter_descriptions: If True, raise an error if a parameter description is missing. Defaults to False.
+            schema_generator: The JSON schema generator class to use for this tool. Defaults to `GenerateToolJsonSchema`.
+            strict: Whether to enforce JSON schema compliance (only affects OpenAI).
+                See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info.
+        """
+        tool = Tool[AgentDepsT](
+            func,
+            takes_ctx=takes_ctx,
+            name=name,
+            max_retries=retries,
+            prepare=prepare,
+            docstring_format=docstring_format,
+            require_parameter_descriptions=require_parameter_descriptions,
+            schema_generator=schema_generator,
+            strict=strict,
+        )
+        self.add_tool(tool)
+
+    def add_tool(self, tool: Tool[AgentDepsT]) -> None:
+        """Add a tool to the toolset.
+
+        Args:
+            tool: The tool to add.
+        """
+        if tool.name in self.tools:
+            raise UserError(f'Tool name conflicts with existing tool: {tool.name!r}')
+        if tool.max_retries is None:
+            tool.max_retries = self.max_retries
+        self.tools[tool.name] = tool
+
+    async def get_tools(self, ctx: RunContext[AgentDepsT]) -> dict[str, ToolsetTool[AgentDepsT]]:
+        tools: dict[str, ToolsetTool[AgentDepsT]] = {}
+        for original_name, tool in self.tools.items():
+            run_context = replace(ctx, tool_name=original_name, retry=ctx.retries.get(original_name, 0))
+            tool_def = await tool.prepare_tool_def(run_context)
+            if not tool_def:
+                continue
+
+            new_name = tool_def.name
+            if new_name in tools:
+                if new_name != original_name:
+                    raise UserError(f'Renaming tool {original_name!r} to {new_name!r} conflicts with existing tool.')
+                else:
+                    raise UserError(f'Tool name conflicts with previously renamed tool: {new_name!r}.')
+
+            tools[new_name] = _FunctionToolsetTool(
+                toolset=self,
+                tool_def=tool_def,
+                max_retries=tool.max_retries if tool.max_retries is not None else self.max_retries,
+                args_validator=tool.function_schema.validator,
+                call_func=tool.function_schema.call,
+            )
+        return tools
+
+    async def call_tool(
+        self, name: str, tool_args: dict[str, Any], ctx: RunContext[AgentDepsT], tool: ToolsetTool[AgentDepsT]
+    ) -> Any:
+        assert isinstance(tool, _FunctionToolsetTool)
+        return await tool.call_func(tool_args, ctx)

pydantic_ai/toolsets/prefixed.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from typing import Any
+
+from .._run_context import AgentDepsT, RunContext
+from .abstract import ToolsetTool
+from .wrapper import WrapperToolset
+
+
+@dataclass
+class PrefixedToolset(WrapperToolset[AgentDepsT]):
+    """A toolset that prefixes the names of the tools it contains.
+
+    See [toolset docs](../toolsets.md#prefixing-tool-names) for more information.
+    """
+
+    prefix: str
+
+    async def get_tools(self, ctx: RunContext[AgentDepsT]) -> dict[str, ToolsetTool[AgentDepsT]]:
+        return {
+            new_name: replace(
+                tool,
+                toolset=self,
+                tool_def=replace(tool.tool_def, name=new_name),
+            )
+            for name, tool in (await super().get_tools(ctx)).items()
+            if (new_name := f'{self.prefix}_{name}')
+        }
+
+    async def call_tool(
+        self, name: str, tool_args: dict[str, Any], ctx: RunContext[AgentDepsT], tool: ToolsetTool[AgentDepsT]
+    ) -> Any:
+        original_name = name.removeprefix(self.prefix + '_')
+        ctx = replace(ctx, tool_name=original_name)
+        tool = replace(tool, tool_def=replace(tool.tool_def, name=original_name))
+        return await super().call_tool(original_name, tool_args, ctx, tool)

pydantic_ai/toolsets/prepared.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+
+from .._run_context import AgentDepsT, RunContext
+from ..exceptions import UserError
+from ..tools import ToolsPrepareFunc
+from .abstract import ToolsetTool
+from .wrapper import WrapperToolset
+
+
+@dataclass
+class PreparedToolset(WrapperToolset[AgentDepsT]):
+    """A toolset that prepares the tools it contains using a prepare function that takes the agent context and the original tool definitions.
+
+    See [toolset docs](../toolsets.md#preparing-tool-definitions) for more information.
+    """
+
+    prepare_func: ToolsPrepareFunc[AgentDepsT]
+
+    async def get_tools(self, ctx: RunContext[AgentDepsT]) -> dict[str, ToolsetTool[AgentDepsT]]:
+        original_tools = await super().get_tools(ctx)
+        original_tool_defs = [tool.tool_def for tool in original_tools.values()]
+        prepared_tool_defs_by_name = {
+            tool_def.name: tool_def for tool_def in (await self.prepare_func(ctx, original_tool_defs) or [])
+        }
+
+        if len(prepared_tool_defs_by_name.keys() - original_tools.keys()) > 0:
+            raise UserError(
+                'Prepare function cannot add or rename tools. Use `FunctionToolset.add_function()` or `RenamedToolset` instead.'
+            )
+
+        return {
+            name: replace(original_tools[name], tool_def=tool_def)
+            for name, tool_def in prepared_tool_defs_by_name.items()
+        }

pydantic_ai/toolsets/renamed.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from typing import Any
+
+from .._run_context import AgentDepsT, RunContext
+from .abstract import ToolsetTool
+from .wrapper import WrapperToolset
+
+
+@dataclass
+class RenamedToolset(WrapperToolset[AgentDepsT]):
+    """A toolset that renames the tools it contains using a dictionary mapping new names to original names.
+
+    See [toolset docs](../toolsets.md#renaming-tools) for more information.
+    """
+
+    name_map: dict[str, str]
+
+    async def get_tools(self, ctx: RunContext[AgentDepsT]) -> dict[str, ToolsetTool[AgentDepsT]]:
+        original_to_new_name_map = {v: k for k, v in self.name_map.items()}
+        original_tools = await super().get_tools(ctx)
+        tools: dict[str, ToolsetTool[AgentDepsT]] = {}
+        for original_name, tool in original_tools.items():
+            new_name = original_to_new_name_map.get(original_name, None)
+            if new_name:
+                tools[new_name] = replace(
+                    tool,
+                    toolset=self,
+                    tool_def=replace(tool.tool_def, name=new_name),
+                )
+            else:
+                tools[original_name] = tool
+        return tools
+
+    async def call_tool(
+        self, name: str, tool_args: dict[str, Any], ctx: RunContext[AgentDepsT], tool: ToolsetTool[AgentDepsT]
+    ) -> Any:
+        original_name = self.name_map.get(name, name)
+        ctx = replace(ctx, tool_name=original_name)
+        tool = replace(tool, tool_def=replace(tool.tool_def, name=original_name))
+        return await super().call_tool(original_name, tool_args, ctx, tool)

pydantic_ai/toolsets/wrapper.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from typing_extensions import Self
+
+from .._run_context import AgentDepsT, RunContext
+from .abstract import AbstractToolset, ToolsetTool
+
+
+@dataclass
+class WrapperToolset(AbstractToolset[AgentDepsT]):
+    """A toolset that wraps another toolset and delegates to it.
+
+    See [toolset docs](../toolsets.md#wrapping-a-toolset) for more information.
+    """
+
+    wrapped: AbstractToolset[AgentDepsT]
+
+    async def __aenter__(self) -> Self:
+        await self.wrapped.__aenter__()
+        return self
+
+    async def __aexit__(self, *args: Any) -> bool | None:
+        return await self.wrapped.__aexit__(*args)
+
+    async def get_tools(self, ctx: RunContext[AgentDepsT]) -> dict[str, ToolsetTool[AgentDepsT]]:
+        return await self.wrapped.get_tools(ctx)
+
+    async def call_tool(
+        self, name: str, tool_args: dict[str, Any], ctx: RunContext[AgentDepsT], tool: ToolsetTool[AgentDepsT]
+    ) -> Any:
+        return await self.wrapped.call_tool(name, tool_args, ctx, tool)
+
+    def apply(self, visitor: Callable[[AbstractToolset[AgentDepsT]], None]) -> None:
+        self.wrapped.apply(visitor)

pydantic_ai/usage.py

@@ -13,7 +13,7 @@ __all__ = 'Usage', 'UsageLimits'
 class Usage:
     """LLM usage associated with a request or run.
 
-    Responsibility for calculating usage is on the model; PydanticAI simply sums the usage information across requests.
+    Responsibility for calculating usage is on the model; Pydantic AI simply sums the usage information across requests.
 
     You'll need to look up the documentation of the model you're using to convert usage to monetary costs.
     """
@@ -57,13 +57,19 @@ class Usage:
 
     def opentelemetry_attributes(self) -> dict[str, int]:
         """Get the token limits as OpenTelemetry attributes."""
-        result = {
-            'gen_ai.usage.input_tokens': self.request_tokens,
-            'gen_ai.usage.output_tokens': self.response_tokens,
-        }
-        for key, value in (self.details or {}).items():
-            result[f'gen_ai.usage.details.{key}'] = value  # pragma: no cover
-        return {k: v for k, v in result.items() if v}
+        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
+        details = self.details
+        if details:
+            prefix = 'gen_ai.usage.details.'
+            for key, value in details.items():
+                # Skipping check for value since spec implies all detail values are relevant
+                if value:
+                    result[prefix + key] = value
+        return result
 
     def has_values(self) -> bool:
         """Whether any values are set and non-zero."""

{pydantic_ai_slim-0.4.3.dist-info → pydantic_ai_slim-0.4.5.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.4.3
+Version: 0.4.5
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
-Author-email: Samuel Colvin <samuel@pydantic.dev>, Marcelo Trylesinski <marcelotryle@gmail.com>, David Montague <david@pydantic.dev>, Alex Hall <alex@pydantic.dev>
+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
 Classifier: Development Status :: 4 - Beta
@@ -30,11 +30,14 @@ Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.4.3
+Requires-Dist: pydantic-graph==0.4.5
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
 Requires-Dist: fasta2a>=0.4.1; extra == 'a2a'
+Provides-Extra: ag-ui
+Requires-Dist: ag-ui-protocol>=0.1.8; extra == 'ag-ui'
+Requires-Dist: starlette>=0.45.3; extra == 'ag-ui'
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.52.0; extra == 'anthropic'
 Provides-Extra: bedrock
@@ -48,7 +51,7 @@ Requires-Dist: cohere>=5.13.11; (platform_system != 'Emscripten') and extra == '
 Provides-Extra: duckduckgo
 Requires-Dist: ddgs>=9.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.4.3; extra == 'evals'
+Requires-Dist: pydantic-evals==0.4.5; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.24.0; extra == 'google'
 Provides-Extra: groq
@@ -62,7 +65,7 @@ Requires-Dist: mcp>=1.9.4; (python_version >= '3.10') and extra == 'mcp'
 Provides-Extra: mistral
 Requires-Dist: mistralai>=1.2.5; extra == 'mistral'
 Provides-Extra: openai
-Requires-Dist: openai>=1.76.0; extra == 'openai'
+Requires-Dist: openai>=1.92.0; extra == 'openai'
 Provides-Extra: tavily
 Requires-Dist: tavily-python>=0.5.0; extra == 'tavily'
 Provides-Extra: vertexai
@@ -70,7 +73,7 @@ Requires-Dist: google-auth>=2.36.0; extra == 'vertexai'
 Requires-Dist: requests>=2.32.2; extra == 'vertexai'
 Description-Content-Type: text/markdown
 
-# PydanticAI Slim
+# Pydantic AI 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)
@@ -78,6 +81,6 @@ Description-Content-Type: text/markdown
 [![versions](https://img.shields.io/pypi/pyversions/pydantic-ai-slim.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.
+Pydantic AI 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.4.3.dist-info → pydantic_ai_slim-0.4.5.dist-info}/RECORD

@@ -1,50 +1,52 @@
 pydantic_ai/__init__.py,sha256=h6Rll8pEzUUUX6SckosummoAFbq7ctfBlI6WSyaXR4I,1300
 pydantic_ai/__main__.py,sha256=Q_zJU15DUA01YtlJ2mnaLCoId2YmgmreVEERGuQT-Y0,132
-pydantic_ai/_a2a.py,sha256=PFgqW6I3qh3deY4WFfubTUroig9-NaAWxbeMxYjdtfI,12067
-pydantic_ai/_agent_graph.py,sha256=2XGCD8Or0zIKkXJLX0jY3eLI38km4mp_jHTQ8yxFw2g,42367
-pydantic_ai/_cli.py,sha256=R-sE-9gYqPxV5-5utso4g-bzAKMiTCdo33XOVqE0ZEg,13206
+pydantic_ai/_a2a.py,sha256=Tw_j9VRud0rLEk5kRs4GhRyhWYioXnsoZaTTyISq4M4,12126
+pydantic_ai/_agent_graph.py,sha256=FrNq9kppV8kFVZf6t-MVGVOWUVBCXQfAinQjMh2gVWw,37192
+pydantic_ai/_cli.py,sha256=YkiW2u9HGPd9fsgo9dpK1DZvtUPk4uXGQJcm75XgfhU,13250
 pydantic_ai/_function_schema.py,sha256=BZus5y51eqiGQKxQIcCiDoSPml3AtAb12-st_aujU2k,10813
 pydantic_ai/_griffe.py,sha256=Ugft16ZHw9CN_6-lW0Svn6jESK9zHXO_x4utkGBkbBI,5253
 pydantic_ai/_mcp.py,sha256=PuvwnlLjv7YYOa9AZJCrklevBug99zGMhwJCBGG7BHQ,5626
-pydantic_ai/_output.py,sha256=Z30MgZ7M3WMFwud6sJDIJ-N6Yil10Q8BrTHO5z5FBv0,37954
-pydantic_ai/_parts_manager.py,sha256=Lioi8b7Nfyax09yQu8jTkMzxd26dYDrdAqhYvjRSKqQ,16182
-pydantic_ai/_run_context.py,sha256=zNkSyiQSH-YweO39ii3iB2taouUOodo3sTjz2Lrj4Pc,1792
+pydantic_ai/_output.py,sha256=bi-ef06b-yDMc_1PUvCWDWLr1Oyk1aRWTYHZpRL-zV0,36595
+pydantic_ai/_parts_manager.py,sha256=CGm_fovTrFNQ3H8s9-edSBuG8Jzqrgw5TqRnPlzPyr4,16184
+pydantic_ai/_run_context.py,sha256=pqb_HPXytE1Z9zZRRuBboRYes_tVTC75WGTpZgnb2Ko,1691
 pydantic_ai/_system_prompt.py,sha256=lUSq-gDZjlYTGtd6BUm54yEvTIvgdwBmJ8mLsNZZtYU,1142
 pydantic_ai/_thinking_part.py,sha256=mzx2RZSfiQxAKpljEflrcXRXmFKxtp6bKVyorY3UYZk,1554
-pydantic_ai/_utils.py,sha256=9QSHZhbrCbUK18ckchC55OkBkP-1o6xhAxUkEMo9DSQ,15741
-pydantic_ai/agent.py,sha256=eAWi7onlDdaXOj2DAriVtzf3cTUrAUrt-oGYx--UJiA,96481
+pydantic_ai/_tool_manager.py,sha256=ptVj2oJm7Qm5MlDQHDNj8BPIEPY0HfkrzqeeD_ZuVbQ,8180
+pydantic_ai/_utils.py,sha256=0Pte4mjir4YFZJTa6i-H6Cra9NbVwSKjOKegArzUggk,16283
+pydantic_ai/ag_ui.py,sha256=b1Uqc0bGcFCn71hl04gcX_W80lQugueEm-0m--fde2s,25758
+pydantic_ai/agent.py,sha256=BIO9-5FGtrI7LfNe8BsjuLmLuzJgIYvR3OB7Bf3vctc,107920
 pydantic_ai/direct.py,sha256=WRfgke3zm-eeR39LTuh9XI2TrdHXAqO81eDvFwih4Ko,14803
-pydantic_ai/exceptions.py,sha256=1ujJeB3jDDQ-pH5ydBYrgStvR35-GlEW0bYGTGEr4ME,3127
+pydantic_ai/exceptions.py,sha256=o0l6fBrWI5UhosICVZ2yaT-JEJF05eqBlKlQCW8i9UM,3462
 pydantic_ai/format_as_xml.py,sha256=IINfh1evWDphGahqHNLBArB5dQ4NIqS3S-kru35ztGg,372
-pydantic_ai/format_prompt.py,sha256=qdKep95Sjlr7u1-qag4JwPbjoURbG0GbeU_l5ODTNw4,4466
-pydantic_ai/mcp.py,sha256=6RvxXIn6bUlL2XWpX69i8G3atU-HLLZBgKc93dYqeVo,21830
-pydantic_ai/messages.py,sha256=1G6cQs1tlBaCUhuv17RXyCkkiXzad6nYrjg-ZevNsjM,39421
-pydantic_ai/output.py,sha256=HU1dIiKyCaCvSxg8U6YMRvn1U50l0D9NMvGt_wqp_xI,11512
+pydantic_ai/format_prompt.py,sha256=Or-Ytq55RQb1UJqy2HKIyPpZ-knWXfdDP3Z6tNc6Orw,4244
+pydantic_ai/mcp.py,sha256=3YvQmTGpWC4stG9CthYCWnEE7XXIGuc2Xtfw4Yiya8c,23817
+pydantic_ai/messages.py,sha256=ZLV6Evc0-HWiR7nt0C_6Oe9kFhmE0o4Hg19TZPUPTaU,40089
+pydantic_ai/output.py,sha256=54Cwd1RruXlA5hucZ1h-SxFrzKHJuLvYvLtH9iyg2GI,11988
 pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/result.py,sha256=PQNWopb0Jb-VD7C-DtIECDX-xjqaFWi8Grhn2Tte66g,25873
+pydantic_ai/result.py,sha256=fhAlW90E_qfsC8IZfKVf8eYCz26NCoDLcxOATKwvYqk,27092
 pydantic_ai/settings.py,sha256=yuUZ7-GkdPB-Gbx71kSdh8dSr6gwM9gEwk84qNxPO_I,3552
-pydantic_ai/tools.py,sha256=ZZ5DZMzSLMZkM9y_G3fx5YnVTki6daPYgRkfuNXAQ-M,17774
-pydantic_ai/usage.py,sha256=35YPmItlzfNOwP35Rhh0qBUOlg5On5rUE7xqHQWrpaU,5596
+pydantic_ai/tools.py,sha256=PQm1yWbocdrhyLdMf_J8dJMTRJTWzyS2BEF24t4jgqw,14205
+pydantic_ai/usage.py,sha256=ceC9HHflyM_rkLBJqtaWPc-M8bEoq5rZF4XwGblPQoU,5830
 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/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/ext/aci.py,sha256=eiuWamUh90kexWyuGw_Fw2kM-EAA6Pv-IfNhf5hQ8fs,2123
-pydantic_ai/ext/langchain.py,sha256=iSyACZiJDDvxr0BKYl9dLxe4BPezCBHxgz_2Vk3W-Ak,1973
-pydantic_ai/models/__init__.py,sha256=SdGY1rsTsQADjsxFbkK-8BSO_ALjTVFj5XazthwWi8w,30299
-pydantic_ai/models/anthropic.py,sha256=DqG1Y9q3rqXYKI2I-AEWTD1jUyoAjlxnuN0FgT5CRXc,23822
+pydantic_ai/ext/aci.py,sha256=vUaNIj6pRM52x6RkPW_DohSYxJPm75pPUfOMw2i5Xx0,2515
+pydantic_ai/ext/langchain.py,sha256=GemxfhpyG1JPxj69PbRiSJANnY8Q5s4hSB7wqt-uTbo,2266
+pydantic_ai/models/__init__.py,sha256=P4tvuf_AS_sl5lfAJd6PxljUHREwSSYmvZdCs8pg4PA,30490
+pydantic_ai/models/anthropic.py,sha256=R_vOfxYiZbijFDLHYz8cMaruGOWL4To1c2iMzVuD-l0,23823
 pydantic_ai/models/bedrock.py,sha256=WnYykDnkyBd340tpt4l35T8SjT3z50RO83EZ8n77FVA,29399
 pydantic_ai/models/cohere.py,sha256=PTqwMRsgaLGVUrzb80sh9jS6CNuvDokvPHKT5KTYR_g,12788
 pydantic_ai/models/fallback.py,sha256=URaV-dTQWkg99xrlkmknue5lXZWDcEt7cJ1Vsky4oB4,5130
-pydantic_ai/models/function.py,sha256=Qyvg7n9SMyhNVugd9T525OrbWYW8BQedy7kBRpHu48Q,12457
-pydantic_ai/models/gemini.py,sha256=iyuw3FBfLsdeUT10sHz5xWXsesUrhE0yLa7R6hy8HJs,38603
-pydantic_ai/models/google.py,sha256=w6G9rXmL0x-PCI7KyBJFlqUdQV5feCpTR2kgCi52hTI,24192
-pydantic_ai/models/groq.py,sha256=fMT1WPkhuLH2G0iQ8IMxZ1oc7zQVgTLhzVZYydASt88,18665
+pydantic_ai/models/function.py,sha256=UIed008-9GgPSox_5uAzmjBLx71kcCWvBS2N3j48Ru4,13586
+pydantic_ai/models/gemini.py,sha256=Pm8KKzrhRrjM39XyQsd9pCzaXwiE1dQ0wPB4Slt10ZI,37973
+pydantic_ai/models/google.py,sha256=p3EPsZ09LIMGdxedHYKYNlRTL7xLJk2TD93BqzHgq0g,23891
+pydantic_ai/models/groq.py,sha256=Ll933U1qfWEA3YfGE4dCJBNNSGwH4DmmiKKfhrjdiSM,18700
 pydantic_ai/models/huggingface.py,sha256=DTkbfySeBfRqIrbMzgUunGnIo-3mLuaDyQjBYTT42bI,18857
-pydantic_ai/models/instrumented.py,sha256=dkVCY_SIoPEBLyAr7jODTsJWh6LzslPVzPwOfvqy3iA,16078
+pydantic_ai/models/instrumented.py,sha256=aqvzspcGexn1Molbu6Mn4EEPRBSoQCCCS_yknJvJJ-8,16205
 pydantic_ai/models/mcp_sampling.py,sha256=q9nnjNEAAbhrfRc_Qw5z9TtCHMG_SwlCWW9FvKWjh8k,3395
-pydantic_ai/models/mistral.py,sha256=fvR5ijjOGdV3OHBKtQFPBNjNO2qXhB0hxzXZkkSLMmY,30716
-pydantic_ai/models/openai.py,sha256=gyN9idM3164ftEW4iW9fFogKP_xQh4--ChwkHQxG-5Q,54264
+pydantic_ai/models/mistral.py,sha256=o7bDP7CF8_MzZ3jYtPpjqm8uVDhKTjw1KePPZCxXRhE,30720
+pydantic_ai/models/openai.py,sha256=_35Cp0-m-6ZECNRVcHpi4O4a37lJOc4OipEHHzZCkY4,55092
 pydantic_ai/models/test.py,sha256=S8hp3fJZJVSwWl01bBi-q7YpijdbstXhGg3aCPon98o,18227
 pydantic_ai/models/wrapper.py,sha256=A5-ncYhPF8c9S_czGoXkd55s2KOQb65p3jbVpwZiFPA,2043
 pydantic_ai/profiles/__init__.py,sha256=BXMqUpgRfosmYgcxjKAI9ESCj47JTSa30DhKXEgVLzM,2419
@@ -53,10 +55,11 @@ pydantic_ai/profiles/amazon.py,sha256=O4ijm1Lpz01vaSiHrkSeGQhbCKV5lyQVtHYqh0pCW_
 pydantic_ai/profiles/anthropic.py,sha256=DtTGh85tbkTrrrn2OrJ4FJKXWUIxUH_1Vw6y5fyMRyM,222
 pydantic_ai/profiles/cohere.py,sha256=lcL34Ht1jZopwuqoU6OV9l8vN4zwF-jiPjlsEABbSRo,215
 pydantic_ai/profiles/deepseek.py,sha256=DS_idprnXpMliKziKF0k1neLDJOwUvpatZ3YLaiYnCM,219
-pydantic_ai/profiles/google.py,sha256=DJ0otpkCgVIrjwV2lzAUAejw8ivwZT9pNAY_sGRcrVg,4891
+pydantic_ai/profiles/google.py,sha256=UUa1WxF--aryLcp0tKACeiSVkLAC4_mYixohRXPhJQs,4892
 pydantic_ai/profiles/grok.py,sha256=nBOxOCYCK9aiLmz2Q-esqYhotNbbBC1boAoOYIk1tVw,211
 pydantic_ai/profiles/meta.py,sha256=IAGPoUrLWd-g9ajAgpWp9fIeOrP-7dBlZ2HEFjIhUbY,334
 pydantic_ai/profiles/mistral.py,sha256=ll01PmcK3szwlTfbaJLQmfd0TADN8lqjov9HpPJzCMQ,217
+pydantic_ai/profiles/moonshotai.py,sha256=LL5RacKHKn6rdvhoKjpGgZ8aVriv5NMeL6HCWEANAiU,223
 pydantic_ai/profiles/openai.py,sha256=wFFtzbM22HbxxRNDXYEs6tr6_RSbv8xN_xBPz6RsP9s,6698
 pydantic_ai/profiles/qwen.py,sha256=u7pL8uomoQTVl45g5wDrHx0P_oFDLaN6ALswuwmkWc0,334
 pydantic_ai/providers/__init__.py,sha256=8D685KEGzwtgeg1Z5tC9ugr_O16E1VWWmeqSgAnx69k,3779
@@ -70,16 +73,26 @@ pydantic_ai/providers/github.py,sha256=zPu3oVJKjUE4zIqZ0YfgcTFBNdEy5rIBrSOdPCHJE
 pydantic_ai/providers/google.py,sha256=b8MOCsawPm07HrFEZGip5OGzW3zfq3HcCDzDNwXgPY4,5946
 pydantic_ai/providers/google_gla.py,sha256=BCF5_6EVtpkCZ6qIDuvgY1Qa9EirS71l51CBqPqk4C4,1825
 pydantic_ai/providers/google_vertex.py,sha256=MN3hnZg06pp2VFAmr3o_aAeop7LHj8TbgPSaF5D6PZE,9596
-pydantic_ai/providers/grok.py,sha256=mtlx7KP6xEDrDnYR1pmuT61wjUlYbCJNASNCDfVGQ5A,2912
-pydantic_ai/providers/groq.py,sha256=LcD0vXiZhWOsMatz0yKzt9NCIAw6H7OhJsQ5GPDqL44,3835
+pydantic_ai/providers/grok.py,sha256=dIkpxuuJlZ4pFtTSgeeJgiM_Z3mJU9qvk4f7jvSzi24,3141
+pydantic_ai/providers/groq.py,sha256=hqcR-RFHHHeemYP3K16IFeQTJKywNEU2wNZOSGTz6fE,3957
 pydantic_ai/providers/heroku.py,sha256=NmDIkAdxtWsvCjlX-bKI5FgI4HW1zO9-e0mrNQNGMCk,2990
 pydantic_ai/providers/huggingface.py,sha256=LRmJcJpQRRYvam3IAPkYs2fMUJf70GgE3aDgQltGRCU,3821
 pydantic_ai/providers/mistral.py,sha256=EIUSENjFuGzBhvbdrarUTM4VPkesIMnZrzfnEKHOsc4,3120
 pydantic_ai/providers/openai.py,sha256=7iGij0EaFylab7dTZAZDgXr78tr-HsZrn9EI9AkWBNQ,3091
 pydantic_ai/providers/openrouter.py,sha256=NXjNdnlXIBrBMMqbzcWQnowXOuZh4NHikXenBn5h3mc,4061
 pydantic_ai/providers/together.py,sha256=zFVSMSm5jXbpkNouvBOTjWrPmlPpCp6sQS5LMSyVjrQ,3482
-pydantic_ai_slim-0.4.3.dist-info/METADATA,sha256=QVhjCkzpDVNZRgtXCo4VCcuHM0gq6KhCPyPqbgH1EbM,3935
-pydantic_ai_slim-0.4.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.4.3.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
-pydantic_ai_slim-0.4.3.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
-pydantic_ai_slim-0.4.3.dist-info/RECORD,,
+pydantic_ai/toolsets/__init__.py,sha256=JCnqqAFeuHhmVW4XK0LM6Op_9B1cvsQUJ3vTmQ9Z5cQ,590
+pydantic_ai/toolsets/abstract.py,sha256=LqunlpwUsoHVn4VMtdjEoLY5kiMUF74PZ4KW539K8tQ,6027
+pydantic_ai/toolsets/combined.py,sha256=bmhQqxq4WQz_55a_cMsUfcCK6ggF74QEPoa12w34MOU,3371
+pydantic_ai/toolsets/deferred.py,sha256=j_CO2KesBXFPyVYiIk3sO2bimJ1bssnShdaGx4UNuPQ,1444
+pydantic_ai/toolsets/filtered.py,sha256=qmPeQDTZoWa_yyk6VXKHcpV9NFgdnLN48sBf7WItjBs,855
+pydantic_ai/toolsets/function.py,sha256=Pgc8q6vh3qkBzI3xL0k-CQaETGG63zfy1PyWtqqzXwc,10186
+pydantic_ai/toolsets/prefixed.py,sha256=MIStkzUdiU0rk2Y6P19IrTBxspH5pTstGxsqCBt-CX0,1293
+pydantic_ai/toolsets/prepared.py,sha256=Zjfz6S8In6PBVxoKFN9sKPN984zO6t0awB7Lnq5KODw,1431
+pydantic_ai/toolsets/renamed.py,sha256=JuLHpi-hYPiSPlaTpN8WiXLiGsywYK0axi2lW2Qs75k,1637
+pydantic_ai/toolsets/wrapper.py,sha256=WjLoiM1WDuffSJ4mDS6pZrEZGHgZ421fjrqFcB66W94,1205
+pydantic_ai_slim-0.4.5.dist-info/METADATA,sha256=TfoF7Uy7T5NeiztgTEl2yqUnMYbMnaP-vZL_l9iQ6kI,4098
+pydantic_ai_slim-0.4.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.4.5.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
+pydantic_ai_slim-0.4.5.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_slim-0.4.5.dist-info/RECORD,,