fix(BA-7364): require the rate limit field on the auth response

A missing field defaulting to null reads as unlimited, so an incomplete
payload would silently disable the limit. Null stays a valid value — it is
what an unset limit means — but it now has to be sent explicitly.

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

Author: jopemachine

src/ai/backend/common/dto/manager/auth/types.py

@@ -58,7 +58,7 @@ class AuthSuccessResponse(AuthResponse):
     status: str
     session_token: str
     user_id: UserID
-    rate_limit: int | None = None
+    rate_limit: int | None
     type: AuthTokenType = AuthTokenType.KEYPAIR
 
     def to_dict(self) -> dict[str, Any]:

tests/unit/client_v2/test_auth_client.py

@@ -82,6 +82,7 @@ async def test_authorize(self, sample_client_type_id: UUID) -> None:
                     "status": "active",
                     "session_token": "test_session_token",
                     "user_id": "12345678-1234-5678-1234-567812345678",
+                    "rate_limit": None,
                     "type": AuthTokenType.KEYPAIR,
                 },
             }

tests/unit/common/dto/manager/auth/test_auth_response.py

@@ -34,6 +34,7 @@ def test_authorize_response() -> None:
         status="active",
         session_token="test_session_token",
         user_id=UserID(uuid4()),
+        rate_limit=None,
         type=AuthTokenType.KEYPAIR,
     )
     resp = AuthorizeResponse(data=data)

tests/unit/common/dto/manager/auth/test_auth_types.py

@@ -45,6 +45,7 @@ def test_auth_success_response_creation() -> None:
         status="active",
         session_token="test_session_token",
         user_id=UserID(uuid4()),
+        rate_limit=None,
     )
     assert resp.access_key == "AKTEST"
     assert resp.secret_key == "SKTEST"
@@ -62,6 +63,7 @@ def test_auth_success_response_to_dict() -> None:
         status="active",
         session_token="test_session_token",
         user_id=UserID(uuid4()),
+        rate_limit=None,
         type=AuthTokenType.JWT,
     )
     d = resp.to_dict()
@@ -123,6 +125,7 @@ def test_parse_auth_response_success() -> None:
         "status": "active",
         "session_token": "test_token",
         "user_id": "12345678-1234-5678-1234-567812345678",
+        "rate_limit": None,
     }
     result = parse_auth_response(data)
     assert isinstance(result, AuthSuccessResponse)
@@ -159,6 +162,7 @@ def test_parse_auth_response_explicit_success() -> None:
         "status": "active",
         "session_token": "test_token",
         "user_id": "12345678-1234-5678-1234-567812345678",
+        "rate_limit": None,
     }
     result = parse_auth_response(data)
     assert isinstance(result, AuthSuccessResponse)

tests/unit/common/dto/manager/v2/BUILD

@@ -0,0 +1,3 @@
+python_tests(
+    name="tests",
+)

tests/unit/common/dto/manager/v2/test_sentinel_wire_protocol.py

