refactor: align REST deployment surface with the v2 GQL scope-id-only shape

Drop nested revision / policy / id-list payloads from
``ModelDeploymentData`` so the projection only ever carries the endpoint
row's own columns. The v2 GQL node already exposes only scope IDs and
defers the revision spec / policy / replica list / auto-scaling rules /
access tokens to dedicated DataLoader resolvers; the v1 REST surface
now mirrors that — clients fetch the spec through the nested endpoints
(``/deployments/{id}/revisions/{revision_id}``,
``/deployments/{id}/policy``, etc.). **Breaking change for v1 REST**:
``DeploymentDTO.current_revision`` and ``DeploymentDTO.deployment_policy``
are removed; ``current_revision_id`` and ``deploying_revision_id`` are
exposed instead.

With the projection no longer touching ``EndpointRow.current_revision_row``
/ ``deploying_revision_row`` / ``deployment_policy``, the four search /
get paths that consume ``to_model_deployment_data`` drop their
``selectinload`` chains — each was incurring a per-row dead eager load.
The v2 ``DeploymentNode.policy`` field is removed for the same reason
(GQL never read it; the resolver always went through the policy
DataLoader). The v1 handler's revision-variant resolver is no longer
needed on the deployment DTO path; ``_deployment_dto`` becomes
synchronous.

Tests:
- ``test_endpoint_projection`` drops the now-obsolete revision-row
  scenarios (the BA-5963 list-order regression is structurally
  impossible once the projection only reads columns) and keeps the
  column-pass-through plus the lifecycle status mapping pins.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jopemachine

src/ai/backend/common/dto/manager/deployment/response.py

@@ -135,11 +135,19 @@ class DeploymentDTO(BackendAISchema):
     default_deployment_strategy: DeploymentStrategy = Field(
         description="Default deployment strategy"
     )
