arize-phoenix 11.23.1__py3-none-any.whl → 12.28.1__py3-none-any.whl

phoenix/server/api/input_types/ExperimentRunSort.py

@@ -0,0 +1,237 @@
+import operator
+from enum import Enum, auto
+from typing import Any, Optional
+
+import strawberry
+from sqlalchemy import ColumnElement, Select, and_, func, literal, or_, select, tuple_
+from sqlalchemy.sql.selectable import NamedFromClause
+from strawberry import Maybe
+from typing_extensions import assert_never
+
+from phoenix.db import models
+from phoenix.server.api.types.pagination import (
+    Cursor,
+    CursorSortColumn,
+    CursorSortColumnDataType,
+    CursorSortColumnValue,
+)
+from phoenix.server.api.types.SortDir import SortDir
+
+
+@strawberry.enum
+class ExperimentRunMetric(Enum):
+    latencyMs = auto()
+
+
+@strawberry.input(one_of=True)
+class ExperimentRunColumn:
+    metric: Maybe[ExperimentRunMetric]
+    annotation_name: Maybe[str]
+
+
+@strawberry.input(description="The sort key and direction for experiment run connections")
+class ExperimentRunSort:
+    col: ExperimentRunColumn
+    dir: SortDir
+
+
+def get_experiment_run_cursor(
+    run: models.ExperimentRun, annotation_score: Optional[float], sort: Optional[ExperimentRunSort]
+) -> Cursor:
+    sort_column: Optional[CursorSortColumn] = None
+    if sort:
+        if sort.col.metric:
+            metric = sort.col.metric.value
+            assert metric is not None
+            if metric is ExperimentRunMetric.latencyMs:
+                sort_column = CursorSortColumn(
+                    type=CursorSortColumnDataType.FLOAT,
+                    value=run.latency_ms,
+                )
+            else:
+                assert_never(metric)
+        elif sort.col.annotation_name:
+            data_type = (
+                CursorSortColumnDataType.FLOAT
+                if annotation_score is not None
+                else CursorSortColumnDataType.NULL
+            )
+            sort_column = CursorSortColumn(
+                type=data_type,
+                value=annotation_score,
+            )
+    return Cursor(rowid=run.id, sort_column=sort_column)
+
+
+def add_order_by_and_page_start_to_query(
+    query: Select[Any],
+    sort: Optional[ExperimentRunSort],
+    experiment_rowid: int,
+    after_experiment_run_rowid: Optional[int],
+    after_sort_column_value: Optional[CursorSortColumnValue] = None,
+) -> Select[Any]:
+    mean_annotation_scores: Optional[NamedFromClause] = None
+    if sort and sort.col.annotation_name:
+        annotation_name = sort.col.annotation_name.value
+        assert annotation_name is not None
+        mean_annotation_scores = _get_mean_annotation_scores_subquery(annotation_name)
+    order_by_columns = _get_order_by_columns(
+        sort=sort, experiment_rowid=experiment_rowid, mean_annotation_scores=mean_annotation_scores
+    )
+    query = query.order_by(*order_by_columns)
+    if after_experiment_run_rowid is not None:
+        query = _add_after_expression(
+            query=query,
+            sort=sort,
+            experiment_run_rowid=after_experiment_run_rowid,
+            after_sort_column_value=after_sort_column_value,
+            mean_annotation_scores=mean_annotation_scores,
+        )
+    query = _add_joins_and_selects_to_query(
+        query=query,
+        sort=sort,
+        mean_annotation_scores=mean_annotation_scores,
+    )
+    return query
+
+
+def _get_order_by_columns(
+    sort: Optional[ExperimentRunSort],
+    experiment_rowid: int,
+    mean_annotation_scores: Optional[NamedFromClause],
+) -> tuple[ColumnElement[Any], ...]:
+    if not sort:
+        # Ideally, this would sort the runs by (example_id, repetition_number),
+        # but this would require making the cursor more complex or adding an additional query
+        # to handle the after cursor.
+        return (models.ExperimentRun.id.asc(),)
+    sort_direction = sort.dir
+    if sort.col.metric:
+        metric = sort.col.metric.value
+        assert metric is not None
+        if metric is ExperimentRunMetric.latencyMs:
+            if sort_direction is SortDir.asc:
+                return (models.ExperimentRun.latency_ms.asc(), models.ExperimentRun.id.asc())
+            else:
+                return (models.ExperimentRun.latency_ms.desc(), models.ExperimentRun.id.desc())
+        else:
+            assert_never(metric)
+    elif sort.col.annotation_name:
+        annotation_name = sort.col.annotation_name.value
+        assert annotation_name is not None
+        assert mean_annotation_scores is not None
+        if sort_direction is SortDir.asc:
+            return (
+                mean_annotation_scores.c.score.asc().nulls_last(),
+                models.ExperimentRun.id.asc(),
+            )
+        else:
+            return (
+                mean_annotation_scores.c.score.desc().nulls_last(),
+                models.ExperimentRun.id.desc(),
+            )
+    raise NotImplementedError
+
+
+def _add_after_expression(
+    query: Select[Any],
+    sort: Optional[ExperimentRunSort],
+    experiment_run_rowid: int,
+    after_sort_column_value: Optional[CursorSortColumnValue],
+    mean_annotation_scores: Optional[NamedFromClause],
+) -> Select[Any]:
+    if not sort:
+        # Ideally, this would return the runs sorted by (example_id, repetition_number),
+        # but this would require making the cursor more complex or adding an additional query.
+        return query.where(models.ExperimentRun.id > literal(experiment_run_rowid))
+    sort_direction = sort.dir
+    compare_fn = operator.gt if sort_direction is SortDir.asc else operator.lt
+    if sort.col.metric:
+        metric = sort.col.metric.value
+        assert metric is not None
+        if metric is ExperimentRunMetric.latencyMs:
+            assert after_sort_column_value is not None
+            return query.where(
+                compare_fn(
+                    tuple_(models.ExperimentRun.latency_ms, models.ExperimentRun.id),
+                    tuple_(
+                        literal(after_sort_column_value),
+                        literal(experiment_run_rowid),
+                    ),
+                )
+            )
+        else:
+            assert_never(metric)
+    elif sort.col.annotation_name:
+        annotation_name = sort.col.annotation_name.value
+        assert annotation_name is not None
+        assert mean_annotation_scores is not None
+        if after_sort_column_value is None:
+            return query.where(
+                and_(
+                    compare_fn(models.ExperimentRun.id, literal(experiment_run_rowid)),
+                    mean_annotation_scores.c.score.is_(None),
+                )
+            )
+        else:
+            return query.where(
+                or_(
+                    compare_fn(
+                        tuple_(mean_annotation_scores.c.score, models.ExperimentRun.id),
+                        tuple_(
+                            literal(after_sort_column_value),
+                            literal(experiment_run_rowid),
+                        ),
+                    ),
+                    mean_annotation_scores.c.score.is_(None),
+                )
+            )
+    raise NotImplementedError
+
+
+def _get_mean_annotation_scores_subquery(annotation_name: str) -> NamedFromClause:
+    return (
+        select(
+            func.avg(models.ExperimentRunAnnotation.score).label("score"),
+            models.ExperimentRunAnnotation.experiment_run_id.label("experiment_run_id"),
+        )
+        .select_from(models.ExperimentRunAnnotation)
+        .join(
+            models.ExperimentRun,
+            models.ExperimentRunAnnotation.experiment_run_id == models.ExperimentRun.id,
+        )
+        .where(models.ExperimentRunAnnotation.name == annotation_name)
+        .group_by(models.ExperimentRunAnnotation.experiment_run_id)
+        .subquery()
+        .alias("mean_annotation_scores")
+    )
+
+
+def _add_joins_and_selects_to_query(
+    query: Select[tuple[models.ExperimentRun]],
+    sort: Optional[ExperimentRunSort],
+    mean_annotation_scores: Optional[NamedFromClause],
+) -> Select[tuple[models.ExperimentRun]]:
+    if not sort:
+        return query
+    if sort.col.metric:
+        metric = sort.col.metric.value
+        assert metric is not None
+        if metric is ExperimentRunMetric.latencyMs:
+            return query
+        else:
+            assert_never(metric)
+    elif sort.col.annotation_name:
+        annotation_name = sort.col.annotation_name.value
+        assert annotation_name is not None
+        assert mean_annotation_scores is not None
+        query = query.join(
+            mean_annotation_scores,
+            mean_annotation_scores.c.experiment_run_id == models.ExperimentRun.id,
+            isouter=True,
+        )
+        query = query.add_columns(
+            mean_annotation_scores.c.score.label("score")
+        )  # the score must be in the select so that the value can be included in the cursor
+        return query
+    raise NotImplementedError