@@ -0,0 +1,132 @@
+"""The three input states must survive serialization as three distinct wire shapes.
+
+A field the caller never mentioned must be absent from the body, an explicit ``None``
+must survive as a JSON null, and a value must survive as itself. Collapsing any two of
+these makes "leave this alone" and "clear this" indistinguishable to the server.
+
+"Never mentioned" has two spellings — omitting the constructor argument and assigning
+``SENTINEL`` — and ``BaseRequestModel`` drops the latter from ``model_fields_set`` so
+that both produce the same body.
+"""
+
+from __future__ import annotations
+
+import importlib
+import pkgutil
+from dataclasses import dataclass
+from typing import Any, get_args
+
+import pytest
+
+import ai.backend.common.dto.manager.v2 as v2_dto
+from ai.backend.common.api_handlers import SENTINEL, BaseRequestModel, Sentinel
+
+# Mirrors client/v2/base_client.py, which is what actually puts a request on the wire.
+_WIRE_DUMP_KWARGS: dict[str, Any] = {"mode": "json", "exclude_unset": True}
+
+
+def _sentinel_fields() -> list[tuple[type[BaseRequestModel], str]]:
+    found: list[tuple[type[BaseRequestModel], str]] = []
+    for module in pkgutil.iter_modules(v2_dto.__path__):
+        try:
+            request_module = importlib.import_module(f"{v2_dto.__name__}.{module.name}.request")
+        except ModuleNotFoundError:
+            continue
+        for attribute in vars(request_module).values():
+            if not (isinstance(attribute, type) and issubclass(attribute, BaseRequestModel)):
+                continue
+            if attribute.__module__ != request_module.__name__:
+                continue
+            for name, info in attribute.model_fields.items():
+                if Sentinel in get_args(info.annotation):
+                    found.append((attribute, name))
+    return found
+
+
+@dataclass(frozen=True)
+class _WireExpectation:
+    key_present: bool
+    value: Any
+
+
+@dataclass(frozen=True)
+class _StateCase:
+    label: str
+    kwargs: dict[str, Any]
+    expected: _WireExpectation
+
+
+class TestSentinelWireProtocol:
+    def test_every_sentinel_field_defaults_to_sentinel(self) -> None:
+        offenders = [
+            f"{cls.__module__.rsplit('.', 2)[-2]}.{cls.__name__}.{name}"
+            for cls, name in _sentinel_fields()
+            if cls.model_fields[name].default is not SENTINEL
+        ]
+        assert offenders == [], (
+            "Sentinel-typed fields must default to SENTINEL so that a field the caller "
+            f"never mentioned means 'no change': {offenders}"
+        )
+
+    @pytest.mark.parametrize(
+        "case",
+        [
+            _StateCase(
+                label="argument-omitted",
+                kwargs={},
+                expected=_WireExpectation(key_present=False, value=None),
+            ),
+            _StateCase(
+                label="sentinel-assigned",
+                kwargs={"field": SENTINEL},
+                expected=_WireExpectation(key_present=False, value=None),
+            ),
+            _StateCase(
+                label="explicit-null",
+                kwargs={"field": None},
+                expected=_WireExpectation(key_present=True, value=None),
+            ),
+            _StateCase(
+                label="value",
+                kwargs={"field": "a-value"},
+                expected=_WireExpectation(key_present=True, value="a-value"),
+            ),
+        ],
+        ids=lambda case: case.label,
+    )
+    def test_state_survives_serialization(self, case: _StateCase) -> None:
+        class _Model(BaseRequestModel):
+            field: str | Sentinel | None = SENTINEL
+
+        dumped = _Model(**case.kwargs).model_dump(**_WIRE_DUMP_KWARGS)
+        assert ("field" in dumped) is case.expected.key_present
+        if case.expected.key_present:
+            assert dumped["field"] == case.expected.value
+
+    def test_an_int_field_is_not_set_to_the_sentinels_enum_value(self) -> None:
+        """Why an assigned SENTINEL must not be serialized.
+
+        ``Sentinel.TOKEN`` is ``enum.auto()``, so ``mode="json"`` would render it as
+        ``1``; an int-typed field re-parses that as a value and the column would be set
+        to 1 instead of left alone.
+        """
+
+        class _Model(BaseRequestModel):
+            count: int | Sentinel | None = SENTINEL
+
+        dumped = _Model(count=SENTINEL).model_dump(**_WIRE_DUMP_KWARGS)
+        assert "count" not in dumped
+        assert _Model.model_validate(dumped).count is SENTINEL
+
+    def test_a_nested_model_drops_its_own_sentinels(self) -> None:
+        class _Nested(BaseRequestModel):
+            inner: str | Sentinel | None = SENTINEL
+
+        class _Outer(BaseRequestModel):
+            nested: _Nested
+            outer: str | Sentinel | None = SENTINEL
+
+        dumped = _Outer(nested=_Nested(inner=SENTINEL), outer=SENTINEL).model_dump(
+            **_WIRE_DUMP_KWARGS
+        )
+        assert dumped == {"nested": {}}