@@ -33,7 +33,7 @@ def default(self, value: Any) -> Any:
             )
         if isinstance(value, datetime):
             if value.tzinfo is None:
-                value = value.replace(tzinfo=datetime.now().astimezone().tzinfo)
+                value = value.astimezone()
             serialized = value.isoformat()
             if value.tzinfo is not None and value.tzinfo.tzname(None) == UTC.tzname(None):
                 return serialized.replace("+00:00", "Z")
@@ -43,16 +43,14 @@ def default(self, value: Any) -> Any:
         if isinstance(value, UUID | Path):
             return str(value)
         if isinstance(value, Enum):
-            return value.value
+            return _sdk_json_value(value.value)
         if isinstance(value, bytes):
             try:
                 return value.decode("utf-8")
             except UnicodeDecodeError:
                 return "<not serializable bytes>"
         if is_dataclass(value) and not isinstance(value, type):
             return asdict(value)
-        if isinstance(value, int) and not isinstance(value, bool):
-            return value if -_MAX_SAFE_INTEGER <= value <= _MAX_SAFE_INTEGER else str(value)
         if isinstance(value, set | frozenset):
             return list(value)
         return f"<{type(value).__name__}>"
@@ -123,20 +121,20 @@ def _json_text(value: Any) -> str:
     """Return the Galileo text representation of a structured value."""
     if isinstance(value, str):
         return value
-    if value is None or isinstance(value, bool | int | float):
-        return json.dumps(value)
     return json.dumps(_sdk_json_value(value))
 
 
 def _json_compatible(value: Any) -> Any:
     """Convert models and containers into values accepted by Galileo Pydantic models."""
     if isinstance(value, BaseModel):
-        return value.model_dump(mode="python", exclude_none=True)
+        return _json_compatible(value.model_dump(mode="python", exclude_none=True))
     if isinstance(value, Mapping):
         return {key: _json_compatible(item) for key, item in value.items()}
     if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):
         return [_json_compatible(item) for item in value]
-    if isinstance(value, UUID | datetime | date | Enum):
+    if isinstance(value, set | frozenset):
+        return [_json_compatible(item) for item in value]
+    if isinstance(value, UUID | datetime | date | Enum | Path | bytes):
         return _GalileoJSONEncoder().default(value)
     return value
 
@@ -157,7 +155,7 @@ def _content_part(value: Any) -> dict[str, Any] | None:
 def _message_content(value: Any) -> Any:
     if isinstance(value, Message):
         return value.content
-    if isinstance(value, Mapping) and ("role" in value or "content" in value):
+    if isinstance(value, Mapping) and "role" in value:
         return value.get("content", "")
     return None
 
@@ -177,7 +175,7 @@ def _normalize_content_items(value: Any) -> list[dict[str, Any]] | None:
 def _message_sequence(value: Any) -> bool:
     return isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray) and all(
         isinstance(item, Message)
-        or (isinstance(item, Mapping) and ("role" in item or "content" in item))
+        or (isinstance(item, Mapping) and "role" in item)
         for item in value
     )
 
@@ -451,9 +449,7 @@ def session_output(cls, value: Any) -> Any:
             content_parts = _normalize_content_items(value)
             if content_parts is not None:
                 return content_parts
-            if all(isinstance(item, Mapping) for item in value):
-                return [_json_compatible(item) for item in value]
-            return [_json_compatible(item) for item in value]
+            return cls.json_text(value)
         return cls.json_text(value)
 
     @classmethod
 
@@ -696,6 +696,16 @@ def test_session_content_parts_are_preserved_by_input_and_output_normalizers() -
     ]
 
 
+def test_session_output_serializes_unsupported_sequences_for_core_model() -> None:
+    output = GalileoRecordNormalizer.session_output([1, 2])
+
+    assert isinstance(output, str)
+    assert output == json.dumps([1, 2])
+    assert json.loads(output) == [1, 2]
+    session = Session(input=[], output=output, traces=[])
+    assert session.output == output
+
+
 def test_record_normalizer_serializes_nested_models_uuids_and_timestamps() -> None:
     identifier = uuid4()
     timestamp = datetime(2025, 1, 2, 3, 4, 5, tzinfo=UTC)
@@ -735,6 +745,9 @@ class NestedModel(BaseModel):
         value: int
         optional: str | None = None
 
