pydantic-ai-slim 1.5.0__py3-none-any.whl → 1.7.0__py3-none-any.whl

pydantic_ai/_output.py

@@ -2,6 +2,7 @@ from __future__ import annotations as _annotations
 
 import inspect
 import json
+import re
 from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable, Sequence
 from dataclasses import dataclass, field
@@ -70,6 +71,7 @@ Usage `OutputValidatorFunc[AgentDepsT, T]`.
 
 DEFAULT_OUTPUT_TOOL_NAME = 'final_result'
 DEFAULT_OUTPUT_TOOL_DESCRIPTION = 'The final response which ends this conversation'
+OUTPUT_TOOL_NAME_SANITIZER = re.compile(r'[^a-zA-Z0-9-_]')
 
 
 async def execute_traced_output_function(
@@ -554,6 +556,20 @@ class PromptedOutputSchema(StructuredTextOutputSchema[OutputDataT]):
     def mode(self) -> OutputMode:
         return 'prompted'
 
+    @classmethod
+    def build_instructions(cls, template: str, object_def: OutputObjectDefinition) -> str:
+        """Build instructions from a template and an object definition."""
+        schema = object_def.json_schema.copy()
+        if object_def.name:
+            schema['title'] = object_def.name
+        if object_def.description:
+            schema['description'] = object_def.description
+
+        if '{schema}' not in template:
+            template = '\n\n'.join([template, '{schema}'])
+
+        return template.format(schema=json.dumps(schema))
+
     def raise_if_unsupported(self, profile: ModelProfile) -> None:
         """Raise an error if the mode is not supported by this model."""
         super().raise_if_unsupported(profile)
@@ -561,18 +577,8 @@ class PromptedOutputSchema(StructuredTextOutputSchema[OutputDataT]):
     def instructions(self, default_template: str) -> str:
         """Get instructions to tell model to output JSON matching the schema."""
         template = self.template or default_template
-
-        if '{schema}' not in template:
-            template = '\n\n'.join([template, '{schema}'])
-
         object_def = self.object_def
-        schema = object_def.json_schema.copy()
-        if object_def.name:
-            schema['title'] = object_def.name
-        if object_def.description:
-            schema['description'] = object_def.description
-
-        return template.format(schema=json.dumps(schema))
+        return self.build_instructions(template, object_def)
 
 
 @dataclass(init=False)
@@ -997,7 +1003,9 @@ class OutputToolset(AbstractToolset[AgentDepsT]):
             if name is None:
                 name = default_name
                 if multiple:
-                    name += f'_{object_def.name}'
+                    # strip unsupported characters like "[" and "]" from generic class names
+                    safe_name = OUTPUT_TOOL_NAME_SANITIZER.sub('', object_def.name or '')
+                    name += f'_{safe_name}'
 
             i = 1
             original_name = name

pydantic_ai/models/openai.py

@@ -1431,6 +1431,8 @@ class OpenAIResponsesModel(Model):
                             call_id=call_id,
                             type='function_call',
                         )
+                        if profile.openai_responses_requires_function_call_status_none:
+                            param['status'] = None  # type: ignore[reportGeneralTypeIssues]
                         if id and send_item_ids:  # pragma: no branch
                             param['id'] = id
                         openai_messages.append(param)

pydantic_ai/models/outlines.py

