fix(minimax): apply empty live model catalogs

Author: elkaix

src/pythinker_code/auth/minimax.py

@@ -192,7 +192,12 @@ async def _fetch_minimax_models(
 ) -> tuple[MiniMaxModel, ...]:
     async with session.get(url, headers=headers, raise_for_status=True) as response:
         payload = await response.json(content_type=None)
-    return _parse_discovered_models(payload)
+    if not isinstance(payload, dict):
+        raise ValueError(f"Unexpected MiniMax models response for {url}")
+    payload_map = cast(dict[str, Any], payload)
+    if not isinstance(payload_map.get("data"), list):
+        raise ValueError(f"Unexpected MiniMax models response for {url}")
+    return _parse_discovered_models(payload_map)
 
 
 async def _discover_minimax_models(api_key: str) -> tuple[MiniMaxModel, ...]:
@@ -217,8 +222,7 @@ async def _discover_minimax_models(api_key: str) -> tuple[MiniMaxModel, ...]:
             except (aiohttp.ClientError, TimeoutError, ValueError) as exc:
                 errors.append(exc)
                 continue
-            if models:
-                return models
+            return models
 
     if auth_errors:
         raise auth_errors[0]
@@ -295,8 +299,7 @@ async def refresh_minimax_models(config: Config) -> tuple[MiniMaxModel, ...] | N
     api_key = _minimax_api_key(config)
     if api_key is None:
         return None
