Update UI layout and provider normalization

Author: successbyfailure

backend/__init__.py

@@ -1,3 +1,3 @@
 """Backend sync worker service."""
 
-__version__ = "0.6.1"
+__version__ = "0.6.20"

backend/provider_sync.py

@@ -3,18 +3,48 @@
 from datetime import UTC, datetime
 
 from shared.sources import fetch_source_models
-from shared.crud import upsert_model, get_models_by_provider
+from shared.crud import upsert_model, get_models_by_provider, delete_model
 from shared.models import ModelMetadata, SourceEndpoint, SourceType
+from shared.db_models import Model
 from backend.litellm_client import reconcile_litellm_models
 
 logger = logging.getLogger(__name__)
 
 
+def _has_user_overrides(model: Model) -> bool:
+    """
+    Check if a model has any user-applied configuration overrides.
+
+    Returns True if the model has:
+    - User-modified parameters (user_params)
+    - User-added tags (user_tags)
+    - Custom pricing override (pricing_override)
+    - Model-level Ollama mode override (ollama_mode)
+    - User modified flag
+    """
+    return (
+        model.user_modified
+        or model.user_params is not None
+        or model.user_tags is not None
+        or model.pricing_override is not None
+        or model.ollama_mode is not None
+    )
+
+
 async def sync_provider(session, config, provider, push_to_litellm: bool = True) -> dict:
     """
     Sync a single provider: fetch models, update database, push to LiteLLM.
 
-    Returns dict with stats: {"added": int, "updated": int, "orphaned": int}
+    Returns dict with stats: {"added": int, "updated": int, "orphaned": int, "deleted": int}
+
+    When a model disappears from the provider:
+    - If model has NO user overrides (user_params, user_tags, pricing_override, etc.)
+      → deleted immediately
+    - If model HAS user overrides → marked as orphaned (so overrides can be reapplied
+      if model returns)
+
+    Orphaned models are NOT synced to LiteLLM and will be removed from LiteLLM during
+    reconciliation.
     """
     stats = {"added": 0, "updated": 0, "orphaned": 0}
 
@@ -80,14 +110,24 @@ async def sync_provider(session, config, provider, push_to_litellm: bool = True)
             else:
                 stats["updated"] += 1
 
-        # Mark orphaned models (models that no longer exist in provider)
+        # Handle models that no longer exist in provider
         all_models = await get_models_by_provider(session, provider.id)
+        stats["deleted"] = 0  # Track deleted models
+
         for model in all_models:
             if model.model_id not in active_model_ids and not model.is_orphaned:
-                model.is_orphaned = True
-                model.orphaned_at = datetime.now(UTC)
-                stats["orphaned"] += 1
-                logger.info("Model %s marked as orphaned", model.model_id)
+                # Model disappeared from provider
+                if _has_user_overrides(model):
+                    # Has user overrides - keep as orphaned so overrides can be reapplied if model returns
+                    model.is_orphaned = True
+                    model.orphaned_at = datetime.now(UTC)
+                    stats["orphaned"] += 1
+                    logger.info("Model %s marked as orphaned (has user overrides)", model.model_id)
+                else:
+                    # No user overrides - delete immediately
+                    await delete_model(session, model)
+                    stats["deleted"] += 1
+                    logger.info("Model %s deleted (no user overrides)", model.model_id)
 
         # Reconcile with LiteLLM if configured and requested
         if push_to_litellm and config.litellm_base_url:

backend/sync_worker.py

@@ -43,6 +43,7 @@ def __init__(self):
         self.running = True
         self.engine = None
         self.session_maker = None
+        self.last_sync_times: dict[int, datetime] = {}  # provider_id -> last sync time
 
     async def initialize(self):
         """Initialize database connection."""
@@ -70,37 +71,61 @@ async def run(self):
 
         logger.info("✅ Sync worker ready")
 
+        # Check interval: check every 30 seconds which providers need syncing
+        CHECK_INTERVAL = 30
+
         while self.running:
             try:
-                # Grab config and provider IDs in a short-lived session
+                # Grab config and providers in a short-lived session
                 async with self.session_maker() as session:
                     config_obj = await get_config(session)
