arize-phoenix 11.38.0__py3-none-any.whl → 12.2.0__py3-none-any.whl

phoenix/server/api/context.py

@@ -23,6 +23,7 @@ from phoenix.server.api.dataloaders import (
     DatasetExampleRevisionsDataLoader,
     DatasetExamplesAndVersionsByExperimentRunDataLoader,
     DatasetExampleSpansDataLoader,
+    DatasetExampleSplitsDataLoader,
     DocumentEvaluationsDataLoader,
     DocumentEvaluationSummaryDataLoader,
     DocumentRetrievalMetricsDataLoader,
@@ -30,7 +31,6 @@ from phoenix.server.api.dataloaders import (
     ExperimentErrorRatesDataLoader,
     ExperimentRepeatedRunGroupAnnotationSummariesDataLoader,
     ExperimentRepeatedRunGroupsDataLoader,
-    ExperimentRepetitionCountsDataLoader,
     ExperimentRunAnnotations,
     ExperimentRunCountsDataLoader,
     ExperimentSequenceNumberDataLoader,
@@ -43,6 +43,7 @@ from phoenix.server.api.dataloaders import (
     ProjectIdsByTraceRetentionPolicyIdDataLoader,
     PromptVersionSequenceNumberDataLoader,
     RecordCountDataLoader,
+    SessionAnnotationsBySessionDataLoader,
     SessionIODataLoader,
     SessionNumTracesDataLoader,
     SessionNumTracesWithErrorDataLoader,
@@ -68,12 +69,14 @@ from phoenix.server.api.dataloaders import (
     SpanProjectsDataLoader,
     TableFieldsDataLoader,
     TokenCountDataLoader,
+    TraceAnnotationsByTraceDataLoader,
     TraceByTraceIdsDataLoader,
     TraceRetentionPolicyIdByProjectIdDataLoader,
     TraceRootSpansDataLoader,
     UserRolesDataLoader,
     UsersDataLoader,
 )
+from phoenix.server.api.dataloaders.dataset_labels import DatasetLabelsDataLoader
 from phoenix.server.bearer_auth import PhoenixUser
 from phoenix.server.daemons.span_cost_calculator import SpanCostCalculator
 from phoenix.server.dml_event import DmlEvent
@@ -97,9 +100,11 @@ class DataLoaders:
     average_experiment_run_latency: AverageExperimentRunLatencyDataLoader
     dataset_example_revisions: DatasetExampleRevisionsDataLoader
     dataset_example_spans: DatasetExampleSpansDataLoader
+    dataset_labels: DatasetLabelsDataLoader
     dataset_examples_and_versions_by_experiment_run: (
         DatasetExamplesAndVersionsByExperimentRunDataLoader
     )
+    dataset_example_splits: DatasetExampleSplitsDataLoader
     document_evaluation_summaries: DocumentEvaluationSummaryDataLoader
     document_evaluations: DocumentEvaluationsDataLoader
     document_retrieval_metrics: DocumentRetrievalMetricsDataLoader
@@ -109,7 +114,6 @@ class DataLoaders:
         ExperimentRepeatedRunGroupAnnotationSummariesDataLoader
     )
     experiment_repeated_run_groups: ExperimentRepeatedRunGroupsDataLoader
-    experiment_repetition_counts: ExperimentRepetitionCountsDataLoader
     experiment_run_annotations: ExperimentRunAnnotations
     experiment_run_counts: ExperimentRunCountsDataLoader
     experiment_sequence_number: ExperimentSequenceNumberDataLoader
@@ -124,6 +128,7 @@ class DataLoaders:
     projects_by_trace_retention_policy_id: ProjectIdsByTraceRetentionPolicyIdDataLoader
     prompt_version_sequence_number: PromptVersionSequenceNumberDataLoader
     record_counts: RecordCountDataLoader
+    session_annotations_by_session: SessionAnnotationsBySessionDataLoader
     session_first_inputs: SessionIODataLoader
     session_last_outputs: SessionIODataLoader
     session_num_traces: SessionNumTracesDataLoader
@@ -158,6 +163,7 @@ class DataLoaders:
     span_fields: TableFieldsDataLoader
     span_projects: SpanProjectsDataLoader
     token_counts: TokenCountDataLoader
+    trace_annotations_by_trace: TraceAnnotationsByTraceDataLoader
     trace_by_trace_ids: TraceByTraceIdsDataLoader
     trace_fields: TableFieldsDataLoader
     trace_retention_policy_id_by_project_id: TraceRetentionPolicyIdByProjectIdDataLoader
@@ -237,3 +243,10 @@ class Context(BaseContext):
     @cached_property
     def user(self) -> PhoenixUser:
         return cast(PhoenixUser, self.get_request().user)
+
+    @cached_property
+    def user_id(self) -> Optional[int]:
+        try:
+            return int(self.user.identity)
+        except Exception:
+            return None

phoenix/server/api/dataloaders/__init__.py

@@ -12,9 +12,11 @@ from .average_experiment_repeated_run_group_latency import (
 from .average_experiment_run_latency import AverageExperimentRunLatencyDataLoader
 from .dataset_example_revisions import DatasetExampleRevisionsDataLoader
 from .dataset_example_spans import DatasetExampleSpansDataLoader
+from .dataset_example_splits import DatasetExampleSplitsDataLoader
 from .dataset_examples_and_versions_by_experiment_run import (
     DatasetExamplesAndVersionsByExperimentRunDataLoader,
 )
+from .dataset_labels import DatasetLabelsDataLoader
 from .document_evaluation_summaries import (
     DocumentEvaluationSummaryCache,
     DocumentEvaluationSummaryDataLoader,
@@ -27,7 +29,6 @@ from .experiment_repeated_run_group_annotation_summaries import (
     ExperimentRepeatedRunGroupAnnotationSummariesDataLoader,
 )
 from .experiment_repeated_run_groups import ExperimentRepeatedRunGroupsDataLoader
-from .experiment_repetition_counts import ExperimentRepetitionCountsDataLoader
 from .experiment_run_annotations import ExperimentRunAnnotations
 from .experiment_run_counts import ExperimentRunCountsDataLoader
 from .experiment_sequence_number import ExperimentSequenceNumberDataLoader
@@ -40,6 +41,7 @@ from .project_by_name import ProjectByNameDataLoader
 from .project_ids_by_trace_retention_policy_id import ProjectIdsByTraceRetentionPolicyIdDataLoader
 from .prompt_version_sequence_number import PromptVersionSequenceNumberDataLoader
 from .record_counts import RecordCountCache, RecordCountDataLoader
+from .session_annotations_by_session import SessionAnnotationsBySessionDataLoader
 from .session_io import SessionIODataLoader
 from .session_num_traces import SessionNumTracesDataLoader
 from .session_num_traces_with_error import SessionNumTracesWithErrorDataLoader
@@ -69,6 +71,7 @@ from .span_descendants import SpanDescendantsDataLoader
 from .span_projects import SpanProjectsDataLoader
 from .table_fields import TableFieldsDataLoader
 from .token_counts import TokenCountCache, TokenCountDataLoader
+from .trace_annotations_by_trace import TraceAnnotationsByTraceDataLoader
 from .trace_by_trace_ids import TraceByTraceIdsDataLoader
 from .trace_retention_policy_id_by_project_id import TraceRetentionPolicyIdByProjectIdDataLoader
 from .trace_root_spans import TraceRootSpansDataLoader
@@ -84,6 +87,8 @@ __all__ = [
     "DatasetExampleRevisionsDataLoader",
     "DatasetExampleSpansDataLoader",
     "DatasetExamplesAndVersionsByExperimentRunDataLoader",
+    "DatasetExampleSplitsDataLoader",
+    "DatasetLabelsDataLoader",
     "DocumentEvaluationSummaryDataLoader",
     "DocumentEvaluationsDataLoader",
     "DocumentRetrievalMetricsDataLoader",
@@ -91,7 +96,6 @@ __all__ = [
     "ExperimentErrorRatesDataLoader",
     "ExperimentRepeatedRunGroupsDataLoader",
     "ExperimentRepeatedRunGroupAnnotationSummariesDataLoader",
-    "ExperimentRepetitionCountsDataLoader",
     "ExperimentRunAnnotations",
     "ExperimentRunCountsDataLoader",
     "ExperimentSequenceNumberDataLoader",
@@ -104,6 +108,7 @@ __all__ = [
     "ProjectIdsByTraceRetentionPolicyIdDataLoader",
     "PromptVersionSequenceNumberDataLoader",
     "RecordCountDataLoader",
+    "SessionAnnotationsBySessionDataLoader",
     "SessionIODataLoader",
     "SessionNumTracesDataLoader",
     "SessionNumTracesWithErrorDataLoader",
@@ -130,6 +135,7 @@ __all__ = [
     "SpanProjectsDataLoader",
     "TableFieldsDataLoader",
     "TokenCountDataLoader",
+    "TraceAnnotationsByTraceDataLoader",
     "TraceByTraceIdsDataLoader",
     "TraceRetentionPolicyIdByProjectIdDataLoader",
     "TraceRootSpansDataLoader",

phoenix/server/api/dataloaders/dataset_example_splits.py

@@ -0,0 +1,40 @@
+from sqlalchemy import select
+from strawberry.dataloader import DataLoader
+from typing_extensions import TypeAlias
+
+from phoenix.db import models
+from phoenix.server.types import DbSessionFactory
+
+ExampleID: TypeAlias = int
+Key: TypeAlias = ExampleID
+Result: TypeAlias = list[models.DatasetSplit]
+
+
+class DatasetExampleSplitsDataLoader(DataLoader[Key, Result]):
+    def __init__(self, db: DbSessionFactory) -> None:
+        super().__init__(
+            load_fn=self._load_fn,
+        )
+        self._db = db
+
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
+        example_ids = keys
+        async with self._db() as session:
+            splits: dict[ExampleID, list[models.DatasetSplit]] = {}
+
+            async for example_id, split in await session.stream(
+                select(models.DatasetSplitDatasetExample.dataset_example_id, models.DatasetSplit)
+                .select_from(models.DatasetSplit)
+                .join(
+                    models.DatasetSplitDatasetExample,
+                    onclause=(
+                        models.DatasetSplit.id == models.DatasetSplitDatasetExample.dataset_split_id
+                    ),
+                )
+                .where(models.DatasetSplitDatasetExample.dataset_example_id.in_(example_ids))
+            ):
+                if example_id not in splits:
+                    splits[example_id] = []
+                splits[example_id].append(split)
+
+            return [sorted(splits.get(example_id, []), key=lambda x: x.name) for example_id in keys]

phoenix/server/api/dataloaders/dataset_labels.py

@@ -0,0 +1,36 @@
+from sqlalchemy import select
+from strawberry.dataloader import DataLoader
+from typing_extensions import TypeAlias
+
+from phoenix.db import models
+from phoenix.server.types import DbSessionFactory
+
+DatasetID: TypeAlias = int
+Key: TypeAlias = DatasetID
+Result: TypeAlias = list[models.DatasetLabel]
+
+
+class DatasetLabelsDataLoader(DataLoader[Key, Result]):
+    def __init__(self, db: DbSessionFactory) -> None:
+        super().__init__(load_fn=self._load_fn)
+        self._db = db
+
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
+        dataset_ids = keys
+        async with self._db() as session:
+            labels: dict[Key, Result] = {}
+            for dataset_id, label in await session.execute(
+                select(models.DatasetsDatasetLabel.dataset_id, models.DatasetLabel)
+                .select_from(models.DatasetLabel)
+                .join(
+                    models.DatasetsDatasetLabel,
+                    models.DatasetLabel.id == models.DatasetsDatasetLabel.dataset_label_id,
+                )
+                .where(models.DatasetsDatasetLabel.dataset_id.in_(dataset_ids))
+            ):
+                if dataset_id not in labels:
+                    labels[dataset_id] = []
+                labels[dataset_id].append(label)
+        return [
+            sorted(labels.get(dataset_id, []), key=lambda label: label.name) for dataset_id in keys
+        ]

phoenix/server/api/dataloaders/session_annotations_by_session.py

@@ -0,0 +1,29 @@
+from collections import defaultdict
+
+from sqlalchemy import select
+from strawberry.dataloader import DataLoader
+from typing_extensions import TypeAlias
+
+from phoenix.db.models import ProjectSessionAnnotation
+from phoenix.server.types import DbSessionFactory
+
+ProjectSessionId: TypeAlias = int
+Key: TypeAlias = ProjectSessionId
+Result: TypeAlias = list[ProjectSessionAnnotation]
+
+
+class SessionAnnotationsBySessionDataLoader(DataLoader[Key, Result]):
+    def __init__(self, db: DbSessionFactory) -> None:
+        super().__init__(load_fn=self._load_fn)
+        self._db = db
+
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
+        annotations_by_id: defaultdict[Key, Result] = defaultdict(list)
+        async with self._db() as session:
+            async for annotation in await session.stream_scalars(
+                select(ProjectSessionAnnotation).where(
+                    ProjectSessionAnnotation.project_session_id.in_(keys)
+                )
+            ):
+                annotations_by_id[annotation.project_session_id].append(annotation)
+        return [annotations_by_id[key] for key in keys]

phoenix/server/api/dataloaders/table_fields.py

@@ -18,7 +18,7 @@ _AttrStrIdentifier: TypeAlias = str
 
 
 class TableFieldsDataLoader(DataLoader[Key, Result]):
-    def __init__(self, db: DbSessionFactory, table: type[models.Base]) -> None:
+    def __init__(self, db: DbSessionFactory, table: type[models.HasId]) -> None:
         super().__init__(load_fn=self._load_fn)
         self._db = db
         self._table = table
@@ -37,7 +37,7 @@ class TableFieldsDataLoader(DataLoader[Key, Result]):
 
 def _get_stmt(
     keys: Iterable[tuple[RowId, QueryableAttribute[Any]]],
-    table: type[models.Base],
+    table: type[models.HasId],
 ) -> tuple[
     Select[Any],
     dict[_ResultColumnPosition, _AttrStrIdentifier],

phoenix/server/api/dataloaders/trace_annotations_by_trace.py

@@ -0,0 +1,27 @@
+from collections import defaultdict
+
+from sqlalchemy import select
+from strawberry.dataloader import DataLoader
+from typing_extensions import TypeAlias
+
+from phoenix.db.models import TraceAnnotation
+from phoenix.server.types import DbSessionFactory
+
+TraceRowId: TypeAlias = int
+Key: TypeAlias = TraceRowId
+Result: TypeAlias = list[TraceAnnotation]
+
+
+class TraceAnnotationsByTraceDataLoader(DataLoader[Key, Result]):
+    def __init__(self, db: DbSessionFactory) -> None:
+        super().__init__(load_fn=self._load_fn)
+        self._db = db
+
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
+        annotations_by_id: defaultdict[Key, Result] = defaultdict(list)
+        async with self._db() as session:
+            async for annotation in await session.stream_scalars(
+                select(TraceAnnotation).where(TraceAnnotation.trace_rowid.in_(keys))
+            ):
+                annotations_by_id[annotation.trace_rowid].append(annotation)
+        return [annotations_by_id[key] for key in keys]

phoenix/server/api/helpers/playground_clients.py

@@ -1677,6 +1677,7 @@ class AnthropicStreamingClient(PlaygroundStreamingClient):
 @register_llm_client(
     provider_key=GenerativeProviderKey.ANTHROPIC,
     model_names=[
+        "claude-sonnet-4-5",
         "claude-sonnet-4-0",
         "claude-sonnet-4-20250514",
         "claude-opus-4-1",
@@ -1705,11 +1706,6 @@ class AnthropicReasoningStreamingClient(AnthropicStreamingClient):
     provider_key=GenerativeProviderKey.GOOGLE,
     model_names=[
         PROVIDER_DEFAULT,
-        "gemini-2.5-flash",
-        "gemini-2.5-flash-lite",
-        "gemini-2.5-pro",
-        "gemini-2.5-pro-preview-03-25",
-        "gemini-2.0-flash",
         "gemini-2.0-flash-lite",
         "gemini-2.0-flash-001",
         "gemini-2.0-flash-thinking-exp-01-21",
@@ -1725,7 +1721,7 @@ class GoogleStreamingClient(PlaygroundStreamingClient):
         model: GenerativeModelInput,
         credentials: Optional[list[PlaygroundClientCredential]] = None,
     ) -> None:
-        import google.generativeai as google_genai
+        import google.genai as google_genai
 
         super().__init__(model=model, credentials=credentials)
         self._attributes[LLM_PROVIDER] = OpenInferenceLLMProviderValues.GOOGLE.value
@@ -1742,12 +1738,12 @@ class GoogleStreamingClient(PlaygroundStreamingClient):
         if not api_key:
             raise BadRequest("An API key is required for Gemini models")
 
-        google_genai.configure(api_key=api_key)
+        self.client = google_genai.Client(api_key=api_key)
         self.model_name = model.name
 
     @classmethod
     def dependencies(cls) -> list[Dependency]:
-        return [Dependency(name="google-generativeai", module_name="google.generativeai")]
+        return [Dependency(name="google-genai", module_name="google.genai")]
 
     @classmethod
     def supported_invocation_parameters(cls) -> list[InvocationParameter]:
@@ -1802,28 +1798,19 @@ class GoogleStreamingClient(PlaygroundStreamingClient):
         tools: list[JSONScalarType],
         **invocation_parameters: Any,
     ) -> AsyncIterator[ChatCompletionChunk]:
-        import google.generativeai as google_genai
+        contents, system_prompt = self._build_google_messages(messages)
 
-        google_message_history, current_message, system_prompt = self._build_google_messages(
-            messages
-        )
-
-        model_args = {"model_name": self.model_name}
+        # Build config object for the new API
+        config = invocation_parameters
         if system_prompt:
-            model_args["system_instruction"] = system_prompt
-        client = google_genai.GenerativeModel(**model_args)
+            config["system_instruction"] = system_prompt
 
-        google_config = google_genai.GenerationConfig(
-            **invocation_parameters,
+        # Use the client's async models.generate_content_stream method
+        stream = await self.client.aio.models.generate_content_stream(
+            model=f"models/{self.model_name}",
+            contents=contents,
+            config=config if config else None,
         )
-        google_params = {
-            "content": current_message,
-            "generation_config": google_config,
-            "stream": True,
-        }
-
-        chat = client.start_chat(history=google_message_history)
-        stream = await chat.send_message_async(**google_params)
         async for event in stream:
             self._attributes.update(
                 {
@@ -1837,26 +1824,70 @@ class GoogleStreamingClient(PlaygroundStreamingClient):
     def _build_google_messages(
         self,
         messages: list[tuple[ChatCompletionMessageRole, str, Optional[str], Optional[list[str]]]],
-    ) -> tuple[list["ContentType"], str, str]:
-        google_message_history: list["ContentType"] = []
+    ) -> tuple[list["ContentType"], str]:
+        """Build Google messages following the standard pattern - process ALL messages."""
+        google_messages: list["ContentType"] = []
         system_prompts = []
         for role, content, _tool_call_id, _tool_calls in messages:
             if role == ChatCompletionMessageRole.USER:
-                google_message_history.append({"role": "user", "parts": content})
+                google_messages.append({"role": "user", "parts": [{"text": content}]})
             elif role == ChatCompletionMessageRole.AI:
-                google_message_history.append({"role": "model", "parts": content})
+                google_messages.append({"role": "model", "parts": [{"text": content}]})
             elif role == ChatCompletionMessageRole.SYSTEM:
                 system_prompts.append(content)
             elif role == ChatCompletionMessageRole.TOOL:
                 raise NotImplementedError
             else:
                 assert_never(role)
-        if google_message_history:
-            prompt = google_message_history.pop()["parts"]
-        else:
-            prompt = ""
 
-        return google_message_history, prompt, "\n".join(system_prompts)
+        return google_messages, "\n".join(system_prompts)
+
+
+@register_llm_client(
+    provider_key=GenerativeProviderKey.GOOGLE,
+    model_names=[
+        PROVIDER_DEFAULT,
+        "gemini-2.5-pro",
+        "gemini-2.5-flash",
+        "gemini-2.5-flash-lite",
+        "gemini-2.5-pro-preview-03-25",
+    ],
+)
+class Gemini25GoogleStreamingClient(GoogleStreamingClient):
+    @classmethod
+    def supported_invocation_parameters(cls) -> list[InvocationParameter]:
+        return [
+            BoundedFloatInvocationParameter(
+                invocation_name="temperature",
+                canonical_name=CanonicalParameterName.TEMPERATURE,
+                label="Temperature",
+                default_value=1.0,
+                min_value=0.0,
+                max_value=2.0,
+            ),
+            IntInvocationParameter(
+                invocation_name="max_output_tokens",
+                canonical_name=CanonicalParameterName.MAX_COMPLETION_TOKENS,
+                label="Max Output Tokens",
+            ),
+            StringListInvocationParameter(
+                invocation_name="stop_sequences",
+                canonical_name=CanonicalParameterName.STOP_SEQUENCES,
+                label="Stop Sequences",
+            ),
+            BoundedFloatInvocationParameter(
+                invocation_name="top_p",
+                canonical_name=CanonicalParameterName.TOP_P,
+                label="Top P",
+                default_value=1.0,
+                min_value=0.0,
+                max_value=1.0,
+            ),
+            FloatInvocationParameter(
+                invocation_name="top_k",
+                label="Top K",
+            ),
+        ]
 
 
 def initialize_playground_clients() -> None:

phoenix/server/api/helpers/playground_users.py

@@ -0,0 +1,26 @@
+from typing import (
+    Optional,
+)
+
+from starlette.requests import Request
+from strawberry import Info
+
+from phoenix.server.api.context import Context
+from phoenix.server.bearer_auth import PhoenixUser
+
+
+def get_user(info: Info[Context, None]) -> Optional[int]:
+    user_id: Optional[int] = None
+    try:
+        assert isinstance(request := info.context.request, Request)
+
+        if "user" in request.scope and isinstance((user := info.context.user), PhoenixUser):
+            user_id = int(user.identity)
+    except AssertionError:
+        # Request is not available, try to obtain user identify
+        # this will also throw an assertion error if auth is not available
+        # the finally block will continue execution returning None
+        if info.context.user.is_authenticated:
+            user_id = int(info.context.user.identity)
+    finally:
+        return user_id

phoenix/server/api/input_types/{SpanAnnotationFilter.py → AnnotationFilter.py}

@@ -1,8 +1,9 @@
-from typing import Optional
+from typing import Optional, Union
 
 import strawberry
 from strawberry import UNSET
 from strawberry.relay import GlobalID
+from typing_extensions import TypeAlias
 
 from phoenix.db import models
 from phoenix.server.api.exceptions import BadRequest
@@ -11,7 +12,7 @@ from phoenix.server.api.types.node import from_global_id_with_expected_type
 
 
 @strawberry.input
-class SpanAnnotationFilterCondition:
+class AnnotationFilterCondition:
     names: Optional[list[str]] = UNSET
     sources: Optional[list[AnnotationSource]] = UNSET
     user_ids: Optional[list[Optional[GlobalID]]] = UNSET
@@ -26,42 +27,49 @@ class SpanAnnotationFilterCondition:
 
 
 @strawberry.input
-class SpanAnnotationFilter:
-    include: Optional[SpanAnnotationFilterCondition] = UNSET
-    exclude: Optional[SpanAnnotationFilterCondition] = UNSET
+class AnnotationFilter:
+    include: Optional[AnnotationFilterCondition] = UNSET
+    exclude: Optional[AnnotationFilterCondition] = UNSET
 
     def __post_init__(self) -> None:
         if self.include is UNSET and self.exclude is UNSET:
             raise BadRequest("include and exclude cannot both be unset")
 
 
-def satisfies_filter(span_annotation: models.SpanAnnotation, filter: SpanAnnotationFilter) -> bool:
+_Annotation: TypeAlias = Union[
+    models.SpanAnnotation,
+    models.TraceAnnotation,
+    models.ProjectSessionAnnotation,
+]
+
+
+def satisfies_filter(annotation: _Annotation, filter: AnnotationFilter) -> bool:
     """
-    Returns true if the span annotation satisfies the filter and false otherwise.
+    Returns true if the annotation satisfies the filter and false otherwise.
     """
-    span_annotation_source = AnnotationSource(span_annotation.source)
+    annotation_source = AnnotationSource(annotation.source)
     if include := filter.include:
-        if include.names and span_annotation.name not in include.names:
+        if include.names and annotation.name not in include.names:
             return False
-        if include.sources and span_annotation_source not in include.sources:
+        if include.sources and annotation_source not in include.sources:
             return False
         if include.user_ids:
             user_rowids = [
                 from_global_id_with_expected_type(user_id, "User") if user_id is not None else None
                 for user_id in include.user_ids
             ]
-            if span_annotation.user_id not in user_rowids:
+            if annotation.user_id not in user_rowids:
                 return False
     if exclude := filter.exclude:
-        if exclude.names and span_annotation.name in exclude.names:
+        if exclude.names and annotation.name in exclude.names:
             return False
-        if exclude.sources and span_annotation_source in exclude.sources:
+        if exclude.sources and annotation_source in exclude.sources:
             return False
         if exclude.user_ids:
             user_rowids = [
                 from_global_id_with_expected_type(user_id, "User") if user_id is not None else None
                 for user_id in exclude.user_ids
             ]
-            if span_annotation.user_id in user_rowids:
+            if annotation.user_id in user_rowids:
                 return False
     return True

phoenix/server/api/input_types/CreateProjectSessionAnnotationInput.py

@@ -0,0 +1,37 @@
+from typing import Optional
+
+import strawberry
+from strawberry.relay import GlobalID
+from strawberry.scalars import JSON
+
+from phoenix.server.api.exceptions import BadRequest
+from phoenix.server.api.types.AnnotationSource import AnnotationSource
+from phoenix.server.api.types.AnnotatorKind import AnnotatorKind
+
+
+@strawberry.input
+class CreateProjectSessionAnnotationInput:
+    project_session_id: GlobalID
+    name: str
+    annotator_kind: AnnotatorKind = AnnotatorKind.HUMAN
+    label: Optional[str] = None
+    score: Optional[float] = None
+    explanation: Optional[str] = None
+    metadata: JSON = strawberry.field(default_factory=dict)
+    source: AnnotationSource = AnnotationSource.APP
+    identifier: Optional[str] = strawberry.UNSET
+
+    def __post_init__(self) -> None:
+        self.name = self.name.strip()
+        if isinstance(self.label, str):
+            self.label = self.label.strip()
+        if not self.label:
+            self.label = None
+        if isinstance(self.explanation, str):
+            self.explanation = self.explanation.strip()
+        if not self.explanation:
+            self.explanation = None
+        if isinstance(self.identifier, str):
+            self.identifier = self.identifier.strip()
+        if self.score is None and not self.label and not self.explanation:
+            raise BadRequest("At least one of score, label, or explanation must be not null/empty.")

phoenix/server/api/input_types/UpdateAnnotationInput.py

@@ -0,0 +1,34 @@
+from typing import Optional
+
+import strawberry
+from strawberry.relay import GlobalID
+from strawberry.scalars import JSON
+
+from phoenix.server.api.exceptions import BadRequest
+from phoenix.server.api.types.AnnotationSource import AnnotationSource
+from phoenix.server.api.types.AnnotatorKind import AnnotatorKind
+
+
+@strawberry.input
+class UpdateAnnotationInput:
+    id: GlobalID
+    name: str
+    annotator_kind: AnnotatorKind = AnnotatorKind.HUMAN
+    label: Optional[str] = None
+    score: Optional[float] = None
+    explanation: Optional[str] = None
+    metadata: JSON = strawberry.field(default_factory=dict)
+    source: AnnotationSource = AnnotationSource.APP
+
+    def __post_init__(self) -> None:
+        self.name = self.name.strip()
+        if isinstance(self.label, str):
+            self.label = self.label.strip()
+        if not self.label:
+            self.label = None
+        if isinstance(self.explanation, str):
+            self.explanation = self.explanation.strip()
+        if not self.explanation:
+            self.explanation = None
+        if self.score is None and not self.label and not self.explanation:
+            raise BadRequest("At least one of score, label, or explanation must be not null/empty.")