fix: Use convert_tooldef_to_openai_tool for function tool serialization

The Responses API function tool conversion used model_dump() to build
the ChatCompletionToolParam function dict, which leaked the "type"
field (and would leak any future fields like defer_loading) into the
FunctionDefinition. OpenAI silently ignores extra fields, but stricter
endpoints (e.g. Gemini) reject them.

Instead of a fragile denylist (exclude={"type"}), reuse
convert_tooldef_to_openai_tool which explicitly picks only the fields
that belong in a FunctionDefinition. Added strict parameter support to
convert_tooldef_to_openai_tool so function tools can pass it through.

Signed-off-by: Dan Prince <dprince@redhat.com>

Author: dprince

src/llama_stack/providers/inline/agents/meta_reference/responses/streaming.py

@@ -1398,8 +1398,13 @@ def make_openai_tool(tool_name: str, tool: ToolDef) -> ChatCompletionToolParam:
         for input_tool in tools:
             if input_tool.type == "function":
                 self.ctx.chat_tools.append(
-                    ChatCompletionToolParam(type="function", function=input_tool.model_dump(exclude_none=True))
-                )  # type: ignore[typeddict-item,arg-type]  # Dict compatible with FunctionDefinition
+                    convert_tooldef_to_openai_tool(
+                        tool_name=input_tool.name,
+                        description=input_tool.description,
+                        input_schema=input_tool.parameters,
+                        strict=input_tool.strict,
+                    )
+                )  # type: ignore[arg-type]  # Returns dict but ChatCompletionToolParam expects TypedDict
             elif input_tool.type in WebSearchToolTypes:
                 tool_name = "web_search"
                 # Need to access tool_groups_api from tool_executor

src/llama_stack/providers/utils/inference/openai_compat.py

@@ -18,6 +18,7 @@ def convert_tooldef_to_openai_tool(
     tool_name: str,
     description: str | None = None,
     input_schema: dict[str, Any] | None = None,
+    strict: bool | None = None,
 ) -> dict[str, Any]:
     """
     Convert tool parameters to an OpenAI API-compatible dictionary.
@@ -26,6 +27,7 @@ def convert_tooldef_to_openai_tool(
         tool_name: Tool name as string
         description: Optional tool description
         input_schema: Optional JSON Schema for tool parameters
+        strict: Optional flag for strict parameter validation
 
     Returns:
         OpenAI-compatible tool dictionary:
@@ -35,6 +37,7 @@ def convert_tooldef_to_openai_tool(
                 "name": tool_name,
                 "description": description,
                 "parameters": {<JSON Schema>},
+                "strict": strict,
             },
         }
 
@@ -54,6 +57,9 @@ def convert_tooldef_to_openai_tool(
     if input_schema:
         function["parameters"] = input_schema
 
+    if strict is not None:
+        function["strict"] = strict
+
     return out
 
 

tests/unit/providers/agents/meta_reference/test_openai_responses.py

@@ -2540,6 +2540,45 @@ async def test_function_tool_strict_false_included(openai_responses_impl, mock_i
     assert tool_function["strict"] is False, "strict field should be False"
 
 
+async def test_function_tool_type_field_excluded_from_function_dict(openai_responses_impl, mock_inference_api):
+    """Test that the 'type' field from the input tool is excluded from the function dict.
+
+    The function dict inside ChatCompletionToolParam should only contain function-specific
+    fields (name, description, parameters, strict) and not the top-level 'type' field,
+    which belongs on the outer tool param.
+    """
+    input_text = "What is the weather?"
+    model = "meta-llama/Llama-3.1-8B-Instruct"
+
+    mock_inference_api.openai_chat_completion.return_value = fake_stream()
+
+    await openai_responses_impl.create_openai_response(
+        input=input_text,
+        model=model,
+        stream=False,
+        tools=[
+            OpenAIResponseInputToolFunction(
+                type="function",
+                name="get_weather",
+                description="Get weather information",
+                parameters={"type": "object", "properties": {"location": {"type": "string"}}, "required": ["location"]},
+            )
+        ],
+    )
+
+    assert mock_inference_api.openai_chat_completion.call_count == 1
+    params = mock_inference_api.openai_chat_completion.call_args[0][0]
+
+    assert len(params.tools) == 1
+    # The outer tool param should have type="function"
+    assert params.tools[0]["type"] == "function"
+    # The inner function dict should NOT contain 'type'
+    tool_function = params.tools[0]["function"]
+    assert "type" not in tool_function, "The input tool 'type' field should be excluded from the function dict"
+    assert tool_function["name"] == "get_weather"
+    assert tool_function["description"] == "Get weather information"
+
+
 async def test_create_openai_response_with_truncation_disabled_streaming(
     openai_responses_impl, mock_inference_api, mock_responses_store
 ):