pydantic-ai-slim 0.0.52__tar.gz → 0.0.54__tar.gz

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.54}/.gitignore

@@ -16,3 +16,4 @@ examples/pydantic_ai_examples/.chat_app_messages.sqlite
 /question_graph_history.json
 /docs-site/.wrangler/
 /CLAUDE.md
+node_modules/

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.52
+Version: 0.0.54
 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.52
+Requires-Dist: pydantic-graph==0.0.54
 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.52; extra == 'evals'
+Requires-Dist: pydantic-evals==0.0.54; extra == 'evals'
 Provides-Extra: groq
 Requires-Dist: groq>=0.15.0; extra == 'groq'
 Provides-Extra: logfire

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.54}/pydantic_ai/_agent_graph.py

@@ -79,7 +79,7 @@ class GraphAgentDeps(Generic[DepsT, ResultDataT]):
 
     user_deps: DepsT
 
-    prompt: str | Sequence[_messages.UserContent]
+    prompt: str | Sequence[_messages.UserContent] | None
     new_message_index: int
 
     model: models.Model
@@ -124,7 +124,7 @@ def is_agent_node(
 
 @dataclasses.dataclass
 class UserPromptNode(AgentNode[DepsT, NodeRunEndT]):
-    user_prompt: str | Sequence[_messages.UserContent]
+    user_prompt: str | Sequence[_messages.UserContent] | None
 
     system_prompts: tuple[str, ...]
     system_prompt_functions: list[_system_prompt.SystemPromptRunner[DepsT]]
@@ -151,7 +151,7 @@ class UserPromptNode(AgentNode[DepsT, NodeRunEndT]):
 
     async def _prepare_messages(
         self,
-        user_prompt: str | Sequence[_messages.UserContent],
+        user_prompt: str | Sequence[_messages.UserContent] | None,
         message_history: list[_messages.ModelMessage] | None,
         run_context: RunContext[DepsT],
     ) -> tuple[list[_messages.ModelMessage], _messages.ModelRequest]:
@@ -166,16 +166,18 @@ class UserPromptNode(AgentNode[DepsT, NodeRunEndT]):
                 messages = ctx_messages.messages
                 ctx_messages.used = True
 
+        parts: list[_messages.ModelRequestPart] = []
         if message_history:
             # Shallow copy messages
             messages.extend(message_history)
             # Reevaluate any dynamic system prompt parts
             await self._reevaluate_dynamic_prompts(messages, run_context)
-            return messages, _messages.ModelRequest([_messages.UserPromptPart(user_prompt)])
         else:
-            parts = await self._sys_parts(run_context)
+            parts.extend(await self._sys_parts(run_context))
+
+        if user_prompt is not None:
             parts.append(_messages.UserPromptPart(user_prompt))
-            return messages, _messages.ModelRequest(parts)
+        return messages, _messages.ModelRequest(parts)
 
     async def _reevaluate_dynamic_prompts(
         self, messages: list[_messages.ModelMessage], run_context: RunContext[DepsT]
@@ -311,6 +313,7 @@ class ModelRequestNode(AgentNode[DepsT, NodeRunEndT]):
             return self._result
 
         model_settings, model_request_parameters = await self._prepare_request(ctx)
+        model_request_parameters = ctx.deps.model.customize_request_parameters(model_request_parameters)
         model_response, request_usage = await ctx.deps.model.request(
             ctx.state.message_history, model_settings, model_request_parameters
         )

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.54}/pydantic_ai/_cli.py

@@ -15,7 +15,7 @@ from typing_inspection.introspection import get_literal_values
 
 from pydantic_ai.agent import Agent
 from pydantic_ai.exceptions import UserError
-from pydantic_ai.messages import ModelMessage, PartDeltaEvent, TextPartDelta
+from pydantic_ai.messages import ModelMessage
 from pydantic_ai.models import KnownModelName, infer_model
 
 try:
@@ -222,10 +222,8 @@ async def ask_agent(
                         status.stop()  # stopping multiple times is idempotent
                         stack.enter_context(live)  # entering multiple times is idempotent
 
-                        async for event in handle_stream:
-                            if isinstance(event, PartDeltaEvent) and isinstance(event.delta, TextPartDelta):
-                                content += event.delta.content_delta
-                                live.update(Markdown(content, code_theme=code_theme))
+                        async for content in handle_stream.stream_output():
+                            live.update(Markdown(content, code_theme=code_theme))
 
         assert agent_run.result is not None
         return agent_run.result.all_messages()

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.54}/pydantic_ai/_utils.py

@@ -50,7 +50,11 @@ def check_object_json_schema(schema: JsonSchemaValue) -> ObjectJsonSchema:
     if schema.get('type') == 'object':
         return schema
     elif schema.get('$ref') is not None:
-        return schema.get('$defs', {}).get(schema['$ref'][8:])  # This removes the initial "#/$defs/".
+        maybe_result = schema.get('$defs', {}).get(schema['$ref'][8:])  # This removes the initial "#/$defs/".
+
+        if "'$ref': '#/$defs/" in str(maybe_result):
+            return schema  # We can't remove the $defs because the schema contains other references
+        return maybe_result
     else:
         raise UserError('Schema must be an object')
 

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.54}/pydantic_ai/agent.py

