arize-phoenix 4.8.1__py3-none-any.whl → 4.10.0__py3-none-any.whl

phoenix/server/api/mutations/span_annotations_mutations.py

@@ -0,0 +1,108 @@
+from typing import List, Sequence
+
+import strawberry
+from sqlalchemy import delete, insert, update
+from strawberry import UNSET
+from strawberry.types import Info
+
+from phoenix.db import models
+from phoenix.server.api.context import Context
+from phoenix.server.api.input_types.CreateSpanAnnotationsInput import CreateSpanAnnotationsInput
+from phoenix.server.api.input_types.DeleteAnnotationsInput import DeleteAnnotationsInput
+from phoenix.server.api.input_types.PatchAnnotationsInput import PatchAnnotationsInput
+from phoenix.server.api.mutations.auth import IsAuthenticated
+from phoenix.server.api.types.node import from_global_id_with_expected_type
+from phoenix.server.api.types.SpanAnnotation import SpanAnnotation, to_gql_span_annotation
+
+
+@strawberry.type
+class SpanAnnotationMutationPayload:
+    span_annotations: List[SpanAnnotation]
+
+
+@strawberry.type
+class SpanAnnotationMutationMixin:
+    @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
+    async def create_span_annotations(
+        self, info: Info[Context, None], input: List[CreateSpanAnnotationsInput]
+    ) -> SpanAnnotationMutationPayload:
+        inserted_annotations: Sequence[models.SpanAnnotation] = []
+        async with info.context.db() as session:
+            values_list = [
+                dict(
+                    span_rowid=from_global_id_with_expected_type(annotation.span_id, "Span"),
+                    name=annotation.name,
+                    label=annotation.label,
+                    score=annotation.score,
+                    explanation=annotation.explanation,
+                    annotator_kind=annotation.annotator_kind,
+                    metadata_=annotation.metadata,
+                )
+                for annotation in input
+            ]
+            stmt = (
+                insert(models.SpanAnnotation).values(values_list).returning(models.SpanAnnotation)
+            )
+            result = await session.scalars(stmt)
+            inserted_annotations = result.all()
+
+        return SpanAnnotationMutationPayload(
+            span_annotations=[
+                to_gql_span_annotation(annotation) for annotation in inserted_annotations
+            ]
+        )
+
+    @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
+    async def patch_span_annotations(
+        self, info: Info[Context, None], input: List[PatchAnnotationsInput]
+    ) -> SpanAnnotationMutationPayload:
+        patched_annotations = []
+        async with info.context.db() as session:
+            for annotation in input:
+                span_annotation_id = from_global_id_with_expected_type(
+                    annotation.annotation_id, "SpanAnnotation"
+                )
+                patch = {
+                    column.key: patch_value
+                    for column, patch_value, column_is_nullable in (
+                        (models.SpanAnnotation.name, annotation.name, False),
+                        (models.SpanAnnotation.annotator_kind, annotation.annotator_kind, False),
+                        (models.SpanAnnotation.label, annotation.label, True),
+                        (models.SpanAnnotation.score, annotation.score, True),
+                        (models.SpanAnnotation.explanation, annotation.explanation, True),
+                        (models.SpanAnnotation.metadata_, annotation.metadata, False),
+                    )
+                    if patch_value is not UNSET and (patch_value is not None or column_is_nullable)
+                }
+                span_annotation = await session.scalar(
+                    update(models.SpanAnnotation)
+                    .where(models.SpanAnnotation.id == span_annotation_id)
+                    .values(**patch)
+                    .returning(models.SpanAnnotation)
+                )
+                if span_annotation is not None:
+                    patched_annotations.append(to_gql_span_annotation(span_annotation))
+
+        return SpanAnnotationMutationPayload(span_annotations=patched_annotations)
+
+    @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
+    async def delete_span_annotations(
+        self, info: Info[Context, None], input: DeleteAnnotationsInput
+    ) -> SpanAnnotationMutationPayload:
+        span_annotation_ids = [
+            from_global_id_with_expected_type(global_id, "SpanAnnotation")
+            for global_id in input.annotation_ids
+        ]
+        async with info.context.db() as session:
+            stmt = (
+                delete(models.SpanAnnotation)
+                .where(models.SpanAnnotation.id.in_(span_annotation_ids))
+                .returning(models.SpanAnnotation)
+            )
+            result = await session.scalars(stmt)
+            deleted_annotations = result.all()
+
+            deleted_annotations_gql = [
+                to_gql_span_annotation(annotation) for annotation in deleted_annotations
+            ]
+        return SpanAnnotationMutationPayload(span_annotations=deleted_annotations_gql)