+    class NestedValuesModel(BaseModel):
+        payload: object
+
     @dataclass
     class NestedDataclass:
         identifier: object
@@ -756,21 +769,32 @@ def __init__(self) -> None:
     naive_timestamp = datetime(2025, 1, 2)
     offset_timestamp = datetime(2025, 1, 2, tzinfo=timezone(timedelta(hours=2)))
 
+    class StructuredState(Enum):
+        VALUE = {"identifier": identifier, "timestamp": utc_timestamp}
+
     assert encoder.default(NestedModel(value=3)) == {"value": 3}
     assert encoder.default(utc_timestamp) == "2025-01-02T00:00:00Z"
-    assert isinstance(encoder.default(naive_timestamp), str)
+    assert encoder.default(naive_timestamp) == naive_timestamp.astimezone().isoformat()
     assert encoder.default(offset_timestamp) == "2025-01-02T00:00:00+02:00"
     assert encoder.default(date(2025, 1, 2)) == "2025-01-02"
     assert encoder.default(identifier) == str(identifier)
     assert encoder.default(Path("folder/file.txt")) == "folder/file.txt"
     assert encoder.default(State.READY) == "ready"
+    assert json.dumps(StructuredState.VALUE, cls=_GalileoJSONEncoder) == json.dumps(
+        {"identifier": str(identifier), "timestamp": "2025-01-02T00:00:00Z"}
+    )
     assert encoder.default(b"text") == "text"
     assert encoder.default(b"\xff") == "<not serializable bytes>"
     assert encoder.default(NestedDataclass(identifier)) == {"identifier": identifier}
-    assert encoder.default(2**53) == str(2**53)
     assert encoder.default({"item"}) == ["item"]
     assert encoder.default(object()) == "<object>"
 
+    assert GalileoRecordNormalizer.json_text(42) == "42"
+    assert GalileoRecordNormalizer.json_text(2**53) == json.dumps(str(2**53))
+    assert GalileoRecordNormalizer.json_text({"large_integer": 2**53}) == json.dumps(
+        {"large_integer": str(2**53)}
+    )
+
     recursive: list[object] = []
     recursive.append(recursive)
     normalized = _sdk_json_value(
@@ -805,29 +829,52 @@ def __init__(self) -> None:
     assert _json_compatible({"values": [State.READY, date(2025, 1, 2)]}) == {
         "values": ["ready", "2025-01-02"]
     }
+    nested_values = _json_compatible(
+        {
+            "nested": {
+                "set": {b"bytes"},
+                "frozenset": frozenset({Path("nested/path")}),
+                "invalid_bytes": {b"\xff"},
+            },
+            "model": NestedValuesModel(
+                payload={"set": {b"model bytes"}, "path": Path("model/path")}
+            ),
+        }
+    )
+    assert nested_values == {
+        "nested": {
+            "set": ["bytes"],
+            "frozenset": ["nested/path"],
+            "invalid_bytes": ["<not serializable bytes>"],
+        },
+        "model": {"payload": {"set": ["model bytes"], "path": "model/path"}},
+    }
+    assert json.loads(json.dumps(nested_values)) == nested_values
 
 
 def test_normalizer_preserves_message_content_and_reports_invalid_trace_inputs() -> None:
     from agent_control_evaluator_galileo.records.normalization import (
         _flatten_message_sequence,
+        _message_content,
         _message_sequence,
         _normalize_content_items,
     )
 
     messages = [
         {"role": "user", "content": ""},
         {"role": "assistant", "content": ["plain", {"unsupported": True}]},
-        {"content": 7},
-        {},
     ]
     flattened = _flatten_message_sequence(messages)
 
     assert [part["text"] for part in flattened] == [
         "plain",
         '{"unsupported": true}',
-        "7",
     ]
     assert _message_sequence([{"role": "user", "content": "question"}])
+    assert not _message_sequence([{"content": "question"}])
+    retriever_document = {"content": "retrieved text", "metadata": {"source": "kb"}}
+    assert not _message_sequence([retriever_document])
+    assert _message_content(retriever_document) is None
     assert not _message_sequence([{"other": "field"}])
     assert _normalize_content_items("not a sequence") is None
     assert _normalize_content_items([{"invalid": True}]) is None