@@ -4,12 +4,15 @@
 Values are serialized as native Python types (not wrapped dicts).
 """
 
+import logging
 from datetime import datetime, timezone
 from typing import Any, Dict, Optional
 
 from feast.protos.feast.serving.ServingService_pb2 import GetOnlineFeaturesResponse
 from feast.protos.feast.types.Value_pb2 import Value
 
+logger = logging.getLogger(__name__)
+
 # FieldStatus enum mapping (protos/feast/serving/ServingService.proto)
 _STATUS_NAMES: Dict[int, str] = {
     0: "INVALID",
@@ -74,8 +77,12 @@ def _value_to_native(v: Value) -> Optional[Any]:
             {k: _value_to_native(vv) for k, vv in m.val.items()}
             for m in getattr(v, which).val
         ]
-    # scalar_map_val has non-string keys and is not JSON-serializable without extra work
+    # scalar_map_val has non-string keys; full conversion requires extra work and
+    # this type is not returned by standard get_online_features paths today.
     elif which == "scalar_map_val":
+        logger.warning(
+            "scalar_map_val is not yet supported by convert_response_to_dict; value will be None"
+        )
         return None
     # All simple list/set types (.val is a repeated scalar field)
     elif "_list_" in which or "_set_" in which:
 
@@ -21,6 +21,7 @@
 Related issue: https://github.com/feast-dev/feast/issues/6013
 """
 
+import json
 import time
 
 import pytest
@@ -146,7 +147,7 @@ def test_bytes_list_val(self):
         assert result == [b"\x00\x01", b"\x02\x03"]
 
     def test_unix_timestamp_list_val(self):
-        v = Value(int64_list_val=Int64List(val=[1609459200, 1609545600]))
+        v = Value(unix_timestamp_list_val=Int64List(val=[1609459200, 1609545600]))
         result = _value_to_native(v)
         assert result == [1609459200, 1609545600]
 
@@ -447,6 +448,24 @@ def test_float_val_precision_matches_message_to_dict(self):
             == standard_result["results"][0]["values"]
         )
 
+    def test_set_types_return_flat_list(self):
+        """set types (string_set_val, int64_set_val, etc.) return flat lists.
+
+        Note: proto_json.patch() does not explicitly handle _set_ types — they fall
+        through to the else branch and return the raw proto object, which MessageToDict
+        then serializes as {"val": [...]}. Our implementation normalizes these to flat
+        lists, which is more useful for API consumers and consistent with list types.
+        """
+        response = GetOnlineFeaturesResponse()
+        fv = response.results.add()
+        fv.values.append(Value(string_set_val=StringSet(val=["a", "b", "c"])))
+        fv.statuses.append(FieldStatus.PRESENT)
+
+        result = convert_response_to_dict(response)
+        values = result["results"][0]["values"]
+        assert isinstance(values[0], list), "set type should be a flat list"
+        assert set(values[0]) == {"a", "b", "c"}
+
     def test_bytes_values_match_patched_message_to_dict(self):
         """Ensure bytes serialization matches proto_json.patch() format (raw bytes)."""
         response = GetOnlineFeaturesResponse()
@@ -463,6 +482,37 @@ def test_bytes_values_match_patched_message_to_dict(self):
         )
 
 
+class TestJsonSerializability:
+    """Ensure convert_response_to_dict output is always JSON-serializable."""
+
+    def test_complex_types_are_json_serializable(self):
+        """map_val, list_val, set_val must not leave proto objects in the output."""
+        response = GetOnlineFeaturesResponse()
+        fv = response.results.add()
+
+        # map_val
+        m = Map()
+        m.val["k"].CopyFrom(Value(int64_val=1))
+        fv.values.append(Value(map_val=m))
+
+        # list_val (RepeatedValue)
+        inner = RepeatedValue()
+        inner.val.append(Value(string_val="a"))
+        fv.values.append(Value(list_val=inner))
+
+        # int64_set_val
+        fv.values.append(Value(int64_set_val=Int64Set(val=[10, 20])))
+
+        fv.statuses.extend(
+            [FieldStatus.PRESENT, FieldStatus.PRESENT, FieldStatus.PRESENT]
+        )
+
+        result = convert_response_to_dict(response)
+        # must not raise
+        serialized = json.dumps(result)
+        assert serialized  # non-empty
+
+
 class TestPerformance:
     """Performance tests to validate the optimization claim."""