refactor(BA-5528): move print_summary onto entry, split clear, drop raw dict iter

Address review comments on PR #11344:

- types.py: add DeploymentChatCacheEntry.print_summary classmethod that
  owns the full per-deployment display (deployment_id header + entry
  fields + masked api_key line). The caller passes a pre-masked token
  string so the type stays free of the mask_token helper. The free
  function _print_entry in commands.py is gone.
- commands.py: split chat-config clear into chat-config clear-cache and
  chat-config clear-token. One name doing two jobs (wipe endpoint cache
  AND user-supplied token) was misleading; each subcommand now touches
  exactly one store.
- utils.py: replace the manual deployments / tokens dict-walking +
  per-entry model_validate with a single DeploymentChatCache.model_validate
  / DeploymentChatConfig.model_validate call. Pydantic now does both UUID
  key parsing and entry validation; per-record resilience downgrades to
  per-file resilience (a tampered file falls back to an empty store).

Tests retire the per-entry skip cases since the loader is fail-all-or-
none now, but still verify that an invalid UUID key or malformed entry
yields an empty store rather than crashing.

Author: jopemachine

src/ai/backend/client/cli/v2/deployment/chat/commands.py

@@ -261,42 +261,31 @@ def show(deployment_id: UUID) -> None:
     token = chat_config_store.get_token(deployment_id)
     if entry is None and token is None:
         raise click.ClickException(f"No chat cache entry for deployment {deployment_id}.")
-    _print_entry(deployment_id, entry, token)
+    DeploymentChatCacheEntry.print_summary(deployment_id, entry, mask_token(token))
 
 
-@chat_config.command(name="clear")
+@chat_config.command(name="clear-cache")
 @click.argument("deployment_id", type=click.UUID)
-def clear(deployment_id: UUID) -> None:
-    """Remove the chat cache entry and stored token for a deployment."""
+def clear_cache(deployment_id: UUID) -> None:
+    """Remove the cached endpoint entry for a deployment."""
     cache = load_chat_cache()
-    chat_config_store = load_chat_config()
-
-    removed_entry = cache.remove(deployment_id)
-    removed_token = chat_config_store.clear_token(deployment_id)
-    if removed_entry:
+    if cache.remove(deployment_id):
         save_chat_cache(cache)
-    if removed_token:
-        save_chat_config(chat_config_store)
-    if removed_entry or removed_token:
-        print(f"Removed chat cache entry for deployment {deployment_id}.")
+        print(f"Removed cache entry for deployment {deployment_id}.")
     else:
-        print(f"No chat cache entry for deployment {deployment_id}.")
+        print(f"No cache entry for deployment {deployment_id}.")
 
 
-def _print_entry(
-    deployment_id: UUID,
-    entry: DeploymentChatCacheEntry | None,
-    token: str | None,
-) -> None:
-    print(f"deployment_id : {deployment_id}")
-    if entry is not None:
-        for line in entry.format_summary():
-            print(line)
+@chat_config.command(name="clear-token")
+@click.argument("deployment_id", type=click.UUID)
+def clear_token(deployment_id: UUID) -> None:
+    """Remove the stored API key for a deployment."""
+    chat_config_store = load_chat_config()
+    if chat_config_store.clear_token(deployment_id):
+        save_chat_config(chat_config_store)
+        print(f"Removed token for deployment {deployment_id}.")
     else:
-        print("endpoint_url  : -")
-        print("default_model : -")
-        print("last_synced_at: -")
-    print(f"api_key       : {mask_token(token)}")
+        print(f"No token for deployment {deployment_id}.")
 
 
 __all__ = ("chat", "chat_config")

src/ai/backend/client/cli/v2/deployment/chat/types.py

@@ -24,6 +24,23 @@ def format_summary(self) -> list[str]:
             f"last_synced_at: {self.last_synced_at.isoformat()}",
         ]
 
+    @classmethod
+    def print_summary(
+        cls,
+        deployment_id: UUID,
+        entry: DeploymentChatCacheEntry | None,
+        token_display: str,
+    ) -> None:
+        print(f"deployment_id : {deployment_id}")
+        if entry is not None:
+            for line in entry.format_summary():
+                print(line)
+        else:
+            print("endpoint_url  : -")
+            print("default_model : -")
+            print("last_synced_at: -")
+        print(f"api_key       : {token_display}")
+
 
 class DeploymentChatCache(BaseModel):
     """In-memory representation of the chat cache file."""

src/ai/backend/client/cli/v2/deployment/chat/utils.py

@@ -16,13 +16,11 @@
 import tempfile
 from pathlib import Path
 from typing import Any
-from uuid import UUID
 
 from pydantic import ValidationError
 
 from ai.backend.client.cli.v2.deployment.chat.types import (
     DeploymentChatCache,
-    DeploymentChatCacheEntry,
     DeploymentChatConfig,
 )
 from ai.backend.client.cli.v2.helpers import CONFIG_DIR
@@ -37,21 +35,10 @@ def load_chat_cache(path: Path = CHAT_CACHE_FILE) -> DeploymentChatCache:
     raw = _read_json(path)
     if raw is None:
         return DeploymentChatCache()