phoenix/server/api/mutations/trace_annotations_mutations.py

@@ -0,0 +1,108 @@
+from typing import List, Sequence
+
+import strawberry
+from sqlalchemy import delete, insert, update
+from strawberry import UNSET
+from strawberry.types import Info
+
+from phoenix.db import models
+from phoenix.server.api.context import Context
+from phoenix.server.api.input_types.CreateTraceAnnotationsInput import CreateTraceAnnotationsInput
+from phoenix.server.api.input_types.DeleteAnnotationsInput import DeleteAnnotationsInput
+from phoenix.server.api.input_types.PatchAnnotationsInput import PatchAnnotationsInput
+from phoenix.server.api.mutations.auth import IsAuthenticated
+from phoenix.server.api.types.node import from_global_id_with_expected_type
+from phoenix.server.api.types.TraceAnnotation import TraceAnnotation, to_gql_trace_annotation
+
+
+@strawberry.type
+class TraceAnnotationMutationPayload:
+    trace_annotations: List[TraceAnnotation]
+
+
+@strawberry.type
+class TraceAnnotationMutationMixin:
+    @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
+    async def create_trace_annotations(
+        self, info: Info[Context, None], input: List[CreateTraceAnnotationsInput]
+    ) -> TraceAnnotationMutationPayload:
+        inserted_annotations: Sequence[models.TraceAnnotation] = []
+        async with info.context.db() as session:
+            values_list = [
+                dict(
+                    trace_rowid=from_global_id_with_expected_type(annotation.trace_id, "Trace"),
+                    name=annotation.name,
+                    label=annotation.label,
+                    score=annotation.score,
+                    explanation=annotation.explanation,
+                    annotator_kind=annotation.annotator_kind,
+                    metadata_=annotation.metadata,
+                )
+                for annotation in input
+            ]
+            stmt = (
+                insert(models.TraceAnnotation).values(values_list).returning(models.TraceAnnotation)
+            )
+            result = await session.scalars(stmt)
+            inserted_annotations = result.all()
+
+        return TraceAnnotationMutationPayload(
+            trace_annotations=[
+                to_gql_trace_annotation(annotation) for annotation in inserted_annotations
+            ]
+        )
+
+    @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
+    async def patch_trace_annotations(
+        self, info: Info[Context, None], input: List[PatchAnnotationsInput]
+    ) -> TraceAnnotationMutationPayload:
+        patched_annotations = []
+        async with info.context.db() as session:
+            for annotation in input:
+                trace_annotation_id = from_global_id_with_expected_type(
+                    annotation.annotation_id, "TraceAnnotation"
+                )
+                patch = {
+                    column.key: patch_value
+                    for column, patch_value, column_is_nullable in (
+                        (models.TraceAnnotation.name, annotation.name, False),
+                        (models.TraceAnnotation.annotator_kind, annotation.annotator_kind, False),
+                        (models.TraceAnnotation.label, annotation.label, True),
+                        (models.TraceAnnotation.score, annotation.score, True),
+                        (models.TraceAnnotation.explanation, annotation.explanation, True),
+                        (models.TraceAnnotation.metadata_, annotation.metadata, False),
+                    )
+                    if patch_value is not UNSET and (patch_value is not None or column_is_nullable)
+                }
+                trace_annotation = await session.scalar(
+                    update(models.TraceAnnotation)
+                    .where(models.TraceAnnotation.id == trace_annotation_id)
+                    .values(**patch)
+                    .returning(models.TraceAnnotation)
+                )
+                if trace_annotation:
+                    patched_annotations.append(to_gql_trace_annotation(trace_annotation))
+
+        return TraceAnnotationMutationPayload(trace_annotations=patched_annotations)
+
+    @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
+    async def delete_trace_annotations(
+        self, info: Info[Context, None], input: DeleteAnnotationsInput
+    ) -> TraceAnnotationMutationPayload:
+        trace_annotation_ids = [
+            from_global_id_with_expected_type(global_id, "TraceAnnotation")
+            for global_id in input.annotation_ids
+        ]
+        async with info.context.db() as session:
+            stmt = (
+                delete(models.TraceAnnotation)
+                .where(models.TraceAnnotation.id.in_(trace_annotation_ids))
+                .returning(models.TraceAnnotation)
+            )
+            result = await session.scalars(stmt)
+            deleted_annotations = result.all()
+
+            deleted_annotations_gql = [
+                to_gql_trace_annotation(annotation) for annotation in deleted_annotations
+            ]
+        return TraceAnnotationMutationPayload(trace_annotations=deleted_annotations_gql)

