Python: Serialize durabletask options response format

Author: VectorPeak

python/packages/durabletask/agent_framework_durabletask/_models.py

@@ -93,6 +93,34 @@ def _deserialize_response_format(response_format: Any) -> type[BaseModel] | None
     return None
 
 
+def _serialize_options(options: dict[str, Any]) -> dict[str, Any]:
+    """Serialize known durable options without mutating caller-provided options."""
+    result = dict(options)
+    response_format = result.get("response_format")
+    if (
+        _PydanticBaseModel is not None
+        and inspect.isclass(response_format)
+        and issubclass(response_format, _PydanticBaseModel)
+    ):
+        result["response_format"] = serialize_response_format(response_format)
+    return result
+
+
+def _deserialize_options(options: dict[str, Any]) -> dict[str, Any]:
+    """Deserialize known durable options without mutating caller-provided options."""
+    result = dict(options)
+    if (response_format_value := result.get("response_format")) is not None:
+        response_format = _deserialize_response_format(response_format_value)
+        if response_format is not None:
+            result["response_format"] = response_format
+        elif (
+            isinstance(response_format_value, dict)
+            and response_format_value.get("__response_schema_type__") == "pydantic_model"
+        ):
+            result.pop("response_format")
+    return result
+
+
 @dataclass
 class RunRequest:
     """Represents a request to run an agent with a specific message and configuration.
@@ -165,7 +193,7 @@ def to_dict(self) -> dict[str, Any]:
             "role": self.role,
             "request_response_format": self.request_response_format,
             "correlationId": self.correlation_id,
-            "options": self.options,
+            "options": _serialize_options(self.options),
         }
         if self.response_format:
             result["response_format"] = serialize_response_format(self.response_format)
@@ -200,6 +228,7 @@ def from_dict(cls, data: dict[str, Any]) -> RunRequest:
             raise ValueError("correlationId is required in RunRequest data")
 
         options = data.get("options")
+        options = _deserialize_options(options) if isinstance(options, dict) else {}
 
         return cls(
             message=data.get("message", ""),
@@ -211,7 +240,7 @@ def from_dict(cls, data: dict[str, Any]) -> RunRequest:
             enable_tool_calls=data.get("enable_tool_calls", True),
             created_at=created_at,
             orchestration_id=data.get("orchestrationId"),
-            options=cast(dict[str, Any], options) if isinstance(options, dict) else {},
+            options=options,
         )
 
 

python/packages/durabletask/tests/test_models.py

@@ -2,6 +2,8 @@
 
 """Unit tests for data models (RunRequest)."""
 
+import json
+
 import pytest
 from pydantic import BaseModel
 
@@ -204,6 +206,47 @@ def test_round_trip_with_options(self) -> None:
         assert restored.options["custom"] == "value"
         assert restored.options["response_format"] is ModuleStructuredResponse
 
+    def test_to_dict_with_options_response_format_is_json_serializable(self) -> None:
+        """Ensure options response_format can cross the durable JSON boundary."""
+        request = RunRequest(
+            message="Test",
+            correlation_id="corr-opts-json",
+            options={"response_format": ModuleStructuredResponse},
+        )
+
+        data = request.to_dict()
+        encoded = json.dumps(data)
+        decoded = json.loads(encoded)
+        restored = RunRequest.from_dict(decoded)
+
+        assert data["options"]["response_format"]["__response_schema_type__"] == "pydantic_model"
+        assert restored.options["response_format"] is ModuleStructuredResponse
+
+    def test_from_dict_drops_unresolved_options_response_format_marker(self) -> None:
+        """Ensure unresolved durable markers do not block top-level response_format fallback."""
+        request = RunRequest.from_dict(
+            {
+                "message": "Test",
+                "correlationId": "corr-opts-missing",
+                "response_format": {
+                    "__response_schema_type__": "pydantic_model",
+                    "module": ModuleStructuredResponse.__module__,
+                    "qualname": ModuleStructuredResponse.__qualname__,
+                },
+                "options": {
+                    "response_format": {
+                        "__response_schema_type__": "pydantic_model",
+                        "module": "missing_module",
+                        "qualname": "MissingModel",
+                    },
+                    "custom": "value",
+                },
+            }
+        )
+
+        assert request.response_format is ModuleStructuredResponse
+        assert request.options == {"custom": "value"}
+
     def test_init_with_correlationId(self) -> None:
         """Test RunRequest initialization with correlationId."""
         request = RunRequest(message="Test message", correlation_id="corr-123")