Upload 9 files

llm_config/__init__.py

@@ -0,0 +1,37 @@
+# llm_config/__init__.py
+"""
+LLM Configuration system with SOLID architecture.
+"""
+
+from .interfaces import (
+    APIKeyValidationResult,
+    LLMConfiguration,
+    IProviderValidator,
+    IConfigurationManager,
+    IProviderManager,
+    IUIStateManager,
+    INotificationService
+)
+
+from .validation import ProviderValidator
+from .configuration import ConfigurationManager
+from .provider_manager import EnhancedProviderManager
+from .ui_manager import UIStateManager
+from .notifications import GradioNotificationService
+from .llm_config_facade import LLMConfigurationFacade
+
+__all__ = [
+    'APIKeyValidationResult',
+    'LLMConfiguration',
+    'IProviderValidator',
+    'IConfigurationManager',
+    'IProviderManager',
+    'IUIStateManager',
+    'INotificationService',
+    'ProviderValidator',
+    'ConfigurationManager',
+    'EnhancedProviderManager',
+    'UIStateManager',
+    'GradioNotificationService',
+    'LLMConfigurationFacade'
+]

llm_config/configuration.py

@@ -0,0 +1,138 @@
+# llm_config/configuration.py
+"""
+Configuration management with persistence and validation.
+"""
+
+import json
+import os
+import logging
+from typing import Optional
+from .interfaces import IConfigurationManager, LLMConfiguration
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigurationManager(IConfigurationManager):
+    """Manages LLM configuration persistence and defaults."""
+    
+    def __init__(self, config_file: str = "llm_config.json"):
+        self.config_file = config_file
+        self.config_dir = os.path.dirname(os.path.abspath(config_file))
+        
+        # Ensure config directory exists
+        if self.config_dir and not os.path.exists(self.config_dir):
+            os.makedirs(self.config_dir, exist_ok=True)
+    
+    def save_configuration(self, config: LLMConfiguration) -> bool:
+        """Save configuration to persistent storage."""
+        try:
+            config_dict = {
+                'provider': config.provider,
+                'model': config.model,
+                'api_key': config.api_key,
+                'temperature': config.temperature,
+                'max_retries': config.max_retries,
+                'helper_model': config.helper_model,
+                'use_rag': config.use_rag,
+                'use_visual_fix_code': config.use_visual_fix_code,
+                'use_context_learning': config.use_context_learning,
+                'verbose': config.verbose,
+                'max_scene_concurrency': config.max_scene_concurrency
+            }
+            
+            with open(self.config_file, 'w') as f:
+                json.dump(config_dict, f, indent=2)
+            
+            logger.info(f"Configuration saved to {self.config_file}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to save configuration: {str(e)}")
+            return False
+    
+    def load_configuration(self) -> Optional[LLMConfiguration]:
+        """Load configuration from persistent storage."""
+        try:
+            if not os.path.exists(self.config_file):
+                logger.info(f"Configuration file {self.config_file} not found")
+                return None
+            
+            with open(self.config_file, 'r') as f:
+                config_dict = json.load(f)
+            
+            config = LLMConfiguration(
+                provider=config_dict.get('provider', 'OpenAI'),
+                model=config_dict.get('model', 'gpt-4'),
+                api_key=config_dict.get('api_key', ''),
+                temperature=config_dict.get('temperature', 0.7),
+                max_retries=config_dict.get('max_retries', 3),
+                helper_model=config_dict.get('helper_model'),
+                use_rag=config_dict.get('use_rag', True),
+                use_visual_fix_code=config_dict.get('use_visual_fix_code', False),
+                use_context_learning=config_dict.get('use_context_learning', True),
+                verbose=config_dict.get('verbose', False),
+                max_scene_concurrency=config_dict.get('max_scene_concurrency', 1)
+            )
+            
+            logger.info(f"Configuration loaded from {self.config_file}")
+            return config
+            
+        except Exception as e:
+            logger.error(f"Failed to load configuration: {str(e)}")
+            return None
+    
+    def get_default_configuration(self) -> LLMConfiguration:
+        """Get default configuration."""
+        return LLMConfiguration(
+            provider='OpenAI',
+            model='gpt-4',
+            api_key='',
+            temperature=0.7,
+            max_retries=3,
+            helper_model='gemini/gemini-2.5-flash-preview-04-17',
+            use_rag=True,
+            use_visual_fix_code=False,
+            use_context_learning=True,
+            verbose=False,
+            max_scene_concurrency=1
+        )
+    
+    def backup_configuration(self) -> bool:
+        """Create a backup of the current configuration."""
+        try:
+            if not os.path.exists(self.config_file):
+                return True  # Nothing to backup
+            
+            backup_file = f"{self.config_file}.backup"
+            
+            with open(self.config_file, 'r') as src:
+                with open(backup_file, 'w') as dst:
+                    dst.write(src.read())
+            
+            logger.info(f"Configuration backed up to {backup_file}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to backup configuration: {str(e)}")
+            return False
+    
+    def restore_configuration(self) -> Optional[LLMConfiguration]:
+        """Restore configuration from backup."""
+        try:
+            backup_file = f"{self.config_file}.backup"
+            
+            if not os.path.exists(backup_file):
+                logger.warning("No backup file found")
+                return None
+            
+            # Replace current config with backup
+            with open(backup_file, 'r') as src:
+                with open(self.config_file, 'w') as dst:
+                    dst.write(src.read())
+            
+            logger.info("Configuration restored from backup")
+            return self.load_configuration()
+            
+        except Exception as e:
+            logger.error(f"Failed to restore configuration: {str(e)}")
+            return None