phoenix/server/api/input_types/GenerativeModelInput.py

@@ -2,6 +2,7 @@ from typing import Optional
 
 import strawberry
 from strawberry import UNSET
+from strawberry.scalars import JSON
 
 from phoenix.server.api.types.GenerativeProvider import GenerativeProviderKey
 
@@ -19,3 +20,5 @@ class GenerativeModelInput:
     """ The API version to use for the model. """
     region: Optional[str] = UNSET
     """ The region to use for the model. """
+    custom_headers: Optional[JSON] = UNSET
+    """ Custom headers to use for the model. """

phoenix/server/api/input_types/ProjectSessionSort.py

@@ -1,8 +1,16 @@
+from dataclasses import dataclass
 from enum import Enum, auto
+from typing import Any, Optional
 
 import strawberry
+from sqlalchemy import and_, desc, func, nulls_last, select
+from sqlalchemy.orm import InstrumentedAttribute
+from sqlalchemy.sql.expression import Select
+from strawberry import UNSET
 from typing_extensions import assert_never
 
+from phoenix.db import models
+from phoenix.db.helpers import truncate_name
 from phoenix.server.api.types.pagination import CursorSortColumnDataType
 from phoenix.server.api.types.SortDir import SortDir
 
@@ -15,6 +23,29 @@ class ProjectSessionColumn(Enum):
     numTraces = auto()
     costTotal = auto()
 
+    @property
+    def column_name(self) -> str:
+        return truncate_name(f"{self.name}_project_session_sort_column")
+
+    def as_orm_expression(self, joined_table: Optional[Any] = None) -> Any:
+        expr: Any
+        if self is ProjectSessionColumn.startTime:
+            expr = models.ProjectSession.start_time
+        elif self is ProjectSessionColumn.endTime:
+            expr = models.ProjectSession.end_time
+        elif self is ProjectSessionColumn.tokenCountTotal:
+            assert joined_table is not None
+            expr = joined_table.c.key
+        elif self is ProjectSessionColumn.numTraces:
+            assert joined_table is not None
+            expr = joined_table.c.key
+        elif self is ProjectSessionColumn.costTotal:
+            assert joined_table is not None
+            expr = joined_table.c.key
+        else:
+            assert_never(self)
+        return expr.label(self.column_name)
+
     @property
     def data_type(self) -> CursorSortColumnDataType:
         if self is ProjectSessionColumn.tokenCountTotal or self is ProjectSessionColumn.numTraces:
@@ -25,8 +56,134 @@ class ProjectSessionColumn(Enum):
             return CursorSortColumnDataType.FLOAT
         assert_never(self)
 
+    def join_tables(self, stmt: Select[Any]) -> tuple[Select[Any], Any]:
+        """
+        If needed, joins tables required for the sort column.
+        """
+        if self is ProjectSessionColumn.tokenCountTotal:
+            sort_subq = (
+                select(
+                    models.Trace.project_session_rowid.label("id"),
+                    func.sum(models.Span.cumulative_llm_token_count_total).label("key"),
+                )
+                .join_from(models.Trace, models.Span)
+                .where(models.Span.parent_id.is_(None))
+                .group_by(models.Trace.project_session_rowid)
+            ).subquery()
+            stmt = stmt.join(sort_subq, models.ProjectSession.id == sort_subq.c.id)
+            return stmt, sort_subq
+        if self is ProjectSessionColumn.numTraces:
+            sort_subq = (
+                select(
+                    models.Trace.project_session_rowid.label("id"),
+                    func.count(models.Trace.id).label("key"),
+                ).group_by(models.Trace.project_session_rowid)
+            ).subquery()
+            stmt = stmt.join(sort_subq, models.ProjectSession.id == sort_subq.c.id)
+            return stmt, sort_subq
+        if self is ProjectSessionColumn.costTotal:
+            sort_subq = (
+                select(
+                    models.Trace.project_session_rowid.label("id"),
+                    func.sum(models.SpanCost.total_cost).label("key"),
+                )
+                .join_from(
+                    models.Trace,
+                    models.SpanCost,
+                    models.Trace.id == models.SpanCost.trace_rowid,
+                )
+                .group_by(models.Trace.project_session_rowid)
+            ).subquery()
+            stmt = stmt.join(sort_subq, models.ProjectSession.id == sort_subq.c.id)
+            return stmt, sort_subq
+        return stmt, None
+
+
+@strawberry.enum
+class ProjectSessionAnnoAttr(Enum):
+    score = "score"
+    label = "label"
+
+    @property
+    def column_name(self) -> str:
+        return f"{self.value}_anno_sort_column"
+
+    @property
+    def orm_expression(self) -> Any:
+        expr: InstrumentedAttribute[Any]
+        if self is ProjectSessionAnnoAttr.score:
+            expr = models.ProjectSessionAnnotation.score
+        elif self is ProjectSessionAnnoAttr.label:
+            expr = models.ProjectSessionAnnotation.label
+        else:
+            assert_never(self)
+        return expr.label(self.column_name)
+
+    @property
+    def data_type(self) -> CursorSortColumnDataType:
+        if self is ProjectSessionAnnoAttr.label:
+            return CursorSortColumnDataType.STRING
+        if self is ProjectSessionAnnoAttr.score:
+            return CursorSortColumnDataType.FLOAT
+        assert_never(self)
+
+
+@strawberry.input
+class ProjectSessionAnnoResultKey:
+    name: str
+    attr: ProjectSessionAnnoAttr
+
+
+@dataclass(frozen=True)
+class ProjectSessionSortConfig:
+    stmt: Select[Any]
+    orm_expression: Any
+    dir: SortDir
+    column_name: str
+    column_data_type: CursorSortColumnDataType
+
 
 @strawberry.input(description="The sort key and direction for ProjectSession connections.")
 class ProjectSessionSort:
