fix: Add endpoint_name fallback for orphaned K8s resource cleanup

When deleting endpoints, if the DB record doesn't exist but K8s resources
do (orphaned resources), we now support looking up by endpoint_name as a
fallback when endpoint_id lookup fails. This handles cases where the
endpoint_id passed might actually be an endpoint_name (e.g.,
mcpx-endpoint-{uuid}).

Changes:
- Add _get_deployment_by_endpoint_name_label method to query K8s by endpoint_name
- Update _cleanup_orphaned_k8s_resources to accept optional endpoint_name parameter
- Add fallback logic in DeleteModelEndpointByIdV1UseCase to try endpoint_name
  when model_endpoint_id looks like an endpoint_name

Author: ashwin-ranade

model-engine/model_engine_server/domain/use_cases/model_endpoint_use_cases.py

@@ -609,8 +609,17 @@ async def execute(self, user: User, model_endpoint_id: str) -> DeleteModelEndpoi
             )
 
             if isinstance(self.model_endpoint_service, LiveModelEndpointService):
+                # If model_endpoint_id looks like an endpoint_name (e.g., "mcpx-endpoint-{uuid}"),
+                # try it as endpoint_name fallback
+                endpoint_name = None
+                if model_endpoint_id.startswith("mcpx-endpoint-"):
+                    endpoint_name = model_endpoint_id
+                    # Try to extract endpoint_id from it (though we don't have it)
+                    # Will rely on endpoint_name lookup
+                    model_endpoint_id = model_endpoint_id  # Keep as-is for logging
+                
                 owner = await self.model_endpoint_service._cleanup_orphaned_k8s_resources(
-                    model_endpoint_id
+                    model_endpoint_id, endpoint_name=endpoint_name
                 )
                 if owner is not None:
                     # Verify authorization - user must match owner (created_by from K8s labels)

model-engine/model_engine_server/infra/gateways/resources/k8s_endpoint_resource_delegate.py

@@ -1191,6 +1191,34 @@ async def _get_deployment_by_endpoint_id_label(endpoint_id: str) -> Optional[V1D
             logger.exception(f"Error querying deployments by endpoint_id label {endpoint_id}")
             raise
 
+    @staticmethod
+    async def _get_deployment_by_endpoint_name_label(endpoint_name: str) -> Optional[V1Deployment]:
+        """
+        Gets a Deployment by querying K8s with endpoint_name label selector.
+        Used when DB record doesn't exist but K8s resources might (orphaned resources).
+
+        Args:
+            endpoint_name: The endpoint_name to search for (e.g., "mcpx-endpoint-{deploymentID}")
+
+        Returns:
+            The first deployment found with matching endpoint_name label, or None if not found
+        """
+        apps_client = get_kubernetes_apps_client()
+        label_selector = f"endpoint_name={endpoint_name}"
+        try:
+            deployments = await apps_client.list_namespaced_deployment(
+                namespace=hmi_config.endpoint_namespace,
+                label_selector=label_selector,
+            )
+            if deployments.items:
+                return deployments.items[0]
+            return None
+        except ApiException as e:
+            if e.status == 404:
+                return None
+            logger.exception(f"Error querying deployments by endpoint_name label {endpoint_name}")
+            raise
+
     @staticmethod
     async def _determine_endpoint_type_from_k8s(endpoint_id: str) -> ModelEndpointType:
         """

model-engine/model_engine_server/infra/services/live_model_endpoint_service.py

@@ -410,13 +410,16 @@ async def delete_model_endpoint(self, model_endpoint_id: str) -> None:
 
         logger.info(f"Endpoint delete released lock for {created_by}, {name}")
 
-    async def _cleanup_orphaned_k8s_resources(self, endpoint_id: str) -> Optional[str]:
+    async def _cleanup_orphaned_k8s_resources(
+        self, endpoint_id: str, endpoint_name: Optional[str] = None
+    ) -> Optional[str]:
         """
         Cleans up orphaned K8s resources when DB record doesn't exist.
         Returns the owner (created_by) from K8s labels if resources were found, None otherwise.
 
         Args:
             endpoint_id: The endpoint_id to check for orphaned resources
+            endpoint_name: Optional endpoint_name to try if endpoint_id lookup fails
 
         Returns:
             The owner (created_by) from K8s labels if resources found, None otherwise
@@ -425,6 +428,27 @@ async def _cleanup_orphaned_k8s_resources(self, endpoint_id: str) -> Optional[st
             deployment = await K8SEndpointResourceDelegate._get_deployment_by_endpoint_id_label(
                 endpoint_id
             )
+            # Fallback: try endpoint_name if endpoint_id lookup fails
+            if deployment is None and endpoint_name:
+                logger.info(
+                    f"endpoint_id {endpoint_id} not found, trying endpoint_name {endpoint_name}"
+                )
+                try:
+                    deployment = await K8SEndpointResourceDelegate._get_deployment_by_endpoint_name_label(
+                        endpoint_name
+                    )
+                    # If found by endpoint_name, extract endpoint_id from labels
+                    if deployment:
+                        labels = deployment.metadata.labels or {}
+                        endpoint_id = labels.get("endpoint_id", endpoint_id)
+                        logger.info(
+                            f"Found deployment by endpoint_name {endpoint_name}, extracted endpoint_id {endpoint_id}"
+                        )
+                    else:
+                        logger.info(f"No deployment found by endpoint_name {endpoint_name}")
+                except Exception as e:
+                    logger.exception(f"Error looking up deployment by endpoint_name {endpoint_name}: {e}")
+                    raise
             if deployment is None:
                 return None