phoenix/server/api/queries.py

@@ -92,6 +92,7 @@ class Query:
                 models.Project.name == models.Experiment.project_name,
             )
             .where(models.Experiment.project_name.is_(None))
+            .order_by(models.Project.id)
         )
         async with info.context.db() as session:
             projects = await session.stream_scalars(stmt)

phoenix/server/api/routers/v1/__init__.py

@@ -40,8 +40,10 @@ V1_ROUTES = [
     Route("/v1/evaluations", evaluations.post_evaluations, methods=["POST"]),
     Route("/v1/evaluations", evaluations.get_evaluations, methods=["GET"]),
     Route("/v1/traces", traces.post_traces, methods=["POST"]),
+    Route("/v1/trace_annotations", traces.annotate_traces, methods=["POST"]),
     Route("/v1/spans", spans.query_spans_handler, methods=["POST"]),
     Route("/v1/spans", spans.get_spans_handler, methods=["GET"]),
+    Route("/v1/span_annotations", spans.annotate_spans, methods=["POST"]),
     Route("/v1/datasets/upload", datasets.post_datasets_upload, methods=["POST"]),
     Route("/v1/datasets", datasets.list_datasets, methods=["GET"]),
     Route("/v1/datasets/{id:str}", datasets.delete_dataset_by_id, methods=["DELETE"]),

phoenix/server/api/routers/v1/experiment_evaluations.py

@@ -7,7 +7,7 @@ from strawberry.relay import GlobalID
 
 from phoenix.db import models
 from phoenix.db.helpers import SupportedSQLDialect
-from phoenix.db.insertion.helpers import OnConflict, insert_on_conflict
+from phoenix.db.insertion.helpers import insert_on_conflict
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 
 
@@ -123,20 +123,13 @@ async def upsert_experiment_evaluation(request: Request) -> Response:
             end_time=datetime.fromisoformat(end_time),
             trace_id=payload.get("trace_id"),
         )
-        set_ = {
-            **{k: v for k, v in values.items() if k != "metadata_"},
-            "metadata": values["metadata_"],  # `metadata` must match database
-        }
         dialect = SupportedSQLDialect(session.bind.dialect.name)
         exp_eval_run = await session.scalar(
             insert_on_conflict(
+                values,
                 dialect=dialect,
                 table=models.ExperimentRunAnnotation,
-                values=values,
-                constraint="uq_experiment_run_annotations_experiment_run_id_name",
-                column_names=("experiment_run_id", "name"),
-                on_conflict=OnConflict.DO_UPDATE,
-                set_=set_,
+                unique_by=("experiment_run_id", "name"),
             ).returning(models.ExperimentRunAnnotation)
         )
     evaluation_gid = GlobalID("ExperimentEvaluation", str(exp_eval_run.id))

phoenix/server/api/routers/v1/experiments.py

