feat(ui): ✨ add interactive launcher TUI and advanced settings tool

Add a new Rich-based interactive launcher TUI (proxy_app/launcher_tui.py) and an advanced settings tool (proxy_app/settings_tool.py). Integrate the launcher into proxy_app/main.py so the TUI is shown when no CLI args are provided and can modify sys.argv to start the proxy.

- LauncherTUI: onboarding checks, credential management entrypoint, proxy configuration menu, provider/advanced settings viewer, and in-place proxy start flow.
- SettingsTool: interactive management of .env advanced settings (custom provider API bases, provider model definitions, concurrency limits) with staging/saving and undo support.
- AdvancedSettings, CustomProviderManager, ModelDefinitionManager, ConcurrencyManager utilities to stage and persist .env changes; settings tools reload the environment after changes.
- Ensure PROXY_API_KEY management and .env loading/reloading across tools; credential tool integration preserved.

No breaking changes expected.

src/proxy_app/launcher_tui.py

@@ -0,0 +1,547 @@
+"""
+Interactive TUI launcher for the LLM API Key Proxy.
+Provides a beautiful Rich-based interface for configuration and execution.
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+from rich.console import Console
+from rich.prompt import IntPrompt, Prompt
+from rich.panel import Panel
+from rich.text import Text
+from dotenv import load_dotenv, set_key
+
+console = Console()
+
+
+class LauncherConfig:
+    """Manages launcher_config.json (host, port, logging only)"""
+    
+    def __init__(self, config_path: Path = Path("launcher_config.json")):
+        self.config_path = config_path
+        self.defaults = {
+            "host": "127.0.0.1",
+            "port": 8000,
+            "enable_request_logging": False
+        }
+        self.config = self.load()
+    
+    def load(self) -> dict:
+        """Load config from file or create with defaults."""
+        if self.config_path.exists():
+            try:
+                with open(self.config_path, 'r') as f:
+                    config = json.load(f)
+                # Merge with defaults for any missing keys
+                for key, value in self.defaults.items():
+                    if key not in config:
+                        config[key] = value
+                return config
+            except (json.JSONDecodeError, IOError):
+                return self.defaults.copy()
+        return self.defaults.copy()
+    
+    def save(self):
+        """Save current config to file."""
+        import datetime
+        self.config["last_updated"] = datetime.datetime.now().isoformat()
+        try:
+            with open(self.config_path, 'w') as f:
+                json.dump(self.config, f, indent=2)
+        except IOError as e:
+            console.print(f"[red]Error saving config: {e}[/red]")
+    
+    def update(self, **kwargs):
+        """Update config values."""
+        self.config.update(kwargs)
+        self.save()
+    
+    @staticmethod
+    def update_proxy_api_key(new_key: str):
+        """Update PROXY_API_KEY in .env only"""
+        env_file = Path.cwd() / ".env"
+        set_key(str(env_file), "PROXY_API_KEY", new_key)
+        load_dotenv(dotenv_path=env_file, override=True)
+
+
+class SettingsDetector:
+    """Detects settings from .env for display"""
+    
+    @staticmethod
+    def _load_local_env() -> dict:
+        """Load environment variables from local .env file only"""
+        env_file = Path.cwd() / ".env"
+        env_dict = {}
+        if not env_file.exists():
+            return env_dict
+        try:
+            with open(env_file, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if not line or line.startswith('#'):
+                        continue
+                    if '=' in line:
+                        key, _, value = line.partition('=')
+                        key, value = key.strip(), value.strip()
+                        if value and value[0] in ('"', "'") and value[-1] == value[0]:
+                            value = value[1:-1]
+                        env_dict[key] = value
+        except (IOError, OSError):
+            pass
+        return env_dict
+
+    @staticmethod
+    def get_all_settings() -> dict:
+        """Returns comprehensive settings overview"""
+        return {
+            "credentials": SettingsDetector.detect_credentials(),
+            "custom_bases": SettingsDetector.detect_custom_api_bases(),
+            "model_definitions": SettingsDetector.detect_model_definitions(),
+            "concurrency_limits": SettingsDetector.detect_concurrency_limits(),
+            "model_filters": SettingsDetector.detect_model_filters()
+        }
+    
+    @staticmethod
+    def detect_credentials() -> dict:
+        """Detect API keys and OAuth credentials"""
+        from pathlib import Path
+        
+        providers = {}
+        
+        # Scan for API keys
+        env_vars = SettingsDetector._load_local_env()
+        for key, value in env_vars.items():
+            if "_API_KEY" in key and key != "PROXY_API_KEY":
+                provider = key.split("_API_KEY")[0].lower()
+                if provider not in providers:
+                    providers[provider] = {"api_keys": 0, "oauth": 0, "custom": False}
+                providers[provider]["api_keys"] += 1
+        
+        # Scan for OAuth credentials
+        oauth_dir = Path("oauth_credentials")
+        if oauth_dir.exists():
+            for file in oauth_dir.glob("*_oauth_*.json"):
+                provider = file.name.split("_oauth_")[0]
+                if provider not in providers:
+                    providers[provider] = {"api_keys": 0, "oauth": 0, "custom": False}
+                providers[provider]["oauth"] += 1
+        
+        # Mark custom providers (have API_BASE set)
+        for provider in providers:
+            if os.getenv(f"{provider.upper()}_API_BASE"):
+                providers[provider]["custom"] = True
+        
+        return providers
+    
+    @staticmethod
+    def detect_custom_api_bases() -> dict:
+        """Detect custom API base URLs (not in hardcoded map)"""
+        from proxy_app.provider_urls import PROVIDER_URL_MAP
+        
+        bases = {}
+        env_vars = SettingsDetector._load_local_env()
+        for key, value in env_vars.items():
+            if key.endswith("_API_BASE"):
+                provider = key.replace("_API_BASE", "").lower()
+                # Only include if NOT in hardcoded map
+                if provider not in PROVIDER_URL_MAP:
+                    bases[provider] = value
+        return bases
+    
+    @staticmethod
+    def detect_model_definitions() -> dict:
+        """Detect provider model definitions"""
+        models = {}
+        env_vars = SettingsDetector._load_local_env()
+        for key, value in env_vars.items():
+            if key.endswith("_MODELS"):
+                provider = key.replace("_MODELS", "").lower()
+                try:
+                    parsed = json.loads(value)
+                    if isinstance(parsed, dict):
+                        models[provider] = len(parsed)
+                    elif isinstance(parsed, list):
+                        models[provider] = len(parsed)
+                except (json.JSONDecodeError, ValueError):
+                    pass
+        return models
+    
+    @staticmethod
+    def detect_concurrency_limits() -> dict:
+        """Detect max concurrent requests per key"""
+        limits = {}
+        env_vars = SettingsDetector._load_local_env()
+        for key, value in env_vars.items():
+            if key.startswith("MAX_CONCURRENT_REQUESTS_PER_KEY_"):
+                provider = key.replace("MAX_CONCURRENT_REQUESTS_PER_KEY_", "").lower()
+                try:
+                    limits[provider] = int(value)
+                except (json.JSONDecodeError, ValueError):
+                    pass
+        return limits
+    
+    @staticmethod
+    def detect_model_filters() -> dict:
+        """Detect active model filters (basic info only: defined or not)"""
+        filters = {}
+        env_vars = SettingsDetector._load_local_env()
+        for key, value in env_vars.items():
+            if key.startswith("IGNORE_MODELS_") or key.startswith("WHITELIST_MODELS_"):
+                filter_type = "ignore" if key.startswith("IGNORE") else "whitelist"
+                provider = key.replace(f"{filter_type.upper()}_MODELS_", "").lower()
+                if provider not in filters:
+                    filters[provider] = {"has_ignore": False, "has_whitelist": False}
+                if filter_type == "ignore":
+                    filters[provider]["has_ignore"] = True
+                else:
+                    filters[provider]["has_whitelist"] = True
+        return filters
+
+
+class LauncherTUI:
+    """Main launcher interface"""
+    
+    def __init__(self):
+        self.console = Console()
+        self.config = LauncherConfig()
+        self.running = True
+        self.env_file = Path.cwd() / ".env"
+    
+    def needs_onboarding(self) -> bool:
+        """Check if onboarding is needed"""
+        return not self.env_file.exists() or not os.getenv("PROXY_API_KEY")
+    
+    def run(self):
+        """Main TUI loop"""
+        while self.running:
+            self.show_main_menu()
+    
+    def show_main_menu(self):
+        """Display main menu and handle selection"""
+        self.console.clear()
+        
+        # Detect all settings
+        settings = SettingsDetector.get_all_settings()
+        credentials = settings["credentials"]
+        custom_bases = settings["custom_bases"]
+        
+        # Check if setup is needed
+        show_warning = self.needs_onboarding()
+        
+        # Build title
+        self.console.print(Panel.fit(
+            "[bold cyan]🚀 LLM API Key Proxy - Interactive Launcher[/bold cyan]",
+            border_style="cyan"
+        ))
+        
+        # Show warning if needed
+        if show_warning:
+            self.console.print()
+            self.console.print(Panel(
+                Text.from_markup(
+                    "⚠️  [bold yellow]CONFIGURATION REQUIRED[/bold yellow]\n\n"
+                    "The proxy cannot start because:\n"
+                    "  ❌ No .env file found (or)\n"
+                    "  ❌ PROXY_API_KEY is not set in .env\n\n"
+                    "Why this matters:\n"
+                    "  • The .env file stores your proxy's authentication key\n"
+                    "  • The PROXY_API_KEY protects your proxy from unauthorized access\n"
+                    "  • Without it, the proxy cannot securely start\n\n"
+                    "What to do:\n"
+                    "  1. Select option \"3. Manage Credentials\" to launch the credential tool\n"
+                    "  2. The tool will create .env and set up PROXY_API_KEY automatically\n"
+                    "  3. You can also add LLM provider credentials while you're there\n\n"
+                    "⚠️  Important: While provider credentials are optional for startup,\n"
+                    "   the proxy won't do anything useful without them. See README.md\n"
+                    "   for supported providers and setup instructions."
+                ),
+                border_style="yellow",
+                expand=False
+            ))
+        
+        # Show config
+        self.console.print()
+        self.console.print("[bold]📋 Proxy Configuration[/bold]")
+        self.console.print("━" * 70)
+        self.console.print(f"   Host:                {self.config.config['host']}")
+        self.console.print(f"   Port:                {self.config.config['port']}")
+        self.console.print(f"   Request Logging:     {'✅ Enabled' if self.config.config['enable_request_logging'] else '❌ Disabled'}")
+        self.console.print(f"   Proxy API Key:       {'✅ Set' if os.getenv('PROXY_API_KEY') else '❌ Not Set'}")
+        
+        # Show status summary
+        self.console.print()
+        self.console.print("[bold]📊 Status Summary[/bold]")
+        self.console.print("━" * 70)
+        provider_count = len(credentials)
+        custom_count = len(custom_bases)
+        has_advanced = bool(settings["model_definitions"] or settings["concurrency_limits"] or settings["model_filters"])
+        
+        self.console.print(f"   Providers:           {provider_count} configured")
+        self.console.print(f"   Custom Providers:    {custom_count} configured")
+        self.console.print(f"   Advanced Settings:   {'Active (view in menu 4)' if has_advanced else 'None'}")
+        
+        # Show menu
+        self.console.print()
+        self.console.print("━" * 70)
+        self.console.print()
+        self.console.print("[bold]🎯 Main Menu[/bold]")
+        self.console.print()
+        
+        if show_warning:
+            self.console.print("   1. ▶️  Run Proxy Server")
+            self.console.print("   2. ⚙️  Configure Proxy Settings")
+            self.console.print("   3. 🔑 Manage Credentials            ⬅️  [bold yellow]Start here![/bold yellow]")
+        else:
+            self.console.print("   1. ▶️  Run Proxy Server")
+            self.console.print("   2. ⚙️  Configure Proxy Settings")
+            self.console.print("   3. 🔑 Manage Credentials")
+        
+        self.console.print("   4. 📊 View Provider & Advanced Settings")
+        self.console.print("   5. 🔄 Reload Configuration")
+        self.console.print("   6. 🚪 Exit")
+        
+        self.console.print()
+        self.console.print("━" * 70)
+        self.console.print()
+        
+        choice = Prompt.ask("Select option", choices=["1", "2", "3", "4", "5", "6"], show_choices=False)
+        
+        if choice == "1":
+            self.run_proxy()
+        elif choice == "2":
+            self.show_config_menu()
+        elif choice == "3":
+            self.launch_credential_tool()
+        elif choice == "4":
+            self.show_provider_settings_menu()
+        elif choice == "5":
+            load_dotenv(dotenv_path=Path.cwd() / ".env",override=True)
+            self.config = LauncherConfig()  # Reload config
+            self.console.print("\n[green]✅ Configuration reloaded![/green]")
+        elif choice == "6":
+            self.running = False
+            sys.exit(0)
+    
+    def show_config_menu(self):
+        """Display configuration sub-menu"""
+        while True:
+            self.console.clear()
+            
+            self.console.print(Panel.fit(
+                "[bold cyan]⚙️  Proxy Configuration[/bold cyan]",
+                border_style="cyan"
+            ))
+            
+            self.console.print()
+            self.console.print("[bold]📋 Current Settings[/bold]")
+            self.console.print("━" * 70)
+            self.console.print(f"   Host:                {self.config.config['host']}")
+            self.console.print(f"   Port:                {self.config.config['port']}")
+            self.console.print(f"   Request Logging:     {'✅ Enabled' if self.config.config['enable_request_logging'] else '❌ Disabled'}")
+            self.console.print(f"   Proxy API Key:       {'✅ Set' if os.getenv('PROXY_API_KEY') else '❌ Not Set'}")
+            
+            self.console.print()
+            self.console.print("━" * 70)
+            self.console.print()
+            self.console.print("[bold]⚙️  Configuration Options[/bold]")
+            self.console.print()
+            self.console.print("   1. 🌐 Set Host IP")
+            self.console.print("   2. 🔌 Set Port")
+            self.console.print("   3. 🔑 Set Proxy API Key")
+            self.console.print("   4. 📝 Toggle Request Logging")
+            self.console.print("   5. ↩️  Back to Main Menu")
+            
+            self.console.print()
+            self.console.print("━" * 70)
+            self.console.print()
+            
+            choice = Prompt.ask("Select option", choices=["1", "2", "3", "4", "5"], show_choices=False)
+            
+            if choice == "1":
+                new_host = Prompt.ask("Enter new host IP", default=self.config.config["host"])
+                self.config.update(host=new_host)
+                self.console.print(f"\n[green]✅ Host updated to: {new_host}[/green]")
+            elif choice == "2":
+                new_port = IntPrompt.ask("Enter new port", default=self.config.config["port"])
+                if 1 <= new_port <= 65535:
+                    self.config.update(port=new_port)
+                    self.console.print(f"\n[green]✅ Port updated to: {new_port}[/green]")
+                else:
+                    self.console.print("\n[red]❌ Port must be between 1-65535[/red]")
+            elif choice == "3":
+                current = os.getenv("PROXY_API_KEY", "")
+                new_key = Prompt.ask("Enter new Proxy API Key", default=current)
+                if new_key and new_key != current:
+                    LauncherConfig.update_proxy_api_key(new_key)
+                    self.console.print("\n[green]✅ Proxy API Key updated successfully![/green]")
+                    self.console.print("   Updated in .env file")
+                else:
+                    self.console.print("\n[yellow]No changes made[/yellow]")
+            elif choice == "4":
+                current = self.config.config["enable_request_logging"]
+                self.config.update(enable_request_logging=not current)
+                self.console.print(f"\n[green]✅ Request Logging {'enabled' if not current else 'disabled'}![/green]")
+            elif choice == "5":
+                break
+    
+    def show_provider_settings_menu(self):
+        """Display provider/advanced settings (read-only + launch tool)"""
+        self.console.clear()
+        
+        settings = SettingsDetector.get_all_settings()
+        credentials = settings["credentials"]
+        custom_bases = settings["custom_bases"]
+        model_defs = settings["model_definitions"]
+        concurrency = settings["concurrency_limits"]
+        filters = settings["model_filters"]
+        
+        self.console.print(Panel.fit(
+            "[bold cyan]📊 Provider & Advanced Settings[/bold cyan]",
+            border_style="cyan"
+        ))
+        
+        # Configured Providers
+        self.console.print()
+        self.console.print("[bold]📊 Configured Providers[/bold]")
+        self.console.print("━" * 70)
+        if credentials:
+            for provider, info in credentials.items():
+                provider_name = provider.title()
+                parts = []
+                if info["api_keys"] > 0:
+                    parts.append(f"{info['api_keys']} API key{'s' if info['api_keys'] > 1 else ''}")
+                if info["oauth"] > 0:
+                    parts.append(f"{info['oauth']} OAuth credential{'s' if info['oauth'] > 1 else ''}")
+                
+                display = " + ".join(parts)
+                if info["custom"]:
+                    display += " (Custom)"
+                
+                self.console.print(f"   ✅ {provider_name:20} {display}")
+        else:
+            self.console.print("   [dim]No providers configured[/dim]")
+        
+        # Custom API Bases
+        if custom_bases:
+            self.console.print()
+            self.console.print("[bold]🌐 Custom API Bases[/bold]")
+            self.console.print("━" * 70)
+            for provider, base in custom_bases.items():
+                self.console.print(f"   • {provider:15} {base}")
+        
+        # Model Definitions
+        if model_defs:
+            self.console.print()
+            self.console.print("[bold]📦 Provider Model Definitions[/bold]")
+            self.console.print("━" * 70)
+            for provider, count in model_defs.items():
+                self.console.print(f"   • {provider:15} {count} model{'s' if count > 1 else ''} configured")
+        
+        # Concurrency Limits
+        if concurrency:
+            self.console.print()
+            self.console.print("[bold]⚡ Concurrency Limits[/bold]")
+            self.console.print("━" * 70)
+            for provider, limit in concurrency.items():
+                self.console.print(f"   • {provider:15} {limit} requests/key")
+            self.console.print(f"   • Default:        1 request/key (all others)")
+        
+        # Model Filters (basic info only)
+        if filters:
+            self.console.print()
+            self.console.print("[bold]🎯 Model Filters[/bold]")
+            self.console.print("━" * 70)
+            for provider, filter_info in filters.items():
+                status_parts = []
+                if filter_info["has_whitelist"]:
+                    status_parts.append("Whitelist")
+                if filter_info["has_ignore"]:
+                    status_parts.append("Ignore list")
+                status = " + ".join(status_parts) if status_parts else "None"
+                self.console.print(f"   • {provider:15} ✅ {status}")
+        
+        # Actions
+        self.console.print()
+        self.console.print("━" * 70)
+        self.console.print()
+        self.console.print("[bold]💡 Actions[/bold]")
+        self.console.print()
+        self.console.print("   1. 🔧 Launch Settings Tool      (configure advanced settings)")
+        self.console.print("   2. ↩️  Back to Main Menu")
+        
+        self.console.print()
+        self.console.print("━" * 70)
+        self.console.print("[dim]ℹ️  Advanced settings are stored in .env file.\n   Use the Settings Tool to configure them interactively.[/dim]")
+        self.console.print()
+        self.console.print("[dim]⚠️  Note: Settings Tool supports only common configuration types.\n   For complex settings, edit .env directly.[/dim]")
+        self.console.print()
+        
+        choice = Prompt.ask("Select option", choices=["1", "2"], show_choices=False)
+        
+        if choice == "1":
+            self.launch_settings_tool()
+        # choice == "2" returns to main menu
+    
+    def launch_credential_tool(self):
+        """Launch credential management tool"""
+        from rotator_library.credential_tool import run_credential_tool
+        run_credential_tool()
+        # Reload environment after credential tool
+        load_dotenv(dotenv_path=Path.cwd() / ".env", override=True)
+    
+    def launch_settings_tool(self):
+        """Launch settings configuration tool"""
+        from proxy_app.settings_tool import run_settings_tool
+        run_settings_tool()
+        # Reload environment after settings tool
+        load_dotenv(dotenv_path=Path.cwd() / ".env", override=True)
+    
+    def run_proxy(self):
+        """Prepare and launch proxy in same window"""
+        # Check if forced onboarding needed
+        if self.needs_onboarding():
+            self.console.clear()
+            self.console.print(Panel(
+                Text.from_markup(
+                    "⚠️  [bold yellow]Setup Required[/bold yellow]\n\n"
+                    "Cannot start without .env and PROXY_API_KEY.\n"
+                    "Launching credential tool..."
+                ),
+                border_style="yellow"
+            ))
+            
+            # Force credential tool
+            from rotator_library.credential_tool import ensure_env_defaults, run_credential_tool
+            ensure_env_defaults()
+            load_dotenv(dotenv_path=Path.cwd() / ".env", override=True)
+            run_credential_tool()
+            load_dotenv(dotenv_path=Path.cwd() / ".env", override=True)
+            
+            # Check again after credential tool
+            if not os.getenv("PROXY_API_KEY"):
+                self.console.print("\n[red]❌ PROXY_API_KEY still not set. Cannot start proxy.[/red]")
+                return
+        
+        # Clear console and modify sys.argv
+        self.console.clear()
+        self.console.print(f"\n[bold green]🚀 Starting proxy on {self.config.config['host']}:{self.config.config['port']}...[/bold green]\n")
+        
+        # Reconstruct sys.argv for main.py
+        sys.argv = [
+            "main.py",
+            "--host", self.config.config["host"],
+            "--port", str(self.config.config["port"])
+        ]
+        if self.config.config["enable_request_logging"]:
+            sys.argv.append("--enable-request-logging")
+        
+        # Exit TUI - main.py will continue execution
+        self.running = False
+
+
+def run_launcher_tui():
+    """Entry point for launcher TUI"""
+    tui = LauncherTUI()
+    tui.run()

src/proxy_app/main.py

@@ -761,6 +761,16 @@ if __name__ == "__main__":
     # Define ENV_FILE for onboarding checks
     ENV_FILE = Path.cwd() / ".env"
     
+    # Check if launcher TUI should be shown (no arguments provided)
+    if len(sys.argv) == 1:
+        # No arguments - show launcher TUI
+        from proxy_app.launcher_tui import run_launcher_tui
+        run_launcher_tui()
+        # Launcher modifies sys.argv and returns, or exits if user chose Exit
+        # If we get here, user chose "Run Proxy" and sys.argv is modified
+        # Re-parse arguments with modified sys.argv
+        args = parser.parse_args()
+    
     def needs_onboarding() -> bool:
         """
         Check if the proxy needs onboarding (first-time setup).

