feat(BA-5978): make BackendAIModel.build_validation_error overridable

Add a public ``build_validation_error`` classmethod on
``BackendAIModel`` that returns the ``BackendAIError`` instance to
raise when ``model_validate*`` fails. Default surfaces the generic
``BackendAIModelValidationFailed``; subclasses override the method to
inject a domain-specific 400 directly, without any caller-side
try/except re-wrap.

Apply the override on the two models that previously needed wrapping:

* ``ModelDefinition`` raises ``ModelDefinitionValidationError``.
  Moved that exception class from ``ai.backend.agent.errors.agent``
  to ``ai.backend.common.exception`` (and dropped the agent re-export)
  so the model — which lives in ``common.config`` — can construct it
  without an upward-layer import. The agent-specific error_type URL
  segment is dropped in the move.
* ``SessionSpec`` raises ``IncompleteSessionSpec`` with the existing
  ``extra_data["missing"]`` shape, using a module-local
  ``_format_loc`` helper.

The caller-side try/except wrappers around ``ModelDefinition.model_validate``
in ``agent/agent.py`` and ``manager/services/model_card/service.py``,
and the wrapper in
``sokovan/scheduling_controller/preparers/session_spec_preparer.py``,
are all removed — the models now raise the right domain error
directly.

Tests stay unchanged: they still expect ``IncompleteSessionSpec`` /
``ModelDefinitionValidationError`` because the override raises the
same types.

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

Author: jopemachine

src/ai/backend/agent/agent.py

@@ -158,7 +158,6 @@
     AbstractEvent,
 )
 from ai.backend.common.exception import (
-    BackendAIModelValidationFailed,
     ConfigurationError,
     VolumeMountFailed,
 )
@@ -236,7 +235,6 @@
     ImagePullTimeoutError,
     ModelDefinitionEmptyError,
     ModelDefinitionNotFoundError,
-    ModelDefinitionValidationError,
     ModelFolderNotSpecifiedError,
     PortConflictError,
     ReservedPortError,
@@ -3295,13 +3293,7 @@ async def _load_model_definition(
                 f" vFolder {model_folder.name} (ID {model_folder.vfid})",
             )
 
-        try:
-            parsed = ModelDefinition.model_validate(inlined)
-        except BackendAIModelValidationFailed as e:
-            raise ModelDefinitionValidationError(
-                "Failed to validate model definition for vFolder"
-                f" {model_folder.name} (ID {model_folder.vfid})",
-            ) from e
+        parsed = ModelDefinition.model_validate(inlined)
         if not parsed.models:
             raise ModelDefinitionEmptyError
         model_definition = parsed.model_dump(mode="json")

src/ai/backend/agent/errors/__init__.py

@@ -20,7 +20,6 @@
     ModelDefinitionEmptyError,
     ModelDefinitionInvalidYAMLError,
     ModelDefinitionNotFoundError,
-    ModelDefinitionValidationError,
     ModelFolderNotSpecifiedError,
     PortConflictError,
     ReservedPortError,
@@ -64,7 +63,6 @@
     "ModelDefinitionEmptyError",
     "ModelDefinitionInvalidYAMLError",
     "ModelDefinitionNotFoundError",
-    "ModelDefinitionValidationError",
     "ModelFolderNotSpecifiedError",
     "PortConflictError",
     "ReservedPortError",

src/ai/backend/agent/errors/agent.py

@@ -169,20 +169,6 @@ def error_code(self) -> ErrorCode:
         )
 
 
-class ModelDefinitionValidationError(BackendAIError, web.HTTPBadRequest):
-    """Raised when model definition validation fails."""
-
-    error_type = "https://api.backend.ai/probs/agent/model-definition-validation-failed"
-    error_title = "Model definition validation failed."
-
-    def error_code(self) -> ErrorCode:
-        return ErrorCode(
-            domain=ErrorDomain.MODEL_SERVICE,
-            operation=ErrorOperation.ACCESS,
-            error_detail=ErrorDetail.INVALID_PARAMETERS,
-        )
-
-
 class ModelFolderNotSpecifiedError(BackendAIError, web.HTTPBadRequest):
     """Raised when no model virtual folder is specified."""
 