@@ -180,16 +180,15 @@ async def create_experiment(request: Request) -> Response:
         dialect = SupportedSQLDialect(session.bind.dialect.name)
         project_rowid = await session.scalar(
             insert_on_conflict(
-                dialect=dialect,
-                table=models.Project,
-                constraint="uq_projects_name",
-                column_names=("name",),
-                values=dict(
+                dict(
                     name=project_name,
                     description=project_description,
                     created_at=experiment.created_at,
                     updated_at=experiment.updated_at,
                 ),
+                dialect=dialect,
+                table=models.Project,
+                unique_by=("name",),
             ).returning(models.Project.id)
         )
         assert project_rowid is not None

phoenix/server/api/routers/v1/spans.py

@@ -1,13 +1,19 @@
 from datetime import timezone
-from typing import AsyncIterator
+from typing import Any, AsyncIterator, Dict, List
 
+from sqlalchemy import select
 from starlette.requests import Request
-from starlette.responses import Response, StreamingResponse
+from starlette.responses import JSONResponse, Response, StreamingResponse
 from starlette.status import HTTP_404_NOT_FOUND, HTTP_422_UNPROCESSABLE_ENTITY
+from strawberry.relay import GlobalID
 
 from phoenix.config import DEFAULT_PROJECT_NAME
 from phoenix.datetime_utils import normalize_datetime
+from phoenix.db import models
+from phoenix.db.helpers import SupportedSQLDialect
+from phoenix.db.insertion.helpers import insert_on_conflict
 from phoenix.server.api.routers.utils import df_to_bytes, from_iso_format
+from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.trace.dsl import SpanQuery
 
 DEFAULT_SPAN_LIMIT = 1000
@@ -128,3 +134,142 @@ async def query_spans_handler(request: Request) -> Response:
 
 async def get_spans_handler(request: Request) -> Response:
     return await query_spans_handler(request)
+
+
+async def annotate_spans(request: Request) -> Response:
+    """
+    summary: Upsert annotations for spans
+    operationId: annotateSpans
+    tags:
+      - private
+    requestBody:
+      description: List of span annotations to be inserted
+      required: true
+      content:
+        application/json:
+          schema:
+            type: object
+            properties:
+              data:
+                type: array
+                items:
+                  type: object
+                  properties:
+                    span_id:
+                      type: string
+                      description: The ID of the span being annotated
+                    name:
+                      type: string
+                      description: The name of the annotation
+                    annotator_kind:
+                      type: string
+                      description: The kind of annotator used for the annotation ("LLM" or "HUMAN")
+                    result:
+                      type: object
+                      description: The result of the annotation
+                      properties:
+                        label:
+                          type: string
+                          description: The label assigned by the annotation
+                        score:
+                          type: number
+                          format: float
+                          description: The score assigned by the annotation
+                        explanation:
+                          type: string
+                          description: Explanation of the annotation result
+                    error:
+                      type: string
+                      description: Optional error message if the annotation encountered an error
+                    metadata:
+                      type: object
+                      description: Metadata for the annotation
+                      additionalProperties:
+                        type: string
+                  required:
+                    - span_id
+                    - name
+                    - annotator_kind
+    responses:
+      200:
+        description: Span annotations inserted successfully
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                data:
+                  type: array
+                  items:
+                    type: object
+                    properties:
+                      id:
+                        type: string
+                        description: The ID of the inserted span annotation
+      404:
+        description: Span not found
+    """
+    payload: List[Dict[str, Any]] = (await request.json()).get("data", [])
+    span_gids = [GlobalID.from_id(annotation["span_id"]) for annotation in payload]
+
+    resolved_span_ids = []
+    for span_gid in span_gids:
+        try:
+            resolved_span_ids.append(from_global_id_with_expected_type(span_gid, "Span"))
+        except ValueError:
+            return Response(
+                content="Span with ID {span_gid} does not exist",
+                status_code=HTTP_404_NOT_FOUND,
+            )
+
+    async with request.app.state.db() as session:
+        spans = await session.execute(
+            select(models.Span).filter(models.Span.id.in_(resolved_span_ids))
+        )
+        existing_span_ids = {span.id for span in spans.scalars()}
+
+        missing_span_ids = set(resolved_span_ids) - existing_span_ids
+        if missing_span_ids:
+            missing_span_gids = [
+                str(GlobalID("Span", str(span_gid))) for span_gid in missing_span_ids
+            ]
+            return Response(
+                content=f"Spans with IDs {', '.join(missing_span_gids)} do not exist.",
+                status_code=HTTP_404_NOT_FOUND,
+            )
+
+        inserted_annotations = []
+        for annotation in payload:
+            span_gid = GlobalID.from_id(annotation["span_id"])
+            span_id = from_global_id_with_expected_type(span_gid, "Span")
+            name = annotation["name"]
+            annotator_kind = annotation["annotator_kind"]
+            result = annotation.get("result")
+            label = result.get("label") if result else None
+            score = result.get("score") if result else None
+            explanation = result.get("explanation") if result else None
+            metadata = annotation.get("metadata") or {}
+
+            values = dict(
+                span_rowid=span_id,
+                name=name,
+                label=label,
+                score=score,
+                explanation=explanation,
+                annotator_kind=annotator_kind,
+                metadata_=metadata,
+            )
+            dialect = SupportedSQLDialect(session.bind.dialect.name)
+            span_annotation_id = await session.scalar(
+                insert_on_conflict(
+                    values,
+                    dialect=dialect,
+                    table=models.SpanAnnotation,
+                    unique_by=("name", "span_rowid"),
+                ).returning(models.SpanAnnotation.id)
+            )
+            inserted_annotations.append(
+                {"id": str(GlobalID("SpanAnnotation", str(span_annotation_id)))}
+            )
+
+    return JSONResponse(content={"data": inserted_annotations})

phoenix/server/api/routers/v1/traces.py

@@ -1,20 +1,28 @@
 import gzip
 import zlib
+from typing import Any, Dict, List
 
 from google.protobuf.message import DecodeError
 from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import (
     ExportTraceServiceRequest,
 )
+from sqlalchemy import select
 from starlette.background import BackgroundTask
 from starlette.concurrency import run_in_threadpool
 from starlette.datastructures import State
 from starlette.requests import Request
-from starlette.responses import Response
+from starlette.responses import JSONResponse, Response
 from starlette.status import (
+    HTTP_404_NOT_FOUND,
     HTTP_415_UNSUPPORTED_MEDIA_TYPE,
     HTTP_422_UNPROCESSABLE_ENTITY,
 )
+from strawberry.relay import GlobalID
 
+from phoenix.db import models
+from phoenix.db.helpers import SupportedSQLDialect
+from phoenix.db.insertion.helpers import insert_on_conflict
+from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.trace.otel import decode_otlp_span
 from phoenix.utilities.project import get_project_name
 
@@ -70,6 +78,147 @@ async def post_traces(request: Request) -> Response:
     return Response(background=BackgroundTask(_add_spans, req, request.state))
 
 
+async def annotate_traces(request: Request) -> Response:
+    """
+    summary: Upsert annotations for traces
+    operationId: annotateTraces
+    tags:
+      - private
+    requestBody:
+      description: List of trace annotations to be inserted
+      required: true
+      content:
+        application/json:
+          schema:
+            type: object
+            properties:
+              data:
+                type: array
+                items:
+                  type: object
+                  properties:
+                    trace_id:
+                      type: string
+                      description: The ID of the trace being annotated
+                    name:
+                      type: string
+                      description: The name of the annotation
+                    annotator_kind:
+                      type: string
+                      description: The kind of annotator used for the annotation ("LLM" or "HUMAN")
+                    result:
+                      type: object
+                      description: The result of the annotation
+                      properties:
+                        label:
+                          type: string
+                          description: The label assigned by the annotation
+                        score:
+                          type: number
+                          format: float
+                          description: The score assigned by the annotation
+                        explanation:
+                          type: string
+                          description: Explanation of the annotation result
+                    error:
+                      type: string
+                      description: Optional error message if the annotation encountered an error
+                    metadata:
+                      type: object
+                      description: Metadata for the annotation
+                      additionalProperties:
+                        type: string
+                  required:
+                    - trace_id
+                    - name
+                    - annotator_kind
+    responses:
+      200:
+        description: Trace annotations inserted successfully
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                data:
+                  type: array
+                  items:
+                    type: object
+                    properties:
+                      id:
+                        type: string
+                        description: The ID of the inserted trace annotation
+      404:
+        description: Trace not found
+    """
+    payload: List[Dict[str, Any]] = (await request.json()).get("data", [])
+    trace_gids = [GlobalID.from_id(annotation["trace_id"]) for annotation in payload]
+
+    resolved_trace_ids = []
+    for trace_gid in trace_gids:
+        try:
+            resolved_trace_ids.append(from_global_id_with_expected_type(trace_gid, "Trace"))
+        except ValueError:
+            return Response(
+                content="Trace with ID {trace_gid} does not exist",
+                status_code=HTTP_404_NOT_FOUND,
+            )
+
+    async with request.app.state.db() as session:
+        traces = await session.execute(
+            select(models.Trace).filter(models.Trace.id.in_(resolved_trace_ids))
+        )
+        existing_trace_ids = {trace.id for trace in traces.scalars()}
+
+        missing_trace_ids = set(resolved_trace_ids) - existing_trace_ids
+        if missing_trace_ids:
+            missing_trace_gids = [
+                str(GlobalID("Trace", str(trace_gid))) for trace_gid in missing_trace_ids
+            ]
+            return Response(
+                content=f"Traces with IDs {', '.join(missing_trace_gids)} do not exist.",
+                status_code=HTTP_404_NOT_FOUND,
+            )
+
+        inserted_annotations = []
+
+        for annotation in payload:
+            trace_gid = GlobalID.from_id(annotation["trace_id"])
+            trace_id = from_global_id_with_expected_type(trace_gid, "Trace")
+
+            name = annotation["name"]
+            annotator_kind = annotation["annotator_kind"]
+            result = annotation.get("result")
+            label = result.get("label") if result else None
+            score = result.get("score") if result else None
+            explanation = result.get("explanation") if result else None
+            metadata = annotation.get("metadata") or {}
+
+            values = dict(
+                trace_rowid=trace_id,
+                name=name,
+                label=label,
+                score=score,
+                explanation=explanation,
+                annotator_kind=annotator_kind,
+                metadata_=metadata,
+            )
+            dialect = SupportedSQLDialect(session.bind.dialect.name)
+            trace_annotation_id = await session.scalar(
+                insert_on_conflict(
+                    values,
+                    dialect=dialect,
+                    table=models.TraceAnnotation,
+                    unique_by=("name", "trace_rowid"),
+                ).returning(models.TraceAnnotation.id)
+            )
+            inserted_annotations.append(
+                {"id": str(GlobalID("TraceAnnotation", str(trace_annotation_id)))}
+            )
+
+    return JSONResponse(content={"data": inserted_annotations})
+
+
 async def _add_spans(req: ExportTraceServiceRequest, state: State) -> None:
     for resource_spans in req.resource_spans:
         project_name = get_project_name(resource_spans.resource.attributes)

phoenix/server/api/types/AnnotatorKind.py

@@ -4,7 +4,13 @@ import strawberry
 
 
 @strawberry.enum
-class AnnotatorKind(Enum):
+class ExperimentRunAnnotatorKind(Enum):
     LLM = "LLM"
     HUMAN = "HUMAN"
     CODE = "CODE"
+
+
+@strawberry.enum
+class AnnotatorKind(Enum):
+    LLM = "LLM"
+    HUMAN = "HUMAN"

phoenix/server/api/types/ExperimentRunAnnotation.py

@@ -7,7 +7,7 @@ from strawberry.relay import Node, NodeID
 from strawberry.scalars import JSON
 
 from phoenix.db import models
-from phoenix.server.api.types.AnnotatorKind import AnnotatorKind
+from phoenix.server.api.types.AnnotatorKind import ExperimentRunAnnotatorKind
 from phoenix.server.api.types.Trace import Trace
 
 
@@ -15,7 +15,7 @@ from phoenix.server.api.types.Trace import Trace
 class ExperimentRunAnnotation(Node):
     id_attr: NodeID[int]
     name: str
-    annotator_kind: AnnotatorKind
+    annotator_kind: ExperimentRunAnnotatorKind
     label: Optional[str]
     score: Optional[float]
     explanation: Optional[str]
@@ -45,7 +45,7 @@ def to_gql_experiment_run_annotation(
     return ExperimentRunAnnotation(
         id_attr=annotation.id,
         name=annotation.name,
-        annotator_kind=AnnotatorKind(annotation.annotator_kind),
+        annotator_kind=ExperimentRunAnnotatorKind(annotation.annotator_kind),
         label=annotation.label,
         score=annotation.score,
         explanation=annotation.explanation,