-    deployments: dict[UUID, DeploymentChatCacheEntry] = {}
-    deployments_raw = raw.get("deployments") or {}
-    if isinstance(deployments_raw, dict):
-        for key, value in deployments_raw.items():
-            try:
-                dep_id = UUID(str(key))
-            except ValueError:
-                continue
-            if not isinstance(value, dict):
-                continue
-            try:
-                deployments[dep_id] = DeploymentChatCacheEntry.model_validate(value)
-            except ValidationError:
-                continue
-    return DeploymentChatCache(deployments=deployments)
+    try:
+        return DeploymentChatCache.model_validate(raw)
+    except ValidationError:
+        return DeploymentChatCache()
 
 
 def save_chat_cache(cache: DeploymentChatCache, path: Path = CHAT_CACHE_FILE) -> None:
@@ -64,17 +51,10 @@ def load_chat_config(path: Path = CHAT_CONFIG_FILE) -> DeploymentChatConfig:
     raw = _read_json(path)
     if raw is None:
         return DeploymentChatConfig()
-    tokens: dict[UUID, str] = {}
-    tokens_raw = raw.get("tokens") or {}
-    if isinstance(tokens_raw, dict):
-        for key, value in tokens_raw.items():
-            try:
-                dep_id = UUID(str(key))
-            except ValueError:
-                continue
-            if isinstance(value, str):
-                tokens[dep_id] = value
-    return DeploymentChatConfig(tokens=tokens)
+    try:
+        return DeploymentChatConfig.model_validate(raw)
+    except ValidationError:
+        return DeploymentChatConfig()
 
 
 def save_chat_config(config: DeploymentChatConfig, path: Path = CHAT_CONFIG_FILE) -> None:

tests/unit/client/cli/test_deployment_chat_utils.py

@@ -5,7 +5,7 @@
 import stat
 from datetime import UTC, datetime
 from pathlib import Path
-from uuid import UUID, uuid4
+from uuid import uuid4
 
 import pytest
 
@@ -100,9 +100,8 @@ def test_load_returns_empty_when_top_level_not_object(self, tmp_path: Path) -> N
         path.write_text("[]", encoding="utf-8")
         assert load_chat_cache(path).deployments == {}
 
-    def test_load_skips_invalid_uuid_keys(self, tmp_path: Path) -> None:
+    def test_load_returns_empty_on_invalid_uuid_key(self, tmp_path: Path) -> None:
         path = tmp_path / "cache.json"
-        good_id = UUID("12345678-1234-5678-1234-567812345678")
         path.write_text(
             json.dumps({
                 "deployments": {
@@ -111,37 +110,23 @@ def test_load_skips_invalid_uuid_keys(self, tmp_path: Path) -> None:
                         "default_model": None,
                         "last_synced_at": "2026-04-27T12:00:00+00:00",
                     },
-                    str(good_id): {
-                        "endpoint_url": "https://y.example",
-                        "default_model": "m",
-                        "last_synced_at": "2026-04-27T12:00:00+00:00",
-                    },
                 },
             }),
             encoding="utf-8",
         )
-        loaded = load_chat_cache(path)
-        assert list(loaded.deployments.keys()) == [good_id]
+        assert load_chat_cache(path).deployments == {}
 
-    def test_load_skips_malformed_entry_payload(self, tmp_path: Path) -> None:
+    def test_load_returns_empty_on_malformed_entry_payload(self, tmp_path: Path) -> None:
         path = tmp_path / "cache.json"
-        good_id = UUID("12345678-1234-5678-1234-567812345678")
-        bad_id = UUID("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")
         path.write_text(
             json.dumps({
                 "deployments": {
-                    str(bad_id): {"default_model": "m"},
-                    str(good_id): {
-                        "endpoint_url": "https://y.example",
-                        "default_model": "m",
-                        "last_synced_at": "2026-04-27T12:00:00+00:00",
-                    },
+                    "12345678-1234-5678-1234-567812345678": {"default_model": "m"},
                 },
             }),
             encoding="utf-8",
         )
-        loaded = load_chat_cache(path)
-        assert list(loaded.deployments.keys()) == [good_id]
+        assert load_chat_cache(path).deployments == {}
 
 
 class TestConfigLoaderResilience:
@@ -150,20 +135,13 @@ def test_load_returns_empty_on_corrupt_json(self, tmp_path: Path) -> None:
         path.write_text("not-json{", encoding="utf-8")
         assert load_chat_config(path).tokens == {}
 
-    def test_load_skips_invalid_uuid_keys(self, tmp_path: Path) -> None:
+    def test_load_returns_empty_on_invalid_uuid_key(self, tmp_path: Path) -> None:
         path = tmp_path / "config.json"
-        good_id = UUID("12345678-1234-5678-1234-567812345678")
         path.write_text(
-            json.dumps({
-                "tokens": {
-                    "not-a-uuid": "sk-x",
-                    str(good_id): "sk-y",
-                },
-            }),
+            json.dumps({"tokens": {"not-a-uuid": "sk-x"}}),
             encoding="utf-8",
         )
-        loaded = load_chat_config(path)
-        assert loaded.tokens == {good_id: "sk-y"}
+        assert load_chat_config(path).tokens == {}
 
 
 class TestMaskToken: