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

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.53}/.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.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.52
+Version: 0.0.53
 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.53
 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.53; 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.53}/pydantic_ai/_agent_graph.py

@@ -311,6 +311,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.53}/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.53}/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.53}/pydantic_ai/agent.py

@@ -940,6 +940,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 +954,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 +997,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 +1015,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
                     docstring_format,
                     require_parameter_descriptions,
                     schema_generator,
+                    strict,
                 )
                 return func_
 
@@ -1018,7 +1023,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 +1049,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 +1063,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 +1106,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 +1122,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 +1151,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 +1164,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)
 

{pydantic_ai_slim-0.0.52 → pydantic_ai_slim-0.0.53}/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.53}/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."""
@@ -640,7 +650,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.53}/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."""
@@ -351,7 +354,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 +362,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 +528,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)
@@ -630,8 +639,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 +916,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.53}/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.

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

@@ -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.
+    """