src/ai/backend/common/config.py

@@ -5,7 +5,7 @@
 import sys
 from collections.abc import Mapping, MutableMapping
 from pathlib import Path
-from typing import Any
+from typing import Any, override
 
 import humps
 import tomli
@@ -19,8 +19,8 @@
 
 from . import validators as tx
 from .etcd import AsyncEtcd, ConfigScopes
-from .exception import ConfigurationError
-from .types import BackendAIModel, RedisHelperConfig
+from .exception import BackendAIError, ConfigurationError, ModelDefinitionValidationError
+from .types import BackendAIModel, ModelValidationFailureInfo, RedisHelperConfig
 
 __all__ = (
     "ConfigurationError",
@@ -477,6 +477,14 @@ class ModelDefinition(BaseConfigModel):
         description="List of models in the model definition.",
     )
 
+    @override
+    @classmethod
+    def build_validation_error(cls, info: ModelValidationFailureInfo) -> BackendAIError:
+        return ModelDefinitionValidationError(
+            extra_msg=info.summary,
+            extra_data={"errors": info.errors},
+        )
+
     def merge(self, override: ModelDefinition) -> ModelDefinition:
         """Merge the given override into this definition, returning a new instance."""
         return _merge_definition(self, override)
@@ -664,6 +672,14 @@ class ModelDefinitionDraft(BaseConfigModel):
 
     models: list[ModelConfigDraft] | None = None
 
+    @override
+    @classmethod
+    def build_validation_error(cls, info: ModelValidationFailureInfo) -> BackendAIError:
+        return ModelDefinitionValidationError(
+            extra_msg=info.summary,
+            extra_data={"errors": info.errors},
+        )
+
     def merge(self, override: ModelDefinitionDraft) -> ModelDefinitionDraft:
         """Merge ``override`` over ``self`` and return a new draft.
 

src/ai/backend/common/exception.py

@@ -1,18 +1,16 @@
 from __future__ import annotations
 
 import enum
-import logging
 from abc import ABC, abstractmethod
 from collections.abc import Mapping
 from dataclasses import dataclass
 from typing import Any, Self
 
 from aiohttp import web
+from pydantic_core import ErrorDetails
 
 from .json import dump_json
 
-log = logging.getLogger(__spec__.name)
-
 
 class ConfigurationError(Exception):
     invalid_data: Mapping[str, Any]
@@ -447,13 +445,10 @@ def error_code(self) -> ErrorCode:
 
 
 class BackendAIModelValidationFailed(BackendAIError, web.HTTPBadRequest):
-    """Generic 400 raised when a :class:`BackendAIModel` fails validation.
+    """Default 400 raised by :class:`BackendAIModel.build_validation_error`.
 
-    Distinct from :class:`InvalidAPIParameters` so callers can tell
-    "this came from a Pydantic model validator" apart from "this came
-    from an explicit API parameter check," and so domain-specific
-    handlers can choose to catch and re-wrap one without affecting the
-    other.
+    Kept distinct from :class:`InvalidAPIParameters` so handlers can
+    catch one without picking up the other.
     """
 
     error_type = "https://api.backend.ai/probs/model-validation-failed"
@@ -466,6 +461,33 @@ def error_code(self) -> ErrorCode:
             error_detail=ErrorDetail.INVALID_PARAMETERS,
         )
 
