pydantic-ai-slim 0.0.47__tar.gz → 0.0.48__tar.gz

{pydantic_ai_slim-0.0.47 → pydantic_ai_slim-0.0.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.47
+Version: 0.0.48
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -29,7 +29,7 @@ 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.0.47
+Requires-Dist: pydantic-graph==0.0.48
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: anthropic
@@ -45,7 +45,7 @@ Requires-Dist: cohere>=5.13.11; (platform_system != 'Emscripten') and extra == '
 Provides-Extra: duckduckgo
 Requires-Dist: duckduckgo-search>=7.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.0.41; extra == 'evals'
+Requires-Dist: pydantic-evals==0.0.48; extra == 'evals'
 Provides-Extra: groq
 Requires-Dist: groq>=0.15.0; extra == 'groq'
 Provides-Extra: logfire

{pydantic_ai_slim-0.0.47 → pydantic_ai_slim-0.0.48}/pydantic_ai/_result.py

@@ -13,7 +13,7 @@ from typing_inspection.introspection import is_union_origin
 from . import _utils, messages as _messages
 from .exceptions import ModelRetry
 from .result import ResultDataT, ResultDataT_inv, ResultValidatorFunc
-from .tools import AgentDepsT, RunContext, ToolDefinition
+from .tools import AgentDepsT, GenerateToolJsonSchema, RunContext, ToolDefinition
 
 T = TypeVar('T')
 """An invariant TypeVar."""
@@ -159,7 +159,9 @@ class ResultTool(Generic[ResultDataT]):
             self.type_adapter = TypeAdapter(response_type)
             outer_typed_dict_key: str | None = None
             # noinspection PyArgumentList
-            parameters_json_schema = _utils.check_object_json_schema(self.type_adapter.json_schema())
+            parameters_json_schema = _utils.check_object_json_schema(
+                self.type_adapter.json_schema(schema_generator=GenerateToolJsonSchema)
+            )
         else:
             response_data_typed_dict = TypedDict(  # noqa: UP013
                 'response_data_typed_dict',
@@ -168,7 +170,9 @@ class ResultTool(Generic[ResultDataT]):
             self.type_adapter = TypeAdapter(response_data_typed_dict)
             outer_typed_dict_key = 'response'
             # noinspection PyArgumentList
-            parameters_json_schema = _utils.check_object_json_schema(self.type_adapter.json_schema())
+            parameters_json_schema = _utils.check_object_json_schema(
+                self.type_adapter.json_schema(schema_generator=GenerateToolJsonSchema)
+            )
             # including `response_data_typed_dict` as a title here doesn't add anything and could confuse the LLM
             parameters_json_schema.pop('title')
 

{pydantic_ai_slim-0.0.47 → pydantic_ai_slim-0.0.48}/pydantic_ai/models/openai.py

@@ -1,12 +1,15 @@
 from __future__ import annotations as _annotations
 
 import base64
+import warnings
 from collections.abc import AsyncIterable, AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from typing import Literal, Union, cast, overload
 
+from openai import NotGiven
+from openai.types import Reasoning
 from typing_extensions import assert_never
 
 from pydantic_ai.providers import Provider, infer_provider
@@ -42,7 +45,7 @@ from . import (
 
 try:
     from openai import NOT_GIVEN, APIStatusError, AsyncOpenAI, AsyncStream
-    from openai.types import ChatModel, chat
+    from openai.types import ChatModel, chat, responses
     from openai.types.chat import (
         ChatCompletionChunk,
         ChatCompletionContentPartImageParam,
@@ -52,6 +55,9 @@ try:
     )
     from openai.types.chat.chat_completion_content_part_image_param import ImageURL
     from openai.types.chat.chat_completion_content_part_input_audio_param import InputAudio
+    from openai.types.responses.response_input_param import FunctionCallOutput, Message
+    from openai.types.shared import ReasoningEffort
+    from openai.types.shared_params import Reasoning
 except ImportError as _import_error:
     raise ImportError(
         'Please install `openai` to use the OpenAI model, '
@@ -79,9 +85,10 @@ class OpenAIModelSettings(ModelSettings, total=False):
     ALL FIELDS MUST BE `openai_` PREFIXED SO YOU CAN MERGE THEM WITH OTHER MODELS.
     """
 
-    openai_reasoning_effort: chat.ChatCompletionReasoningEffort
+    openai_reasoning_effort: ReasoningEffort
     """
     Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning).
+
     Currently supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
     result in faster responses and fewer tokens used on reasoning in a response.
     """
@@ -178,8 +185,7 @@ class OpenAIModel(Model):
         stream: Literal[True],
         model_settings: OpenAIModelSettings,
         model_request_parameters: ModelRequestParameters,
-    ) -> AsyncStream[ChatCompletionChunk]:
-        pass
+    ) -> AsyncStream[ChatCompletionChunk]: ...
 
     @overload
     async def _completions_create(
@@ -188,8 +194,7 @@ class OpenAIModel(Model):
         stream: Literal[False],
         model_settings: OpenAIModelSettings,
         model_request_parameters: ModelRequestParameters,
-    ) -> chat.ChatCompletion:
-        pass
+    ) -> chat.ChatCompletion: ...
 
     async def _completions_create(
         self,
@@ -248,7 +253,7 @@ class OpenAIModel(Model):
             items.append(TextPart(choice.message.content))
         if choice.message.tool_calls is not None:
             for c in choice.message.tool_calls:
-                items.append(ToolCallPart(c.function.name, c.function.arguments, c.id))
+                items.append(ToolCallPart(c.function.name, c.function.arguments, tool_call_id=c.id))
         return ModelResponse(items, model_name=response.model, timestamp=timestamp)
 
     async def _process_streamed_response(self, response: AsyncStream[ChatCompletionChunk]) -> OpenAIStreamedResponse:
@@ -399,6 +404,311 @@ class OpenAIModel(Model):
         return chat.ChatCompletionUserMessageParam(role='user', content=content)
 
 
+@dataclass(init=False)
+class OpenAIResponsesModel(Model):
+    """A model that uses the OpenAI Responses API.
+
+    The [OpenAI Responses API](https://platform.openai.com/docs/api-reference/responses) is the
+    new API for OpenAI models.
+
+    The Responses API has built-in tools, that you can use instead of building your own:
+
+    - [Web search](https://platform.openai.com/docs/guides/tools-web-search)
+    - [File search](https://platform.openai.com/docs/guides/tools-file-search)
+    - [Computer use](https://platform.openai.com/docs/guides/tools-computer-use)
+
+    If you are interested in the differences between the Responses API and the Chat Completions API,
+    see the [OpenAI API docs](https://platform.openai.com/docs/guides/responses-vs-chat-completions).
+    """
+
+    client: AsyncOpenAI = field(repr=False)
+    system_prompt_role: OpenAISystemPromptRole | None = field(default=None)
+
+    _model_name: OpenAIModelName = field(repr=False)
+    _system: str = field(default='openai', repr=False)
+
+    def __init__(
+        self,
+        model_name: OpenAIModelName,
+        *,
+        provider: Literal['openai', 'deepseek', 'azure'] | Provider[AsyncOpenAI] = 'openai',
+    ):
+        """Initialize an OpenAI Responses model.
+
+        Args:
+            model_name: The name of the OpenAI model to use.
+            provider: The provider to use. Defaults to `'openai'`.
+        """
+        self._model_name = model_name
+        if isinstance(provider, str):
+            provider = infer_provider(provider)
+        self.client = provider.client
+
+    @property
+    def model_name(self) -> OpenAIModelName:
+        """The model name."""
+        return self._model_name
+
+    @property
+    def system(self) -> str:
+        """The system / model provider."""
+        return self._system
+
+    async def request(
+        self,
+        messages: list[ModelRequest | ModelResponse],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> tuple[ModelResponse, usage.Usage]:
+        check_allow_model_requests()
+        response = await self._responses_create(
+            messages, False, cast(OpenAIModelSettings, model_settings or {}), model_request_parameters
+        )
+        return self._process_response(response), _map_usage(response)
+
+    @asynccontextmanager
+    async def request_stream(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> AsyncIterator[StreamedResponse]:
+        check_allow_model_requests()
+        response = await self._responses_create(
+            messages, True, cast(OpenAIModelSettings, model_settings or {}), model_request_parameters
+        )
+        async with response:
+            yield await self._process_streamed_response(response)
+
+    def _process_response(self, response: responses.Response) -> ModelResponse:
+        """Process a non-streamed response, and prepare a message to return."""
+        timestamp = datetime.fromtimestamp(response.created_at, tz=timezone.utc)
+        items: list[ModelResponsePart] = []
+        items.append(TextPart(response.output_text))
+        for item in response.output:
+            if item.type == 'function_call':
+                items.append(ToolCallPart(item.name, item.arguments, tool_call_id=item.call_id))
+        return ModelResponse(items, model_name=response.model, timestamp=timestamp)
+
+    async def _process_streamed_response(
+        self, response: AsyncStream[responses.ResponseStreamEvent]
+    ) -> OpenAIResponsesStreamedResponse:
+        """Process a streamed response, and prepare a streaming response to return."""
+        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')
+
+        assert isinstance(first_chunk, responses.ResponseCreatedEvent)
+        return OpenAIResponsesStreamedResponse(
+            _model_name=self._model_name,
+            _response=peekable_response,
+            _timestamp=datetime.fromtimestamp(first_chunk.response.created_at, tz=timezone.utc),
+        )
+
+    @overload
+    async def _responses_create(
+        self,
+        messages: list[ModelRequest | ModelResponse],
+        stream: Literal[False],
+        model_settings: OpenAIModelSettings,
+        model_request_parameters: ModelRequestParameters,
+    ) -> responses.Response: ...
+
+    @overload
+    async def _responses_create(
+        self,
+        messages: list[ModelRequest | ModelResponse],
+        stream: Literal[True],
+        model_settings: OpenAIModelSettings,
+        model_request_parameters: ModelRequestParameters,
+    ) -> AsyncStream[responses.ResponseStreamEvent]: ...
+
+    async def _responses_create(
+        self,
+        messages: list[ModelRequest | ModelResponse],
+        stream: bool,
+        model_settings: OpenAIModelSettings,
+        model_request_parameters: ModelRequestParameters,
+    ) -> responses.Response | AsyncStream[responses.ResponseStreamEvent]:
+        tools = self._get_tools(model_request_parameters)
+
+        # standalone function to make it easier to override
+        if not tools:
+            tool_choice: Literal['none', 'required', 'auto'] | None = None
+        elif not model_request_parameters.allow_text_result:
+            tool_choice = 'required'
+        else:
+            tool_choice = 'auto'
+
+        system_prompt, openai_messages = await self._map_message(messages)
+
+        reasoning_effort = model_settings.get('openai_reasoning_effort', NOT_GIVEN)
+        if not isinstance(reasoning_effort, NotGiven):
+            reasoning = Reasoning(effort=reasoning_effort)
+        else:
+            reasoning = NOT_GIVEN
+
+        try:
+            return await self.client.responses.create(
+                input=openai_messages,
+                model=self._model_name,
+                instructions=system_prompt,
+                parallel_tool_calls=model_settings.get('parallel_tool_calls', NOT_GIVEN),
+                tools=tools or NOT_GIVEN,
+                tool_choice=tool_choice or NOT_GIVEN,
+                max_output_tokens=model_settings.get('max_tokens', NOT_GIVEN),
+                stream=stream,
+                temperature=model_settings.get('temperature', NOT_GIVEN),
+                top_p=model_settings.get('top_p', NOT_GIVEN),
+                timeout=model_settings.get('timeout', NOT_GIVEN),
+                reasoning=reasoning,
+                user=model_settings.get('user', NOT_GIVEN),
+            )
+        except APIStatusError as e:
+            if (status_code := e.status_code) >= 400:
+                raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=e.body) from e
+            raise
+
+    def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[responses.FunctionToolParam]:
+        tools = [self._map_tool_definition(r) for r in model_request_parameters.function_tools]
+        if model_request_parameters.result_tools:
+            tools += [self._map_tool_definition(r) for r in model_request_parameters.result_tools]
+        return tools
+
+    @staticmethod
+    def _map_tool_definition(f: ToolDefinition) -> responses.FunctionToolParam:
+        return {
+            'name': f.name,
+            'parameters': f.parameters_json_schema,
+            'type': 'function',
+            'description': f.description,
+            'strict': True,
+        }
+
+    async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[responses.ResponseInputItemParam]]:
+        """Just maps a `pydantic_ai.Message` to a `openai.types.responses.ResponseInputParam`."""
+        system_prompt: str = ''
+        openai_messages: list[responses.ResponseInputItemParam] = []
+        for message in messages:
+            if isinstance(message, ModelRequest):
+                for part in message.parts:
+                    if isinstance(part, SystemPromptPart):
+                        system_prompt += part.content
+                    elif isinstance(part, UserPromptPart):
+                        openai_messages.append(await self._map_user_prompt(part))
+                    elif isinstance(part, ToolReturnPart):
+                        openai_messages.append(
+                            FunctionCallOutput(
+                                type='function_call_output',
+                                call_id=_guard_tool_call_id(t=part),
+                                output=part.model_response_str(),
+                            )
+                        )
+                    elif isinstance(part, RetryPromptPart):
+                        # TODO(Marcelo): How do we test this conditional branch?
+                        if part.tool_name is None:  # pragma: no cover
+                            openai_messages.append(
+                                Message(role='user', content=[{'type': 'input_text', 'text': part.model_response()}])
+                            )
+                        else:
+                            openai_messages.append(
+                                FunctionCallOutput(
+                                    type='function_call_output',
+                                    call_id=_guard_tool_call_id(t=part),
+                                    output=part.model_response(),
+                                )
+                            )
+                    else:
+                        assert_never(part)
+            elif isinstance(message, ModelResponse):
+                for item in message.parts:
+                    if isinstance(item, TextPart):
+                        openai_messages.append(responses.EasyInputMessageParam(role='assistant', content=item.content))
+                    elif isinstance(item, ToolCallPart):
+                        openai_messages.append(self._map_tool_call(item))
+                    else:
+                        assert_never(item)
+            else:
+                assert_never(message)
+        return system_prompt, openai_messages
+
+    @staticmethod
+    def _map_tool_call(t: ToolCallPart) -> responses.ResponseFunctionToolCallParam:
+        return responses.ResponseFunctionToolCallParam(
+            arguments=t.args_as_json_str(),
+            call_id=_guard_tool_call_id(t=t),
+            name=t.tool_name,
+            type='function_call',
+        )
+
+    @staticmethod
+    async def _map_user_prompt(part: UserPromptPart) -> responses.EasyInputMessageParam:
+        content: str | list[responses.ResponseInputContentParam]
+        if isinstance(part.content, str):
+            content = part.content
+        else:
+            content = []
+            for item in part.content:
+                if isinstance(item, str):
+                    content.append(responses.ResponseInputTextParam(text=item, type='input_text'))
+                elif isinstance(item, BinaryContent):
+                    base64_encoded = base64.b64encode(item.data).decode('utf-8')
+                    if item.is_image:
+                        content.append(
+                            responses.ResponseInputImageParam(
+                                image_url=f'data:{item.media_type};base64,{base64_encoded}',
+                                type='input_image',
+                                detail='auto',
+                            )
+                        )
+                    elif item.is_document:
+                        content.append(
+                            responses.ResponseInputFileParam(
+                                type='input_file',
+                                file_data=f'data:{item.media_type};base64,{base64_encoded}',
+                                # NOTE: Type wise it's not necessary to include the filename, but it's required by the
+                                # API itself. If we add empty string, the server sends a 500 error - which OpenAI needs
+                                # to fix. In any case, we add a placeholder name.
+                                filename=f'filename.{item.format}',
+                            )
+                        )
+                    elif item.is_audio:
+                        raise NotImplementedError('Audio as binary content is not supported for OpenAI Responses API.')
+                    else:  # pragma: no cover
+                        raise RuntimeError(f'Unsupported binary content type: {item.media_type}')
+                elif isinstance(item, ImageUrl):
+                    content.append(
+                        responses.ResponseInputImageParam(image_url=item.url, type='input_image', detail='auto')
+                    )
+                elif isinstance(item, AudioUrl):  # pragma: no cover
+                    client = cached_async_http_client()
+                    response = await client.get(item.url)
+                    response.raise_for_status()
+                    base64_encoded = base64.b64encode(response.content).decode('utf-8')
+                    content.append(
+                        responses.ResponseInputFileParam(
+                            type='input_file',
+                            file_data=f'data:{item.media_type};base64,{base64_encoded}',
+                        )
+                    )
+                elif isinstance(item, DocumentUrl):  # pragma: no cover
+                    client = cached_async_http_client()
+                    response = await client.get(item.url)
+                    response.raise_for_status()
+                    base64_encoded = base64.b64encode(response.content).decode('utf-8')
+                    content.append(
+                        responses.ResponseInputFileParam(
+                            type='input_file',
+                            file_data=f'data:{item.media_type};base64,{base64_encoded}',
+                            filename=f'filename.{item.format}',
+                        )
+                    )
+                else:
+                    assert_never(item)
+        return responses.EasyInputMessageParam(role='user', content=content)
+
+
 @dataclass
 class OpenAIStreamedResponse(StreamedResponse):
     """Implementation of `StreamedResponse` for OpenAI models."""
@@ -442,10 +752,101 @@ class OpenAIStreamedResponse(StreamedResponse):
         return self._timestamp
 
 
-def _map_usage(response: chat.ChatCompletion | ChatCompletionChunk) -> usage.Usage:
+@dataclass
+class OpenAIResponsesStreamedResponse(StreamedResponse):
+    """Implementation of `StreamedResponse` for OpenAI Responses API."""
+
+    _model_name: OpenAIModelName
+    _response: AsyncIterable[responses.ResponseStreamEvent]
+    _timestamp: datetime
+
+    async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:  # noqa: C901
+        async for chunk in self._response:
+            if isinstance(chunk, responses.ResponseCompletedEvent):
+                self._usage += _map_usage(chunk.response)
+
+            elif isinstance(chunk, responses.ResponseContentPartAddedEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseContentPartDoneEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseCreatedEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseFailedEvent):  # pragma: no cover
+                self._usage += _map_usage(chunk.response)
+
+            elif isinstance(chunk, responses.ResponseFunctionCallArgumentsDeltaEvent):
+                maybe_event = self._parts_manager.handle_tool_call_delta(
+                    vendor_part_id=chunk.item_id,
+                    tool_name=None,
+                    args=chunk.delta,
+                    tool_call_id=chunk.item_id,
+                )
+                if maybe_event is not None:
+                    yield maybe_event
+
+            elif isinstance(chunk, responses.ResponseFunctionCallArgumentsDoneEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseIncompleteEvent):  # pragma: no cover
+                self._usage += _map_usage(chunk.response)
+
+            elif isinstance(chunk, responses.ResponseInProgressEvent):
+                self._usage += _map_usage(chunk.response)
+
+            elif isinstance(chunk, responses.ResponseOutputItemAddedEvent):
+                if isinstance(chunk.item, responses.ResponseFunctionToolCall):
+                    yield self._parts_manager.handle_tool_call_part(
+                        vendor_part_id=chunk.item.id,
+                        tool_name=chunk.item.name,
+                        args=chunk.item.arguments,
+                        tool_call_id=chunk.item.id,
+                    )
+
+            elif isinstance(chunk, responses.ResponseOutputItemDoneEvent):
+                # NOTE: We only need this if the tool call deltas don't include the final info.
+                pass
+
+            elif isinstance(chunk, responses.ResponseTextDeltaEvent):
+                yield self._parts_manager.handle_text_delta(vendor_part_id=chunk.content_index, content=chunk.delta)
+
+            elif isinstance(chunk, responses.ResponseTextDoneEvent):
+                pass  # there's nothing we need to do here
+
+            else:  # pragma: no cover
+                warnings.warn(
+                    f'Handling of this event type is not yet implemented. Please report on our GitHub: {chunk}',
+                    UserWarning,
+                )
+
+    @property
+    def model_name(self) -> OpenAIModelName:
+        """Get the model name of the response."""
+        return self._model_name
+
+    @property
+    def timestamp(self) -> datetime:
+        """Get the timestamp of the response."""
+        return self._timestamp
+
+
+def _map_usage(response: chat.ChatCompletion | ChatCompletionChunk | responses.Response) -> usage.Usage:
     response_usage = response.usage
     if response_usage is None:
         return usage.Usage()
+    elif isinstance(response_usage, responses.ResponseUsage):
+        details: dict[str, int] = {}
+        return usage.Usage(
+            request_tokens=response_usage.input_tokens,
+            response_tokens=response_usage.output_tokens,
+            total_tokens=response_usage.total_tokens,
+            details={
+                'reasoning_tokens': response_usage.output_tokens_details.reasoning_tokens,
+                'cached_tokens': response_usage.input_tokens_details.cached_tokens,
+            },
+        )
     else:
         details: dict[str, int] = {}
         if response_usage.completion_tokens_details is not None:

{pydantic_ai_slim-0.0.47 → pydantic_ai_slim-0.0.48}/pydantic_ai/tools.py

@@ -149,8 +149,8 @@ class GenerateToolJsonSchema(GenerateJsonSchema):
     def typed_dict_schema(self, schema: core_schema.TypedDictSchema) -> JsonSchemaValue:
         s = super().typed_dict_schema(schema)
         total = schema.get('total')
-        if total is not None:
-            s['additionalProperties'] = not total
+        if 'additionalProperties' not in s and (total is True or total is None):
+            s['additionalProperties'] = False
         return s
 
     def _named_required_fields_schema(self, named_required_fields: Sequence[tuple[str, bool, Any]]) -> JsonSchemaValue:

{pydantic_ai_slim-0.0.47 → pydantic_ai_slim-0.0.48}/pyproject.toml

@@ -12,7 +12,7 @@ bump = true
 
 [project]
 name = "pydantic-ai-slim"
-dynamic = ["version", "dependencies"]
+dynamic = ["version", "dependencies", "optional-dependencies"]
 description = "Agent Framework / shim to use Pydantic with LLMs, slim package"
 authors = [{ name = "Samuel Colvin", email = "samuel@pydantic.dev" }]
 license = "MIT"
@@ -52,7 +52,7 @@ dependencies = [
     "typing-inspection>=0.4.0",
 ]
 
-[project.optional-dependencies]
+[tool.hatch.metadata.hooks.uv-dynamic-versioning.optional-dependencies]
 # WARNING if you add optional groups, please update docs/install.md
 logfire = ["logfire>=3.11.0"]
 # Models
@@ -71,7 +71,7 @@ cli = ["rich>=13", "prompt-toolkit>=3", "argcomplete>=3.5.0"]
 # MCP
 mcp = ["mcp>=1.4.1; python_version >= '3.10'"]
 # Evals
-evals = ["pydantic-evals==0.0.41"]
+evals = ["pydantic-evals=={{ version }}"]
 
 [dependency-groups]
 dev = [