feat: add Open WebUI Files API integration

Upload images to Open WebUI's file storage for better accessibility.
When OPENWEBUI_API_URL and OPENWEBUI_API_KEY are configured,
images are automatically uploaded to Open WebUI and URLs point there.

This solves the issue where IMAGE_BASE_URL needs to be accessible
from the browser - now images are served by Open WebUI itself.

Author: danielcopper

app/core/config.py

@@ -52,6 +52,10 @@ class Settings(BaseSettings):
     FILTER_IMAGE_MODELS: bool = True  # Only return image generation models from LiteLLM
     DEFAULT_MODEL: str | None = None  # Default model for image generation
 
+    # Open WebUI Integration (optional)
+    OPENWEBUI_API_URL: str | None = None  # e.g. https://chat.mydomain.com
+    OPENWEBUI_API_KEY: str | None = None  # API key from Open WebUI settings
+
     # Server Configuration
     HOST: str = "0.0.0.0"
     PORT: int = 8000
@@ -71,5 +75,10 @@ def gemini_available(self) -> bool:
         """Check if Gemini direct access is available."""
         return bool(self.GEMINI_API_KEY)
 
+    @property
+    def openwebui_available(self) -> bool:
+        """Check if Open WebUI integration is configured."""
+        return bool(self.OPENWEBUI_API_URL and self.OPENWEBUI_API_KEY)
+
 
 settings = Settings()

app/services/openwebui_service.py

@@ -0,0 +1,86 @@
+import logging
+
+import httpx
+
+from app.core.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class OpenWebUIService:
+    """
+    Service for uploading images to Open WebUI's Files API.
+
+    When configured, images are uploaded to Open WebUI's storage,
+    making them accessible regardless of network topology.
+    """
+
+    def __init__(self):
+        if not settings.OPENWEBUI_API_URL:
+            raise ValueError("OPENWEBUI_API_URL not configured")
+        if not settings.OPENWEBUI_API_KEY:
+            raise ValueError("OPENWEBUI_API_KEY not configured")
+
+        self.base_url = settings.OPENWEBUI_API_URL.rstrip("/")
+        self.api_key = settings.OPENWEBUI_API_KEY
+
+    async def upload_image(self, image_data: bytes, filename: str) -> str:
+        """
+        Upload image to Open WebUI Files API.
+
+        Args:
+            image_data: Image bytes
+            filename: Filename with extension (e.g., "image.png")
+
+        Returns:
+            URL to access the uploaded file
+        """
+        url = f"{self.base_url}/api/v1/files/"
+
+        # Determine content type from filename
+        ext = filename.rsplit(".", 1)[-1].lower() if "." in filename else "png"
+        content_types = {
+            "png": "image/png",
+            "jpg": "image/jpeg",
+            "jpeg": "image/jpeg",
+            "webp": "image/webp",
+            "gif": "image/gif",
+        }
+        content_type = content_types.get(ext, "image/png")
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        # Multipart file upload
+        files = {
+            "file": (filename, image_data, content_type),
+        }
+
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.post(url, headers=headers, files=files)
+            response.raise_for_status()
+
+            data = response.json()
+            file_id = data.get("id")
+
+            if not file_id:
+                raise ValueError(f"No file ID in response: {data}")
+
+            # Return URL to access the file
+            file_url = f"{self.base_url}/api/v1/files/{file_id}/content"
+            logger.info(f"Uploaded image to Open WebUI: {file_url}")
+
+            return file_url
+
+
+# Singleton instance (lazy initialization)
+_openwebui_service: OpenWebUIService | None = None
+
+
+def get_openwebui_service() -> OpenWebUIService:
+    """Get Open WebUI service instance."""
+    global _openwebui_service
+    if _openwebui_service is None:
+        _openwebui_service = OpenWebUIService()
+    return _openwebui_service

app/services/storage_service.py

@@ -1,3 +1,4 @@
+import logging
 import uuid
 from pathlib import Path
 
@@ -6,10 +7,13 @@
 
 from app.core.config import settings
 
+logger = logging.getLogger(__name__)
+
 
 class StorageService:
     """
     Handles local file storage for generated images.
+    Optionally uploads to Open WebUI for better accessibility.
     """
 
     def __init__(self):
@@ -18,24 +22,36 @@ def __init__(self):
 
     async def save_image(self, image_data: bytes, extension: str = "png") -> str:
         """
-        Save image bytes to local storage and return public URL.
+        Save image bytes to local storage and optionally upload to Open WebUI.
 
         Args:
             image_data: Raw image bytes
             extension: File extension (png, jpg, webp)
 
         Returns:
-            Public URL to access the image
+            Public URL to access the image (Open WebUI URL if configured, else local)
         """
         filename = f"{uuid.uuid4()}.{extension}"
         filepath = self.storage_path / filename
 
+        # Always save locally first
         async with aiofiles.open(filepath, "wb") as f:
             await f.write(image_data)
 
-        relative_url = f"/images/{filename}"
+        local_url = f"{settings.IMAGE_BASE_URL.rstrip('/')}/images/{filename}"
+
+        # Upload to Open WebUI if configured
+        if settings.openwebui_available:
+            try:
+                from app.services.openwebui_service import get_openwebui_service
+
+                webui_service = get_openwebui_service()
+                webui_url = await webui_service.upload_image(image_data, filename)
+                return webui_url
+            except Exception as e:
+                logger.warning(f"Open WebUI upload failed, using local URL: {e}")
 
-        return f"{settings.IMAGE_BASE_URL.rstrip('/')}{relative_url}"
+        return local_url
 
     async def get_image(self, url: str) -> bytes:
         """