arize-phoenix 12.8.0__py3-none-any.whl → 12.9.0__py3-none-any.whl

phoenix/server/api/types/ExperimentRun.py

@@ -12,10 +12,7 @@ from strawberry.types import Info
 from phoenix.db import models
 from phoenix.server.api.context import Context
 from phoenix.server.api.types.CostBreakdown import CostBreakdown
-from phoenix.server.api.types.ExperimentRunAnnotation import (
-    ExperimentRunAnnotation,
-    to_gql_experiment_run_annotation,
-)
+from phoenix.server.api.types.ExperimentRunAnnotation import ExperimentRunAnnotation
 from phoenix.server.api.types.pagination import (
     ConnectionArgs,
     CursorString,
@@ -26,23 +23,100 @@ from phoenix.server.api.types.SpanCostSummary import SpanCostSummary
 from phoenix.server.api.types.Trace import Trace
 
 if TYPE_CHECKING:
-    from phoenix.server.api.types.DatasetExample import DatasetExample
+    from .DatasetExample import DatasetExample
+    from .Trace import Trace
 
 
 @strawberry.type
 class ExperimentRun(Node):
-    id_attr: NodeID[int]
-    experiment_id: GlobalID
-    repetition_number: int
-    trace_id: Optional[str]
-    output: Optional[JSON]
-    start_time: datetime
-    end_time: datetime
-    error: Optional[str]
+    id: NodeID[int]
+    db_record: strawberry.Private[Optional[models.ExperimentRun]] = None
+
+    def __post_init__(self) -> None:
+        if self.db_record and self.id != self.db_record.id:
+            raise ValueError("ExperimentRun ID mismatch")
+
+    @strawberry.field
+    async def experiment_id(self, info: Info[Context, None]) -> GlobalID:
+        from .Experiment import Experiment
+
+        if self.db_record:
+            experiment_id = self.db_record.experiment_id
+        else:
+            experiment_id = await info.context.data_loaders.experiment_run_fields.load(
+                (self.id, models.ExperimentRun.experiment_id),
+            )
+        return GlobalID(Experiment.__name__, str(experiment_id))
+
+    @strawberry.field
+    async def repetition_number(self, info: Info[Context, None]) -> int:
+        if self.db_record:
+            val = self.db_record.repetition_number
+        else:
+            val = await info.context.data_loaders.experiment_run_fields.load(
+                (self.id, models.ExperimentRun.repetition_number),
+            )
+        return val
+
+    @strawberry.field
+    async def trace_id(self, info: Info[Context, None]) -> Optional[str]:
+        if self.db_record:
+            val = self.db_record.trace_id
+        else:
+            val = await info.context.data_loaders.experiment_run_fields.load(
+                (self.id, models.ExperimentRun.trace_id),
+            )
+        return val
+
+    @strawberry.field
+    async def output(self, info: Info[Context, None]) -> Optional[JSON]:
+        if self.db_record:
+            output_dict = self.db_record.output
+        else:
+            output_dict = await info.context.data_loaders.experiment_run_fields.load(
+                (self.id, models.ExperimentRun.output),
+            )
+        return output_dict.get("task_output") if output_dict else None
 
     @strawberry.field
-    def latency_ms(self) -> float:
-        return (self.end_time - self.start_time).total_seconds() * 1000
+    async def start_time(self, info: Info[Context, None]) -> datetime:
+        if self.db_record:
+            val = self.db_record.start_time
+        else:
+            val = await info.context.data_loaders.experiment_run_fields.load(
+                (self.id, models.ExperimentRun.start_time),
+            )
+        return val
+
+    @strawberry.field
+    async def end_time(self, info: Info[Context, None]) -> datetime:
+        if self.db_record:
+            val = self.db_record.end_time
+        else:
+            val = await info.context.data_loaders.experiment_run_fields.load(
+                (self.id, models.ExperimentRun.end_time),
+            )
+        return val
+
+    @strawberry.field
+    async def error(self, info: Info[Context, None]) -> Optional[str]:
+        if self.db_record:
+            val = self.db_record.error
+        else:
+            val = await info.context.data_loaders.experiment_run_fields.load(
+                (self.id, models.ExperimentRun.error),
+            )
+        return val
+
+    @strawberry.field
+    async def latency_ms(self, info: Info[Context, None]) -> float:
+        if self.db_record:
+            val = self.db_record.latency_ms
+        else:
+            val = await info.context.data_loaders.experiment_run_fields.load(
+                (self.id, models.ExperimentRun.latency_ms),
+            )
+        return val
 
     @strawberry.field
     async def annotations(
@@ -59,45 +133,49 @@ class ExperimentRun(Node):
             last=last,
             before=before if isinstance(before, CursorString) else None,
         )
-        run_id = self.id_attr
-        annotations = await info.context.data_loaders.experiment_run_annotations.load(run_id)
+        annotations = await info.context.data_loaders.experiment_run_annotations.load(self.id)
         return connection_from_list(
-            [to_gql_experiment_run_annotation(annotation) for annotation in annotations], args
+            [
+                ExperimentRunAnnotation(id=annotation.id, db_record=annotation)
+                for annotation in annotations
+            ],
+            args,
         )
 
     @strawberry.field
-    async def trace(self, info: Info) -> Optional[Trace]:
-        if not self.trace_id:
+    async def trace(
+        self, info: Info[Context, None]
+    ) -> Optional[Annotated["Trace", strawberry.lazy(".Trace")]]:
+        if self.db_record:
+            trace_id = self.db_record.trace_id
+        else:
+            trace_id = await info.context.data_loaders.experiment_run_fields.load(
+                (self.id, models.ExperimentRun.trace_id),
+            )
+        if not trace_id:
             return None
-        dataloader = info.context.data_loaders.trace_by_trace_ids
-        if (trace := await dataloader.load(self.trace_id)) is None:
+        loader = info.context.data_loaders.trace_by_trace_ids
+        if (trace := await loader.load(trace_id)) is None:
             return None
-        return Trace(trace_rowid=trace.id, db_trace=trace)
+        from .Trace import Trace
+
+        return Trace(id=trace.id, db_record=trace)
 
     @strawberry.field
     async def example(
-        self, info: Info
+        self, info: Info[Context, None]
     ) -> Annotated[
-        "DatasetExample", strawberry.lazy("phoenix.server.api.types.DatasetExample")
+        "DatasetExample", strawberry.lazy(".DatasetExample")
     ]:  # use lazy types to avoid circular import: https://strawberry.rocks/docs/types/lazy
-        from phoenix.server.api.types.DatasetExample import DatasetExample
+        from .DatasetExample import DatasetExample
 
-        (
-            example,
-            version_id,
-        ) = await info.context.data_loaders.dataset_examples_and_versions_by_experiment_run.load(
-            self.id_attr
-        )
-        return DatasetExample(
-            id_attr=example.id,
-            created_at=example.created_at,
-            version_id=version_id,
-        )
+        loader = info.context.data_loaders.dataset_examples_and_versions_by_experiment_run
+        (example, version_id) = await loader.load(self.id)
+        return DatasetExample(id=example.id, db_record=example, version_id=version_id)
 
     @strawberry.field
     async def cost_summary(self, info: Info[Context, None]) -> SpanCostSummary:
-        run_id = self.id_attr
-        summary = await info.context.data_loaders.span_cost_summary_by_experiment_run.load(run_id)
+        summary = await info.context.data_loaders.span_cost_summary_by_experiment_run.load(self.id)
         return SpanCostSummary(
             prompt=CostBreakdown(
                 tokens=summary.prompt.tokens,
@@ -117,8 +195,6 @@ class ExperimentRun(Node):
     async def cost_detail_summary_entries(
         self, info: Info[Context, None]
     ) -> list[SpanCostDetailSummaryEntry]:
-        run_id = self.id_attr
-
         stmt = (
             select(
                 models.SpanCostDetail.token_type,
@@ -131,7 +207,7 @@ class ExperimentRun(Node):
             .join(models.Span, models.SpanCost.span_rowid == models.Span.id)
             .join(models.Trace, models.Span.trace_rowid == models.Trace.id)
             .join(models.ExperimentRun, models.ExperimentRun.trace_id == models.Trace.trace_id)
-            .where(models.ExperimentRun.id == run_id)
+            .where(models.ExperimentRun.id == self.id)
             .group_by(models.SpanCostDetail.token_type, models.SpanCostDetail.is_prompt)
         )
 
@@ -145,22 +221,3 @@ class ExperimentRun(Node):
                 )
                 async for token_type, is_prompt, cost, tokens in data
             ]
-
-
-def to_gql_experiment_run(run: models.ExperimentRun) -> ExperimentRun:
-    """
-    Converts an ORM experiment run to a GraphQL ExperimentRun.
-    """
-
-    from phoenix.server.api.types.Experiment import Experiment
-
-    return ExperimentRun(
-        id_attr=run.id,
-        experiment_id=GlobalID(Experiment.__name__, str(run.experiment_id)),
-        repetition_number=run.repetition_number,
-        trace_id=run.trace.trace_id if run.trace else None,
-        output=run.output.get("task_output"),
-        start_time=run.start_time,
-        end_time=run.end_time,
-        error=run.error,
-    )

phoenix/server/api/types/ExperimentRunAnnotation.py

@@ -1,56 +1,175 @@
 from datetime import datetime
+from math import isfinite
 from typing import Optional
 
 import strawberry
 from strawberry import Info
-from strawberry.relay import Node, NodeID
+from strawberry.relay import GlobalID, Node, NodeID
 from strawberry.scalars import JSON
 
 from phoenix.db import models
+from phoenix.server.api.context import Context
 from phoenix.server.api.types.AnnotatorKind import ExperimentRunAnnotatorKind
 from phoenix.server.api.types.Trace import Trace
 
 
 @strawberry.type
 class ExperimentRunAnnotation(Node):
-    id_attr: NodeID[int]
-    name: str
-    annotator_kind: ExperimentRunAnnotatorKind
-    label: Optional[str]
-    score: Optional[float]
-    explanation: Optional[str]
-    error: Optional[str]
-    metadata: JSON
-    start_time: datetime
-    end_time: datetime
-    trace_id: Optional[str]
-
-    @strawberry.field
-    async def trace(self, info: Info) -> Optional[Trace]:
-        if not self.trace_id:
+    id: NodeID[int]
+    db_record: strawberry.Private[Optional[models.ExperimentRunAnnotation]] = None
+
+    def __post_init__(self) -> None:
+        if self.db_record and self.id != self.db_record.id:
+            raise ValueError("ExperimentRunAnnotation ID mismatch")
+
+    @strawberry.field(description="Name of the annotation, e.g. 'helpfulness' or 'relevance'.")  # type: ignore
+    async def name(
+        self,
+        info: Info[Context, None],
+    ) -> str:
+        if self.db_record:
+            val = self.db_record.name
+        else:
+            val = await info.context.data_loaders.experiment_run_annotation_fields.load(
+                (self.id, models.ExperimentRunAnnotation.name),
+            )
+        return val
+
+    @strawberry.field(description="The kind of annotator that produced the annotation.")  # type: ignore
+    async def annotator_kind(
+        self,
+        info: Info[Context, None],
+    ) -> ExperimentRunAnnotatorKind:
+        if self.db_record:
+            val = self.db_record.annotator_kind
+        else:
+            val = await info.context.data_loaders.experiment_run_annotation_fields.load(
+                (self.id, models.ExperimentRunAnnotation.annotator_kind),
+            )
+        return ExperimentRunAnnotatorKind(val)
+
+    @strawberry.field(
+        description="Value of the annotation in the form of a string, e.g. 'helpful' or 'not helpful'. Note that the label is not necessarily binary."  # noqa: E501
+    )  # type: ignore
+    async def label(
+        self,
+        info: Info[Context, None],
+    ) -> Optional[str]:
+        if self.db_record:
+            val = self.db_record.label
+        else:
+            val = await info.context.data_loaders.experiment_run_annotation_fields.load(
+                (self.id, models.ExperimentRunAnnotation.label),
+            )
+        return val
+
+    @strawberry.field(description="Value of the annotation in the form of a numeric score.")  # type: ignore
+    async def score(
+        self,
+        info: Info[Context, None],
+    ) -> Optional[float]:
+        if self.db_record:
+            val = self.db_record.score
+        else:
+            val = await info.context.data_loaders.experiment_run_annotation_fields.load(
+                (self.id, models.ExperimentRunAnnotation.score),
+            )
+        return val if val is not None and isfinite(val) else None
+
+    @strawberry.field(
+        description="The annotator's explanation for the annotation result (i.e. score or label, or both) given to the subject."  # noqa: E501
+    )  # type: ignore
+    async def explanation(
+        self,
+        info: Info[Context, None],
+    ) -> Optional[str]:
+        if self.db_record:
+            val = self.db_record.explanation
+        else:
+            val = await info.context.data_loaders.experiment_run_annotation_fields.load(
+                (self.id, models.ExperimentRunAnnotation.explanation),
+            )
+        return val
+
+    @strawberry.field(description="Error message if the annotation failed to produce a result.")  # type: ignore
+    async def error(
+        self,
+        info: Info[Context, None],
+    ) -> Optional[str]:
+        if self.db_record:
+            val = self.db_record.error
+        else:
+            val = await info.context.data_loaders.experiment_run_annotation_fields.load(
+                (self.id, models.ExperimentRunAnnotation.error),
+            )
+        return val
+
+    @strawberry.field(description="Metadata about the annotation.")  # type: ignore
+    async def metadata(
+        self,
+        info: Info[Context, None],
+    ) -> JSON:
+        if self.db_record:
+            val = self.db_record.metadata_
+        else:
+            val = await info.context.data_loaders.experiment_run_annotation_fields.load(
+                (self.id, models.ExperimentRunAnnotation.metadata_),
+            )
+        return val
+
+    @strawberry.field(description="The date and time when the annotation was created.")  # type: ignore
+    async def start_time(
+        self,
+        info: Info[Context, None],
+    ) -> datetime:
+        if self.db_record:
+            val = self.db_record.start_time
+        else:
+            val = await info.context.data_loaders.experiment_run_annotation_fields.load(
+                (self.id, models.ExperimentRunAnnotation.start_time),
+            )
+        return val
+
+    @strawberry.field(description="The date and time when the annotation was last updated.")  # type: ignore
+    async def end_time(
+        self,
+        info: Info[Context, None],
+    ) -> datetime:
+        if self.db_record:
+            val = self.db_record.end_time
+        else:
+            val = await info.context.data_loaders.experiment_run_annotation_fields.load(
+                (self.id, models.ExperimentRunAnnotation.end_time),
+            )
+        return val
+
+    @strawberry.field(description="The identifier of the trace associated with the annotation.")  # type: ignore
+    async def trace_id(
+        self,
+        info: Info[Context, None],
+    ) -> Optional[GlobalID]:
+        if self.db_record:
+            val = self.db_record.trace_id
+        else:
+            val = await info.context.data_loaders.experiment_run_annotation_fields.load(
+                (self.id, models.ExperimentRunAnnotation.trace_id),
+            )
+        return None if val is None else GlobalID(type_name=Trace.__name__, node_id=val)
+
+    @strawberry.field(description="The trace associated with the annotation.")  # type: ignore
+    async def trace(
+        self,
+        info: Info[Context, None],
+    ) -> Optional[Trace]:
+        if self.db_record:
+            trace_id = self.db_record.trace_id
+        else:
+            trace_id = await info.context.data_loaders.experiment_run_annotation_fields.load(
+                (self.id, models.ExperimentRunAnnotation.trace_id),
+            )
+        if not trace_id:
             return None
         dataloader = info.context.data_loaders.trace_by_trace_ids
-        if (trace := await dataloader.load(self.trace_id)) is None:
+        if (trace := await dataloader.load(trace_id)) is None:
             return None
-        return Trace(trace_rowid=trace.id, db_trace=trace)
-
-
-def to_gql_experiment_run_annotation(
-    annotation: models.ExperimentRunAnnotation,
-) -> ExperimentRunAnnotation:
-    """
-    Converts an ORM experiment run annotation to a GraphQL ExperimentRunAnnotation.
-    """
-    return ExperimentRunAnnotation(
-        id_attr=annotation.id,
-        name=annotation.name,
-        annotator_kind=ExperimentRunAnnotatorKind(annotation.annotator_kind),
-        label=annotation.label,
-        score=annotation.score,
-        explanation=annotation.explanation,
-        error=annotation.error,
-        metadata=annotation.metadata_,
-        start_time=annotation.start_time,
-        end_time=annotation.end_time,
-        trace_id=annotation.trace_id,
-    )
+        return Trace(id=trace.id, db_record=trace)

phoenix/server/api/types/GenerativeModel.py

@@ -4,7 +4,6 @@ from typing import TYPE_CHECKING, Optional
 
 import strawberry
 from openinference.semconv.trace import OpenInferenceLLMProviderValues
-from sqlalchemy import inspect
 from strawberry.relay import Node, NodeID
 from strawberry.relay.types import GlobalID
 from strawberry.types import Info
@@ -37,20 +36,98 @@ CachedCostSummaryKey: TypeAlias = tuple[Optional[ProjectId], TimeRangeKey]
 
 @strawberry.type
 class GenerativeModel(Node, ModelInterface):
-    id_attr: NodeID[int]
-    name: str
-    provider: Optional[str]
-    name_pattern: str
-    kind: GenerativeModelKind
-    created_at: datetime
-    updated_at: datetime
-    provider_key: Optional[GenerativeProviderKey]
-    costs: strawberry.Private[Optional[list[models.TokenPrice]]] = None
-    start_time: Optional[datetime] = None
+    id: NodeID[int]
+    db_record: strawberry.Private[Optional[models.GenerativeModel]] = None
     cached_cost_summary: strawberry.Private[
         Optional[dict[CachedCostSummaryKey, SpanCostSummary]]
     ] = None
 
+    def __post_init__(self) -> None:
+        if self.db_record and self.id != self.db_record.id:
+            raise ValueError("GenerativeModel ID mismatch")
+
+    @strawberry.field
+    async def name(self, info: Info[Context, None]) -> str:
+        if self.db_record:
+            val = self.db_record.name
+        else:
+            val = await info.context.data_loaders.generative_model_fields.load(
+                (self.id, models.GenerativeModel.name),
+            )
+        return val
+
+    @strawberry.field
+    async def provider(self, info: Info[Context, None]) -> Optional[str]:
+        if self.db_record:
+            provider = self.db_record.provider
+        else:
+            provider = await info.context.data_loaders.generative_model_fields.load(
+                (self.id, models.GenerativeModel.provider),
+            )
+        return provider or None
+
+    @strawberry.field
+    async def name_pattern(self, info: Info[Context, None]) -> str:
+        if self.db_record:
+            pattern = self.db_record.name_pattern.pattern
+        else:
+            name_pattern_obj = await info.context.data_loaders.generative_model_fields.load(
+                (self.id, models.GenerativeModel.name_pattern),
+            )
+            pattern = name_pattern_obj.pattern
+        assert isinstance(pattern, str)
+        return pattern
+
+    @strawberry.field
+    async def kind(self, info: Info[Context, None]) -> GenerativeModelKind:
+        if self.db_record:
+            is_built_in = self.db_record.is_built_in
+        else:
+            is_built_in = await info.context.data_loaders.generative_model_fields.load(
+                (self.id, models.GenerativeModel.is_built_in),
+            )
+        return GenerativeModelKind.BUILT_IN if is_built_in else GenerativeModelKind.CUSTOM
+
+    @strawberry.field
+    async def created_at(self, info: Info[Context, None]) -> datetime:
+        if self.db_record:
+            val = self.db_record.created_at
+        else:
+            val = await info.context.data_loaders.generative_model_fields.load(
+                (self.id, models.GenerativeModel.created_at),
+            )
+        return val
+
+    @strawberry.field
+    async def updated_at(self, info: Info[Context, None]) -> datetime:
+        if self.db_record:
+            val = self.db_record.updated_at
+        else:
+            val = await info.context.data_loaders.generative_model_fields.load(
+                (self.id, models.GenerativeModel.updated_at),
+            )
+        return val
+
+    @strawberry.field
+    async def provider_key(self, info: Info[Context, None]) -> Optional[GenerativeProviderKey]:
+        if self.db_record:
+            provider = self.db_record.provider
+        else:
+            provider = await info.context.data_loaders.generative_model_fields.load(
+                (self.id, models.GenerativeModel.provider),
+            )
+        return _semconv_provider_to_gql_generative_provider_key(provider) if provider else None
+
+    @strawberry.field
+    async def start_time(self, info: Info[Context, None]) -> Optional[datetime]:
+        if self.db_record:
+            val = self.db_record.start_time
+        else:
+            val = await info.context.data_loaders.generative_model_fields.load(
+                (self.id, models.GenerativeModel.start_time),
+            )
+        return val
+
     def add_cached_cost_summary(
         self, project_id: Optional[int], time_range: TimeRange, cost_summary: SpanCostSummary
     ) -> None:
@@ -61,11 +138,10 @@ class GenerativeModel(Node, ModelInterface):
         self.cached_cost_summary[cache_key] = cost_summary
 
     @strawberry.field
-    async def token_prices(self) -> list[TokenPrice]:
-        if self.costs is None:
-            raise NotImplementedError
-        token_prices: list[TokenPrice] = list()
-        for cost in self.costs:
+    async def token_prices(self, info: Info[Context, None]) -> list[TokenPrice]:
+        costs = await info.context.data_loaders.token_prices_by_model.load(self.id)
+        token_prices: list[TokenPrice] = []
+        for cost in costs:
             token_prices.append(
                 TokenPrice(
                     token_type=cost.token_type,
@@ -100,7 +176,7 @@ class GenerativeModel(Node, ModelInterface):
             )
 
         loader = info.context.data_loaders.span_cost_summary_by_generative_model
-        summary = await loader.load(self.id_attr)
+        summary = await loader.load(self.id)
         return SpanCostSummary(
             prompt=CostBreakdown(
                 tokens=summary.prompt.tokens,
@@ -122,7 +198,7 @@ class GenerativeModel(Node, ModelInterface):
         info: Info[Context, None],
     ) -> list[SpanCostDetailSummaryEntry]:
         loader = info.context.data_loaders.span_cost_detail_summary_entries_by_generative_model
-        summary = await loader.load(self.id_attr)
+        summary = await loader.load(self.id)
         return [
             SpanCostDetailSummaryEntry(
                 token_type=entry.token_type,
@@ -137,30 +213,7 @@ class GenerativeModel(Node, ModelInterface):
 
     @strawberry.field
     async def last_used_at(self, info: Info[Context, None]) -> Optional[datetime]:
-        model_id = self.id_attr
-        return await info.context.data_loaders.last_used_times_by_generative_model_id.load(model_id)
-
-
-def to_gql_generative_model(
-    model: models.GenerativeModel,
-) -> GenerativeModel:
-    costs_are_loaded = isinstance(inspect(model).attrs.token_prices.loaded_value, list)
-    name_pattern = model.name_pattern.pattern
-    assert isinstance(name_pattern, str)
-    return GenerativeModel(
-        id_attr=model.id,
-        name=model.name,
-        provider=model.provider or None,
-        name_pattern=name_pattern,
-        kind=GenerativeModelKind.BUILT_IN if model.is_built_in else GenerativeModelKind.CUSTOM,
-        created_at=model.created_at,
-        updated_at=model.updated_at,
-        start_time=model.start_time,
-        provider_key=_semconv_provider_to_gql_generative_provider_key(model.provider)
-        if model.provider
-        else None,
-        costs=model.token_prices if costs_are_loaded else None,
-    )
+        return await info.context.data_loaders.last_used_times_by_generative_model_id.load(self.id)
 
 
 def _semconv_provider_to_gql_generative_provider_key(

phoenix/server/api/types/ModelInterface.py

@@ -7,5 +7,10 @@ from phoenix.server.api.types.GenerativeProvider import GenerativeProviderKey
 
 @strawberry.interface
 class ModelInterface:
-    name: str
-    provider_key: Optional[GenerativeProviderKey]
+    @strawberry.field
+    async def name(self) -> str:
+        raise NotImplementedError
+
+    @strawberry.field
+    async def provider_key(self) -> Optional[GenerativeProviderKey]:
+        raise NotImplementedError

phoenix/server/api/types/PlaygroundModel.py

@@ -1,10 +1,20 @@
 import strawberry
+from strawberry.types import Info
 
+from phoenix.server.api.context import Context
 from phoenix.server.api.types.GenerativeProvider import GenerativeProviderKey
 from phoenix.server.api.types.ModelInterface import ModelInterface
 
 
 @strawberry.type
 class PlaygroundModel(ModelInterface):
-    name: str
-    provider_key: GenerativeProviderKey  # PlaygroundModel always has a provider_key
+    name_value: strawberry.Private[str]
+    provider_key_value: strawberry.Private[GenerativeProviderKey]
+
+    @strawberry.field
+    async def name(self, info: Info[Context, None]) -> str:
+        return self.name_value
+
+    @strawberry.field
+    async def provider_key(self, info: Info[Context, None]) -> GenerativeProviderKey:
+        return self.provider_key_value