feat(api): ✨ adopt OpenAI schema and blacklist patterns for model discovery

Expose `/v1/models` in the canonical OpenAI list shape while letting admins hide entire model families via wildcard patterns.

- Map provider/model responses to `ModelCard`/`ModelList` DTOs that match upstream
- Parse `IGNORE_MODELS_<provider>` env vars to drop models at runtime (`gpt-3.5*,claude-*`)
- Strip provider prefixes from IDs for a clean, client-friendly catalog
- Remove `grouped` option; the endpoint now always returns the flattened spec

BREAKING CHANGE: Legacy `{provider: {models: [...]}}` envelope and the `grouped` query parameter are gone. Update clients to expect `{"object":"list","data":[...]}` with bare model IDs.

src/proxy_app/main.py

@@ -13,8 +13,9 @@ import colorlog
 from pathlib import Path
 import sys
 import json
+import time
 from typing import AsyncGenerator, Any, List, Optional, Union
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 import argparse
 import litellm
 
@@ -27,6 +28,18 @@ class EmbeddingRequest(BaseModel):
     dimensions: Optional[int] = None
     user: Optional[str] = None
 
+
+# --- Pydantic Models for Model Endpoints ---
+class ModelCard(BaseModel):
+    id: str
+    object: str = "model"
+    created: int = Field(default_factory=lambda: int(time.time()))
+    owned_by: str = "Mirro-Proxy"
+
+class ModelList(BaseModel):
+    object: str = "list"
+    data: List[ModelCard]
+
 # --- Argument Parsing ---
 parser = argparse.ArgumentParser(description="API Key Proxy Server")
 parser.add_argument("--host", type=str, default="0.0.0.0", help="Host to bind the server to.")
@@ -125,12 +138,21 @@ for key, value in os.environ.items():
 if not api_keys:
     raise ValueError("No provider API keys found in environment variables.")
 
+# Load model ignore lists from environment variables
+ignore_models = {}
+for key, value in os.environ.items():
+    if key.startswith("IGNORE_MODELS_"):
+        provider = key.replace("IGNORE_MODELS_", "").lower()
+        models_to_ignore = [model.strip() for model in value.split(',')]
+        ignore_models[provider] = models_to_ignore
+        logging.debug(f"Loaded ignore list for provider '{provider}': {models_to_ignore}")
+
 # --- Lifespan Management ---
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """Manage the RotatingClient's lifecycle with the app's lifespan."""
     # The client now uses the root logger configuration
-    client = RotatingClient(api_keys=api_keys, configure_logging=True)
+    client = RotatingClient(api_keys=api_keys, configure_logging=True, ignore_models=ignore_models)
     app.state.rotating_client = client
     os.environ["LITELLM_LOG"] = "ERROR"
     litellm.set_verbose = False
@@ -504,18 +526,18 @@ async def embeddings(
 def read_root():
     return {"Status": "API Key Proxy is running"}
 
-@app.get("/v1/models")
+@app.get("/v1/models", response_model=ModelList)
 async def list_models(
-    grouped: bool = False, 
     client: RotatingClient = Depends(get_rotating_client),
     _=Depends(verify_api_key)
 ):
     """
-    Returns a list of available models from all configured providers.
-    Optionally returns them as a flat list if grouped=False.
+    Returns a list of available models in the OpenAI-compatible format.
     """
-    models = await client.get_all_available_models(grouped=grouped)
-    return models
+    model_ids = await client.get_all_available_models(grouped=False)
+    model_cards = [ModelCard(id=model_id) for model_id in model_ids]
+    return ModelList(data=model_cards)
+
 
 @app.get("/v1/providers")
 async def list_providers(_=Depends(verify_api_key)):

src/rotator_library/client.py

@@ -36,7 +36,16 @@ class RotatingClient:
     A client that intelligently rotates and retries API keys using LiteLLM,
     with support for both streaming and non-streaming responses.
     """
-    def __init__(self, api_keys: Dict[str, List[str]], max_retries: int = 2, usage_file_path: str = "key_usage.json", configure_logging: bool = True, global_timeout: int = 30, abort_on_callback_error: bool = True):
+    def __init__(
+        self,
+        api_keys: Dict[str, List[str]],
+        max_retries: int = 2,
+        usage_file_path: str = "key_usage.json",
+        configure_logging: bool = True,
+        global_timeout: int = 30,
+        abort_on_callback_error: bool = True,
+        ignore_models: Optional[Dict[str, List[str]]] = None
+    ):
         os.environ["LITELLM_LOG"] = "ERROR"
         litellm.set_verbose = False
         litellm.drop_params = True
@@ -64,6 +73,27 @@ class RotatingClient:
         self.http_client = httpx.AsyncClient()
         self.all_providers = AllProviders()
         self.cooldown_manager = CooldownManager()
+        self.ignore_models = ignore_models or {}
+
+    def _is_model_ignored(self, provider: str, model_id: str) -> bool:
+        """
+        Checks if a model should be ignored based on the ignore list.
+        Supports exact and partial matching.
+        """
+        if provider not in self.ignore_models:
+            return False
+
+        ignore_list = self.ignore_models[provider]
+        for ignored_model in ignore_list:
+            if ignored_model.endswith('*'):
+                # Partial match
+                if ignored_model[:-1] in model_id:
+                    return True
+            else:
+                # Exact match (ignoring provider prefix)
+                if model_id.endswith(ignored_model):
+                    return True
+        return False
 
     def _sanitize_litellm_log(self, log_data: dict) -> dict:
         """
@@ -800,8 +830,14 @@ class RotatingClient:
                     lib_logger.debug(f"Attempting to get models for {provider} with key ...{api_key[-4:]}")
                     models = await provider_instance.get_models(api_key, self.http_client)
                     lib_logger.info(f"Got {len(models)} models for provider: {provider}")
-                    self._model_list_cache[provider] = models
-                    return models
+
+                    # Filter models based on the ignore list
+                    filtered_models = [m for m in models if not self._is_model_ignored(provider, m)]
+                    if len(filtered_models) != len(models):
+                        lib_logger.info(f"Filtered out {len(models) - len(filtered_models)} models for provider {provider}.")
+
+                    self._model_list_cache[provider] = filtered_models
+                    return filtered_models
                 except Exception as e:
                     classified_error = classify_error(e)
                     lib_logger.debug(f"Failed to get models for provider {provider} with key ...{api_key[-4:]}: {classified_error.error_type}. Trying next key.")
@@ -829,7 +865,6 @@ class RotatingClient:
             return all_provider_models
         else:
             flat_models = []
-            for provider, models in all_provider_models.items():
-                for model in models:
-                    flat_models.append(f"{provider}/{model}")
-            return flat_models
+            for models in all_provider_models.values():
+                flat_models.extend(models)
+            return flat_models