-                    provider_ids = [p.id for p in await get_all_providers(session)]
+                    all_providers = await get_all_providers(session)
+
+                    # Create provider snapshots with intervals
+                    providers_info = []
+                    for p in all_providers:
+                        # Use provider-specific interval, or global if not set
+                        interval = p.sync_interval_seconds if p.sync_interval_seconds else config_obj.sync_interval_seconds
+                        providers_info.append({
+                            "id": p.id,
+                            "name": p.name,
+                            "sync_enabled": p.sync_enabled,
+                            "sync_interval_seconds": interval,
+                        })
 
                 # Snapshot config values to avoid session-bound objects
-                sync_interval = config_obj.sync_interval_seconds
                 config_snapshot = {
                     "litellm_base_url": config_obj.litellm_base_url,
                     "litellm_api_key": config_obj.litellm_api_key,
                     "default_pricing_profile": config_obj.default_pricing_profile,
                     "default_pricing_override": config_obj.default_pricing_override_dict,
                 }
 
-                # Check if sync is enabled
-                if sync_interval == 0:
-                    logger.debug("Sync disabled (interval=0), sleeping for 60s...")
-                    await asyncio.sleep(60)
-                    continue
+                # Check which providers need syncing
+                now = datetime.now(UTC)
+                providers_to_sync = []
+                for provider_info in providers_info:
+                    if not provider_info["sync_enabled"]:
+                        continue
 
-                logger.info("⏰ Starting sync cycle (interval: %ds)", sync_interval)
+                    interval = provider_info["sync_interval_seconds"]
+                    if interval == 0:
+                        continue  # Sync disabled for this provider
 
-                # Sync all enabled providers
-                await self.sync_all_providers(provider_ids, config_snapshot)
+                    provider_id = provider_info["id"]
+                    last_sync = self.last_sync_times.get(provider_id)
 
-                logger.info("✓ Sync cycle complete, waiting %ds for next cycle", sync_interval)
+                    # Sync if never synced or interval has passed
+                    if last_sync is None or (now - last_sync).total_seconds() >= interval:
+                        providers_to_sync.append(provider_id)
 
-                # Wait for next interval
-                await asyncio.sleep(sync_interval)
+                # Sync providers that are due
+                if providers_to_sync:
+                    logger.info("⏰ Syncing %d provider(s)...", len(providers_to_sync))
+                    await self.sync_providers(providers_to_sync, config_snapshot)
+
+                # Wait before next check
+                await asyncio.sleep(CHECK_INTERVAL)
 
             except Exception as e:
                 logger.exception("❌ Error in sync loop: %s", e)
@@ -112,8 +137,8 @@ async def run(self):
         if self.engine:
             await self.engine.dispose()
 
-    async def sync_all_providers(self, provider_ids: list[int], config_snapshot: dict[str, str | None]):
-        """Sync models from all enabled providers."""
+    async def sync_providers(self, provider_ids: list[int], config_snapshot: dict[str, str | None]):
+        """Sync models from specified providers and update their last sync times."""
         if not provider_ids:
             logger.info("No providers configured")
             return
@@ -158,6 +183,8 @@ async def sync_all_providers(self, provider_ids: list[int], config_snapshot: dic
                                 stats.get("updated", 0) if stats else 0,
                                 stats.get("deleted", 0) if stats else 0
                             )
+                            # Mark successful sync time
+                            self.last_sync_times[provider_id] = datetime.now(UTC)
                         else:
                             logger.debug("LiteLLM not configured, skipping push for %s", provider.name)
                         continue
@@ -177,6 +204,9 @@ async def sync_all_providers(self, provider_ids: list[int], config_snapshot: dic
                         stats.get("orphaned", 0)
                     )
 
+                    # Mark successful sync time
+                    self.last_sync_times[provider_id] = datetime.now(UTC)
+
                 except Exception as e:
                     logger.error("❌ Failed to sync provider %s: %s", provider.name, e, exc_info=True)
                     await session.rollback()

frontend/__init__.py

@@ -1,3 +1,3 @@
 """Frontend API and UI service."""
 
-__version__ = "0.6.1"
+__version__ = "0.6.20"