@@ -242,7 +242,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
     @overload
     async def run(
         self,
-        user_prompt: str | Sequence[_messages.UserContent],
+        user_prompt: str | Sequence[_messages.UserContent] | None = None,
         *,
         result_type: None = None,
         message_history: list[_messages.ModelMessage] | None = None,
@@ -257,7 +257,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
     @overload
     async def run(
         self,
-        user_prompt: str | Sequence[_messages.UserContent],
+        user_prompt: str | Sequence[_messages.UserContent] | None = None,
         *,
         result_type: type[RunResultDataT],
         message_history: list[_messages.ModelMessage] | None = None,
@@ -271,7 +271,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
 
     async def run(
         self,
-        user_prompt: str | Sequence[_messages.UserContent],
+        user_prompt: str | Sequence[_messages.UserContent] | None = None,
         *,
         result_type: type[RunResultDataT] | None = None,
         message_history: list[_messages.ModelMessage] | None = None,
@@ -335,7 +335,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
     @asynccontextmanager
     async def iter(
         self,
-        user_prompt: str | Sequence[_messages.UserContent],
+        user_prompt: str | Sequence[_messages.UserContent] | None = None,
         *,
         result_type: type[RunResultDataT] | None = None,
         message_history: list[_messages.ModelMessage] | None = None,
@@ -372,6 +372,12 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
             print(nodes)
             '''
             [
+                UserPromptNode(
+                    user_prompt='What is the capital of France?',
+                    system_prompts=(),
+                    system_prompt_functions=[],
+                    system_prompt_dynamic_functions={},
+                ),
                 ModelRequestNode(
                     request=ModelRequest(
                         parts=[
@@ -497,7 +503,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
     @overload
     def run_sync(
         self,
-        user_prompt: str | Sequence[_messages.UserContent],
+        user_prompt: str | Sequence[_messages.UserContent] | None = None,
         *,
         message_history: list[_messages.ModelMessage] | None = None,
         model: models.Model | models.KnownModelName | str | None = None,
@@ -511,7 +517,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
     @overload
     def run_sync(
         self,
-        user_prompt: str | Sequence[_messages.UserContent],
+        user_prompt: str | Sequence[_messages.UserContent] | None = None,
         *,
         result_type: type[RunResultDataT] | None,
         message_history: list[_messages.ModelMessage] | None = None,
@@ -525,7 +531,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
 
     def run_sync(
         self,
-        user_prompt: str | Sequence[_messages.UserContent],
+        user_prompt: str | Sequence[_messages.UserContent] | None = None,
         *,
         result_type: type[RunResultDataT] | None = None,
         message_history: list[_messages.ModelMessage] | None = None,
@@ -940,6 +946,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         docstring_format: DocstringFormat = 'auto',
         require_parameter_descriptions: bool = False,
         schema_generator: type[GenerateJsonSchema] = GenerateToolJsonSchema,
+        strict: bool | None = None,
     ) -> Callable[[ToolFuncContext[AgentDepsT, ToolParams]], ToolFuncContext[AgentDepsT, ToolParams]]: ...
 
     def tool(
@@ -953,6 +960,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         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.
 
@@ -995,6 +1003,8 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
                 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.
         """
         if func is None:
 
@@ -1011,6 +1021,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
                     docstring_format,
                     require_parameter_descriptions,
                     schema_generator,
+                    strict,
                 )
                 return func_
 
@@ -1018,7 +1029,15 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         else:
             # noinspection PyTypeChecker
             self._register_function(
-                func, True, name, retries, prepare, docstring_format, require_parameter_descriptions, schema_generator
+                func,
+                True,
+                name,
+                retries,
+                prepare,
+                docstring_format,
+                require_parameter_descriptions,
+                schema_generator,
+                strict,
             )
             return func
 
@@ -1036,6 +1055,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         docstring_format: DocstringFormat = 'auto',
         require_parameter_descriptions: bool = False,
         schema_generator: type[GenerateJsonSchema] = GenerateToolJsonSchema,
+        strict: bool | None = None,
     ) -> Callable[[ToolFuncPlain[ToolParams]], ToolFuncPlain[ToolParams]]: ...
 
     def tool_plain(
@@ -1049,6 +1069,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         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 DOES NOT take `RunContext` as an argument.
 
@@ -1091,6 +1112,8 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
                 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.
         """
         if func is None:
 
@@ -1105,13 +1128,22 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
                     docstring_format,
                     require_parameter_descriptions,
                     schema_generator,
+                    strict,
                 )
                 return func_
 
             return tool_decorator
         else:
             self._register_function(
-                func, False, name, retries, prepare, docstring_format, require_parameter_descriptions, schema_generator
+                func,
+                False,
+                name,
+                retries,
+                prepare,
+                docstring_format,
+                require_parameter_descriptions,
+                schema_generator,
+                strict,
             )
             return func
 
@@ -1125,6 +1157,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         docstring_format: DocstringFormat,
         require_parameter_descriptions: bool,
         schema_generator: type[GenerateJsonSchema],
+        strict: bool | None,
     ) -> None:
         """Private utility to register a function as a tool."""
         retries_ = retries if retries is not None else self._default_retries
@@ -1137,6 +1170,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
             docstring_format=docstring_format,
             require_parameter_descriptions=require_parameter_descriptions,
             schema_generator=schema_generator,
+            strict=strict,
         )
         self._register_tool(tool)
 
@@ -1327,6 +1361,12 @@ class AgentRun(Generic[AgentDepsT, ResultDataT]):
         print(nodes)
         '''
         [
+            UserPromptNode(
+                user_prompt='What is the capital of France?',
+                system_prompts=(),
+                system_prompt_functions=[],
+                system_prompt_dynamic_functions={},
+            ),
             ModelRequestNode(
                 request=ModelRequest(
                     parts=[

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.54}/pydantic_ai/models/__init__.py

@@ -274,6 +274,15 @@ class Model(ABC):
         # noinspection PyUnreachableCode
         yield  # pragma: no cover
 
+    def customize_request_parameters(self, model_request_parameters: ModelRequestParameters) -> ModelRequestParameters:
+        """Customize the request parameters for the model.
+
+        This method can be overridden by subclasses to modify the request parameters before sending them to the model.
+        In particular, this method can be used to make modifications to the generated tool JSON schemas if necessary
+        for vendor/model-specific reasons.
+        """
+        return model_request_parameters
+
     @property
     @abstractmethod
     def model_name(self) -> str:

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.54}/pydantic_ai/models/anthropic.py

@@ -226,6 +226,7 @@ class AnthropicModel(Model):
                 tools=tools or NOT_GIVEN,
                 tool_choice=tool_choice or NOT_GIVEN,
                 stream=stream,
+                stop_sequences=model_settings.get('stop_sequences', NOT_GIVEN),
                 temperature=model_settings.get('temperature', NOT_GIVEN),
                 top_p=model_settings.get('top_p', NOT_GIVEN),
                 timeout=model_settings.get('timeout', NOT_GIVEN),

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.54}/pydantic_ai/models/bedrock.py

@@ -42,12 +42,14 @@ if TYPE_CHECKING:
     from mypy_boto3_bedrock_runtime.type_defs import (
         ContentBlockOutputTypeDef,
         ContentBlockUnionTypeDef,
+        ConverseRequestTypeDef,
         ConverseResponseTypeDef,
         ConverseStreamMetadataEventTypeDef,
         ConverseStreamOutputTypeDef,
         ImageBlockTypeDef,
         InferenceConfigurationTypeDef,
         MessageUnionTypeDef,
+        SystemContentBlockTypeDef,
         ToolChoiceTypeDef,
         ToolTypeDef,
     )
@@ -258,20 +260,19 @@ class BedrockConverseModel(Model):
         else:
             tool_choice = {'auto': {}}
 
-        system_prompt, bedrock_messages = await self._map_message(messages)
+        system_prompt, bedrock_messages = await self._map_messages(messages)
         inference_config = self._map_inference_config(model_settings)
 
-        params = {
+        params: ConverseRequestTypeDef = {
             'modelId': self.model_name,
             'messages': bedrock_messages,
-            'system': [{'text': system_prompt}],
+            'system': system_prompt,
             'inferenceConfig': inference_config,
-            **(
-                {'toolConfig': {'tools': tools, **({'toolChoice': tool_choice} if tool_choice else {})}}
-                if tools
-                else {}
-            ),
         }
+        if tools:
+            params['toolConfig'] = {'tools': tools}
+            if tool_choice:
+                params['toolConfig']['toolChoice'] = tool_choice
 
         if stream:
             model_response = await anyio.to_thread.run_sync(functools.partial(self.client.converse_stream, **params))
@@ -293,21 +294,22 @@ class BedrockConverseModel(Model):
             inference_config['temperature'] = temperature
         if top_p := model_settings.get('top_p'):
             inference_config['topP'] = top_p
-        # TODO(Marcelo): This is not included in model_settings yet.
-        # if stop_sequences := model_settings.get('stop_sequences'):
-        #     inference_config['stopSequences'] = stop_sequences
+        if stop_sequences := model_settings.get('stop_sequences'):
+            inference_config['stopSequences'] = stop_sequences
 
         return inference_config
 
-    async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[MessageUnionTypeDef]]:
+    async def _map_messages(
+        self, messages: list[ModelMessage]
+    ) -> tuple[list[SystemContentBlockTypeDef], list[MessageUnionTypeDef]]:
         """Just maps a `pydantic_ai.Message` to the Bedrock `MessageUnionTypeDef`."""
-        system_prompt: str = ''
+        system_prompt: list[SystemContentBlockTypeDef] = []
         bedrock_messages: list[MessageUnionTypeDef] = []
         for m in messages:
             if isinstance(m, ModelRequest):
                 for part in m.parts:
                     if isinstance(part, SystemPromptPart):
-                        system_prompt += part.content
+                        system_prompt.append({'text': part.content})
                     elif isinstance(part, UserPromptPart):
                         bedrock_messages.extend(await self._map_user_prompt(part))
                     elif isinstance(part, ToolReturnPart):

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.54}/pydantic_ai/models/cohere.py

@@ -118,7 +118,7 @@ class CohereModel(Model):
                 'cohere' or an instance of `Provider[AsyncClientV2]`. If not provided, a new provider will be
                 created using the other parameters.
         """
-        self._model_name: CohereModelName = model_name
+        self._model_name = model_name
 
         if isinstance(provider, str):
             provider = infer_provider(provider)
@@ -163,6 +163,7 @@ class CohereModel(Model):
                 messages=cohere_messages,
                 tools=tools or OMIT,
                 max_tokens=model_settings.get('max_tokens', OMIT),
+                stop_sequences=model_settings.get('stop_sequences', OMIT),
                 temperature=model_settings.get('temperature', OMIT),
                 p=model_settings.get('top_p', OMIT),
                 seed=model_settings.get('seed', OMIT),

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.54}/pydantic_ai/models/gemini.py

@@ -5,7 +5,7 @@ import re
 from collections.abc import AsyncIterator, Sequence
 from contextlib import asynccontextmanager
 from copy import deepcopy
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from datetime import datetime
 from typing import Annotated, Any, Literal, Protocol, Union, cast
 from uuid import uuid4
@@ -152,6 +152,16 @@ class GeminiModel(Model):
         ) as http_response:
             yield await self._process_streamed_response(http_response)
 
+    def customize_request_parameters(self, model_request_parameters: ModelRequestParameters) -> ModelRequestParameters:
+        def _customize_tool_def(t: ToolDefinition):
+            return replace(t, parameters_json_schema=_GeminiJsonSchema(t.parameters_json_schema).simplify())
+
+        return ModelRequestParameters(
+            function_tools=[_customize_tool_def(tool) for tool in model_request_parameters.function_tools],
+            allow_text_result=model_request_parameters.allow_text_result,
+            result_tools=[_customize_tool_def(tool) for tool in model_request_parameters.result_tools],
+        )
+
     @property
     def model_name(self) -> GeminiModelName:
         """The model name."""
@@ -496,6 +506,7 @@ class _GeminiGenerationConfig(TypedDict, total=False):
     top_p: float
     presence_penalty: float
     frequency_penalty: float
+    stop_sequences: list[str]
 
 
 class _GeminiContent(TypedDict):
@@ -640,7 +651,7 @@ class _GeminiFunction(TypedDict):
 
 
 def _function_from_abstract_tool(tool: ToolDefinition) -> _GeminiFunction:
-    json_schema = _GeminiJsonSchema(tool.parameters_json_schema).simplify()
+    json_schema = tool.parameters_json_schema
     f = _GeminiFunction(name=tool.name, description=tool.description)
     if json_schema.get('properties'):
         f['parameters'] = json_schema

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.54}/pydantic_ai/models/groq.py

@@ -208,6 +208,7 @@ class GroqModel(Model):
                 parallel_tool_calls=model_settings.get('parallel_tool_calls', NOT_GIVEN),
                 tools=tools or NOT_GIVEN,
                 tool_choice=tool_choice or NOT_GIVEN,
+                stop=model_settings.get('stop_sequences', NOT_GIVEN),
                 stream=stream,
                 max_tokens=model_settings.get('max_tokens', NOT_GIVEN),
                 temperature=model_settings.get('temperature', NOT_GIVEN),

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.54}/pydantic_ai/models/mistral.py

@@ -199,6 +199,7 @@ class MistralModel(Model):
                 top_p=model_settings.get('top_p', 1),
                 timeout_ms=self._get_timeout_ms(model_settings.get('timeout')),
                 random_seed=model_settings.get('seed', UNSET),
+                stop=model_settings.get('stop_sequences', None),
             )
         except SDKError as e:
             if (status_code := e.status_code) >= 400:
@@ -236,6 +237,7 @@ class MistralModel(Model):
                 timeout_ms=self._get_timeout_ms(model_settings.get('timeout')),
                 presence_penalty=model_settings.get('presence_penalty'),
                 frequency_penalty=model_settings.get('frequency_penalty'),
+                stop=model_settings.get('stop_sequences', None),
             )
 
         elif model_request_parameters.result_tools:

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.54}/pydantic_ai/models/openai.py

@@ -4,9 +4,9 @@ import base64
 import warnings
 from collections.abc import AsyncIterable, AsyncIterator, Sequence
 from contextlib import asynccontextmanager
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from datetime import datetime, timezone
-from typing import Literal, Union, cast, overload
+from typing import Any, Literal, Union, cast, overload
 
 from typing_extensions import assert_never
 
@@ -150,7 +150,7 @@ class OpenAIModel(Model):
     """
 
     client: AsyncOpenAI = field(repr=False)
-    system_prompt_role: OpenAISystemPromptRole | None = field(default=None)
+    system_prompt_role: OpenAISystemPromptRole | None = field(default=None, repr=False)
 
     _model_name: OpenAIModelName = field(repr=False)
     _system: str = field(default='openai', repr=False)
@@ -208,6 +208,9 @@ class OpenAIModel(Model):
         async with response:
             yield await self._process_streamed_response(response)
 
+    def customize_request_parameters(self, model_request_parameters: ModelRequestParameters) -> ModelRequestParameters:
+        return _customize_request_parameters(model_request_parameters)
+
     @property
     def model_name(self) -> OpenAIModelName:
         """The model name."""
@@ -268,6 +271,7 @@ class OpenAIModel(Model):
                 tool_choice=tool_choice or NOT_GIVEN,
                 stream=stream,
                 stream_options={'include_usage': True} if stream else NOT_GIVEN,
+                stop=model_settings.get('stop_sequences', NOT_GIVEN),
                 max_completion_tokens=model_settings.get('max_tokens', NOT_GIVEN),
                 temperature=model_settings.get('temperature', NOT_GIVEN),
                 top_p=model_settings.get('top_p', NOT_GIVEN),
@@ -351,7 +355,7 @@ class OpenAIModel(Model):
 
     @staticmethod
     def _map_tool_definition(f: ToolDefinition) -> chat.ChatCompletionToolParam:
-        return {
+        tool_param: chat.ChatCompletionToolParam = {
             'type': 'function',
             'function': {
                 'name': f.name,
@@ -359,6 +363,9 @@ class OpenAIModel(Model):
                 'parameters': f.parameters_json_schema,
             },
         }
+        if f.strict:
+            tool_param['function']['strict'] = f.strict
+        return tool_param
 
     async def _map_user_message(self, message: ModelRequest) -> AsyncIterable[chat.ChatCompletionMessageParam]:
         for part in message.parts:
@@ -522,6 +529,9 @@ class OpenAIResponsesModel(Model):
         async with response:
             yield await self._process_streamed_response(response)
 
+    def customize_request_parameters(self, model_request_parameters: ModelRequestParameters) -> ModelRequestParameters:
+        return _customize_request_parameters(model_request_parameters)
+
     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)
@@ -602,7 +612,7 @@ class OpenAIResponsesModel(Model):
                 truncation=model_settings.get('openai_truncation', NOT_GIVEN),
                 timeout=model_settings.get('timeout', NOT_GIVEN),
                 reasoning=reasoning,
-                user=model_settings.get('user', NOT_GIVEN),
+                user=model_settings.get('openai_user', NOT_GIVEN),
             )
         except APIStatusError as e:
             if (status_code := e.status_code) >= 400:
@@ -630,8 +640,8 @@ class OpenAIResponsesModel(Model):
             'parameters': f.parameters_json_schema,
             'type': 'function',
             'description': f.description,
-            # TODO(Marcelo): We should make this configurable, and if True, set `additionalProperties` to False.
-            'strict': False,
+            # NOTE: f.strict should already be a boolean thanks to customize_request_parameters
+            'strict': f.strict or False,
         }
 
     async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[responses.ResponseInputItemParam]]:
@@ -907,3 +917,139 @@ def _map_usage(response: chat.ChatCompletion | ChatCompletionChunk | responses.R
             total_tokens=response_usage.total_tokens,
             details=details,
         )
+
+
+class _StrictSchemaHelper:
+    def make_schema_strict(self, schema: dict[str, Any]) -> dict[str, Any]:
+        """Recursively handle the schema to make it compatible with OpenAI strict mode.
+
+        See https://platform.openai.com/docs/guides/function-calling?api-mode=responses#strict-mode for more details,
+        but this basically just requires:
+        * `additionalProperties` must be set to false for each object in the parameters
+        * all fields in properties must be marked as required
+        """
+        assert isinstance(schema, dict), 'Schema must be a dictionary, this is probably a bug'
+
+        # Create a copy to avoid modifying the original schema
+        schema = schema.copy()
+
+        # Handle $defs
+        if defs := schema.get('$defs'):
+            schema['$defs'] = {k: self.make_schema_strict(v) for k, v in defs.items()}
+
+        # Process schema based on its type
+        schema_type = schema.get('type')
+        if schema_type == 'object':
+            # Handle object type by setting additionalProperties to false
+            # and adding all properties to required list
+            self._make_object_schema_strict(schema)
+        elif schema_type == 'array':
+            # Handle array types by processing their items
+            if 'items' in schema:
+                items: Any = schema['items']
+                schema['items'] = self.make_schema_strict(items)
+            if 'prefixItems' in schema:
+                prefix_items: list[Any] = schema['prefixItems']
+                schema['prefixItems'] = [self.make_schema_strict(item) for item in prefix_items]
+
+        elif schema_type in {'string', 'number', 'integer', 'boolean', 'null'}:
+            pass  # Primitive types need no special handling
+        elif 'oneOf' in schema:
+            schema['oneOf'] = [self.make_schema_strict(item) for item in schema['oneOf']]
+        elif 'anyOf' in schema:
+            schema['anyOf'] = [self.make_schema_strict(item) for item in schema['anyOf']]
+
+        return schema
+
+    def _make_object_schema_strict(self, schema: dict[str, Any]) -> None:
+        schema['additionalProperties'] = False
+
+        # Handle patternProperties; note this may not be compatible with strict mode but is included for completeness
+        if 'patternProperties' in schema and isinstance(schema['patternProperties'], dict):
+            pattern_props: dict[str, Any] = schema['patternProperties']
+            schema['patternProperties'] = {str(k): self.make_schema_strict(v) for k, v in pattern_props.items()}
+
+        # Handle properties — update their schemas recursively, and make all properties required
+        if 'properties' in schema and isinstance(schema['properties'], dict):
+            properties: dict[str, Any] = schema['properties']
+            schema['properties'] = {k: self.make_schema_strict(v) for k, v in properties.items()}
+            schema['required'] = list(properties.keys())
+
+    def is_schema_strict(self, schema: dict[str, Any]) -> bool:
+        """Check if the schema is strict-mode-compatible.
+
+        A schema is compatible if:
+        * `additionalProperties` is set to false for each object in the parameters
+        * all fields in properties are marked as required
+
+        See https://platform.openai.com/docs/guides/function-calling?api-mode=responses#strict-mode for more details.
+        """
+        assert isinstance(schema, dict), 'Schema must be a dictionary, this is probably a bug'
+
+        # Note that checking the defs first is usually the fastest way to proceed, but
+        # it makes it hard/impossible to hit coverage below, hence all the pragma no covers.
+        # I still included the handling below because I'm not _confident_ those code paths can't be hit.
+        if defs := schema.get('$defs'):
+            if not all(self.is_schema_strict(v) for v in defs.values()):  # pragma: no branch
+                return False
+
+        schema_type = schema.get('type')
+        if schema_type == 'object':
+            if not self._is_object_schema_strict(schema):
+                return False
+        elif schema_type == 'array':
+            if 'items' in schema:
+                items: Any = schema['items']
+                if not self.is_schema_strict(items):  # pragma: no cover
+                    return False
+            if 'prefixItems' in schema:
+                prefix_items: list[Any] = schema['prefixItems']
+                if not all(self.is_schema_strict(item) for item in prefix_items):  # pragma: no cover
+                    return False
+        elif schema_type in {'string', 'number', 'integer', 'boolean', 'null'}:
+            pass
+        elif 'oneOf' in schema:  # pragma: no cover
+            if not all(self.is_schema_strict(item) for item in schema['oneOf']):
+                return False
+
+        elif 'anyOf' in schema:  # pragma: no cover
+            if not all(self.is_schema_strict(item) for item in schema['anyOf']):
+                return False
+
+        return True
+
+    def _is_object_schema_strict(self, schema: dict[str, Any]) -> bool:
+        """Check if the schema is an object and has additionalProperties set to false."""
+        if schema.get('additionalProperties') is not False:
+            return False
+        if 'properties' not in schema:  # pragma: no cover
+            return False
+        if 'required' not in schema:  # pragma: no cover
+            return False
+
+        for k, v in schema['properties'].items():
+            if k not in schema['required']:
+                return False
+            if not self.is_schema_strict(v):  # pragma: no cover
+                return False
+
+        return True
+
+
+def _customize_request_parameters(model_request_parameters: ModelRequestParameters) -> ModelRequestParameters:
+    """Customize the request parameters for OpenAI models."""
+
+    def _customize_tool_def(t: ToolDefinition):
+        if t.strict is True:
+            parameters_json_schema = _StrictSchemaHelper().make_schema_strict(t.parameters_json_schema)
+            return replace(t, parameters_json_schema=parameters_json_schema)
+        elif t.strict is None:
+            strict = _StrictSchemaHelper().is_schema_strict(t.parameters_json_schema)
+            return replace(t, strict=strict)
+        return t
+
+    return ModelRequestParameters(
+        function_tools=[_customize_tool_def(tool) for tool in model_request_parameters.function_tools],
+        allow_text_result=model_request_parameters.allow_text_result,
+        result_tools=[_customize_tool_def(tool) for tool in model_request_parameters.result_tools],
+    )

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.54}/pydantic_ai/settings.py

