feat(providers): ✨ add antigravity provider and auth base

Add a new Antigravity provider and authentication base to integrate with the Antigravity (internal Google) API.

- Add providers/antigravity_auth_base.py: OAuth2 token management with env/file loading, atomic saves, refresh logic, backoff/queue tracking, interactive and headless browser auth flow, and helper utilities.
- Add providers/antigravity_provider.py: request/response transformations (OpenAI → Gemini CLI → Antigravity), model aliasing, thinking/reasoning config mapping, tool response grouping, streaming & non-streaming handling, and base-URL fallback.
- Update provider_factory.py and providers/__init__.py to register the new provider.
- Bump project metadata in pyproject.toml (package name and version).

BREAKING CHANGE: project packaging metadata updated — package name changed to "rotator_library" and version bumped to 0.95. Update any dependency or packaging references that relied on the previous name/version.

src/rotator_library/provider_factory.py

@@ -3,11 +3,13 @@
 from .providers.gemini_auth_base import GeminiAuthBase
 from .providers.qwen_auth_base import QwenAuthBase
 from .providers.iflow_auth_base import IFlowAuthBase
+from .providers.antigravity_auth_base import AntigravityAuthBase
 
 PROVIDER_MAP = {
     "gemini_cli": GeminiAuthBase,
     "qwen_code": QwenAuthBase,
     "iflow": IFlowAuthBase,
+    "antigravity": AntigravityAuthBase,
 }
 
 def get_provider_auth_class(provider_name: str):

src/rotator_library/providers/__init__.py

@@ -112,6 +112,8 @@ def _register_providers():
                 "chutes",
                 "iflow",
                 "qwen_code",
+                "gemini_cli",
+                "antigravity",
             ]:
                 continue
 

src/rotator_library/providers/antigravity_auth_base.py

