Merge branch 'main' into fix-tool-call-args

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

@@ -37,7 +37,6 @@ from llama_stack.apis.inference import (
     OpenAIJSONSchema,
     OpenAIResponseFormatJSONObject,
     OpenAIResponseFormatJSONSchema,
-    OpenAIResponseFormatText,
     OpenAIUserMessageParam,
 )
 from llama_stack.apis.tools.tools import Tool, ToolGroups, ToolInvocationResult, ToolParameter, ToolRuntime
@@ -148,7 +147,7 @@ async def test_create_openai_response_with_string_input(openai_responses_impl, m
     mock_inference_api.openai_chat_completion.assert_called_once_with(
         model=model,
         messages=[OpenAIUserMessageParam(role="user", content="What is the capital of Ireland?", name=None)],
-        response_format=OpenAIResponseFormatText(),
+        response_format=None,
         tools=None,
         stream=True,
         temperature=0.1,
@@ -949,16 +948,16 @@ async def test_store_response_uses_rehydrated_input_with_previous_response(
 @pytest.mark.parametrize(
     "text_format, response_format",
     [
-        (OpenAIResponseText(format=OpenAIResponseTextFormat(type="text")), OpenAIResponseFormatText()),
+        (OpenAIResponseText(format=OpenAIResponseTextFormat(type="text")), None),
         (
             OpenAIResponseText(format=OpenAIResponseTextFormat(name="Test", schema={"foo": "bar"}, type="json_schema")),
             OpenAIResponseFormatJSONSchema(json_schema=OpenAIJSONSchema(name="Test", schema={"foo": "bar"})),
         ),
         (OpenAIResponseText(format=OpenAIResponseTextFormat(type="json_object")), OpenAIResponseFormatJSONObject()),
-        # ensure text param with no format specified defaults to text
-        (OpenAIResponseText(format=None), OpenAIResponseFormatText()),
-        # ensure text param of None defaults to text
-        (None, OpenAIResponseFormatText()),
+        # ensure text param with no format specified defaults to None
+        (OpenAIResponseText(format=None), None),
+        # ensure text param of None defaults to None
+        (None, None),
     ],
 )
 async def test_create_openai_response_with_text_format(
@@ -981,7 +980,6 @@ async def test_create_openai_response_with_text_format(
     # Verify
     first_call = mock_inference_api.openai_chat_completion.call_args_list[0]
     assert first_call.kwargs["messages"][0].content == input_text
-    assert first_call.kwargs["response_format"] is not None
     assert first_call.kwargs["response_format"] == response_format
 
 

tests/unit/providers/utils/test_form_data.py

@@ -0,0 +1,179 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# 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 AsyncMock, MagicMock
+
+from pydantic import BaseModel
+
+from llama_stack.providers.utils.files.form_data import (
+    parse_expires_after,
+    parse_pydantic_from_form,
+)
+
+
+class _TestModel(BaseModel):
+    """Simple test model for generic parsing tests."""
+
+    name: str
+    value: int
+
+
+async def test_parse_pydantic_from_form_bracket_notation():
+    """Test parsing a Pydantic model using bracket notation."""
+    # Create mock request with form data
+    mock_request = MagicMock()
+    mock_form = {
+        "test_field[name]": "test_name",
+        "test_field[value]": "42",
+    }
+    mock_request.form = AsyncMock(return_value=mock_form)
+
+    result = await parse_pydantic_from_form(mock_request, "test_field", _TestModel)
+
+    assert result is not None
+    assert result.name == "test_name"
+    assert result.value == 42
+
+
+async def test_parse_pydantic_from_form_json_string():
+    """Test parsing a Pydantic model from JSON string."""
+    # Create mock request with form data
+    mock_request = MagicMock()
+    test_data = {"name": "test_name", "value": 42}
+    mock_form = {
+        "test_field": json.dumps(test_data),
+    }
+    mock_request.form = AsyncMock(return_value=mock_form)
+
+    result = await parse_pydantic_from_form(mock_request, "test_field", _TestModel)
+
+    assert result is not None
+    assert result.name == "test_name"
+    assert result.value == 42
+
+
+async def test_parse_pydantic_from_form_bracket_takes_precedence():
+    """Test that bracket notation takes precedence over JSON string."""
+    # Create mock request with both formats
+    mock_request = MagicMock()
+    mock_form = {
+        "test_field[name]": "bracket_name",
+        "test_field[value]": "100",
+        "test_field": json.dumps({"name": "json_name", "value": 50}),
+    }
+    mock_request.form = AsyncMock(return_value=mock_form)
+
+    result = await parse_pydantic_from_form(mock_request, "test_field", _TestModel)
+
+    assert result is not None
+    # Bracket notation should win
+    assert result.name == "bracket_name"
+    assert result.value == 100
+
+
+async def test_parse_pydantic_from_form_missing_field():
+    """Test that None is returned when field is missing."""
+    # Create mock request with empty form
+    mock_request = MagicMock()
+    mock_form = {}
+    mock_request.form = AsyncMock(return_value=mock_form)
+
+    result = await parse_pydantic_from_form(mock_request, "test_field", _TestModel)
+
+    assert result is None
+
+
+async def test_parse_pydantic_from_form_invalid_json():
+    """Test that None is returned for invalid JSON."""
+    # Create mock request with invalid JSON
+    mock_request = MagicMock()
+    mock_form = {
+        "test_field": "not valid json",
+    }
+    mock_request.form = AsyncMock(return_value=mock_form)
+
+    result = await parse_pydantic_from_form(mock_request, "test_field", _TestModel)
+
+    assert result is None
+
+
+async def test_parse_pydantic_from_form_invalid_data():
+    """Test that None is returned when data doesn't match model."""
+    # Create mock request with data that doesn't match the model
+    mock_request = MagicMock()
+    mock_form = {
+        "test_field[wrong_field]": "value",
+    }
+    mock_request.form = AsyncMock(return_value=mock_form)
+
+    result = await parse_pydantic_from_form(mock_request, "test_field", _TestModel)
+
+    assert result is None
+
+
+async def test_parse_expires_after_bracket_notation():
+    """Test parsing expires_after using bracket notation."""
+    # Create mock request with form data
+    mock_request = MagicMock()
+    mock_form = {
+        "expires_after[anchor]": "created_at",
+        "expires_after[seconds]": "3600",
+    }
+    mock_request.form = AsyncMock(return_value=mock_form)
+
+    result = await parse_expires_after(mock_request)
+
+    assert result is not None
+    assert result.anchor == "created_at"
+    assert result.seconds == 3600
+
+
+async def test_parse_expires_after_json_string():
+    """Test parsing expires_after from JSON string."""
+    # Create mock request with form data
+    mock_request = MagicMock()
+    expires_data = {"anchor": "created_at", "seconds": 7200}
+    mock_form = {
+        "expires_after": json.dumps(expires_data),
+    }
+    mock_request.form = AsyncMock(return_value=mock_form)
+
+    result = await parse_expires_after(mock_request)
+
+    assert result is not None
+    assert result.anchor == "created_at"
+    assert result.seconds == 7200
+
+
+async def test_parse_expires_after_missing():
+    """Test that None is returned when expires_after is missing."""
+    # Create mock request with empty form
+    mock_request = MagicMock()
+    mock_form = {}
+    mock_request.form = AsyncMock(return_value=mock_form)
+
+    result = await parse_expires_after(mock_request)
+
+    assert result is None
+
+
+async def test_parse_pydantic_from_form_type_conversion():
+    """Test that bracket notation properly handles type conversion."""
+    # Create mock request with string values that need conversion
+    mock_request = MagicMock()
+    mock_form = {
+        "test_field[name]": "test",
+        "test_field[value]": "999",  # String that should be converted to int
+    }
+    mock_request.form = AsyncMock(return_value=mock_form)
+
+    result = await parse_pydantic_from_form(mock_request, "test_field", _TestModel)
+
+    assert result is not None
+    assert result.name == "test"
+    assert result.value == 999
+    assert isinstance(result.value, int)