arize-phoenix 10.15.0__tar.gz → 11.0.0__tar.gz

{arize_phoenix-10.15.0 → arize_phoenix-11.0.0}/.gitignore

@@ -85,4 +85,6 @@ packages/phoenix-client/docs/build/
 packages/phoenix-evals/docs/build/
 
 # Deployment
-helm/charts/*.tgz
+helm/charts/*.tgz
+# mypy
+.mypy_cache

{arize_phoenix-10.15.0 → arize_phoenix-11.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arize-phoenix
-Version: 10.15.0
+Version: 11.0.0
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://arize.com/docs/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues
@@ -33,7 +33,7 @@ Requires-Dist: httpx
 Requires-Dist: jinja2
 Requires-Dist: numpy!=2.0.0
 Requires-Dist: openinference-instrumentation>=0.1.32
-Requires-Dist: openinference-semantic-conventions>=0.1.17
+Requires-Dist: openinference-semantic-conventions>=0.1.20
 Requires-Dist: opentelemetry-exporter-otlp
 Requires-Dist: opentelemetry-proto>=1.12.0
 Requires-Dist: opentelemetry-sdk

{arize_phoenix-10.15.0 → arize_phoenix-11.0.0}/pyproject.toml

@@ -43,7 +43,7 @@ dependencies = [
   "opentelemetry-proto>=1.12.0",  # needed to avoid this issue: https://github.com/Arize-ai/phoenix/issues/2695
   "opentelemetry-exporter-otlp",
   "opentelemetry-semantic-conventions",
-  "openinference-semantic-conventions>=0.1.17",
+  "openinference-semantic-conventions>=0.1.20",
   "openinference-instrumentation>=0.1.32",
   "sqlalchemy[asyncio]>=2.0.4, <3",
   "alembic>=1.3.0, <2",

{arize_phoenix-10.15.0 → arize_phoenix-11.0.0}/src/phoenix/config.py

@@ -135,8 +135,11 @@ ENV_PHOENIX_DANGEROUSLY_DISABLE_MIGRATIONS = "PHOENIX_DANGEROUSLY_DISABLE_MIGRAT
 """
 Whether or not to disable migrations. Defaults to None / False.
 
-This should only be used by developers working on the Phoenix server that need to be
-switching between branches without having to run migrations.
+This should only be used by developers working on the Phoenix server that need
+to be switching between branches without having to run migrations.
+
+This can also be useful if a migration fails and you want to put the applicaiton
+in a running state.
 """
 
 # Phoenix server OpenTelemetry instrumentation environment variables

{arize_phoenix-10.15.0 → arize_phoenix-11.0.0}/src/phoenix/datetime_utils.py

@@ -28,7 +28,7 @@ def normalize_datetime(
     """
     if not isinstance(dt, datetime):
         return None
-    if dt.tzinfo is None or dt.tzinfo.utcoffset(dt) is None:
+    if not is_timezone_aware(dt):
         dt = dt.replace(tzinfo=tz if tz else _LOCAL_TIMEZONE)
     return dt.astimezone(timezone.utc)
 
@@ -106,3 +106,10 @@ def right_open_time_range(
         floor_to_minute(min_time) if min_time else None,
         floor_to_minute(max_time + timedelta(minutes=1)) if max_time else None,
     )
+
+
+def is_timezone_aware(dt: datetime) -> bool:
+    """
+    Returns True if the datetime is timezone-aware, False otherwise.
+    """
+    return dt.tzinfo is not None and dt.tzinfo.utcoffset(dt) is not None

{arize_phoenix-10.15.0 → arize_phoenix-11.0.0}/src/phoenix/db/bulk_inserter.py

@@ -8,6 +8,7 @@ from itertools import islice
 from time import perf_counter
 from typing import Any, Optional, cast
 
+from openinference.semconv.trace import SpanAttributes
 from typing_extensions import TypeAlias
 
 import phoenix.trace.v1 as pb
@@ -17,11 +18,19 @@ from phoenix.db.insertion.evaluation import (
     InsertEvaluationError,
     insert_evaluation,
 )
-from phoenix.db.insertion.helpers import DataManipulation, DataManipulationEvent
+from phoenix.db.insertion.helpers import (
+    DataManipulation,
+    DataManipulationEvent,
+    should_calculate_span_cost,
+)
 from phoenix.db.insertion.span import SpanInsertionEvent, insert_span
 from phoenix.db.insertion.span_annotation import SpanAnnotationQueueInserter
 from phoenix.db.insertion.trace_annotation import TraceAnnotationQueueInserter
 from phoenix.db.insertion.types import Insertables, Precursors
+from phoenix.server.daemons.span_cost_calculator import (
+    SpanCostCalculator,
+    SpanCostCalculatorQueueItem,
+)
 from phoenix.server.dml_event import DmlEvent, SpanInsertEvent
 from phoenix.server.types import CanPutItem, DbSessionFactory
 from phoenix.trace.schemas import Span
@@ -42,6 +51,7 @@ class BulkInserter:
         db: DbSessionFactory,
         *,
         event_queue: CanPutItem[DmlEvent],
+        span_cost_calculator: SpanCostCalculator,
         initial_batch_of_spans: Optional[Iterable[tuple[Span, str]]] = None,
         initial_batch_of_evaluations: Optional[Iterable[pb.Evaluation]] = None,
         sleep: float = 0.1,
@@ -78,6 +88,7 @@ class BulkInserter:
         self._retry_delay_sec = retry_delay_sec
         self._retry_allowance = retry_allowance
         self._queue_inserters = _QueueInserters(db, self._retry_delay_sec, self._retry_allowance)
+        self._span_cost_calculator = span_cost_calculator
 
     async def __aenter__(
         self,
@@ -175,6 +186,7 @@ class BulkInserter:
 
     async def _insert_spans(self, spans: list[tuple[Span, str]]) -> None:
         project_ids = set()
+        span_cost_calculator_queue: list[SpanCostCalculatorQueueItem] = []
         for i in range(0, len(spans), self._max_ops_per_transaction):
             try:
                 start = perf_counter()
@@ -198,6 +210,16 @@ class BulkInserter:
                             )
                         if result is not None:
                             project_ids.add(result.project_rowid)
+                            if should_calculate_span_cost(span.attributes):
+                                span_cost_calculator_queue.append(
+                                    SpanCostCalculatorQueueItem(
+                                        span_rowid=result.span_rowid,
+                                        trace_rowid=result.trace_rowid,
+                                        attributes=span.attributes,
+                                        span_start_time=span.start_time,
+                                    )
+                                )
+
                 if self._enable_prometheus:
                     from phoenix.server.prometheus import BULK_LOADER_INSERTION_TIME
 
@@ -209,6 +231,8 @@ class BulkInserter:
                     BULK_LOADER_EXCEPTIONS.inc()
                 logger.exception("Failed to insert spans")
         self._event_queue.put(SpanInsertEvent(tuple(project_ids)))
+        for item in span_cost_calculator_queue:
+            self._span_cost_calculator.put_nowait(item)
 
     async def _insert_evaluations(self, evaluations: list[pb.Evaluation]) -> None:
         for i in range(0, len(evaluations), self._max_ops_per_transaction):
@@ -292,3 +316,18 @@ class _QueueInserters:
     @_enqueue.register(Insertables.DocumentAnnotation)
     async def _(self, item: Precursors.DocumentAnnotation) -> None:
         await self._document_annotations.enqueue(item)
+
+
+LLM_MODEL_NAME = SpanAttributes.LLM_MODEL_NAME
+LLM_PROVIDER = SpanAttributes.LLM_PROVIDER
+LLM_TOKEN_COUNT_COMPLETION = SpanAttributes.LLM_TOKEN_COUNT_COMPLETION
+LLM_TOKEN_COUNT_COMPLETION_DETAILS_AUDIO = SpanAttributes.LLM_TOKEN_COUNT_COMPLETION_DETAILS_AUDIO
+LLM_TOKEN_COUNT_COMPLETION_DETAILS_REASONING = (
+    SpanAttributes.LLM_TOKEN_COUNT_COMPLETION_DETAILS_REASONING
+)
+LLM_TOKEN_COUNT_PROMPT = SpanAttributes.LLM_TOKEN_COUNT_PROMPT
+LLM_TOKEN_COUNT_PROMPT_DETAILS_AUDIO = SpanAttributes.LLM_TOKEN_COUNT_PROMPT_DETAILS_AUDIO
+LLM_TOKEN_COUNT_PROMPT_DETAILS_CACHE_READ = SpanAttributes.LLM_TOKEN_COUNT_PROMPT_DETAILS_CACHE_READ
+LLM_TOKEN_COUNT_PROMPT_DETAILS_CACHE_WRITE = (
+    SpanAttributes.LLM_TOKEN_COUNT_PROMPT_DETAILS_CACHE_WRITE
+)

arize_phoenix-11.0.0/src/phoenix/db/facilitator.py

@@ -0,0 +1,522 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import re
+import secrets
+from asyncio import gather
+from datetime import datetime, timedelta, timezone
+from functools import partial
+from pathlib import Path
+from typing import NamedTuple, Optional, Union
+
+import sqlalchemy as sa
+from sqlalchemy import select
+from sqlalchemy.orm import InstrumentedAttribute, joinedload
+from sqlalchemy.sql.dml import ReturningDelete
+
+from phoenix import config
+from phoenix.auth import (
+    DEFAULT_ADMIN_EMAIL,
+    DEFAULT_ADMIN_USERNAME,
+    DEFAULT_SECRET_LENGTH,
+    DEFAULT_SYSTEM_EMAIL,
+    DEFAULT_SYSTEM_USERNAME,
+    compute_password_hash,
+)
+from phoenix.config import (
+    get_env_admins,
+    get_env_default_admin_initial_password,
+    get_env_disable_basic_auth,
+)
+from phoenix.db import models
+from phoenix.db.constants import DEFAULT_PROJECT_TRACE_RETENTION_POLICY_ID
+from phoenix.db.enums import ENUM_COLUMNS
+from phoenix.db.types.trace_retention import (
+    MaxDaysRule,
+    TraceRetentionCronExpression,
+    TraceRetentionRule,
+)
+from phoenix.server.email.types import WelcomeEmailSender
+from phoenix.server.types import DbSessionFactory
+
+logger = logging.getLogger(__name__)
+
+
+class Facilitator:
+    """
+    Facilitates the creation of database records necessary for Phoenix to function. This includes
+    ensuring that all enum values are present in their respective tables, ensuring that all user
+    roles are present, and ensuring that the admin user has a password hash. These tasks will be
+    carried out as callbacks at the very beginning of Starlette's lifespan process.
+    """
+
+    def __init__(
+        self,
+        *,
+        db: DbSessionFactory,
+        email_sender: Optional[WelcomeEmailSender] = None,
+    ) -> None:
+        self._db = db
+        self._email_sender = email_sender
+
+    async def __call__(self) -> None:
+        for fn in (
+            _ensure_enums,
+            _ensure_user_roles,
+            _get_system_user_id,
+            partial(_ensure_admins, email_sender=self._email_sender),
+            _ensure_default_project_trace_retention_policy,
+            _ensure_model_costs,
+            _delete_expired_childless_records,
+        ):
+            await fn(self._db)
+
+
+async def _ensure_enums(db: DbSessionFactory) -> None:
+    """
+    Ensure that all enum values are present in their respective tables. If any values are missing,
+    they will be added. If any values are present in the database but not in the enum, an error will
+    be raised. This function is idempotent: it will not add duplicate values to the database.
+    """
+    for column in ENUM_COLUMNS:
+        table = column.class_
+        assert isinstance(column.type, sa.Enum)
+        async with db() as session:
+            existing = set(await session.scalars(sa.select(column)))
+            expected = set(column.type.enums)
+            if unexpected := existing - expected:
+                raise ValueError(f"Unexpected values in {table.name}.{column.key}: {unexpected}")
+            if not (missing := expected - existing):
+                continue
+            await session.execute(sa.insert(table), [{column.key: v} for v in missing])
+
+
+async def _ensure_user_roles(db: DbSessionFactory) -> None:
+    """
+    Ensure that the system and admin roles are present in the database. If they are not, they will
+    be added. The system user will have the email "system@localhost" and the admin user will have
+    the email "admin@localhost".
+    """
+    async with db() as session:
+        role_ids: dict[models.UserRoleName, int] = {
+            name: id_
+            async for name, id_ in await session.stream(
+                sa.select(models.UserRole.name, models.UserRole.id)
+            )
+        }
+        existing_roles: list[models.UserRoleName] = [
+            name
+            async for name in await session.stream_scalars(
+                sa.select(sa.distinct(models.UserRole.name)).join_from(models.User, models.UserRole)
+            )
+        ]
+        if (
+            "SYSTEM" not in existing_roles
+            and (system_role_id := role_ids.get("SYSTEM")) is not None
+        ):
+            system_user = models.LocalUser(
+                user_role_id=system_role_id,
+                username=DEFAULT_SYSTEM_USERNAME,
+                email=DEFAULT_SYSTEM_EMAIL,
+                reset_password=False,
+                password_salt=secrets.token_bytes(DEFAULT_SECRET_LENGTH),
+                password_hash=secrets.token_bytes(DEFAULT_SECRET_LENGTH),
+            )
+            session.add(system_user)
+        if "ADMIN" not in existing_roles and (admin_role_id := role_ids.get("ADMIN")) is not None:
+            salt = secrets.token_bytes(DEFAULT_SECRET_LENGTH)
+            password = get_env_default_admin_initial_password()
+            compute = partial(compute_password_hash, password=password, salt=salt)
+            loop = asyncio.get_running_loop()
+            hash_ = await loop.run_in_executor(None, compute)
+            admin_user = models.LocalUser(
+                user_role_id=admin_role_id,
+                username=DEFAULT_ADMIN_USERNAME,
+                email=DEFAULT_ADMIN_EMAIL,
+                password_salt=salt,
+                password_hash=hash_,
+                reset_password=True,
+            )
+            session.add(admin_user)
+        await session.flush()
+
+
+async def _get_system_user_id(db: DbSessionFactory) -> None:
+    """
+    Set the system user ID in the config. This is used to identify the system user in the database.
+    """
+    async with db() as session:
+        system_user_id = await session.scalar(
+            sa.select(models.User.id)
+            .join(models.UserRole)
+            .where(models.UserRole.name == "SYSTEM")
+            .order_by(models.User.id)
+            .limit(1)
+        )
+    if system_user_id is None:
+        raise ValueError("System user not found in database")
+    config.SYSTEM_USER_ID = system_user_id
+
+
+async def _ensure_admins(
+    db: DbSessionFactory,
+    *,
+    email_sender: Optional[WelcomeEmailSender] = None,
+) -> None:
+    """
+    Ensure that all startup admin users are present in the database. If any are missing, they will
+    be added. Existing records will not be modified.
+    """
+    if not (admins := get_env_admins()):
+        return
+    disable_basic_auth = get_env_disable_basic_auth()
+    async with db() as session:
+        existing_emails = set(
+            await session.scalars(
+                sa.select(models.User.email).where(models.User.email.in_(admins.keys()))
+            )
+        )
+        admins = {
+            email: username for email, username in admins.items() if email not in existing_emails
+        }
+        if not admins:
+            return
+        existing_usernames = set(
+            await session.scalars(
+                sa.select(models.User.username).where(models.User.username.in_(admins.values()))
+            )
+        )
+        admins = {
+            email: username
+            for email, username in admins.items()
+            if username not in existing_usernames
+        }
+        if not admins:
+            return
+        admin_role_id = await session.scalar(sa.select(models.UserRole.id).filter_by(name="ADMIN"))
+        assert admin_role_id is not None, "Admin role not found in database"
+        user: models.User
+        for email, username in admins.items():
+            if not disable_basic_auth:
+                user = models.LocalUser(
+                    email=email,
+                    username=username,
+                    password_salt=secrets.token_bytes(DEFAULT_SECRET_LENGTH),
+                    password_hash=secrets.token_bytes(DEFAULT_SECRET_LENGTH),
+                )
+            else:
+                user = models.OAuth2User(
+                    email=email,
+                    username=username,
+                )
+            user.user_role_id = admin_role_id
+            session.add(user)
+        await session.flush()
+    if email_sender is None:
+        return
+    for exc in await gather(
+        *(email_sender.send_welcome_email(email, username) for email, username in admins.items()),
+        return_exceptions=True,
+    ):
+        if isinstance(exc, Exception):
+            logger.error(f"Failed to send welcome email: {exc}")
+
+
+_CHILDLESS_RECORD_DELETION_GRACE_PERIOD_DAYS = 1
+
+
+def _stmt_to_delete_expired_childless_records(
+    table: type[models.Base],
+    foreign_key: Union[InstrumentedAttribute[int], InstrumentedAttribute[Optional[int]]],
+) -> ReturningDelete[tuple[int]]:
+    """
+    Creates a SQLAlchemy DELETE statement to permanently remove childless records.
+
+    Args:
+        table: The table model class that has a deleted_at column
+        foreign_key: The foreign key attribute to check for child relationships
+
+    Returns:
+        A DELETE statement that removes childless records marked for deletion more than
+        _CHILDLESS_RECORD_DELETION_GRACE_PERIOD_DAYS days ago
+    """  # noqa: E501
+    if not hasattr(table, "deleted_at"):
+        raise TypeError("Table must have a 'deleted_at' column")
+    cutoff_time = datetime.now(timezone.utc) - timedelta(
+        days=_CHILDLESS_RECORD_DELETION_GRACE_PERIOD_DAYS
+    )
+    return (
+        sa.delete(table)
+        .where(table.deleted_at.isnot(None))
+        .where(table.deleted_at < cutoff_time)
+        .where(~sa.exists().where(table.id == foreign_key))
+        .returning(table.id)
+    )
+
+
+async def _delete_expired_childless_records_on_generative_models(
+    db: DbSessionFactory,
+) -> None:
+    """
+    Permanently deletes childless GenerativeModel records that have been marked for deletion.
+
+    This function removes GenerativeModel records that:
+    - Have been marked for deletion (deleted_at is not NULL)
+    - Were marked more than 1 day ago (grace period expired)
+    - Have no associated SpanCost records (childless)
+
+    This cleanup is necessary to remove orphaned records that may have been left behind
+    due to previous migrations or deletions.
+    """  # noqa: E501
+    stmt = _stmt_to_delete_expired_childless_records(
+        models.GenerativeModel,
+        models.SpanCost.model_id,
+    )
+    async with db() as session:
+        result = (await session.scalars(stmt)).all()
+    if result:
+        logger.info(f"Permanently deleted {len(result)} expired childless GenerativeModel records")
+    else:
+        logger.debug("No expired childless GenerativeModel records found for permanent deletion")
+
+
+async def _delete_expired_childless_records(
+    db: DbSessionFactory,
+) -> None:
+    """
+    Permanently deletes childless records across all relevant tables.
+
+    This function runs the deletion process for all table types that support soft deletion,
+    handling any exceptions that occur during the process. Only records that have been
+    marked for deletion for more than the grace period (1 day) are permanently removed.
+    """  # noqa: E501
+    exceptions = await gather(
+        _delete_expired_childless_records_on_generative_models(db),
+        return_exceptions=True,
+    )
+    for exc in exceptions:
+        if isinstance(exc, Exception):
+            logger.error(f"Failed to delete childless records: {exc}")
+
+
+async def _ensure_default_project_trace_retention_policy(db: DbSessionFactory) -> None:
+    """
+    Ensures the default trace retention policy (id=1) exists in the database. Default policy
+    applies to all projects without a specific policy (i.e. foreign key is null).
+
+    This function checks for the presence of the default trace retention policy and
+    creates it if missing. The default trace retention policy:
+
+        - Has ID=0
+        - Is named "Default"
+        - Runs every Sunday at midnight UTC (cron: "0 0 * * 0")
+        - Retains traces indefinitely
+
+    If the default policy already exists, this function makes no changes.
+
+    Args:
+        db (DbSessionFactory): An async SQLAlchemy session factory.
+
+    Returns:
+        None
+    """
+    assert DEFAULT_PROJECT_TRACE_RETENTION_POLICY_ID == 0
+    async with db() as session:
+        if await session.scalar(
+            sa.select(
+                sa.exists().where(
+                    models.ProjectTraceRetentionPolicy.id
+                    == DEFAULT_PROJECT_TRACE_RETENTION_POLICY_ID
+                )
+            )
+        ):
+            return
+        cron_expression = TraceRetentionCronExpression(root="0 0 * * 0")
+        rule = TraceRetentionRule(root=MaxDaysRule(max_days=0))
+        await session.execute(
+            sa.insert(models.ProjectTraceRetentionPolicy),
+            [
+                {
+                    "id": DEFAULT_PROJECT_TRACE_RETENTION_POLICY_ID,
+                    "name": "Default",
+                    "cron_expression": cron_expression,
+                    "rule": rule,
+                }
+            ],
+        )
+
+
+_COST_MODEL_MANIFEST: Path = (
+    Path(__file__).parent.parent / "server" / "cost_tracking" / "model_cost_manifest.json"
+)
+
+
+class _TokenTypeKey(NamedTuple):
+    """
+    Composite key for uniquely identifying token price configurations.
+
+    Token prices are differentiated by both their type (e.g., "input", "output", "audio")
+    and whether they represent prompt tokens (input to the model) or completion tokens
+    (output from the model). Some token types like "audio" can exist in both categories.
+
+    Attributes:
+        token_type: The category of token (e.g., "input", "output", "audio", "cache_write")
+        is_prompt: True if these are prompt/input tokens, False if completion/output tokens
+    """
+
+    token_type: str
+    is_prompt: bool
+
+
+async def _ensure_model_costs(db: DbSessionFactory) -> None:
+    """
+    Ensures that built-in generative models and their token pricing information are up-to-date
+    in the database based on the model cost manifest file.
+
+    This function performs a comprehensive synchronization between the database and the manifest:
+
+    1. **Model Management**: Creates new built-in models from the manifest or updates existing ones
+    2. **Token Price Synchronization**: Ensures all token prices match the manifest rates
+    3. **Cleanup**: Soft-deletes built-in models no longer present in the manifest
+
+    The function handles different token types including:
+    - Input tokens (prompt): Standard input tokens for generation
+    - Cache write tokens (prompt): Tokens written to cache systems
+    - Cache read tokens (prompt): Tokens read from cache systems
+    - Output tokens (non-prompt): Generated response tokens
+    - Audio tokens (both prompt and non-prompt): Audio processing tokens
+
+    Token prices are uniquely identified by (token_type, is_prompt) pairs to handle
+    cases like audio tokens that can be both prompt and non-prompt.
+
+    Args:
+        db (DbSessionFactory): Database session factory for database operations
+
+    Returns:
+        None
+
+    Raises:
+        FileNotFoundError: If the model cost manifest file is not found
+        json.JSONDecodeError: If the manifest file contains invalid JSON
+        ValueError: If manifest data is malformed or missing required fields
+    """
+    # Load the authoritative model cost data from the manifest file
+    with open(_COST_MODEL_MANIFEST) as f:
+        manifest = json.load(f)
+
+    # Define all supported token types with their prompt/non-prompt classification
+    # This determines how tokens are categorized for billing purposes
+    token_types: list[_TokenTypeKey] = [
+        _TokenTypeKey("input", True),  # Standard input tokens
+        _TokenTypeKey("cache_write", True),  # Tokens written to cache
+        _TokenTypeKey("cache_read", True),  # Tokens read from cache
+        _TokenTypeKey("output", False),  # Generated output tokens
+        _TokenTypeKey("audio", True),  # Audio input tokens
+        _TokenTypeKey("audio", False),  # Audio output tokens
+    ]
+
+    async with db() as session:
+        # Fetch all existing built-in models with their token prices eagerly loaded
+        # Using .unique() to deduplicate models when multiple token prices are joined
+        built_in_models = {
+            omodel.name: omodel
+            for omodel in (
+                await session.scalars(
+                    select(models.GenerativeModel)
+                    .where(models.GenerativeModel.deleted_at.is_(None))
+                    .where(models.GenerativeModel.is_built_in.is_(True))
+                    .options(joinedload(models.GenerativeModel.token_prices))
+                )
+            ).unique()
+        }
+
+        seen_names: set[str] = set()
+        seen_patterns: set[tuple[re.Pattern[str], str]] = set()
+
+        # Process each model in the manifest
+        for model_data in manifest:
+            name = str(model_data.get("model") or "").strip()
+            if not name:
+                logger.warning("Skipping model with empty name in manifest")
+                continue
+            if name in seen_names:
+                logger.warning(f"Skipping model '{name}' with duplicate name in manifest")
+                continue
+            seen_names.add(name)
+            regex = str(model_data.get("regex") or "").strip()
+            try:
+                pattern = re.compile(regex)
+            except re.error as e:
+                logger.warning(f"Skipping model '{name}' with invalid regex: {e}")
+                continue
+            provider = str(model_data.get("provider") or "").strip()
+            if (pattern, provider) in seen_patterns:
+                logger.warning(
+                    f"Skipping model '{name}' with duplicate name_pattern/provider combination"
+                )
+                continue
+            seen_patterns.add((pattern, provider))
+            # Remove model from built_in_models dict (for cleanup tracking)
+            # or create new model if not found
+            model = built_in_models.pop(model_data["model"], None)
+            if model is None:
+                # Create new built-in model from manifest data
+                model = models.GenerativeModel(
+                    name=name,
+                    provider=provider,
+                    name_pattern=pattern,
+                    is_built_in=True,
+                )
+                session.add(model)
+            else:
+                # Update existing model's metadata from manifest
+                model.provider = provider
+                model.name_pattern = pattern
+
+            # Create lookup table for existing token prices by (token_type, is_prompt)
+            # Using pop() during iteration allows us to track which prices are no longer needed
+            token_prices = {
+                _TokenTypeKey(token_price.token_type, token_price.is_prompt): token_price
+                for token_price in model.token_prices
+            }
+
+            # Synchronize token prices for all supported token types
+            for token_type, is_prompt in token_types:
+                # Skip if this token type has no rate in the manifest
+                if not (base_rate := model_data.get(token_type)):
+                    continue
+
+                key = _TokenTypeKey(token_type, is_prompt)
+                # Remove from tracking dict and get existing price (if any)
+                if not (token_price := token_prices.pop(key, None)):
+                    # Create new token price if it doesn't exist
+                    token_price = models.TokenPrice(
+                        token_type=token_type,
+                        is_prompt=is_prompt,
+                        base_rate=base_rate,
+                    )
+                    model.token_prices.append(token_price)
+                elif token_price.base_rate != base_rate:
+                    # Update existing price if rate has changed
+                    token_price.base_rate = base_rate
+
+            # Remove any token prices that are no longer in the manifest
+            # These are prices that weren't popped from the token_prices dict above
+            for token_price in token_prices.values():
+                model.token_prices.remove(token_price)
+
+    # Clean up built-in models that are no longer in the manifest
+    # These are models that weren't popped from built_in_models dict above
+    remaining_models = list(built_in_models.values())
+    if not remaining_models:
+        return
+
+    # Soft delete obsolete built-in models
+    async with db() as session:
+        await session.execute(
+            sa.update(models.GenerativeModel)
+            .values(deleted_at=sa.func.now())
+            .where(models.GenerativeModel.id.in_([m.id for m in remaining_models]))
+        )