test(galileo): verify factory BaseStep compatibility

Author: namrataghadi-galileo

evaluators/contrib/galileo/src/agent_control_evaluator_galileo/records/factory.py

@@ -242,7 +242,10 @@ def record_from_step(
     values override only the corresponding input/output fields, preserving the
     selected evaluator payload while the unselected side comes from ``step``.
     Trace and session records require structured child context; scalar selected
-    values are never promoted into those record types.
+    values are never promoted into those record types. The result is a concrete
+    Galileo Core step model (a ``BaseStep`` subclass) that can be JSON-serialized
+    and revalidated using that subtype's schema. The factory doesn't assign
+    execution IDs or storage ownership fields.
     """
     if not isinstance(step, Step):
         raise RecordFactoryError("A complete Agent Control Step is required.")

evaluators/contrib/galileo/tests/test_records_factory.py

@@ -23,6 +23,7 @@
 from galileo_core.schemas.logging.llm import Message
 from galileo_core.schemas.logging.session import Session
 from galileo_core.schemas.logging.span import LlmSpan, RetrieverSpan, ToolSpan
+from galileo_core.schemas.logging.step import BaseStep
 from galileo_core.schemas.logging.trace import Trace
 from galileo_core.schemas.shared.content_parts import FileContentPart, TextContentPart
 from galileo_core.schemas.shared.document import Document
@@ -48,6 +49,64 @@ def test_required_galileo_core_public_exports_are_importable() -> None:
     assert all((LlmSpan, ToolSpan, RetrieverSpan, Trace, Session, Document, Message))
 
 
+def test_factory_records_are_serializable_concrete_base_steps() -> None:
+    # Given: one record of each type accepted by the Galileo factory
+    records = [
+        record_from_step(Step(type="llm", name="answer", input="question", output="answer")),
+        record_from_step(Step(type="tool", name="search", input={"query": "q"}, output="result")),
+        record_from_step(
+            Step(type="retriever", name="retrieve", input="question", output=["document"])
+        ),
+        record_from_step(
+            Step(
+                type="trace",
+                name="request",
+                input="question",
+                output="answer",
+                context={"spans": [{"type": "llm", "name": "answer", "input": "question"}]},
+            )
+        ),
+        record_from_step(
+            Step(
+                type="session",
+                name="conversation",
+                input="question",
+                context={
+                    "traces": [
+                        {
+                            "type": "trace",
+                            "name": "request",
+                            "input": "question",
+                            "spans": [{"type": "llm", "name": "answer", "input": "question"}],
+                        }
+                    ]
+                },
+            )
+        ),
+    ]
+
+    # When: each concrete Galileo step is serialized and parsed back through its own schema
+    rebuilt = [
+        type(record).model_validate(record.model_dump(mode="json", exclude_none=True))
+        for record in records
+    ]
+
+    # Then: every concrete class remains a BaseStep and keeps its discriminator and children
+    assert all(isinstance(record, BaseStep) for record in records)
+    assert all(isinstance(record, BaseStep) for record in rebuilt)
+    assert [record.type.value for record in rebuilt] == [
+        "llm",
+        "tool",
+        "retriever",
+        "trace",
+        "session",
+    ]
+    assert isinstance(rebuilt[3], Trace)
+    assert isinstance(rebuilt[4], Session)
+    assert isinstance(rebuilt[3].spans[0], LlmSpan)
+    assert isinstance(rebuilt[4].traces[0].spans[0], LlmSpan)
+
+
 def test_llm_messages_use_public_canonical_validation() -> None:
     record = record_from_step(
         Step(