src/proxy_app/settings_tool.py

@@ -0,0 +1,790 @@
+"""
+Advanced settings configuration tool for the LLM API Key Proxy.
+Provides interactive configuration for custom providers, model definitions, and concurrency limits.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, Any, Optional, List
+from rich.console import Console
+from rich.prompt import Prompt, IntPrompt, Confirm
+from rich.panel import Panel
+from dotenv import set_key, unset_key
+
+console = Console()
+
+
+class AdvancedSettings:
+    """Manages pending changes to .env"""
+    
+    def __init__(self):
+        self.env_file = Path.cwd() / ".env"
+        self.pending_changes = {}  # key -> value (None means delete)
+        self.load_current_settings()
+    
+    def load_current_settings(self):
+        """Load current .env values into env vars"""
+        from dotenv import load_dotenv
+        load_dotenv(override=True)
+    
+    def set(self, key: str, value: str):
+        """Stage a change"""
+        self.pending_changes[key] = value
+    
+    def remove(self, key: str):
+        """Stage a removal"""
+        self.pending_changes[key] = None
+    
+    def save(self):
+        """Write pending changes to .env"""
+        for key, value in self.pending_changes.items():
+            if value is None:
+                # Remove key
+                unset_key(str(self.env_file), key)
+            else:
+                # Set key
+                set_key(str(self.env_file), key, value)
+        
+        self.pending_changes.clear()
+        self.load_current_settings()
+    
+    def discard(self):
+        """Discard pending changes"""
+        self.pending_changes.clear()
+    
+    def has_pending(self) -> bool:
+        """Check if there are pending changes"""
+        return bool(self.pending_changes)
+
+
+class CustomProviderManager:
+    """Manages custom provider API bases"""
+    
+    def __init__(self, settings: AdvancedSettings):
+        self.settings = settings
+    
+    def get_current_providers(self) -> Dict[str, str]:
+        """Get currently configured custom providers"""
+        from proxy_app.provider_urls import PROVIDER_URL_MAP
+        
+        providers = {}
+        for key, value in os.environ.items():
+            if key.endswith("_API_BASE"):
+                provider = key.replace("_API_BASE", "").lower()
+                # Only include if NOT in hardcoded map
+                if provider not in PROVIDER_URL_MAP:
+                    providers[provider] = value
+        return providers
+    
+    def add_provider(self, name: str, api_base: str):
+        """Add PROVIDER_API_BASE"""
+        key = f"{name.upper()}_API_BASE"
+        self.settings.set(key, api_base)
+    
+    def edit_provider(self, name: str, api_base: str):
+        """Edit PROVIDER_API_BASE"""
+        self.add_provider(name, api_base)
+    
+    def remove_provider(self, name: str):
+        """Remove PROVIDER_API_BASE"""
+        key = f"{name.upper()}_API_BASE"
+        self.settings.remove(key)
+
+
+class ModelDefinitionManager:
+    """Manages PROVIDER_MODELS"""
+    
+    def __init__(self, settings: AdvancedSettings):
+        self.settings = settings
+    
+    def get_current_provider_models(self, provider: str) -> Optional[Dict]:
+        """Get currently configured models for a provider"""
+        key = f"{provider.upper()}_MODELS"
+        value = os.getenv(key)
+        if value:
+            try:
+                return json.loads(value)
+            except (json.JSONDecodeError, ValueError):
+                return None
+        return None
+    
+    def get_all_providers_with_models(self) -> Dict[str, int]:
+        """Get all providers with model definitions"""
+        providers = {}
+        for key, value in os.environ.items():
+            if key.endswith("_MODELS"):
+                provider = key.replace("_MODELS", "").lower()
+                try:
+                    parsed = json.loads(value)
+                    if isinstance(parsed, dict):
+                        providers[provider] = len(parsed)
+                    elif isinstance(parsed, list):
+                        providers[provider] = len(parsed)
+                except (json.JSONDecodeError, ValueError):
+                    pass
+        return providers
+    
+    def set_models(self, provider: str, models: Dict[str, Dict[str, Any]]):
+        """Set PROVIDER_MODELS"""
+        key = f"{provider.upper()}_MODELS"
+        value = json.dumps(models)
+        self.settings.set(key, value)
+    
+    def remove_models(self, provider: str):
+        """Remove PROVIDER_MODELS"""
+        key = f"{provider.upper()}_MODELS"
+        self.settings.remove(key)
+
+
+class ConcurrencyManager:
+    """Manages MAX_CONCURRENT_REQUESTS_PER_KEY_PROVIDER"""
+    
+    def __init__(self, settings: AdvancedSettings):
+        self.settings = settings
+    
+    def get_current_limits(self) -> Dict[str, int]:
+        """Get currently configured concurrency limits"""
+        limits = {}
+        for key, value in os.environ.items():
+            if key.startswith("MAX_CONCURRENT_REQUESTS_PER_KEY_"):
+                provider = key.replace("MAX_CONCURRENT_REQUESTS_PER_KEY_", "").lower()
+                try:
+                    limits[provider] = int(value)
+                except (json.JSONDecodeError, ValueError):
+                    pass
+        return limits
+    
+    def set_limit(self, provider: str, limit: int):
+        """Set concurrency limit"""
+        key = f"MAX_CONCURRENT_REQUESTS_PER_KEY_{provider.upper()}"
+        self.settings.set(key, str(limit))
+    
+    def remove_limit(self, provider: str):
+        """Remove concurrency limit (reset to default)"""
+        key = f"MAX_CONCURRENT_REQUESTS_PER_KEY_{provider.upper()}"
+        self.settings.remove(key)
+
+
+class SettingsTool:
+    """Main settings tool TUI"""
+    
+    def __init__(self):
+        self.console = Console()
+        self.settings = AdvancedSettings()
+        self.provider_mgr = CustomProviderManager(self.settings)
+        self.model_mgr = ModelDefinitionManager(self.settings)
+        self.concurrency_mgr = ConcurrencyManager(self.settings)
+        self.running = True
+    
+    def get_available_providers(self) -> List[str]:
+        """Get list of providers that have credentials configured"""
+        env_file = Path.cwd() / ".env"
+        providers = set()
+        
+        # Scan for providers with API keys from local .env
+        if env_file.exists():
+            try:
+                with open(env_file, 'r', encoding='utf-8') as f:
+                    for line in f:
+                        line = line.strip()
+                        if "_API_KEY" in line and "PROXY_API_KEY" not in line and "=" in line:
+                            provider = line.split("_API_KEY")[0].strip().lower()
+                            providers.add(provider)
+            except (IOError, OSError):
+                pass
+        
+        # Also check for OAuth providers from files
+        oauth_dir = Path("oauth_credentials")
+        if oauth_dir.exists():
+            for file in oauth_dir.glob("*_oauth_*.json"):
+                provider = file.name.split("_oauth_")[0]
+                providers.add(provider)
+        
+        return sorted(list(providers))
+
+    def run(self):
+        """Main loop"""
+        while self.running:
+            self.show_main_menu()
+    
+    def show_main_menu(self):
+        """Display settings categories"""
+        self.console.clear()
+        
+        self.console.print(Panel.fit(
+            "[bold cyan]🔧 Advanced Settings Configuration[/bold cyan]",
+            border_style="cyan"
+        ))
+        
+        self.console.print()
+        self.console.print("[bold]⚙️  Configuration Categories[/bold]")
+        self.console.print()
+        self.console.print("   1. 🌐 Custom Provider API Bases")
+        self.console.print("   2. 📦 Provider Model Definitions")
+        self.console.print("   3. ⚡ Concurrency Limits")
+        self.console.print("   4. 💾 Save & Exit")
+        self.console.print("   5. 🚫 Exit Without Saving")
+        
+        self.console.print()
+        self.console.print("━" * 70)
+        
+        if self.settings.has_pending():
+            self.console.print("[yellow]ℹ️  Changes are pending until you select \"Save & Exit\"[/yellow]")
+        else:
+            self.console.print("[dim]ℹ️  No pending changes[/dim]")
+        
+        self.console.print()
+        self.console.print("[dim]⚠️  Model filters not supported - edit .env for IGNORE_MODELS_* / WHITELIST_MODELS_*[/dim]")
+        self.console.print()
+        
+        choice = Prompt.ask("Select option", choices=["1", "2", "3", "4", "5"], show_choices=False)
+        
+        if choice == "1":
+            self.manage_custom_providers()
+        elif choice == "2":
+            self.manage_model_definitions()
+        elif choice == "3":
+            self.manage_concurrency_limits()
+        elif choice == "4":
+            self.save_and_exit()
+        elif choice == "5":
+            self.exit_without_saving()
+    
+    def manage_custom_providers(self):
+        """Manage custom provider API bases"""
+        while True:
+            self.console.clear()
+            
+            providers = self.provider_mgr.get_current_providers()
+            
+            self.console.print(Panel.fit(
+                "[bold cyan]🌐 Custom Provider API Bases[/bold cyan]",
+                border_style="cyan"
+            ))
+            
+            self.console.print()
+            self.console.print("[bold]📋 Configured Custom Providers[/bold]")
+            self.console.print("━" * 70)
+            
+            if providers:
+                for name, base in providers.items():
+                    self.console.print(f"   • {name:15} {base}")
+            else:
+                self.console.print("   [dim]No custom providers configured[/dim]")
+            
+            self.console.print()
+            self.console.print("━" * 70)
+            self.console.print()
+            self.console.print("[bold]⚙️  Actions[/bold]")
+            self.console.print()
+            self.console.print("   1. ➕ Add New Custom Provider")
+            self.console.print("   2. ✏️  Edit Existing Provider")
+            self.console.print("   3. 🗑️  Remove Provider")
+            self.console.print("   4. ↩️  Back to Settings Menu")
+            
+            self.console.print()
+            self.console.print("━" * 70)
+            self.console.print()
+            
+            choice = Prompt.ask("Select option", choices=["1", "2", "3", "4"], show_choices=False)
+            
+            if choice == "1":
+                name = Prompt.ask("Provider name (e.g., 'opencode')").strip().lower()
+                if name:
+                    api_base = Prompt.ask("API Base URL").strip()
+                    if api_base:
+                        self.provider_mgr.add_provider(name, api_base)
+                        self.console.print(f"\n[green]✅ Custom provider '{name}' configured![/green]")
+                        self.console.print(f"   To use: set {name.upper()}_API_KEY in credentials")
+                        input("\nPress Enter to continue...")
+            
+            elif choice == "2":
+                if not providers:
+                    self.console.print("\n[yellow]No providers to edit[/yellow]")
+                    input("\nPress Enter to continue...")
+                    continue
+                
+                # Show numbered list
+                self.console.print("\n[bold]Select provider to edit:[/bold]")
+                providers_list = list(providers.keys())
+                for idx, prov in enumerate(providers_list, 1):
+                    self.console.print(f"   {idx}. {prov}")
+                
+                choice_idx = IntPrompt.ask("Select option", choices=[str(i) for i in range(1, len(providers_list) + 1)])
+                name = providers_list[choice_idx - 1]
+                current_base = providers.get(name, "")
+                
+                self.console.print(f"\nCurrent API Base: {current_base}")
+                new_base = Prompt.ask("New API Base [press Enter to keep current]", default=current_base).strip()
+                
+                if new_base and new_base != current_base:
+                    self.provider_mgr.edit_provider(name, new_base)
+                    self.console.print(f"\n[green]✅ Custom provider '{name}' updated![/green]")
+                else:
+                    self.console.print("\n[yellow]No changes made[/yellow]")
+                input("\nPress Enter to continue...")
+            
+            elif choice == "3":
+                if not providers:
+                    self.console.print("\n[yellow]No providers to remove[/yellow]")
+                    input("\nPress Enter to continue...")
+                    continue
+                
+                # Show numbered list
+                self.console.print("\n[bold]Select provider to remove:[/bold]")
+                providers_list = list(providers.keys())
+                for idx, prov in enumerate(providers_list, 1):
+                    self.console.print(f"   {idx}. {prov}")
+                
+                choice_idx = IntPrompt.ask("Select option", choices=[str(i) for i in range(1, len(providers_list) + 1)])
+                name = providers_list[choice_idx - 1]
+                
+                if Confirm.ask(f"Remove '{name}'?"):
+                    self.provider_mgr.remove_provider(name)
+                    self.console.print(f"\n[green]✅ Provider '{name}' removed![/green]")
+                    input("\nPress Enter to continue...")
+            
+            elif choice == "4":
+                break
+    
+    def manage_model_definitions(self):
+        """Manage provider model definitions"""
+        while True:
+            self.console.clear()
+            
+            all_providers = self.model_mgr.get_all_providers_with_models()
+            
+            self.console.print(Panel.fit(
+                "[bold cyan]📦 Provider Model Definitions[/bold cyan]",
+                border_style="cyan"
+            ))
+            
+            self.console.print()
+            self.console.print("[bold]📋 Configured Provider Models[/bold]")
+            self.console.print("━" * 70)
+            
+            if all_providers:
+                for provider, count in all_providers.items():
+                    self.console.print(f"   • {provider:15} {count} model{'s' if count > 1 else ''}")
+            else:
+                self.console.print("   [dim]No model definitions configured[/dim]")
+            
+            self.console.print()
+            self.console.print("━" * 70)
+            self.console.print()
+            self.console.print("[bold]⚙️  Actions[/bold]")
+            self.console.print()
+            self.console.print("   1. ➕ Add Models for Provider")
+            self.console.print("   2. ✏️  Edit Provider Models")
+            self.console.print("   3. 👁️  View Provider Models")
+            self.console.print("   4. 🗑️  Remove Provider Models")
+            self.console.print("   5. ↩️  Back to Settings Menu")
+            
+            self.console.print()
+            self.console.print("━" * 70)
+            self.console.print()
+            
+            choice = Prompt.ask("Select option", choices=["1", "2", "3", "4", "5"], show_choices=False)
+            
+            if choice == "1":
+                self.add_model_definitions()
+            elif choice == "2":
+                if not all_providers:
+                    self.console.print("\n[yellow]No providers to edit[/yellow]")
+                    input("\nPress Enter to continue...")
+                    continue
+                self.edit_model_definitions(list(all_providers.keys()))
+            elif choice == "3":
+                if not all_providers:
+                    self.console.print("\n[yellow]No providers to view[/yellow]")
+                    input("\nPress Enter to continue...")
+                    continue
+                self.view_model_definitions(list(all_providers.keys()))
+            elif choice == "4":
+                if not all_providers:
+                    self.console.print("\n[yellow]No providers to remove[/yellow]")
+                    input("\nPress Enter to continue...")
+                    continue
+                
+                # Show numbered list
+                self.console.print("\n[bold]Select provider to remove models from:[/bold]")
+                providers_list = list(all_providers.keys())
+                for idx, prov in enumerate(providers_list, 1):
+                    self.console.print(f"   {idx}. {prov}")
+                
+                choice_idx = IntPrompt.ask("Select option", choices=[str(i) for i in range(1, len(providers_list) + 1)])
+                provider = providers_list[choice_idx - 1]
+                
+                if Confirm.ask(f"Remove all model definitions for '{provider}'?"):
+                    self.model_mgr.remove_models(provider)
+                    self.console.print(f"\n[green]✅ Model definitions removed for '{provider}'![/green]")
+                    input("\nPress Enter to continue...")
+            elif choice == "5":
+                break
+    
+    def add_model_definitions(self):
+        """Add model definitions for a provider"""
+        # Get available providers from credentials
+        available_providers = self.get_available_providers()
+        
+        if not available_providers:
+            self.console.print("\n[yellow]No providers with credentials found. Please add credentials first.[/yellow]")
+            input("\nPress Enter to continue...")
+            return
+        
+        # Show provider selection menu
+        self.console.print("\n[bold]Select provider:[/bold]")
+        for idx, prov in enumerate(available_providers, 1):
+            self.console.print(f"   {idx}. {prov}")
+        self.console.print(f"   {len(available_providers) + 1}. Enter custom provider name")
+        
+        choice = IntPrompt.ask("Select option", choices=[str(i) for i in range(1, len(available_providers) + 2)])
+        
+        if choice == len(available_providers) + 1:
+            provider = Prompt.ask("Provider name").strip().lower()
+        else:
+            provider = available_providers[choice - 1]
+        
+        if not provider:
+            return
+        
+        self.console.print("\nHow would you like to define models?")
+        self.console.print("   1. Simple list (names only)")
+        self.console.print("   2. Advanced (names with IDs and options)")
+        
+        mode = Prompt.ask("Select mode", choices=["1", "2"], show_choices=False)
+        
+        models = {}
+        
+        if mode == "1":
+            # Simple mode
+            while True:
+                name = Prompt.ask("\nModel name (or 'done' to finish)").strip()
+                if name.lower() == "done":
+                    break
+                if name:
+                    models[name] = {}
+        else:
+            # Advanced mode
+            while True:
+                name = Prompt.ask("\nModel name (or 'done' to finish)").strip()
+                if name.lower() == "done":
+                    break
+                if name:
+                    model_def = {}
+                    model_id = Prompt.ask(f"Model ID [press Enter to use '{name}']", default=name).strip()
+                    if model_id and model_id != name:
+                        model_def["id"] = model_id
+                    
+                    # Optional: model options
+                    if Confirm.ask("Add model options (e.g., temperature limits)?", default=False):
+                        self.console.print("\nEnter options as key=value pairs (one per line, 'done' to finish):")
+                        options = {}
+                        while True:
+                            opt = Prompt.ask("Option").strip()
+                            if opt.lower() == "done":
+                                break
+                            if "=" in opt:
+                                key, value = opt.split("=", 1)
+                                value = value.strip()
+                                # Try to convert to number if possible
+                                try:
+                                    value = float(value) if "." in value else int(value)
+                                except (ValueError, TypeError):
+                                    pass
+                                options[key.strip()] = value
+                        if options:
+                            model_def["options"] = options
+                    
+                    models[name] = model_def
+        
+        if models:
+            self.model_mgr.set_models(provider, models)
+            self.console.print(f"\n[green]✅ Model definitions saved for '{provider}'![/green]")
+        else:
+            self.console.print("\n[yellow]No models added[/yellow]")
+        
+        input("\nPress Enter to continue...")
+    
+    def edit_model_definitions(self, providers: List[str]):
+        """Edit existing model definitions"""
+        # Show numbered list
+        self.console.print("\n[bold]Select provider to edit:[/bold]")
+        for idx, prov in enumerate(providers, 1):
+            self.console.print(f"   {idx}. {prov}")
+        
+        choice_idx = IntPrompt.ask("Select option", choices=[str(i) for i in range(1, len(providers) + 1)])
+        provider = providers[choice_idx - 1]
+        
+        current_models = self.model_mgr.get_current_provider_models(provider)
+        if not current_models:
+            self.console.print(f"\n[yellow]No models found for '{provider}'[/yellow]")
+            input("\nPress Enter to continue...")
+            return
+        
+        # Convert to dict if list
+        if isinstance(current_models, list):
+            current_models = {m: {} for m in current_models}
+        
+        while True:
+            self.console.clear()
+            self.console.print(f"[bold]Editing models for: {provider}[/bold]\n")
+            self.console.print("Current models:")
+            for i, (name, definition) in enumerate(current_models.items(), 1):
+                model_id = definition.get("id", name) if isinstance(definition, dict) else name
+                self.console.print(f"   {i}. {name} (ID: {model_id})")
+            
+            self.console.print("\nOptions:")
+            self.console.print("   1. Add new model")
+            self.console.print("   2. Edit existing model")
+            self.console.print("   3. Remove model")
+            self.console.print("   4. Done")
+            
+            choice = Prompt.ask("\nSelect option", choices=["1", "2", "3", "4"], show_choices=False)
+            
+            if choice == "1":
+                name = Prompt.ask("New model name").strip()
+                if name and name not in current_models:
+                    model_id = Prompt.ask("Model ID", default=name).strip()
+                    current_models[name] = {"id": model_id} if model_id != name else {}
+            
+            elif choice == "2":
+                # Show numbered list
+                models_list = list(current_models.keys())
+                self.console.print("\n[bold]Select model to edit:[/bold]")
+                for idx, model_name in enumerate(models_list, 1):
+                    self.console.print(f"   {idx}. {model_name}")
+                
+                model_idx = IntPrompt.ask("Select option", choices=[str(i) for i in range(1, len(models_list) + 1)])
+                name = models_list[model_idx - 1]
+                
+                current_def = current_models[name]
+                current_id = current_def.get("id", name) if isinstance(current_def, dict) else name
+                
+                new_id = Prompt.ask("Model ID", default=current_id).strip()
+                current_models[name] = {"id": new_id} if new_id != name else {}
+            
+            elif choice == "3":
+                # Show numbered list
+                models_list = list(current_models.keys())
+                self.console.print("\n[bold]Select model to remove:[/bold]")
+                for idx, model_name in enumerate(models_list, 1):
+                    self.console.print(f"   {idx}. {model_name}")
+                
+                model_idx = IntPrompt.ask("Select option", choices=[str(i) for i in range(1, len(models_list) + 1)])
+                name = models_list[model_idx - 1]
+                
+                if Confirm.ask(f"Remove '{name}'?"):
+                    del current_models[name]
+            
+            elif choice == "4":
+                break
+        
+        if current_models:
+            self.model_mgr.set_models(provider, current_models)
+            self.console.print(f"\n[green]✅ Models updated for '{provider}'![/green]")
+        else:
+            self.console.print("\n[yellow]No models left - removing definition[/yellow]")
+            self.model_mgr.remove_models(provider)
+        
+        input("\nPress Enter to continue...")
+    
+    def view_model_definitions(self, providers: List[str]):
+        """View model definitions for a provider"""
+        # Show numbered list
+        self.console.print("\n[bold]Select provider to view:[/bold]")
+        for idx, prov in enumerate(providers, 1):
+            self.console.print(f"   {idx}. {prov}")
+        
+        choice_idx = IntPrompt.ask("Select option", choices=[str(i) for i in range(1, len(providers) + 1)])
+        provider = providers[choice_idx - 1]
+        
+        models = self.model_mgr.get_current_provider_models(provider)
+        if not models:
+            self.console.print(f"\n[yellow]No models found for '{provider}'[/yellow]")
+            input("\nPress Enter to continue...")
+            return
+        
+        self.console.clear()
+        self.console.print(f"[bold]Provider: {provider}[/bold]\n")
+        self.console.print("[bold]📦 Configured Models:[/bold]")
+        self.console.print("━" * 50)
+        
+        # Handle both dict and list formats
+        if isinstance(models, dict):
+            for name, definition in models.items():
+                if isinstance(definition, dict):
+                    model_id = definition.get("id", name)
+                    self.console.print(f"   Name: {name}")
+                    self.console.print(f"   ID:   {model_id}")
+                    if "options" in definition:
+                        self.console.print(f"   Options: {definition['options']}")
+                    self.console.print()
+                else:
+                    self.console.print(f"   Name: {name}")
+                    self.console.print()
+        elif isinstance(models, list):
+            for name in models:
+                self.console.print(f"   Name: {name}")
+                self.console.print()
+        
+        input("Press Enter to return...")
+    
+    def manage_concurrency_limits(self):
+        """Manage concurrency limits"""
+        while True:
+            self.console.clear()
+            
+            limits = self.concurrency_mgr.get_current_limits()
+            
+            self.console.print(Panel.fit(
+                "[bold cyan]⚡ Concurrency Limits Configuration[/bold cyan]",
+                border_style="cyan"
+            ))
+            
+            self.console.print()
+            self.console.print("[bold]📋 Current Concurrency Settings[/bold]")
+            self.console.print("━" * 70)
+            
+            if limits:
+                for provider, limit in limits.items():
+                    self.console.print(f"   • {provider:15} {limit} requests/key")
+                self.console.print(f"   • Default:        1 request/key (all others)")
+            else:
+                self.console.print("   • Default:        1 request/key (all providers)")
+            
+            self.console.print()
+            self.console.print("━" * 70)
+            self.console.print()
+            self.console.print("[bold]⚙️  Actions[/bold]")
+            self.console.print()
+            self.console.print("   1. ➕ Add Concurrency Limit for Provider")
+            self.console.print("   2. ✏️  Edit Existing Limit")
+            self.console.print("   3. 🗑️  Remove Limit (reset to default)")
+            self.console.print("   4. ↩️  Back to Settings Menu")
+            
+            self.console.print()
+            self.console.print("━" * 70)
+            self.console.print()
+            
+            choice = Prompt.ask("Select option", choices=["1", "2", "3", "4"], show_choices=False)
+            
+            if choice == "1":
+                # Get available providers
+                available_providers = self.get_available_providers()
+                
+                if not available_providers:
+                    self.console.print("\n[yellow]No providers with credentials found. Please add credentials first.[/yellow]")
+                    input("\nPress Enter to continue...")
+                    continue
+                
+                # Show provider selection menu
+                self.console.print("\n[bold]Select provider:[/bold]")
+                for idx, prov in enumerate(available_providers, 1):
+                    self.console.print(f"   {idx}. {prov}")
+                self.console.print(f"   {len(available_providers) + 1}. Enter custom provider name")
+                
+                choice_idx = IntPrompt.ask("Select option", choices=[str(i) for i in range(1, len(available_providers) + 2)])
+                
+                if choice_idx == len(available_providers) + 1:
+                    provider = Prompt.ask("Provider name").strip().lower()
+                else:
+                    provider = available_providers[choice_idx - 1]
+                
+                if provider:
+                    limit = IntPrompt.ask("Max concurrent requests per key (1-100)", default=1)
+                    if 1 <= limit <= 100:
+                        self.concurrency_mgr.set_limit(provider, limit)
+                        self.console.print(f"\n[green]✅ Concurrency limit set for '{provider}': {limit} requests/key[/green]")
+                    else:
+                        self.console.print("\n[red]❌ Limit must be between 1-100[/red]")
+                    input("\nPress Enter to continue...")
+            
+            elif choice == "2":
+                if not limits:
+                    self.console.print("\n[yellow]No limits to edit[/yellow]")
+                    input("\nPress Enter to continue...")
+                    continue
+                
+                # Show numbered list
+                self.console.print("\n[bold]Select provider to edit:[/bold]")
+                limits_list = list(limits.keys())
+                for idx, prov in enumerate(limits_list, 1):
+                    self.console.print(f"   {idx}. {prov}")
+                
+                choice_idx = IntPrompt.ask("Select option", choices=[str(i) for i in range(1, len(limits_list) + 1)])
+                provider = limits_list[choice_idx - 1]
+                current_limit = limits.get(provider, 1)
+                
+                self.console.print(f"\nCurrent limit: {current_limit} requests/key")
+                new_limit = IntPrompt.ask("New limit (1-100) [press Enter to keep current]", default=current_limit)
+                
+                if 1 <= new_limit <= 100:
+                    if new_limit != current_limit:
+                        self.concurrency_mgr.set_limit(provider, new_limit)
+                        self.console.print(f"\n[green]✅ Concurrency limit updated for '{provider}': {new_limit} requests/key[/green]")
+                    else:
+                        self.console.print("\n[yellow]No changes made[/yellow]")
+                else:
+                    self.console.print("\n[red]Limit must be between 1-100[/red]")
+                input("\nPress Enter to continue...")
+            
+            elif choice == "3":
+                if not limits:
+                    self.console.print("\n[yellow]No limits to remove[/yellow]")
+                    input("\nPress Enter to continue...")
+                    continue
+                
+                # Show numbered list
+                self.console.print("\n[bold]Select provider to remove limit from:[/bold]")
+                limits_list = list(limits.keys())
+                for idx, prov in enumerate(limits_list, 1):
+                    self.console.print(f"   {idx}. {prov}")
+                
+                choice_idx = IntPrompt.ask("Select option", choices=[str(i) for i in range(1, len(limits_list) + 1)])
+                provider = limits_list[choice_idx - 1]
+                
+                if Confirm.ask(f"Remove concurrency limit for '{provider}' (reset to default 1)?"):
+                    self.concurrency_mgr.remove_limit(provider)
+                    self.console.print(f"\n[green]✅ Limit removed for '{provider}' - using default (1 request/key)[/green]")
+                    input("\nPress Enter to continue...")
+            
+            elif choice == "4":
+                break
+    
+    def save_and_exit(self):
+        """Save pending changes and exit"""
+        if self.settings.has_pending():
+            if Confirm.ask("\n[bold yellow]Save all pending changes?[/bold yellow]"):
+                self.settings.save()
+                self.console.print("\n[green]✅ All changes saved to .env![/green]")
+                input("\nPress Enter to return to launcher...")
+            else:
+                self.console.print("\n[yellow]Changes not saved[/yellow]")
+                input("\nPress Enter to continue...")
+                return
+        else:
+            self.console.print("\n[dim]No changes to save[/dim]")
+            input("\nPress Enter to return to launcher...")
+        
+        self.running = False
+    
+    def exit_without_saving(self):
+        """Exit without saving"""
+        if self.settings.has_pending():
+            if Confirm.ask("\n[bold red]Discard all pending changes?[/bold red]"):
+                self.settings.discard()
+                self.console.print("\n[yellow]Changes discarded[/yellow]")
+                input("\nPress Enter to return to launcher...")
+                self.running = False
+            else:
+                return
+        else:
+            self.running = False
+
+
+def run_settings_tool():
+    """Entry point for settings tool"""
+    tool = SettingsTool()
+    tool.run()