-    col: ProjectSessionColumn
+    col: Optional[ProjectSessionColumn] = UNSET
+    anno_result_key: Optional[ProjectSessionAnnoResultKey] = UNSET
     dir: SortDir
+
+    def update_orm_expr(self, stmt: Select[Any]) -> ProjectSessionSortConfig:
+        if (col := self.col) and not self.anno_result_key:
+            stmt, joined_table = col.join_tables(stmt)
+            expr = col.as_orm_expression(joined_table)
+            stmt = stmt.add_columns(expr)
+            if self.dir == SortDir.desc:
+                expr = desc(expr)
+            return ProjectSessionSortConfig(
+                stmt=stmt.order_by(nulls_last(expr)),
+                orm_expression=col.as_orm_expression(joined_table),
+                dir=self.dir,
+                column_name=col.column_name,
+                column_data_type=col.data_type,
+            )
+        if (anno_result_key := self.anno_result_key) and not col:
+            anno_name = anno_result_key.name
+            anno_attr = anno_result_key.attr
+            expr = anno_result_key.attr.orm_expression
+            stmt = stmt.add_columns(expr)
+            if self.dir == SortDir.desc:
+                expr = desc(expr)
+            stmt = stmt.join(
+                models.ProjectSessionAnnotation,
+                onclause=and_(
+                    models.ProjectSessionAnnotation.project_session_id == models.ProjectSession.id,
+                    models.ProjectSessionAnnotation.name == anno_name,
+                ),
+            ).order_by(nulls_last(expr))
+            return ProjectSessionSortConfig(
+                stmt=stmt,
+                orm_expression=anno_result_key.attr.orm_expression,
+                dir=self.dir,
+                column_name=anno_attr.column_name,
+                column_data_type=anno_attr.data_type,
+            )
+        raise ValueError(
+            "Exactly one of `col` or `annoResultKey` must be specified on `ProjectSessionSort`."
+        )

phoenix/server/api/input_types/PromptVersionInput.py

@@ -1,10 +1,11 @@
 import json
-from typing import Optional, cast
+from typing import Any, Optional, Union, cast
 
 import strawberry
 from strawberry import UNSET
 from strawberry.scalars import JSON
 
