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/ogx/providers/inline/responses/builtin/responses/streaming.py

@@ -1570,9 +1570,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
+                tool_param: ChatCompletionToolParam = convert_tooldef_to_openai_tool(  # type: ignore[assignment]
+                    tool_name=input_tool.name,
+                    description=input_tool.description,
+                    input_schema=input_tool.parameters,
+                    strict=input_tool.strict,
                 )
+                self.ctx.chat_tools.append(tool_param)
             elif input_tool.type in WebSearchToolTypes:
                 tool_name = "web_search"
                 # Need to access tool_groups_api from tool_executor

src/ogx/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/responses/builtin/test_openai_responses_tools.py

@@ -4,6 +4,7 @@
 # This source code is licensed under the terms described in the LICENSE file in
 # the root directory of this source tree.
 
+import json
 from unittest.mock import patch
 
 from openai.types.chat.chat_completion_chunk import (
@@ -678,9 +679,6 @@ async def fake_stream_vllm_style():
     assert len(completed_chunk.response.output) == 1
     assert completed_chunk.response.output[0].type == "function_call"
     assert completed_chunk.response.output[0].name == "get_weather"
-    # Arguments must be valid JSON — not '{}{"location": "..."}' which was the bug
-    import json
-
     parsed = json.loads(completed_chunk.response.output[0].arguments)
     assert parsed == {"location": "San Francisco"}
 
@@ -781,8 +779,6 @@ async def fake_stream_split_args():
     assert completed_chunk.response.output[0].type == "function_call"
     assert completed_chunk.response.output[0].name == "get_weather"
 
-    import json
-
     parsed = json.loads(completed_chunk.response.output[0].arguments)
     assert parsed == {"location": "Boston"}
 
@@ -837,9 +833,6 @@ async def fake_stream_no_args():
     assert completed_chunk.type == "response.completed"
     assert completed_chunk.response.output[0].type == "function_call"
     assert completed_chunk.response.output[0].name == "get_current_time"
-    # No-parameter functions should produce valid empty JSON
-    import json
-
     parsed = json.loads(completed_chunk.response.output[0].arguments)
     assert parsed == {}
 
@@ -963,3 +956,42 @@ async def test_function_tool_strict_false_included(openai_responses_impl, mock_i
     tool_function = params.tools[0]["function"]
     assert "strict" in tool_function, "strict field should be included when explicitly set to False"
     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"