@@ -0,0 +1,466 @@
+# src/rotator_library/providers/antigravity_auth_base.py
+
+import os
+import webbrowser
+from typing import Union, Optional
+import json
+import time
+import asyncio
+import logging
+from pathlib import Path
+from typing import Dict, Any
+import tempfile
+import shutil
+
+import httpx
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from ..utils.headless_detection import is_headless_environment
+
+lib_logger = logging.getLogger('rotator_library')
+
+# Antigravity OAuth credentials from CLIProxyAPI
+CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com"
+CLIENT_SECRET = "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"
+TOKEN_URI = "https://oauth2.googleapis.com/token"
+USER_INFO_URI = "https://www.googleapis.com/oauth2/v1/userinfo"
+REFRESH_EXPIRY_BUFFER_SECONDS = 30 * 60  # 30 minutes buffer before expiry
+
+# Antigravity requires additional scopes
+OAUTH_SCOPES = [
+    "https://www.googleapis.com/auth/cloud-platform",
+    "https://www.googleapis.com/auth/userinfo.email",
+    "https://www.googleapis.com/auth/userinfo.profile",
+    "https://www.googleapis.com/auth/cclog",  # Antigravity-specific
+    "https://www.googleapis.com/auth/experimentsandconfigs"  # Antigravity-specific
+]
+
+console = Console()
+
+class AntigravityAuthBase:
+    """
+    Base authentication class for Antigravity provider.
+    Handles OAuth2 flow, token management, and refresh logic.
+    
+    Based on GeminiAuthBase but uses Antigravity-specific OAuth credentials and scopes.
+    """
+    
+    def __init__(self):
+        self._credentials_cache: Dict[str, Dict[str, Any]] = {}
+        self._refresh_locks: Dict[str, asyncio.Lock] = {}
+        self._locks_lock = asyncio.Lock()  # Protects the locks dict from race conditions
+        # [BACKOFF TRACKING] Track consecutive failures per credential
+        self._refresh_failures: Dict[str, int] = {}  # Track consecutive failures per credential
+        self._next_refresh_after: Dict[str, float] = {}  # Track backoff timers (Unix timestamp)
+        
+        # [QUEUE SYSTEM] Sequential refresh processing
+        self._refresh_queue: asyncio.Queue = asyncio.Queue()
+        self._queued_credentials: set = set()  # Track credentials already in queue
+        self._unavailable_credentials: set = set()  # Mark credentials unavailable during re-auth
+        self._queue_tracking_lock = asyncio.Lock()  # Protects queue sets
+        self._queue_processor_task: Optional[asyncio.Task] = None  # Background worker task
+
+    def _load_from_env(self) -> Optional[Dict[str, Any]]:
+        """
+        Load OAuth credentials from environment variables for stateless deployments.
+
+        Expected environment variables:
+        - ANTIGRAVITY_ACCESS_TOKEN (required)
+        - ANTIGRAVITY_REFRESH_TOKEN (required)
+        - ANTIGRAVITY_EXPIRY_DATE (optional, defaults to 0)
+        - ANTIGRAVITY_CLIENT_ID (optional, uses default)
+        - ANTIGRAVITY_CLIENT_SECRET (optional, uses default)
+        - ANTIGRAVITY_TOKEN_URI (optional, uses default)
+        - ANTIGRAVITY_UNIVERSE_DOMAIN (optional, defaults to googleapis.com)
+        - ANTIGRAVITY_EMAIL (optional, defaults to "env-user")
+
+        Returns:
+            Dict with credential structure if env vars present, None otherwise
+        """
+        access_token = os.getenv("ANTIGRAVITY_ACCESS_TOKEN")
+        refresh_token = os.getenv("ANTIGRAVITY_REFRESH_TOKEN")
+
+        # Both access and refresh tokens are required
+        if not (access_token and refresh_token):
+            return None
+
+        lib_logger.debug("Loading Antigravity credentials from environment variables")
+
+        # Parse expiry_date as float, default to 0 if not present
+        expiry_str = os.getenv("ANTIGRAVITY_EXPIRY_DATE", "0")
+        try:
+            expiry_date = float(expiry_str)
+        except ValueError:
+            lib_logger.warning(f"Invalid ANTIGRAVITY_EXPIRY_DATE value: {expiry_str}, using 0")
+            expiry_date = 0
+
+        creds = {
+            "access_token": access_token,
+            "refresh_token": refresh_token,
+            "expiry_date": expiry_date,
+            "client_id": os.getenv("ANTIGRAVITY_CLIENT_ID", CLIENT_ID),
+            "client_secret": os.getenv("ANTIGRAVITY_CLIENT_SECRET", CLIENT_SECRET),
+            "token_uri": os.getenv("ANTIGRAVITY_TOKEN_URI", TOKEN_URI),
+            "universe_domain": os.getenv("ANTIGRAVITY_UNIVERSE_DOMAIN", "googleapis.com"),
+            "_proxy_metadata": {
+                "email": os.getenv("ANTIGRAVITY_EMAIL", "env-user"),
+                "last_check_timestamp": time.time(),
+                "loaded_from_env": True  # Flag to indicate env-based credentials
+            }
+        }
+
+        return creds
+
+    async def _load_credentials(self, path: str) -> Dict[str, Any]:
+        """
+        Load credentials from a file. First attempts file-based load,
+        then falls back to environment variables if file not found.
+
+        Args:
+            path: File path to load credentials from
+
+        Returns:
+            Dict containing the credentials
+
+        Raises:
+            ValueError: If credentials cannot be loaded from either source
+        """
+        # If path is special marker "env", load from environment
+        if path == "env":
+            env_creds = self._load_from_env()
+            if env_creds:
+                lib_logger.debug("Using Antigravity credentials from environment variables")
+                return env_creds
+            raise ValueError("ANTIGRAVITY_ACCESS_TOKEN and ANTIGRAVITY_REFRESH_TOKEN environment variables not set")
+
+        # Try loading from cache first
+        if path in self._credentials_cache:
+            cached_creds = self._credentials_cache[path]
+            lib_logger.debug(f"Using cached Antigravity credentials for: {Path(path).name}")
+            return cached_creds
+
+        # Try loading from file
+        try:
+            with open(path, 'r') as f:
+                creds = json.load(f)
+            self._credentials_cache[path] = creds
+            lib_logger.debug(f"Loaded Antigravity credentials from file: {Path(path).name}")
+            return creds
+        except FileNotFoundError:
+            # Fall back to environment variables
+            lib_logger.debug(f"Credential file not found: {path}, attempting environment variables")
+            env_creds = self._load_from_env()
+            if env_creds:
+                lib_logger.debug("Using Antigravity credentials from environment variables as fallback")
+                # Cache with special path marker
+                self._credentials_cache[path] = env_creds
+                return env_creds
+            raise ValueError(f"Credential file not found: {path} and environment variables not set")
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON in credential file {path}: {e}")
+
+    async def _save_credentials(self, path: str, creds: Dict[str, Any]) -> None:
+        """
+        Save credentials to a file. Skip if credentials were loaded from environment.
+
+        Args:
+            path: File path to save credentials to
+            creds: Credentials dictionary to save
+        """
+        # Don't save environment-based credentials to file
+        if creds.get("_proxy_metadata", {}).get("loaded_from_env"):
+            lib_logger.debug("Skipping credential save (loaded from environment)")
+            return
+
+        # Don't save if path is special marker
+        if path == "env":
+            return
+
+        try:
+            # Ensure directory exists
+            Path(path).parent.mkdir(parents=True, exist_ok=True)
+            
+            # Write atomically using temp file + rename
+            temp_fd, temp_path = tempfile.mkstemp(
+                dir=Path(path).parent,
+                prefix='.tmp_',
+                suffix='.json'
+            )
+            try:
+                with os.fdopen(temp_fd, 'w') as f:
+                    json.dump(creds, f, indent=2)
+                shutil.move(temp_path, path)
+                lib_logger.debug(f"Saved Antigravity credentials to: {Path(path).name}")
+            except Exception:
+                # Clean up temp file on error
+                try:
+                    os.unlink(temp_path)
+                except Exception:
+                    pass
+                raise
+        except Exception as e:
+            lib_logger.warning(f"Failed to save Antigravity credentials to {path}: {e}")
+
+    def _is_token_expired(self, creds: Dict[str, Any]) -> bool:
+        """
+        Check if the access token is expired or close to expiry.
+
+        Args:
+            creds: Credentials dict with expiry_date field (in milliseconds)
+
+        Returns:
+            True if token is expired or within buffer time of expiry
+        """
+        if 'expiry_date' not in creds:
+            return True
+
+        # expiry_date is in milliseconds
+        expiry_timestamp = creds['expiry_date'] / 1000.0
+        current_time = time.time()
+        
+        # Consider expired if within buffer time
+        return (expiry_timestamp - current_time) <= REFRESH_EXPIRY_BUFFER_SECONDS
+
+    async def _refresh_token(self, path: str, creds: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Refresh an expired OAuth token using the refresh token.
+
+        Args:
+            path: Credential file path (for saving updated credentials)
+            creds: Current credentials dict with refresh_token
+
+        Returns:
+            Updated credentials dict with fresh access token
+
+        Raises:
+            ValueError: If refresh fails
+        """
+        if 'refresh_token' not in creds:
+            raise ValueError("No refresh token available")
+
+        lib_logger.debug(f"Refreshing Antigravity OAuth token for: {Path(path).name if path != 'env' else 'env'}")
+
+        client_id = creds.get('client_id', CLIENT_ID)
+        client_secret = creds.get('client_secret', CLIENT_SECRET)
+        token_uri = creds.get('token_uri', TOKEN_URI)
+
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    token_uri,
+                    data={
+                        'client_id': client_id,
+                        'client_secret': client_secret,
+                        'refresh_token': creds['refresh_token'],
+                        'grant_type': 'refresh_token'
+                    },
+                    timeout=30.0
+                )
+                response.raise_for_status()
+                token_data = response.json()
+
+                # Update credentials with new token
+                creds['access_token'] = token_data['access_token']
+                creds['expiry_date'] = (time.time() + token_data['expires_in']) * 1000
+
+                # Update metadata
+                if '_proxy_metadata' not in creds:
+                    creds['_proxy_metadata'] = {}
+                creds['_proxy_metadata']['last_check_timestamp'] = time.time()
+
+                # Save updated credentials
+                await self._save_credentials(path, creds)
+
+                # Update cache
+                self._credentials_cache[path] = creds
+
+                # Reset failure count on success
+                self._refresh_failures[path] = 0
+
+                lib_logger.info(f"Successfully refreshed Antigravity OAuth token for: {Path(path).name if path != 'env' else 'env'}")
+                return creds
+
+            except httpx.HTTPStatusError as e:
+                # Track failures for backoff
+                self._refresh_failures[path] = self._refresh_failures.get(path, 0) + 1
+                raise ValueError(f"Failed to refresh Antigravity token (HTTP {e.response.status_code}): {e.response.text}")
+            except Exception as e:
+                self._refresh_failures[path] = self._refresh_failures.get(path, 0) + 1
+                raise ValueError(f"Failed to refresh Antigravity token: {e}")
+
+    async def initialize_token(self, creds_or_path: Union[Dict[str, Any], str]) -> Dict[str, Any]:
+        """
+        Initialize or refresh an OAuth token. Handles the complete OAuth flow if needed.
+
+        Args:
+            creds_or_path: Either a credentials dict or a file path string
+
+        Returns:
+            Valid credentials dict with fresh access token
+        """
+        path = creds_or_path if isinstance(creds_or_path, str) else None
+
+        if isinstance(creds_or_path, dict):
+            display_name = creds_or_path.get("_proxy_metadata", {}).get("display_name", "in-memory object")
+        else:
+            display_name = Path(path).name if path and path != "env" else "env"
+
+        lib_logger.debug(f"Initializing Antigravity token for '{display_name}'...")
+        
+        try:
+            creds = await self._load_credentials(creds_or_path) if path else creds_or_path
+            reason = ""
+            if not creds.get("refresh_token"):
+                reason = "refresh token is missing"
+            elif self._is_token_expired(creds):
+                reason = "token is expired"
+
+            if reason:
+                if reason == "token is expired" and creds.get("refresh_token"):
+                    try:
+                        return await self._refresh_token(path, creds)
+                    except Exception as e:
+                        lib_logger.warning(f"Automatic token refresh for '{display_name}' failed: {e}. Proceeding to interactive login.")
+
+                lib_logger.warning(f"Antigravity OAuth token for '{display_name}' needs setup: {reason}.")
+                
+                is_headless = is_headless_environment()
+                
+                auth_code_future = asyncio.get_event_loop().create_future()
+                server = None
+
+                async def handle_callback(reader, writer):
+                    try:
+                        request_line_bytes = await reader.readline()
+                        if not request_line_bytes:
+                            return
+                        path_str = request_line_bytes.decode('utf-8').strip().split(' ')[1]
+                        # Consume headers
+                        while await reader.readline() != b'\r\n':
+                            pass
+                        
+                        from urllib.parse import urlparse, parse_qs
+                        query_params = parse_qs(urlparse(path_str).query)
+                        
+                        writer.write(b"HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n")
+                        if 'code' in query_params:
+                            if not auth_code_future.done():
+                                auth_code_future.set_result(query_params['code'][0])
+                            writer.write(b"<html><body><h1>Authentication successful!</h1><p>You can close this window.</p></body></html>")
+                        else:
+                            error = query_params.get('error', ['Unknown error'])[0]
+                            if not auth_code_future.done():
+                                auth_code_future.set_exception(Exception(f"OAuth failed: {error}"))
+                            writer.write(f"<html><body><h1>Authentication Failed</h1><p>Error: {error}. Please try again.</p></body></html>".encode())
+                        await writer.drain()
+                    except Exception as e:
+                        lib_logger.error(f"Error in OAuth callback handler: {e}")
+                    finally:
+                        writer.close()
+
+                try:
+                    server = await asyncio.start_server(handle_callback, '127.0.0.1', 8085)
+                    
+                    from urllib.parse import urlencode
+                    auth_url = "https://accounts.google.com/o/oauth2/v2/auth?" + urlencode({
+                        "client_id": CLIENT_ID,
+                        "redirect_uri": "http://localhost:8085/oauth2callback",
+                        "scope": " ".join(OAUTH_SCOPES),
+                        "access_type": "offline",
+                        "response_type": "code",
+                        "prompt": "consent"
+                    })
+                    
+                    if is_headless:
+                        auth_panel_text = Text.from_markup(
+                            "Running in headless environment (no GUI detected).\n"
+                            "Please open the URL below in a browser on another machine to authorize:\n"
+                        )
+                    else:
+                        auth_panel_text = Text.from_markup(
+                            "1. Your browser will now open to log in and authorize the application.\n"
+                            "2. If it doesn't open automatically, please open the URL below manually."
+                        )
+                    
+                    console.print(Panel(auth_panel_text, title=f"Antigravity OAuth Setup for [bold yellow]{display_name}[/bold yellow]", style="bold blue"))
+                    console.print(f"[bold]URL:[/bold] [link={auth_url}]{auth_url}[/link]\n")
+                    
+                    if not is_headless:
+                        try:
+                            webbrowser.open(auth_url)
+                            lib_logger.info("Browser opened successfully for OAuth flow")
+                        except Exception as e:
+                            lib_logger.warning(f"Failed to open browser automatically: {e}. Please open the URL manually.")
+                    
+                    with console.status("[bold green]Waiting for you to complete authentication in the browser...[/bold green]", spinner="dots"):
+                        auth_code = await asyncio.wait_for(auth_code_future, timeout=300)
+                except asyncio.TimeoutError:
+                    raise Exception("OAuth flow timed out. Please try again.")
+                finally:
+                    if server:
+                        server.close()
+                        await server.wait_closed()
+                
+                lib_logger.info(f"Attempting to exchange authorization code for tokens...")
+                async with httpx.AsyncClient() as client:
+                    response = await client.post(TOKEN_URI, data={
+                        "code": auth_code.strip(),
+                        "client_id": CLIENT_ID,
+                        "client_secret": CLIENT_SECRET,
+                        "redirect_uri": "http://localhost:8085/oauth2callback",
+                        "grant_type": "authorization_code"
+                    })
+                    response.raise_for_status()
+                    token_data = response.json()
+                    
+                    creds = token_data.copy()
+                    creds["expiry_date"] = (time.time() + creds.pop("expires_in")) * 1000
+                    creds["client_id"] = CLIENT_ID
+                    creds["client_secret"] = CLIENT_SECRET
+                    creds["token_uri"] = TOKEN_URI
+                    creds["universe_domain"] = "googleapis.com"
+                    
+                    # Fetch user info
+                    user_info_response = await client.get(
+                        USER_INFO_URI,
+                        headers={"Authorization": f"Bearer {creds['access_token']}"}
+                    )
+                    user_info_response.raise_for_status()
+                    user_info = user_info_response.json()
+                    
+                    creds["_proxy_metadata"] = {
+                        "email": user_info.get("email"),
+                        "last_check_timestamp": time.time()
+                    }
+
+                    if path:
+                        await self._save_credentials(path, creds)
+                    
+                    lib_logger.info(f"Antigravity OAuth initialized successfully for '{display_name}'.")
+                    return creds
+
+            lib_logger.info(f"Antigravity OAuth token at '{display_name}' is valid.")
+            return creds
+        except Exception as e:
+            raise ValueError(f"Failed to initialize Antigravity OAuth for '{display_name}': {e}")
+
+    async def get_valid_token(self, credential_path: str) -> str:
+        """
+        Get a valid access token, refreshing if necessary.
+
+        Args:
+            credential_path: Path to credential file or "env" for environment variables
+
+        Returns:
+            Valid access token string
+
+        Raises:
+            ValueError: If token cannot be obtained
+        """
+        try:
+            creds = await self.initialize_token(credential_path)
+            return creds['access_token']
+        except Exception as e:
+            raise ValueError(f"Failed to get valid Antigravity token: {e}")

src/rotator_library/providers/antigravity_provider.py

@@ -0,0 +1,869 @@
+# src/rotator_library/providers/antigravity_provider.py
+
+import json
+import httpx
+import logging
+import time
+import asyncio
+import random
+import uuid
+import copy
+from typing import List, Dict, Any, AsyncGenerator, Union, Optional, Tuple
+from .provider_interface import ProviderInterface
+from .antigravity_auth_base import AntigravityAuthBase
+from ..model_definitions import ModelDefinitions
+import litellm
+from litellm.exceptions import RateLimitError
+from litellm.llms.vertex_ai.common_utils import _build_vertex_schema
+
+lib_logger = logging.getLogger('rotator_library')
+
+# Antigravity base URLs with fallback order
+# Priority: daily (sandbox) → autopush (sandbox) → production
+BASE_URLS = [
+    "https://daily-cloudcode-pa.sandbox.googleapis.com/v1internal",
+    "https://autopush-cloudcode-pa.sandbox.googleapis.com/v1internal",
+    "https://cloudcode-pa.googleapis.com/v1internal"  # Production fallback
+]
+
+# Hardcoded models available via Antigravity
+HARDCODED_MODELS = [
+    "gemini-2.5-pro",
+    "gemini-2.5-flash",
+    "gemini-2.5-flash-lite",
+    "gemini-3-pro-preview",
+    "gemini-3-pro-image-preview",
+    "gemini-2.5-computer-use-preview-10-2025"
+]
+
+
+class AntigravityProvider(AntigravityAuthBase, ProviderInterface):
+    """
+    Antigravity provider implementation for Gemini models.
+    
+    Antigravity is an experimental internal Google API that provides access to Gemini models
+    including Gemini 3 with thinking/reasoning capabilities. It wraps standard Gemini API
+    requests with additional metadata and uses sandbox endpoints.
+    
+    Key features:
+    - Model aliasing (gemini-3-pro-high ↔ gemini-3-pro-preview)
+    - Gemini 3 thinkingLevel support
+    - Thinking signature preservation for multi-turn conversations
+    - Sophisticated tool response grouping
+    - Base URL fallback (sandbox → production)
+    """
+    skip_cost_calculation = True
+
+    def __init__(self):
+        super().__init__()
+        self.model_definitions = ModelDefinitions()
+        self._current_base_url = BASE_URLS[0]  # Start with daily sandbox
+        self._base_url_index = 0
+
+    # ============================================================================
+    # MODEL ALIAS SYSTEM
+    # ============================================================================
+
+    def _model_name_to_alias(self, model_name: str) -> str:
+        """
+        Convert internal Antigravity model names to public aliases.
+        
+        Args:
+            model_name: Internal model name
+            
+        Returns:
+            Public alias name, or empty string if model should be excluded
+        """
+        alias_map = {
+            "rev19-uic3-1p": "gemini-2.5-computer-use-preview-10-2025",
+            "gemini-3-pro-image": "gemini-3-pro-image-preview",
+            "gemini-3-pro-high": "gemini-3-pro-preview",
+            "claude-sonnet-4-5": "gemini-claude-sonnet-4-5",
+            "claude-sonnet-4-5-thinking": "gemini-claude-sonnet-4-5-thinking",
+        }
+        
+        # Filter out excluded models (return empty string to skip)
+        excluded = [
+            "chat_20706", "chat_23310", "gemini-2.5-flash-thinking",
+            "gemini-3-pro-low", "gemini-2.5-pro"
+        ]
+        if model_name in excluded:
+            return ""
+        
+        return alias_map.get(model_name, model_name)
+
+    def _alias_to_model_name(self, alias: str) -> str:
+        """
+        Convert public aliases to internal Antigravity model names.
+        
+        Args:
+            alias: Public alias name
+            
+        Returns:
+            Internal model name
+        """
+        reverse_map = {
+            "gemini-2.5-computer-use-preview-10-2025": "rev19-uic3-1p",
+            "gemini-3-pro-image-preview": "gemini-3-pro-image",
+            "gemini-3-pro-preview": "gemini-3-pro-high",
+            "gemini-claude-sonnet-4-5": "claude-sonnet-4-5",
+            "gemini-claude-sonnet-4-5-thinking": "claude-sonnet-4-5-thinking",
+        }
+        return reverse_map.get(alias, alias)
+
+    # ============================================================================
+    # RANDOM ID GENERATION
+    # ============================================================================
+
+    @staticmethod
+    def generate_request_id() -> str:
+        """Generate Antigravity request ID: agent-{uuid}"""
+        return f"agent-{uuid.uuid4()}"
+
+    @staticmethod
+    def generate_session_id() -> str:
+        """Generate Antigravity session ID: -{random_number}"""
+        # Generate random 19-digit number
+        n = random.randint(1_000_000_000_000_000_000, 9_999_999_999_999_999_999)
+        return f"-{n}"
+
+    @staticmethod
+    def generate_project_id() -> str:
+        """Generate fake project ID: {adj}-{noun}-{random}"""
+        adjectives = ["useful", "bright", "swift", "calm", "bold"]
+        nouns = ["fuze", "wave", "spark", "flow", "core"]
+        adj = random.choice(adjectives)
+        noun = random.choice(nouns)
+        random_part = str(uuid.uuid4())[:5].lower()
+        return f"{adj}-{noun}-{random_part}"
+
+    # ============================================================================
+    # MESSAGE TRANSFORMATION (OpenAI → Gemini CLI format)
+    # ============================================================================
+
+    def _transform_messages(self, messages: List[Dict[str, Any]]) -> Tuple[Optional[Dict[str, Any]], List[Dict[str, Any]]]:
+        """
+        Transform OpenAI messages to Gemini CLI format.
+        Reused from GeminiCliProvider with modifications for Antigravity.
+        
+        Returns:
+            Tuple of (system_instruction, gemini_contents)
+        """
+        system_instruction = None
+        gemini_contents = []
+        
+        # Make a copy to avoid modifying original
+        messages = copy.deepcopy(messages)
+        
+        # Separate system prompt from other messages
+        if messages and messages[0].get('role') == 'system':
+            system_prompt_content = messages.pop(0).get('content', '')
+            if system_prompt_content:
+                system_instruction = {
+                    "role": "user",
+                    "parts": [{"text": system_prompt_content}]
+                }
+
+        # Build tool call ID to name mapping
+        tool_call_id_to_name = {}
+        for msg in messages:
+            if msg.get("role") == "assistant" and msg.get("tool_calls"):
+                for tool_call in msg["tool_calls"]:
+                    if tool_call.get("type") == "function":
+                        tool_call_id_to_name[tool_call["id"]] = tool_call["function"]["name"]
+
+        # Convert each message
+        for msg in messages:
+            role = msg.get("role")
+            content = msg.get("content")
+            parts = []
+            gemini_role = "model" if role == "assistant" else "tool" if role == "tool" else "user"
+
+            if role == "user":
+                if isinstance(content, str):
+                    # Simple text content
+                    if content:
+                        parts.append({"text": content})
+                elif isinstance(content, list):
+                    # Multi-part content (text, images, etc.)
+                    for item in content:
+                        if item.get("type") == "text":
+                            text = item.get("text", "")
+                            if text:
+                                parts.append({"text": text})
+                        elif item.get("type") == "image_url":
+                            # Handle image data URLs
+                            image_url = item.get("image_url", {}).get("url", "")
+                            if image_url.startswith("data:"):
+                                try:
+                                    # Parse: data:image/png;base64,iVBORw0KG...
+                                    header, data = image_url.split(",", 1)
+                                    mime_type = header.split(":")[1].split(";")[0]
+                                    parts.append({
+                                        "inlineData": {
+                                            "mimeType": mime_type,
+                                            "data": data
+                                        }
+                                    })
+                                except Exception as e:
+                                    lib_logger.warning(f"Failed to parse image data URL: {e}")
+
+            elif role == "assistant":
+                if isinstance(content, str) and content:
+                    parts.append({"text": content})
+                if msg.get("tool_calls"):
+                    for tool_call in msg["tool_calls"]:
+                        if tool_call.get("type") == "function":
+                            try:
+                                args_dict = json.loads(tool_call["function"]["arguments"])
+                            except (json.JSONDecodeError, TypeError):
+                                args_dict = {}
+                            
+                            # Add function call part with thoughtSignature
+                            func_call_part = {
+                                "functionCall": {
+                                    "name": tool_call["function"]["name"],
+                                    "args": args_dict
+                                },
+                                "thoughtSignature": "skip_thought_signature_validator"
+                            }
+                            parts.append(func_call_part)
+
+            elif role == "tool":
+                tool_call_id = msg.get("tool_call_id")
+                function_name = tool_call_id_to_name.get(tool_call_id)
+                if function_name:
+                    # Wrap the tool response in a 'result' object
+                    response_content = {"result": content}
+                    parts.append({"functionResponse": {"name": function_name, "response": response_content}})
+
+            if parts:
+                gemini_contents.append({"role": gemini_role, "parts": parts})
+
+        # Ensure first message is from user
+        if not gemini_contents or gemini_contents[0]['role'] != 'user':
+            gemini_contents.insert(0, {"role": "user", "parts": [{"text": ""}]})
+
+        return system_instruction, gemini_contents
+
+    # ============================================================================
+    # THINKING/REASONING CONFIGURATION
+    # ============================================================================
+
+    def _map_reasoning_effort_to_thinking_config(
+        self,
+        reasoning_effort: Optional[str],
+        model: str
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Map OpenAI reasoning_effort to Gemini thinking configuration.
+        Handles Gemini 3 thinkingLevel vs other models thinkingBudget.
+        
+        Args:
+            reasoning_effort: OpenAI reasoning_effort value
+            model: Model name (public alias)
+            
+        Returns:
+            Dictionary with thinkingConfig or None
+        """
+        internal_model = self._alias_to_model_name(model)
+        is_gemini_3 = internal_model.startswith("gemini-3-")
+        
+        # Default for gemini-3-pro-preview when no reasoning_effort specified
+        if not reasoning_effort:
+            if model == "gemini-3-pro-preview" or internal_model == "gemini-3-pro-high":
+                return {
+                    "thinkingBudget": -1,
+                    "include_thoughts": True
+                }
+            return None
+        
+        if reasoning_effort == "none":
+            return {
+                "thinkingBudget": 0,
+                "include_thoughts": False
+            }
+        
+        if reasoning_effort == "auto":
+            # Auto always uses thinkingBudget=-1, even for Gemini 3
+            return {
+                "thinkingBudget": -1,
+                "include_thoughts": True
+            }
+        
+        if is_gemini_3:
+            # Gemini 3: Use thinkingLevel
+            level_map = {
+                "low": "low",
+                "medium": "high",  # Medium not released yet, map to high
+                "high": "high"
+            }
+            level = level_map.get(reasoning_effort, "high")
+            return {
+                "thinkingLevel": level,
+                "include_thoughts": True
+            }
+        else:
+            # Non-Gemini-3: Use thinkingBudget with normalization
+            budget_map = {
+                "low": 1024,
+                "medium": 8192,
+                "high": 32768
+            }
+            budget = budget_map.get(reasoning_effort, -1)
+            # TODO: Add model-specific normalization via model registry
+            return {
+                "thinkingBudget": budget,
+                "include_thoughts": True
+            }
+
+    # ============================================================================
+    # TOOL RESPONSE GROUPING
+    # ============================================================================
+
+    def _fix_tool_response_grouping(self, contents: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """
+        Group function calls with their responses for Antigravity compatibility.
+        
+        Converts linear format (function call, response, function call, response)
+        to grouped format (model with calls, function role with all responses).
+        
+        Args:
+            contents: List of Gemini content objects
+            
+        Returns:
+            List of grouped content objects
+        """
+        new_contents = []
+        pending_groups = []  # Groups awaiting responses
+        collected_responses = []  # Standalone responses to match
+        
+        for content in contents:
+            role = content.get("role")
+            parts = content.get("parts", [])
+            
+            # Check if this content has function responses
+            response_parts = [p for p in parts if "functionResponse" in p]
+            
+            if response_parts:
+                # Collect responses
+                collected_responses.extend(response_parts)
+                
+                # Try to satisfy pending groups
+                for i in range(len(pending_groups) - 1, -1, -1):
+                    group = pending_groups[i]
+                    if len(collected_responses) >= group["responses_needed"]:
+                        # Take needed responses
+                        group_responses = collected_responses[:group["responses_needed"]]
+                        collected_responses = collected_responses[group["responses_needed"]:]
+                        
+                        # Create merged function response content
+                        function_response_content = {
+                            "parts": group_responses,
+                            "role": "function"  # Changed from tool
+                        }
+                        new_contents.append(function_response_content)
+                        
+                        # Remove satisfied group
+                        pending_groups.pop(i)
+                        break
+                
+                continue  # Skip adding this content
+            
+            # If this is model content with function calls, create a group
+            if role == "model":
+                function_calls = [p for p in parts if "functionCall" in p]
+                
+                if function_calls:
+                    # Add model content first
+                    new_contents.append(content)
+                    
+                    # Create pending group
+                    pending_groups.append({
+                        "model_content": content,
+                        "function_calls": function_calls,
+                        "responses_needed": len(function_calls)
+                    })
+                else:
+                    # Regular model content without function calls
+                    new_contents.append(content)
+            else:
+                # Non-model content (user, etc.)
+                new_contents.append(content)
+        
+        # Handle remaining pending groups
+        for group in pending_groups:
+            if len(collected_responses) >= group["responses_needed"]:
+                group_responses = collected_responses[:group["responses_needed"]]
+                collected_responses = collected_responses[group["responses_needed"]:]
+                
+                function_response_content = {
+                    "parts": group_responses,
+                    "role": "function"
+                }
+                new_contents.append(function_response_content)
+        
+        return new_contents
+
+    # ============================================================================
+    # ANTIGRAVITY REQUEST TRANSFORMATION
+    # ============================================================================
+
+    def _transform_to_antigravity_format(
+        self,
+        gemini_cli_payload: Dict[str, Any],
+        model: str
+    ) -> Dict[str, Any]:
+        """
+        Transform Gemini CLI format to complete Antigravity format.
+        
+        Args:
+            gemini_cli_payload: Request in Gemini CLI format
+            model: Model name (public alias)
+            
+        Returns:
+            Complete Antigravity request payload
+        """
+        internal_model = self._alias_to_model_name(model)
+        
+        # 1. Wrap in Antigravity envelope
+        antigravity_payload = {
+            "project": self.generate_project_id(),
+            "userAgent": "antigravity",
+            "requestId": self.generate_request_id(),
+            "model": internal_model,  # Use internal name
+            "request": copy.deepcopy(gemini_cli_payload)
+        }
+        
+        # 2. Add session ID
+        antigravity_payload["request"]["sessionId"] = self.generate_session_id()
+        
+        # 3. Remove fields that Antigravity doesn't support
+        antigravity_payload["request"].pop("safetySettings", None)
+        if "generationConfig" in antigravity_payload["request"]:
+            antigravity_payload["request"]["generationConfig"].pop("maxOutputTokens", None)
+        
+        # 4. Set toolConfig mode
+        if "toolConfig" not in antigravity_payload["request"]:
+            antigravity_payload["request"]["toolConfig"] = {}
+        if "functionCallingConfig" not in antigravity_payload["request"]["toolConfig"]:
+            antigravity_payload["request"]["toolConfig"]["functionCallingConfig"] = {}
+        antigravity_payload["request"]["toolConfig"]["functionCallingConfig"]["mode"] = "VALIDATED"
+        
+        # 5. Handle Gemini 3 specific thinking logic
+        # For non-Gemini-3 models, convert thinkingLevel to thinkingBudget
+        if not internal_model.startswith("gemini-3-"):
+            gen_config = antigravity_payload["request"].get("generationConfig", {})
+            thinking_config = gen_config.get("thinkingConfig", {})
+            if "thinkingLevel" in thinking_config:
+                # Remove thinkingLevel for non-Gemini-3 models
+                del thinking_config["thinkingLevel"]
+                # Set thinkingBudget to -1 (auto/dynamic)
+                thinking_config["thinkingBudget"] = -1
+        
+        # 6. Preserve/add thoughtSignature to ALL function calls in model role content
+        for content in antigravity_payload["request"].get("contents", []):
+            if content.get("role") == "model":
+                for part in content.get("parts", []):
+                    # Add signature to function calls OR preserve if already exists
+                    if "functionCall" in part and "thoughtSignature" not in part:
+                        part["thoughtSignature"] = "skip_thought_signature_validator"
+                    # If thoughtSignature already exists, preserve it (important for Gemini 3)
+        
+        # 7. Handle Claude models (special tool schema conversion)
+        if internal_model.startswith("claude-sonnet-"):
+            # For Claude models, convert parametersJsonSchema back to parameters
+            for tool in antigravity_payload["request"].get("tools", []):
+                for func_decl in tool.get("functionDeclarations", []):
+                    if "parametersJsonSchema" in func_decl:
+                        func_decl["parameters"] = func_decl.pop("parametersJsonSchema")
+                        # Remove $schema if present
+                        if "parameters" in func_decl and "$schema" in func_decl["parameters"]:
+                            del func_decl["parameters"]["$schema"]
+        
+        return antigravity_payload
+
+    #============================================================================
+    # BASE URL FALLBACK LOGIC
+    # ============================================================================
+
+    def _get_current_base_url(self) -> str:
+        """Get the current base URL from the fallback list."""
+        return self._current_base_url
+
+    def _try_next_base_url(self) -> bool:
+        """
+        Switch to the next base URL in the fallback list.
+        
+        Returns:
+            True if successfully switched to next URL, False if no more URLs available
+        """
+        if self._base_url_index < len(BASE_URLS) - 1:
+            self._base_url_index += 1
+            self._current_base_url = BASE_URLS[self._base_url_index]
+            lib_logger.info(f"Switching to fallback Antigravity base URL: {self._current_base_url}")
+            return True
+        return False
+
+    def _reset_base_url(self):
+        """Reset to the primary base URL (daily sandbox)."""
+        self._base_url_index = 0
+        self._current_base_url = BASE_URLS[0]
+
+    # ============================================================================
+    # RESPONSE TRANSFORMATION (Antigravity → OpenAI)
+    # ============================================================================
+
+    def _unwrap_antigravity_response(self, antigravity_response: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Extract Gemini response from Antigravity envelope.
+        
+        Args:
+            antigravity_response: Response from Antigravity API
+            
+        Returns:
+            Gemini response (unwrapped)
+        """
+        # For both streaming and non-streaming, response is in 'response' field
+        return antigravity_response.get("response", antigravity_response)
+
+    def _gemini_to_openai_chunk(self, gemini_chunk: Dict[str, Any], model: str) -> litellm.ModelResponse:
+        """
+        Convert a single Gemini response chunk to OpenAI format.
+        Based on GeminiCliProvider logic.
+        
+        Args:
+            gemini_chunk: Gemini response chunk
+            model: Model name
+            
+        Returns:
+            OpenAI-format ModelResponse
+        """
+        # Extract candidate
+        candidates = gemini_chunk.get("candidates", [])
+        if not candidates:
+            # Empty chunk, return minimal response
+            return litellm.ModelResponse(
+                id=f"chatcmpl-{uuid.uuid4()}",
+                created=int(time.time()),
+                model=model,
+                choices=[]
+            )
+        
+        candidate = candidates[0]
+        content_parts = candidate.get("content", {}).get("parts", [])
+        
+        # Extract text, tool calls, and thinking
+        text_content = ""
+        tool_calls = []
+        
+        for part in content_parts:
+            # Extract text
+            if "text" in part:
+                text_content += part["text"]
+            
+            # Extract function calls (tool calls)
+            if "functionCall" in part:
+                func_call = part["functionCall"]
+                tool_calls.append({
+                    "id": f"call_{uuid.uuid4().hex[:24]}",
+                    "type": "function",
+                    "function": {
+                        "name": func_call.get("name", ""),
+                        "arguments": json.dumps(func_call.get("args", {}))
+                    }
+                })
+        
+        # Build delta
+        delta = {}
+        if text_content:
+            delta["content"] = text_content
+        if tool_calls:
+            delta["tool_calls"] = tool_calls
+        
+        # Get finish reason
+        finish_reason = candidate.get("finishReason", "").lower() if candidate.get("finishReason") else None
+        if finish_reason == "stop":
+            finish_reason = "stop"
+        elif finish_reason == "max_tokens":
+            finish_reason = "length"
+        
+        # Build choice
+        choice = {
+            "index": 0,
+            "delta": delta,
+            "finish_reason": finish_reason
+        }
+        
+        # Extract usage (if present)
+        usage_metadata = gemini_chunk.get("usageMetadata", {})
+        usage = None
+        if usage_metadata:
+            usage = {
+                "prompt_tokens": usage_metadata.get("promptTokenCount", 0),
+                "completion_tokens": usage_metadata.get("candidatesTokenCount", 0),
+                "total_tokens": usage_metadata.get("totalTokenCount", 0)
+            }
+        
+        return litellm.ModelResponse(
+            id=f"chatcmpl-{uuid.uuid4()}",
+            created=int(time.time()),
+            model=model,
+            choices=[choice],
+            usage=usage
+        )
+
+    # ============================================================================
+    # PROVIDER INTERFACE IMPLEMENTATION
+    # ============================================================================
+
+    def has_custom_logic(self) -> bool:
+        """Antigravity uses custom translation logic."""
+        return True
+
+    async def get_auth_header(self, credential_identifier: str) -> Dict[str, str]:
+        """
+        Get OAuth authorization header for Antigravity.
+        
+        Args:
+            credential_identifier: Credential file path or "env"
+            
+        Returns:
+            Dict with Authorization header
+        """
+        access_token = await self.get_valid_token(credential_identifier)
+        return {"Authorization": f"Bearer {access_token}"}
+
+    async def get_models(self, api_key: str, client: httpx.AsyncClient) -> List[str]:
+        """
+        Fetch available models from Antigravity.
+        
+        For Antigravity, we use the fetchAvailableModels endpoint and apply
+        alias mapping to convert internal names to public names.
+        
+        Args:
+            api_key: Credential path (not a traditional API key)
+            client: HTTP client
+            
+        Returns:
+            List of public model names
+        """
+        credential_path = api_key  # For OAuth providers, this is the credential path
+        
+        try:
+            access_token = await self.get_valid_token(credential_path)
+            base_url = self._get_current_base_url()
+            
+            # Generate required IDs
+            project_id = self.generate_project_id()
+            request_id = self.generate_request_id()
+            
+            # Fetch models endpoint
+            url = f"{base_url}/fetchAvailableModels"
+            
+            headers = {
+                "Authorization": f"Bearer {access_token}",
+                "Content-Type": "application/json"
+            }
+            
+            payload = {
+                "project": project_id,
+                "requestId": request_id,
+                "userAgent": "antigravity"
+            }
+            
+            lib_logger.debug(f"Fetching Antigravity models from: {url}")
+            
+            response = await client.post(url, json=payload, headers=headers, timeout=30.0)
+            response.raise_for_status()
+            
+            data = response.json()
+            
+            # Extract model names and apply aliasing
+            models = []
+            if "models" in data:
+                for model_info in data["models"]:
+                    internal_name = model_info.get("name", "").replace("models/", "")
+                    if internal_name:
+                        public_name = self._model_name_to_alias(internal_name)
+                        if public_name:  # Skip excluded models (empty string)
+                            models.append(public_name)
+            
+            if models:
+                lib_logger.info(f"Discovered {len(models)} Antigravity models")
+                return models
+            else:
+                lib_logger.warning("No models returned from Antigravity, using hardcoded list")
+                return HARDCODED_MODELS
+                
+        except Exception as e:
+            lib_logger.warning(f"Failed to fetch Antigravity models: {e}, using hardcoded list")
+            return HARDCODED_MODELS
+
+    async def acompletion(
+        self,
+        client: httpx.AsyncClient,
+        **kwargs
+    ) -> Union[litellm.ModelResponse, AsyncGenerator[litellm.ModelResponse, None]]:
+        """
+        Handle completion requests for Antigravity.
+        
+        This is the main entry point that:
+        1. Extracts the model and credential path
+        2. Transforms OpenAI request → Gemini CLI → Antigravity format
+        3. Makes the API call with fallback logic
+        4. Transforms Antigravity response → Gemini → OpenAI format
+        
+        Args:
+            client: HTTP client
+            **kwargs: LiteLLM completion parameters
+            
+        Returns:
+            ModelResponse (non-streaming) or AsyncGenerator (streaming)
+        """
+        # Extract key parameters
+        model = kwargs.get("model", "gemini-2.5-pro")
+        messages = kwargs.get("messages", [])
+        stream = kwargs.get("stream", False)
+        credential_path = kwargs.pop("credential_identifier", kwargs.get("api_key", ""))
+        tools = kwargs.get("tools")
+        reasoning_effort = kwargs.get("reasoning_effort")
+        temperature = kwargs.get("temperature")
+        top_p = kwargs.get("top_p")
+        max_tokens = kwargs.get("max_tokens")
+        
+        lib_logger.info(f"Antigravity completion: model={model}, stream={stream}, messages={len(messages)}")
+        
+        # Step 1: Transform messages (OpenAI → Gemini CLI)
+        system_instruction, gemini_contents = self._transform_messages(messages)
+        
+        # Apply tool response grouping
+        gemini_contents = self._fix_tool_response_grouping(gemini_contents)
+        
+        # Step 2: Build Gemini CLI payload
+        gemini_cli_payload = {
+            "contents": gemini_contents
+        }
+        
+        if system_instruction:
+            gemini_cli_payload["system_instruction"] = system_instruction
+        
+        # Add generation config
+        generation_config = {}
+        if temperature is not None:
+            generation_config["temperature"] = temperature
+        if top_p is not None:
+            generation_config["topP"] = top_p
+        
+        # Handle thinking config
+        thinking_config = self._map_reasoning_effort_to_thinking_config(reasoning_effort, model)
+        if thinking_config:
+            generation_config.setdefault("thinkingConfig", {}).update(thinking_config)
+        
+        if generation_config:
+            gemini_cli_payload["generationConfig"] = generation_config
+        
+        # Add tools
+        if tools:
+            gemini_tools = []
+            for tool in tools:
+                if tool.get("type") == "function":
+                    func = tool.get("function", {})
+                    schema = _build_vertex_schema(parameters=func.get("parameters", {}))
+                    gemini_tools.append({
+                        "functionDeclarations": [{
+                            "name": func.get("name", ""),
+                            "description": func.get("description", ""),
+                            "parametersJsonSchema": schema
+                        }]
+                    })
+            if gemini_tools:
+                gemini_cli_payload["tools"] = gemini_tools
+        
+        # Step 3: Transform to Antigravity format
+        antigravity_payload = self._transform_to_antigravity_format(gemini_cli_payload, model)
+        
+        # Step 4: Make API call
+        access_token = await self.get_valid_token(credential_path)
+        base_url = self._get_current_base_url()
+        
+        endpoint = ":streamGenerateContent" if stream else ":generateContent"
+        url = f"{base_url}{endpoint}"
+        
+        headers = {
+            "Authorization": f"Bearer {access_token}",
+            "Content-Type": "application/json"
+        }
+        
+        lib_logger.debug(f"Antigravity request to: {url}")
+        
+        try:
+            if stream:
+                return self._handle_streaming(client, url, headers, antigravity_payload, model)
+            else:
+                return await self._handle_non_streaming(client, url, headers, antigravity_payload, model)
+        except Exception as e:
+            # Try fallback URL if available
+            if self._try_next_base_url():
+                lib_logger.warning(f"Retrying Antigravity request with fallback URL: {e}")
+                base_url = self._get_current_base_url()
+                url = f"{base_url}{endpoint}"
+                
+                if stream:
+                    return self._handle_streaming(client, url, headers, antigravity_payload, model)
+                else:
+                    return await self._handle_non_streaming(client, url, headers, antigravity_payload, model)
+            else:
+                raise
+
+    async def _handle_non_streaming(
+        self,
+        client: httpx.AsyncClient,
+        url: str,
+        headers: Dict[str, str],
+        payload: Dict[str, Any],
+        model: str
+    ) -> litellm.ModelResponse:
+        """Handle non-streaming completion."""
+        response = await client.post(url, headers=headers, json=payload, timeout=120.0)
+        response.raise_for_status()
+        
+        antigravity_response = response.json()
+        
+        # Unwrap Antigravity envelope
+        gemini_response = self._unwrap_antigravity_response(antigravity_response)
+        
+        # Convert to OpenAI format
+        return self._gemini_to_openai_chunk(gemini_response, model)
+
+    async def _handle_streaming(
+        self,
+        client: httpx.AsyncClient,
+        url: str,
+        headers: Dict[str, str],
+        payload: Dict[str, Any],
+        model: str
+    ) -> AsyncGenerator[litellm.ModelResponse, None]:
+        """Handle streaming completion."""
+        async with client.stream("POST", url, headers=headers, json=payload, timeout=120.0) as response:
+            response.raise_for_status()
+            
+            async for line in response.aiter_lines():
+                if line.startswith("data: "):
+                    data_str = line[6:]
+                    if data_str == "[DONE]":
+                        break
+                    
+                    try:
+                        antigravity_chunk = json.loads(data_str)
+                        
+                        # Unwrap Antigravity envelope
+                        gemini_chunk = self._unwrap_antigravity_response(antigravity_chunk)
+                        
+                        # Convert to OpenAI format
+                        openai_chunk = self._gemini_to_openai_chunk(gemini_chunk, model)
+                        
+                        yield openai_chunk
+                    except json.JSONDecodeError:
+                        lib_logger.warning(f"Failed to parse Antigravity chunk: {data_str[:100]}")
+                        continue

src/rotator_library/pyproject.toml

@@ -3,8 +3,8 @@ requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
-name = "rotating-api-key-client"
-version = "0.9"
+name = "rotator_library"
+version = "0.95"
 authors = [
     { name="Mirrowel", email="nuh@uh.com" },
 ]