+from phoenix.db import models
 from phoenix.db.types.model_provider import ModelProvider
 from phoenix.server.api.helpers.prompts.models import (
     ContentPart,
@@ -12,11 +13,15 @@ from phoenix.server.api.helpers.prompts.models import (
     PromptMessage,
     PromptMessageRole,
     PromptTemplateFormat,
+    PromptTemplateType,
     RoleConversion,
     TextContentPart,
     ToolCallContentPart,
     ToolCallFunction,
     ToolResultContentPart,
+    normalize_response_format,
+    normalize_tools,
+    validate_invocation_parameters,
 )
 
 
@@ -88,6 +93,47 @@ class ChatPromptVersionInput:
             k: v for k, v in self.invocation_parameters.items() if v is not None
         }
 
+    def to_orm_prompt_version(
+        self,
+        user_id: Optional[int],
+    ) -> models.PromptVersion:
+        tool_definitions = [tool.definition for tool in self.tools]
+        tool_choice = cast(
+            Optional[Union[str, dict[str, Any]]],
+            cast(dict[str, Any], self.invocation_parameters).pop("tool_choice", None),
+        )
+        model_provider = ModelProvider(self.model_provider)
+        tools = (
+            normalize_tools(tool_definitions, model_provider, tool_choice)
+            if tool_definitions
+            else None
+        )
+        template = to_pydantic_prompt_chat_template_v1(self.template)
+        response_format = (
+            normalize_response_format(
+                self.response_format.definition,
+                model_provider,
+            )
+            if self.response_format
+            else None
+        )
+        invocation_parameters = validate_invocation_parameters(
+            self.invocation_parameters,
+            model_provider,
+        )
+        return models.PromptVersion(
+            description=self.description,
+            user_id=user_id,
+            template_type=PromptTemplateType.CHAT,
+            template_format=self.template_format,
+            template=template,
+            invocation_parameters=invocation_parameters,
+            tools=tools,
+            response_format=response_format,
+            model_provider=ModelProvider(self.model_provider),
+            model_name=self.model_name,
+        )
+
 
 def to_pydantic_prompt_chat_template_v1(
     prompt_chat_template_input: PromptChatTemplateInput,

phoenix/server/api/input_types/SpanSort.py

@@ -11,6 +11,7 @@ from typing_extensions import assert_never
 
 import phoenix.trace.v1 as pb
 from phoenix.db import models
+from phoenix.db.helpers import truncate_name
 from phoenix.server.api.types.pagination import CursorSortColumnDataType
 from phoenix.server.api.types.SortDir import SortDir
 from phoenix.trace.schemas import SpanID
@@ -32,7 +33,7 @@ class SpanColumn(Enum):
 
     @property
     def column_name(self) -> str:
-        return f"{self.name}_span_sort_column"
+        return truncate_name(f"{self.name}_span_sort_column")
 
     def as_orm_expression(self, joined_table: Optional[Any] = None) -> Any:
         expr: Any
@@ -199,7 +200,7 @@ class SpanSort:
                     models.SpanAnnotation.span_rowid == models.Span.id,
                     models.SpanAnnotation.name == eval_name,
                 ),