@@ -0,0 +1,563 @@
+# There are linting and coverage escapes for MLXLM and VLLMOffline as the CI would not contain the right
+# environment to be able to run the associated tests
+
+# pyright: reportUnnecessaryTypeIgnoreComment = false
+
+from __future__ import annotations
+
+import io
+from collections.abc import AsyncIterable, AsyncIterator, Sequence
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Any, Literal, cast
+
+from typing_extensions import assert_never
+
+from .. import UnexpectedModelBehavior, _utils
+from .._output import PromptedOutputSchema
+from .._run_context import RunContext
+from .._thinking_part import split_content_into_text_and_thinking
+from ..exceptions import UserError
+from ..messages import (
+    BinaryContent,
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
+    FilePart,
+    ImageUrl,
+    ModelMessage,
+    ModelRequest,
+    ModelResponse,
+    ModelResponsePart,
+    ModelResponseStreamEvent,
+    RetryPromptPart,
+    SystemPromptPart,
+    TextPart,
+    ThinkingPart,
+    ToolCallPart,
+    ToolReturnPart,
+    UserPromptPart,
+)
+from ..profiles import ModelProfile, ModelProfileSpec
+from ..providers import Provider, infer_provider
+from ..settings import ModelSettings
+from . import (
+    DownloadedItem,
+    Model,
+    ModelRequestParameters,
+    StreamedResponse,
+    download_item,
+)
+
+try:
+    from outlines.inputs import Chat, Image
+    from outlines.models.base import AsyncModel as OutlinesAsyncBaseModel, Model as OutlinesBaseModel
+    from outlines.models.llamacpp import LlamaCpp, from_llamacpp
+    from outlines.models.mlxlm import MLXLM, from_mlxlm
+    from outlines.models.sglang import AsyncSGLang, SGLang, from_sglang
+    from outlines.models.transformers import (
+        Transformers,
+        from_transformers,
+    )
+    from outlines.models.vllm_offline import (
+        VLLMOffline,
+        from_vllm_offline,  # pyright: ignore[reportUnknownVariableType]
+    )
+    from outlines.types.dsl import JsonSchema
+    from PIL import Image as PILImage
+except ImportError as _import_error:
+    raise ImportError(
+        'Please install `outlines` to use the Outlines model, '
+        'you can use the `outlines` optional group — `pip install "pydantic-ai-slim[outlines]"`'
+    ) from _import_error
+
+if TYPE_CHECKING:
+    import llama_cpp
+    import mlx.nn as nn
+    import transformers
+
+
+@dataclass(init=False)
+class OutlinesModel(Model):
+    """A model that relies on the Outlines library to run non API-based models."""
+
+    def __init__(
+        self,
+        model: OutlinesBaseModel | OutlinesAsyncBaseModel,
+        *,
+        provider: Literal['outlines'] | Provider[OutlinesBaseModel] = 'outlines',
+        profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
+    ):
+        """Initialize an Outlines model.
+
+        Args:
+            model: The Outlines model used for the model.
+            provider: The provider to use for OutlinesModel. Can be either the string 'outlines' or an
+                instance of `Provider[OutlinesBaseModel]`. If not provided, the other parameters will be used.
+            profile: The model profile to use. Defaults to a profile picked by the provider.
+            settings: Default model settings for this model instance.
+        """
+        self.model: OutlinesBaseModel | OutlinesAsyncBaseModel = model
+        self._model_name: str = 'outlines-model'
+
+        if isinstance(provider, str):
+            provider = infer_provider(provider)
+
+        super().__init__(settings=settings, profile=profile or provider.model_profile)
+
+    @classmethod
+    def from_transformers(
+        cls,
+        hf_model: transformers.modeling_utils.PreTrainedModel,
+        hf_tokenizer_or_processor: transformers.tokenization_utils.PreTrainedTokenizer
+        | transformers.processing_utils.ProcessorMixin,
+        *,
+        provider: Literal['outlines'] | Provider[OutlinesBaseModel] = 'outlines',
+        profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
+    ):
+        """Create an Outlines model from a Hugging Face model and tokenizer.
+
+        Args:
+            hf_model: The Hugging Face PreTrainedModel or any model that is compatible with the
+                `transformers` API.
+            hf_tokenizer_or_processor: Either a HuggingFace `PreTrainedTokenizer` or any tokenizer that is compatible
+                with the `transformers` API, or a HuggingFace processor inheriting from `ProcessorMixin`. If a
+                tokenizer is provided, a regular model will be used, while if you provide a processor, it will be a
+                multimodal model.
+            provider: The provider to use for OutlinesModel. Can be either the string 'outlines' or an
+                instance of `Provider[OutlinesBaseModel]`. If not provided, the other parameters will be used.
+            profile: The model profile to use. Defaults to a profile picked by the provider.
+            settings: Default model settings for this model instance.
+        """
+        outlines_model: OutlinesBaseModel = from_transformers(hf_model, hf_tokenizer_or_processor)
+        return cls(outlines_model, provider=provider, profile=profile, settings=settings)
+
+    @classmethod
+    def from_llamacpp(
+        cls,
+        llama_model: llama_cpp.Llama,
+        *,
+        provider: Literal['outlines'] | Provider[OutlinesBaseModel] = 'outlines',
+        profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
+    ):
+        """Create an Outlines model from a LlamaCpp model.
+
+        Args:
+            llama_model: The llama_cpp.Llama model to use.
+            provider: The provider to use for OutlinesModel. Can be either the string 'outlines' or an
+                instance of `Provider[OutlinesBaseModel]`. If not provided, the other parameters will be used.
+            profile: The model profile to use. Defaults to a profile picked by the provider.
+            settings: Default model settings for this model instance.
+        """
+        outlines_model: OutlinesBaseModel = from_llamacpp(llama_model)
+        return cls(outlines_model, provider=provider, profile=profile, settings=settings)
+
+    @classmethod
+    def from_mlxlm(  # pragma: no cover
+        cls,
+        mlx_model: nn.Module,
+        mlx_tokenizer: transformers.tokenization_utils.PreTrainedTokenizer,
+        *,
+        provider: Literal['outlines'] | Provider[OutlinesBaseModel] = 'outlines',
+        profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
+    ):
+        """Create an Outlines model from a MLXLM model.
+
+        Args:
+            mlx_model: The nn.Module model to use.
+            mlx_tokenizer: The PreTrainedTokenizer to use.
+            provider: The provider to use for OutlinesModel. Can be either the string 'outlines' or an
+                instance of `Provider[OutlinesBaseModel]`. If not provided, the other parameters will be used.
+            profile: The model profile to use. Defaults to a profile picked by the provider.
+            settings: Default model settings for this model instance.
+        """
+        outlines_model: OutlinesBaseModel = from_mlxlm(mlx_model, mlx_tokenizer)
+        return cls(outlines_model, provider=provider, profile=profile, settings=settings)
+
+    @classmethod
+    def from_sglang(
+        cls,
+        base_url: str,
+        api_key: str | None = None,
+        model_name: str | None = None,
+        *,
+        provider: Literal['outlines'] | Provider[OutlinesBaseModel] = 'outlines',
+        profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
+    ):
+        """Create an Outlines model to send requests to an SGLang server.
+
+        Args:
+            base_url: The url of the SGLang server.
+            api_key: The API key to use for authenticating requests to the SGLang server.
+            model_name: The name of the model to use.
+            provider: The provider to use for OutlinesModel. Can be either the string 'outlines' or an
+                instance of `Provider[OutlinesBaseModel]`. If not provided, the other parameters will be used.
+            profile: The model profile to use. Defaults to a profile picked by the provider.
+            settings: Default model settings for this model instance.
+        """
+        try:
+            from openai import AsyncOpenAI
+        except ImportError as _import_error:
+            raise ImportError(
+                'Please install `openai` to use the Outlines SGLang model, '
+                'you can use the `openai` optional group — `pip install "pydantic-ai-slim[openai]"`'
+            ) from _import_error
+
+        openai_client = AsyncOpenAI(base_url=base_url, api_key=api_key)
+        outlines_model: OutlinesBaseModel | OutlinesAsyncBaseModel = from_sglang(openai_client, model_name)
+        return cls(outlines_model, provider=provider, profile=profile, settings=settings)
+
+    @classmethod
+    def from_vllm_offline(  # pragma: no cover
+        cls,
+        vllm_model: Any,
+        *,
+        provider: Literal['outlines'] | Provider[OutlinesBaseModel] = 'outlines',
+        profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
+    ):
+        """Create an Outlines model from a vLLM offline inference model.
+
+        Args:
+            vllm_model: The vllm.LLM local model to use.
+            provider: The provider to use for OutlinesModel. Can be either the string 'outlines' or an
+                instance of `Provider[OutlinesBaseModel]`. If not provided, the other parameters will be used.
+            profile: The model profile to use. Defaults to a profile picked by the provider.
+            settings: Default model settings for this model instance.
+        """
+        outlines_model: OutlinesBaseModel | OutlinesAsyncBaseModel = from_vllm_offline(vllm_model)
+        return cls(outlines_model, provider=provider, profile=profile, settings=settings)
+
+    @property
+    def model_name(self) -> str:
+        return self._model_name
+
+    @property
+    def system(self) -> str:
+        return 'outlines'
+
+    async def request(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> ModelResponse:
+        """Make a request to the model."""
+        prompt, output_type, inference_kwargs = await self._build_generation_arguments(
+            messages, model_settings, model_request_parameters
+        )
+        # Async is available for SgLang
+        response: str
+        if isinstance(self.model, OutlinesAsyncBaseModel):
+            response = await self.model(prompt, output_type, None, **inference_kwargs)
+        else:
+            response = self.model(prompt, output_type, None, **inference_kwargs)
+        return self._process_response(response)
+
+    @asynccontextmanager
+    async def request_stream(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+        run_context: RunContext[Any] | None = None,
+    ) -> AsyncIterator[StreamedResponse]:
+        prompt, output_type, inference_kwargs = await self._build_generation_arguments(
+            messages, model_settings, model_request_parameters
+        )
+        # Async is available for SgLang
+        if isinstance(self.model, OutlinesAsyncBaseModel):
+            response = self.model.stream(prompt, output_type, None, **inference_kwargs)
+            yield await self._process_streamed_response(response, model_request_parameters)
+        else:
+            response = self.model.stream(prompt, output_type, None, **inference_kwargs)
+
+            async def async_response():
+                for chunk in response:
+                    yield chunk
+
+            yield await self._process_streamed_response(async_response(), model_request_parameters)
+
+    async def _build_generation_arguments(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> tuple[Chat, JsonSchema | None, dict[str, Any]]:
+        """Build the generation arguments for the model."""
+        if (
+            model_request_parameters.function_tools
+            or model_request_parameters.builtin_tools
+            or model_request_parameters.output_tools
+        ):
+            raise UserError('Outlines does not support function tools and builtin tools yet.')
+
+        if model_request_parameters.output_object:
+            instructions = PromptedOutputSchema.build_instructions(
+                self.profile.prompted_output_template, model_request_parameters.output_object
+            )
+            output_type = JsonSchema(model_request_parameters.output_object.json_schema)
+        else:
+            instructions = None
+            output_type = None
+
+        prompt = await self._format_prompt(messages, instructions)
+        inference_kwargs = self.format_inference_kwargs(model_settings)
+
+        return prompt, output_type, inference_kwargs
+
+    def format_inference_kwargs(self, model_settings: ModelSettings | None) -> dict[str, Any]:
+        """Format the model settings for the inference kwargs."""
+        settings_dict: dict[str, Any] = dict(model_settings) if model_settings else {}
+
+        if isinstance(self.model, Transformers):
+            settings_dict = self._format_transformers_inference_kwargs(settings_dict)
+        elif isinstance(self.model, LlamaCpp):
+            settings_dict = self._format_llama_cpp_inference_kwargs(settings_dict)
+        elif isinstance(self.model, MLXLM):  # pragma: no cover
+            settings_dict = self._format_mlxlm_inference_kwargs(settings_dict)
+        elif isinstance(self.model, SGLang | AsyncSGLang):
+            settings_dict = self._format_sglang_inference_kwargs(settings_dict)
+        elif isinstance(self.model, VLLMOffline):  # pragma: no cover
+            settings_dict = self._format_vllm_offline_inference_kwargs(settings_dict)
+
+        extra_body = settings_dict.pop('extra_body', {})
+        settings_dict.update(extra_body)
+
+        return settings_dict
+
+    def _format_transformers_inference_kwargs(self, model_settings: dict[str, Any]) -> dict[str, Any]:
+        """Select the model settings supported by the Transformers model."""
+        supported_args = [
+            'max_tokens',
+            'temperature',
+            'top_p',
+            'logit_bias',
+            'extra_body',
+        ]
+        filtered_settings = {k: model_settings[k] for k in supported_args if k in model_settings}
+
+        return filtered_settings
+
+    def _format_llama_cpp_inference_kwargs(self, model_settings: dict[str, Any]) -> dict[str, Any]:
+        """Select the model settings supported by the LlamaCpp model."""
+        supported_args = [
+            'max_tokens',
+            'temperature',
+            'top_p',
+            'seed',
+            'presence_penalty',
+            'frequency_penalty',
+            'logit_bias',
+            'extra_body',
+        ]
+        filtered_settings = {k: model_settings[k] for k in supported_args if k in model_settings}
+
+        return filtered_settings
+
+    def _format_mlxlm_inference_kwargs(  # pragma: no cover
+        self, model_settings: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Select the model settings supported by the MLXLM model."""
+        supported_args = [
+            'extra_body',
+        ]
+        filtered_settings = {k: model_settings[k] for k in supported_args if k in model_settings}
+
+        return filtered_settings
+
+    def _format_sglang_inference_kwargs(self, model_settings: dict[str, Any]) -> dict[str, Any]:
+        """Select the model settings supported by the SGLang model."""
+        supported_args = [
+            'max_tokens',
+            'temperature',
+            'top_p',
+            'presence_penalty',
+            'frequency_penalty',
+            'extra_body',
+        ]
+        filtered_settings = {k: model_settings[k] for k in supported_args if k in model_settings}
+
+        return filtered_settings
+
+    def _format_vllm_offline_inference_kwargs(  # pragma: no cover
+        self, model_settings: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Select the model settings supported by the vLLMOffline model."""
+        from vllm.sampling_params import SamplingParams  # pyright: ignore
+
+        supported_args = [
+            'max_tokens',
+            'temperature',
+            'top_p',
+            'seed',
+            'presence_penalty',
+            'frequency_penalty',
+            'logit_bias',
+            'extra_body',
+        ]
+        # The arguments that are part of the fields of `ModelSettings` must be put in a `SamplingParams` object and
+        # provided through the `sampling_params` argument to vLLM
+        sampling_params = model_settings.get('extra_body', {}).pop('sampling_params', SamplingParams())
+
+        for key in supported_args:
+            setattr(sampling_params, key, model_settings.get(key, None))
+
+        filtered_settings = {
+            'sampling_params': sampling_params,
+            **model_settings.get('extra_body', {}),
+        }
+
+        return filtered_settings
+
+    async def _format_prompt(  # noqa: C901
+        self, messages: list[ModelMessage], output_format_instructions: str | None
+    ) -> Chat:
+        """Turn the model messages into an Outlines Chat instance."""
+        chat = Chat()
+
+        if instructions := self._get_instructions(messages):
+            chat.add_system_message(instructions)
+
+        if output_format_instructions:
+            chat.add_system_message(output_format_instructions)
+
+        for message in messages:
+            if isinstance(message, ModelRequest):
+                for part in message.parts:
+                    if isinstance(part, SystemPromptPart):
+                        chat.add_system_message(part.content)
+                    elif isinstance(part, UserPromptPart):
+                        if isinstance(part.content, str):
+                            chat.add_user_message(part.content)
+                        elif isinstance(part.content, Sequence):
+                            outlines_input: Sequence[str | Image] = []
+                            for item in part.content:
+                                if isinstance(item, str):
+                                    outlines_input.append(item)
+                                elif isinstance(item, ImageUrl):
+                                    image_content: DownloadedItem[bytes] = await download_item(
+                                        item, data_format='bytes', type_format='mime'
+                                    )
+                                    image = self._create_PIL_image(image_content['data'], image_content['data_type'])
+                                    outlines_input.append(Image(image))
+                                elif isinstance(item, BinaryContent) and item.is_image:
+                                    image = self._create_PIL_image(item.data, item.media_type)
+                                    outlines_input.append(Image(image))
+                                else:
+                                    raise UserError(
+                                        'Each element of the content sequence must be a string, an `ImageUrl`'
+                                        + ' or a `BinaryImage`.'
+                                    )
+                            chat.add_user_message(outlines_input)
+                        else:
+                            assert_never(part.content)
+                    elif isinstance(part, RetryPromptPart):
+                        chat.add_user_message(part.model_response())
+                    elif isinstance(part, ToolReturnPart):
+                        raise UserError('Tool calls are not supported for Outlines models yet.')
+                    else:
+                        assert_never(part)
+            elif isinstance(message, ModelResponse):
+                text_parts: list[str] = []
+                image_parts: list[Image] = []
+                for part in message.parts:
+                    if isinstance(part, TextPart):
+                        text_parts.append(part.content)
+                    elif isinstance(part, ThinkingPart):
+                        # NOTE: We don't send ThinkingPart to the providers yet.
+                        pass
+                    elif isinstance(part, ToolCallPart | BuiltinToolCallPart | BuiltinToolReturnPart):
+                        raise UserError('Tool calls are not supported for Outlines models yet.')
+                    elif isinstance(part, FilePart):
+                        if isinstance(part.content, BinaryContent) and part.content.is_image:
+                            image = self._create_PIL_image(part.content.data, part.content.media_type)
+                            image_parts.append(Image(image))
+                        else:
+                            raise UserError(
+                                'File parts other than `BinaryImage` are not supported for Outlines models yet.'
+                            )
+                    else:
+                        assert_never(part)
+                if len(text_parts) == 1 and len(image_parts) == 0:
+                    chat.add_assistant_message(text_parts[0])
+                else:
+                    chat.add_assistant_message([*text_parts, *image_parts])
+            else:
+                assert_never(message)
+        return chat
+
+    def _create_PIL_image(self, data: bytes, data_type: str) -> PILImage.Image:
+        """Create a PIL Image from the data and data type."""
+        image = PILImage.open(io.BytesIO(data))
+        image.format = data_type.split('/')[-1]
+        return image
+
+    def _process_response(self, response: str) -> ModelResponse:
+        """Turn the Outlines text response into a Pydantic AI model response instance."""
+        return ModelResponse(
+            parts=cast(
+                list[ModelResponsePart], split_content_into_text_and_thinking(response, self.profile.thinking_tags)
+            ),
+        )
+
+    async def _process_streamed_response(
+        self, response: AsyncIterable[str], model_request_parameters: ModelRequestParameters
+    ) -> StreamedResponse:
+        """Turn the Outlines text response into a Pydantic AI streamed response instance."""
+        peekable_response = _utils.PeekableAsyncStream(response)
+        first_chunk = await peekable_response.peek()
+        if isinstance(first_chunk, _utils.Unset):  # pragma: no cover
+            raise UnexpectedModelBehavior('Streamed response ended without content or tool calls')
+
+        timestamp = datetime.now(tz=timezone.utc)
+        return OutlinesStreamedResponse(
+            model_request_parameters=model_request_parameters,
+            _model_name=self._model_name,
+            _model_profile=self.profile,
+            _response=peekable_response,
+            _timestamp=timestamp,
+            _provider_name='outlines',
+        )
+
+
+@dataclass
+class OutlinesStreamedResponse(StreamedResponse):
+    """Implementation of `StreamedResponse` for Outlines models."""
+
+    _model_name: str
+    _model_profile: ModelProfile
+    _response: AsyncIterable[str]
+    _timestamp: datetime
+    _provider_name: str
+
+    async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
+        async for event in self._response:
+            event = self._parts_manager.handle_text_delta(
+                vendor_part_id='content',
+                content=event,
+                thinking_tags=self._model_profile.thinking_tags,
+                ignore_leading_whitespace=self._model_profile.ignore_streamed_leading_whitespace,
+            )
+            if event is not None:  # pragma: no branch
+                yield event
+
+    @property
+    def model_name(self) -> str:
+        """Get the model name of the response."""
+        return self._model_name
+
+    @property
+    def provider_name(self) -> str:
+        """Get the provider name."""
+        return self._provider_name
+
+    @property
+    def timestamp(self) -> datetime:
+        """Get the timestamp of the response."""
+        return self._timestamp

pydantic_ai/models/test.py

@@ -44,11 +44,14 @@ class _WrappedTextOutput:
     value: str | None
 
 
-@dataclass
+@dataclass(init=False)
 class _WrappedToolOutput:
     """A wrapper class to tag an output that came from the custom_output_args field."""
 
-    value: Any | None
+    value: dict[str, Any] | None
+
+    def __init__(self, value: Any | None):
+        self.value = pydantic_core.to_jsonable_python(value)
 
 
 @dataclass(init=False)
@@ -364,7 +367,7 @@ class _JsonSchemaTestData:
         self.defs = schema.get('$defs', {})
         self.seed = seed
 
-    def generate(self) -> Any:
+    def generate(self) -> dict[str, Any]:
         """Generate data for the JSON schema."""
         return self._gen_any(self.schema)
 

pydantic_ai/profiles/openai.py

@@ -44,6 +44,13 @@ class OpenAIModelProfile(ModelProfile):
     openai_supports_encrypted_reasoning_content: bool = False
     """Whether the model supports including encrypted reasoning content in the response."""
 
+    openai_responses_requires_function_call_status_none: bool = False
+    """Whether the Responses API requires the `status` field on function tool calls to be `None`.
+
+    This is required by vLLM Responses API versions before https://github.com/vllm-project/vllm/pull/26706.
+    See https://github.com/pydantic/pydantic-ai/issues/3245 for more details.
+    """
+
     def __post_init__(self):  # pragma: no cover
         if not self.openai_supports_sampling_settings:
             warnings.warn(

pydantic_ai/providers/__init__.py

@@ -145,6 +145,10 @@ def infer_provider_class(provider: str) -> type[Provider[Any]]:  # noqa: C901
         from .ovhcloud import OVHcloudProvider
 
         return OVHcloudProvider
+    elif provider == 'outlines':
+        from .outlines import OutlinesProvider
+
+        return OutlinesProvider
     else:  # pragma: no cover
         raise ValueError(f'Unknown provider: {provider}')
 

pydantic_ai/providers/outlines.py

@@ -0,0 +1,40 @@
+from __future__ import annotations as _annotations
+
+from typing import Any
+
+from pydantic_ai.profiles import ModelProfile
+from pydantic_ai.providers import Provider
+
+
+class OutlinesProvider(Provider[Any]):
+    """Provider for Outlines API."""
+
+    @property
+    def name(self) -> str:
+        """The provider name."""
+        return 'outlines'
+
+    @property
+    def base_url(self) -> str:
+        """The base URL for the provider API."""
+        raise NotImplementedError(
+            'The Outlines provider does not have a set base URL as it functions '
+            + 'with a set of different underlying models.'
+        )
+
+    @property
+    def client(self) -> Any:
+        """The client for the provider."""
+        raise NotImplementedError(
+            'The Outlines provider does not have a set client as it functions '
+            + 'with a set of different underlying models.'
+        )
+
+    def model_profile(self, model_name: str) -> ModelProfile | None:
+        """The model profile for the named model, if available."""
+        return ModelProfile(
+            supports_tools=False,
+            supports_json_schema_output=True,
+            supports_json_object_output=True,
+            default_structured_output_mode='native',
+        )

pydantic_ai/settings.py

@@ -24,6 +24,7 @@ class ModelSettings(TypedDict, total=False):
     * Mistral
     * Bedrock
     * MCP Sampling
+    * Outlines (all providers)
     """
 
     temperature: float
@@ -43,6 +44,7 @@ class ModelSettings(TypedDict, total=False):
     * Cohere
     * Mistral
     * Bedrock
+    * Outlines (Transformers, LlamaCpp, SgLang, VLLMOffline)
     """
 
     top_p: float
@@ -61,6 +63,7 @@ class ModelSettings(TypedDict, total=False):
     * Cohere
     * Mistral
     * Bedrock
+    * Outlines (Transformers, LlamaCpp, SgLang, VLLMOffline)
     """
 
     timeout: float | Timeout
@@ -95,6 +98,7 @@ class ModelSettings(TypedDict, total=False):
     * Cohere
     * Mistral
     * Gemini
+    * Outlines (LlamaCpp, VLLMOffline)
     """
 
     presence_penalty: float
@@ -107,6 +111,7 @@ class ModelSettings(TypedDict, total=False):
     * Cohere
     * Gemini
     * Mistral
+    * Outlines (LlamaCpp, SgLang, VLLMOffline)
     """
 
     frequency_penalty: float
@@ -119,6 +124,7 @@ class ModelSettings(TypedDict, total=False):
     * Cohere
     * Gemini
     * Mistral
+    * Outlines (LlamaCpp, SgLang, VLLMOffline)
     """
 
     logit_bias: dict[str, int]
@@ -128,6 +134,7 @@ class ModelSettings(TypedDict, total=False):
 
     * OpenAI
     * Groq
+    * Outlines (Transformers, LlamaCpp, VLLMOffline)
     """
 
     stop_sequences: list[str]
@@ -162,6 +169,7 @@ class ModelSettings(TypedDict, total=False):
     * OpenAI
     * Anthropic
     * Groq
+    * Outlines (all providers)
     """
 
 

pydantic_ai/toolsets/fastmcp.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+import base64
+from asyncio import Lock
+from contextlib import AsyncExitStack
+from dataclasses import KW_ONLY, dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+from pydantic import AnyUrl
+from typing_extensions import Self, assert_never
+
+from pydantic_ai import messages
+from pydantic_ai.exceptions import ModelRetry
+from pydantic_ai.tools import AgentDepsT, RunContext, ToolDefinition
+from pydantic_ai.toolsets import AbstractToolset
+from pydantic_ai.toolsets.abstract import ToolsetTool
+
+try:
+    from fastmcp.client import Client
+    from fastmcp.client.transports import ClientTransport
+    from fastmcp.exceptions import ToolError
+    from fastmcp.mcp_config import MCPConfig
+    from fastmcp.server import FastMCP
+    from mcp.server.fastmcp import FastMCP as FastMCP1Server
+    from mcp.types import (
+        AudioContent,
+        BlobResourceContents,
+        ContentBlock,
+        EmbeddedResource,
+        ImageContent,
+        ResourceLink,
+        TextContent,
+        TextResourceContents,
+        Tool as MCPTool,
+    )
+
+    from pydantic_ai.mcp import TOOL_SCHEMA_VALIDATOR
+
+except ImportError as _import_error:
+    raise ImportError(
+        'Please install the `fastmcp` package to use the FastMCP server, '
+        'you can use the `fastmcp` optional group — `pip install "pydantic-ai-slim[fastmcp]"`'
+    ) from _import_error
+
+
+if TYPE_CHECKING:
+    from fastmcp.client.client import CallToolResult
+
+
+FastMCPToolResult = messages.BinaryContent | dict[str, Any] | str | None
+
+ToolErrorBehavior = Literal['model_retry', 'error']
+
+UNKNOWN_BINARY_MEDIA_TYPE = 'application/octet-stream'
+
+
+@dataclass(init=False)
+class FastMCPToolset(AbstractToolset[AgentDepsT]):
+    """A FastMCP Toolset that uses the FastMCP Client to call tools from a local or remote MCP Server.
+
+    The Toolset can accept a FastMCP Client, a FastMCP Transport, or any other object which a FastMCP Transport can be created from.
+
+    See https://gofastmcp.com/clients/transports for a full list of transports available.
+    """
+
+    client: Client[Any]
+    """The FastMCP client to use."""
+
+    _: KW_ONLY
+
+    tool_error_behavior: Literal['model_retry', 'error']
+    """The behavior to take when a tool error occurs."""
+
+    max_retries: int
+    """The maximum number of retries to attempt if a tool call fails."""
+
+    _id: str | None
+
+    def __init__(
+        self,
+        client: Client[Any]
+        | ClientTransport
+        | FastMCP
+        | FastMCP1Server
+        | AnyUrl
+        | Path
+        | MCPConfig
+        | dict[str, Any]
+        | str,
+        *,
+        max_retries: int = 1,
+        tool_error_behavior: Literal['model_retry', 'error'] = 'model_retry',
+        id: str | None = None,
+    ) -> None:
+        if isinstance(client, Client):
+            self.client = client
+        else:
+            self.client = Client[Any](transport=client)
+
+        self._id = id
+        self.max_retries = max_retries
+        self.tool_error_behavior = tool_error_behavior
+
+        self._enter_lock: Lock = Lock()
+        self._running_count: int = 0
+        self._exit_stack: AsyncExitStack | None = None
+
+    @property
+    def id(self) -> str | None:
+        return self._id
+
+    async def __aenter__(self) -> Self:
+        async with self._enter_lock:
+            if self._running_count == 0:
+                self._exit_stack = AsyncExitStack()
+                await self._exit_stack.enter_async_context(self.client)
+
+            self._running_count += 1
+
+        return self
+
+    async def __aexit__(self, *args: Any) -> bool | None:
+        async with self._enter_lock:
+            self._running_count -= 1
+            if self._running_count == 0 and self._exit_stack:
+                await self._exit_stack.aclose()
+                self._exit_stack = None
+
+        return None
+
+    async def get_tools(self, ctx: RunContext[AgentDepsT]) -> dict[str, ToolsetTool[AgentDepsT]]:
+        async with self:
+            mcp_tools: list[MCPTool] = await self.client.list_tools()
+
+            return {
+                tool.name: _convert_mcp_tool_to_toolset_tool(toolset=self, mcp_tool=tool, retries=self.max_retries)
+                for tool in mcp_tools
+            }
+
+    async def call_tool(
+        self, name: str, tool_args: dict[str, Any], ctx: RunContext[AgentDepsT], tool: ToolsetTool[AgentDepsT]
+    ) -> Any:
+        async with self:
+            try:
+                call_tool_result: CallToolResult = await self.client.call_tool(name=name, arguments=tool_args)
+            except ToolError as e:
+                if self.tool_error_behavior == 'model_retry':
+                    raise ModelRetry(message=str(e)) from e
+                else:
+                    raise e
+
+        # If we have structured content, return that
+        if call_tool_result.structured_content:
+            return call_tool_result.structured_content
+
+        # Otherwise, return the content
+        return _map_fastmcp_tool_results(parts=call_tool_result.content)
+
+
+def _convert_mcp_tool_to_toolset_tool(
+    toolset: FastMCPToolset[AgentDepsT],
+    mcp_tool: MCPTool,
+    retries: int,
+) -> ToolsetTool[AgentDepsT]:
+    """Convert an MCP tool to a toolset tool."""
+    return ToolsetTool[AgentDepsT](
+        tool_def=ToolDefinition(
+            name=mcp_tool.name,
+            description=mcp_tool.description,
+            parameters_json_schema=mcp_tool.inputSchema,
+            metadata={
+                'meta': mcp_tool.meta,
+                'annotations': mcp_tool.annotations.model_dump() if mcp_tool.annotations else None,
+                'output_schema': mcp_tool.outputSchema or None,
+            },
+        ),
+        toolset=toolset,
+        max_retries=retries,
+        args_validator=TOOL_SCHEMA_VALIDATOR,
+    )
+
+
+def _map_fastmcp_tool_results(parts: list[ContentBlock]) -> list[FastMCPToolResult] | FastMCPToolResult:
+    """Map FastMCP tool results to toolset tool results."""
+    mapped_results = [_map_fastmcp_tool_result(part) for part in parts]
+
+    if len(mapped_results) == 1:
+        return mapped_results[0]
+
+    return mapped_results
+
+
+def _map_fastmcp_tool_result(part: ContentBlock) -> FastMCPToolResult:
+    if isinstance(part, TextContent):
+        return part.text
+    elif isinstance(part, ImageContent | AudioContent):
+        return messages.BinaryContent(data=base64.b64decode(part.data), media_type=part.mimeType)
+    elif isinstance(part, EmbeddedResource):
+        if isinstance(part.resource, BlobResourceContents):
+            return messages.BinaryContent(
+                data=base64.b64decode(part.resource.blob),
+                media_type=part.resource.mimeType or UNKNOWN_BINARY_MEDIA_TYPE,
+            )
+        elif isinstance(part.resource, TextResourceContents):
+            return part.resource.text
+        else:
+            assert_never(part.resource)
+    elif isinstance(part, ResourceLink):
+        # ResourceLink is not yet supported by the FastMCP toolset as reading resources is not yet supported.
+        raise NotImplementedError(
+            'ResourceLink is not supported by the FastMCP toolset as reading resources is not yet supported.'
+        )
+    else:
+        assert_never(part)

{pydantic_ai_slim-1.5.0.dist-info → pydantic_ai_slim-1.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 1.5.0
+Version: 1.7.0
 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
@@ -33,7 +33,7 @@ Requires-Dist: genai-prices>=0.0.35
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==1.5.0
+Requires-Dist: pydantic-graph==1.7.0
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -57,7 +57,9 @@ Requires-Dist: dbos>=1.14.0; extra == 'dbos'
 Provides-Extra: duckduckgo
 Requires-Dist: ddgs>=9.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==1.5.0; extra == 'evals'
+Requires-Dist: pydantic-evals==1.7.0; extra == 'evals'
+Provides-Extra: fastmcp
+Requires-Dist: fastmcp>=2.12.0; extra == 'fastmcp'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.46.0; extra == 'google'
 Provides-Extra: groq
@@ -72,6 +74,20 @@ Provides-Extra: mistral
 Requires-Dist: mistralai>=1.9.10; extra == 'mistral'
 Provides-Extra: openai
 Requires-Dist: openai>=1.107.2; extra == 'openai'
+Provides-Extra: outlines-llamacpp
+Requires-Dist: outlines[llamacpp]<1.3.0,>=1.0.0; extra == 'outlines-llamacpp'
+Provides-Extra: outlines-mlxlm
+Requires-Dist: outlines[mlxlm]<1.3.0,>=1.0.0; extra == 'outlines-mlxlm'
+Provides-Extra: outlines-sglang
+Requires-Dist: outlines[sglang]<1.3.0,>=1.0.0; extra == 'outlines-sglang'
+Requires-Dist: pillow; extra == 'outlines-sglang'
+Provides-Extra: outlines-transformers
+Requires-Dist: outlines[transformers]<1.3.0,>=1.0.0; extra == 'outlines-transformers'
+Requires-Dist: pillow; extra == 'outlines-transformers'
+Requires-Dist: transformers>=4.0.0; extra == 'outlines-transformers'
+Provides-Extra: outlines-vllm-offline
+Requires-Dist: outlines<1.3.0,>=1.0.0; extra == 'outlines-vllm-offline'
+Requires-Dist: vllm; (python_version < '3.12') and extra == 'outlines-vllm-offline'
 Provides-Extra: prefect
 Requires-Dist: prefect>=3.4.21; extra == 'prefect'
 Provides-Extra: retries

{pydantic_ai_slim-1.5.0.dist-info → pydantic_ai_slim-1.7.0.dist-info}/RECORD

@@ -9,7 +9,7 @@ pydantic_ai/_instrumentation.py,sha256=3XJxRUT0m2K6NfpAb-JKro4Rpw-8weqQ_ydtufeKV
 pydantic_ai/_json_schema.py,sha256=Br48srbwCTVIie98a9UEMGcCcTIa3E4zVvCbkxqQRso,7268
 pydantic_ai/_mcp.py,sha256=PuvwnlLjv7YYOa9AZJCrklevBug99zGMhwJCBGG7BHQ,5626
 pydantic_ai/_otel_messages.py,sha256=SsMpbyI1fIISOck_wQcZJPIOei8lOmvwARkdPSCx8y8,1650
-pydantic_ai/_output.py,sha256=gHS1qwM701cH5FGGRUrMxgWlJhY1vNgdM6ylnHRa-Ew,40784
+pydantic_ai/_output.py,sha256=83Imvnwqwr-zveX_I95E24zt2Iqn-ofpd0HsbvOhS70,41274
 pydantic_ai/_parts_manager.py,sha256=05m8q2JZQk9Z8vNKOocxGDJQwYgbUGABGBRnXYJcsg8,19914
 pydantic_ai/_run_context.py,sha256=-ah9Ipf3mLTbvuYqmJSqBmBexaCcED7HGA1Llzs0dKU,2324
 pydantic_ai/_system_prompt.py,sha256=WdDW_DTGHujcFFaK-J7J6mA4ZDJZ0IOKpyizJA-1Y5Q,1142
@@ -28,7 +28,7 @@ pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/result.py,sha256=sVabgrAJXmj96I7NM-w0RBz1rH5x_zZql1V6epei4JU,26700
 pydantic_ai/retries.py,sha256=QM4oDA9DG-Y2qP06fbCp8Dqq8ups40Rr4HYjAOlbNyM,14650
 pydantic_ai/run.py,sha256=5mOgh7UkLRtCjs1S85NM6OjcWvOy91VQhCkNMQQPhxs,17039
-pydantic_ai/settings.py,sha256=0mr6KudxKKjTG8e3nsv_8vDLxNhu_1-WvefCOzCGSYM,3565
+pydantic_ai/settings.py,sha256=HlQxrw62YsXpIIhhddecYNTquDfhnpfaZU7y1p4CuVs,3935
 pydantic_ai/tools.py,sha256=dCecmJtRkF1ioqFYbfT00XGGqzGB4PPO9n6IrHCQtnc,20343
 pydantic_ai/usage.py,sha256=lhReoVNwqt7mfmWk40A1ddnKk4-MVFJ0qCl_oFdGzxo,16251
 pydantic_ai/agent/__init__.py,sha256=rvVo5Fw78yu5IOVE6ub6tmJTIuDGsIY15D3_KTFXtx4,66525
@@ -75,8 +75,9 @@ pydantic_ai/models/huggingface.py,sha256=iADyoCKYrNyjixr55rEpXW02F-sah4rLmqrThEc
 pydantic_ai/models/instrumented.py,sha256=J8eVTutr3UP1r_wd5sM5c0BIdzkRqT-EGgd2NiF0ssQ,22319
 pydantic_ai/models/mcp_sampling.py,sha256=qY4y4nXbRpNp2QbkfjzWLvF_8KLZGXypz4cc0lYRHXU,3553
 pydantic_ai/models/mistral.py,sha256=fi57hADjYxZw8wEpAcNI6mqY32VG9hHK9GGRQ-9vlZg,33905
-pydantic_ai/models/openai.py,sha256=wQJDGVAPzN5GNzny4ZN0CrnnrPIMxUOXQYfAtK0u7z4,108980
-pydantic_ai/models/test.py,sha256=5ER66nwZG7Iwm-KkzPo4vwNd3rulzgkpgysu4YcT1W4,20568
+pydantic_ai/models/openai.py,sha256=1x2pXZFJfb-LGEweFNzKB77qIOWcVT4hvMEvSwBVVYE,109160
+pydantic_ai/models/outlines.py,sha256=Un4KERT-jW97georXrE3iNuThFiYaYxZjGYHm2-PpD8,24270
+pydantic_ai/models/test.py,sha256=cRiLD1uXKERUkBTyrVj3L5NQHoDrDqL5UU9EG_odkTg,20707
 pydantic_ai/models/wrapper.py,sha256=nwh8Gea59blbr1JDKlUnkYICuI9TUubC4qP7iZRRW28,2440
 pydantic_ai/profiles/__init__.py,sha256=UHknN-CYsQexUaxfsgz_J_uSZ9QwistLSuAErQkvbcM,3385
 pydantic_ai/profiles/amazon.py,sha256=IPa2wydpcbFLLvhDK35-pwwoKo0Pg4vP84823fHx0zc,314
@@ -90,9 +91,9 @@ pydantic_ai/profiles/harmony.py,sha256=HKOQ1QUBd9jLLabO9jMCq97d3pgAzd3Y7c_jiwPFS
 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=MXOsktUqfcF2pBgYJMyFWMZafPJ7tejwyoFM2mjKzaY,9689
+pydantic_ai/profiles/openai.py,sha256=kve8KnvsGguioNi1gQtO7dqF8vvxR8W21fERehb3GPo,10053
 pydantic_ai/profiles/qwen.py,sha256=9SnTpMKndxNQMFyumyaOczJa5JGWbYQdpVKKW4OzKjk,749
-pydantic_ai/providers/__init__.py,sha256=UMgxQqav_-nxZw7oA5pUAlNJV694HwTtvMrv8WgELfI,4872
+pydantic_ai/providers/__init__.py,sha256=Fwpu0w2-NpkKYQkDS2__kaWOR3dMW2KiE9v0K1EKwP4,4985
 pydantic_ai/providers/anthropic.py,sha256=vwNjO2JJ0Ux_3PXI9_XvzNZ24PKessm8z2ja1uzbBwM,3327
 pydantic_ai/providers/azure.py,sha256=PFRykTOfARMdANODnTLq__0ZynX7DlQ35GVf2Qs9VBY,5814
 pydantic_ai/providers/bedrock.py,sha256=bPbz-o3UhDzCRrg5xCrTfluLpDi2Yy9-JiCtC5mCIRk,8539
@@ -116,6 +117,7 @@ pydantic_ai/providers/nebius.py,sha256=nGpgbZnBZgNz4wHTi1vgvc-9tO2_zj5r3vRzEUbhP
 pydantic_ai/providers/ollama.py,sha256=jg48g_3fYsvK8g-V3UOmR9HOsvnvb533BAB-rZZDxdA,4733
 pydantic_ai/providers/openai.py,sha256=cVVf99GgBnYBKYeWKBscvnkoRCu0ctWuKulG19lgWMo,3401
 pydantic_ai/providers/openrouter.py,sha256=o33Fk7kMyMhEM4NcSXU6IuG0cIUc45ySaenozrRypBI,4145
+pydantic_ai/providers/outlines.py,sha256=9Y3bnRKooqeUIVquexf75oGWpj8XOpJ71tBMWp0mTMQ,1251
 pydantic_ai/providers/ovhcloud.py,sha256=qvPB7-hgeClBMeNSKOiTrF-pSp6RczRaqWg5iAeUwss,3428
 pydantic_ai/providers/together.py,sha256=QtIR1BVJjoEYLvsUFpvPe81akx0iQvjYptl87XVpCpo,3441
 pydantic_ai/providers/vercel.py,sha256=AdaRmTejcr4CLPY2X0D3iZ0T4xPdUm4HAXXLS0Q0jMA,4248
@@ -125,14 +127,15 @@ pydantic_ai/toolsets/abstract.py,sha256=CXsDF37JkBWcy9hwrgdBe4gqgocNcPKOFEIvQ7t9
 pydantic_ai/toolsets/approval_required.py,sha256=zyYGEx2VqprLed16OXg1QWr81rnAB0CmAzTeyQJ9A4o,1100
 pydantic_ai/toolsets/combined.py,sha256=LQzm_g6gskiHRUMFDvm88SSrz8OGxbdxyHiKzQrMBNU,4026
 pydantic_ai/toolsets/external.py,sha256=J9mWQm1HLbRCOJwpLBIvUZZGR_ywSB7pz8MrXkRNBoU,1736
+pydantic_ai/toolsets/fastmcp.py,sha256=txkWP0JfF8QXBfn7n6YGiDa01KC6nkQuCrq8TcgMLjc,7202
 pydantic_ai/toolsets/filtered.py,sha256=PSQG9EbBYJpHUEBb_4TGzhjAcQPo5aPKvTuReeoWYtQ,864
 pydantic_ai/toolsets/function.py,sha256=7QNKUddsSehwtM1kC13fVPkswzh2qa63p5wqIgrUFKk,16819
 pydantic_ai/toolsets/prefixed.py,sha256=0KwcDkW8OM36ZUsOLVP5h-Nj2tPq78L3_E2c-1Fbh5s,1426
 pydantic_ai/toolsets/prepared.py,sha256=Zjfz6S8In6PBVxoKFN9sKPN984zO6t0awB7Lnq5KODw,1431
 pydantic_ai/toolsets/renamed.py,sha256=JuLHpi-hYPiSPlaTpN8WiXLiGsywYK0axi2lW2Qs75k,1637
 pydantic_ai/toolsets/wrapper.py,sha256=KRzF1p8dncHbva8CE6Ud-IC5E_aygIHlwH5atXK55k4,1673
-pydantic_ai_slim-1.5.0.dist-info/METADATA,sha256=za8KqhM9ey6DIczK7Q5VaVYGT0BcmNJBc0RSJoZQ5P4,4703
-pydantic_ai_slim-1.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-1.5.0.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
-pydantic_ai_slim-1.5.0.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
-pydantic_ai_slim-1.5.0.dist-info/RECORD,,
+pydantic_ai_slim-1.7.0.dist-info/METADATA,sha256=GxDZ2iV6RaVqJckEQSAT4GhQcvyLisSlydAsM1CdKNQ,5592
+pydantic_ai_slim-1.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-1.7.0.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
+pydantic_ai_slim-1.7.0.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_slim-1.7.0.dist-info/RECORD,,