Add support for GPT-5 Free-Form Function Calling and Context Free Grammar constraints over tools

pydantic_ai_slim/pydantic_ai/_output.py

@@ -591,6 +591,7 @@ class OutputObjectDefinition:
     name: str | None = None
     description: str | None = None
     strict: bool | None = None
+    free_form: bool = False
 
 
 @dataclass(init=False)
@@ -621,6 +622,7 @@ def __init__(
         name: str | None = None,
         description: str | None = None,
         strict: bool | None = None,
+        free_form: bool = False,
     ):
         if inspect.isfunction(output) or inspect.ismethod(output):
             self._function_schema = _function_schema.function_schema(output, GenerateToolJsonSchema)
@@ -663,6 +665,7 @@ def __init__(
             description=description,
             json_schema=json_schema,
             strict=strict,
+            free_form=free_form,
         )
 
     async def process(
@@ -925,14 +928,17 @@ def build(
                 name = output.name
                 description = output.description
                 strict = output.strict
+                free_form = output.free_form
 
                 output = output.output
 
             description = description or default_description
             if strict is None:
                 strict = default_strict
 
-            processor = ObjectOutputProcessor(output=output, description=description, strict=strict)
+            processor = ObjectOutputProcessor(
+                output=output, description=description, strict=strict, free_form=free_form
+            )
             object_def = processor.object_def
 
             if name is None:
@@ -957,6 +963,7 @@ def build(
                 description=description,
                 parameters_json_schema=object_def.json_schema,
                 strict=object_def.strict,
+                free_form=object_def.free_form,
                 outer_typed_dict_key=processor.outer_typed_dict_key,
                 kind='output',
             )

pydantic_ai_slim/pydantic_ai/agent/__init__.py

@@ -8,7 +8,7 @@
 from collections.abc import AsyncIterator, Awaitable, Iterator, Sequence
 from contextlib import AbstractAsyncContextManager, AsyncExitStack, asynccontextmanager, contextmanager
 from contextvars import ContextVar
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, cast, overload
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Literal, cast, overload
 
 from opentelemetry.trace import NoOpTracer, use_span
 from pydantic.json_schema import GenerateJsonSchema
@@ -963,6 +963,9 @@ def tool(
         require_parameter_descriptions: bool = False,
         schema_generator: type[GenerateJsonSchema] = GenerateToolJsonSchema,
         strict: bool | None = None,
+        free_form: bool | None = None,
+        grammar_syntax: Literal['regex', 'lark'] | None = None,
+        grammar_definition: str | None = None,
     ) -> Callable[[ToolFuncContext[AgentDepsT, ToolParams]], ToolFuncContext[AgentDepsT, ToolParams]]: ...
 
     def tool(
@@ -977,6 +980,9 @@ def tool(
         require_parameter_descriptions: bool = False,
         schema_generator: type[GenerateJsonSchema] = GenerateToolJsonSchema,
         strict: bool | None = None,
+        free_form: bool | None = None,
+        grammar_syntax: Literal['regex', 'lark'] | None = None,
+        grammar_definition: str | None = None,
     ) -> Any:
         """Decorator to register a tool function which takes [`RunContext`][pydantic_ai.tools.RunContext] as its first argument.
 
@@ -1021,6 +1027,12 @@ async def spam(ctx: RunContext[str], y: float) -> float:
             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.
+            free_form: Whether to invoke the function using free-form function calling (only affects OpenAI).
+                See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info.
+            grammar_syntax: Whether to restrict the free-form function calling argument according to this syntax.
+                See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info.
+            grammar_definition: Whether to restrict the free-form function calling argument according to this syntax.
+                See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info.
         """
 
         def tool_decorator(
@@ -1037,6 +1049,9 @@ def tool_decorator(
                 require_parameter_descriptions,
                 schema_generator,
                 strict,
+                free_form,
+                grammar_syntax,
+                grammar_definition,
             )
             return func_
 
@@ -1057,6 +1072,9 @@ def tool_plain(
         require_parameter_descriptions: bool = False,
         schema_generator: type[GenerateJsonSchema] = GenerateToolJsonSchema,
         strict: bool | None = None,
+        free_form: bool | None = None,
+        grammar_syntax: Literal['regex', 'lark'] | None = None,
+        grammar_definition: str | None = None,
     ) -> Callable[[ToolFuncPlain[ToolParams]], ToolFuncPlain[ToolParams]]: ...
 
     def tool_plain(
@@ -1071,6 +1089,9 @@ def tool_plain(
         require_parameter_descriptions: bool = False,
         schema_generator: type[GenerateJsonSchema] = GenerateToolJsonSchema,
         strict: bool | None = None,
+        free_form: bool | None = None,
+        grammar_syntax: Literal['regex', 'lark'] | None = None,
+        grammar_definition: str | None = None,
     ) -> Any:
         """Decorator to register a tool function which DOES NOT take `RunContext` as an argument.
 
@@ -1115,6 +1136,12 @@ async def spam(ctx: RunContext[str]) -> float:
             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.
+            free_form: Whether to invoke the function using free-form function calling (only affects OpenAI).
+                See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info.
+            grammar_syntax: Whether to restrict the free-form function calling argument according to this syntax.
+                See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info.
+            grammar_definition: Whether to restrict the free-form function calling argument according to this syntax.
+                See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info.
         """
 
         def tool_decorator(func_: ToolFuncPlain[ToolParams]) -> ToolFuncPlain[ToolParams]:
@@ -1129,6 +1156,9 @@ def tool_decorator(func_: ToolFuncPlain[ToolParams]) -> ToolFuncPlain[ToolParams
                 require_parameter_descriptions,
                 schema_generator,
                 strict,
+                free_form,
+                grammar_syntax,
+                grammar_definition,
             )
             return func_
 

pydantic_ai_slim/pydantic_ai/models/openai.py

@@ -313,7 +313,7 @@ async def request(
         response = await self._completions_create(
             messages, False, cast(OpenAIModelSettings, model_settings or {}), model_request_parameters
         )
-        model_response = self._process_response(response)
+        model_response = self._process_response(response, model_request_parameters)
         return model_response
 
     @asynccontextmanager
@@ -762,7 +762,7 @@ async def request(
         response = await self._responses_create(
             messages, False, cast(OpenAIResponsesModelSettings, model_settings or {}), model_request_parameters
         )
-        return self._process_response(response)
+        return self._process_response(response, model_request_parameters)
 
     @asynccontextmanager
     async def request_stream(
@@ -779,7 +779,11 @@ async def request_stream(
         async with response:
             yield await self._process_streamed_response(response, model_request_parameters)
 
-    def _process_response(self, response: responses.Response) -> ModelResponse:
+    def _process_response(
+        self,
+        response: responses.Response,
+        model_request_parameters: ModelRequestParameters,
+    ) -> ModelResponse:
         """Process a non-streamed response, and prepare a message to return."""
         timestamp = number_to_datetime(response.created_at)
         items: list[ModelResponsePart] = []
@@ -795,6 +799,12 @@ def _process_response(self, response: responses.Response) -> ModelResponse:
                         items.append(TextPart(content.text))
             elif item.type == 'function_call':
                 items.append(ToolCallPart(item.name, item.arguments, tool_call_id=item.call_id))
+            elif item.type == 'custom_tool_call':
+                if item.name not in model_request_parameters.tool_defs:
+                    raise UnexpectedModelBehavior(f'Unknown tool called: {item.name}')
+                tool = model_request_parameters.tool_defs[item.name]
+                argument_name = tool.single_string_argument_name
+                items.append(ToolCallPart(item.name, {argument_name: item.input}, tool_call_id=item.call_id))
         return ModelResponse(
             items,
             usage=_map_usage(response),
@@ -893,11 +903,14 @@ async def _responses_create(
         try:
             extra_headers = model_settings.get('extra_headers', {})
             extra_headers.setdefault('User-Agent', get_user_agent())
+            parallel_tool_calls = self._get_parallel_tool_calling(
+                model_settings=model_settings, model_request_parameters=model_request_parameters
+            )
             return await self.client.responses.create(
                 input=openai_messages,
                 model=self._model_name,
                 instructions=instructions,
-                parallel_tool_calls=model_settings.get('parallel_tool_calls', NOT_GIVEN),
+                parallel_tool_calls=parallel_tool_calls,
                 tools=tools or NOT_GIVEN,
                 tool_choice=tool_choice or NOT_GIVEN,
                 max_output_tokens=model_settings.get('max_tokens', NOT_GIVEN),
@@ -937,7 +950,18 @@ def _get_reasoning(self, model_settings: OpenAIResponsesModelSettings) -> Reason
             return NOT_GIVEN
         return Reasoning(effort=reasoning_effort, summary=reasoning_summary)
 
-    def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[responses.FunctionToolParam]:
+    def _get_parallel_tool_calling(
+        self, model_settings: OpenAIResponsesModelSettings, model_request_parameters: ModelRequestParameters
+    ) -> bool | NotGiven:
+        if any(tool_definition.free_form for tool_definition in model_request_parameters.tool_defs.values()):
+            return False
+        if any(tool_definition.free_form for tool_definition in model_request_parameters.output_tools):
+            return False
+        return model_settings.get('parallel_tool_calls', NOT_GIVEN)
+
+    def _get_tools(
+        self, model_request_parameters: ModelRequestParameters
+    ) -> list[responses.FunctionToolParam | responses.CustomToolParam]:
         return [self._map_tool_definition(r) for r in model_request_parameters.tool_defs.values()]
 
     def _get_builtin_tools(self, model_request_parameters: ModelRequestParameters) -> list[responses.ToolParam]:
@@ -960,15 +984,33 @@ def _get_builtin_tools(self, model_request_parameters: ModelRequestParameters) -
                 )
         return tools
 
-    def _map_tool_definition(self, f: ToolDefinition) -> responses.FunctionToolParam:
+    def _map_tool_definition(self, f: ToolDefinition) -> responses.FunctionToolParam | responses.CustomToolParam:
+        model_profile = OpenAIModelProfile.from_profile(self.profile)
+        if f.free_form:
+            if not model_profile.openai_supports_freeform_function_calling:
+                raise UserError(
+                    f'`{f.name}` is set as free_form but {model_profile.name} does not support free form function calling.'
+                )
+            if not f.only_takes_string_argument:
+                raise UserError(f'`{f.name}` is set as free_form but does not take a single string argument.')
+            if f.grammar_syntax is not None:
+                format = {'type': 'grammar', 'syntax': f.grammar_syntax, 'definition': f.grammar_definition}
+            else:
+                format = {'type': 'text'}
+            tool_param: responses.CustomToolParam = {
+                'name': f.name,
+                'type': 'custom',
+                'description': f.description or '',
+                'format': format,
+            }
+            return tool_param
+
         return {
             'name': f.name,
             'parameters': f.parameters_json_schema,
             'type': 'function',
             'description': f.description,
-            'strict': bool(
-                f.strict and OpenAIModelProfile.from_profile(self.profile).openai_supports_strict_tool_definition
-            ),
+            'strict': bool(f.strict and model_profile.openai_supports_strict_tool_definition),
         }
 
     async def _map_messages(

pydantic_ai_slim/pydantic_ai/output.py

@@ -112,6 +112,8 @@ class Vehicle(BaseModel):
     """The maximum number of retries for the tool."""
     strict: bool | None
     """Whether to use strict mode for the tool."""
+    free_form: bool
+    """Whether to invoke the function with free-form function calling for tool calls."""
 
     def __init__(
         self,
@@ -121,12 +123,14 @@ def __init__(
         description: str | None = None,
         max_retries: int | None = None,
         strict: bool | None = None,
+        free_form: bool = False,
     ):
         self.output = type_
         self.name = name
         self.description = description
         self.max_retries = max_retries
         self.strict = strict
+        self.free_form = free_form
 
 
 @dataclass(init=False)

pydantic_ai_slim/pydantic_ai/profiles/openai.py

@@ -33,10 +33,16 @@ class OpenAIModelProfile(ModelProfile):
     openai_system_prompt_role: OpenAISystemPromptRole | None = None
     """The role to use for the system prompt message. If not provided, defaults to `'system'`."""
 
+    # GPT-5 introduced support for directly calling a function with a string.
+    openai_supports_freeform_function_calling: bool = False
+    """Whether the provider accepts the value ``type='custom'`` for tools in the
+    request payload."""
+
 
 def openai_model_profile(model_name: str) -> ModelProfile:
     """Get the model profile for an OpenAI model."""
     is_reasoning_model = model_name.startswith('o') or model_name.startswith('gpt-5')
+    is_freeform_function_calling_model = model_name.startswith('gpt-5')
     # Structured Outputs (output mode 'native') is only supported with the gpt-4o-mini, gpt-4o-mini-2024-07-18, and gpt-4o-2024-08-06 model snapshots and later.
     # We leave it in here for all models because the `default_structured_output_mode` is `'tool'`, so `native` is only used
     # when the user specifically uses the `NativeOutput` marker, so an error from the API is acceptable.
@@ -50,6 +56,7 @@ def openai_model_profile(model_name: str) -> ModelProfile:
         supports_json_schema_output=True,
         supports_json_object_output=True,
         openai_supports_sampling_settings=not is_reasoning_model,
+        openai_supports_freeform_function_calling=is_freeform_function_calling_model,
         openai_system_prompt_role=openai_system_prompt_role,
     )