-            ).order_by(expr)
+            ).order_by(nulls_last(expr))
             return SpanSortConfig(
                 stmt=stmt,
                 orm_expression=eval_result_key.attr.orm_expression,

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.")

phoenix/server/api/input_types/UserRoleInput.py

@@ -7,3 +7,4 @@ import strawberry
 class UserRoleInput(Enum):
     ADMIN = "ADMIN"
     MEMBER = "MEMBER"
+    VIEWER = "VIEWER"

phoenix/server/api/mutations/__init__.py

@@ -5,11 +5,16 @@ from phoenix.server.api.mutations.api_key_mutations import ApiKeyMutationMixin
 from phoenix.server.api.mutations.chat_mutations import (
     ChatCompletionMutationMixin,
 )
+from phoenix.server.api.mutations.dataset_label_mutations import DatasetLabelMutationMixin
 from phoenix.server.api.mutations.dataset_mutations import DatasetMutationMixin
+from phoenix.server.api.mutations.dataset_split_mutations import DatasetSplitMutationMixin
 from phoenix.server.api.mutations.experiment_mutations import ExperimentMutationMixin
 from phoenix.server.api.mutations.export_events_mutations import ExportEventsMutationMixin
 from phoenix.server.api.mutations.model_mutations import ModelMutationMixin
 from phoenix.server.api.mutations.project_mutations import ProjectMutationMixin
+from phoenix.server.api.mutations.project_session_annotations_mutations import (
+    ProjectSessionAnnotationMutationMixin,
+)
 from phoenix.server.api.mutations.project_trace_retention_policy_mutations import (
     ProjectTraceRetentionPolicyMutationMixin,
 )
@@ -27,7 +32,9 @@ class Mutation(
     AnnotationConfigMutationMixin,
     ApiKeyMutationMixin,
     ChatCompletionMutationMixin,
+    DatasetLabelMutationMixin,
     DatasetMutationMixin,
+    DatasetSplitMutationMixin,
     ExperimentMutationMixin,
     ExportEventsMutationMixin,
     ModelMutationMixin,
@@ -37,6 +44,7 @@ class Mutation(
     PromptVersionTagMutationMixin,
     PromptLabelMutationMixin,
     SpanAnnotationMutationMixin,
+    ProjectSessionAnnotationMutationMixin,
     TraceAnnotationMutationMixin,
     TraceMutationMixin,
     UserMutationMixin,

phoenix/server/api/mutations/annotation_config_mutations.py

@@ -23,7 +23,7 @@ from phoenix.db.types.annotation_configs import (
 from phoenix.db.types.annotation_configs import (
     FreeformAnnotationConfig as FreeformAnnotationConfigModel,
 )
-from phoenix.server.api.auth import IsNotReadOnly
+from phoenix.server.api.auth import IsNotReadOnly, IsNotViewer
 from phoenix.server.api.context import Context
 from phoenix.server.api.exceptions import BadRequest, Conflict, NotFound
 from phoenix.server.api.queries import Query
@@ -197,7 +197,7 @@ def _to_pydantic_freeform_annotation_config(
 
 @strawberry.type
 class AnnotationConfigMutationMixin:
-    @strawberry.mutation(permission_classes=[IsNotReadOnly])  # type: ignore[misc]
+    @strawberry.mutation(permission_classes=[IsNotReadOnly, IsNotViewer])  # type: ignore[misc]
     async def create_annotation_config(
         self,
         info: Info[Context, None],
@@ -236,7 +236,7 @@ class AnnotationConfigMutationMixin:
             annotation_config=to_gql_annotation_config(annotation_config),
         )
 
-    @strawberry.mutation(permission_classes=[IsNotReadOnly])  # type: ignore[misc]
+    @strawberry.mutation(permission_classes=[IsNotReadOnly, IsNotViewer])  # type: ignore[misc]
     async def update_annotation_config(
         self,
         info: Info[Context, None],
@@ -285,7 +285,7 @@ class AnnotationConfigMutationMixin:
             annotation_config=to_gql_annotation_config(annotation_config),
         )
 
-    @strawberry.mutation(permission_classes=[IsNotReadOnly])  # type: ignore[misc]
+    @strawberry.mutation(permission_classes=[IsNotReadOnly, IsNotViewer])  # type: ignore[misc]
     async def delete_annotation_configs(
         self,
         info: Info[Context, None],
@@ -317,7 +317,7 @@ class AnnotationConfigMutationMixin:
             ],
         )
 
-    @strawberry.mutation(permission_classes=[IsNotReadOnly])  # type: ignore[misc]
+    @strawberry.mutation(permission_classes=[IsNotReadOnly, IsNotViewer])  # type: ignore[misc]
     async def add_annotation_config_to_project(
         self,
         info: Info[Context, None],
@@ -374,10 +374,10 @@ class AnnotationConfigMutationMixin:
                 )
             return AddAnnotationConfigToProjectPayload(
                 query=Query(),
-                project=Project(project_rowid=project_id),
+                project=Project(id=project_id),
             )
 
-    @strawberry.mutation(permission_classes=[IsNotReadOnly])  # type: ignore[misc]
+    @strawberry.mutation(permission_classes=[IsNotReadOnly, IsNotViewer])  # type: ignore[misc]
     async def remove_annotation_config_from_project(
         self,
         info: Info[Context, None],
@@ -409,5 +409,5 @@ class AnnotationConfigMutationMixin:
                 raise NotFound("Could not find one or more input project annotation configs")
         return RemoveAnnotationConfigFromProjectPayload(
             query=Query(),
-            project=Project(project_rowid=project_id),
+            project=Project(id=project_id),
         )