refactor(BA-5983): defer default-value application to strict Pydantic types

``ModelHealthCheckDraft.to_resolved`` and
``ModelServiceConfigDraft.to_resolved`` previously duplicated every
default value (``10.0``, ``10``, ``15.0``, ``200``, ``60.0`` for the
health-check fields; ``[]`` and ``"/bin/bash"`` for the service
config) inline as ``if self.x is not None else <default>`` branches.
Those literals were already declared on the strict ``ModelHealthCheck``
/ ``ModelServiceConfig`` classes via ``Field(default=...)``, so the
project carried the same constants in two places at risk of drift.

Switch ``to_resolved`` to drop ``None`` scalars via
``model_dump(exclude_none=True)`` and let the strict type's field
defaults apply during ``model_validate``/constructor call. Required-
field checks (``path``, ``port``) stay as explicit ``ValueError``
raises so the error message remains domain-specific rather than a
generic ``pydantic.ValidationError``. The nested ``health_check``
draft is resolved out-of-band before the strict service config is
composed, since it carries its own required-field check.

Behavior-preserving:

- Every ``Field(default=...)`` on the strict type matches the
  literal the old code wrote inline (verified field-by-field).
- ``pre_start_actions``: old ``or []`` and new ``exclude_none=True``
  produce identical results for the two reachable shapes (``None``
  and ``list[PreStartAction]``).
- Field-level constraints (``gt``, ``ge``) still fire because both
  the old constructor call and the new ``model_validate`` execute
  Pydantic validators.

Existing tests in test_config / test_revision_draft_merge /
test_model_definition_start_command_compat / test_revision_draft_reader
still pass.

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

Author: jopemachine

src/ai/backend/common/config.py

@@ -534,16 +534,9 @@ class ModelHealthCheckDraft(BaseConfigModel):
     def to_resolved(self) -> ModelHealthCheck:
         if self.path is None:
             raise ValueError("ModelHealthCheck.path is required")
-        return ModelHealthCheck(
-            interval=self.interval if self.interval is not None else 10.0,
-            path=self.path,
-            max_retries=self.max_retries if self.max_retries is not None else 10,
-            max_wait_time=self.max_wait_time if self.max_wait_time is not None else 15.0,
-            expected_status_code=(
-                self.expected_status_code if self.expected_status_code is not None else 200
-            ),
-            initial_delay=self.initial_delay if self.initial_delay is not None else 60.0,
-        )
+        # Drop unset (None) fields so the strict type's ``Field(default=...)``
+        # declarations remain the single source of truth for default values.
+        return ModelHealthCheck.model_validate(self.model_dump(exclude_none=True))
 
 
 class ModelServiceConfigDraft(BaseConfigModel):
@@ -561,12 +554,13 @@ def _coerce_start_command(cls, value: Any) -> Any:
     def to_resolved(self) -> ModelServiceConfig:
         if self.port is None:
             raise ValueError("ModelServiceConfig.port is required")
+        # Drop unset (None) scalars so the strict type's ``Field(default=...)``
+        # declarations remain the single source of truth for default values;
+        # resolve the nested ``health_check`` draft explicitly so its own
+        # required-field check (``path``) fires with a clear error message.
         return ModelServiceConfig(
-            pre_start_actions=self.pre_start_actions or [],
-            start_command=self.start_command,
-            shell=self.shell if self.shell is not None else "/bin/bash",
-            port=self.port,
-            health_check=(self.health_check.to_resolved() if self.health_check else None),
+            **self.model_dump(exclude_none=True, exclude={"health_check"}),
+            health_check=self.health_check.to_resolved() if self.health_check else None,
         )