-    current_revision: RevisionDTO | None = Field(
-        default=None, description="Current active revision"
+    current_revision_id: UUID | None = Field(
+        default=None,
+        description=(
+            "ID of the current active revision. Fetch the revision spec via"
+            " ``GET /deployments/{deployment_id}/revisions/{revision_id}``."
+        ),
     )
-    deployment_policy: DeploymentPolicyDTO | None = Field(
-        default=None, description="Deployment rollout policy"
+    deploying_revision_id: UUID | None = Field(
+        default=None,
+        description=(
+            "ID of the revision currently being deployed (in progress, not yet"
+            " active). Fetch the spec via the nested revision endpoint."
+        ),
     )
     sub_step: str | None = Field(
         default=None, description="Current deployment sub-step (e.g. provisioning, rolling_back)"

src/ai/backend/common/dto/manager/v2/deployment/response.py

@@ -26,7 +26,6 @@
     ClusterConfigInfoDTO,
     DeploymentMetadataInfoDTO,
     DeploymentNetworkAccessInfoDTO,
-    DeploymentPolicyInfo,
     DeploymentStrategyInfoDTO,
     ExtraVFolderMountGQLDTO,
     ModelDefinitionInfoDTO,
@@ -176,9 +175,6 @@ class DeploymentNode(BaseResponseModel):
         default=None,
         description="ID of the revision currently being deployed (in progress, not yet active)",
     )
-    policy: DeploymentPolicyInfo | None = Field(
-        default=None, description="Deployment update policy"
-    )
 
 
 class RouteNode(BaseResponseModel):

src/ai/backend/manager/api/adapters/deployment/adapter.py

@@ -98,13 +98,11 @@
     UpsertDeploymentPolicyPayload,
 )
 from ai.backend.common.dto.manager.v2.deployment.types import (
-    BlueGreenConfigInfo,
     BlueGreenStrategySpecInfo,
     ClusterConfigInfoDTO,
     DeploymentMetadataInfoDTO,
     DeploymentNetworkAccessInfoDTO,
     DeploymentOrderField,
-    DeploymentPolicyInfo,
     DeploymentStrategyInfoDTO,
     EnvironmentVariableEntryInfoDTO,
     EnvironmentVariablesInfoDTO,
@@ -117,7 +115,6 @@
     ReplicaStateInfo,
     ResourceConfigInfoDTO,
     RevisionOrderField,
-    RollingUpdateConfigInfo,
     RollingUpdateStrategySpecInfo,
     RouteOrderField,
 )
@@ -2229,26 +2226,6 @@ def _convert_replica_orders(orders: list[ReplicaOrder]) -> list[QueryOrder]:
 
     @staticmethod
     def _deployment_data_to_dto(data: ModelDeploymentData) -> DeploymentNode:
-        policy_info: DeploymentPolicyInfo | None = None
-        if data.policy is not None:
-            policy_spec = data.policy.strategy_spec
-            rolling: RollingUpdateConfigInfo | None = None
-            blue_green: BlueGreenConfigInfo | None = None
-            if isinstance(policy_spec, RollingUpdateSpec):
-                rolling = RollingUpdateConfigInfo(
-                    max_surge=policy_spec.max_surge,
-                    max_unavailable=policy_spec.max_unavailable,
-                )
-            elif isinstance(policy_spec, BlueGreenSpec):
-                blue_green = BlueGreenConfigInfo(
-                    auto_promote=policy_spec.auto_promote,
-                    promote_delay_seconds=policy_spec.promote_delay_seconds,
-                )
-            policy_info = DeploymentPolicyInfo(
-                strategy=data.policy.strategy,
-                rolling_update=rolling,
-                blue_green=blue_green,
-            )
         return DeploymentNode(
             id=data.id,
             metadata=DeploymentMetadataInfoDTO(
@@ -2278,7 +2255,6 @@ def _deployment_data_to_dto(data: ModelDeploymentData) -> DeploymentNode:
             scaling_state=data.scaling_state,
             current_revision_id=data.current_revision_id,
             deploying_revision_id=data.deploying_revision_id,
-            policy=policy_info,
         )
 
     @staticmethod

src/ai/backend/manager/api/rest/deployment/adapter.py

@@ -106,45 +106,16 @@
 class DeploymentAdapter(BaseFilterAdapter):
     """Adapter for converting deployment requests to repository queries."""
 
-    def __init__(
-        self,
-        *,
-        revision_adapter: RevisionAdapter,
-        policy_adapter: DeploymentPolicyAdapter,
-    ) -> None:
-        """Inject the sub-adapters this converter delegates to.
-
-        ``RevisionAdapter`` / ``DeploymentPolicyAdapter`` are the single
-        place that knows how to render a revision or policy surface into
-        a DTO — recomputing them per call would duplicate that knowledge
-        and lose the ability to swap implementations (e.g. testing).
+    def convert_to_dto(self, data: ModelDeploymentData) -> DeploymentDTO:
+        """Convert ModelDeploymentData to the v1 response DTO.
+
+        Surfaces ``current_revision_id`` and ``deploying_revision_id`` as
+        scope IDs only — mirrors the v2 GQL ``ModelDeployment`` node, which
+        likewise exposes only the IDs and defers the revision / policy
+        specs to dedicated DataLoader resolvers. Clients fetch the revision
+        spec through ``GET /deployments/{deployment_id}/revisions/{id}`` and
+        the policy through ``GET /deployments/{deployment_id}/policy``.
         """
-        self._revision_adapter = revision_adapter
-        self._policy_adapter = policy_adapter
-
-    def convert_to_dto(
-        self,
-        data: ModelDeploymentData,
-        runtime_variant_name: RuntimeVariant,
-    ) -> DeploymentDTO:
-        """Convert ModelDeploymentData to DTO.
-
-        ``runtime_variant_name`` is resolved by the caller (REST handler)
-        from ``data.revision.model_runtime_config.runtime_variant_id``
-        via the RuntimeVariant resolver path — the legacy REST response
-        preserves the historical name-based field so old clients keep
-        seeing the same shape.
-        """
-        current_revision = None
-        if data.revision:
-            current_revision = self._revision_adapter.convert_to_dto(
-                data.revision, runtime_variant_name
-            )
-
-        deployment_policy = None
-        if data.policy:
-            deployment_policy = self._policy_adapter.convert_to_dto(data.policy)
-
         return DeploymentDTO(
             id=data.id,
             name=data.metadata.name,
@@ -165,8 +136,8 @@ def convert_to_dto(
                 replica_ids=data.replica_state.replica_ids,
             ),
             default_deployment_strategy=data.default_deployment_strategy,
-            current_revision=current_revision,
-            deployment_policy=deployment_policy,
+            current_revision_id=data.current_revision_id,
+            deploying_revision_id=data.deploying_revision_id,
             sub_step=data.sub_step,
         )
 

src/ai/backend/manager/api/rest/deployment/handler.py

@@ -128,10 +128,7 @@ def __init__(
         self._runtime_variant_adapter = runtime_variant_adapter
         self._revision_adapter = RevisionAdapter()
         self._policy_adapter = DeploymentPolicyAdapter()
-        self._deployment_adapter = DeploymentAdapter(
-            revision_adapter=self._revision_adapter,
-            policy_adapter=self._policy_adapter,
-        )
+        self._deployment_adapter = DeploymentAdapter()
         self._route_adapter = RouteAdapter()
         self._create_deployment_adapter = CreateDeploymentAdapter()
         self._add_revision_adapter = AddRevisionAdapter()
@@ -145,29 +142,21 @@ async def _revision_dto(self, data: ModelRevisionData) -> RevisionDTO:
         resolving the runtime-variant id back to its name so the legacy
         shape stays stable.
         """
-        variant_name = await self._resolve_revision_variant_name(data)
-        return self._revision_adapter.convert_to_dto(data, variant_name)
-
-    async def _resolve_revision_variant_name(self, data: ModelRevisionData) -> RuntimeVariant:
-        """Resolve the runtime-variant name from a revision's variant id."""
         variant_node = await self._runtime_variant_adapter.get(
             data.model_runtime_config.runtime_variant_id
         )
-        return RuntimeVariant(variant_node.name)
+        return self._revision_adapter.convert_to_dto(data, RuntimeVariant(variant_node.name))
 
-    async def _deployment_dto(self, data: ModelDeploymentData) -> DeploymentDTO:
-        """Render a deployment DTO with runtime-variant name pre-resolved.
+    def _deployment_dto(self, data: ModelDeploymentData) -> DeploymentDTO:
+        """Render a deployment DTO.
 
-        ``DeploymentAdapter.convert_to_dto`` expects the caller to provide
-        the runtime-variant name; when no current revision exists the
-        value is an empty ``RuntimeVariant`` sentinel since the adapter
-        drops ``current_revision`` anyway.
+        Synchronous now — the v1 response surface mirrors the v2 GQL node
+        and only carries ``current_revision_id`` / ``deploying_revision_id``,
+        so there is no nested revision to resolve here. Clients fetch the
+        revision spec through ``GET /deployments/{deployment_id}/revisions/{id}``
+        and the policy through ``GET /deployments/{deployment_id}/policy``.
         """
-        if data.revision is None:
-            variant_name = RuntimeVariant("")
-        else:
-            variant_name = await self._resolve_revision_variant_name(data.revision)
-        return self._deployment_adapter.convert_to_dto(data, variant_name)
+        return self._deployment_adapter.convert_to_dto(data)
 
     # Deployment Endpoints
 
@@ -192,7 +181,7 @@ async def create_deployment(
         )
 
         # Build response
-        resp = CreateDeploymentResponse(deployment=await self._deployment_dto(action_result.data))
+        resp = CreateDeploymentResponse(deployment=self._deployment_dto(action_result.data))
         return APIResponse.build(status_code=HTTPStatus.CREATED, response_model=resp)
 
     async def search_deployments(
@@ -214,7 +203,7 @@ async def search_deployments(
             SearchProjectDeploymentsAction(scope=scope, querier=querier)
         )
 
-        deployment_dtos = [await self._deployment_dto(dep) for dep in action_result.data]
+        deployment_dtos = [self._deployment_dto(dep) for dep in action_result.data]
         resp = ListDeploymentsResponse(
             deployments=deployment_dtos,
             pagination=PaginationInfo(
@@ -236,7 +225,7 @@ async def get_deployment(
         )
 
         # Build response
-        resp = GetDeploymentResponse(deployment=await self._deployment_dto(action_result.data))
+        resp = GetDeploymentResponse(deployment=self._deployment_dto(action_result.data))
         return APIResponse.build(status_code=HTTPStatus.OK, response_model=resp)
 
     async def update_deployment(
@@ -273,7 +262,7 @@ async def update_deployment(
         )
 
         # Build response
-        resp = UpdateDeploymentResponse(deployment=await self._deployment_dto(action_result.data))
+        resp = UpdateDeploymentResponse(deployment=self._deployment_dto(action_result.data))
         return APIResponse.build(status_code=HTTPStatus.OK, response_model=resp)
 
     async def destroy_deployment(

src/ai/backend/manager/data/deployment/types.py

@@ -1027,14 +1027,21 @@ class ReplicaStateData:
 
 @dataclass
 class ModelDeploymentData:
+    """API-shaped projection of an ``EndpointRow``.
+
+    Carries only the row's own columns (plus the metadata composite). Joined
+    children — current/deploying revision spec, deployment policy, replica
+    list, auto-scaling rules, access tokens — are NOT included; the v2 GQL
+    layer fetches each via its own DataLoader/resolver and v1 REST clients
+    follow up with the dedicated nested endpoints. The projection therefore
+    stays scope-id-only and requires no eager loads beyond the row itself.
+    """
+
     id: DeploymentID
     metadata: ModelDeploymentMetadataInfo
     network_access: DeploymentNetworkData
-    revision: ModelRevisionData | None
     current_revision_id: DeploymentRevisionID | None
     deploying_revision_id: DeploymentRevisionID | None
-    revision_history_ids: list[DeploymentRevisionID]
-    scaling_rule_ids: list[UUID]
     replica_state: ReplicaStateData
     default_deployment_strategy: DeploymentStrategy
     created_user_id: UUID
@@ -1043,8 +1050,6 @@ class ModelDeploymentData:
     # whether the endpoint is currently reconciling its replica count
     # (``SCALING``) or holding at the desired count (``STABLE``).
     scaling_state: ScalingState
-    policy: DeploymentPolicyData | None = None
-    access_token_ids: list[UUID] | None = None
     sub_step: DeploymentLifecycleSubStep | None = None
 
 

src/ai/backend/manager/models/endpoint/row.py

@@ -819,27 +819,16 @@ def _build_deployment_info(
     def to_model_deployment_data(self) -> ModelDeploymentData:
         """Project the row to the API-shaped ``ModelDeploymentData``.
 
-        Eager-load requirements: ``current_revision_row`` (and
-        ``deploying_revision_row`` if the spec is needed) plus
-        ``deployment_policy``. Mirrors the relationship usage in
-        ``to_deployment_info`` so the projection follows the same
-        column-direct lookup as the BA-6056 split — no list scan over
-        ``revisions``. ``current_revision_id`` / ``deploying_revision_id``
-        surface directly from the row columns; the joined ``revision``
-        spec is ``None`` when the row was not eager-loaded (callers can
-        still act on the ID).
+        Reads only the row's own columns — no relationship access — so the
+        caller does not need to eager-load anything beyond the endpoint
+        row itself. Joined children (revision spec, policy, replicas, etc.)
+        are surfaced through their dedicated DataLoader/resolver paths
+        (v2 GQL) or via the nested REST endpoints (v1 REST); the projection
+        only carries scope IDs.
         """
-        revision: ModelRevisionData | None = None
-        if self.current_revision_row is not None:
-            revision = self.current_revision_row.to_data()
-
         desired_count = (
             self.desired_replicas if self.desired_replicas is not None else self.replicas
         )
-        policy_data = (
-            self.deployment_policy.to_data() if self.deployment_policy is not None else None
-        )
-
         return ModelDeploymentData(
             id=self.id,
             metadata=ModelDeploymentMetadataInfo(
@@ -858,11 +847,8 @@ def to_model_deployment_data(self) -> ModelDeploymentData:
                 url=self.url,
                 preferred_domain_name=None,
             ),
-            revision_history_ids=[self.current_revision] if self.current_revision else [],
-            revision=revision,
             current_revision_id=self.current_revision,
             deploying_revision_id=self.deploying_revision,
-            scaling_rule_ids=[],
             replica_state=ReplicaStateData(
                 desired_replica_count=desired_count,
                 replica_ids=[],
@@ -871,7 +857,6 @@ def to_model_deployment_data(self) -> ModelDeploymentData:
             created_user_id=self.created_user,
             options=self.options,
             scaling_state=self.scaling_state,
-            policy=policy_data,
             sub_step=self.sub_step,
         )
 

src/ai/backend/manager/repositories/deployment/db_source/db_source.py

@@ -413,15 +413,7 @@ async def get_deployment_data(
             EndpointNotFound: If the endpoint does not exist.
         """
         async with self._begin_readonly_session_read_committed() as db_sess:
-            query = (
-                sa.select(EndpointRow)
-                .where(EndpointRow.id == endpoint_id)
-                .options(
-                    selectinload(EndpointRow.current_revision_row),
-                    selectinload(EndpointRow.deploying_revision_row),
-                    selectinload(EndpointRow.deployment_policy),
-                )
-            )
+            query = sa.select(EndpointRow).where(EndpointRow.id == endpoint_id)
             result = await db_sess.execute(query)
             row: EndpointRow | None = result.scalar_one_or_none()
 
@@ -1148,11 +1140,7 @@ async def admin_search_deployments(
         the stack (db_source → repository → service).
         """
         async with self._begin_readonly_session_read_committed() as db_sess:
-            query = sa.select(EndpointRow).options(
-                selectinload(EndpointRow.current_revision_row),
-                selectinload(EndpointRow.deploying_revision_row),
-                selectinload(EndpointRow.deployment_policy),
-            )
+            query = sa.select(EndpointRow)
 
             result = await execute_batch_querier(
                 db_sess,
@@ -1181,11 +1169,7 @@ async def search_user_deployments(
         ``execute_batch_querier``'s ``scope`` argument.
         """
         async with self._begin_readonly_session_read_committed() as db_sess:
-            query = sa.select(EndpointRow).options(
-                selectinload(EndpointRow.current_revision_row),
-                selectinload(EndpointRow.deploying_revision_row),
-                selectinload(EndpointRow.deployment_policy),
-            )
+            query = sa.select(EndpointRow)
 
             result = await execute_batch_querier(
                 db_sess,
@@ -1215,11 +1199,7 @@ async def search_project_deployments(
         admin list pages. Backs the v2 adapter's ``project_search`` path.
         """
         async with self._begin_readonly_session_read_committed() as db_sess:
-            query = sa.select(EndpointRow).options(
-                selectinload(EndpointRow.current_revision_row),
-                selectinload(EndpointRow.deploying_revision_row),
-                selectinload(EndpointRow.deployment_policy),
-            )
+            query = sa.select(EndpointRow)
 
             result = await execute_batch_querier(
                 db_sess,