-    discovered = await _discover_minimax_models(api_key)
-    return discovered or None
+    return await _discover_minimax_models(api_key)
 
 
 async def login_minimax_api_key(
@@ -323,9 +326,7 @@ async def login_minimax_api_key(
 
     models = MINIMAX_MODELS
     try:
-        discovered = await _discover_minimax_models(resolved_key)
-        if discovered:
-            models = discovered
+        models = await _discover_minimax_models(resolved_key)
     except aiohttp.ClientResponseError as exc:
         if exc.status in {401, 403}:
             yield OAuthEvent("error", "Invalid MiniMax API key; the key was not saved.")

src/pythinker_code/auth/platforms.py

@@ -414,7 +414,7 @@ async def refresh_managed_models(config: Config) -> bool:
         minimax_models = await refresh_minimax_models(config)
     except (aiohttp.ClientError, TimeoutError, ValueError) as exc:
         logger.warning("Failed to refresh MiniMax models: {error}", error=exc)
-    if minimax_models and apply_minimax_models(config, minimax_models):
+    if minimax_models is not None and apply_minimax_models(config, minimax_models):
         changed = True
 
     if changed:
@@ -425,7 +425,7 @@ async def refresh_managed_models(config: Config) -> bool:
                 save_changed = True
         if opencode_go_models and apply_opencode_go_models(config_for_save, opencode_go_models):
             save_changed = True
-        if minimax_models and apply_minimax_models(config_for_save, minimax_models):
+        if minimax_models is not None and apply_minimax_models(config_for_save, minimax_models):
             save_changed = True
         if save_changed:
             save_config(config_for_save)

tests/auth/test_minimax_auth.py

@@ -171,26 +171,42 @@ async def fake_discover(api_key):
 
 @pytest.mark.asyncio
 async def test_login_minimax_token_plan_uses_discovered_available_subset(monkeypatch, tmp_path):
-    from pythinker_code.auth.minimax import MiniMaxModel, login_minimax_api_key
+    from pythinker_code.auth.minimax import MINIMAX_ANTHROPIC_MODELS_URL, login_minimax_api_key
 
     monkeypatch.setenv("PYTHINKER_SHARE_DIR", str(tmp_path))
     config = Config(is_from_default_location=True)
 
-    async def fake_discover(api_key):
-        assert api_key == "sk-cp-token-plan-abc"
-        return (
-            MiniMaxModel(
-                model_id="MiniMax-M2.7",
-                alias_suffix="m2.7",
-                display_name="MiniMax M2.7",
-            ),
-        )
+    class FakeResponse:
+        async def __aenter__(self):
+            return self
 
-    monkeypatch.setattr("pythinker_code.auth.minimax._discover_minimax_models", fake_discover)
+        async def __aexit__(self, *args):
+            pass
+
+        async def json(self, *, content_type=None):
+            return {"data": [{"id": "MiniMax-M2.7"}]}
+
+    class FakeSession:
+        def __init__(self):
+            self.calls: list[tuple[str, dict[str, str]]] = []
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, *args):
+            pass
+
+        def get(self, url, *, headers, raise_for_status):
+            self.calls.append((url, headers))
+            return FakeResponse()
+
+    session = FakeSession()
+    monkeypatch.setattr("pythinker_code.auth.minimax.new_client_session", lambda **_: session)
 
     events = [event async for event in login_minimax_api_key(config, "sk-cp-token-plan-abc")]
 
     assert [event.type for event in events] == ["info", "success"]
+    assert session.calls == [(MINIMAX_ANTHROPIC_MODELS_URL, {"X-Api-Key": "sk-cp-token-plan-abc"})]
     assert set(config.models) == {"minimax/m2.7"}
     assert config.default_model == "minimax/m2.7"
 
@@ -227,6 +243,8 @@ async def fake_discover(api_key):
     assert "Token Plan" in events[0].message
     assert types[-1] == "success"
     assert "sk-cp-token-plan-abc" not in "\n".join(event.json for event in events)
+    assert config.models == {}
+    assert config.default_model == ""
 
 
 @pytest.mark.asyncio

tests/auth/test_platforms.py

@@ -800,7 +800,7 @@ async def test_refresh_managed_models_refreshes_minimax_token_plan_without_relog
 
     with (
         patch(
-            "pythinker_code.auth.minimax._discover_minimax_models",
+            "pythinker_code.auth.minimax.refresh_minimax_models",
             new=AsyncMock(return_value=discovered),
         ),
         patch("pythinker_code.auth.platforms.list_models", new=AsyncMock()) as list_models_mock,
@@ -824,6 +824,41 @@ async def test_refresh_managed_models_refreshes_minimax_token_plan_without_relog
     assert "minimax/m2.7-highspeed" not in saved[0].models
 
 
+@pytest.mark.asyncio
+async def test_refresh_managed_models_applies_empty_minimax_catalog():
+    """An authenticated empty MiniMax catalog is authoritative and prunes stale models."""
+    from pythinker_code.auth.minimax import MINIMAX_ANTHROPIC_PROVIDER_KEY
+
+    config = _make_minimax_config()
+    saved: list[Config] = []
+
+    with (
+        patch(
+            "pythinker_code.auth.minimax.refresh_minimax_models",
+            new=AsyncMock(return_value=()),
+        ) as refresh_mock,
+        patch("pythinker_code.auth.platforms.list_models", new=AsyncMock()) as list_models_mock,
+        patch("pythinker_code.auth.platforms.load_config", side_effect=_make_minimax_config),
+        patch(
+            "pythinker_code.auth.platforms.save_config",
+            side_effect=lambda cfg, *a, **k: saved.append(cfg),
+        ),
+    ):
+        changed = await refresh_managed_models(config)
+
+    assert changed is True
+    assert refresh_mock.await_count == 1
+    assert list_models_mock.await_count == 0
+    assert not any(
+        model.provider == MINIMAX_ANTHROPIC_PROVIDER_KEY for model in config.models.values()
+    )
+    assert config.default_model == ""
+    assert len(saved) == 1
+    assert not any(
+        model.provider == MINIMAX_ANTHROPIC_PROVIDER_KEY for model in saved[0].models.values()
+    )
+
+
 @pytest.mark.asyncio
 async def test_refresh_managed_models_isolates_minimax_discovery_failure():
     """MiniMax refresh failure must not abort other managed-provider refreshes."""
@@ -857,7 +892,7 @@ def _config_with_generic_provider() -> Config:
 
     with (
         patch(
-            "pythinker_code.auth.minimax._discover_minimax_models",
+            "pythinker_code.auth.minimax.refresh_minimax_models",
             new=AsyncMock(side_effect=aiohttp.ClientConnectionError("offline")),
         ),
         patch(
@@ -878,4 +913,6 @@ def _config_with_generic_provider() -> Config:
     assert changed is True
     assert len(saved) == 1
     assert saved[0].models["pythinker-code/pythinker-for-coding"].max_context_size == 200_000
+    assert "minimax/m2.7-highspeed" in saved[0].models
+    assert saved[0].models["minimax/m2.7-highspeed"].provider == "managed:minimax-anthropic"
     assert "minimax/m2.7-highspeed" in config.models