@@ -1,13 +1,8 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
 from httpx import Timeout
 from typing_extensions import TypedDict
 
-if TYPE_CHECKING:
-    pass
-
 
 class ModelSettings(TypedDict, total=False):
     """Settings to configure an LLM.
@@ -133,6 +128,19 @@ class ModelSettings(TypedDict, total=False):
     * Groq
     """
 
+    stop_sequences: list[str]
+    """Sequences that will cause the model to stop generating.
+
+    Supported by:
+
+    * OpenAI
+    * Anthropic
+    * Bedrock
+    * Mistral
+    * Groq
+    * Cohere
+    """
+
 
 def merge_model_settings(base: ModelSettings | None, overrides: ModelSettings | None) -> ModelSettings | None:
     """Merge two sets of model settings, preferring the overrides.

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.54}/pydantic_ai/tools.py

@@ -48,7 +48,7 @@ class RunContext(Generic[AgentDepsT]):
     """The model used in this run."""
     usage: Usage
     """LLM usage associated with the run."""
-    prompt: str | Sequence[_messages.UserContent]
+    prompt: str | Sequence[_messages.UserContent] | None
     """The original user prompt passed to the run."""
     messages: list[_messages.ModelMessage] = field(default_factory=list)
     """Messages exchanged in the conversation so far."""
@@ -173,12 +173,18 @@ class Tool(Generic[AgentDepsT]):
     prepare: ToolPrepareFunc[AgentDepsT] | None
     docstring_format: DocstringFormat
     require_parameter_descriptions: bool
+    strict: bool | None
     _is_async: bool = field(init=False)
     _single_arg_name: str | None = field(init=False)
     _positional_fields: list[str] = field(init=False)
     _var_positional_field: str | None = field(init=False)
     _validator: SchemaValidator = field(init=False, repr=False)
-    _parameters_json_schema: ObjectJsonSchema = field(init=False)
+    _base_parameters_json_schema: ObjectJsonSchema = field(init=False)
+    """
+    The base JSON schema for the tool's parameters.
+
+    This schema may be modified by the `prepare` function or by the Model class prior to including it in an API request.
+    """
 
     # TODO: Move this state off the Tool class, which is otherwise stateless.
     #   This should be tracked inside a specific agent run, not the tool.
@@ -196,6 +202,7 @@ class Tool(Generic[AgentDepsT]):
         docstring_format: DocstringFormat = 'auto',
         require_parameter_descriptions: bool = False,
         schema_generator: type[GenerateJsonSchema] = GenerateToolJsonSchema,
+        strict: bool | None = None,
     ):
         """Create a new tool instance.
 
