arize-phoenix 7.12.3__py3-none-any.whl → 8.0.1__py3-none-any.whl

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

@@ -9,6 +9,7 @@ from .evaluations import router as evaluations_router
 from .experiment_evaluations import router as experiment_evaluations_router
 from .experiment_runs import router as experiment_runs_router
 from .experiments import router as experiments_router
+from .prompts import router as prompts_router
 from .spans import router as spans_router
 from .traces import router as traces_router
 from .utils import add_errors_to_responses
@@ -61,4 +62,5 @@ def create_v1_router(authentication_enabled: bool) -> APIRouter:
     router.include_router(traces_router)
     router.include_router(spans_router)
     router.include_router(evaluations_router)
+    router.include_router(prompts_router)
     return router

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

@@ -48,7 +48,7 @@ from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.api.utils import delete_projects, delete_traces
 from phoenix.server.dml_event import DatasetInsertEvent
 
-from .pydantic_compat import V1RoutesBaseModel
+from .models import V1RoutesBaseModel
 from .utils import (
     PaginatedResponseBody,
     ResponseBody,

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

@@ -13,7 +13,7 @@ from phoenix.db.insertion.helpers import insert_on_conflict
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.dml_event import ExperimentRunAnnotationInsertEvent
 
-from .pydantic_compat import V1RoutesBaseModel
+from .models import V1RoutesBaseModel
 from .utils import ResponseBody, add_errors_to_responses
 
 router = APIRouter(tags=["experiments"], include_in_schema=False)

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

@@ -13,7 +13,7 @@ from phoenix.db.models import ExperimentRunOutput
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.dml_event import ExperimentRunInsertEvent
 
-from .pydantic_compat import V1RoutesBaseModel
+from .models import V1RoutesBaseModel
 from .utils import ResponseBody, add_errors_to_responses
 
 router = APIRouter(tags=["experiments"], include_in_schema=False)

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

@@ -15,7 +15,7 @@ from phoenix.db.insertion.helpers import insert_on_conflict
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.dml_event import ExperimentInsertEvent
 
-from .pydantic_compat import V1RoutesBaseModel
+from .models import V1RoutesBaseModel
 from .utils import ResponseBody, add_errors_to_responses
 
 router = APIRouter(tags=["experiments"], include_in_schema=True)

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

@@ -0,0 +1,45 @@
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict
+
+
+def datetime_encoder(dt: datetime) -> str:
+    """
+    Encodes a `datetime` object to an ISO-formatted timestamp string.
+
+    By default, Pydantic v2 serializes `datetime` objects in a format that
+    cannot be parsed by `datetime.fromisoformat`. Adding this encoder to the
+    `json_encoders` config for a Pydantic model ensures that the serialized
+    `datetime` objects are parseable.
+    """
+    return dt.isoformat()
+
+
+# `json_encoders` is a configuration setting from Pydantic v1 that was
+# removed in Pydantic v2.0.* but restored in Pydantic v2.1.0 with a
+# deprecation warning. At this time, it remains the simplest way to
+# configure custom JSON serialization for specific data types.
+#
+# For details, see:
+# - https://github.com/pydantic/pydantic/pull/6811
+# - https://github.com/pydantic/pydantic/releases/tag/v2.1.0
+#
+# The assertion below is added in case a future release of Pydantic v2 fully
+# removes the `json_encoders` parameter.
+assert "json_encoders" in ConfigDict.__annotations__, (
+    "If you encounter this error with `pydantic<2.1.0`, "
+    "please upgrade `pydantic` with `pip install -U pydantic>=2.1.0`. "
+    "If you encounter this error with `pydantic>=2.1.0`, "
+    "please upgrade `arize-phoenix` with `pip install -U arize-phoenix`, "
+    "or downgrade `pydantic` to a version that supports the `json_encoders` config setting."
+)
+
+
+class V1RoutesBaseModel(BaseModel):
+    model_config = ConfigDict(
+        json_encoders={datetime: datetime_encoder},
+        validate_assignment=True,
+        protected_namespaces=tuple(
+            []
+        ),  # suppress warnings about protected namespaces starting with `model_` on pydantic 2.9
+    )

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

@@ -0,0 +1,415 @@
+import logging
+from typing import Any, Optional, Union
+
+from fastapi import APIRouter, HTTPException, Path, Query
+from pydantic import ValidationError
+from sqlalchemy import select
+from sqlalchemy.sql import Select
+from starlette.requests import Request
+from starlette.status import HTTP_404_NOT_FOUND, HTTP_422_UNPROCESSABLE_ENTITY
+from strawberry.relay import GlobalID
+from typing_extensions import TypeAlias, assert_never
+
+from phoenix.db import models
+from phoenix.db.types.identifier import Identifier
+from phoenix.db.types.model_provider import ModelProvider
+from phoenix.server.api.helpers.prompts.models import (
+    PromptInvocationParameters,
+    PromptResponseFormat,
+    PromptTemplate,
+    PromptTemplateFormat,
+    PromptTemplateType,
+    PromptTools,
+)
+from phoenix.server.api.routers.v1.models import V1RoutesBaseModel
+from phoenix.server.api.routers.v1.utils import ResponseBody, add_errors_to_responses
+from phoenix.server.api.types.node import from_global_id_with_expected_type
+from phoenix.server.api.types.Prompt import Prompt as PromptNodeType
+from phoenix.server.api.types.PromptVersion import PromptVersion as PromptVersionNodeType
+from phoenix.server.bearer_auth import PhoenixUser
+
+logger = logging.getLogger(__name__)
+
+
+class PromptData(V1RoutesBaseModel):
+    name: Identifier
+    description: Optional[str] = None
+    source_prompt_id: Optional[str] = None
+
+
+class Prompt(PromptData):
+    id: str
+
+
+class PromptVersionData(V1RoutesBaseModel):
+    description: Optional[str] = None
+    model_provider: ModelProvider
+    model_name: str
+    template: PromptTemplate
+    template_type: PromptTemplateType
+    template_format: PromptTemplateFormat
+    invocation_parameters: PromptInvocationParameters
+    tools: Optional[PromptTools] = None
+    response_format: Optional[PromptResponseFormat] = None
+
+
+class PromptVersion(PromptVersionData):
+    id: str
+
+
+class GetPromptResponseBody(ResponseBody[PromptVersion]):
+    pass
+
+
+class GetPromptsResponseBody(ResponseBody[list[Prompt]]):
+    pass
+
+
+class GetPromptVersionsResponseBody(ResponseBody[list[PromptVersion]]):
+    pass
+
+
+class CreatePromptRequestBody(V1RoutesBaseModel):
+    prompt: PromptData
+    version: PromptVersionData
+
+
+class CreatePromptResponseBody(ResponseBody[PromptVersion]):
+    pass
+
+
+router = APIRouter(tags=["prompts"])
+
+
+@router.get(
+    "/prompts",
+    operation_id="getPrompts",
+    summary="Get all prompts",
+    responses=add_errors_to_responses(
+        [
+            HTTP_422_UNPROCESSABLE_ENTITY,
+        ]
+    ),
+)
+async def get_prompts(
+    request: Request,
+    cursor: Optional[str] = Query(
+        default=None,
+        description="Cursor for pagination (base64-encoded prompt ID)",
+    ),
+    limit: int = Query(
+        default=100, description="The max number of prompts to return at a time.", gt=0
+    ),
+) -> GetPromptsResponseBody:
+    async with request.app.state.db() as session:
+        query = select(models.Prompt).order_by(models.Prompt.id.desc())
+
+        if cursor:
+            try:
+                cursor_id = GlobalID.from_id(cursor).node_id
+                query = query.filter(models.Prompt.id <= int(cursor_id))
+            except ValueError:
+                raise HTTPException(
+                    detail=f"Invalid cursor format: {cursor}",
+                    status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                )
+
+        query = query.limit(limit + 1)
+        result = await session.execute(query)
+        orm_prompts = result.scalars().all()
+
+        if not orm_prompts:
+            return GetPromptsResponseBody(next_cursor=None, data=[])
+
+        next_cursor = None
+        if len(orm_prompts) == limit + 1:
+            last_prompt = orm_prompts[-1]
+            next_cursor = str(GlobalID(PromptNodeType.__name__, str(last_prompt.id)))
+            orm_prompts = orm_prompts[:-1]
+
+        prompts = [_prompt_from_orm_prompt(orm_prompt) for orm_prompt in orm_prompts]
+    return GetPromptsResponseBody(next_cursor=next_cursor, data=prompts)
+
+
+@router.get(
+    "/prompts/{prompt_identifier}/versions",
+    operation_id="listPromptVersions",
+    summary="List all prompt versions for a given prompt",
+    responses=add_errors_to_responses([HTTP_422_UNPROCESSABLE_ENTITY]),
+    response_model_by_alias=True,
+    response_model_exclude_defaults=True,
+    response_model_exclude_unset=True,
+)
+async def list_prompt_versions(
+    request: Request,
+    prompt_identifier: str = Path(description="The identifier of the prompt, i.e. name or ID."),
+    cursor: Optional[str] = Query(
+        default=None,
+        description="Cursor for pagination (base64-encoded promptVersion ID)",
+    ),
+    limit: int = Query(
+        default=100, description="The max number of prompt versions to return at a time.", gt=0
+    ),
+) -> GetPromptVersionsResponseBody:
+    query = select(models.PromptVersion)
+    query = _filter_by_prompt_identifier(query.join(models.Prompt), prompt_identifier)
+    query = query.order_by(models.PromptVersion.id.desc())
+
+    async with request.app.state.db() as session:
+        if cursor:
+            try:
+                cursor_id = GlobalID.from_id(cursor).node_id
+                query = query.filter(models.PromptVersion.id <= int(cursor_id))
+            except ValueError:
+                raise HTTPException(
+                    detail=f"Invalid cursor format: {cursor}",
+                    status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                )
+
+        query = query.limit(limit + 1)
+        result = await session.execute(query)
+        orm_versions = result.scalars().all()
+
+        if not orm_versions:
+            return GetPromptVersionsResponseBody(next_cursor=None, data=[])
+
+        next_cursor = None
+        if len(orm_versions) == limit + 1:
+            last_version = orm_versions[-1]
+            next_cursor = str(GlobalID(PromptVersionNodeType.__name__, str(last_version.id)))
+            orm_versions = orm_versions[:-1]
+
+        versions = [_prompt_version_from_orm_version(orm_version) for orm_version in orm_versions]
+        return GetPromptVersionsResponseBody(next_cursor=next_cursor, data=versions)
+
+
+@router.get(
+    "/prompt_versions/{prompt_version_id}",
+    operation_id="getPromptVersionByPromptVersionId",
+    summary="Get prompt by prompt version ID",
+    responses=add_errors_to_responses(
+        [
+            HTTP_404_NOT_FOUND,
+            HTTP_422_UNPROCESSABLE_ENTITY,
+        ]
+    ),
+    response_model_by_alias=True,
+    response_model_exclude_defaults=True,
+    response_model_exclude_unset=True,
+)
+async def get_prompt_version_by_prompt_version_id(
+    request: Request,
+    prompt_version_id: str = Path(description="The ID of the prompt version."),
+) -> GetPromptResponseBody:
+    try:
+        id_ = from_global_id_with_expected_type(
+            GlobalID.from_id(prompt_version_id),
+            PromptVersionNodeType.__name__,
+        )
+    except ValueError:
+        raise HTTPException(HTTP_422_UNPROCESSABLE_ENTITY, "Invalid prompt version ID")
+    async with request.app.state.db() as session:
+        prompt_version = await session.get(models.PromptVersion, id_)
+        if prompt_version is None:
+            raise HTTPException(HTTP_404_NOT_FOUND)
+    data = _prompt_version_from_orm_version(prompt_version)
+    return GetPromptResponseBody(data=data)
+
+
+@router.get(
+    "/prompts/{prompt_identifier}/tags/{tag_name}",
+    operation_id="getPromptVersionByTagName",
+    summary="Get prompt by tag name",
+    responses=add_errors_to_responses(
+        [
+            HTTP_404_NOT_FOUND,
+            HTTP_422_UNPROCESSABLE_ENTITY,
+        ]
+    ),
+    response_model_by_alias=True,
+    response_model_exclude_unset=True,
+    response_model_exclude_defaults=True,
+)
+async def get_prompt_version_by_tag_name(
+    request: Request,
+    prompt_identifier: str = Path(description="The identifier of the prompt, i.e. name or ID."),
+    tag_name: str = Path(description="The tag of the prompt version"),
+) -> GetPromptResponseBody:
+    try:
+        name = Identifier.model_validate(tag_name)
+    except ValidationError:
+        raise HTTPException(HTTP_422_UNPROCESSABLE_ENTITY, "Invalid tag name")
+    stmt = (
+        select(models.PromptVersion)
+        .join_from(models.PromptVersion, models.PromptVersionTag)
+        .where(models.PromptVersionTag.name == name)
+    )
+    stmt = _filter_by_prompt_identifier(stmt.join(models.Prompt), prompt_identifier)
+    async with request.app.state.db() as session:
+        prompt_version: models.PromptVersion = await session.scalar(stmt)
+        if prompt_version is None:
+            raise HTTPException(HTTP_404_NOT_FOUND)
+    data = _prompt_version_from_orm_version(prompt_version)
+    return GetPromptResponseBody(data=data)
+
+
+@router.get(
+    "/prompts/{prompt_identifier}/latest",
+    operation_id="getPromptVersionLatest",
+    summary="Get the latest prompt version",
+    responses=add_errors_to_responses(
+        [
+            HTTP_404_NOT_FOUND,
+            HTTP_422_UNPROCESSABLE_ENTITY,
+        ]
+    ),
+    response_model_by_alias=True,
+    response_model_exclude_defaults=True,
+    response_model_exclude_unset=True,
+)
+async def get_prompt_version_by_latest(
+    request: Request,
+    prompt_identifier: str = Path(description="The identifier of the prompt, i.e. name or ID."),
+) -> GetPromptResponseBody:
+    stmt = select(models.PromptVersion).order_by(models.PromptVersion.id.desc()).limit(1)
+    stmt = _filter_by_prompt_identifier(stmt.join(models.Prompt), prompt_identifier)
+    async with request.app.state.db() as session:
+        prompt_version: models.PromptVersion = await session.scalar(stmt)
+        if prompt_version is None:
+            raise HTTPException(HTTP_404_NOT_FOUND)
+    data = _prompt_version_from_orm_version(prompt_version)
+    return GetPromptResponseBody(data=data)
+
+
+@router.post(
+    "/prompts",
+    operation_id="postPromptVersion",
+    summary="Create a prompt version",
+    responses=add_errors_to_responses(
+        [
+            HTTP_422_UNPROCESSABLE_ENTITY,
+        ]
+    ),
+    response_model_by_alias=True,
+    response_model_exclude_defaults=True,
+    response_model_exclude_unset=True,
+)
+async def create_prompt(
+    request: Request,
+    request_body: CreatePromptRequestBody,
+) -> CreatePromptResponseBody:
+    if (
+        request_body.version.template.type.lower() != "chat"
+        or request_body.version.template_type != PromptTemplateType.CHAT
+    ):
+        raise HTTPException(
+            HTTP_422_UNPROCESSABLE_ENTITY,
+            "Only CHAT template type is supported for prompts",
+        )
+    prompt = request_body.prompt
+    try:
+        name = Identifier.model_validate(prompt.name)
+    except ValidationError as e:
+        raise HTTPException(
+            HTTP_422_UNPROCESSABLE_ENTITY,
+            "Invalid name identifier for prompt: " + e.errors()[0]["msg"],
+        )
+    version = request_body.version
+    user_id: Optional[int] = None
+    if request.app.state.authentication_enabled:
+        assert isinstance(user := request.user, PhoenixUser)
+        user_id = int(user.identity)
+    async with request.app.state.db() as session:
+        if not (prompt_id := await session.scalar(select(models.Prompt.id).filter_by(name=name))):
+            prompt_orm = models.Prompt(
+                name=name,
+                description=prompt.description,
+            )
+            session.add(prompt_orm)
+            await session.flush()
+            prompt_id = prompt_orm.id
+        version_orm = models.PromptVersion(
+            user_id=user_id,
+            prompt_id=prompt_id,
+            description=version.description,
+            model_provider=version.model_provider,
+            model_name=version.model_name,
+            template_type=version.template_type,
+            template_format=version.template_format,
+            template=version.template,
+            invocation_parameters=version.invocation_parameters,
+            tools=version.tools,
+            response_format=version.response_format,
+        )
+        session.add(version_orm)
+    data = _prompt_version_from_orm_version(version_orm)
+    return CreatePromptResponseBody(data=data)
+
+
+class _PromptId(int): ...
+
+
+_PromptIdentifier: TypeAlias = Union[_PromptId, Identifier]
+
+
+def _parse_prompt_identifier(
+    prompt_identifier: str,
+) -> _PromptIdentifier:
+    if not prompt_identifier:
+        raise HTTPException(HTTP_422_UNPROCESSABLE_ENTITY, "Invalid prompt identifier")
+    try:
+        prompt_id = from_global_id_with_expected_type(
+            GlobalID.from_id(prompt_identifier),
+            PromptNodeType.__name__,
+        )
+    except ValueError:
+        try:
+            return Identifier.model_validate(prompt_identifier)
+        except ValidationError:
+            raise HTTPException(HTTP_422_UNPROCESSABLE_ENTITY, "Invalid prompt name")
+    return _PromptId(prompt_id)
+
+
+def _filter_by_prompt_identifier(
+    stmt: Select[tuple[models.PromptVersion]],
+    prompt_identifier: str,
+) -> Any:
+    identifier = _parse_prompt_identifier(prompt_identifier)
+    if isinstance(identifier, _PromptId):
+        return stmt.where(models.Prompt.id == int(identifier))
+    if isinstance(identifier, Identifier):
+        return stmt.where(models.Prompt.name == identifier)
+    assert_never(identifier)
+
+
+def _prompt_version_from_orm_version(
+    prompt_version: models.PromptVersion,
+) -> PromptVersion:
+    prompt_template_type = PromptTemplateType(prompt_version.template_type)
+    prompt_template_format = PromptTemplateFormat(prompt_version.template_format)
+    return PromptVersion(
+        id=str(GlobalID(PromptVersionNodeType.__name__, str(prompt_version.id))),
+        description=prompt_version.description or "",
+        model_provider=prompt_version.model_provider,
+        model_name=prompt_version.model_name,
+        template=prompt_version.template,
+        template_type=prompt_template_type,
+        template_format=prompt_template_format,
+        invocation_parameters=prompt_version.invocation_parameters,
+        tools=prompt_version.tools,
+        response_format=prompt_version.response_format,
+    )
+
+
+def _prompt_from_orm_prompt(orm_prompt: models.Prompt) -> Prompt:
+    source_prompt_id = (
+        str(GlobalID(PromptNodeType.__name__, str(orm_prompt.source_prompt_id)))
+        if orm_prompt.source_prompt_id
+        else None
+    )
+    return Prompt(
+        id=str(GlobalID(PromptNodeType.__name__, str(orm_prompt.id))),
+        source_prompt_id=source_prompt_id,
+        name=orm_prompt.name,
+        description=orm_prompt.description,
+    )

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

@@ -24,7 +24,7 @@ from phoenix.server.dml_event import SpanAnnotationInsertEvent
 from phoenix.trace.dsl import SpanQuery as SpanQuery_
 from phoenix.utilities.json import encode_df_as_json_string
 
-from .pydantic_compat import V1RoutesBaseModel
+from .models import V1RoutesBaseModel
 from .utils import RequestBody, ResponseBody, add_errors_to_responses
 
 DEFAULT_SPAN_LIMIT = 1000

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

@@ -30,7 +30,7 @@ from phoenix.server.dml_event import TraceAnnotationInsertEvent
 from phoenix.trace.otel import decode_otlp_span
 from phoenix.utilities.project import get_project_name
 
-from .pydantic_compat import V1RoutesBaseModel
+from .models import V1RoutesBaseModel
 from .utils import RequestBody, ResponseBody, add_errors_to_responses
 
 router = APIRouter(tags=["traces"])

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

@@ -2,7 +2,7 @@ from typing import Any, Generic, Optional, TypedDict, TypeVar, Union
 
 from typing_extensions import TypeAlias, assert_never
 
-from .pydantic_compat import V1RoutesBaseModel
+from .models import V1RoutesBaseModel
 
 StatusCode: TypeAlias = int
 DataType = TypeVar("DataType")

phoenix/server/api/subscriptions.py

@@ -41,6 +41,7 @@ from phoenix.server.api.helpers.playground_spans import (
     get_db_trace,
     streaming_llm_span,
 )
+from phoenix.server.api.helpers.prompts.models import PromptTemplateFormat
 from phoenix.server.api.input_types.ChatCompletionInput import (
     ChatCompletionInput,
     ChatCompletionOverDatasetInput,
@@ -59,7 +60,6 @@ from phoenix.server.api.types.Experiment import to_gql_experiment
 from phoenix.server.api.types.ExperimentRun import to_gql_experiment_run
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.api.types.Span import to_gql_span
-from phoenix.server.api.types.TemplateLanguage import TemplateLanguage
 from phoenix.server.dml_event import SpanInsertEvent
 from phoenix.server.types import DbSessionFactory
 from phoenix.utilities.template_formatters import (
@@ -124,7 +124,7 @@ class Subscription:
             messages = list(
                 _formatted_messages(
                     messages=messages,
-                    template_language=template_options.language,
+                    template_format=template_options.format,
                     template_variables=template_options.variables,
                 )
             )
@@ -198,9 +198,7 @@ class Subscription:
         )
         async with info.context.db() as session:
             if (
-                dataset := await session.scalar(
-                    select(models.Dataset).where(models.Dataset.id == dataset_id)
-                )
+                await session.scalar(select(models.Dataset).where(models.Dataset.id == dataset_id))
             ) is None:
                 raise NotFound(f"Could not find dataset with ID {dataset_id}")
             if version_id is None:
@@ -274,9 +272,9 @@ class Subscription:
             experiment = models.Experiment(
                 dataset_id=from_global_id_with_expected_type(input.dataset_id, Dataset.__name__),
                 dataset_version_id=resolved_version_id,
-                name=input.experiment_name or _default_playground_experiment_name(),
-                description=input.experiment_description
-                or _default_playground_experiment_description(dataset_name=dataset.name),
+                name=input.experiment_name
+                or _default_playground_experiment_name(input.prompt_name),
+                description=input.experiment_description,
                 repetitions=1,
                 metadata_=input.experiment_metadata or dict(),
                 project_name=PLAYGROUND_PROJECT_NAME,
@@ -394,7 +392,7 @@ async def _stream_chat_completion_over_dataset_example(
         messages = list(
             _formatted_messages(
                 messages=messages,
-                template_language=input.template_language,
+                template_format=input.template_format,
                 template_variables=revision.input,
             )
         )
@@ -472,7 +470,7 @@ def _is_result_payloads_stream(
     Checks if the given generator was instantiated from
     `_chat_completion_result_payloads`
     """
-    return stream.ag_code == _chat_completion_result_payloads.__code__
+    return stream.ag_code == _chat_completion_result_payloads.__code__  # type: ignore
 
 
 def _create_task_with_timeout(
@@ -534,13 +532,13 @@ async def _as_coroutine(iterable: AsyncIterator[GenericType]) -> GenericType:
 def _formatted_messages(
     *,
     messages: Iterable[ChatCompletionMessage],
-    template_language: TemplateLanguage,
+    template_format: PromptTemplateFormat,
     template_variables: Mapping[str, Any],
 ) -> Iterator[tuple[ChatCompletionMessageRole, str, Optional[str], Optional[list[str]]]]:
     """
     Formats the messages using the given template options.
     """
-    template_formatter = _template_formatter(template_language=template_language)
+    template_formatter = _template_formatter(template_format=template_format)
     (
         roles,
         templates,
@@ -555,25 +553,24 @@ def _formatted_messages(
     return formatted_messages
 
 
-def _template_formatter(template_language: TemplateLanguage) -> TemplateFormatter:
+def _template_formatter(template_format: PromptTemplateFormat) -> TemplateFormatter:
     """
-    Instantiates the appropriate template formatter for the template language.
+    Instantiates the appropriate template formatter for the template format
     """
-    if template_language is TemplateLanguage.MUSTACHE:
+    if template_format is PromptTemplateFormat.MUSTACHE:
         return MustacheTemplateFormatter()
-    if template_language is TemplateLanguage.F_STRING:
+    if template_format is PromptTemplateFormat.F_STRING:
         return FStringTemplateFormatter()
-    if template_language is TemplateLanguage.NONE:
+    if template_format is PromptTemplateFormat.NONE:
         return NoOpFormatter()
-    assert_never(template_language)
-
-
-def _default_playground_experiment_name() -> str:
-    return "playground-experiment"
+    assert_never(template_format)
 
 
-def _default_playground_experiment_description(dataset_name: str) -> str:
-    return f'Playground experiment for dataset "{dataset_name}"'
+def _default_playground_experiment_name(prompt_name: Optional[str] = None) -> str:
+    name = "playground-experiment"
+    if prompt_name:
+        name = f"{name} prompt:{prompt_name}"
+    return name
 
 
 LLM_OUTPUT_MESSAGES = SpanAttributes.LLM_OUTPUT_MESSAGES