+    def errors(self) -> list[ErrorDetails]:
+        """Per-field errors in the same shape as
+        ``pydantic.ValidationError.errors()``. Empty when no
+        ``extra_data["errors"]`` is attached."""
+        if not self.extra_data:
+            return []
+        return list(self.extra_data.get("errors") or [])
+
+
+class ModelDefinitionValidationError(BackendAIError, web.HTTPBadRequest):
+    """400 raised by ``ModelDefinition.model_validate`` (via its
+    :meth:`BackendAIModel.build_validation_error` override).
+
+    Lives in ``common`` so ``ModelDefinition`` (also in ``common``) can
+    construct it without an upward-layer import.
+    """
+
+    error_type = "https://api.backend.ai/probs/model-definition-validation-failed"
+    error_title = "Model definition validation failed."
+
+    def error_code(self) -> ErrorCode:
+        return ErrorCode(
+            domain=ErrorDomain.MODEL_SERVICE,
+            operation=ErrorOperation.ACCESS,
+            error_detail=ErrorDetail.INVALID_PARAMETERS,
+        )
+
 
 class DeprecatedAPI(BackendAIError, web.HTTPBadRequest):
     error_type = "https://api.backend.ai/probs/deprecated"

src/ai/backend/common/types.py

@@ -51,10 +51,12 @@
     TypeAdapter,
     ValidationError,
 )
+from pydantic_core import ErrorDetails
 from redis.asyncio import Redis
 
 from .defs import UNKNOWN_CONTAINER_ID, RedisRole
 from .exception import (
+    BackendAIError,
     BackendAIModelValidationFailed,
     GenericNotImplementedError,
     InvalidIpAddressValue,
@@ -116,6 +118,7 @@
     "MetricValue",
     "ModelServiceProfile",
     "ModelServiceStatus",
+    "ModelValidationFailureInfo",
     "MountExpression",
     "MountInfoEntry",
     "MountPermission",
@@ -181,56 +184,70 @@
 )
 
 
+@dataclass(frozen=True)
+class ModelValidationFailureInfo:
+    """Pydantic-decoupled view of a failed ``model_validate*`` call,
+    passed to :meth:`BackendAIModel.build_validation_error`.
+
+    ``summary`` is ``str(pydantic.ValidationError)``; ``errors`` is
+    ``exc.errors()`` as-is.
+    """
+
+    summary: str
+    errors: list[ErrorDetails]
+
+
 class BackendAIModel(BaseModel):