llm_config/interfaces.py

@@ -0,0 +1,132 @@
+# llm_config/interfaces.py
+"""
+Abstract interfaces for LLM configuration system following SOLID principles.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Tuple
+from dataclasses import dataclass
+
+
+@dataclass
+class APIKeyValidationResult:
+    """Result of API key validation."""
+    is_valid: bool
+    error_message: Optional[str] = None
+    provider_name: Optional[str] = None
+
+
+@dataclass
+class LLMConfiguration:
+    """Complete LLM configuration."""
+    provider: str
+    model: str
+    api_key: str
+    temperature: float = 0.7
+    max_retries: int = 3
+    helper_model: Optional[str] = None
+    use_rag: bool = True
+    use_visual_fix_code: bool = False
+    use_context_learning: bool = True
+    verbose: bool = False
+    max_scene_concurrency: int = 1
+
+
+class IProviderValidator(ABC):
+    """Interface for validating provider configurations."""
+    
+    @abstractmethod
+    async def validate_api_key(self, provider: str, api_key: str) -> APIKeyValidationResult:
+        """Validate an API key for a specific provider."""
+        pass
+    
+    @abstractmethod
+    def get_supported_providers(self) -> List[str]:
+        """Get list of supported providers."""
+        pass
+
+
+class IConfigurationManager(ABC):
+    """Interface for managing LLM configurations."""
+    
+    @abstractmethod
+    def save_configuration(self, config: LLMConfiguration) -> bool:
+        """Save configuration to persistent storage."""
+        pass
+    
+    @abstractmethod
+    def load_configuration(self) -> Optional[LLMConfiguration]:
+        """Load configuration from persistent storage."""
+        pass
+    
+    @abstractmethod
+    def get_default_configuration(self) -> LLMConfiguration:
+        """Get default configuration."""
+        pass
+
+
+class IProviderManager(ABC):
+    """Interface for managing providers and models."""
+    
+    @abstractmethod
+    def get_providers(self) -> List[str]:
+        """Get available providers."""
+        pass
+    
+    @abstractmethod
+    def get_models(self, provider: str) -> List[str]:
+        """Get available models for a provider."""
+        pass
+    
+    @abstractmethod
+    def get_model_description(self, model: str) -> str:
+        """Get description for a model."""
+        pass
+    
+    @abstractmethod
+    def set_api_key(self, provider: str, api_key: str) -> None:
+        """Set API key for a provider."""
+        pass
+
+
+class IUIStateManager(ABC):
+    """Interface for managing UI state."""
+    
+    @abstractmethod
+    def update_provider_selection(self, provider: str) -> Dict:
+        """Update UI when provider is selected."""
+        pass
+    
+    @abstractmethod
+    def update_model_selection(self, model: str) -> Dict:
+        """Update UI when model is selected."""
+        pass
+    
+    @abstractmethod
+    def show_validation_feedback(self, result: APIKeyValidationResult) -> Dict:
+        """Show validation feedback to user."""
+        pass
+    
+    @abstractmethod
+    def reset_form(self) -> Dict:
+        """Reset form to default state."""
+        pass
+
+
+class INotificationService(ABC):
+    """Interface for user notifications."""
+    
+    @abstractmethod
+    def show_success(self, message: str) -> None:
+        """Show success notification."""
+        pass
+    
+    @abstractmethod
+    def show_error(self, message: str) -> None:
+        """Show error notification."""
+        pass
+    
+    @abstractmethod
+    def show_warning(self, message: str) -> None:
+        """Show warning notification."""
+        pass

llm_config/llm_config_facade.py

@@ -0,0 +1,230 @@
+# llm_config/llm_config_facade.py
+"""
+Facade pattern implementation for clean LLM configuration management.
+This provides a simple interface to the complex subsystem.
+"""
+
+import logging
+import asyncio
+from typing import Dict, List, Optional, Tuple, Any
+from .interfaces import (
+    LLMConfiguration, APIKeyValidationResult,
+    IProviderValidator, IConfigurationManager, IProviderManager, 
+    IUIStateManager, INotificationService
+)
+from .validation import ProviderValidator
+from .configuration import ConfigurationManager
+from .provider_manager import EnhancedProviderManager
+from .ui_manager import UIStateManager
+from .notifications import GradioNotificationService
+
+logger = logging.getLogger(__name__)
+
+
+class LLMConfigurationFacade:
+    """
+    Facade for LLM configuration system.
+    Provides a simple interface to manage providers, models, and API keys.
+    """
+    
+    def __init__(self, config_file: str = "llm_config.json"):
+        # Initialize all components
+        self.validator: IProviderValidator = ProviderValidator()
+        self.config_manager: IConfigurationManager = ConfigurationManager(config_file)
+        self.provider_manager: IProviderManager = EnhancedProviderManager()
+        self.notification_service: INotificationService = GradioNotificationService()
+        self.ui_manager: IUIStateManager = UIStateManager(
+            self.provider_manager, 
+            self.notification_service
+        )
+        
+        # Load saved configuration if available
+        self._load_saved_configuration()
+    
+    def _load_saved_configuration(self) -> None:
+        """Load previously saved configuration."""
+        try:
+            config = self.config_manager.load_configuration()
+            if config:
+                # Set API key in provider manager
+                if config.api_key:
+                    self.provider_manager.set_api_key(config.provider, config.api_key)
+                
+                logger.info("Loaded saved configuration")
+            else:
+                logger.info("No saved configuration found, using defaults")
+        except Exception as e:
+            logger.error(f"Failed to load saved configuration: {str(e)}")
+    
+    # Provider Management
+    def get_providers(self) -> List[str]:
+        """Get list of available providers."""
+        return self.provider_manager.get_providers()
+    
+    def get_models(self, provider: str) -> List[str]:
+        """Get models for a specific provider."""
+        return self.provider_manager.get_models(provider)
+    
+    def get_model_description(self, model: str) -> str:
+        """Get description for a model."""
+        return self.provider_manager.get_model_description(model)
+    
+    def get_provider_description(self, provider: str) -> str:
+        """Get description for a provider."""
+        return self.provider_manager.get_provider_description(provider)
+    
+    # API Key Management
+    def set_api_key(self, provider: str, api_key: str) -> bool:
+        """Set API key for a provider."""
+        try:
+            if not api_key or not api_key.strip():
+                self.notification_service.show_error("API key cannot be empty")
+                return False
+            
+            self.provider_manager.set_api_key(provider, api_key)
+            self.notification_service.show_success(f"API key set for {provider}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to set API key: {str(e)}")
+            self.notification_service.show_error(f"Failed to set API key: {str(e)}")
+            return False
+    
+    def validate_api_key(self, provider: str, api_key: str) -> APIKeyValidationResult:
+        """Validate an API key synchronously."""
+        return self.validator.validate_api_key_sync(provider, api_key)
+    
+    async def validate_api_key_async(self, provider: str, api_key: str) -> APIKeyValidationResult:
+        """Validate an API key asynchronously."""
+        return await self.validator.validate_api_key(provider, api_key)
+    
+    def has_api_key(self, provider: str) -> bool:
+        """Check if provider has an API key set."""
+        return self.provider_manager.has_api_key(provider)
+    
+    # Configuration Management
+    def save_configuration(self, config: LLMConfiguration) -> bool:
+        """Save complete configuration."""
+        try:
+            success = self.config_manager.save_configuration(config)
+            if success:
+                self.notification_service.show_success("Configuration saved successfully")
+            else:
+                self.notification_service.show_error("Failed to save configuration")
+            return success
+        except Exception as e:
+            logger.error(f"Failed to save configuration: {str(e)}")
+            self.notification_service.show_error(f"Failed to save configuration: {str(e)}")
+            return False
+    
+    def load_configuration(self) -> Optional[LLMConfiguration]:
+        """Load saved configuration."""
+        return self.config_manager.load_configuration()
+    
+    def get_default_configuration(self) -> LLMConfiguration:
+        """Get default configuration."""
+        return self.config_manager.get_default_configuration()
+    
+    def create_configuration(self, provider: str, model: str, api_key: str, **kwargs) -> LLMConfiguration:
+        """Create a new LLM configuration."""
+        return LLMConfiguration(
+            provider=provider,
+            model=model,
+            api_key=api_key,
+            temperature=kwargs.get('temperature', 0.7),
+            max_retries=kwargs.get('max_retries', 3),
+            helper_model=kwargs.get('helper_model'),
+            use_rag=kwargs.get('use_rag', True),
+            use_visual_fix_code=kwargs.get('use_visual_fix_code', False),
+            use_context_learning=kwargs.get('use_context_learning', True),
+            verbose=kwargs.get('verbose', False),
+            max_scene_concurrency=kwargs.get('max_scene_concurrency', 1)
+        )
+    
+    # UI State Management
+    def update_provider_selection(self, provider: str) -> Dict:
+        """Update UI when provider is selected."""
+        return self.ui_manager.update_provider_selection(provider)
+    
+    def update_model_selection(self, model: str) -> Dict:
+        """Update UI when model is selected."""
+        return self.ui_manager.update_model_selection(model)
+    
+    def show_validation_feedback(self, result: APIKeyValidationResult) -> Dict:
+        """Show validation feedback in UI."""
+        return self.ui_manager.show_validation_feedback(result)
+    
+    def reset_form(self) -> Dict:
+        """Reset form to default state."""
+        return self.ui_manager.reset_form()
+    
+    def get_current_ui_state(self) -> Dict[str, Any]:
+        """Get current UI state."""
+        return self.ui_manager.get_current_configuration()
+    
+    def validate_current_configuration(self) -> Tuple[bool, str]:
+        """Validate current configuration."""
+        return self.ui_manager.validate_current_configuration()
+    
+    # Utility Methods
+    def get_configuration_summary(self) -> Dict:
+        """Get summary of current configuration."""
+        return self.provider_manager.get_configuration_summary()
+    
+    def test_configuration(self, config: LLMConfiguration) -> Tuple[bool, str]:
+        """Test a configuration by validating API key."""
+        try:
+            result = self.validate_api_key(config.provider, config.api_key)
+            return result.is_valid, result.error_message or "Configuration test completed"
+        except Exception as e:
+            logger.error(f"Failed to test configuration: {str(e)}")
+            return False, f"Test failed: {str(e)}"
+    
+    def backup_configuration(self) -> bool:
+        """Create a backup of current configuration."""
+        return self.config_manager.backup_configuration()
+    
+    def restore_configuration(self) -> Optional[LLMConfiguration]:
+        """Restore configuration from backup."""
+        config = self.config_manager.restore_configuration()
+        if config:
+            self.notification_service.show_success("Configuration restored from backup")
+        else:
+            self.notification_service.show_error("Failed to restore configuration")
+        return config
+    
+    def clear_all_api_keys(self) -> None:
+        """Clear all stored API keys."""
+        try:
+            for provider in self.get_providers():
+                self.provider_manager.clear_api_key(provider)
+            self.notification_service.show_success("All API keys cleared")
+        except Exception as e:
+            logger.error(f"Failed to clear API keys: {str(e)}")
+            self.notification_service.show_error(f"Failed to clear API keys: {str(e)}")
+    
+    def get_last_notification(self) -> Optional[str]:
+        """Get last notification message."""
+        return self.notification_service.get_last_notification()
+    
+    def initialize_ui_defaults(self) -> Dict:
+        """Initialize UI with default values."""
+        try:
+            providers = self.get_providers()
+            if not providers:
+                return {}
+            
+            default_provider = providers[0]
+            models = self.get_models(default_provider)
+            default_model = models[0] if models else None
+            
+            return {
+                'provider_choices': providers,
+                'provider_value': default_provider,
+                'model_choices': models,
+                'model_value': default_model,
+                'model_description': self.get_model_description(default_model) if default_model else "",
+                'has_api_key': self.has_api_key(default_provider)
+            }
+        except Exception as e:
+            logger.error(f"Failed to initialize UI defaults: {str(e)}")
+            return {}

llm_config/notifications.py

@@ -0,0 +1,116 @@
+# llm_config/notifications.py
+"""
+Notification service for user feedback.
+"""
+
+import gradio as gr
+import logging
+from typing import Optional
+from .interfaces import INotificationService
+
+logger = logging.getLogger(__name__)
+
+
+class GradioNotificationService(INotificationService):
+    """Gradio-specific notification service for user feedback."""
+    
+    def __init__(self):
+        self.last_message: Optional[str] = None
+        self.last_type: Optional[str] = None
+    
+    def show_success(self, message: str) -> None:
+        """Show success notification."""
+        self.last_message = f"✅ {message}"
+        self.last_type = "success"
+        logger.info(f"Success notification: {message}")
+        # In a real Gradio app, you might want to trigger a UI update here
+    
+    def show_error(self, message: str) -> None:
+        """Show error notification."""
+        self.last_message = f"❌ {message}"
+        self.last_type = "error"
+        logger.error(f"Error notification: {message}")
+    
+    def show_warning(self, message: str) -> None:
+        """Show warning notification."""
+        self.last_message = f"⚠️ {message}"
+        self.last_type = "warning"
+        logger.warning(f"Warning notification: {message}")
+    
+    def show_info(self, message: str) -> None:
+        """Show info notification."""
+        self.last_message = f"ℹ️ {message}"
+        self.last_type = "info"
+        logger.info(f"Info notification: {message}")
+    
+    def get_last_notification(self) -> Optional[str]:
+        """Get the last notification message."""
+        return self.last_message
+    
+    def get_last_type(self) -> Optional[str]:
+        """Get the type of the last notification."""
+        return self.last_type
+    
+    def clear_notifications(self) -> None:
+        """Clear all notifications."""
+        self.last_message = None
+        self.last_type = None
+    
+    def create_gradio_update(self, message: str, notification_type: str = "info") -> dict:
+        """Create a Gradio update dict for displaying notifications."""
+        icons = {
+            "success": "✅",
+            "error": "❌",
+            "warning": "⚠️",
+            "info": "ℹ️"
+        }
+        
+        icon = icons.get(notification_type, "ℹ️")
+        formatted_message = f"{icon} {message}"
+        
+        # Store the notification
+        self.last_message = formatted_message
+        self.last_type = notification_type
+        
+        return gr.update(
+            value=formatted_message,
+            visible=True
+        )
+    
+    def format_validation_message(self, is_valid: bool, message: str) -> str:
+        """Format a validation message with appropriate styling."""
+        if is_valid:
+            return f"✅ {message}"
+        else:
+            return f"❌ {message}"
+    
+    def format_status_message(self, status: str, details: str = "") -> str:
+        """Format a status message."""
+        if details:
+            return f"📊 {status}: {details}"
+        else:
+            return f"📊 {status}"
+
+
+class ConsoleNotificationService(INotificationService):
+    """Console-based notification service for testing/development."""
+    
+    def show_success(self, message: str) -> None:
+        """Show success notification."""
+        print(f"✅ SUCCESS: {message}")
+        logger.info(f"Success: {message}")
+    
+    def show_error(self, message: str) -> None:
+        """Show error notification."""
+        print(f"❌ ERROR: {message}")
+        logger.error(f"Error: {message}")
+    
+    def show_warning(self, message: str) -> None:
+        """Show warning notification."""
+        print(f"⚠️ WARNING: {message}")
+        logger.warning(f"Warning: {message}")
+    
+    def show_info(self, message: str) -> None:
+        """Show info notification."""
+        print(f"ℹ️ INFO: {message}")
+        logger.info(f"Info: {message}")

llm_config/provider_manager.py

@@ -0,0 +1,185 @@
+# llm_config/provider_manager.py
+"""
+Enhanced provider manager with better separation of concerns.
+"""
+
+import os
+import logging
+from typing import Dict, List, Optional
+from .interfaces import IProviderManager
+
+logger = logging.getLogger(__name__)
+
+
+class EnhancedProviderManager(IProviderManager):
+    """Enhanced provider manager with better organization and extensibility."""
+    
+    def __init__(self):
+        self.providers_config = {
+            'OpenAI': {
+                'api_key_env': 'OPENAI_API_KEY',
+                'models': [
+                    'openai/gpt-4',
+                    'openai/gpt-4o',
+                    'openai/gpt-3.5-turbo'
+                ],
+                'display_name': 'OpenAI',
+                'description': 'Advanced AI models from OpenAI'
+            },
+            'Google Gemini': {
+                'api_key_env': 'GOOGLE_API_KEY',
+                'models': [
+                    'gemini/gemini-1.5-pro-002',
+                    'gemini/gemini-2.5-flash-preview-04-17'
+                ],
+                'display_name': 'Google Gemini',
+                'description': 'Google\'s powerful Gemini models'
+            },
+            'Anthropic': {
+                'api_key_env': 'ANTHROPIC_API_KEY',
+                'models': [
+                    'anthropic/claude-3-5-sonnet-20241022',
+                    'anthropic/claude-3-haiku'
+                ],
+                'display_name': 'Anthropic Claude',
+                'description': 'Anthropic\'s Claude family of models'
+            },
+            'OpenRouter': {
+                'api_key_env': 'OPENROUTER_API_KEY',
+                'models': [
+                    'openrouter/openai/gpt-4o',
+                    'openrouter/openai/gpt-4o-mini',
+                    'openrouter/anthropic/claude-3.5-sonnet',
+                    'openrouter/anthropic/claude-3-haiku',
+                    'openrouter/google/gemini-pro-1.5',
+                    'openrouter/deepseek/deepseek-chat',
+                    'openrouter/qwen/qwen-2.5-72b-instruct',
+                    'openrouter/meta-llama/llama-3.1-8b-instruct:free',
+                    'openrouter/microsoft/phi-3-mini-128k-instruct:free'
+                ],
+                'display_name': 'OpenRouter',
+                'description': 'Access multiple models through OpenRouter'
+            }
+        }
+        
+        self.model_descriptions = {
+            "openai/gpt-4": "🎯 Reliable and consistent, great for educational content",
+            "openai/gpt-4o": "🚀 Latest OpenAI model with enhanced capabilities",
+            "gemini/gemini-1.5-pro-002": "🧠 Advanced reasoning, excellent for complex mathematical concepts",
+            "gemini/gemini-2.5-flash-preview-04-17": "⚡ Fast processing, good for quick prototypes",
+            "anthropic/claude-3-5-sonnet-20241022": "📚 Excellent at detailed explanations and structured content",
+            "anthropic/claude-3-haiku": "💨 Fast and efficient for simpler tasks",
+            "openrouter/openai/gpt-4o": "🌐 GPT-4o via OpenRouter - Powerful and versatile",
+            "openrouter/openai/gpt-4o-mini": "🌐 GPT-4o Mini via OpenRouter - Fast and cost-effective",
+            "openrouter/anthropic/claude-3.5-sonnet": "🌐 Claude 3.5 Sonnet via OpenRouter - Excellent reasoning",
+            "openrouter/anthropic/claude-3-haiku": "🌐 Claude 3 Haiku via OpenRouter - Quick responses",
+            "openrouter/google/gemini-pro-1.5": "🌐 Gemini Pro 1.5 via OpenRouter - Google's advanced model",
+            "openrouter/deepseek/deepseek-chat": "🌐 DeepSeek Chat via OpenRouter - Advanced conversation",
+            "openrouter/qwen/qwen-2.5-72b-instruct": "🌐 Qwen 2.5 72B via OpenRouter - Alibaba's flagship model",
+            "openrouter/meta-llama/llama-3.1-8b-instruct:free": "🌐 Llama 3.1 8B via OpenRouter - Free open source model",
+            "openrouter/microsoft/phi-3-mini-128k-instruct:free": "🌐 Phi-3 Mini via OpenRouter - Free Microsoft model"
+        }
+        
+        self.api_keys: Dict[str, str] = {}
+        self.selected_provider: Optional[str] = None
+        self.selected_model: Optional[str] = None
+    
+    def get_providers(self) -> List[str]:
+        """Get available providers."""
+        return list(self.providers_config.keys())
+    
+    def get_models(self, provider: str) -> List[str]:
+        """Get available models for a provider."""
+        if provider not in self.providers_config:
+            logger.warning(f"Provider '{provider}' not found")
+            return []
+        
+        return self.providers_config[provider].get('models', [])
+    
+    def get_model_description(self, model: str) -> str:
+        """Get description for a model."""
+        return self.model_descriptions.get(model, "No description available")
+    
+    def get_provider_description(self, provider: str) -> str:
+        """Get description for a provider."""
+        if provider not in self.providers_config:
+            return "Unknown provider"
+        
+        return self.providers_config[provider].get('description', 'No description available')
+    
+    def get_provider_display_name(self, provider: str) -> str:
+        """Get display name for a provider."""
+        if provider not in self.providers_config:
+            return provider
+        
+        return self.providers_config[provider].get('display_name', provider)
+    
+    def set_api_key(self, provider: str, api_key: str) -> None:
+        """Set API key for a provider."""
+        if provider not in self.providers_config:
+            logger.error(f"Cannot set API key for unknown provider: {provider}")
+            return
+        
+        env_var = self.providers_config[provider]['api_key_env']
+        os.environ[env_var] = api_key
+        self.api_keys[provider] = api_key
+        
+        logger.info(f"API key set for provider: {provider}")
+    
+    def get_api_key(self, provider: str) -> Optional[str]:
+        """Get API key for a provider."""
+        if provider not in self.providers_config:
+            return None
+        
+        # First check our internal storage
+        if provider in self.api_keys:
+            return self.api_keys[provider]
+        
+        # Then check environment variable
+        env_var = self.providers_config[provider]['api_key_env']
+        return os.environ.get(env_var)
+    
+    def has_api_key(self, provider: str) -> bool:
+        """Check if provider has an API key set."""
+        api_key = self.get_api_key(provider)
+        return api_key is not None and api_key.strip() != ""
+    
+    def get_default_model(self, provider: str) -> Optional[str]:
+        """Get the default (first) model for a provider."""
+        models = self.get_models(provider)
+        return models[0] if models else None
+    
+    def is_valid_provider(self, provider: str) -> bool:
+        """Check if provider is valid."""
+        return provider in self.providers_config
+    
+    def is_valid_model(self, provider: str, model: str) -> bool:
+        """Check if model is valid for the given provider."""
+        return model in self.get_models(provider)
+    
+    def get_models_with_descriptions(self, provider: str) -> Dict[str, str]:
+        """Get models with their descriptions for a provider."""
+        models = self.get_models(provider)
+        return {model: self.get_model_description(model) for model in models}
+    
+    def clear_api_key(self, provider: str) -> None:
+        """Clear API key for a provider."""
+        if provider in self.api_keys:
+            del self.api_keys[provider]
+        
+        if provider in self.providers_config:
+            env_var = self.providers_config[provider]['api_key_env']
+            if env_var in os.environ:
+                del os.environ[env_var]
+        
+        logger.info(f"API key cleared for provider: {provider}")
+    
+    def get_configuration_summary(self) -> Dict:
+        """Get a summary of current configuration."""
+        return {
+            'total_providers': len(self.providers_config),
+            'providers_with_keys': sum(1 for p in self.providers_config if self.has_api_key(p)),
+            'selected_provider': self.selected_provider,
+            'selected_model': self.selected_model,
+            'available_models': sum(len(config['models']) for config in self.providers_config.values())
+        }

llm_config/ui_manager.py

@@ -0,0 +1,236 @@
+# llm_config/ui_manager.py
+"""
+UI state management with clean separation of concerns.
+"""
+
+import gradio as gr
+import logging
+from typing import Dict, List, Optional, Tuple, Any
+from .interfaces import IUIStateManager, APIKeyValidationResult, IProviderManager, INotificationService
+
+logger = logging.getLogger(__name__)
+
+
+class UIStateManager(IUIStateManager):
+    """Manages UI state changes and updates for LLM configuration."""
+    
+    def __init__(self, provider_manager: IProviderManager, notification_service: INotificationService):
+        self.provider_manager = provider_manager
+        self.notification_service = notification_service
+        self.current_provider: Optional[str] = None
+        self.current_model: Optional[str] = None
+        
+    def update_provider_selection(self, provider: str) -> Dict:
+        """Update UI when provider is selected."""
+        try:
+            if not self.provider_manager.is_valid_provider(provider):
+                logger.warning(f"Invalid provider selected: {provider}")
+                return self._create_error_update("Invalid provider selected")
+            
+            self.current_provider = provider
+            models = self.provider_manager.get_models(provider)
+            default_model = models[0] if models else None
+            self.current_model = default_model
+            
+            # Check if API key is already set
+            has_key = self.provider_manager.has_api_key(provider)
+            api_key_value = self.provider_manager.get_api_key(provider) if has_key else ""
+            
+            # Get provider description
+            provider_desc = self.provider_manager.get_provider_description(provider)
+            
+            return {
+                'model_dropdown': gr.update(
+                    choices=models,
+                    value=default_model,
+                    visible=len(models) > 0
+                ),
+                'api_key_input': gr.update(
+                    value=api_key_value,
+                    placeholder=f"Enter your {provider} API key"
+                ),
+                'provider_info': gr.update(
+                    value=f"**{provider}**: {provider_desc}",
+                    visible=True
+                ),
+                'model_description': gr.update(
+                    value=self.provider_manager.get_model_description(default_model) if default_model else "",
+                    visible=default_model is not None
+                ),
+                'validation_status': gr.update(
+                    value="✅ API key found" if has_key else "⚠️ API key required",
+                    visible=True
+                )
+            }
+            
+        except Exception as e:
+            logger.error(f"Error updating provider selection: {str(e)}")
+            return self._create_error_update(f"Error updating provider: {str(e)}")
+    
+    def update_model_selection(self, model: str) -> Dict:
+        """Update UI when model is selected."""
+        try:
+            if not model:
+                return {}
+            
+            self.current_model = model
+            model_description = self.provider_manager.get_model_description(model)
+            
+            return {
+                'model_description': gr.update(
+                    value=model_description,
+                    visible=True
+                )
+            }
+            
+        except Exception as e:
+            logger.error(f"Error updating model selection: {str(e)}")
+            return self._create_error_update(f"Error updating model: {str(e)}")
+    
+    def show_validation_feedback(self, result: APIKeyValidationResult) -> Dict:
+        """Show validation feedback to user."""
+        try:
+            if result.is_valid:
+                status_text = "✅ API key is valid"
+                status_color = "green"
+                if result.error_message:
+                    status_text += f" ({result.error_message})"
+            else:
+                status_text = f"❌ {result.error_message or 'Invalid API key'}"
+                status_color = "red"
+            
+            return {
+                'validation_status': gr.update(
+                    value=status_text,
+                    visible=True
+                ),
+                'api_key_feedback': gr.update(
+                    value=status_text,
+                    visible=True
+                )
+            }
+            
+        except Exception as e:
+            logger.error(f"Error showing validation feedback: {str(e)}")
+            return self._create_error_update(f"Error showing feedback: {str(e)}")
+    
+    def reset_form(self) -> Dict:
+        """Reset form to default state."""
+        try:
+            providers = self.provider_manager.get_providers()
+            default_provider = providers[0] if providers else None
+            
+            if default_provider:
+                models = self.provider_manager.get_models(default_provider)
+                default_model = models[0] if models else None
+            else:
+                models = []
+                default_model = None
+            
+            self.current_provider = default_provider
+            self.current_model = default_model
+            
+            return {
+                'provider_dropdown': gr.update(
+                    value=default_provider,
+                    choices=providers
+                ),
+                'model_dropdown': gr.update(
+                    value=default_model,
+                    choices=models
+                ),
+                'api_key_input': gr.update(
+                    value="",
+                    placeholder="Enter your API key"
+                ),
+                'temperature_slider': gr.update(value=0.7),
+                'max_retries_slider': gr.update(value=3),
+                'max_scene_concurrency_slider': gr.update(value=1),
+                'use_rag_checkbox': gr.update(value=True),
+                'use_visual_fix_code_checkbox': gr.update(value=False),
+                'use_context_learning_checkbox': gr.update(value=True),
+                'verbose_checkbox': gr.update(value=False),
+                'validation_status': gr.update(
+                    value="⚠️ Configuration reset",
+                    visible=True
+                ),
+                'model_description': gr.update(
+                    value=self.provider_manager.get_model_description(default_model) if default_model else "",
+                    visible=default_model is not None
+                )
+            }
+            
+        except Exception as e:
+            logger.error(f"Error resetting form: {str(e)}")
+            return self._create_error_update(f"Error resetting form: {str(e)}")
+    
+    def update_helper_model_selection(self, helper_model: str) -> Dict:
+        """Update UI when helper model is selected."""
+        try:
+            if not helper_model:
+                return {}
+            
+            helper_description = self.provider_manager.get_model_description(helper_model)
+            
+            return {
+                'helper_model_description': gr.update(
+                    value=f"Helper: {helper_description}",
+                    visible=True
+                )
+            }
+            
+        except Exception as e:
+            logger.error(f"Error updating helper model selection: {str(e)}")
+            return {}
+    
+    def get_current_configuration(self) -> Dict[str, Any]:
+        """Get current UI configuration state."""
+        return {
+            'provider': self.current_provider,
+            'model': self.current_model,
+            'has_api_key': self.provider_manager.has_api_key(self.current_provider) if self.current_provider else False
+        }
+    
+    def validate_current_configuration(self) -> Tuple[bool, str]:
+        """Validate current configuration."""
+        if not self.current_provider:
+            return False, "No provider selected"
+        
+        if not self.current_model:
+            return False, "No model selected"
+        
+        if not self.provider_manager.has_api_key(self.current_provider):
+            return False, "API key not set for selected provider"
+        
+        return True, "Configuration is valid"
+    
+    def _create_error_update(self, error_message: str) -> Dict:
+        """Create an error update for UI components."""
+        return {
+            'validation_status': gr.update(
+                value=f"❌ {error_message}",
+                visible=True
+            )
+        }
+    
+    def show_configuration_summary(self) -> Dict:
+        """Show a summary of current configuration."""
+        try:
+            config = self.get_current_configuration()
+            summary_text = f"""
+            **Current Configuration:**
+            - Provider: {config['provider'] or 'None'}
+            - Model: {config['model'] or 'None'}
+            - API Key: {'✅ Set' if config['has_api_key'] else '❌ Not set'}
+            """
+            
+            return {
+                'configuration_summary': gr.update(
+                    value=summary_text,
+                    visible=True
+                )
+            }
+            
+        except Exception as e:
+            logger.error(f"Error showing configuration summary: {str(e)}")
+            return {}

llm_config/validation.py

@@ -0,0 +1,151 @@
+# llm_config/validation.py
+"""
+Provider validation implementation with proper error handling and async support.
+"""
+
+import asyncio
+import aiohttp
+import os
+import logging
+from typing import Dict, List, Optional
+from .interfaces import IProviderValidator, APIKeyValidationResult
+
+logger = logging.getLogger(__name__)
+
+
+class ProviderValidator(IProviderValidator):
+    """Validates API keys and provider configurations."""
+    
+    def __init__(self):
+        self.validation_endpoints = {
+            'OpenAI': {
+                'url': 'https://api.openai.com/v1/models',
+                'headers_fn': lambda key: {'Authorization': f'Bearer {key}'}
+            },
+            'Google Gemini': {
+                'url': 'https://generativelanguage.googleapis.com/v1beta/models',
+                'headers_fn': lambda key: {},
+                'params_fn': lambda key: {'key': key}
+            },
+            'Anthropic': {
+                'url': 'https://api.anthropic.com/v1/messages',
+                'headers_fn': lambda key: {
+                    'x-api-key': key,
+                    'anthropic-version': '2023-06-01',
+                    'content-type': 'application/json'
+                },
+                'method': 'POST',
+                'data': {
+                    'model': 'claude-3-haiku-20240307',
+                    'max_tokens': 1,
+                    'messages': [{'role': 'user', 'content': 'test'}]
+                }
+            },
+            'OpenRouter': {
+                'url': 'https://openrouter.ai/api/v1/models',
+                'headers_fn': lambda key: {'Authorization': f'Bearer {key}'}
+            }
+        }
+        
+        # Timeout for validation requests
+        self.timeout = 10.0
+    
+    async def validate_api_key(self, provider: str, api_key: str) -> APIKeyValidationResult:
+        """Validate an API key for a specific provider."""
+        if not api_key or not api_key.strip():
+            return APIKeyValidationResult(
+                is_valid=False,
+                error_message="API key cannot be empty",
+                provider_name=provider
+            )
+        
+        if provider not in self.validation_endpoints:
+            return APIKeyValidationResult(
+                is_valid=False,
+                error_message=f"Provider '{provider}' is not supported",
+                provider_name=provider
+            )
+        
+        try:
+            endpoint_config = self.validation_endpoints[provider]
+            url = endpoint_config['url']
+            headers = endpoint_config['headers_fn'](api_key)
+            method = endpoint_config.get('method', 'GET')
+            
+            timeout = aiohttp.ClientTimeout(total=self.timeout)
+            
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                kwargs = {'headers': headers}
+                
+                # Add query parameters if needed
+                if 'params_fn' in endpoint_config:
+                    kwargs['params'] = endpoint_config['params_fn'](api_key)
+                
+                # Add data for POST requests
+                if method == 'POST' and 'data' in endpoint_config:
+                    kwargs['json'] = endpoint_config['data']
+                
+                async with session.request(method, url, **kwargs) as response:
+                    # Consider 200-299 as valid, and some specific error codes as invalid API key
+                    if response.status < 300:
+                        logger.info(f"API key validation successful for {provider}")
+                        return APIKeyValidationResult(
+                            is_valid=True,
+                            provider_name=provider
+                        )
+                    elif response.status in [401, 403]:
+                        logger.warning(f"Invalid API key for {provider}: {response.status}")
+                        return APIKeyValidationResult(
+                            is_valid=False,
+                            error_message="Invalid API key - please check your credentials",
+                            provider_name=provider
+                        )
+                    else:
+                        logger.warning(f"Unexpected response for {provider}: {response.status}")
+                        # For other errors, we'll assume the key might be valid but service unavailable
+                        return APIKeyValidationResult(
+                            is_valid=True,  # Assume valid if we can't determine
+                            error_message=f"Could not verify API key (service returned {response.status})",
+                            provider_name=provider
+                        )
+                        
+        except asyncio.TimeoutError:
+            logger.warning(f"Timeout validating API key for {provider}")
+            return APIKeyValidationResult(
+                is_valid=True,  # Assume valid if timeout
+                error_message="Validation timed out - key might be valid",
+                provider_name=provider
+            )
+        except Exception as e:
+            logger.error(f"Error validating API key for {provider}: {str(e)}")
+            return APIKeyValidationResult(
+                is_valid=False,
+                error_message=f"Validation error: {str(e)}",
+                provider_name=provider
+            )
+    
+    def get_supported_providers(self) -> List[str]:
+        """Get list of supported providers."""
+        return list(self.validation_endpoints.keys())
+    
+    def validate_api_key_sync(self, provider: str, api_key: str) -> APIKeyValidationResult:
+        """Synchronous wrapper for API key validation."""
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # If we're already in an event loop, create a new thread
+                import concurrent.futures
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(
+                        lambda: asyncio.run(self.validate_api_key(provider, api_key))
+                    )
+                    return future.result(timeout=self.timeout + 5)
+            else:
+                return loop.run_until_complete(self.validate_api_key(provider, api_key))
+        except Exception as e:
+            logger.error(f"Error in sync validation: {str(e)}")
+            return APIKeyValidationResult(
+                is_valid=False,
+                error_message=f"Validation failed: {str(e)}",
+                provider_name=provider
+            )

provider.py

@@ -0,0 +1,71 @@
+# provider.py
+"""
+Provider management for Theory2Manim Gradio app.
+Allows user to select provider, enter API key, and select model.
+"""
+
+import os
+from typing import Dict, List, Optional
+
+class ProviderManager:
+    def __init__(self):
+        # Example provider configs; extend as needed
+        self.providers = {
+            'OpenAI': {
+                'api_key_env': 'OPENAI_API_KEY',
+                'models': [
+                    'gpt-4.1', 'gpt-4o', 'gpt-3.5-turbo'
+                ]
+            },
+            'Google Gemini': {
+                'api_key_env': 'GOOGLE_API_KEY',
+                'models': [
+                    'gemini-1.5-pro-002', 'gemini-2.5-flash-preview-04-17'
+                ]
+            },
+            'Anthropic': {
+                'api_key_env': 'ANTHROPIC_API_KEY',
+                'models': [
+                    'claude-3-5-sonnet-20241022', 'claude-3-haiku'
+                ]
+            },
+            'OpenRouter': {
+                'api_key_env': 'OPENROUTER_API_KEY',
+                'models': [
+                    'openai/gpt-4o', 'openai/gpt-4o-mini', 'anthropic/claude-3.5-sonnet',
+                    'anthropic/claude-3-haiku', 'google/gemini-pro-1.5', 'deepseek/deepseek-chat',
+                    'qwen/qwen-2.5-72b-instruct', 'meta-llama/llama-3.1-8b-instruct:free',
+                    'microsoft/phi-3-mini-128k-instruct:free'
+                ]
+            }
+        }
+        self.selected_provider = None
+        self.api_keys = {}
+
+    def get_providers(self) -> List[str]:
+        return list(self.providers.keys())
+
+    def get_models(self, provider: str) -> List[str]:
+        return self.providers.get(provider, {}).get('models', [])
+
+    def set_api_key(self, provider: str, api_key: str):
+        env_var = self.providers[provider]['api_key_env']
+        os.environ[env_var] = api_key
+        self.api_keys[provider] = api_key
+
+    def get_api_key(self, provider: str) -> Optional[str]:
+        env_var = self.providers[provider]['api_key_env']
+        return os.environ.get(env_var)
+
+    def get_selected_provider(self) -> Optional[str]:
+        return self.selected_provider
+
+    def set_selected_provider(self, provider: str):
+        self.selected_provider = provider
+
+    def get_selected_model(self) -> Optional[str]:
+        if self.selected_provider:
+            return self.get_models(self.selected_provider)[0]
+        return None
+
+provider_manager = ProviderManager()