WIP

Author: chiang-daniel

libs/core/kiln_ai/adapters/model_adapters/litellm_adapter.py

@@ -392,7 +392,7 @@ def json_schema_response_format(self) -> dict[str, Any]:
             raise ValueError(
                 "Invalid output schema for this task. Cannot use JSON schema response format."
             )
-        output_schema = close_object_schemas(output_schema)
+        output_schema = close_object_schemas(output_schema, strict=True)
         return {
             "response_format": {
                 "type": "json_schema",
@@ -410,7 +410,7 @@ def tool_call_params(self, strict: bool) -> dict[str, Any]:
             raise ValueError(
                 "Invalid output schema for this task. Can not use tool calls."
             )
-        output_schema = close_object_schemas(output_schema)
+        output_schema = close_object_schemas(output_schema, strict=strict)
 
         function_params = {
             "name": "task_response",

libs/core/kiln_ai/adapters/model_adapters/test_litellm_adapter.py

@@ -195,7 +195,7 @@ async def test_response_format_options_json_schema(config, mock_task):
         patch.object(adapter, "has_structured_output", return_value=True),
     ):
         options = await adapter.response_format_options()
-        expected_schema = close_object_schemas(mock_task.output_schema())
+        expected_schema = close_object_schemas(mock_task.output_schema(), strict=True)
         assert options == {
             "response_format": {
                 "type": "json_schema",
@@ -235,7 +235,7 @@ def test_tool_call_params_strict(config, mock_task):
     adapter = LiteLlmAdapter(config=config, kiln_task=mock_task)
 
     params = adapter.tool_call_params(strict=True)
-    expected_schema = close_object_schemas(mock_task.output_schema())
+    expected_schema = close_object_schemas(mock_task.output_schema(), strict=True)
 
     assert params == {
         "tools": [
@@ -255,6 +255,81 @@ def test_tool_call_params_strict(config, mock_task):
     }
 
 
+def test_tool_call_params_strict_adds_required_to_nested(config, tmp_path):
+    project_path = tmp_path / "test_project_nested" / "project.kiln"
+    project_path.parent.mkdir()
+    project = Project(name="Nested Project", path=str(project_path))
+    project.save_to_file()
+
+    nested_schema = {
+        "type": "object",
+        "properties": {
+            "user": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string"},
+                    "age": {"type": "integer"},
+                },
+            },
+            "status": {"type": "string"},
+        },
+    }
+    task = Task(
+        name="Nested Task",
+        instruction="Test instruction",
+        parent=project,
+        output_json_schema=json.dumps(nested_schema),
+    )
+    task.save_to_file()
+
+    adapter = LiteLlmAdapter(config=config, kiln_task=task)
+    params = adapter.tool_call_params(strict=True)
+
+    result_schema = params["tools"][0]["function"]["parameters"]
+    assert result_schema["required"] == ["user", "status"]
+    assert result_schema["properties"]["user"]["required"] == ["name", "age"]
+
+
+@pytest.mark.asyncio
+async def test_json_schema_response_format_adds_required_to_nested(config, tmp_path):
+    project_path = tmp_path / "test_project_nested2" / "project.kiln"
+    project_path.parent.mkdir()
+    project = Project(name="Nested Project 2", path=str(project_path))
+    project.save_to_file()
+
+    nested_schema = {
+        "type": "object",
+        "properties": {
+            "result": {
+                "type": "object",
+                "properties": {
+                    "value": {"type": "number"},
+                    "unit": {"type": "string"},
+                },
+            },
+        },
+    }
+    task = Task(
+        name="Nested Task 2",
+        instruction="Test instruction",
+        parent=project,
+        output_json_schema=json.dumps(nested_schema),
+    )
+    task.save_to_file()
+
+    config.run_config_properties.structured_output_mode = (
+        StructuredOutputMode.json_schema
+    )
+    adapter = LiteLlmAdapter(config=config, kiln_task=task)
+
+    with patch.object(adapter, "has_structured_output", return_value=True):
+        options = await adapter.response_format_options()
+
+    result_schema = options["response_format"]["json_schema"]["schema"]
+    assert result_schema["required"] == ["result"]
+    assert result_schema["properties"]["result"]["required"] == ["value", "unit"]
+
+
 @pytest.mark.parametrize(
     "provider_name,expected_prefix",
     [

libs/core/kiln_ai/datamodel/json_schema.py

@@ -157,14 +157,18 @@ def single_string_field_name(schema: Dict) -> str | None:
     return None
 
 
-def close_object_schemas(schema: Dict) -> Dict:
+def close_object_schemas(schema: Dict, strict: bool = False) -> Dict:
     """Return a deep-copied schema with object nodes closed by default.
 
     Any schema node with 'type == "object"' gets 'additionalProperties: false'
     if it is not already set. This normalization is recursive and walks nested
     schema structures such as 'properties', 'items', '$defs', and composed
     schemas like 'anyOf'/'oneOf'/'allOf'. Existing explicit
     'additionalProperties' values are preserved.
+
+    When strict=True, also sets 'required' to list all property keys on every
+    object node with 'properties'. This is needed for OpenAI's strict
+    structured output mode, which does not support optional properties.
     """
 
     def _normalize(node: Any) -> Any:
@@ -203,6 +207,9 @@ def _normalize(node: Any) -> Any:
         ):
             normalized["additionalProperties"] = False
 
+        if strict and normalized.get("type") == "object" and "properties" in normalized:
+            normalized["required"] = list(normalized["properties"].keys())
+
         return normalized
 
     return _normalize(schema)

libs/core/kiln_ai/datamodel/test_json_schema.py

@@ -248,6 +248,96 @@ def test_close_object_schemas_preserves_explicit_additional_properties():
     assert normalized["properties"]["metadata"]["additionalProperties"] is True
 
 
+def test_close_object_schemas_strict_adds_required():
+    schema = {
+        "type": "object",
+        "properties": {
+            "name": {"type": "string"},
+            "age": {"type": "integer"},
+        },
+    }
+    result = close_object_schemas(schema, strict=True)
+    assert result["required"] == ["name", "age"]
+    assert result["additionalProperties"] is False
+
+
+def test_close_object_schemas_strict_overwrites_partial_required():
+    schema = {
+        "type": "object",
+        "properties": {
+            "name": {"type": "string"},
+            "age": {"type": "integer"},
+            "email": {"type": "string"},
+        },
+        "required": ["name"],
+    }
+    result = close_object_schemas(schema, strict=True)
+    assert result["required"] == ["name", "age", "email"]
+
+
+def test_close_object_schemas_strict_nested():
+    schema = {
+        "type": "object",
+        "properties": {
+            "user": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string"},
+                    "address": {
+                        "type": "object",
+                        "properties": {
+                            "street": {"type": "string"},
+                            "city": {"type": "string"},
+                        },
+                    },
+                },
+            },
+            "tags": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "key": {"type": "string"},
+                        "value": {"type": "string"},
+                    },
+                },
+            },
+        },
+    }
+    result = close_object_schemas(schema, strict=True)
+    assert result["required"] == ["user", "tags"]
+    assert result["properties"]["user"]["required"] == ["name", "address"]
+    assert result["properties"]["user"]["properties"]["address"]["required"] == [
+        "street",
+        "city",
+    ]
+    assert result["properties"]["tags"]["items"]["required"] == ["key", "value"]
+
+
+def test_close_object_schemas_non_strict_no_required():
+    schema = {
+        "type": "object",
+        "properties": {
+            "name": {"type": "string"},
+            "age": {"type": "integer"},
+        },
+    }
+    result = close_object_schemas(schema)
+    assert "required" not in result
+
+    result_explicit = close_object_schemas(schema, strict=False)
+    assert "required" not in result_explicit
+
+
+def test_close_object_schemas_strict_no_properties():
+    schema = {
+        "type": "object",
+        "additionalProperties": {"type": "string"},
+    }
+    result = close_object_schemas(schema, strict=True)
+    assert "required" not in result
+
+
 @pytest.mark.parametrize(
     "schema,expected",
     [