feat(antigravity): ✨ add credential availability tracking for models

Add get_available_credentials_for_model method to filter credentials not on cooldown.
Update client logging to display available credentials count alongside total count.

src/rotator_library/client.py

@@ -1033,8 +1033,17 @@ class RotatingClient:
                 if not creds_to_try:
                     break
 
+                # Get count of credentials not on cooldown for this model
+                available_creds = (
+                    await self.usage_manager.get_available_credentials_for_model(
+                        creds_to_try, model
+                    )
+                )
+                available_count = len(available_creds)
+                total_count = len(credentials_for_provider)
+
                 lib_logger.info(
-                    f"Acquiring key for model {model}. Tried keys: {len(tried_creds)}/{len(credentials_for_provider)}"
+                    f"Acquiring key for model {model}. Tried keys: {len(tried_creds)}/{available_count}({total_count})"
                 )
                 max_concurrent = self.max_concurrent_requests_per_key.get(provider, 1)
                 current_cred = await self.usage_manager.acquire_key(
@@ -1757,8 +1766,17 @@ class RotatingClient:
                         )
                         break
 
+                    # Get count of credentials not on cooldown for this model
+                    available_creds = (
+                        await self.usage_manager.get_available_credentials_for_model(
+                            creds_to_try, model
+                        )
+                    )
+                    available_count = len(available_creds)
+                    total_count = len(credentials_for_provider)
+
                     lib_logger.info(
-                        f"Acquiring credential for model {model}. Tried credentials: {len(tried_creds)}/{len(credentials_for_provider)}"
+                        f"Acquiring credential for model {model}. Tried credentials: {len(tried_creds)}/{available_count}({total_count})"
                     )
                     max_concurrent = self.max_concurrent_requests_per_key.get(
                         provider, 1

src/rotator_library/usage_manager.py

@@ -600,6 +600,43 @@ class UsageManager:
         async with self._data_lock:
             return dict(self._usage_data) if self._usage_data else {}
 
+    async def get_available_credentials_for_model(
+        self, credentials: List[str], model: str
+    ) -> List[str]:
+        """
+        Get credentials that are not on cooldown for a specific model.
+
+        Filters out credentials where:
+        - key_cooldown_until > now (key-level cooldown)
+        - model_cooldowns[model] > now (model-specific cooldown, includes quota exhausted)
+
+        Args:
+            credentials: List of credential identifiers to check
+            model: Model name to check cooldowns for
+
+        Returns:
+            List of credentials that are available (not on cooldown) for this model
+        """
+        await self._lazy_init()
+        now = time.time()
+        available = []
+
+        async with self._data_lock:
+            for key in credentials:
+                key_data = self._usage_data.get(key, {})
+
+                # Skip if key-level cooldown is active
+                if (key_data.get("key_cooldown_until") or 0) > now:
+                    continue
+
+                # Skip if model-specific cooldown is active
+                if (key_data.get("model_cooldowns", {}).get(model) or 0) > now:
+                    continue
+
+                available.append(key)
+
+        return available
+
     async def _reset_daily_stats_if_needed(self):
         """
         Checks if usage stats need to be reset for any key.