fix(inference, anthropic): default json_schema.strict to true (#6024)

Fixes #6020

## Summary

- Default `json_schema.strict` to `false` when it is `None`, so it
survives `model_dump(exclude_none=True)` serialization
- Prevents Anthropic's API from rejecting the request with a 400 due to
missing `strict` field

## Test plan

- [x] Unit test for strict field defaulting
- [ ] Integration test with Anthropic provider and structured output
<!-- devin-review-badge-begin -->

---

<a href="https://app.devin.ai/review/ogx-ai/ogx/pull/6024"
target="_blank">
  <picture>
<source media="(prefers-color-scheme: dark)"
srcset="https://static.devin.ai/assets/gh-open-in-devin-review-dark.svg?v=1">
<img
src="https://static.devin.ai/assets/gh-open-in-devin-review-light.svg?v=1"
alt="Open in Devin Review">
  </picture>
</a>
<!-- devin-review-badge-end -->

---------

Signed-off-by: Derek Higgins <derekh@redhat.com>
Co-authored-by: Derek Higgins <dhiggins@example.com>

Author: derekhiggins

src/ogx/providers/remote/inference/anthropic/anthropic.py

@@ -20,6 +20,15 @@
 from .config import AnthropicConfig
 
 
+def _make_schema_strict(schema: dict) -> None:
+    """Recursively add additionalProperties: false to all object schemas for strict mode compliance."""
+    if schema.get("type") == "object":
+        if "additionalProperties" not in schema:
+            schema["additionalProperties"] = False
+        for prop in (schema.get("properties") or {}).values():
+            _make_schema_strict(prop)
+
+
 class AnthropicInferenceAdapter(OpenAIMixin):
     """Inference adapter for Anthropic Claude models."""
 
@@ -56,6 +65,18 @@ async def openai_chat_completion(
                 p = func.get("parameters")
                 if isinstance(p, dict) and not p:
                     func["parameters"] = {"type": "object"}
+        if (
+            params.response_format
+            and hasattr(params.response_format, "json_schema")
+            and params.response_format.json_schema
+        ):
+            js = params.response_format.json_schema
+            # Anthropic requires strict: true for json_schema response format
+            if js.get("strict") is None:
+                js["strict"] = True
+            schema = js.get("schema")
+            if js["strict"] and isinstance(schema, dict):
+                _make_schema_strict(schema)
         return await super().openai_chat_completion(params)
 
     async def openai_completion(

tests/unit/providers/inference/test_anthropic_adapter.py

@@ -4,13 +4,14 @@
 # This source code is licensed under the terms described in the LICENSE file in
 # the root directory of this source tree.
 
-from unittest.mock import AsyncMock, patch
+from unittest.mock import AsyncMock, MagicMock, PropertyMock, patch
 
 import pytest
 
-from ogx.providers.remote.inference.anthropic.anthropic import AnthropicInferenceAdapter
+from ogx.providers.remote.inference.anthropic.anthropic import AnthropicInferenceAdapter, _make_schema_strict
 from ogx.providers.remote.inference.anthropic.config import AnthropicConfig
-from ogx_api.inference.models import OpenAIChatCompletionRequestWithExtraBody
+from ogx_api import Model, OpenAIChatCompletionRequestWithExtraBody, OpenAIUserMessageParam
+from ogx_api.inference.models import OpenAIJSONSchema, OpenAIResponseFormatJSONSchema
 
 
 @pytest.fixture
@@ -40,3 +41,70 @@ async def test_empty_tool_parameters_normalized(adapter, input_params, expected_
         await adapter.openai_chat_completion(params)
 
     assert params.tools[0]["function"]["parameters"] == expected_params
+
+
+async def _empty_stream():
+    if False:
+        yield None
+
+
+async def test_chat_completion_defaults_strict_true_when_none():
+    adapter = AnthropicInferenceAdapter(config=AnthropicConfig(api_key="test-key"))
+    adapter.__provider_id__ = "anthropic"
+    adapter.model_store = AsyncMock()
+    adapter.model_store.get_model.return_value = Model(
+        identifier="test-model",
+        provider_id="anthropic",
+        provider_resource_id="test-model",
+    )
+
+    mock_client = MagicMock()
+    captured_params = {}
+
+    async def _capture_create(**kwargs):
+        captured_params.update(kwargs)
+        return _empty_stream()
+
+    mock_client.chat.completions.create = _capture_create
+
+    with patch.object(type(adapter), "client", new_callable=PropertyMock, return_value=mock_client):
+        params = OpenAIChatCompletionRequestWithExtraBody(
+            model="test-model",
+            messages=[OpenAIUserMessageParam(role="user", content="test")],
+            response_format=OpenAIResponseFormatJSONSchema(
+                json_schema=OpenAIJSONSchema(
+                    name="test",
+                    schema={"type": "object", "properties": {"a": {"type": "string"}}},
+                ),
+            ),
+        )
+
+        await adapter.openai_chat_completion(params)
+
+    assert captured_params["response_format"]["json_schema"]["strict"] is True
+    assert captured_params["response_format"]["json_schema"]["schema"]["additionalProperties"] is False
+
+
+def test_make_schema_strict_adds_additional_properties():
+    schema = {
+        "type": "object",
+        "properties": {
+            "name": {"type": "string"},
+            "age": {"type": "integer"},
+        },
+    }
+    _make_schema_strict(schema)
+    assert schema["additionalProperties"] is False
+    assert "required" not in schema
+
+
+def test_make_schema_strict_preserves_existing():
+    schema = {
+        "type": "object",
+        "properties": {"a": {"type": "string"}},
+        "additionalProperties": True,
+        "required": ["a"],
+    }
+    _make_schema_strict(schema)
+    assert schema["additionalProperties"] is True
+    assert schema["required"] == ["a"]