📝 chore: Add mixed-input regression coverage to generate config tests (#607)

Code changes was requested by @binaryaaron.

*
#595 (comment)

The following files were modified:

* `tests/config/test_generate.py`

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

Author: coderabbitai[bot]

tests/config/test_generate.py

@@ -119,3 +119,93 @@ def test_from_params_accepts_nested_structured_generation(self) -> None:
         assert params.generation.structured_generation.enabled is True
         assert params.generation.structured_generation.schema_method == "json_schema"
         assert params.generation.structured_generation.backend == "outlines"
+
+
+@pytest.mark.unit
+class TestMixedInputMigration:
+    """Regression coverage for mixed-input: legacy flat keys coexist with nested structured_generation dict.
+
+    The migration contract: when both forms are present, legacy flat keys win as explicit overrides.
+    Un-overridden nested dict fields are preserved.
+    """
+
+    def test_legacy_backend_overrides_nested_dict_backend(self) -> None:
+        """A legacy flat backend key beats the nested dict backend when both are supplied."""
+        params = GenerateParameters.model_validate(
+            {
+                "structured_generation": {"enabled": True, "backend": "outlines"},
+                "structured_generation_backend": "xgrammar",
+            }
+        )
+        assert params.structured_generation.backend == "xgrammar"
+        assert params.structured_generation.enabled is True  # nested value preserved
+
+    def test_legacy_enabled_overrides_nested_dict_enabled(self) -> None:
+        """A legacy use_structured_generation key beats the nested dict enabled field."""
+        params = GenerateParameters.model_validate(
+            {
+                "use_structured_generation": True,
+                "structured_generation": {"enabled": False, "schema_method": "json_schema"},
+            }
+        )
+        assert params.structured_generation.enabled is True
+        assert params.structured_generation.schema_method == "json_schema"  # preserved
+
+    def test_legacy_schema_method_overrides_nested_dict_schema_method(self) -> None:
+        """A legacy schema_method key beats the nested dict schema_method field."""
+        params = GenerateParameters.model_validate(
+            {
+                "structured_generation_schema_method": "regex",
+                "structured_generation": {"enabled": True, "schema_method": "json_schema"},
+            }
+        )
+        assert params.structured_generation.schema_method == "regex"
+        assert params.structured_generation.enabled is True  # preserved
+
+    def test_from_params_legacy_backend_overrides_generation_section_backend(self) -> None:
+        """from_params: a top-level legacy backend key overrides the backend inside generation={}."""
+        params = SafeSynthesizerParameters.from_params(
+            generation={"structured_generation": {"enabled": True, "backend": "outlines"}},
+            structured_generation_backend="xgrammar",
+        )
+        assert params.generation.structured_generation.backend == "xgrammar"
+        assert params.generation.structured_generation.enabled is True  # preserved
+
+    def test_from_params_legacy_enabled_overrides_structured_generation_kwarg(self) -> None:
+        """from_params: a top-level legacy use_structured_generation overrides structured_generation kwarg."""
+        params = SafeSynthesizerParameters.from_params(
+            structured_generation={"enabled": False, "schema_method": "json_schema"},
+            use_structured_generation=True,
+        )
+        assert params.generation.structured_generation.enabled is True
+        assert params.generation.structured_generation.schema_method == "json_schema"  # preserved
+
+    def test_nested_dict_with_no_legacy_keys_uses_dict_values(self) -> None:
+        """When no legacy flat keys are present, nested dict values are used as-is."""
+        params = GenerateParameters.model_validate(
+            {
+                "structured_generation": {
+                    "enabled": True,
+                    "backend": "outlines",
+                    "schema_method": "json_schema",
+                }
+            }
+        )
+        assert params.structured_generation.enabled is True
+        assert params.structured_generation.backend == "outlines"
+        assert params.structured_generation.schema_method == "json_schema"
+
+    def test_legacy_keys_with_no_nested_dict_are_migrated(self) -> None:
+        """When only legacy flat keys are present, migration produces the correct nested values."""
+        params = GenerateParameters.model_validate(
+            {
+                "use_structured_generation": True,
+                "structured_generation_backend": "xgrammar",
+                "structured_generation_schema_method": "structural_tag",
+                "structured_generation_use_single_sequence": True,
+            }
+        )
+        assert params.structured_generation.enabled is True
+        assert params.structured_generation.backend == "xgrammar"
+        assert params.structured_generation.schema_method == "structural_tag"
+        assert params.structured_generation.use_single_sequence is True