Python: fix: coerce dict response_format to Azure AI typed model to fix Azure Monitor compatibility

When response_format is passed as a plain Python dict (e.g. {"type":
"json_object"}), the Azure AI telemetry instrumentor raises
ValueError: Unknown response format <class 'dict'> because it only
handles the typed SDK models (AgentsResponseFormat,
ResponseFormatJsonSchemaType, AgentsResponseFormatMode, str).

Add AgentThreadActions._coerce_response_format() to convert plain
dicts to the appropriate typed model before the options dict is
forwarded to agents.runs.create(), preventing the telemetry error
when Azure Monitor is enabled.

Fixes #13715

Author: octo-patch

python/semantic_kernel/agents/azure_ai/agent_thread_actions.py

@@ -8,6 +8,8 @@
 from azure.ai.agents.models import (
     AgentsNamedToolChoiceType,
     AgentStreamEvent,
+    AgentsResponseFormat,
+    AgentsResponseFormatMode,
     AsyncAgentEventHandler,
     AsyncAgentRunStream,
     BaseAsyncAgentEventHandler,
@@ -923,7 +925,7 @@ def _generate_options(cls: type[_T], **kwargs: Any) -> dict[str, Any]:
         return {
             "model": merged.get("model"),
             "top_p": merged.get("top_p"),
-            "response_format": merged.get("response_format"),
+            "response_format": cls._coerce_response_format(merged.get("response_format")),
             "temperature": merged.get("temperature"),
             "truncation_strategy": truncation_strategy,
             "metadata": merged.get("metadata"),
@@ -933,6 +935,28 @@ def _generate_options(cls: type[_T], **kwargs: Any) -> dict[str, Any]:
             "additional_messages": additional_messages,
         }
 
+    @staticmethod
+    def _coerce_response_format(
+        response_format: Any,
+    ) -> "str | AgentsResponseFormatMode | AgentsResponseFormat | ResponseFormatJsonSchemaType | None":
+        """Coerce a plain dict response_format to the appropriate Azure AI typed model.
+
+        When users supply ``response_format`` as a plain Python :class:`dict` (e.g.
+        ``{"type": "json_object"}``), the Azure AI telemetry instrumentor raises
+        ``ValueError: Unknown response format <class 'dict'>`` because it only handles
+        the typed SDK models.  This method converts plain dicts to the correct type so
+        that the Azure AI telemetry layer can serialize them without error.
+        """
+        if response_format is None or isinstance(
+            response_format, (str, AgentsResponseFormatMode, AgentsResponseFormat, ResponseFormatJsonSchemaType)
+        ):
+            return response_format
+        if isinstance(response_format, dict):
+            if response_format.get("type") == "json_schema":
+                return ResponseFormatJsonSchemaType(response_format)
+            return AgentsResponseFormat(response_format)
+        return response_format
+
     @classmethod
     def _translate_additional_messages(
         cls: type[_T], messages: "list[ChatMessageContent] | None"

python/tests/unit/agents/azure_ai_agent/test_agent_thread_actions.py

@@ -3,11 +3,15 @@
 from datetime import datetime, timezone
 from unittest.mock import AsyncMock, MagicMock, patch
 
+import pytest
 from azure.ai.agents.models import (
+    AgentsResponseFormat,
+    AgentsResponseFormatMode,
     MessageTextContent,
     MessageTextDetails,
     RequiredFunctionToolCall,
     RequiredFunctionToolCallDetails,
+    ResponseFormatJsonSchemaType,
     RunStep,
     RunStepCodeInterpreterToolCall,
     RunStepCodeInterpreterToolCallDetails,
@@ -354,3 +358,52 @@ async def test_agent_thread_actions_invoke_stream(ai_project_client, ai_agent_de
             collected_messages.append(content)
             assert isinstance(content, ChatMessageContent)
             assert content.metadata.get("message_id") == "msg_1"
+
+
+# region _coerce_response_format tests
+
+
+@pytest.mark.parametrize(
+    "input_value, expected_type",
+    [
+        (None, type(None)),
+        ("auto", str),
+        (AgentsResponseFormatMode.AUTO, AgentsResponseFormatMode),
+        (AgentsResponseFormat({"type": "json_object"}), AgentsResponseFormat),
+        (
+            ResponseFormatJsonSchemaType({"type": "json_schema", "json_schema": {"name": "t", "schema": {}}}),
+            ResponseFormatJsonSchemaType,
+        ),
+    ],
+)
+def test_coerce_response_format_passthrough(input_value, expected_type):
+    """Values that are already the correct type should be returned unchanged."""
+    result = AgentThreadActions._coerce_response_format(input_value)
+    assert isinstance(result, expected_type) or result is None
+
+
+def test_coerce_response_format_dict_json_object():
+    """A plain dict with type 'json_object' should become AgentsResponseFormat."""
+    result = AgentThreadActions._coerce_response_format({"type": "json_object"})
+    assert isinstance(result, AgentsResponseFormat)
+
+
+def test_coerce_response_format_dict_json_schema():
+    """A plain dict with type 'json_schema' should become ResponseFormatJsonSchemaType."""
+    payload = {"type": "json_schema", "json_schema": {"name": "MySchema", "strict": True, "schema": {}}}
+    result = AgentThreadActions._coerce_response_format(payload)
+    assert isinstance(result, ResponseFormatJsonSchemaType)
+
+
+def test_coerce_response_format_unknown_type_passthrough():
+    """An unknown (non-dict) type should be returned as-is to let the SDK handle it."""
+
+    class Custom:
+        pass
+
+    custom = Custom()
+    result = AgentThreadActions._coerce_response_format(custom)
+    assert result is custom
+
+
+# endregion