@@ -246,6 +253,8 @@ class Tool(Generic[AgentDepsT]):
                 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. Defaults to `GenerateToolJsonSchema`.
+            strict: Whether to enforce JSON schema compliance (only affects OpenAI).
+                See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info.
         """
         if takes_ctx is None:
             takes_ctx = _pydantic.takes_ctx(function)
@@ -261,12 +270,13 @@ class Tool(Generic[AgentDepsT]):
         self.prepare = prepare
         self.docstring_format = docstring_format
         self.require_parameter_descriptions = require_parameter_descriptions
+        self.strict = strict
         self._is_async = inspect.iscoroutinefunction(self.function)
         self._single_arg_name = f['single_arg_name']
         self._positional_fields = f['positional_fields']
         self._var_positional_field = f['var_positional_field']
         self._validator = f['validator']
-        self._parameters_json_schema = f['json_schema']
+        self._base_parameters_json_schema = f['json_schema']
 
     async def prepare_tool_def(self, ctx: RunContext[AgentDepsT]) -> ToolDefinition | None:
         """Get the tool definition.
@@ -280,7 +290,8 @@ class Tool(Generic[AgentDepsT]):
         tool_def = ToolDefinition(
             name=self.name,
             description=self.description,
-            parameters_json_schema=self._parameters_json_schema,
+            parameters_json_schema=self._base_parameters_json_schema,
+            strict=self.strict,
         )
         if self.prepare is not None:
             return await self.prepare(ctx, tool_def)
@@ -400,7 +411,7 @@ With PEP-728 this should be a TypedDict with `type: Literal['object']`, and `ext
 class ToolDefinition:
     """Definition of a tool passed to a model.
 
-    This is used for both function tools result tools.
+    This is used for both function tools and result tools.
     """
 
     name: str
@@ -417,3 +428,15 @@ class ToolDefinition:
 
     This will only be set for result tools which don't have an `object` JSON schema.
     """
+
+    strict: bool | None = None
+    """Whether to enforce (vendor-specific) strict JSON schema validation for tool calls.
+
+    Setting this to `True` while using a supported model generally imposes some restrictions on the tool's JSON schema
+    in exchange for guaranteeing the API responses strictly match that schema.
+
+    When `False`, the model may be free to generate other properties or types (depending on the vendor).
+    When `None` (the default), the value will be inferred based on the compatibility of the parameters_json_schema.
+
+    Note: this is currently only supported by OpenAI models.
+    """