-    """Project-wide Pydantic base for Backend.AI models.
-
-    Overrides ``model_validate`` / ``model_validate_json`` /
-    ``model_validate_strings`` so a ``ValidationError`` is auto-mapped
-    to :class:`BackendAIModelValidationFailed` (HTTP 400) carrying the structured
-    per-field error list. Call sites get a clean 4xx without repeating
-    ``try / except ValidationError`` at every site.
-
-    Notes:
-
-    * Pydantic v2 routes nested validation through
-      ``__pydantic_validator__`` directly, not the classmethod, so this
-      override only affects explicit ``Model.model_validate(...)``
-      calls — nested models are unaffected.
-    * The ``__init__`` constructor and the compiled validator stay
-      untouched, so internal default-value construction
-      (``Model()`` / ``Model(field=...)``) still works exactly like
-      stock Pydantic.
+    """Pydantic base whose ``model_validate`` / ``model_validate_json``
+    auto-map ``ValidationError`` to a :class:`BackendAIError` (HTTP 4xx)
+    via :meth:`build_validation_error`. Subclasses override the
+    classmethod to inject a domain-specific 400::
+
+        class MyConfig(BackendAIModel):
+            @override
+            @classmethod
+            def build_validation_error(
+                cls, info: ModelValidationFailureInfo
+            ) -> BackendAIError:
+                return MyConfigParseError(
+                    extra_msg=info.summary,
+                    extra_data={"errors": info.errors},
+                )
+
+    ``__init__`` is left alone: pydantic v2 invokes nested models'
+    ``__init__`` from inside the outer validator, so converting there
+    would break ``loc``-path aggregation. Direct ``Model(field=...)``
+    construction therefore still raises stock ``pydantic.ValidationError``;
+    switch the call site to ``Model.model_validate({...})`` to opt into
+    the override path.
     """
 
+    @classmethod
+    def build_validation_error(cls, info: ModelValidationFailureInfo) -> BackendAIError:
+        """Default override raising the generic
+        :class:`BackendAIModelValidationFailed`."""
+        return BackendAIModelValidationFailed(
+            extra_msg=info.summary,
+            extra_data={"errors": info.errors},
+        )
+
+    @classmethod
+    def _validation_failure_info(cls, exc: ValidationError) -> ModelValidationFailureInfo:
+        return ModelValidationFailureInfo(summary=str(exc), errors=exc.errors())
+
     @classmethod
     def model_validate(cls, *args: Any, **kwargs: Any) -> Self:
         try:
             return super().model_validate(*args, **kwargs)
         except ValidationError as e:
-            raise BackendAIModelValidationFailed(
-                extra_msg=str(e),
-                extra_data={"errors": e.errors()},
-            ) from e
+            raise cls.build_validation_error(cls._validation_failure_info(e)) from e
 
     @classmethod
     def model_validate_json(cls, *args: Any, **kwargs: Any) -> Self:
         try:
             return super().model_validate_json(*args, **kwargs)
         except ValidationError as e:
-            raise BackendAIModelValidationFailed(
-                extra_msg=str(e),
-                extra_data={"errors": e.errors()},
-            ) from e
-
-    @classmethod
-    def model_validate_strings(cls, *args: Any, **kwargs: Any) -> Self:
-        try:
-            return super().model_validate_strings(*args, **kwargs)
-        except ValidationError as e:
-            raise BackendAIModelValidationFailed(
-                extra_msg=str(e),
-                extra_data={"errors": e.errors()},
-            ) from e
+            raise cls.build_validation_error(cls._validation_failure_info(e)) from e
 
 
 class aobject:

src/ai/backend/manager/data/session/spec.py

@@ -17,22 +17,30 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
-from typing import Any
+from typing import Any, override
 from uuid import UUID
 
 import yarl
 from pydantic import ConfigDict, Field
 
+from ai.backend.common.exception import BackendAIError
 from ai.backend.common.identifier.domain import DomainName
 from ai.backend.common.identifier.project import ProjectID
 from ai.backend.common.identifier.resource_group import ResourceGroupName
 from ai.backend.common.identifier.session import SessionID
-from ai.backend.common.types import AccessKey, BackendAIModel, SessionTypes, VFolderMount
+from ai.backend.common.types import (
+    AccessKey,
+    BackendAIModel,
+    ModelValidationFailureInfo,
+    SessionTypes,
+    VFolderMount,
+)
 from ai.backend.manager.data.session.options import (
     InternalDataExtras,
     KernelExecutionSpec,
     SessionOptions,
 )
+from ai.backend.manager.errors.kernel import IncompleteSessionSpec
 from ai.backend.manager.models.network import NetworkType
 
 
@@ -138,3 +146,22 @@ class SessionSpec(_SpecBaseModel):
     options: SessionOptions
     kernel_specs: tuple[KernelSpec, ...]
     internal_data_extras: InternalDataExtras = Field(default_factory=InternalDataExtras)
+
+    @override
+    @classmethod
+    def build_validation_error(cls, info: ModelValidationFailureInfo) -> BackendAIError:
+        missing_paths = [cls._format_loc(tuple(err["loc"])) for err in info.errors]
+        return IncompleteSessionSpec(
+            extra_msg="SessionSpec fields not resolved: " + ", ".join(missing_paths),
+            extra_data={"missing": missing_paths},
+        )
+
+    @staticmethod
+    def _format_loc(loc: tuple[object, ...]) -> str:
+        parts: list[str] = []
+        for item in loc:
+            if isinstance(item, int):
+                parts.append(f"[{item}]")
+            else:
+                parts.append(f".{item}" if parts else str(item))
+        return "".join(parts)