CVE-2026-45666

@@ -2,125 +2,107 @@
 
 
 class MESSAGES(str, Enum):
-    DEFAULT = lambda msg="": f"{msg if msg else ''}"
-    MODEL_ADDED = lambda model="": f"The model '{model}' has been added successfully."
-    MODEL_DELETED = (
-        lambda model="": f"The model '{model}' has been deleted successfully."
-    )
+    DEFAULT = lambda msg='': f'{msg if msg else ""}'
+    MODEL_ADDED = lambda model='': f"The model '{model}' has been added successfully."
+    MODEL_DELETED = lambda model='': f"The model '{model}' has been deleted successfully."
 
 
 class WEBHOOK_MESSAGES(str, Enum):
-    DEFAULT = lambda msg="": f"{msg if msg else ''}"
-    USER_SIGNUP = lambda username="": (
-        f"New user signed up: {username}" if username else "New user signed up"
-    )
+    DEFAULT = lambda msg='': f'{msg if msg else ""}'
+    USER_SIGNUP = lambda username='': (f'New user signed up: {username}' if username else 'New user signed up')
 
 
 class ERROR_MESSAGES(str, Enum):
     def __str__(self) -> str:
         return super().__str__()
 
-    DEFAULT = (
-        lambda err="": f'{"Something went wrong :/" if err == "" else "[ERROR: " + str(err) + "]"}'
-    )
-    ENV_VAR_NOT_FOUND = "Required environment variable not found. Terminating now."
-    CREATE_USER_ERROR = "Oops! Something went wrong while creating your account. Please try again later. If the issue persists, contact support for assistance."
-    DELETE_USER_ERROR = "Oops! Something went wrong. We encountered an issue while trying to delete the user. Please give it another shot."
-    EMAIL_MISMATCH = "Uh-oh! This email does not match the email your provider is registered with. Please check your email and try again."
-    EMAIL_TAKEN = "Uh-oh! This email is already registered. Sign in with your existing account or choose another email to start anew."
-    USERNAME_TAKEN = (
-        "Uh-oh! This username is already registered. Please choose another username."
+    DEFAULT = lambda err='': f'{"Something went wrong :/" if err == "" else "[ERROR: " + str(err) + "]"}'
+    ENV_VAR_NOT_FOUND = 'Required environment variable not found. Terminating now.'
+    CREATE_USER_ERROR = 'Oops! Something went wrong while creating your account. Please try again later. If the issue persists, contact support for assistance.'
+    DELETE_USER_ERROR = 'Oops! Something went wrong. We encountered an issue while trying to delete the user. Please give it another shot.'
+    EMAIL_MISMATCH = 'Uh-oh! This email does not match the email your provider is registered with. Please check your email and try again.'
+    EMAIL_TAKEN = 'Uh-oh! This email is already registered. Sign in with your existing account or choose another email to start anew.'
+    USERNAME_TAKEN = 'Uh-oh! This username is already registered. Please choose another username.'
+    PASSWORD_TOO_LONG = (
+        'Uh-oh! The password you entered is too long. Please make sure your password is less than 72 bytes long.'
     )
-    PASSWORD_TOO_LONG = "Uh-oh! The password you entered is too long. Please make sure your password is less than 72 bytes long."
-    COMMAND_TAKEN = "Uh-oh! This command is already registered. Please choose another command string."
-    FILE_EXISTS = "Uh-oh! This file is already registered. Please choose another file."
+    COMMAND_TAKEN = 'Uh-oh! This command is already registered. Please choose another command string.'
+    FILE_EXISTS = 'Uh-oh! This file is already registered. Please choose another file.'
 
-    ID_TAKEN = "Uh-oh! This id is already registered. Please choose another id string."
-    MODEL_ID_TAKEN = "Uh-oh! This model id is already registered. Please choose another model id string."
-    NAME_TAG_TAKEN = "Uh-oh! This name tag is already registered. Please choose another name tag string."
-    MODEL_ID_TOO_LONG = "The model id is too long. Please make sure your model id is less than 256 characters long."
+    ID_TAKEN = 'Uh-oh! This id is already registered. Please choose another id string.'
+    MODEL_ID_TAKEN = 'Uh-oh! This model id is already registered. Please choose another model id string.'
+    NAME_TAG_TAKEN = 'Uh-oh! This name tag is already registered. Please choose another name tag string.'
+    MODEL_ID_TOO_LONG = 'The model id is too long. Please make sure your model id is less than 256 characters long.'
 
-    INVALID_TOKEN = (
-        "Your session has expired or the token is invalid. Please sign in again."
-    )
-    INVALID_CRED = "The email or password provided is incorrect. Please check for typos and try logging in again."
+    INVALID_TOKEN = 'Your session has expired or the token is invalid. Please sign in again.'
+    INVALID_CRED = 'The email or password provided is incorrect. Please check for typos and try logging in again.'
     INVALID_EMAIL_FORMAT = "The email format you entered is invalid. Please double-check and make sure you're using a valid email address (e.g., yourname@example.com)."
-    INCORRECT_PASSWORD = (
-        "The password provided is incorrect. Please check for typos and try again."
+    INCORRECT_PASSWORD = 'The password provided is incorrect. Please check for typos and try again.'
+    INVALID_TRUSTED_HEADER = (
+        'Your provider has not provided a trusted header. Please contact your administrator for assistance.'
     )
-    INVALID_TRUSTED_HEADER = "Your provider has not provided a trusted header. Please contact your administrator for assistance."
 
     EXISTING_USERS = "You can't turn off authentication because there are existing users. If you want to disable WEBUI_AUTH, make sure your web interface doesn't have any existing users and is a fresh installation."
 
-    UNAUTHORIZED = "401 Unauthorized"
-    ACCESS_PROHIBITED = "You do not have permission to access this resource. Please contact your administrator for assistance."
-    ACTION_PROHIBITED = (
-        "The requested action has been restricted as a security measure."
+    UNAUTHORIZED = '401 Unauthorized'
+    ACCESS_PROHIBITED = (
+        'You do not have permission to access this resource. Please contact your administrator for assistance.'
     )
+    ACTION_PROHIBITED = 'The requested action has been restricted as a security measure.'
 
-    FILE_NOT_SENT = "FILE_NOT_SENT"
+    FILE_NOT_SENT = 'FILE_NOT_SENT'
     FILE_NOT_SUPPORTED = "Oops! It seems like the file format you're trying to upload is not supported. Please upload a file with a supported format and try again."
 
     NOT_FOUND = "We could not find what you're looking for :/"
     USER_NOT_FOUND = "We could not find what you're looking for :/"
     API_KEY_NOT_FOUND = "Oops! It looks like there's a hiccup. The API key is missing. Please make sure to provide a valid API key to access this feature."
-    API_KEY_NOT_ALLOWED = "Use of API key is not enabled in the environment."
+    API_KEY_NOT_ALLOWED = 'Use of API key is not enabled in the environment.'
 
-    MALICIOUS = "Unusual activities detected, please try again in a few minutes."
+    MALICIOUS = 'Unusual activities detected, please try again in a few minutes.'
 
-    PANDOC_NOT_INSTALLED = "Pandoc is not installed on the server. Please contact your administrator for assistance."
-    INCORRECT_FORMAT = (
-        lambda err="": f"Invalid format. Please use the correct format{err}"
-    )
-    RATE_LIMIT_EXCEEDED = "API rate limit exceeded"
+    PANDOC_NOT_INSTALLED = 'Pandoc is not installed on the server. Please contact your administrator for assistance.'
+    INCORRECT_FORMAT = lambda err='': f'Invalid format. Please use the correct format{err}'
+    RATE_LIMIT_EXCEEDED = 'API rate limit exceeded'
 
-    MODEL_NOT_FOUND = lambda name="": f"Model '{name}' was not found"
-    OPENAI_NOT_FOUND = lambda name="": "OpenAI API was not found"
-    OLLAMA_NOT_FOUND = "WebUI could not connect to Ollama"
-    CREATE_API_KEY_ERROR = "Oops! Something went wrong while creating your API key. Please try again later. If the issue persists, contact support for assistance."
-    API_KEY_CREATION_NOT_ALLOWED = "API key creation is not allowed in the environment."
+    MODEL_NOT_FOUND = lambda name='': f"Model '{name}' was not found"
+    OPENAI_NOT_FOUND = lambda name='': 'OpenAI API was not found'
+    OLLAMA_NOT_FOUND = 'WebUI could not connect to Ollama'
+    CREATE_API_KEY_ERROR = 'Oops! Something went wrong while creating your API key. Please try again later. If the issue persists, contact support for assistance.'
+    API_KEY_CREATION_NOT_ALLOWED = 'API key creation is not allowed in the environment.'
 
-    EMPTY_CONTENT = "The content provided is empty. Please ensure that there is text or data present before proceeding."
+    EMPTY_CONTENT = 'The content provided is empty. Please ensure that there is text or data present before proceeding.'
 
-    DB_NOT_SQLITE = "This feature is only available when running with SQLite databases."
+    DB_NOT_SQLITE = 'This feature is only available when running with SQLite databases.'
 
-    INVALID_URL = (
-        "Oops! The URL you provided is invalid. Please double-check and try again."
-    )
+    INVALID_URL = 'Oops! The URL you provided is invalid. Please double-check and try again.'
 
-    WEB_SEARCH_ERROR = (
-        lambda err="": f"{err if err else 'Oops! Something went wrong while searching the web.'}"
-    )
+    WEB_SEARCH_ERROR = lambda err='': f'{err if err else "Oops! Something went wrong while searching the web."}'
 
-    OLLAMA_API_DISABLED = (
-        "The Ollama API is disabled. Please enable it to use this feature."
-    )
+    OLLAMA_API_DISABLED = 'The Ollama API is disabled. Please enable it to use this feature.'
 
     FILE_TOO_LARGE = (
-        lambda size="": f"Oops! The file you're trying to upload is too large. Please upload a file that is less than {size}."
+        lambda size='': f"Oops! The file you're trying to upload is too large. Please upload a file that is less than {size}."
     )
 
-    DUPLICATE_CONTENT = (
-        "Duplicate content detected. Please provide unique content to proceed."
+    DUPLICATE_CONTENT = 'Duplicate content detected. Please provide unique content to proceed.'
+    FILE_NOT_PROCESSED = (
+        'Extracted content is not available for this file. Please ensure that the file is processed before proceeding.'
     )
-    FILE_NOT_PROCESSED = "Extracted content is not available for this file. Please ensure that the file is processed before proceeding."
 
-    INVALID_PASSWORD = lambda err="": (
-        err if err else "The password does not meet the required validation criteria."
-    )
+    INVALID_PASSWORD = lambda err='': (err if err else 'The password does not meet the required validation criteria.')
 
 
 class TASKS(str, Enum):
     def __str__(self) -> str:
         return super().__str__()
 
-    DEFAULT = lambda task="": f"{task if task else 'generation'}"
-    TITLE_GENERATION = "title_generation"
-    FOLLOW_UP_GENERATION = "follow_up_generation"
-    TAGS_GENERATION = "tags_generation"
-    EMOJI_GENERATION = "emoji_generation"
-    QUERY_GENERATION = "query_generation"
-    IMAGE_PROMPT_GENERATION = "image_prompt_generation"
-    AUTOCOMPLETE_GENERATION = "autocomplete_generation"
-    FUNCTION_CALLING = "function_calling"
-    MOA_RESPONSE_GENERATION = "moa_response_generation"
+    DEFAULT = lambda task='': f'{task if task else "generation"}'
+    TITLE_GENERATION = 'title_generation'
+    FOLLOW_UP_GENERATION = 'follow_up_generation'
+    TAGS_GENERATION = 'tags_generation'
+    EMOJI_GENERATION = 'emoji_generation'
+    QUERY_GENERATION = 'query_generation'
+    IMAGE_PROMPT_GENERATION = 'image_prompt_generation'
+    AUTOCOMPLETE_GENERATION = 'autocomplete_generation'
+    FUNCTION_CALLING = 'function_calling'
+    MOA_RESPONSE_GENERATION = 'moa_response_generation'

@@ -37,37 +37,34 @@
 try:
     from dotenv import find_dotenv, load_dotenv
 
-    load_dotenv(find_dotenv(str(BASE_DIR / ".env")))
+    load_dotenv(find_dotenv(str(BASE_DIR / '.env')))
 except ImportError:
-    print("dotenv not installed, skipping...")
+    print('dotenv not installed, skipping...')
 
-DOCKER = os.environ.get("DOCKER", "False").lower() == "true"
+DOCKER = os.environ.get('DOCKER', 'False').lower() == 'true'
 
 # device type embedding models - "cpu" (default), "cuda" (nvidia gpu required) or "mps" (apple silicon) - choosing this right can lead to better performance
-USE_CUDA = os.environ.get("USE_CUDA_DOCKER", "false")
+USE_CUDA = os.environ.get('USE_CUDA_DOCKER', 'false')
 
-if USE_CUDA.lower() == "true":
+if USE_CUDA.lower() == 'true':
     try:
         import torch
 
-        assert torch.cuda.is_available(), "CUDA not available"
-        DEVICE_TYPE = "cuda"
+        assert torch.cuda.is_available(), 'CUDA not available'
+        DEVICE_TYPE = 'cuda'
     except Exception as e:
-        cuda_error = (
-            "Error when testing CUDA but USE_CUDA_DOCKER is true. "
-            f"Resetting USE_CUDA_DOCKER to false: {e}"
-        )
-        os.environ["USE_CUDA_DOCKER"] = "false"
-        USE_CUDA = "false"
-        DEVICE_TYPE = "cpu"
+        cuda_error = f'Error when testing CUDA but USE_CUDA_DOCKER is true. Resetting USE_CUDA_DOCKER to false: {e}'
+        os.environ['USE_CUDA_DOCKER'] = 'false'
+        USE_CUDA = 'false'
+        DEVICE_TYPE = 'cpu'
 else:
-    DEVICE_TYPE = "cpu"
+    DEVICE_TYPE = 'cpu'
 
 try:
     import torch
 
     if torch.backends.mps.is_available() and torch.backends.mps.is_built():
-        DEVICE_TYPE = "mps"
+        DEVICE_TYPE = 'mps'
 except Exception:
     pass
 
@@ -76,11 +73,11 @@
 ####################################
 
 _LEVEL_MAP = {
-    "DEBUG": "debug",
-    "INFO": "info",
-    "WARNING": "warn",
-    "ERROR": "error",
-    "CRITICAL": "fatal",
+    'DEBUG': 'debug',
+    'INFO': 'info',
+    'WARNING': 'warn',
+    'ERROR': 'error',
+    'CRITICAL': 'fatal',
 }
 
 
@@ -89,132 +86,128 @@ class JSONFormatter(logging.Formatter):
 
     def format(self, record: logging.LogRecord) -> str:
         log_entry: dict[str, Any] = {
-            "ts": datetime.fromtimestamp(record.created, tz=timezone.utc).isoformat(
-                timespec="milliseconds"
-            ),
-            "level": _LEVEL_MAP.get(record.levelname, record.levelname.lower()),
-            "msg": record.getMessage(),
-            "caller": record.name,
+            'ts': datetime.fromtimestamp(record.created, tz=timezone.utc).isoformat(timespec='milliseconds'),
+            'level': _LEVEL_MAP.get(record.levelname, record.levelname.lower()),
+            'msg': record.getMessage(),
+            'caller': record.name,
         }
 
         if record.exc_info and record.exc_info[0] is not None:
-            log_entry["error"] = "".join(
-                traceback.format_exception(*record.exc_info)
-            ).rstrip()
+            log_entry['error'] = ''.join(traceback.format_exception(*record.exc_info)).rstrip()
         elif record.exc_text:
-            log_entry["error"] = record.exc_text
+            log_entry['error'] = record.exc_text
 
         if record.stack_info:
-            log_entry["stacktrace"] = record.stack_info
+            log_entry['stacktrace'] = record.stack_info
 
         return json.dumps(log_entry, ensure_ascii=False, default=str)
 
 
-LOG_FORMAT = os.environ.get("LOG_FORMAT", "").lower()
+LOG_FORMAT = os.environ.get('LOG_FORMAT', '').lower()
 
-GLOBAL_LOG_LEVEL = os.environ.get("GLOBAL_LOG_LEVEL", "").upper()
+GLOBAL_LOG_LEVEL = os.environ.get('GLOBAL_LOG_LEVEL', '').upper()
 if GLOBAL_LOG_LEVEL in logging.getLevelNamesMapping():
-    if LOG_FORMAT == "json":
+    if LOG_FORMAT == 'json':
         _handler = logging.StreamHandler(sys.stdout)
         _handler.setFormatter(JSONFormatter())
         logging.basicConfig(handlers=[_handler], level=GLOBAL_LOG_LEVEL, force=True)
     else:
         logging.basicConfig(stream=sys.stdout, level=GLOBAL_LOG_LEVEL, force=True)
 else:
-    GLOBAL_LOG_LEVEL = "INFO"
+    GLOBAL_LOG_LEVEL = 'INFO'
 
 log = logging.getLogger(__name__)
-log.info(f"GLOBAL_LOG_LEVEL: {GLOBAL_LOG_LEVEL}")
+log.info(f'GLOBAL_LOG_LEVEL: {GLOBAL_LOG_LEVEL}')
 
-if "cuda_error" in locals():
+if 'cuda_error' in locals():
     log.exception(cuda_error)
     del cuda_error
 
 SRC_LOG_LEVELS = {}  # Legacy variable, do not remove
 
-WEBUI_NAME = os.environ.get("WEBUI_NAME", "Open WebUI")
-if WEBUI_NAME != "Open WebUI":
-    WEBUI_NAME += " (Open WebUI)"
+WEBUI_NAME = os.environ.get('WEBUI_NAME', 'Open WebUI')
+if WEBUI_NAME != 'Open WebUI':
+    WEBUI_NAME += ' (Open WebUI)'
 
-WEBUI_FAVICON_URL = "https://openwebui.com/favicon.png"
+WEBUI_FAVICON_URL = 'https://openwebui.com/favicon.png'
 
-TRUSTED_SIGNATURE_KEY = os.environ.get("TRUSTED_SIGNATURE_KEY", "")
+TRUSTED_SIGNATURE_KEY = os.environ.get('TRUSTED_SIGNATURE_KEY', '')
 
 ####################################
 # ENV (dev,test,prod)
 ####################################
 
-ENV = os.environ.get("ENV", "dev")
+ENV = os.environ.get('ENV', 'dev')
 
-FROM_INIT_PY = os.environ.get("FROM_INIT_PY", "False").lower() == "true"
+FROM_INIT_PY = os.environ.get('FROM_INIT_PY', 'False').lower() == 'true'
 
 if FROM_INIT_PY:
-    PACKAGE_DATA = {"version": importlib.metadata.version("open-webui")}
+    PACKAGE_DATA = {'version': importlib.metadata.version('open-webui')}
 else:
     try:
-        PACKAGE_DATA = json.loads((BASE_DIR / "package.json").read_text())
+        PACKAGE_DATA = json.loads((BASE_DIR / 'package.json').read_text())
     except Exception:
-        PACKAGE_DATA = {"version": "0.0.0"}
+        PACKAGE_DATA = {'version': '0.0.0'}
 
-VERSION = PACKAGE_DATA["version"]
+VERSION = PACKAGE_DATA['version']
 
 
-DEPLOYMENT_ID = os.environ.get("DEPLOYMENT_ID", "")
-INSTANCE_ID = os.environ.get("INSTANCE_ID", str(uuid4()))
+DEPLOYMENT_ID = os.environ.get('DEPLOYMENT_ID', '')
+INSTANCE_ID = os.environ.get('INSTANCE_ID', str(uuid4()))
 
-ENABLE_DB_MIGRATIONS = os.environ.get("ENABLE_DB_MIGRATIONS", "True").lower() == "true"
+ENABLE_DB_MIGRATIONS = os.environ.get('ENABLE_DB_MIGRATIONS', 'True').lower() == 'true'
 
 
 # Function to parse each section
 def parse_section(section):
     items = []
-    for li in section.find_all("li"):
+    for li in section.find_all('li'):
         # Extract raw HTML string
         raw_html = str(li)
 
         # Extract text without HTML tags
-        text = li.get_text(separator=" ", strip=True)
+        text = li.get_text(separator=' ', strip=True)
 
         # Split into title and content
-        parts = text.split(": ", 1)
-        title = parts[0].strip() if len(parts) > 1 else ""
+        parts = text.split(': ', 1)
+        title = parts[0].strip() if len(parts) > 1 else ''
         content = parts[1].strip() if len(parts) > 1 else text
 
-        items.append({"title": title, "content": content, "raw": raw_html})
+        items.append({'title': title, 'content': content, 'raw': raw_html})
     return items
 
 
 try:
-    changelog_path = BASE_DIR / "CHANGELOG.md"
-    with open(str(changelog_path.absolute()), "r", encoding="utf8") as file:
+    changelog_path = BASE_DIR / 'CHANGELOG.md'
+    with open(str(changelog_path.absolute()), 'r', encoding='utf8') as file:
         changelog_content = file.read()
 
 except Exception:
-    changelog_content = (pkgutil.get_data("open_webui", "CHANGELOG.md") or b"").decode()
+    changelog_content = (pkgutil.get_data('open_webui', 'CHANGELOG.md') or b'').decode()
 
 # Convert markdown content to HTML
 html_content = markdown.markdown(changelog_content)
 
 # Parse the HTML content
-soup = BeautifulSoup(html_content, "html.parser")
+soup = BeautifulSoup(html_content, 'html.parser')
 
 # Initialize JSON structure
 changelog_json = {}
 
 # Iterate over each version
-for version in soup.find_all("h2"):
-    version_number = version.get_text().strip().split(" - ")[0][1:-1]  # Remove brackets
-    date = version.get_text().strip().split(" - ")[1]
+for version in soup.find_all('h2'):
+    version_number = version.get_text().strip().split(' - ')[0][1:-1]  # Remove brackets
+    date = version.get_text().strip().split(' - ')[1]
 
-    version_data = {"date": date}
+    version_data = {'date': date}
 
     # Find the next sibling that is a h3 tag (section title)
     current = version.find_next_sibling()
 
-    while current and current.name != "h2":
-        if current.name == "h3":
+    while current and current.name != 'h2':
+        if current.name == 'h3':
             section_title = current.get_text().lower()  # e.g., "added", "fixed"
-            section_items = parse_section(current.find_next_sibling("ul"))
+            section_items = parse_section(current.find_next_sibling('ul'))
             version_data[section_title] = section_items
 
         # Move to the next element
@@ -228,65 +221,51 @@ def parse_section(section):
 # SAFE_MODE
 ####################################
 
-SAFE_MODE = os.environ.get("SAFE_MODE", "false").lower() == "true"
+SAFE_MODE = os.environ.get('SAFE_MODE', 'false').lower() == 'true'
 
 
 ####################################
 # ENABLE_FORWARD_USER_INFO_HEADERS
 ####################################
 
-ENABLE_FORWARD_USER_INFO_HEADERS = (
-    os.environ.get("ENABLE_FORWARD_USER_INFO_HEADERS", "False").lower() == "true"
-)
+ENABLE_FORWARD_USER_INFO_HEADERS = os.environ.get('ENABLE_FORWARD_USER_INFO_HEADERS', 'False').lower() == 'true'
 
 # Header names for user info forwarding (customizable via environment variables)
-FORWARD_USER_INFO_HEADER_USER_NAME = os.environ.get(
-    "FORWARD_USER_INFO_HEADER_USER_NAME", "X-OpenWebUI-User-Name"
-)
-FORWARD_USER_INFO_HEADER_USER_ID = os.environ.get(
-    "FORWARD_USER_INFO_HEADER_USER_ID", "X-OpenWebUI-User-Id"
-)
-FORWARD_USER_INFO_HEADER_USER_EMAIL = os.environ.get(
-    "FORWARD_USER_INFO_HEADER_USER_EMAIL", "X-OpenWebUI-User-Email"
-)
-FORWARD_USER_INFO_HEADER_USER_ROLE = os.environ.get(
-    "FORWARD_USER_INFO_HEADER_USER_ROLE", "X-OpenWebUI-User-Role"
-)
+FORWARD_USER_INFO_HEADER_USER_NAME = os.environ.get('FORWARD_USER_INFO_HEADER_USER_NAME', 'X-OpenWebUI-User-Name')
+FORWARD_USER_INFO_HEADER_USER_ID = os.environ.get('FORWARD_USER_INFO_HEADER_USER_ID', 'X-OpenWebUI-User-Id')
+FORWARD_USER_INFO_HEADER_USER_EMAIL = os.environ.get('FORWARD_USER_INFO_HEADER_USER_EMAIL', 'X-OpenWebUI-User-Email')
+FORWARD_USER_INFO_HEADER_USER_ROLE = os.environ.get('FORWARD_USER_INFO_HEADER_USER_ROLE', 'X-OpenWebUI-User-Role')
 
 # Header name for chat ID forwarding (customizable via environment variable)
 FORWARD_SESSION_INFO_HEADER_MESSAGE_ID = os.environ.get(
-    "FORWARD_SESSION_INFO_HEADER_MESSAGE_ID", "X-OpenWebUI-Message-Id"
-)
-FORWARD_SESSION_INFO_HEADER_CHAT_ID = os.environ.get(
-    "FORWARD_SESSION_INFO_HEADER_CHAT_ID", "X-OpenWebUI-Chat-Id"
+    'FORWARD_SESSION_INFO_HEADER_MESSAGE_ID', 'X-OpenWebUI-Message-Id'
 )
+FORWARD_SESSION_INFO_HEADER_CHAT_ID = os.environ.get('FORWARD_SESSION_INFO_HEADER_CHAT_ID', 'X-OpenWebUI-Chat-Id')
 
 # Experimental feature, may be removed in future
-ENABLE_STAR_SESSIONS_MIDDLEWARE = (
-    os.environ.get("ENABLE_STAR_SESSIONS_MIDDLEWARE", "False").lower() == "true"
-)
+ENABLE_STAR_SESSIONS_MIDDLEWARE = os.environ.get('ENABLE_STAR_SESSIONS_MIDDLEWARE', 'False').lower() == 'true'
 
-ENABLE_EASTER_EGGS = os.environ.get("ENABLE_EASTER_EGGS", "True").lower() == "true"
+ENABLE_EASTER_EGGS = os.environ.get('ENABLE_EASTER_EGGS', 'True').lower() == 'true'
 
 ####################################
 # WEBUI_BUILD_HASH
 ####################################
 
-WEBUI_BUILD_HASH = os.environ.get("WEBUI_BUILD_HASH", "dev-build")
+WEBUI_BUILD_HASH = os.environ.get('WEBUI_BUILD_HASH', 'dev-build')
 
 ####################################
 # DATA/FRONTEND BUILD DIR
 ####################################
 
-DATA_DIR = Path(os.getenv("DATA_DIR", BACKEND_DIR / "data")).resolve()
+DATA_DIR = Path(os.getenv('DATA_DIR', BACKEND_DIR / 'data')).resolve()
 
 if FROM_INIT_PY:
-    NEW_DATA_DIR = Path(os.getenv("DATA_DIR", OPEN_WEBUI_DIR / "data")).resolve()
+    NEW_DATA_DIR = Path(os.getenv('DATA_DIR', OPEN_WEBUI_DIR / 'data')).resolve()
     NEW_DATA_DIR.mkdir(parents=True, exist_ok=True)
 
     # Check if the data directory exists in the package directory
     if DATA_DIR.exists() and DATA_DIR != NEW_DATA_DIR:
-        log.info(f"Moving {DATA_DIR} to {NEW_DATA_DIR}")
+        log.info(f'Moving {DATA_DIR} to {NEW_DATA_DIR}')
         for item in DATA_DIR.iterdir():
             dest = NEW_DATA_DIR / item.name
             if item.is_dir():
@@ -295,157 +274,143 @@ def parse_section(section):
                 shutil.copy2(item, dest)
 
         # Zip the data directory
-        shutil.make_archive(DATA_DIR.parent / "open_webui_data", "zip", DATA_DIR)
+        shutil.make_archive(DATA_DIR.parent / 'open_webui_data', 'zip', DATA_DIR)
 
         # Remove the old data directory
         shutil.rmtree(DATA_DIR)
 
-    DATA_DIR = Path(os.getenv("DATA_DIR", OPEN_WEBUI_DIR / "data"))
+    DATA_DIR = Path(os.getenv('DATA_DIR', OPEN_WEBUI_DIR / 'data'))
 
-STATIC_DIR = Path(os.getenv("STATIC_DIR", OPEN_WEBUI_DIR / "static"))
+STATIC_DIR = Path(os.getenv('STATIC_DIR', OPEN_WEBUI_DIR / 'static'))
 
-FONTS_DIR = Path(os.getenv("FONTS_DIR", OPEN_WEBUI_DIR / "static" / "fonts"))
+FONTS_DIR = Path(os.getenv('FONTS_DIR', OPEN_WEBUI_DIR / 'static' / 'fonts'))
 
-FRONTEND_BUILD_DIR = Path(os.getenv("FRONTEND_BUILD_DIR", BASE_DIR / "build")).resolve()
+FRONTEND_BUILD_DIR = Path(os.getenv('FRONTEND_BUILD_DIR', BASE_DIR / 'build')).resolve()
 
 if FROM_INIT_PY:
-    FRONTEND_BUILD_DIR = Path(
-        os.getenv("FRONTEND_BUILD_DIR", OPEN_WEBUI_DIR / "frontend")
-    ).resolve()
+    FRONTEND_BUILD_DIR = Path(os.getenv('FRONTEND_BUILD_DIR', OPEN_WEBUI_DIR / 'frontend')).resolve()
 
 ####################################
 # Database
 ####################################
 
 # Check if the file exists
-if os.path.exists(f"{DATA_DIR}/ollama.db"):
+if os.path.exists(f'{DATA_DIR}/ollama.db'):
     # Rename the file
-    os.rename(f"{DATA_DIR}/ollama.db", f"{DATA_DIR}/webui.db")
-    log.info("Database migrated from Ollama-WebUI successfully.")
+    os.rename(f'{DATA_DIR}/ollama.db', f'{DATA_DIR}/webui.db')
+    log.info('Database migrated from Ollama-WebUI successfully.')
 else:
     pass
 
-DATABASE_URL = os.environ.get("DATABASE_URL", f"sqlite:///{DATA_DIR}/webui.db")
+DATABASE_URL = os.environ.get('DATABASE_URL', f'sqlite:///{DATA_DIR}/webui.db')
 
-DATABASE_TYPE = os.environ.get("DATABASE_TYPE")
-DATABASE_USER = os.environ.get("DATABASE_USER")
-DATABASE_PASSWORD = os.environ.get("DATABASE_PASSWORD")
+DATABASE_TYPE = os.environ.get('DATABASE_TYPE')
+DATABASE_USER = os.environ.get('DATABASE_USER')
+DATABASE_PASSWORD = os.environ.get('DATABASE_PASSWORD')
 
-DATABASE_CRED = ""
+DATABASE_CRED = ''
 if DATABASE_USER:
-    DATABASE_CRED += f"{DATABASE_USER}"
+    DATABASE_CRED += f'{DATABASE_USER}'
 if DATABASE_PASSWORD:
-    DATABASE_CRED += f":{DATABASE_PASSWORD}"
+    DATABASE_CRED += f':{DATABASE_PASSWORD}'
 
 DB_VARS = {
-    "db_type": DATABASE_TYPE,
-    "db_cred": DATABASE_CRED,
-    "db_host": os.environ.get("DATABASE_HOST"),
-    "db_port": os.environ.get("DATABASE_PORT"),
-    "db_name": os.environ.get("DATABASE_NAME"),
+    'db_type': DATABASE_TYPE,
+    'db_cred': DATABASE_CRED,
+    'db_host': os.environ.get('DATABASE_HOST'),
+    'db_port': os.environ.get('DATABASE_PORT'),
+    'db_name': os.environ.get('DATABASE_NAME'),
 }
 
 if all(DB_VARS.values()):
-    DATABASE_URL = f"{DB_VARS['db_type']}://{DB_VARS['db_cred']}@{DB_VARS['db_host']}:{DB_VARS['db_port']}/{DB_VARS['db_name']}"
-elif DATABASE_TYPE == "sqlite+sqlcipher" and not os.environ.get("DATABASE_URL"):
+    DATABASE_URL = (
+        f'{DB_VARS["db_type"]}://{DB_VARS["db_cred"]}@{DB_VARS["db_host"]}:{DB_VARS["db_port"]}/{DB_VARS["db_name"]}'
+    )
+elif DATABASE_TYPE == 'sqlite+sqlcipher' and not os.environ.get('DATABASE_URL'):
     # Handle SQLCipher with local file when DATABASE_URL wasn't explicitly set
-    DATABASE_URL = f"sqlite+sqlcipher:///{DATA_DIR}/webui.db"
+    DATABASE_URL = f'sqlite+sqlcipher:///{DATA_DIR}/webui.db'
 
 # Replace the postgres:// with postgresql://
-if "postgres://" in DATABASE_URL:
-    DATABASE_URL = DATABASE_URL.replace("postgres://", "postgresql://")
+if 'postgres://' in DATABASE_URL:
+    DATABASE_URL = DATABASE_URL.replace('postgres://', 'postgresql://')
 
-DATABASE_SCHEMA = os.environ.get("DATABASE_SCHEMA", None)
+DATABASE_SCHEMA = os.environ.get('DATABASE_SCHEMA', None)
 
-DATABASE_POOL_SIZE = os.environ.get("DATABASE_POOL_SIZE", None)
+DATABASE_POOL_SIZE = os.environ.get('DATABASE_POOL_SIZE', None)
 
 if DATABASE_POOL_SIZE != None:
     try:
         DATABASE_POOL_SIZE = int(DATABASE_POOL_SIZE)
     except Exception:
         DATABASE_POOL_SIZE = None
 
-DATABASE_POOL_MAX_OVERFLOW = os.environ.get("DATABASE_POOL_MAX_OVERFLOW", 0)
+DATABASE_POOL_MAX_OVERFLOW = os.environ.get('DATABASE_POOL_MAX_OVERFLOW', 0)
 
-if DATABASE_POOL_MAX_OVERFLOW == "":
+if DATABASE_POOL_MAX_OVERFLOW == '':
     DATABASE_POOL_MAX_OVERFLOW = 0
 else:
     try:
         DATABASE_POOL_MAX_OVERFLOW = int(DATABASE_POOL_MAX_OVERFLOW)
     except Exception:
         DATABASE_POOL_MAX_OVERFLOW = 0
 
-DATABASE_POOL_TIMEOUT = os.environ.get("DATABASE_POOL_TIMEOUT", 30)
+DATABASE_POOL_TIMEOUT = os.environ.get('DATABASE_POOL_TIMEOUT', 30)
 
-if DATABASE_POOL_TIMEOUT == "":
+if DATABASE_POOL_TIMEOUT == '':
     DATABASE_POOL_TIMEOUT = 30
 else:
     try:
         DATABASE_POOL_TIMEOUT = int(DATABASE_POOL_TIMEOUT)
     except Exception:
         DATABASE_POOL_TIMEOUT = 30
 
-DATABASE_POOL_RECYCLE = os.environ.get("DATABASE_POOL_RECYCLE", 3600)
+DATABASE_POOL_RECYCLE = os.environ.get('DATABASE_POOL_RECYCLE', 3600)
 
-if DATABASE_POOL_RECYCLE == "":
+if DATABASE_POOL_RECYCLE == '':
     DATABASE_POOL_RECYCLE = 3600
 else:
     try:
         DATABASE_POOL_RECYCLE = int(DATABASE_POOL_RECYCLE)
     except Exception:
         DATABASE_POOL_RECYCLE = 3600
 
-DATABASE_ENABLE_SQLITE_WAL = (
-    os.environ.get("DATABASE_ENABLE_SQLITE_WAL", "False").lower() == "true"
-)
+DATABASE_ENABLE_SQLITE_WAL = os.environ.get('DATABASE_ENABLE_SQLITE_WAL', 'False').lower() == 'true'
 
-DATABASE_USER_ACTIVE_STATUS_UPDATE_INTERVAL = os.environ.get(
-    "DATABASE_USER_ACTIVE_STATUS_UPDATE_INTERVAL", None
-)
+DATABASE_USER_ACTIVE_STATUS_UPDATE_INTERVAL = os.environ.get('DATABASE_USER_ACTIVE_STATUS_UPDATE_INTERVAL', None)
 if DATABASE_USER_ACTIVE_STATUS_UPDATE_INTERVAL is not None:
     try:
-        DATABASE_USER_ACTIVE_STATUS_UPDATE_INTERVAL = float(
-            DATABASE_USER_ACTIVE_STATUS_UPDATE_INTERVAL
-        )
+        DATABASE_USER_ACTIVE_STATUS_UPDATE_INTERVAL = float(DATABASE_USER_ACTIVE_STATUS_UPDATE_INTERVAL)
     except Exception:
         DATABASE_USER_ACTIVE_STATUS_UPDATE_INTERVAL = 0.0
 
 # When enabled, get_db_context reuses existing sessions; set to False to always create new sessions
-DATABASE_ENABLE_SESSION_SHARING = (
-    os.environ.get("DATABASE_ENABLE_SESSION_SHARING", "False").lower() == "true"
-)
+DATABASE_ENABLE_SESSION_SHARING = os.environ.get('DATABASE_ENABLE_SESSION_SHARING', 'False').lower() == 'true'
 
 # Enable public visibility of active user count (when disabled, only admins can see it)
-ENABLE_PUBLIC_ACTIVE_USERS_COUNT = (
-    os.environ.get("ENABLE_PUBLIC_ACTIVE_USERS_COUNT", "True").lower() == "true"
-)
+ENABLE_PUBLIC_ACTIVE_USERS_COUNT = os.environ.get('ENABLE_PUBLIC_ACTIVE_USERS_COUNT', 'True').lower() == 'true'
 
-RESET_CONFIG_ON_START = (
-    os.environ.get("RESET_CONFIG_ON_START", "False").lower() == "true"
-)
+RESET_CONFIG_ON_START = os.environ.get('RESET_CONFIG_ON_START', 'False').lower() == 'true'
 
-ENABLE_REALTIME_CHAT_SAVE = (
-    os.environ.get("ENABLE_REALTIME_CHAT_SAVE", "False").lower() == "true"
-)
+ENABLE_REALTIME_CHAT_SAVE = os.environ.get('ENABLE_REALTIME_CHAT_SAVE', 'False').lower() == 'true'
 
-ENABLE_QUERIES_CACHE = os.environ.get("ENABLE_QUERIES_CACHE", "False").lower() == "true"
+ENABLE_QUERIES_CACHE = os.environ.get('ENABLE_QUERIES_CACHE', 'False').lower() == 'true'
 
-RAG_SYSTEM_CONTEXT = os.environ.get("RAG_SYSTEM_CONTEXT", "False").lower() == "true"
+RAG_SYSTEM_CONTEXT = os.environ.get('RAG_SYSTEM_CONTEXT', 'False').lower() == 'true'
 
 ####################################
 # REDIS
 ####################################
 
-REDIS_URL = os.environ.get("REDIS_URL", "")
-REDIS_CLUSTER = os.environ.get("REDIS_CLUSTER", "False").lower() == "true"
+REDIS_URL = os.environ.get('REDIS_URL', '')
+REDIS_CLUSTER = os.environ.get('REDIS_CLUSTER', 'False').lower() == 'true'
 
-REDIS_KEY_PREFIX = os.environ.get("REDIS_KEY_PREFIX", "open-webui")
+REDIS_KEY_PREFIX = os.environ.get('REDIS_KEY_PREFIX', 'open-webui')
 
-REDIS_SENTINEL_HOSTS = os.environ.get("REDIS_SENTINEL_HOSTS", "")
-REDIS_SENTINEL_PORT = os.environ.get("REDIS_SENTINEL_PORT", "26379")
+REDIS_SENTINEL_HOSTS = os.environ.get('REDIS_SENTINEL_HOSTS', '')
+REDIS_SENTINEL_PORT = os.environ.get('REDIS_SENTINEL_PORT', '26379')
 
 # Maximum number of retries for Redis operations when using Sentinel fail-over
-REDIS_SENTINEL_MAX_RETRY_COUNT = os.environ.get("REDIS_SENTINEL_MAX_RETRY_COUNT", "2")
+REDIS_SENTINEL_MAX_RETRY_COUNT = os.environ.get('REDIS_SENTINEL_MAX_RETRY_COUNT', '2')
 try:
     REDIS_SENTINEL_MAX_RETRY_COUNT = int(REDIS_SENTINEL_MAX_RETRY_COUNT)
     if REDIS_SENTINEL_MAX_RETRY_COUNT < 1:
@@ -454,15 +419,15 @@ def parse_section(section):
     REDIS_SENTINEL_MAX_RETRY_COUNT = 2
 
 
-REDIS_SOCKET_CONNECT_TIMEOUT = os.environ.get("REDIS_SOCKET_CONNECT_TIMEOUT", "")
+REDIS_SOCKET_CONNECT_TIMEOUT = os.environ.get('REDIS_SOCKET_CONNECT_TIMEOUT', '')
 try:
     REDIS_SOCKET_CONNECT_TIMEOUT = float(REDIS_SOCKET_CONNECT_TIMEOUT)
 except ValueError:
     REDIS_SOCKET_CONNECT_TIMEOUT = None
 
-REDIS_RECONNECT_DELAY = os.environ.get("REDIS_RECONNECT_DELAY", "")
+REDIS_RECONNECT_DELAY = os.environ.get('REDIS_RECONNECT_DELAY', '')
 
-if REDIS_RECONNECT_DELAY == "":
+if REDIS_RECONNECT_DELAY == '':
     REDIS_RECONNECT_DELAY = None
 else:
     try:
@@ -477,192 +442,155 @@ def parse_section(section):
 ####################################
 
 # Number of uvicorn worker processes for handling requests
-UVICORN_WORKERS = os.environ.get("UVICORN_WORKERS", "1")
+UVICORN_WORKERS = os.environ.get('UVICORN_WORKERS', '1')
 try:
     UVICORN_WORKERS = int(UVICORN_WORKERS)
     if UVICORN_WORKERS < 1:
         UVICORN_WORKERS = 1
 except ValueError:
     UVICORN_WORKERS = 1
-    log.info(f"Invalid UVICORN_WORKERS value, defaulting to {UVICORN_WORKERS}")
+    log.info(f'Invalid UVICORN_WORKERS value, defaulting to {UVICORN_WORKERS}')
 
 ####################################
 # WEBUI_AUTH (Required for security)
 ####################################
 
-WEBUI_AUTH = os.environ.get("WEBUI_AUTH", "True").lower() == "true"
+WEBUI_AUTH = os.environ.get('WEBUI_AUTH', 'True').lower() == 'true'
 
-ENABLE_INITIAL_ADMIN_SIGNUP = (
-    os.environ.get("ENABLE_INITIAL_ADMIN_SIGNUP", "False").lower() == "true"
-)
-ENABLE_SIGNUP_PASSWORD_CONFIRMATION = (
-    os.environ.get("ENABLE_SIGNUP_PASSWORD_CONFIRMATION", "False").lower() == "true"
-)
+ENABLE_INITIAL_ADMIN_SIGNUP = os.environ.get('ENABLE_INITIAL_ADMIN_SIGNUP', 'False').lower() == 'true'
+ENABLE_SIGNUP_PASSWORD_CONFIRMATION = os.environ.get('ENABLE_SIGNUP_PASSWORD_CONFIRMATION', 'False').lower() == 'true'
 
 ####################################
 # Admin Account Runtime Creation
 ####################################
 
 # Optional env vars for creating an admin account on startup
 # Useful for headless/automated deployments
-WEBUI_ADMIN_EMAIL = os.environ.get("WEBUI_ADMIN_EMAIL", "")
-WEBUI_ADMIN_PASSWORD = os.environ.get("WEBUI_ADMIN_PASSWORD", "")
-WEBUI_ADMIN_NAME = os.environ.get("WEBUI_ADMIN_NAME", "Admin")
+WEBUI_ADMIN_EMAIL = os.environ.get('WEBUI_ADMIN_EMAIL', '')
+WEBUI_ADMIN_PASSWORD = os.environ.get('WEBUI_ADMIN_PASSWORD', '')
+WEBUI_ADMIN_NAME = os.environ.get('WEBUI_ADMIN_NAME', 'Admin')
 
-WEBUI_AUTH_TRUSTED_EMAIL_HEADER = os.environ.get(
-    "WEBUI_AUTH_TRUSTED_EMAIL_HEADER", None
-)
-WEBUI_AUTH_TRUSTED_NAME_HEADER = os.environ.get("WEBUI_AUTH_TRUSTED_NAME_HEADER", None)
-WEBUI_AUTH_TRUSTED_GROUPS_HEADER = os.environ.get(
-    "WEBUI_AUTH_TRUSTED_GROUPS_HEADER", None
-)
+WEBUI_AUTH_TRUSTED_EMAIL_HEADER = os.environ.get('WEBUI_AUTH_TRUSTED_EMAIL_HEADER', None)
+WEBUI_AUTH_TRUSTED_NAME_HEADER = os.environ.get('WEBUI_AUTH_TRUSTED_NAME_HEADER', None)
+WEBUI_AUTH_TRUSTED_GROUPS_HEADER = os.environ.get('WEBUI_AUTH_TRUSTED_GROUPS_HEADER', None)
 
 
-ENABLE_PASSWORD_VALIDATION = (
-    os.environ.get("ENABLE_PASSWORD_VALIDATION", "False").lower() == "true"
-)
+ENABLE_PASSWORD_VALIDATION = os.environ.get('ENABLE_PASSWORD_VALIDATION', 'False').lower() == 'true'
 PASSWORD_VALIDATION_REGEX_PATTERN = os.environ.get(
-    "PASSWORD_VALIDATION_REGEX_PATTERN",
-    r"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\w\s]).{8,}$",
+    'PASSWORD_VALIDATION_REGEX_PATTERN',
+    r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\w\s]).{8,}$',
 )
 
 
 try:
-    PASSWORD_VALIDATION_REGEX_PATTERN = rf"{PASSWORD_VALIDATION_REGEX_PATTERN}"
+    PASSWORD_VALIDATION_REGEX_PATTERN = rf'{PASSWORD_VALIDATION_REGEX_PATTERN}'
     PASSWORD_VALIDATION_REGEX_PATTERN = re.compile(PASSWORD_VALIDATION_REGEX_PATTERN)
 except Exception as e:
-    log.error(f"Invalid PASSWORD_VALIDATION_REGEX_PATTERN: {e}")
-    PASSWORD_VALIDATION_REGEX_PATTERN = re.compile(
-        r"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\w\s]).{8,}$"
-    )
+    log.error(f'Invalid PASSWORD_VALIDATION_REGEX_PATTERN: {e}')
+    PASSWORD_VALIDATION_REGEX_PATTERN = re.compile(r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\w\s]).{8,}$')
 
-PASSWORD_VALIDATION_HINT = os.environ.get("PASSWORD_VALIDATION_HINT", "")
+PASSWORD_VALIDATION_HINT = os.environ.get('PASSWORD_VALIDATION_HINT', '')
 
 
-BYPASS_MODEL_ACCESS_CONTROL = (
-    os.environ.get("BYPASS_MODEL_ACCESS_CONTROL", "False").lower() == "true"
-)
+BYPASS_MODEL_ACCESS_CONTROL = os.environ.get('BYPASS_MODEL_ACCESS_CONTROL', 'False').lower() == 'true'
 
-WEBUI_AUTH_SIGNOUT_REDIRECT_URL = os.environ.get(
-    "WEBUI_AUTH_SIGNOUT_REDIRECT_URL", None
-)
+WEBUI_AUTH_SIGNOUT_REDIRECT_URL = os.environ.get('WEBUI_AUTH_SIGNOUT_REDIRECT_URL', None)
 
 ####################################
 # WEBUI_SECRET_KEY
 ####################################
 
 WEBUI_SECRET_KEY = os.environ.get(
-    "WEBUI_SECRET_KEY",
-    os.environ.get(
-        "WEBUI_JWT_SECRET_KEY", "t0p-s3cr3t"
-    ),  # DEPRECATED: remove at next major version
+    'WEBUI_SECRET_KEY',
+    os.environ.get('WEBUI_JWT_SECRET_KEY', 't0p-s3cr3t'),  # DEPRECATED: remove at next major version
 )
 
-WEBUI_SESSION_COOKIE_SAME_SITE = os.environ.get("WEBUI_SESSION_COOKIE_SAME_SITE", "lax")
+WEBUI_SESSION_COOKIE_SAME_SITE = os.environ.get('WEBUI_SESSION_COOKIE_SAME_SITE', 'lax')
 
-WEBUI_SESSION_COOKIE_SECURE = (
-    os.environ.get("WEBUI_SESSION_COOKIE_SECURE", "false").lower() == "true"
-)
+WEBUI_SESSION_COOKIE_SECURE = os.environ.get('WEBUI_SESSION_COOKIE_SECURE', 'false').lower() == 'true'
 
-WEBUI_AUTH_COOKIE_SAME_SITE = os.environ.get(
-    "WEBUI_AUTH_COOKIE_SAME_SITE", WEBUI_SESSION_COOKIE_SAME_SITE
-)
+WEBUI_AUTH_COOKIE_SAME_SITE = os.environ.get('WEBUI_AUTH_COOKIE_SAME_SITE', WEBUI_SESSION_COOKIE_SAME_SITE)
 
 WEBUI_AUTH_COOKIE_SECURE = (
     os.environ.get(
-        "WEBUI_AUTH_COOKIE_SECURE",
-        os.environ.get("WEBUI_SESSION_COOKIE_SECURE", "false"),
+        'WEBUI_AUTH_COOKIE_SECURE',
+        os.environ.get('WEBUI_SESSION_COOKIE_SECURE', 'false'),
     ).lower()
-    == "true"
+    == 'true'
 )
 
-if WEBUI_AUTH and WEBUI_SECRET_KEY == "":
+if WEBUI_AUTH and WEBUI_SECRET_KEY == '':
     raise ValueError(ERROR_MESSAGES.ENV_VAR_NOT_FOUND)
 
-ENABLE_COMPRESSION_MIDDLEWARE = (
-    os.environ.get("ENABLE_COMPRESSION_MIDDLEWARE", "True").lower() == "true"
-)
+ENABLE_COMPRESSION_MIDDLEWARE = os.environ.get('ENABLE_COMPRESSION_MIDDLEWARE', 'True').lower() == 'true'
 
 ####################################
 # OAUTH Configuration
 ####################################
-ENABLE_OAUTH_EMAIL_FALLBACK = (
-    os.environ.get("ENABLE_OAUTH_EMAIL_FALLBACK", "False").lower() == "true"
-)
+ENABLE_OAUTH_EMAIL_FALLBACK = os.environ.get('ENABLE_OAUTH_EMAIL_FALLBACK', 'False').lower() == 'true'
 
-ENABLE_OAUTH_ID_TOKEN_COOKIE = (
-    os.environ.get("ENABLE_OAUTH_ID_TOKEN_COOKIE", "True").lower() == "true"
-)
+ENABLE_OAUTH_ID_TOKEN_COOKIE = os.environ.get('ENABLE_OAUTH_ID_TOKEN_COOKIE', 'True').lower() == 'true'
 
-OAUTH_CLIENT_INFO_ENCRYPTION_KEY = os.environ.get(
-    "OAUTH_CLIENT_INFO_ENCRYPTION_KEY", WEBUI_SECRET_KEY
-)
+OAUTH_CLIENT_INFO_ENCRYPTION_KEY = os.environ.get('OAUTH_CLIENT_INFO_ENCRYPTION_KEY', WEBUI_SECRET_KEY)
 
-OAUTH_SESSION_TOKEN_ENCRYPTION_KEY = os.environ.get(
-    "OAUTH_SESSION_TOKEN_ENCRYPTION_KEY", WEBUI_SECRET_KEY
-)
+OAUTH_SESSION_TOKEN_ENCRYPTION_KEY = os.environ.get('OAUTH_SESSION_TOKEN_ENCRYPTION_KEY', WEBUI_SECRET_KEY)
 
 # Maximum number of concurrent OAuth sessions per user per provider
 # This prevents unbounded session growth while allowing multi-device usage
-OAUTH_MAX_SESSIONS_PER_USER = int(os.environ.get("OAUTH_MAX_SESSIONS_PER_USER", "10"))
+OAUTH_MAX_SESSIONS_PER_USER = int(os.environ.get('OAUTH_MAX_SESSIONS_PER_USER', '10'))
 
 # Token Exchange Configuration
 # Allows external apps to exchange OAuth tokens for OpenWebUI tokens
-ENABLE_OAUTH_TOKEN_EXCHANGE = (
-    os.environ.get("ENABLE_OAUTH_TOKEN_EXCHANGE", "False").lower() == "true"
-)
+ENABLE_OAUTH_TOKEN_EXCHANGE = os.environ.get('ENABLE_OAUTH_TOKEN_EXCHANGE', 'False').lower() == 'true'
 
 ####################################
 # SCIM Configuration
 ####################################
 
-ENABLE_SCIM = (
-    os.environ.get("ENABLE_SCIM", os.environ.get("SCIM_ENABLED", "False")).lower()
-    == "true"
-)
-SCIM_TOKEN = os.environ.get("SCIM_TOKEN", "")
-SCIM_AUTH_PROVIDER = os.environ.get("SCIM_AUTH_PROVIDER", "")
+ENABLE_SCIM = os.environ.get('ENABLE_SCIM', os.environ.get('SCIM_ENABLED', 'False')).lower() == 'true'
+SCIM_TOKEN = os.environ.get('SCIM_TOKEN', '')
+SCIM_AUTH_PROVIDER = os.environ.get('SCIM_AUTH_PROVIDER', '')
 
 if ENABLE_SCIM and not SCIM_AUTH_PROVIDER:
     log.warning(
-        "SCIM is enabled but SCIM_AUTH_PROVIDER is not set. "
+        'SCIM is enabled but SCIM_AUTH_PROVIDER is not set. '
         "Set SCIM_AUTH_PROVIDER to the OAuth provider name (e.g. 'microsoft', 'oidc') "
-        "to enable externalId storage."
+        'to enable externalId storage.'
     )
 
 ####################################
 # LICENSE_KEY
 ####################################
 
-LICENSE_KEY = os.environ.get("LICENSE_KEY", "")
+LICENSE_KEY = os.environ.get('LICENSE_KEY', '')
 
 LICENSE_BLOB = None
-LICENSE_BLOB_PATH = os.environ.get("LICENSE_BLOB_PATH", DATA_DIR / "l.data")
+LICENSE_BLOB_PATH = os.environ.get('LICENSE_BLOB_PATH', DATA_DIR / 'l.data')
 if LICENSE_BLOB_PATH and os.path.exists(LICENSE_BLOB_PATH):
-    with open(LICENSE_BLOB_PATH, "rb") as f:
+    with open(LICENSE_BLOB_PATH, 'rb') as f:
         LICENSE_BLOB = f.read()
 
-LICENSE_PUBLIC_KEY = os.environ.get("LICENSE_PUBLIC_KEY", "")
+LICENSE_PUBLIC_KEY = os.environ.get('LICENSE_PUBLIC_KEY', '')
 
 pk = None
 if LICENSE_PUBLIC_KEY:
-    pk = serialization.load_pem_public_key(f"""
+    pk = serialization.load_pem_public_key(
+        f"""
 -----BEGIN PUBLIC KEY-----
 {LICENSE_PUBLIC_KEY}
 -----END PUBLIC KEY-----
-""".encode("utf-8"))
+""".encode('utf-8')
+    )
 
 
 ####################################
 # MODELS
 ####################################
 
-ENABLE_CUSTOM_MODEL_FALLBACK = (
-    os.environ.get("ENABLE_CUSTOM_MODEL_FALLBACK", "False").lower() == "true"
-)
+ENABLE_CUSTOM_MODEL_FALLBACK = os.environ.get('ENABLE_CUSTOM_MODEL_FALLBACK', 'False').lower() == 'true'
 
-MODELS_CACHE_TTL = os.environ.get("MODELS_CACHE_TTL", "1")
-if MODELS_CACHE_TTL == "":
+MODELS_CACHE_TTL = os.environ.get('MODELS_CACHE_TTL', '1')
+if MODELS_CACHE_TTL == '':
     MODELS_CACHE_TTL = None
 else:
     try:
@@ -676,30 +604,23 @@ def parse_section(section):
 ####################################
 
 ENABLE_CHAT_RESPONSE_BASE64_IMAGE_URL_CONVERSION = (
-    os.environ.get("ENABLE_CHAT_RESPONSE_BASE64_IMAGE_URL_CONVERSION", "False").lower()
-    == "true"
+    os.environ.get('ENABLE_CHAT_RESPONSE_BASE64_IMAGE_URL_CONVERSION', 'False').lower() == 'true'
 )
 
-CHAT_RESPONSE_STREAM_DELTA_CHUNK_SIZE = os.environ.get(
-    "CHAT_RESPONSE_STREAM_DELTA_CHUNK_SIZE", "1"
-)
+CHAT_RESPONSE_STREAM_DELTA_CHUNK_SIZE = os.environ.get('CHAT_RESPONSE_STREAM_DELTA_CHUNK_SIZE', '1')
 
-if CHAT_RESPONSE_STREAM_DELTA_CHUNK_SIZE == "":
+if CHAT_RESPONSE_STREAM_DELTA_CHUNK_SIZE == '':
     CHAT_RESPONSE_STREAM_DELTA_CHUNK_SIZE = 1
 else:
     try:
-        CHAT_RESPONSE_STREAM_DELTA_CHUNK_SIZE = int(
-            CHAT_RESPONSE_STREAM_DELTA_CHUNK_SIZE
-        )
+        CHAT_RESPONSE_STREAM_DELTA_CHUNK_SIZE = int(CHAT_RESPONSE_STREAM_DELTA_CHUNK_SIZE)
     except Exception:
         CHAT_RESPONSE_STREAM_DELTA_CHUNK_SIZE = 1
 
 
-CHAT_RESPONSE_MAX_TOOL_CALL_RETRIES = os.environ.get(
-    "CHAT_RESPONSE_MAX_TOOL_CALL_RETRIES", "30"
-)
+CHAT_RESPONSE_MAX_TOOL_CALL_RETRIES = os.environ.get('CHAT_RESPONSE_MAX_TOOL_CALL_RETRIES', '30')
 
-if CHAT_RESPONSE_MAX_TOOL_CALL_RETRIES == "":
+if CHAT_RESPONSE_MAX_TOOL_CALL_RETRIES == '':
     CHAT_RESPONSE_MAX_TOOL_CALL_RETRIES = 30
 else:
     try:
@@ -708,17 +629,13 @@ def parse_section(section):
         CHAT_RESPONSE_MAX_TOOL_CALL_RETRIES = 30
 
 
-CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE = os.environ.get(
-    "CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE", ""
-)
+CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE = os.environ.get('CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE', '')
 
-if CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE == "":
+if CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE == '':
     CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE = None
 else:
     try:
-        CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE = int(
-            CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE
-        )
+        CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE = int(CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE)
     except Exception:
         CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE = None
 
@@ -727,70 +644,62 @@ def parse_section(section):
 # WEBSOCKET SUPPORT
 ####################################
 
-ENABLE_WEBSOCKET_SUPPORT = (
-    os.environ.get("ENABLE_WEBSOCKET_SUPPORT", "True").lower() == "true"
-)
+ENABLE_WEBSOCKET_SUPPORT = os.environ.get('ENABLE_WEBSOCKET_SUPPORT', 'True').lower() == 'true'
 
 
-WEBSOCKET_MANAGER = os.environ.get("WEBSOCKET_MANAGER", "")
+WEBSOCKET_MANAGER = os.environ.get('WEBSOCKET_MANAGER', '')
 
-WEBSOCKET_REDIS_OPTIONS = os.environ.get("WEBSOCKET_REDIS_OPTIONS", "")
+WEBSOCKET_REDIS_OPTIONS = os.environ.get('WEBSOCKET_REDIS_OPTIONS', '')
 
 
-if WEBSOCKET_REDIS_OPTIONS == "":
+if WEBSOCKET_REDIS_OPTIONS == '':
     if REDIS_SOCKET_CONNECT_TIMEOUT:
-        WEBSOCKET_REDIS_OPTIONS = {
-            "socket_connect_timeout": REDIS_SOCKET_CONNECT_TIMEOUT
-        }
+        WEBSOCKET_REDIS_OPTIONS = {'socket_connect_timeout': REDIS_SOCKET_CONNECT_TIMEOUT}
     else:
-        log.debug("No WEBSOCKET_REDIS_OPTIONS provided, defaulting to None")
+        log.debug('No WEBSOCKET_REDIS_OPTIONS provided, defaulting to None')
         WEBSOCKET_REDIS_OPTIONS = None
 else:
     try:
         WEBSOCKET_REDIS_OPTIONS = json.loads(WEBSOCKET_REDIS_OPTIONS)
     except Exception:
-        log.warning("Invalid WEBSOCKET_REDIS_OPTIONS, defaulting to None")
+        log.warning('Invalid WEBSOCKET_REDIS_OPTIONS, defaulting to None')
         WEBSOCKET_REDIS_OPTIONS = None
 
-WEBSOCKET_REDIS_URL = os.environ.get("WEBSOCKET_REDIS_URL", REDIS_URL)
-WEBSOCKET_REDIS_CLUSTER = (
-    os.environ.get("WEBSOCKET_REDIS_CLUSTER", str(REDIS_CLUSTER)).lower() == "true"
-)
+WEBSOCKET_REDIS_URL = os.environ.get('WEBSOCKET_REDIS_URL', REDIS_URL)
+WEBSOCKET_REDIS_CLUSTER = os.environ.get('WEBSOCKET_REDIS_CLUSTER', str(REDIS_CLUSTER)).lower() == 'true'
 
-websocket_redis_lock_timeout = os.environ.get("WEBSOCKET_REDIS_LOCK_TIMEOUT", "60")
+websocket_redis_lock_timeout = os.environ.get('WEBSOCKET_REDIS_LOCK_TIMEOUT', '60')
 
 try:
     WEBSOCKET_REDIS_LOCK_TIMEOUT = int(websocket_redis_lock_timeout)
 except ValueError:
     WEBSOCKET_REDIS_LOCK_TIMEOUT = 60
 
-WEBSOCKET_SENTINEL_HOSTS = os.environ.get("WEBSOCKET_SENTINEL_HOSTS", "")
-WEBSOCKET_SENTINEL_PORT = os.environ.get("WEBSOCKET_SENTINEL_PORT", "26379")
-WEBSOCKET_SERVER_LOGGING = (
-    os.environ.get("WEBSOCKET_SERVER_LOGGING", "False").lower() == "true"
-)
+WEBSOCKET_SENTINEL_HOSTS = os.environ.get('WEBSOCKET_SENTINEL_HOSTS', '')
+WEBSOCKET_SENTINEL_PORT = os.environ.get('WEBSOCKET_SENTINEL_PORT', '26379')
+WEBSOCKET_SERVER_LOGGING = os.environ.get('WEBSOCKET_SERVER_LOGGING', 'False').lower() == 'true'
 WEBSOCKET_SERVER_ENGINEIO_LOGGING = (
     os.environ.get(
-        "WEBSOCKET_SERVER_ENGINEIO_LOGGING",
-        os.environ.get("WEBSOCKET_SERVER_LOGGING", "False"),
+        'WEBSOCKET_SERVER_ENGINEIO_LOGGING',
+        os.environ.get('WEBSOCKET_SERVER_LOGGING', 'False'),
     ).lower()
-    == "true"
+    == 'true'
 )
-WEBSOCKET_SERVER_PING_TIMEOUT = os.environ.get("WEBSOCKET_SERVER_PING_TIMEOUT", "20")
+WEBSOCKET_SERVER_PING_TIMEOUT = os.environ.get('WEBSOCKET_SERVER_PING_TIMEOUT', '20')
 try:
     WEBSOCKET_SERVER_PING_TIMEOUT = int(WEBSOCKET_SERVER_PING_TIMEOUT)
 except ValueError:
     WEBSOCKET_SERVER_PING_TIMEOUT = 20
 
-WEBSOCKET_SERVER_PING_INTERVAL = os.environ.get("WEBSOCKET_SERVER_PING_INTERVAL", "25")
+WEBSOCKET_SERVER_PING_INTERVAL = os.environ.get('WEBSOCKET_SERVER_PING_INTERVAL', '25')
 try:
     WEBSOCKET_SERVER_PING_INTERVAL = int(WEBSOCKET_SERVER_PING_INTERVAL)
 except ValueError:
     WEBSOCKET_SERVER_PING_INTERVAL = 25
 
-WEBSOCKET_EVENT_CALLER_TIMEOUT = os.environ.get("WEBSOCKET_EVENT_CALLER_TIMEOUT", "")
+WEBSOCKET_EVENT_CALLER_TIMEOUT = os.environ.get('WEBSOCKET_EVENT_CALLER_TIMEOUT', '')
 
-if WEBSOCKET_EVENT_CALLER_TIMEOUT == "":
+if WEBSOCKET_EVENT_CALLER_TIMEOUT == '':
     WEBSOCKET_EVENT_CALLER_TIMEOUT = None
 else:
     try:
@@ -799,11 +708,11 @@ def parse_section(section):
         WEBSOCKET_EVENT_CALLER_TIMEOUT = 300
 
 
-REQUESTS_VERIFY = os.environ.get("REQUESTS_VERIFY", "True").lower() == "true"
+REQUESTS_VERIFY = os.environ.get('REQUESTS_VERIFY', 'True').lower() == 'true'
 
-AIOHTTP_CLIENT_TIMEOUT = os.environ.get("AIOHTTP_CLIENT_TIMEOUT", "")
+AIOHTTP_CLIENT_TIMEOUT = os.environ.get('AIOHTTP_CLIENT_TIMEOUT', '')
 
-if AIOHTTP_CLIENT_TIMEOUT == "":
+if AIOHTTP_CLIENT_TIMEOUT == '':
     AIOHTTP_CLIENT_TIMEOUT = None
 else:
     try:
@@ -812,16 +721,14 @@ def parse_section(section):
         AIOHTTP_CLIENT_TIMEOUT = 300
 
 
-AIOHTTP_CLIENT_SESSION_SSL = (
-    os.environ.get("AIOHTTP_CLIENT_SESSION_SSL", "True").lower() == "true"
-)
+AIOHTTP_CLIENT_SESSION_SSL = os.environ.get('AIOHTTP_CLIENT_SESSION_SSL', 'True').lower() == 'true'
 
 AIOHTTP_CLIENT_TIMEOUT_MODEL_LIST = os.environ.get(
-    "AIOHTTP_CLIENT_TIMEOUT_MODEL_LIST",
-    os.environ.get("AIOHTTP_CLIENT_TIMEOUT_OPENAI_MODEL_LIST", "10"),
+    'AIOHTTP_CLIENT_TIMEOUT_MODEL_LIST',
+    os.environ.get('AIOHTTP_CLIENT_TIMEOUT_OPENAI_MODEL_LIST', '10'),
 )
 
-if AIOHTTP_CLIENT_TIMEOUT_MODEL_LIST == "":
+if AIOHTTP_CLIENT_TIMEOUT_MODEL_LIST == '':
     AIOHTTP_CLIENT_TIMEOUT_MODEL_LIST = None
 else:
     try:
@@ -830,29 +737,25 @@ def parse_section(section):
         AIOHTTP_CLIENT_TIMEOUT_MODEL_LIST = 10
 
 
-AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER_DATA = os.environ.get(
-    "AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER_DATA", "10"
-)
+AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER_DATA = os.environ.get('AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER_DATA', '10')
 
-if AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER_DATA == "":
+if AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER_DATA == '':
     AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER_DATA = None
 else:
     try:
-        AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER_DATA = int(
-            AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER_DATA
-        )
+        AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER_DATA = int(AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER_DATA)
     except Exception:
         AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER_DATA = 10
 
 
 AIOHTTP_CLIENT_SESSION_TOOL_SERVER_SSL = (
-    os.environ.get("AIOHTTP_CLIENT_SESSION_TOOL_SERVER_SSL", "True").lower() == "true"
+    os.environ.get('AIOHTTP_CLIENT_SESSION_TOOL_SERVER_SSL', 'True').lower() == 'true'
 )
 
 
-RAG_EMBEDDING_TIMEOUT = os.environ.get("RAG_EMBEDDING_TIMEOUT", "")
+RAG_EMBEDDING_TIMEOUT = os.environ.get('RAG_EMBEDDING_TIMEOUT', '')
 
-if RAG_EMBEDDING_TIMEOUT == "":
+if RAG_EMBEDDING_TIMEOUT == '':
     RAG_EMBEDDING_TIMEOUT = None
 else:
     try:
@@ -866,210 +769,158 @@ def parse_section(section):
 ####################################
 
 
-SENTENCE_TRANSFORMERS_BACKEND = os.environ.get("SENTENCE_TRANSFORMERS_BACKEND", "")
-if SENTENCE_TRANSFORMERS_BACKEND == "":
-    SENTENCE_TRANSFORMERS_BACKEND = "torch"
+SENTENCE_TRANSFORMERS_BACKEND = os.environ.get('SENTENCE_TRANSFORMERS_BACKEND', '')
+if SENTENCE_TRANSFORMERS_BACKEND == '':
+    SENTENCE_TRANSFORMERS_BACKEND = 'torch'
 
 
-SENTENCE_TRANSFORMERS_MODEL_KWARGS = os.environ.get(
-    "SENTENCE_TRANSFORMERS_MODEL_KWARGS", ""
-)
-if SENTENCE_TRANSFORMERS_MODEL_KWARGS == "":
+SENTENCE_TRANSFORMERS_MODEL_KWARGS = os.environ.get('SENTENCE_TRANSFORMERS_MODEL_KWARGS', '')
+if SENTENCE_TRANSFORMERS_MODEL_KWARGS == '':
     SENTENCE_TRANSFORMERS_MODEL_KWARGS = None
 else:
     try:
-        SENTENCE_TRANSFORMERS_MODEL_KWARGS = json.loads(
-            SENTENCE_TRANSFORMERS_MODEL_KWARGS
-        )
+        SENTENCE_TRANSFORMERS_MODEL_KWARGS = json.loads(SENTENCE_TRANSFORMERS_MODEL_KWARGS)
     except Exception:
         SENTENCE_TRANSFORMERS_MODEL_KWARGS = None
 
 
-SENTENCE_TRANSFORMERS_CROSS_ENCODER_BACKEND = os.environ.get(
-    "SENTENCE_TRANSFORMERS_CROSS_ENCODER_BACKEND", ""
-)
-if SENTENCE_TRANSFORMERS_CROSS_ENCODER_BACKEND == "":
-    SENTENCE_TRANSFORMERS_CROSS_ENCODER_BACKEND = "torch"
+SENTENCE_TRANSFORMERS_CROSS_ENCODER_BACKEND = os.environ.get('SENTENCE_TRANSFORMERS_CROSS_ENCODER_BACKEND', '')
+if SENTENCE_TRANSFORMERS_CROSS_ENCODER_BACKEND == '':
+    SENTENCE_TRANSFORMERS_CROSS_ENCODER_BACKEND = 'torch'
 
 
 SENTENCE_TRANSFORMERS_CROSS_ENCODER_MODEL_KWARGS = os.environ.get(
-    "SENTENCE_TRANSFORMERS_CROSS_ENCODER_MODEL_KWARGS", ""
+    'SENTENCE_TRANSFORMERS_CROSS_ENCODER_MODEL_KWARGS', ''
 )
-if SENTENCE_TRANSFORMERS_CROSS_ENCODER_MODEL_KWARGS == "":
+if SENTENCE_TRANSFORMERS_CROSS_ENCODER_MODEL_KWARGS == '':
     SENTENCE_TRANSFORMERS_CROSS_ENCODER_MODEL_KWARGS = None
 else:
     try:
-        SENTENCE_TRANSFORMERS_CROSS_ENCODER_MODEL_KWARGS = json.loads(
-            SENTENCE_TRANSFORMERS_CROSS_ENCODER_MODEL_KWARGS
-        )
+        SENTENCE_TRANSFORMERS_CROSS_ENCODER_MODEL_KWARGS = json.loads(SENTENCE_TRANSFORMERS_CROSS_ENCODER_MODEL_KWARGS)
     except Exception:
         SENTENCE_TRANSFORMERS_CROSS_ENCODER_MODEL_KWARGS = None
 
 # Whether to apply sigmoid normalization to CrossEncoder reranking scores.
 # When enabled (default), scores are normalized to 0-1 range for proper
 # relevance threshold behavior with MS MARCO models.
 SENTENCE_TRANSFORMERS_CROSS_ENCODER_SIGMOID_ACTIVATION_FUNCTION = (
-    os.environ.get(
-        "SENTENCE_TRANSFORMERS_CROSS_ENCODER_SIGMOID_ACTIVATION_FUNCTION", "True"
-    ).lower()
-    == "true"
+    os.environ.get('SENTENCE_TRANSFORMERS_CROSS_ENCODER_SIGMOID_ACTIVATION_FUNCTION', 'True').lower() == 'true'
 )
 
 ####################################
 # OFFLINE_MODE
 ####################################
 
-ENABLE_VERSION_UPDATE_CHECK = (
-    os.environ.get("ENABLE_VERSION_UPDATE_CHECK", "true").lower() == "true"
-)
-OFFLINE_MODE = os.environ.get("OFFLINE_MODE", "false").lower() == "true"
+ENABLE_VERSION_UPDATE_CHECK = os.environ.get('ENABLE_VERSION_UPDATE_CHECK', 'true').lower() == 'true'
+OFFLINE_MODE = os.environ.get('OFFLINE_MODE', 'false').lower() == 'true'
 
 if OFFLINE_MODE:
-    os.environ["HF_HUB_OFFLINE"] = "1"
+    os.environ['HF_HUB_OFFLINE'] = '1'
     ENABLE_VERSION_UPDATE_CHECK = False
 
 ####################################
 # AUDIT LOGGING
 ####################################
 
 
-ENABLE_AUDIT_STDOUT = os.getenv("ENABLE_AUDIT_STDOUT", "False").lower() == "true"
-ENABLE_AUDIT_LOGS_FILE = os.getenv("ENABLE_AUDIT_LOGS_FILE", "True").lower() == "true"
+ENABLE_AUDIT_STDOUT = os.getenv('ENABLE_AUDIT_STDOUT', 'False').lower() == 'true'
+ENABLE_AUDIT_LOGS_FILE = os.getenv('ENABLE_AUDIT_LOGS_FILE', 'True').lower() == 'true'
 
 # Where to store log file
 # Defaults to the DATA_DIR/audit.log. To set AUDIT_LOGS_FILE_PATH you need to
 # provide the whole path, like: /app/audit.log
-AUDIT_LOGS_FILE_PATH = os.getenv("AUDIT_LOGS_FILE_PATH", f"{DATA_DIR}/audit.log")
+AUDIT_LOGS_FILE_PATH = os.getenv('AUDIT_LOGS_FILE_PATH', f'{DATA_DIR}/audit.log')
 # Maximum size of a file before rotating into a new log file
-AUDIT_LOG_FILE_ROTATION_SIZE = os.getenv("AUDIT_LOG_FILE_ROTATION_SIZE", "10MB")
+AUDIT_LOG_FILE_ROTATION_SIZE = os.getenv('AUDIT_LOG_FILE_ROTATION_SIZE', '10MB')
 
 # Comma separated list of logger names to use for audit logging
 # Default is "uvicorn.access" which is the access log for Uvicorn
 # You can add more logger names to this list if you want to capture more logs
-AUDIT_UVICORN_LOGGER_NAMES = os.getenv(
-    "AUDIT_UVICORN_LOGGER_NAMES", "uvicorn.access"
-).split(",")
+AUDIT_UVICORN_LOGGER_NAMES = os.getenv('AUDIT_UVICORN_LOGGER_NAMES', 'uvicorn.access').split(',')
 
 # METADATA | REQUEST | REQUEST_RESPONSE
-AUDIT_LOG_LEVEL = os.getenv("AUDIT_LOG_LEVEL", "NONE").upper()
+AUDIT_LOG_LEVEL = os.getenv('AUDIT_LOG_LEVEL', 'NONE').upper()
 try:
-    MAX_BODY_LOG_SIZE = int(os.environ.get("MAX_BODY_LOG_SIZE") or 2048)
+    MAX_BODY_LOG_SIZE = int(os.environ.get('MAX_BODY_LOG_SIZE') or 2048)
 except ValueError:
     MAX_BODY_LOG_SIZE = 2048
 
 # Comma separated list for urls to exclude from audit
-AUDIT_EXCLUDED_PATHS = os.getenv("AUDIT_EXCLUDED_PATHS", "/chats,/chat,/folders").split(
-    ","
-)
+AUDIT_EXCLUDED_PATHS = os.getenv('AUDIT_EXCLUDED_PATHS', '/chats,/chat,/folders').split(',')
 AUDIT_EXCLUDED_PATHS = [path.strip() for path in AUDIT_EXCLUDED_PATHS]
-AUDIT_EXCLUDED_PATHS = [path.lstrip("/") for path in AUDIT_EXCLUDED_PATHS]
+AUDIT_EXCLUDED_PATHS = [path.lstrip('/') for path in AUDIT_EXCLUDED_PATHS]
 
 # Comma separated list of urls to include in audit (whitelist mode)
 # When set, only these paths are audited and AUDIT_EXCLUDED_PATHS is ignored
-AUDIT_INCLUDED_PATHS = os.getenv("AUDIT_INCLUDED_PATHS", "").split(",")
+AUDIT_INCLUDED_PATHS = os.getenv('AUDIT_INCLUDED_PATHS', '').split(',')
 AUDIT_INCLUDED_PATHS = [path.strip() for path in AUDIT_INCLUDED_PATHS]
-AUDIT_INCLUDED_PATHS = [path.lstrip("/") for path in AUDIT_INCLUDED_PATHS if path]
+AUDIT_INCLUDED_PATHS = [path.lstrip('/') for path in AUDIT_INCLUDED_PATHS if path]
 
 
 ####################################
 # OPENTELEMETRY
 ####################################
 
-ENABLE_OTEL = os.environ.get("ENABLE_OTEL", "False").lower() == "true"
-ENABLE_OTEL_TRACES = os.environ.get("ENABLE_OTEL_TRACES", "False").lower() == "true"
-ENABLE_OTEL_METRICS = os.environ.get("ENABLE_OTEL_METRICS", "False").lower() == "true"
-ENABLE_OTEL_LOGS = os.environ.get("ENABLE_OTEL_LOGS", "False").lower() == "true"
+ENABLE_OTEL = os.environ.get('ENABLE_OTEL', 'False').lower() == 'true'
+ENABLE_OTEL_TRACES = os.environ.get('ENABLE_OTEL_TRACES', 'False').lower() == 'true'
+ENABLE_OTEL_METRICS = os.environ.get('ENABLE_OTEL_METRICS', 'False').lower() == 'true'
+ENABLE_OTEL_LOGS = os.environ.get('ENABLE_OTEL_LOGS', 'False').lower() == 'true'
 
-OTEL_EXPORTER_OTLP_ENDPOINT = os.environ.get(
-    "OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4317"
-)
-OTEL_METRICS_EXPORTER_OTLP_ENDPOINT = os.environ.get(
-    "OTEL_METRICS_EXPORTER_OTLP_ENDPOINT", OTEL_EXPORTER_OTLP_ENDPOINT
-)
-OTEL_LOGS_EXPORTER_OTLP_ENDPOINT = os.environ.get(
-    "OTEL_LOGS_EXPORTER_OTLP_ENDPOINT", OTEL_EXPORTER_OTLP_ENDPOINT
-)
-OTEL_EXPORTER_OTLP_INSECURE = (
-    os.environ.get("OTEL_EXPORTER_OTLP_INSECURE", "False").lower() == "true"
-)
+OTEL_EXPORTER_OTLP_ENDPOINT = os.environ.get('OTEL_EXPORTER_OTLP_ENDPOINT', 'http://localhost:4317')
+OTEL_METRICS_EXPORTER_OTLP_ENDPOINT = os.environ.get('OTEL_METRICS_EXPORTER_OTLP_ENDPOINT', OTEL_EXPORTER_OTLP_ENDPOINT)
+OTEL_LOGS_EXPORTER_OTLP_ENDPOINT = os.environ.get('OTEL_LOGS_EXPORTER_OTLP_ENDPOINT', OTEL_EXPORTER_OTLP_ENDPOINT)
+OTEL_EXPORTER_OTLP_INSECURE = os.environ.get('OTEL_EXPORTER_OTLP_INSECURE', 'False').lower() == 'true'
 OTEL_METRICS_EXPORTER_OTLP_INSECURE = (
-    os.environ.get(
-        "OTEL_METRICS_EXPORTER_OTLP_INSECURE", str(OTEL_EXPORTER_OTLP_INSECURE)
-    ).lower()
-    == "true"
+    os.environ.get('OTEL_METRICS_EXPORTER_OTLP_INSECURE', str(OTEL_EXPORTER_OTLP_INSECURE)).lower() == 'true'
 )
 OTEL_LOGS_EXPORTER_OTLP_INSECURE = (
-    os.environ.get(
-        "OTEL_LOGS_EXPORTER_OTLP_INSECURE", str(OTEL_EXPORTER_OTLP_INSECURE)
-    ).lower()
-    == "true"
-)
-OTEL_SERVICE_NAME = os.environ.get("OTEL_SERVICE_NAME", "open-webui")
-OTEL_RESOURCE_ATTRIBUTES = os.environ.get(
-    "OTEL_RESOURCE_ATTRIBUTES", ""
-)  # e.g. key1=val1,key2=val2
-OTEL_TRACES_SAMPLER = os.environ.get(
-    "OTEL_TRACES_SAMPLER", "parentbased_always_on"
-).lower()
-OTEL_BASIC_AUTH_USERNAME = os.environ.get("OTEL_BASIC_AUTH_USERNAME", "")
-OTEL_BASIC_AUTH_PASSWORD = os.environ.get("OTEL_BASIC_AUTH_PASSWORD", "")
-OTEL_METRICS_EXPORT_INTERVAL_MILLIS = int(
-    os.environ.get("OTEL_METRICS_EXPORT_INTERVAL_MILLIS", "10000")
+    os.environ.get('OTEL_LOGS_EXPORTER_OTLP_INSECURE', str(OTEL_EXPORTER_OTLP_INSECURE)).lower() == 'true'
 )
+OTEL_SERVICE_NAME = os.environ.get('OTEL_SERVICE_NAME', 'open-webui')
+OTEL_RESOURCE_ATTRIBUTES = os.environ.get('OTEL_RESOURCE_ATTRIBUTES', '')  # e.g. key1=val1,key2=val2
+OTEL_TRACES_SAMPLER = os.environ.get('OTEL_TRACES_SAMPLER', 'parentbased_always_on').lower()
+OTEL_BASIC_AUTH_USERNAME = os.environ.get('OTEL_BASIC_AUTH_USERNAME', '')
+OTEL_BASIC_AUTH_PASSWORD = os.environ.get('OTEL_BASIC_AUTH_PASSWORD', '')
+OTEL_METRICS_EXPORT_INTERVAL_MILLIS = int(os.environ.get('OTEL_METRICS_EXPORT_INTERVAL_MILLIS', '10000'))
 
-OTEL_METRICS_BASIC_AUTH_USERNAME = os.environ.get(
-    "OTEL_METRICS_BASIC_AUTH_USERNAME", OTEL_BASIC_AUTH_USERNAME
-)
-OTEL_METRICS_BASIC_AUTH_PASSWORD = os.environ.get(
-    "OTEL_METRICS_BASIC_AUTH_PASSWORD", OTEL_BASIC_AUTH_PASSWORD
-)
-OTEL_LOGS_BASIC_AUTH_USERNAME = os.environ.get(
-    "OTEL_LOGS_BASIC_AUTH_USERNAME", OTEL_BASIC_AUTH_USERNAME
-)
-OTEL_LOGS_BASIC_AUTH_PASSWORD = os.environ.get(
-    "OTEL_LOGS_BASIC_AUTH_PASSWORD", OTEL_BASIC_AUTH_PASSWORD
-)
+OTEL_METRICS_BASIC_AUTH_USERNAME = os.environ.get('OTEL_METRICS_BASIC_AUTH_USERNAME', OTEL_BASIC_AUTH_USERNAME)
+OTEL_METRICS_BASIC_AUTH_PASSWORD = os.environ.get('OTEL_METRICS_BASIC_AUTH_PASSWORD', OTEL_BASIC_AUTH_PASSWORD)
+OTEL_LOGS_BASIC_AUTH_USERNAME = os.environ.get('OTEL_LOGS_BASIC_AUTH_USERNAME', OTEL_BASIC_AUTH_USERNAME)
+OTEL_LOGS_BASIC_AUTH_PASSWORD = os.environ.get('OTEL_LOGS_BASIC_AUTH_PASSWORD', OTEL_BASIC_AUTH_PASSWORD)
 
-OTEL_OTLP_SPAN_EXPORTER = os.environ.get(
-    "OTEL_OTLP_SPAN_EXPORTER", "grpc"
-).lower()  # grpc or http
+OTEL_OTLP_SPAN_EXPORTER = os.environ.get('OTEL_OTLP_SPAN_EXPORTER', 'grpc').lower()  # grpc or http
 
 OTEL_METRICS_OTLP_SPAN_EXPORTER = os.environ.get(
-    "OTEL_METRICS_OTLP_SPAN_EXPORTER", OTEL_OTLP_SPAN_EXPORTER
+    'OTEL_METRICS_OTLP_SPAN_EXPORTER', OTEL_OTLP_SPAN_EXPORTER
 ).lower()  # grpc or http
 
 OTEL_LOGS_OTLP_SPAN_EXPORTER = os.environ.get(
-    "OTEL_LOGS_OTLP_SPAN_EXPORTER", OTEL_OTLP_SPAN_EXPORTER
+    'OTEL_LOGS_OTLP_SPAN_EXPORTER', OTEL_OTLP_SPAN_EXPORTER
 ).lower()  # grpc or http
 
 ####################################
 # TOOLS/FUNCTIONS PIP OPTIONS
 ####################################
 
 ENABLE_PIP_INSTALL_FRONTMATTER_REQUIREMENTS = (
-    os.environ.get("ENABLE_PIP_INSTALL_FRONTMATTER_REQUIREMENTS", "True").lower()
-    == "true"
+    os.environ.get('ENABLE_PIP_INSTALL_FRONTMATTER_REQUIREMENTS', 'True').lower() == 'true'
 )
 
-PIP_OPTIONS = os.getenv("PIP_OPTIONS", "").split()
-PIP_PACKAGE_INDEX_OPTIONS = os.getenv("PIP_PACKAGE_INDEX_OPTIONS", "").split()
+PIP_OPTIONS = os.getenv('PIP_OPTIONS', '').split()
+PIP_PACKAGE_INDEX_OPTIONS = os.getenv('PIP_PACKAGE_INDEX_OPTIONS', '').split()
 
 
 ####################################
 # PROGRESSIVE WEB APP OPTIONS
 ####################################
 
-EXTERNAL_PWA_MANIFEST_URL = os.environ.get("EXTERNAL_PWA_MANIFEST_URL")
+EXTERNAL_PWA_MANIFEST_URL = os.environ.get('EXTERNAL_PWA_MANIFEST_URL')
 
 ####################################
 # GROUP DEFAULTS
 ####################################
 
 # Controls the default "Who can share to this group" setting for new groups.
 # Env var values: "true" (anyone), "false" (no one), "members" (only group members).
-_default_group_share = (
-    os.environ.get("DEFAULT_GROUP_SHARE_PERMISSION", "members").strip().lower()
-)
-DEFAULT_GROUP_SHARE_PERMISSION = (
-    "members" if _default_group_share == "members" else _default_group_share == "true"
-)
+_default_group_share = os.environ.get('DEFAULT_GROUP_SHARE_PERMISSION', 'members').strip().lower()
+DEFAULT_GROUP_SHARE_PERMISSION = 'members' if _default_group_share == 'members' else _default_group_share == 'true'

@@ -57,17 +57,15 @@
 def get_function_module_by_id(request: Request, pipe_id: str):
     function_module, _, _ = get_function_module_from_cache(request, pipe_id)
 
-    if hasattr(function_module, "valves") and hasattr(function_module, "Valves"):
+    if hasattr(function_module, 'valves') and hasattr(function_module, 'Valves'):
         Valves = function_module.Valves
         valves = Functions.get_function_valves_by_id(pipe_id)
 
         if valves:
             try:
-                function_module.valves = Valves(
-                    **{k: v for k, v in valves.items() if v is not None}
-                )
+                function_module.valves = Valves(**{k: v for k, v in valves.items() if v is not None})
             except Exception as e:
-                log.exception(f"Error loading valves for function {pipe_id}: {e}")
+                log.exception(f'Error loading valves for function {pipe_id}: {e}')
                 raise e
         else:
             function_module.valves = Valves()
@@ -76,19 +74,19 @@ def get_function_module_by_id(request: Request, pipe_id: str):
 
 
 async def get_function_models(request):
-    pipes = Functions.get_functions_by_type("pipe", active_only=True)
+    pipes = Functions.get_functions_by_type('pipe', active_only=True)
     pipe_models = []
 
     for pipe in pipes:
         try:
             function_module = get_function_module_by_id(request, pipe.id)
 
             has_user_valves = False
-            if hasattr(function_module, "UserValves"):
+            if hasattr(function_module, 'UserValves'):
                 has_user_valves = True
 
             # Check if function is a manifold
-            if hasattr(function_module, "pipes"):
+            if hasattr(function_module, 'pipes'):
                 sub_pipes = []
 
                 # Handle pipes being a list, sync function, or async function
@@ -104,46 +102,44 @@ async def get_function_models(request):
                     log.exception(e)
                     sub_pipes = []
 
-                log.debug(
-                    f"get_function_models: function '{pipe.id}' is a manifold of {sub_pipes}"
-                )
+                log.debug(f"get_function_models: function '{pipe.id}' is a manifold of {sub_pipes}")
 
                 for p in sub_pipes:
                     sub_pipe_id = f'{pipe.id}.{p["id"]}'
-                    sub_pipe_name = p["name"]
+                    sub_pipe_name = p['name']
 
-                    if hasattr(function_module, "name"):
-                        sub_pipe_name = f"{function_module.name}{sub_pipe_name}"
+                    if hasattr(function_module, 'name'):
+                        sub_pipe_name = f'{function_module.name}{sub_pipe_name}'
 
-                    pipe_flag = {"type": pipe.type}
+                    pipe_flag = {'type': pipe.type}
 
                     pipe_models.append(
                         {
-                            "id": sub_pipe_id,
-                            "name": sub_pipe_name,
-                            "object": "model",
-                            "created": pipe.created_at,
-                            "owned_by": "openai",
-                            "pipe": pipe_flag,
-                            "has_user_valves": has_user_valves,
+                            'id': sub_pipe_id,
+                            'name': sub_pipe_name,
+                            'object': 'model',
+                            'created': pipe.created_at,
+                            'owned_by': 'openai',
+                            'pipe': pipe_flag,
+                            'has_user_valves': has_user_valves,
                         }
                     )
             else:
-                pipe_flag = {"type": "pipe"}
+                pipe_flag = {'type': 'pipe'}
 
                 log.debug(
                     f"get_function_models: function '{pipe.id}' is a single pipe {{ 'id': {pipe.id}, 'name': {pipe.name} }}"
                 )
 
                 pipe_models.append(
                     {
-                        "id": pipe.id,
-                        "name": pipe.name,
-                        "object": "model",
-                        "created": pipe.created_at,
-                        "owned_by": "openai",
-                        "pipe": pipe_flag,
-                        "has_user_valves": has_user_valves,
+                        'id': pipe.id,
+                        'name': pipe.name,
+                        'object': 'model',
+                        'created': pipe.created_at,
+                        'owned_by': 'openai',
+                        'pipe': pipe_flag,
+                        'has_user_valves': has_user_valves,
                     }
                 )
         except Exception as e:
@@ -153,9 +149,7 @@ async def get_function_models(request):
     return pipe_models
 
 
-async def generate_function_chat_completion(
-    request, form_data, user, models: dict = {}
-):
+async def generate_function_chat_completion(request, form_data, user, models: dict = {}):
     async def execute_pipe(pipe, params):
         if inspect.iscoroutinefunction(pipe):
             return await pipe(**params)
@@ -166,32 +160,32 @@ async def get_message_content(res: str | Generator | AsyncGenerator) -> str:
         if isinstance(res, str):
             return res
         if isinstance(res, Generator):
-            return "".join(map(str, res))
+            return ''.join(map(str, res))
         if isinstance(res, AsyncGenerator):
-            return "".join([str(stream) async for stream in res])
+            return ''.join([str(stream) async for stream in res])
 
     def process_line(form_data: dict, line):
         if isinstance(line, BaseModel):
             line = line.model_dump_json()
-            line = f"data: {line}"
+            line = f'data: {line}'
         if isinstance(line, dict):
-            line = f"data: {json.dumps(line)}"
+            line = f'data: {json.dumps(line)}'
 
         try:
-            line = line.decode("utf-8")
+            line = line.decode('utf-8')
         except Exception:
             pass
 
-        if line.startswith("data:"):
-            return f"{line}\n\n"
+        if line.startswith('data:'):
+            return f'{line}\n\n'
         else:
-            line = openai_chat_chunk_message_template(form_data["model"], line)
-            return f"data: {json.dumps(line)}\n\n"
+            line = openai_chat_chunk_message_template(form_data['model'], line)
+            return f'data: {json.dumps(line)}\n\n'
 
     def get_pipe_id(form_data: dict) -> str:
-        pipe_id = form_data["model"]
-        if "." in pipe_id:
-            pipe_id, _ = pipe_id.split(".", 1)
+        pipe_id = form_data['model']
+        if '.' in pipe_id:
+            pipe_id, _ = pipe_id.split('.', 1)
         return pipe_id
 
     def get_function_params(function_module, form_data, user, extra_params=None):
@@ -202,27 +196,25 @@ def get_function_params(function_module, form_data, user, extra_params=None):
 
         # Get the signature of the function
         sig = inspect.signature(function_module.pipe)
-        params = {"body": form_data} | {
-            k: v for k, v in extra_params.items() if k in sig.parameters
-        }
+        params = {'body': form_data} | {k: v for k, v in extra_params.items() if k in sig.parameters}
 
-        if "__user__" in params and hasattr(function_module, "UserValves"):
+        if '__user__' in params and hasattr(function_module, 'UserValves'):
             user_valves = Functions.get_user_valves_by_id_and_user_id(pipe_id, user.id)
             try:
-                params["__user__"]["valves"] = function_module.UserValves(**user_valves)
+                params['__user__']['valves'] = function_module.UserValves(**user_valves)
             except Exception as e:
                 log.exception(e)
-                params["__user__"]["valves"] = function_module.UserValves()
+                params['__user__']['valves'] = function_module.UserValves()
 
         return params
 
-    model_id = form_data.get("model")
+    model_id = form_data.get('model')
     model_info = Models.get_model_by_id(model_id)
 
-    metadata = form_data.pop("metadata", {})
+    metadata = form_data.pop('metadata', {})
 
-    files = metadata.get("files", [])
-    tool_ids = metadata.get("tool_ids", [])
+    files = metadata.get('files', [])
+    tool_ids = metadata.get('tool_ids', [])
     # Check if tool_ids is None
     if tool_ids is None:
         tool_ids = []
@@ -233,56 +225,56 @@ def get_function_params(function_module, form_data, user, extra_params=None):
     __task_body__ = None
 
     if metadata:
-        if all(k in metadata for k in ("session_id", "chat_id", "message_id")):
+        if all(k in metadata for k in ('session_id', 'chat_id', 'message_id')):
             __event_emitter__ = get_event_emitter(metadata)
             __event_call__ = get_event_call(metadata)
-        __task__ = metadata.get("task", None)
-        __task_body__ = metadata.get("task_body", None)
+        __task__ = metadata.get('task', None)
+        __task_body__ = metadata.get('task_body', None)
 
     oauth_token = None
     try:
-        if request.cookies.get("oauth_session_id", None):
+        if request.cookies.get('oauth_session_id', None):
             oauth_token = await request.app.state.oauth_manager.get_oauth_token(
                 user.id,
-                request.cookies.get("oauth_session_id", None),
+                request.cookies.get('oauth_session_id', None),
             )
     except Exception as e:
-        log.error(f"Error getting OAuth token: {e}")
+        log.error(f'Error getting OAuth token: {e}')
 
     extra_params = {
-        "__event_emitter__": __event_emitter__,
-        "__event_call__": __event_call__,
-        "__chat_id__": metadata.get("chat_id", None),
-        "__session_id__": metadata.get("session_id", None),
-        "__message_id__": metadata.get("message_id", None),
-        "__task__": __task__,
-        "__task_body__": __task_body__,
-        "__files__": files,
-        "__user__": user.model_dump() if isinstance(user, UserModel) else {},
-        "__metadata__": metadata,
-        "__oauth_token__": oauth_token,
-        "__request__": request,
+        '__event_emitter__': __event_emitter__,
+        '__event_call__': __event_call__,
+        '__chat_id__': metadata.get('chat_id', None),
+        '__session_id__': metadata.get('session_id', None),
+        '__message_id__': metadata.get('message_id', None),
+        '__task__': __task__,
+        '__task_body__': __task_body__,
+        '__files__': files,
+        '__user__': user.model_dump() if isinstance(user, UserModel) else {},
+        '__metadata__': metadata,
+        '__oauth_token__': oauth_token,
+        '__request__': request,
     }
-    extra_params["__tools__"] = await get_tools(
+    extra_params['__tools__'] = await get_tools(
         request,
         tool_ids,
         user,
         {
             **extra_params,
-            "__model__": models.get(form_data["model"], None),
-            "__messages__": form_data["messages"],
-            "__files__": files,
+            '__model__': models.get(form_data['model'], None),
+            '__messages__': form_data['messages'],
+            '__files__': files,
         },
     )
 
     if model_info:
         if model_info.base_model_id:
-            form_data["model"] = model_info.base_model_id
+            form_data['model'] = model_info.base_model_id
 
         params = model_info.params.model_dump()
 
         if params:
-            system = params.pop("system", None)
+            system = params.pop('system', None)
             form_data = apply_model_params_to_body_openai(params, form_data)
             form_data = apply_system_prompt_to_body(system, form_data, metadata, user)
 
@@ -292,7 +284,7 @@ def get_function_params(function_module, form_data, user, extra_params=None):
     pipe = function_module.pipe
     params = get_function_params(function_module, form_data, user, extra_params)
 
-    if form_data.get("stream", False):
+    if form_data.get('stream', False):
 
         async def stream_content():
             try:
@@ -304,17 +296,17 @@ async def stream_content():
                         yield data
                     return
                 if isinstance(res, dict):
-                    yield f"data: {json.dumps(res)}\n\n"
+                    yield f'data: {json.dumps(res)}\n\n'
                     return
 
             except Exception as e:
-                log.error(f"Error: {e}")
-                yield f"data: {json.dumps({'error': {'detail':str(e)}})}\n\n"
+                log.error(f'Error: {e}')
+                yield f'data: {json.dumps({"error": {"detail": str(e)}})}\n\n'
                 return
 
             if isinstance(res, str):
-                message = openai_chat_chunk_message_template(form_data["model"], res)
-                yield f"data: {json.dumps(message)}\n\n"
+                message = openai_chat_chunk_message_template(form_data['model'], res)
+                yield f'data: {json.dumps(message)}\n\n'
 
             if isinstance(res, Iterator):
                 for line in res:
@@ -325,26 +317,24 @@ async def stream_content():
                     yield process_line(form_data, line)
 
             if isinstance(res, str) or isinstance(res, Generator):
-                finish_message = openai_chat_chunk_message_template(
-                    form_data["model"], ""
-                )
-                finish_message["choices"][0]["finish_reason"] = "stop"
-                yield f"data: {json.dumps(finish_message)}\n\n"
-                yield "data: [DONE]"
+                finish_message = openai_chat_chunk_message_template(form_data['model'], '')
+                finish_message['choices'][0]['finish_reason'] = 'stop'
+                yield f'data: {json.dumps(finish_message)}\n\n'
+                yield 'data: [DONE]'
 
-        return StreamingResponse(stream_content(), media_type="text/event-stream")
+        return StreamingResponse(stream_content(), media_type='text/event-stream')
     else:
         try:
             res = await execute_pipe(pipe, params)
 
         except Exception as e:
-            log.error(f"Error: {e}")
-            return {"error": {"detail": str(e)}}
+            log.error(f'Error: {e}')
+            return {'error': {'detail': str(e)}}
 
         if isinstance(res, StreamingResponse) or isinstance(res, dict):
             return res
         if isinstance(res, BaseModel):
             return res.model_dump()
 
         message = await get_message_content(res)
-        return openai_chat_completion_message_template(form_data["model"], message)
+        return openai_chat_completion_message_template(form_data['model'], message)

@@ -10,94 +10,88 @@
 
 app = typer.Typer()
 
-KEY_FILE = Path.cwd() / ".webui_secret_key"
+KEY_FILE = Path.cwd() / '.webui_secret_key'
 
 
 def version_callback(value: bool):
     if value:
         from open_webui.env import VERSION
 
-        typer.echo(f"Open WebUI version: {VERSION}")
+        typer.echo(f'Open WebUI version: {VERSION}')
         raise typer.Exit()
 
 
 @app.command()
 def main(
-    version: Annotated[
-        Optional[bool], typer.Option("--version", callback=version_callback)
-    ] = None,
+    version: Annotated[Optional[bool], typer.Option('--version', callback=version_callback)] = None,
 ):
     pass
 
 
 @app.command()
 def serve(
-    host: str = "0.0.0.0",
+    host: str = '0.0.0.0',
     port: int = 8080,
 ):
-    os.environ["FROM_INIT_PY"] = "true"
-    if os.getenv("WEBUI_SECRET_KEY") is None:
-        typer.echo(
-            "Loading WEBUI_SECRET_KEY from file, not provided as an environment variable."
-        )
+    os.environ['FROM_INIT_PY'] = 'true'
+    if os.getenv('WEBUI_SECRET_KEY') is None:
+        typer.echo('Loading WEBUI_SECRET_KEY from file, not provided as an environment variable.')
         if not KEY_FILE.exists():
-            typer.echo(f"Generating a new secret key and saving it to {KEY_FILE}")
+            typer.echo(f'Generating a new secret key and saving it to {KEY_FILE}')
             KEY_FILE.write_bytes(base64.b64encode(random.randbytes(12)))
-        typer.echo(f"Loading WEBUI_SECRET_KEY from {KEY_FILE}")
-        os.environ["WEBUI_SECRET_KEY"] = KEY_FILE.read_text()
+        typer.echo(f'Loading WEBUI_SECRET_KEY from {KEY_FILE}')
+        os.environ['WEBUI_SECRET_KEY'] = KEY_FILE.read_text()
 
-    if os.getenv("USE_CUDA_DOCKER", "false") == "true":
-        typer.echo(
-            "CUDA is enabled, appending LD_LIBRARY_PATH to include torch/cudnn & cublas libraries."
-        )
-        LD_LIBRARY_PATH = os.getenv("LD_LIBRARY_PATH", "").split(":")
-        os.environ["LD_LIBRARY_PATH"] = ":".join(
+    if os.getenv('USE_CUDA_DOCKER', 'false') == 'true':
+        typer.echo('CUDA is enabled, appending LD_LIBRARY_PATH to include torch/cudnn & cublas libraries.')
+        LD_LIBRARY_PATH = os.getenv('LD_LIBRARY_PATH', '').split(':')
+        os.environ['LD_LIBRARY_PATH'] = ':'.join(
             LD_LIBRARY_PATH
             + [
-                "/usr/local/lib/python3.11/site-packages/torch/lib",
-                "/usr/local/lib/python3.11/site-packages/nvidia/cudnn/lib",
+                '/usr/local/lib/python3.11/site-packages/torch/lib',
+                '/usr/local/lib/python3.11/site-packages/nvidia/cudnn/lib',
             ]
         )
         try:
             import torch
 
-            assert torch.cuda.is_available(), "CUDA not available"
-            typer.echo("CUDA seems to be working")
+            assert torch.cuda.is_available(), 'CUDA not available'
+            typer.echo('CUDA seems to be working')
         except Exception as e:
             typer.echo(
-                "Error when testing CUDA but USE_CUDA_DOCKER is true. "
-                "Resetting USE_CUDA_DOCKER to false and removing "
-                f"LD_LIBRARY_PATH modifications: {e}"
+                'Error when testing CUDA but USE_CUDA_DOCKER is true. '
+                'Resetting USE_CUDA_DOCKER to false and removing '
+                f'LD_LIBRARY_PATH modifications: {e}'
             )
-            os.environ["USE_CUDA_DOCKER"] = "false"
-            os.environ["LD_LIBRARY_PATH"] = ":".join(LD_LIBRARY_PATH)
+            os.environ['USE_CUDA_DOCKER'] = 'false'
+            os.environ['LD_LIBRARY_PATH'] = ':'.join(LD_LIBRARY_PATH)
 
     import open_webui.main  # we need set environment variables before importing main
     from open_webui.env import UVICORN_WORKERS  # Import the workers setting
 
     uvicorn.run(
-        "open_webui.main:app",
+        'open_webui.main:app',
         host=host,
         port=port,
-        forwarded_allow_ips="*",
+        forwarded_allow_ips='*',
         workers=UVICORN_WORKERS,
     )
 
 
 @app.command()
 def dev(
-    host: str = "0.0.0.0",
+    host: str = '0.0.0.0',
     port: int = 8080,
     reload: bool = True,
 ):
     uvicorn.run(
-        "open_webui.main:app",
+        'open_webui.main:app',
         host=host,
         port=port,
         reload=reload,
-        forwarded_allow_ips="*",
+        forwarded_allow_ips='*',
     )
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     app()

@@ -56,25 +56,23 @@ def handle_peewee_migration(DATABASE_URL):
     # db = None
     try:
         # Replace the postgresql:// with postgres:// to handle the peewee migration
-        db = register_connection(DATABASE_URL.replace("postgresql://", "postgres://"))
-        migrate_dir = OPEN_WEBUI_DIR / "internal" / "migrations"
+        db = register_connection(DATABASE_URL.replace('postgresql://', 'postgres://'))
+        migrate_dir = OPEN_WEBUI_DIR / 'internal' / 'migrations'
         router = Router(db, logger=log, migrate_dir=migrate_dir)
         router.run()
         db.close()
 
     except Exception as e:
-        log.error(f"Failed to initialize the database connection: {e}")
-        log.warning(
-            "Hint: If your database password contains special characters, you may need to URL-encode it."
-        )
+        log.error(f'Failed to initialize the database connection: {e}')
+        log.warning('Hint: If your database password contains special characters, you may need to URL-encode it.')
         raise
     finally:
         # Properly closing the database connection
         if db and not db.is_closed():
             db.close()
 
         # Assert if db connection has been closed
-        assert db.is_closed(), "Database connection is still open."
+        assert db.is_closed(), 'Database connection is still open.'
 
 
 if ENABLE_DB_MIGRATIONS:
@@ -84,15 +82,13 @@ def handle_peewee_migration(DATABASE_URL):
 SQLALCHEMY_DATABASE_URL = DATABASE_URL
 
 # Handle SQLCipher URLs
-if SQLALCHEMY_DATABASE_URL.startswith("sqlite+sqlcipher://"):
-    database_password = os.environ.get("DATABASE_PASSWORD")
-    if not database_password or database_password.strip() == "":
-        raise ValueError(
-            "DATABASE_PASSWORD is required when using sqlite+sqlcipher:// URLs"
-        )
+if SQLALCHEMY_DATABASE_URL.startswith('sqlite+sqlcipher://'):
+    database_password = os.environ.get('DATABASE_PASSWORD')
+    if not database_password or database_password.strip() == '':
+        raise ValueError('DATABASE_PASSWORD is required when using sqlite+sqlcipher:// URLs')
 
     # Extract database path from SQLCipher URL
-    db_path = SQLALCHEMY_DATABASE_URL.replace("sqlite+sqlcipher://", "")
+    db_path = SQLALCHEMY_DATABASE_URL.replace('sqlite+sqlcipher://', '')
 
     # Create a custom creator function that uses sqlcipher3
     def create_sqlcipher_connection():
@@ -109,7 +105,7 @@ def create_sqlcipher_connection():
     # or QueuePool if DATABASE_POOL_SIZE is explicitly configured.
     if isinstance(DATABASE_POOL_SIZE, int) and DATABASE_POOL_SIZE > 0:
         engine = create_engine(
-            "sqlite://",
+            'sqlite://',
             creator=create_sqlcipher_connection,
             pool_size=DATABASE_POOL_SIZE,
             max_overflow=DATABASE_POOL_MAX_OVERFLOW,
@@ -121,28 +117,26 @@ def create_sqlcipher_connection():
         )
     else:
         engine = create_engine(
-            "sqlite://",
+            'sqlite://',
             creator=create_sqlcipher_connection,
             poolclass=NullPool,
             echo=False,
         )
 
-    log.info("Connected to encrypted SQLite database using SQLCipher")
+    log.info('Connected to encrypted SQLite database using SQLCipher')
 
-elif "sqlite" in SQLALCHEMY_DATABASE_URL:
-    engine = create_engine(
-        SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
-    )
+elif 'sqlite' in SQLALCHEMY_DATABASE_URL:
+    engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={'check_same_thread': False})
 
     def on_connect(dbapi_connection, connection_record):
         cursor = dbapi_connection.cursor()
         if DATABASE_ENABLE_SQLITE_WAL:
-            cursor.execute("PRAGMA journal_mode=WAL")
+            cursor.execute('PRAGMA journal_mode=WAL')
         else:
-            cursor.execute("PRAGMA journal_mode=DELETE")
+            cursor.execute('PRAGMA journal_mode=DELETE')
         cursor.close()
 
-    event.listen(engine, "connect", on_connect)
+    event.listen(engine, 'connect', on_connect)
 else:
     if isinstance(DATABASE_POOL_SIZE, int):
         if DATABASE_POOL_SIZE > 0:
@@ -156,16 +150,12 @@ def on_connect(dbapi_connection, connection_record):
                 poolclass=QueuePool,
             )
         else:
-            engine = create_engine(
-                SQLALCHEMY_DATABASE_URL, pool_pre_ping=True, poolclass=NullPool
-            )
+            engine = create_engine(SQLALCHEMY_DATABASE_URL, pool_pre_ping=True, poolclass=NullPool)
     else:
         engine = create_engine(SQLALCHEMY_DATABASE_URL, pool_pre_ping=True)
 
 
-SessionLocal = sessionmaker(
-    autocommit=False, autoflush=False, bind=engine, expire_on_commit=False
-)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine, expire_on_commit=False)
 metadata_obj = MetaData(schema=DATABASE_SCHEMA)
 Base = declarative_base(metadata=metadata_obj)
 ScopedSession = scoped_session(SessionLocal)

@@ -56,7 +56,7 @@ class Auth(pw.Model):
         active = pw.BooleanField()
 
         class Meta:
-            table_name = "auth"
+            table_name = 'auth'
 
     @migrator.create_model
     class Chat(pw.Model):
@@ -67,7 +67,7 @@ class Chat(pw.Model):
         timestamp = pw.BigIntegerField()
 
         class Meta:
-            table_name = "chat"
+            table_name = 'chat'
 
     @migrator.create_model
     class ChatIdTag(pw.Model):
@@ -78,7 +78,7 @@ class ChatIdTag(pw.Model):
         timestamp = pw.BigIntegerField()
 
         class Meta:
-            table_name = "chatidtag"
+            table_name = 'chatidtag'
 
     @migrator.create_model
     class Document(pw.Model):
@@ -92,7 +92,7 @@ class Document(pw.Model):
         timestamp = pw.BigIntegerField()
 
         class Meta:
-            table_name = "document"
+            table_name = 'document'
 
     @migrator.create_model
     class Modelfile(pw.Model):
@@ -103,7 +103,7 @@ class Modelfile(pw.Model):
         timestamp = pw.BigIntegerField()
 
         class Meta:
-            table_name = "modelfile"
+            table_name = 'modelfile'
 
     @migrator.create_model
     class Prompt(pw.Model):
@@ -115,7 +115,7 @@ class Prompt(pw.Model):
         timestamp = pw.BigIntegerField()
 
         class Meta:
-            table_name = "prompt"
+            table_name = 'prompt'
 
     @migrator.create_model
     class Tag(pw.Model):
@@ -125,7 +125,7 @@ class Tag(pw.Model):
         data = pw.TextField(null=True)
 
         class Meta:
-            table_name = "tag"
+            table_name = 'tag'
 
     @migrator.create_model
     class User(pw.Model):
@@ -137,7 +137,7 @@ class User(pw.Model):
         timestamp = pw.BigIntegerField()
 
         class Meta:
-            table_name = "user"
+            table_name = 'user'
 
 
 def migrate_external(migrator: Migrator, database: pw.Database, *, fake=False):
@@ -149,7 +149,7 @@ class Auth(pw.Model):
         active = pw.BooleanField()
 
         class Meta:
-            table_name = "auth"
+            table_name = 'auth'
 
     @migrator.create_model
     class Chat(pw.Model):
@@ -160,7 +160,7 @@ class Chat(pw.Model):
         timestamp = pw.BigIntegerField()
 
         class Meta:
-            table_name = "chat"
+            table_name = 'chat'
 
     @migrator.create_model
     class ChatIdTag(pw.Model):
@@ -171,7 +171,7 @@ class ChatIdTag(pw.Model):
         timestamp = pw.BigIntegerField()
 
         class Meta:
-            table_name = "chatidtag"
+            table_name = 'chatidtag'
 
     @migrator.create_model
     class Document(pw.Model):
@@ -185,7 +185,7 @@ class Document(pw.Model):
         timestamp = pw.BigIntegerField()
 
         class Meta:
-            table_name = "document"
+            table_name = 'document'
 
     @migrator.create_model
     class Modelfile(pw.Model):
@@ -196,7 +196,7 @@ class Modelfile(pw.Model):
         timestamp = pw.BigIntegerField()
 
         class Meta:
-            table_name = "modelfile"
+            table_name = 'modelfile'
 
     @migrator.create_model
     class Prompt(pw.Model):
@@ -208,7 +208,7 @@ class Prompt(pw.Model):
         timestamp = pw.BigIntegerField()
 
         class Meta:
-            table_name = "prompt"
+            table_name = 'prompt'
 
     @migrator.create_model
     class Tag(pw.Model):
@@ -218,7 +218,7 @@ class Tag(pw.Model):
         data = pw.TextField(null=True)
 
         class Meta:
-            table_name = "tag"
+            table_name = 'tag'
 
     @migrator.create_model
     class User(pw.Model):
@@ -230,24 +230,24 @@ class User(pw.Model):
         timestamp = pw.BigIntegerField()
 
         class Meta:
-            table_name = "user"
+            table_name = 'user'
 
 
 def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your rollback migrations here."""
 
-    migrator.remove_model("user")
+    migrator.remove_model('user')
 
-    migrator.remove_model("tag")
+    migrator.remove_model('tag')
 
-    migrator.remove_model("prompt")
+    migrator.remove_model('prompt')
 
-    migrator.remove_model("modelfile")
+    migrator.remove_model('modelfile')
 
-    migrator.remove_model("document")
+    migrator.remove_model('document')
 
-    migrator.remove_model("chatidtag")
+    migrator.remove_model('chatidtag')
 
-    migrator.remove_model("chat")
+    migrator.remove_model('chat')
 
-    migrator.remove_model("auth")
+    migrator.remove_model('auth')

@@ -36,12 +36,10 @@
 def migrate(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your migrations here."""
 
-    migrator.add_fields(
-        "chat", share_id=pw.CharField(max_length=255, null=True, unique=True)
-    )
+    migrator.add_fields('chat', share_id=pw.CharField(max_length=255, null=True, unique=True))
 
 
 def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your rollback migrations here."""
 
-    migrator.remove_fields("chat", "share_id")
+    migrator.remove_fields('chat', 'share_id')

@@ -36,12 +36,10 @@
 def migrate(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your migrations here."""
 
-    migrator.add_fields(
-        "user", api_key=pw.CharField(max_length=255, null=True, unique=True)
-    )
+    migrator.add_fields('user', api_key=pw.CharField(max_length=255, null=True, unique=True))
 
 
 def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your rollback migrations here."""
 
-    migrator.remove_fields("user", "api_key")
+    migrator.remove_fields('user', 'api_key')

@@ -36,10 +36,10 @@
 def migrate(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your migrations here."""
 
-    migrator.add_fields("chat", archived=pw.BooleanField(default=False))
+    migrator.add_fields('chat', archived=pw.BooleanField(default=False))
 
 
 def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your rollback migrations here."""
 
-    migrator.remove_fields("chat", "archived")
+    migrator.remove_fields('chat', 'archived')

@@ -45,22 +45,20 @@ def migrate(migrator: Migrator, database: pw.Database, *, fake=False):
 def migrate_sqlite(migrator: Migrator, database: pw.Database, *, fake=False):
     # Adding fields created_at and updated_at to the 'chat' table
     migrator.add_fields(
-        "chat",
+        'chat',
         created_at=pw.DateTimeField(null=True),  # Allow null for transition
         updated_at=pw.DateTimeField(null=True),  # Allow null for transition
     )
 
     # Populate the new fields from an existing 'timestamp' field
-    migrator.sql(
-        "UPDATE chat SET created_at = timestamp, updated_at = timestamp WHERE timestamp IS NOT NULL"
-    )
+    migrator.sql('UPDATE chat SET created_at = timestamp, updated_at = timestamp WHERE timestamp IS NOT NULL')
 
     # Now that the data has been copied, remove the original 'timestamp' field
-    migrator.remove_fields("chat", "timestamp")
+    migrator.remove_fields('chat', 'timestamp')
 
     # Update the fields to be not null now that they are populated
     migrator.change_fields(
-        "chat",
+        'chat',
         created_at=pw.DateTimeField(null=False),
         updated_at=pw.DateTimeField(null=False),
     )
@@ -69,22 +67,20 @@ def migrate_sqlite(migrator: Migrator, database: pw.Database, *, fake=False):
 def migrate_external(migrator: Migrator, database: pw.Database, *, fake=False):
     # Adding fields created_at and updated_at to the 'chat' table
     migrator.add_fields(
-        "chat",
+        'chat',
         created_at=pw.BigIntegerField(null=True),  # Allow null for transition
         updated_at=pw.BigIntegerField(null=True),  # Allow null for transition
     )
 
     # Populate the new fields from an existing 'timestamp' field
-    migrator.sql(
-        "UPDATE chat SET created_at = timestamp, updated_at = timestamp WHERE timestamp IS NOT NULL"
-    )
+    migrator.sql('UPDATE chat SET created_at = timestamp, updated_at = timestamp WHERE timestamp IS NOT NULL')
 
     # Now that the data has been copied, remove the original 'timestamp' field
-    migrator.remove_fields("chat", "timestamp")
+    migrator.remove_fields('chat', 'timestamp')
 
     # Update the fields to be not null now that they are populated
     migrator.change_fields(
-        "chat",
+        'chat',
         created_at=pw.BigIntegerField(null=False),
         updated_at=pw.BigIntegerField(null=False),
     )
@@ -101,29 +97,29 @@ def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
 
 def rollback_sqlite(migrator: Migrator, database: pw.Database, *, fake=False):
     # Recreate the timestamp field initially allowing null values for safe transition
-    migrator.add_fields("chat", timestamp=pw.DateTimeField(null=True))
+    migrator.add_fields('chat', timestamp=pw.DateTimeField(null=True))
 
     # Copy the earliest created_at date back into the new timestamp field
     # This assumes created_at was originally a copy of timestamp
-    migrator.sql("UPDATE chat SET timestamp = created_at")
+    migrator.sql('UPDATE chat SET timestamp = created_at')
 
     # Remove the created_at and updated_at fields
-    migrator.remove_fields("chat", "created_at", "updated_at")
+    migrator.remove_fields('chat', 'created_at', 'updated_at')
 
     # Finally, alter the timestamp field to not allow nulls if that was the original setting
-    migrator.change_fields("chat", timestamp=pw.DateTimeField(null=False))
+    migrator.change_fields('chat', timestamp=pw.DateTimeField(null=False))
 
 
 def rollback_external(migrator: Migrator, database: pw.Database, *, fake=False):
     # Recreate the timestamp field initially allowing null values for safe transition
-    migrator.add_fields("chat", timestamp=pw.BigIntegerField(null=True))
+    migrator.add_fields('chat', timestamp=pw.BigIntegerField(null=True))
 
     # Copy the earliest created_at date back into the new timestamp field
     # This assumes created_at was originally a copy of timestamp
-    migrator.sql("UPDATE chat SET timestamp = created_at")
+    migrator.sql('UPDATE chat SET timestamp = created_at')
 
     # Remove the created_at and updated_at fields
-    migrator.remove_fields("chat", "created_at", "updated_at")
+    migrator.remove_fields('chat', 'created_at', 'updated_at')
 
     # Finally, alter the timestamp field to not allow nulls if that was the original setting
-    migrator.change_fields("chat", timestamp=pw.BigIntegerField(null=False))
+    migrator.change_fields('chat', timestamp=pw.BigIntegerField(null=False))

@@ -38,45 +38,45 @@ def migrate(migrator: Migrator, database: pw.Database, *, fake=False):
 
     # Alter the tables with timestamps
     migrator.change_fields(
-        "chatidtag",
+        'chatidtag',
         timestamp=pw.BigIntegerField(),
     )
     migrator.change_fields(
-        "document",
+        'document',
         timestamp=pw.BigIntegerField(),
     )
     migrator.change_fields(
-        "modelfile",
+        'modelfile',
         timestamp=pw.BigIntegerField(),
     )
     migrator.change_fields(
-        "prompt",
+        'prompt',
         timestamp=pw.BigIntegerField(),
     )
     migrator.change_fields(
-        "user",
+        'user',
         timestamp=pw.BigIntegerField(),
     )
     # Alter the tables with varchar to text where necessary
     migrator.change_fields(
-        "auth",
+        'auth',
         password=pw.TextField(),
     )
     migrator.change_fields(
-        "chat",
+        'chat',
         title=pw.TextField(),
     )
     migrator.change_fields(
-        "document",
+        'document',
         title=pw.TextField(),
         filename=pw.TextField(),
     )
     migrator.change_fields(
-        "prompt",
+        'prompt',
         title=pw.TextField(),
     )
     migrator.change_fields(
-        "user",
+        'user',
         profile_image_url=pw.TextField(),
     )
 
@@ -87,43 +87,43 @@ def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
     if isinstance(database, pw.SqliteDatabase):
         # Alter the tables with timestamps
         migrator.change_fields(
-            "chatidtag",
+            'chatidtag',
             timestamp=pw.DateField(),
         )
         migrator.change_fields(
-            "document",
+            'document',
             timestamp=pw.DateField(),
         )
         migrator.change_fields(
-            "modelfile",
+            'modelfile',
             timestamp=pw.DateField(),
         )
         migrator.change_fields(
-            "prompt",
+            'prompt',
             timestamp=pw.DateField(),
         )
         migrator.change_fields(
-            "user",
+            'user',
             timestamp=pw.DateField(),
         )
     migrator.change_fields(
-        "auth",
+        'auth',
         password=pw.CharField(max_length=255),
     )
     migrator.change_fields(
-        "chat",
+        'chat',
         title=pw.CharField(),
     )
     migrator.change_fields(
-        "document",
+        'document',
         title=pw.CharField(),
         filename=pw.CharField(),
     )
     migrator.change_fields(
-        "prompt",
+        'prompt',
         title=pw.CharField(),
     )
     migrator.change_fields(
-        "user",
+        'user',
         profile_image_url=pw.CharField(),
     )

@@ -38,7 +38,7 @@ def migrate(migrator: Migrator, database: pw.Database, *, fake=False):
 
     # Adding fields created_at and updated_at to the 'user' table
     migrator.add_fields(
-        "user",
+        'user',
         created_at=pw.BigIntegerField(null=True),  # Allow null for transition
         updated_at=pw.BigIntegerField(null=True),  # Allow null for transition
         last_active_at=pw.BigIntegerField(null=True),  # Allow null for transition
@@ -50,11 +50,11 @@ def migrate(migrator: Migrator, database: pw.Database, *, fake=False):
     )
 
     # Now that the data has been copied, remove the original 'timestamp' field
-    migrator.remove_fields("user", "timestamp")
+    migrator.remove_fields('user', 'timestamp')
 
     # Update the fields to be not null now that they are populated
     migrator.change_fields(
-        "user",
+        'user',
         created_at=pw.BigIntegerField(null=False),
         updated_at=pw.BigIntegerField(null=False),
         last_active_at=pw.BigIntegerField(null=False),
@@ -65,14 +65,14 @@ def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your rollback migrations here."""
 
     # Recreate the timestamp field initially allowing null values for safe transition
-    migrator.add_fields("user", timestamp=pw.BigIntegerField(null=True))
+    migrator.add_fields('user', timestamp=pw.BigIntegerField(null=True))
 
     # Copy the earliest created_at date back into the new timestamp field
     # This assumes created_at was originally a copy of timestamp
     migrator.sql('UPDATE "user" SET timestamp = created_at')
 
     # Remove the created_at and updated_at fields
-    migrator.remove_fields("user", "created_at", "updated_at", "last_active_at")
+    migrator.remove_fields('user', 'created_at', 'updated_at', 'last_active_at')
 
     # Finally, alter the timestamp field to not allow nulls if that was the original setting
-    migrator.change_fields("user", timestamp=pw.BigIntegerField(null=False))
+    migrator.change_fields('user', timestamp=pw.BigIntegerField(null=False))

@@ -43,10 +43,10 @@ class Memory(pw.Model):
         created_at = pw.BigIntegerField(null=False)
 
         class Meta:
-            table_name = "memory"
+            table_name = 'memory'
 
 
 def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your rollback migrations here."""
 
-    migrator.remove_model("memory")
+    migrator.remove_model('memory')

@@ -51,10 +51,10 @@ class Model(pw.Model):
         updated_at = pw.BigIntegerField(null=False)
 
         class Meta:
-            table_name = "model"
+            table_name = 'model'
 
 
 def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your rollback migrations here."""
 
-    migrator.remove_model("model")
+    migrator.remove_model('model')

@@ -42,12 +42,12 @@ def migrate(migrator: Migrator, database: pw.Database, *, fake=False):
     # Fetch data from 'modelfile' table and insert into 'model' table
     migrate_modelfile_to_model(migrator, database)
     # Drop the 'modelfile' table
-    migrator.remove_model("modelfile")
+    migrator.remove_model('modelfile')
 
 
 def migrate_modelfile_to_model(migrator: Migrator, database: pw.Database):
-    ModelFile = migrator.orm["modelfile"]
-    Model = migrator.orm["model"]
+    ModelFile = migrator.orm['modelfile']
+    Model = migrator.orm['model']
 
     modelfiles = ModelFile.select()
 
@@ -57,25 +57,25 @@ def migrate_modelfile_to_model(migrator: Migrator, database: pw.Database):
         modelfile.modelfile = json.loads(modelfile.modelfile)
         meta = json.dumps(
             {
-                "description": modelfile.modelfile.get("desc"),
-                "profile_image_url": modelfile.modelfile.get("imageUrl"),
-                "ollama": {"modelfile": modelfile.modelfile.get("content")},
-                "suggestion_prompts": modelfile.modelfile.get("suggestionPrompts"),
-                "categories": modelfile.modelfile.get("categories"),
-                "user": {**modelfile.modelfile.get("user", {}), "community": True},
+                'description': modelfile.modelfile.get('desc'),
+                'profile_image_url': modelfile.modelfile.get('imageUrl'),
+                'ollama': {'modelfile': modelfile.modelfile.get('content')},
+                'suggestion_prompts': modelfile.modelfile.get('suggestionPrompts'),
+                'categories': modelfile.modelfile.get('categories'),
+                'user': {**modelfile.modelfile.get('user', {}), 'community': True},
             }
         )
 
-        info = parse_ollama_modelfile(modelfile.modelfile.get("content"))
+        info = parse_ollama_modelfile(modelfile.modelfile.get('content'))
 
         # Insert the processed data into the 'model' table
         Model.create(
-            id=f"ollama-{modelfile.tag_name}",
+            id=f'ollama-{modelfile.tag_name}',
             user_id=modelfile.user_id,
-            base_model_id=info.get("base_model_id"),
-            name=modelfile.modelfile.get("title"),
+            base_model_id=info.get('base_model_id'),
+            name=modelfile.modelfile.get('title'),
             meta=meta,
-            params=json.dumps(info.get("params", {})),
+            params=json.dumps(info.get('params', {})),
             created_at=modelfile.timestamp,
             updated_at=modelfile.timestamp,
         )
@@ -86,7 +86,7 @@ def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
 
     recreate_modelfile_table(migrator, database)
     move_data_back_to_modelfile(migrator, database)
-    migrator.remove_model("model")
+    migrator.remove_model('model')
 
 
 def recreate_modelfile_table(migrator: Migrator, database: pw.Database):
@@ -102,8 +102,8 @@ def recreate_modelfile_table(migrator: Migrator, database: pw.Database):
 
 
 def move_data_back_to_modelfile(migrator: Migrator, database: pw.Database):
-    Model = migrator.orm["model"]
-    Modelfile = migrator.orm["modelfile"]
+    Model = migrator.orm['model']
+    Modelfile = migrator.orm['modelfile']
 
     models = Model.select()
 
@@ -112,13 +112,13 @@ def move_data_back_to_modelfile(migrator: Migrator, database: pw.Database):
         meta = json.loads(model.meta)
 
         modelfile_data = {
-            "title": model.name,
-            "desc": meta.get("description"),
-            "imageUrl": meta.get("profile_image_url"),
-            "content": meta.get("ollama", {}).get("modelfile"),
-            "suggestionPrompts": meta.get("suggestion_prompts"),
-            "categories": meta.get("categories"),
-            "user": {k: v for k, v in meta.get("user", {}).items() if k != "community"},
+            'title': model.name,
+            'desc': meta.get('description'),
+            'imageUrl': meta.get('profile_image_url'),
+            'content': meta.get('ollama', {}).get('modelfile'),
+            'suggestionPrompts': meta.get('suggestion_prompts'),
+            'categories': meta.get('categories'),
+            'user': {k: v for k, v in meta.get('user', {}).items() if k != 'community'},
         }
 
         # Insert the processed data back into the 'modelfile' table

@@ -37,11 +37,11 @@ def migrate(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your migrations here."""
 
     # Adding fields settings to the 'user' table
-    migrator.add_fields("user", settings=pw.TextField(null=True))
+    migrator.add_fields('user', settings=pw.TextField(null=True))
 
 
 def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your rollback migrations here."""
 
     # Remove the settings field
-    migrator.remove_fields("user", "settings")
+    migrator.remove_fields('user', 'settings')

@@ -51,10 +51,10 @@ class Tool(pw.Model):
         updated_at = pw.BigIntegerField(null=False)
 
         class Meta:
-            table_name = "tool"
+            table_name = 'tool'
 
 
 def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your rollback migrations here."""
 
-    migrator.remove_model("tool")
+    migrator.remove_model('tool')

@@ -37,11 +37,11 @@ def migrate(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your migrations here."""
 
     # Adding fields info to the 'user' table
-    migrator.add_fields("user", info=pw.TextField(null=True))
+    migrator.add_fields('user', info=pw.TextField(null=True))
 
 
 def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your rollback migrations here."""
 
     # Remove the settings field
-    migrator.remove_fields("user", "info")
+    migrator.remove_fields('user', 'info')

@@ -45,10 +45,10 @@ class File(pw.Model):
         created_at = pw.BigIntegerField(null=False)
 
         class Meta:
-            table_name = "file"
+            table_name = 'file'
 
 
 def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your rollback migrations here."""
 
-    migrator.remove_model("file")
+    migrator.remove_model('file')

@@ -51,10 +51,10 @@ class Function(pw.Model):
         updated_at = pw.BigIntegerField(null=False)
 
         class Meta:
-            table_name = "function"
+            table_name = 'function'
 
 
 def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your rollback migrations here."""
 
-    migrator.remove_model("function")
+    migrator.remove_model('function')

@@ -36,14 +36,14 @@
 def migrate(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your migrations here."""
 
-    migrator.add_fields("tool", valves=pw.TextField(null=True))
-    migrator.add_fields("function", valves=pw.TextField(null=True))
-    migrator.add_fields("function", is_active=pw.BooleanField(default=False))
+    migrator.add_fields('tool', valves=pw.TextField(null=True))
+    migrator.add_fields('function', valves=pw.TextField(null=True))
+    migrator.add_fields('function', is_active=pw.BooleanField(default=False))
 
 
 def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your rollback migrations here."""
 
-    migrator.remove_fields("tool", "valves")
-    migrator.remove_fields("function", "valves")
-    migrator.remove_fields("function", "is_active")
+    migrator.remove_fields('tool', 'valves')
+    migrator.remove_fields('function', 'valves')
+    migrator.remove_fields('function', 'is_active')

@@ -33,12 +33,12 @@ def migrate(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your migrations here."""
 
     migrator.add_fields(
-        "user",
+        'user',
         oauth_sub=pw.TextField(null=True, unique=True),
     )
 
 
 def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your rollback migrations here."""
 
-    migrator.remove_fields("user", "oauth_sub")
+    migrator.remove_fields('user', 'oauth_sub')

@@ -37,12 +37,12 @@ def migrate(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your migrations here."""
 
     migrator.add_fields(
-        "function",
+        'function',
         is_global=pw.BooleanField(default=False),
     )
 
 
 def rollback(migrator: Migrator, database: pw.Database, *, fake=False):
     """Write your rollback migrations here."""
 
-    migrator.remove_fields("function", "is_global")
+    migrator.remove_fields('function', 'is_global')

@@ -10,13 +10,13 @@
 
 log = logging.getLogger(__name__)
 
-db_state_default = {"closed": None, "conn": None, "ctx": None, "transactions": None}
-db_state = ContextVar("db_state", default=db_state_default.copy())
+db_state_default = {'closed': None, 'conn': None, 'ctx': None, 'transactions': None}
+db_state = ContextVar('db_state', default=db_state_default.copy())
 
 
 class PeeweeConnectionState(object):
     def __init__(self, **kwargs):
-        super().__setattr__("_state", db_state)
+        super().__setattr__('_state', db_state)
         super().__init__(**kwargs)
 
     def __setattr__(self, name, value):
@@ -30,10 +30,10 @@ def __getattr__(self, name):
 class CustomReconnectMixin(ReconnectMixin):
     reconnect_errors = (
         # psycopg2
-        (OperationalError, "termin"),
-        (InterfaceError, "closed"),
+        (OperationalError, 'termin'),
+        (InterfaceError, 'closed'),
         # peewee
-        (PeeWeeInterfaceError, "closed"),
+        (PeeWeeInterfaceError, 'closed'),
     )
 
 
@@ -43,23 +43,21 @@ class ReconnectingPostgresqlDatabase(CustomReconnectMixin, PostgresqlDatabase):
 
 def register_connection(db_url):
     # Check if using SQLCipher protocol
-    if db_url.startswith("sqlite+sqlcipher://"):
-        database_password = os.environ.get("DATABASE_PASSWORD")
-        if not database_password or database_password.strip() == "":
-            raise ValueError(
-                "DATABASE_PASSWORD is required when using sqlite+sqlcipher:// URLs"
-            )
+    if db_url.startswith('sqlite+sqlcipher://'):
+        database_password = os.environ.get('DATABASE_PASSWORD')
+        if not database_password or database_password.strip() == '':
+            raise ValueError('DATABASE_PASSWORD is required when using sqlite+sqlcipher:// URLs')
         from playhouse.sqlcipher_ext import SqlCipherDatabase
 
         # Parse the database path from SQLCipher URL
         # Convert sqlite+sqlcipher:///path/to/db.sqlite to /path/to/db.sqlite
-        db_path = db_url.replace("sqlite+sqlcipher://", "")
+        db_path = db_url.replace('sqlite+sqlcipher://', '')
 
         # Use Peewee's native SqlCipherDatabase with encryption
         db = SqlCipherDatabase(db_path, passphrase=database_password)
         db.autoconnect = True
         db.reuse_if_open = True
-        log.info("Connected to encrypted SQLite database using SQLCipher")
+        log.info('Connected to encrypted SQLite database using SQLCipher')
 
     else:
         # Standard database connection (existing logic)
@@ -68,7 +66,7 @@ def register_connection(db_url):
             # Enable autoconnect for SQLite databases, managed by Peewee
             db.autoconnect = True
             db.reuse_if_open = True
-            log.info("Connected to PostgreSQL database")
+            log.info('Connected to PostgreSQL database')
 
             # Get the connection details
             connection = parse(db_url, unquote_user=True, unquote_password=True)
@@ -80,7 +78,7 @@ def register_connection(db_url):
             # Enable autoconnect for SQLite databases, managed by Peewee
             db.autoconnect = True
             db.reuse_if_open = True
-            log.info("Connected to SQLite database")
+            log.info('Connected to SQLite database')
         else:
-            raise ValueError("Unsupported database connection")
+            raise ValueError('Unsupported database connection')
     return db

@@ -565,7 +565,7 @@
 from open_webui.constants import ERROR_MESSAGES
 
 if SAFE_MODE:
-    print("SAFE MODE ENABLED")
+    print('SAFE MODE ENABLED')
     Functions.deactivate_all_functions()
 
 logging.basicConfig(stream=sys.stdout, level=GLOBAL_LOG_LEVEL)
@@ -578,16 +578,16 @@ async def get_response(self, path: str, scope):
             return await super().get_response(path, scope)
         except (HTTPException, StarletteHTTPException) as ex:
             if ex.status_code == 404:
-                if path.endswith(".js"):
+                if path.endswith('.js'):
                     # Return 404 for javascript files
                     raise ex
                 else:
-                    return await super().get_response("index.html", scope)
+                    return await super().get_response('index.html', scope)
             else:
                 raise ex
 
 
-if LOG_FORMAT != "json":
+if LOG_FORMAT != 'json':
     print(rf"""
  ██████╗ ██████╗ ███████╗███╗   ██╗    ██╗    ██╗███████╗██████╗ ██╗   ██╗██╗
 ██╔═══██╗██╔══██╗██╔════╝████╗  ██║    ██║    ██║██╔════╝██╔══██╗██║   ██║██║
@@ -598,7 +598,7 @@ async def get_response(self, path: str, scope):
 
 
 v{VERSION} - building the best AI user interface.
-{f"Commit: {WEBUI_BUILD_HASH}" if WEBUI_BUILD_HASH != "dev-build" else ""}
+{f'Commit: {WEBUI_BUILD_HASH}' if WEBUI_BUILD_HASH != 'dev-build' else ''}
 https://github.com/open-webui/open-webui
 """)
 
@@ -626,22 +626,18 @@ async def lifespan(app: FastAPI):
 
     # This should be blocking (sync) so functions are not deactivated on first /get_models calls
     # when the first user lands on the / route.
-    log.info("Installing external dependencies of functions and tools...")
+    log.info('Installing external dependencies of functions and tools...')
     install_tool_and_function_dependencies()
 
     app.state.redis = get_redis_connection(
         redis_url=REDIS_URL,
-        redis_sentinels=get_sentinels_from_env(
-            REDIS_SENTINEL_HOSTS, REDIS_SENTINEL_PORT
-        ),
+        redis_sentinels=get_sentinels_from_env(REDIS_SENTINEL_HOSTS, REDIS_SENTINEL_PORT),
         redis_cluster=REDIS_CLUSTER,
         async_mode=True,
     )
 
     if app.state.redis is not None:
-        app.state.redis_task_command_listener = asyncio.create_task(
-            redis_task_command_listener(app)
-        )
+        app.state.redis_task_command_listener = asyncio.create_task(redis_task_command_listener(app))
 
     if THREAD_POOL_SIZE and THREAD_POOL_SIZE > 0:
         limiter = anyio.to_thread.current_default_thread_limiter()
@@ -656,66 +652,64 @@ async def lifespan(app: FastAPI):
                 Request(
                     # Creating a mock request object to pass to get_all_models
                     {
-                        "type": "http",
-                        "asgi.version": "3.0",
-                        "asgi.spec_version": "2.0",
-                        "method": "GET",
-                        "path": "/internal",
-                        "query_string": b"",
-                        "headers": Headers({}).raw,
-                        "client": ("127.0.0.1", 12345),
-                        "server": ("127.0.0.1", 80),
-                        "scheme": "http",
-                        "app": app,
+                        'type': 'http',
+                        'asgi.version': '3.0',
+                        'asgi.spec_version': '2.0',
+                        'method': 'GET',
+                        'path': '/internal',
+                        'query_string': b'',
+                        'headers': Headers({}).raw,
+                        'client': ('127.0.0.1', 12345),
+                        'server': ('127.0.0.1', 80),
+                        'scheme': 'http',
+                        'app': app,
                     }
                 ),
                 None,
             )
         except Exception as e:
-            log.warning(f"Failed to pre-fetch models at startup: {e}")
+            log.warning(f'Failed to pre-fetch models at startup: {e}')
 
     # Pre-fetch tool server specs so the first request doesn't pay the latency cost
     if len(app.state.config.TOOL_SERVER_CONNECTIONS) > 0:
-        log.info("Initializing tool servers...")
+        log.info('Initializing tool servers...')
         try:
             mock_request = Request(
                 {
-                    "type": "http",
-                    "asgi.version": "3.0",
-                    "asgi.spec_version": "2.0",
-                    "method": "GET",
-                    "path": "/internal",
-                    "query_string": b"",
-                    "headers": Headers({}).raw,
-                    "client": ("127.0.0.1", 12345),
-                    "server": ("127.0.0.1", 80),
-                    "scheme": "http",
-                    "app": app,
+                    'type': 'http',
+                    'asgi.version': '3.0',
+                    'asgi.spec_version': '2.0',
+                    'method': 'GET',
+                    'path': '/internal',
+                    'query_string': b'',
+                    'headers': Headers({}).raw,
+                    'client': ('127.0.0.1', 12345),
+                    'server': ('127.0.0.1', 80),
+                    'scheme': 'http',
+                    'app': app,
                 }
             )
             await set_tool_servers(mock_request)
-            log.info(f"Initialized {len(app.state.TOOL_SERVERS)} tool server(s)")
+            log.info(f'Initialized {len(app.state.TOOL_SERVERS)} tool server(s)')
 
             await set_terminal_servers(mock_request)
-            log.info(
-                f"Initialized {len(app.state.TERMINAL_SERVERS)} terminal server(s)"
-            )
+            log.info(f'Initialized {len(app.state.TERMINAL_SERVERS)} terminal server(s)')
         except Exception as e:
-            log.warning(f"Failed to initialize tool/terminal servers at startup: {e}")
+            log.warning(f'Failed to initialize tool/terminal servers at startup: {e}')
 
     # Mark application as ready to accept traffic from a startup perspective.
     app.state.startup_complete = True
 
     yield
 
-    if hasattr(app.state, "redis_task_command_listener"):
+    if hasattr(app.state, 'redis_task_command_listener'):
         app.state.redis_task_command_listener.cancel()
 
 
 app = FastAPI(
-    title="Open WebUI",
-    docs_url="/docs" if ENV == "dev" else None,
-    openapi_url="/openapi.json" if ENV == "dev" else None,
+    title='Open WebUI',
+    docs_url='/docs' if ENV == 'dev' else None,
+    openapi_url='/openapi.json' if ENV == 'dev' else None,
     redoc_url=None,
     lifespan=lifespan,
 )
@@ -837,9 +831,7 @@ async def lifespan(app: FastAPI):
 app.state.config.ENABLE_LOGIN_FORM = ENABLE_LOGIN_FORM
 
 app.state.config.ENABLE_API_KEYS = ENABLE_API_KEYS
-app.state.config.ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS = (
-    ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS
-)
+app.state.config.ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS = ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS
 app.state.config.API_KEYS_ALLOWED_ENDPOINTS = API_KEYS_ALLOWED_ENDPOINTS
 
 app.state.config.JWT_EXPIRES_IN = JWT_EXPIRES_IN
@@ -885,15 +877,15 @@ async def lifespan(app: FastAPI):
 from open_webui.utils.access_control import migrate_access_control
 
 connections = app.state.config.TOOL_SERVER_CONNECTIONS
-if any("access_control" in c.get("config", {}) for c in connections):
+if any('access_control' in c.get('config', {}) for c in connections):
     for connection in connections:
-        migrate_access_control(connection.get("config", {}))
+        migrate_access_control(connection.get('config', {}))
     app.state.config.TOOL_SERVER_CONNECTIONS = connections
 
 arena_models = app.state.config.EVALUATION_ARENA_MODELS
-if any("access_control" in m.get("meta", {}) for m in arena_models):
+if any('access_control' in m.get('meta', {}) for m in arena_models):
     for model in arena_models:
-        migrate_access_control(model.get("meta", {}))
+        migrate_access_control(model.get('meta', {}))
     app.state.config.EVALUATION_ARENA_MODELS = arena_models
 
 app.state.config.OAUTH_USERNAME_CLAIM = OAUTH_USERNAME_CLAIM
@@ -962,9 +954,7 @@ async def lifespan(app: FastAPI):
 app.state.config.RAG_FULL_CONTEXT = RAG_FULL_CONTEXT
 app.state.config.BYPASS_EMBEDDING_AND_RETRIEVAL = BYPASS_EMBEDDING_AND_RETRIEVAL
 app.state.config.ENABLE_RAG_HYBRID_SEARCH = ENABLE_RAG_HYBRID_SEARCH
-app.state.config.ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS = (
-    ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS
-)
+app.state.config.ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS = ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS
 app.state.config.ENABLE_WEB_LOADER_SSL_VERIFICATION = ENABLE_WEB_LOADER_SSL_VERIFICATION
 
 app.state.config.CONTENT_EXTRACTION_ENGINE = CONTENT_EXTRACTION_ENGINE
@@ -975,9 +965,7 @@ async def lifespan(app: FastAPI):
 app.state.config.DATALAB_MARKER_FORCE_OCR = DATALAB_MARKER_FORCE_OCR
 app.state.config.DATALAB_MARKER_PAGINATE = DATALAB_MARKER_PAGINATE
 app.state.config.DATALAB_MARKER_STRIP_EXISTING_OCR = DATALAB_MARKER_STRIP_EXISTING_OCR
-app.state.config.DATALAB_MARKER_DISABLE_IMAGE_EXTRACTION = (
-    DATALAB_MARKER_DISABLE_IMAGE_EXTRACTION
-)
+app.state.config.DATALAB_MARKER_DISABLE_IMAGE_EXTRACTION = DATALAB_MARKER_DISABLE_IMAGE_EXTRACTION
 app.state.config.DATALAB_MARKER_FORMAT_LINES = DATALAB_MARKER_FORMAT_LINES
 app.state.config.DATALAB_MARKER_USE_LLM = DATALAB_MARKER_USE_LLM
 app.state.config.DATALAB_MARKER_OUTPUT_FORMAT = DATALAB_MARKER_OUTPUT_FORMAT
@@ -999,9 +987,7 @@ async def lifespan(app: FastAPI):
 app.state.config.MINERU_PARAMS = MINERU_PARAMS
 
 app.state.config.TEXT_SPLITTER = RAG_TEXT_SPLITTER
-app.state.config.ENABLE_MARKDOWN_HEADER_TEXT_SPLITTER = (
-    ENABLE_MARKDOWN_HEADER_TEXT_SPLITTER
-)
+app.state.config.ENABLE_MARKDOWN_HEADER_TEXT_SPLITTER = ENABLE_MARKDOWN_HEADER_TEXT_SPLITTER
 
 app.state.config.TIKTOKEN_ENCODING_NAME = TIKTOKEN_ENCODING_NAME
 
@@ -1053,9 +1039,7 @@ async def lifespan(app: FastAPI):
 app.state.config.WEB_LOADER_TIMEOUT = WEB_LOADER_TIMEOUT
 
 app.state.config.WEB_SEARCH_TRUST_ENV = WEB_SEARCH_TRUST_ENV
-app.state.config.BYPASS_WEB_SEARCH_EMBEDDING_AND_RETRIEVAL = (
-    BYPASS_WEB_SEARCH_EMBEDDING_AND_RETRIEVAL
-)
+app.state.config.BYPASS_WEB_SEARCH_EMBEDDING_AND_RETRIEVAL = BYPASS_WEB_SEARCH_EMBEDDING_AND_RETRIEVAL
 app.state.config.BYPASS_WEB_SEARCH_WEB_LOADER = BYPASS_WEB_SEARCH_WEB_LOADER
 
 app.state.config.ENABLE_GOOGLE_DRIVE_INTEGRATION = ENABLE_GOOGLE_DRIVE_INTEGRATION
@@ -1120,13 +1104,8 @@ async def lifespan(app: FastAPI):
 
 
 try:
-    app.state.ef = get_ef(
-        app.state.config.RAG_EMBEDDING_ENGINE, app.state.config.RAG_EMBEDDING_MODEL
-    )
-    if (
-        app.state.config.ENABLE_RAG_HYBRID_SEARCH
-        and not app.state.config.BYPASS_EMBEDDING_AND_RETRIEVAL
-    ):
+    app.state.ef = get_ef(app.state.config.RAG_EMBEDDING_ENGINE, app.state.config.RAG_EMBEDDING_MODEL)
+    if app.state.config.ENABLE_RAG_HYBRID_SEARCH and not app.state.config.BYPASS_EMBEDDING_AND_RETRIEVAL:
         app.state.rf = get_rf(
             app.state.config.RAG_RERANKING_ENGINE,
             app.state.config.RAG_RERANKING_MODEL,
@@ -1137,7 +1116,7 @@ async def lifespan(app: FastAPI):
     else:
         app.state.rf = None
 except Exception as e:
-    log.error(f"Error updating models: {e}")
+    log.error(f'Error updating models: {e}')
     pass
 
 
@@ -1147,26 +1126,26 @@ async def lifespan(app: FastAPI):
     embedding_function=app.state.ef,
     url=(
         app.state.config.RAG_OPENAI_API_BASE_URL
-        if app.state.config.RAG_EMBEDDING_ENGINE == "openai"
+        if app.state.config.RAG_EMBEDDING_ENGINE == 'openai'
         else (
             app.state.config.RAG_OLLAMA_BASE_URL
-            if app.state.config.RAG_EMBEDDING_ENGINE == "ollama"
+            if app.state.config.RAG_EMBEDDING_ENGINE == 'ollama'
             else app.state.config.RAG_AZURE_OPENAI_BASE_URL
         )
     ),
     key=(
         app.state.config.RAG_OPENAI_API_KEY
-        if app.state.config.RAG_EMBEDDING_ENGINE == "openai"
+        if app.state.config.RAG_EMBEDDING_ENGINE == 'openai'
         else (
             app.state.config.RAG_OLLAMA_API_KEY
-            if app.state.config.RAG_EMBEDDING_ENGINE == "ollama"
+            if app.state.config.RAG_EMBEDDING_ENGINE == 'ollama'
             else app.state.config.RAG_AZURE_OPENAI_API_KEY
         )
     ),
     embedding_batch_size=app.state.config.RAG_EMBEDDING_BATCH_SIZE,
     azure_api_version=(
         app.state.config.RAG_AZURE_OPENAI_API_VERSION
-        if app.state.config.RAG_EMBEDDING_ENGINE == "azure_openai"
+        if app.state.config.RAG_EMBEDDING_ENGINE == 'azure_openai'
         else None
     ),
     enable_async=app.state.config.ENABLE_ASYNC_EMBEDDING,
@@ -1190,9 +1169,7 @@ async def lifespan(app: FastAPI):
 app.state.config.CODE_EXECUTION_JUPYTER_URL = CODE_EXECUTION_JUPYTER_URL
 app.state.config.CODE_EXECUTION_JUPYTER_AUTH = CODE_EXECUTION_JUPYTER_AUTH
 app.state.config.CODE_EXECUTION_JUPYTER_AUTH_TOKEN = CODE_EXECUTION_JUPYTER_AUTH_TOKEN
-app.state.config.CODE_EXECUTION_JUPYTER_AUTH_PASSWORD = (
-    CODE_EXECUTION_JUPYTER_AUTH_PASSWORD
-)
+app.state.config.CODE_EXECUTION_JUPYTER_AUTH_PASSWORD = CODE_EXECUTION_JUPYTER_AUTH_PASSWORD
 app.state.config.CODE_EXECUTION_JUPYTER_TIMEOUT = CODE_EXECUTION_JUPYTER_TIMEOUT
 
 app.state.config.ENABLE_CODE_INTERPRETER = ENABLE_CODE_INTERPRETER
@@ -1201,12 +1178,8 @@ async def lifespan(app: FastAPI):
 
 app.state.config.CODE_INTERPRETER_JUPYTER_URL = CODE_INTERPRETER_JUPYTER_URL
 app.state.config.CODE_INTERPRETER_JUPYTER_AUTH = CODE_INTERPRETER_JUPYTER_AUTH
-app.state.config.CODE_INTERPRETER_JUPYTER_AUTH_TOKEN = (
-    CODE_INTERPRETER_JUPYTER_AUTH_TOKEN
-)
-app.state.config.CODE_INTERPRETER_JUPYTER_AUTH_PASSWORD = (
-    CODE_INTERPRETER_JUPYTER_AUTH_PASSWORD
-)
+app.state.config.CODE_INTERPRETER_JUPYTER_AUTH_TOKEN = CODE_INTERPRETER_JUPYTER_AUTH_TOKEN
+app.state.config.CODE_INTERPRETER_JUPYTER_AUTH_PASSWORD = CODE_INTERPRETER_JUPYTER_AUTH_PASSWORD
 app.state.config.CODE_INTERPRETER_JUPYTER_TIMEOUT = CODE_INTERPRETER_JUPYTER_TIMEOUT
 
 ########################################
@@ -1282,9 +1255,7 @@ async def lifespan(app: FastAPI):
 
 app.state.config.AUDIO_STT_MISTRAL_API_KEY = AUDIO_STT_MISTRAL_API_KEY
 app.state.config.AUDIO_STT_MISTRAL_API_BASE_URL = AUDIO_STT_MISTRAL_API_BASE_URL
-app.state.config.AUDIO_STT_MISTRAL_USE_CHAT_COMPLETIONS = (
-    AUDIO_STT_MISTRAL_USE_CHAT_COMPLETIONS
-)
+app.state.config.AUDIO_STT_MISTRAL_USE_CHAT_COMPLETIONS = AUDIO_STT_MISTRAL_USE_CHAT_COMPLETIONS
 
 app.state.config.TTS_ENGINE = AUDIO_TTS_ENGINE
 
@@ -1330,23 +1301,13 @@ async def lifespan(app: FastAPI):
 
 app.state.config.TITLE_GENERATION_PROMPT_TEMPLATE = TITLE_GENERATION_PROMPT_TEMPLATE
 app.state.config.TAGS_GENERATION_PROMPT_TEMPLATE = TAGS_GENERATION_PROMPT_TEMPLATE
-app.state.config.IMAGE_PROMPT_GENERATION_PROMPT_TEMPLATE = (
-    IMAGE_PROMPT_GENERATION_PROMPT_TEMPLATE
-)
-app.state.config.FOLLOW_UP_GENERATION_PROMPT_TEMPLATE = (
-    FOLLOW_UP_GENERATION_PROMPT_TEMPLATE
-)
+app.state.config.IMAGE_PROMPT_GENERATION_PROMPT_TEMPLATE = IMAGE_PROMPT_GENERATION_PROMPT_TEMPLATE
+app.state.config.FOLLOW_UP_GENERATION_PROMPT_TEMPLATE = FOLLOW_UP_GENERATION_PROMPT_TEMPLATE
 
-app.state.config.TOOLS_FUNCTION_CALLING_PROMPT_TEMPLATE = (
-    TOOLS_FUNCTION_CALLING_PROMPT_TEMPLATE
-)
+app.state.config.TOOLS_FUNCTION_CALLING_PROMPT_TEMPLATE = TOOLS_FUNCTION_CALLING_PROMPT_TEMPLATE
 app.state.config.QUERY_GENERATION_PROMPT_TEMPLATE = QUERY_GENERATION_PROMPT_TEMPLATE
-app.state.config.AUTOCOMPLETE_GENERATION_PROMPT_TEMPLATE = (
-    AUTOCOMPLETE_GENERATION_PROMPT_TEMPLATE
-)
-app.state.config.AUTOCOMPLETE_GENERATION_INPUT_MAX_LENGTH = (
-    AUTOCOMPLETE_GENERATION_INPUT_MAX_LENGTH
-)
+app.state.config.AUTOCOMPLETE_GENERATION_PROMPT_TEMPLATE = AUTOCOMPLETE_GENERATION_PROMPT_TEMPLATE
+app.state.config.AUTOCOMPLETE_GENERATION_INPUT_MAX_LENGTH = AUTOCOMPLETE_GENERATION_INPUT_MAX_LENGTH
 app.state.config.VOICE_MODE_PROMPT_TEMPLATE = VOICE_MODE_PROMPT_TEMPLATE
 
 
@@ -1366,36 +1327,36 @@ async def lifespan(app: FastAPI):
 class RedirectMiddleware(BaseHTTPMiddleware):
     async def dispatch(self, request: Request, call_next):
         # Check if the request is a GET request
-        if request.method == "GET":
+        if request.method == 'GET':
             path = request.url.path
             query_params = dict(parse_qs(urlparse(str(request.url)).query))
 
             redirect_params = {}
 
             # Check for the specific watch path and the presence of 'v' parameter
-            if path.endswith("/watch") and "v" in query_params:
+            if path.endswith('/watch') and 'v' in query_params:
                 # Extract the first 'v' parameter
-                youtube_video_id = query_params["v"][0]
-                redirect_params["youtube"] = youtube_video_id
+                youtube_video_id = query_params['v'][0]
+                redirect_params['youtube'] = youtube_video_id
 
-            if "shared" in query_params and len(query_params["shared"]) > 0:
+            if 'shared' in query_params and len(query_params['shared']) > 0:
                 # PWA share_target support
 
-                text = query_params["shared"][0]
+                text = query_params['shared'][0]
                 if text:
-                    urls = re.match(r"https://\S+", text)
+                    urls = re.match(r'https://\S+', text)
                     if urls:
                         from open_webui.retrieval.loaders.youtube import _parse_video_id
 
                         if youtube_video_id := _parse_video_id(urls[0]):
-                            redirect_params["youtube"] = youtube_video_id
+                            redirect_params['youtube'] = youtube_video_id
                         else:
-                            redirect_params["load-url"] = urls[0]
+                            redirect_params['load-url'] = urls[0]
                     else:
-                        redirect_params["q"] = text
+                        redirect_params['q'] = text
 
             if redirect_params:
-                redirect_url = f"/?{urlencode(redirect_params)}"
+                redirect_url = f'/?{urlencode(redirect_params)}'
                 return RedirectResponse(url=redirect_url)
 
         # Proceed with the normal flow of other requests
@@ -1412,43 +1373,37 @@ def __init__(self, app):
         self.app = app
 
     async def __call__(self, scope, receive, send):
-        if scope["type"] == "http":
+        if scope['type'] == 'http':
             request = Request(scope)
-            auth_header = request.headers.get("Authorization")
+            auth_header = request.headers.get('Authorization')
             token = None
 
             if auth_header:
-                parts = auth_header.split(" ", 1)
+                parts = auth_header.split(' ', 1)
                 if len(parts) == 2:
                     token = parts[1]
 
             # Only apply restrictions if an sk- API key is used
-            if token and token.startswith("sk-"):
+            if token and token.startswith('sk-'):
                 # Check if restrictions are enabled
                 if app.state.config.ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS:
                     allowed_paths = [
                         path.strip()
-                        for path in str(
-                            app.state.config.API_KEYS_ALLOWED_ENDPOINTS
-                        ).split(",")
+                        for path in str(app.state.config.API_KEYS_ALLOWED_ENDPOINTS).split(',')
                         if path.strip()
                     ]
 
                     request_path = request.url.path
 
                     # Match exact path or prefix path
                     is_allowed = any(
-                        request_path == allowed
-                        or request_path.startswith(allowed + "/")
-                        for allowed in allowed_paths
+                        request_path == allowed or request_path.startswith(allowed + '/') for allowed in allowed_paths
                     )
 
                     if not is_allowed:
                         await JSONResponse(
                             status_code=status.HTTP_403_FORBIDDEN,
-                            content={
-                                "detail": "API key not allowed to access this endpoint."
-                            },
+                            content={'detail': 'API key not allowed to access this endpoint.'},
                         )(scope, receive, send)
                         return
 
@@ -1458,7 +1413,7 @@ async def __call__(self, scope, receive, send):
 app.add_middleware(APIKeyRestrictionMiddleware)
 
 
-@app.middleware("http")
+@app.middleware('http')
 async def commit_session_after_request(request: Request, call_next):
     response = await call_next(request)
     # log.debug("Commit session after request")
@@ -1472,51 +1427,44 @@ async def commit_session_after_request(request: Request, call_next):
     return response
 
 
-@app.middleware("http")
+@app.middleware('http')
 async def check_url(request: Request, call_next):
     start_time = int(time.time())
-    request.state.token = get_http_authorization_cred(
-        request.headers.get("Authorization")
-    )
+    request.state.token = get_http_authorization_cred(request.headers.get('Authorization'))
     # Fallback to cookie token for browser sessions
-    if request.state.token is None and request.cookies.get("token"):
+    if request.state.token is None and request.cookies.get('token'):
         from fastapi.security import HTTPAuthorizationCredentials
 
-        request.state.token = HTTPAuthorizationCredentials(
-            scheme="Bearer", credentials=request.cookies.get("token")
-        )
+        request.state.token = HTTPAuthorizationCredentials(scheme='Bearer', credentials=request.cookies.get('token'))
 
     # Fallback to x-api-key header for Anthropic Messages API routes
-    if request.state.token is None and request.headers.get("x-api-key"):
+    if request.state.token is None and request.headers.get('x-api-key'):
         request_path = request.url.path
-        if request_path in ("/api/message", "/api/v1/messages"):
+        if request_path in ('/api/message', '/api/v1/messages'):
             from fastapi.security import HTTPAuthorizationCredentials
 
             request.state.token = HTTPAuthorizationCredentials(
-                scheme="Bearer", credentials=request.headers.get("x-api-key")
+                scheme='Bearer', credentials=request.headers.get('x-api-key')
             )
 
     request.state.enable_api_keys = app.state.config.ENABLE_API_KEYS
     response = await call_next(request)
     process_time = int(time.time()) - start_time
-    response.headers["X-Process-Time"] = str(process_time)
+    response.headers['X-Process-Time'] = str(process_time)
     return response
 
 
-@app.middleware("http")
+@app.middleware('http')
 async def inspect_websocket(request: Request, call_next):
-    if (
-        "/ws/socket.io" in request.url.path
-        and request.query_params.get("transport") == "websocket"
-    ):
-        upgrade = (request.headers.get("Upgrade") or "").lower()
-        connection = (request.headers.get("Connection") or "").lower().split(",")
+    if '/ws/socket.io' in request.url.path and request.query_params.get('transport') == 'websocket':
+        upgrade = (request.headers.get('Upgrade') or '').lower()
+        connection = (request.headers.get('Connection') or '').lower().split(',')
         # Check that there's the correct headers for an upgrade, else reject the connection
         # This is to work around this upstream issue: https://github.com/miguelgrinberg/python-engineio/issues/367
-        if upgrade != "websocket" or "upgrade" not in connection:
+        if upgrade != 'websocket' or 'upgrade' not in connection:
             return JSONResponse(
                 status_code=status.HTTP_400_BAD_REQUEST,
-                content={"detail": "Invalid WebSocket upgrade request"},
+                content={'detail': 'Invalid WebSocket upgrade request'},
             )
     return await call_next(request)
 
@@ -1525,64 +1473,62 @@ async def inspect_websocket(request: Request, call_next):
     CORSMiddleware,
     allow_origins=CORS_ALLOW_ORIGIN,
     allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
+    allow_methods=['*'],
+    allow_headers=['*'],
 )
 
 
-app.mount("/ws", socket_app)
+app.mount('/ws', socket_app)
 
 
-app.include_router(ollama.router, prefix="/ollama", tags=["ollama"])
-app.include_router(openai.router, prefix="/openai", tags=["openai"])
+app.include_router(ollama.router, prefix='/ollama', tags=['ollama'])
+app.include_router(openai.router, prefix='/openai', tags=['openai'])
 
 
-app.include_router(pipelines.router, prefix="/api/v1/pipelines", tags=["pipelines"])
-app.include_router(tasks.router, prefix="/api/v1/tasks", tags=["tasks"])
-app.include_router(images.router, prefix="/api/v1/images", tags=["images"])
+app.include_router(pipelines.router, prefix='/api/v1/pipelines', tags=['pipelines'])
+app.include_router(tasks.router, prefix='/api/v1/tasks', tags=['tasks'])
+app.include_router(images.router, prefix='/api/v1/images', tags=['images'])
 
-app.include_router(audio.router, prefix="/api/v1/audio", tags=["audio"])
-app.include_router(retrieval.router, prefix="/api/v1/retrieval", tags=["retrieval"])
+app.include_router(audio.router, prefix='/api/v1/audio', tags=['audio'])
+app.include_router(retrieval.router, prefix='/api/v1/retrieval', tags=['retrieval'])
 
-app.include_router(configs.router, prefix="/api/v1/configs", tags=["configs"])
+app.include_router(configs.router, prefix='/api/v1/configs', tags=['configs'])
 
-app.include_router(auths.router, prefix="/api/v1/auths", tags=["auths"])
-app.include_router(users.router, prefix="/api/v1/users", tags=["users"])
+app.include_router(auths.router, prefix='/api/v1/auths', tags=['auths'])
+app.include_router(users.router, prefix='/api/v1/users', tags=['users'])
 
 
-app.include_router(channels.router, prefix="/api/v1/channels", tags=["channels"])
-app.include_router(chats.router, prefix="/api/v1/chats", tags=["chats"])
-app.include_router(notes.router, prefix="/api/v1/notes", tags=["notes"])
+app.include_router(channels.router, prefix='/api/v1/channels', tags=['channels'])
+app.include_router(chats.router, prefix='/api/v1/chats', tags=['chats'])
+app.include_router(notes.router, prefix='/api/v1/notes', tags=['notes'])
 
 
-app.include_router(models.router, prefix="/api/v1/models", tags=["models"])
-app.include_router(knowledge.router, prefix="/api/v1/knowledge", tags=["knowledge"])
-app.include_router(prompts.router, prefix="/api/v1/prompts", tags=["prompts"])
-app.include_router(tools.router, prefix="/api/v1/tools", tags=["tools"])
-app.include_router(skills.router, prefix="/api/v1/skills", tags=["skills"])
+app.include_router(models.router, prefix='/api/v1/models', tags=['models'])
+app.include_router(knowledge.router, prefix='/api/v1/knowledge', tags=['knowledge'])
+app.include_router(prompts.router, prefix='/api/v1/prompts', tags=['prompts'])
+app.include_router(tools.router, prefix='/api/v1/tools', tags=['tools'])
+app.include_router(skills.router, prefix='/api/v1/skills', tags=['skills'])
 
-app.include_router(memories.router, prefix="/api/v1/memories", tags=["memories"])
-app.include_router(folders.router, prefix="/api/v1/folders", tags=["folders"])
-app.include_router(groups.router, prefix="/api/v1/groups", tags=["groups"])
-app.include_router(files.router, prefix="/api/v1/files", tags=["files"])
-app.include_router(functions.router, prefix="/api/v1/functions", tags=["functions"])
-app.include_router(
-    evaluations.router, prefix="/api/v1/evaluations", tags=["evaluations"]
-)
+app.include_router(memories.router, prefix='/api/v1/memories', tags=['memories'])
+app.include_router(folders.router, prefix='/api/v1/folders', tags=['folders'])
+app.include_router(groups.router, prefix='/api/v1/groups', tags=['groups'])
+app.include_router(files.router, prefix='/api/v1/files', tags=['files'])
+app.include_router(functions.router, prefix='/api/v1/functions', tags=['functions'])
+app.include_router(evaluations.router, prefix='/api/v1/evaluations', tags=['evaluations'])
 if ENABLE_ADMIN_ANALYTICS:
-    app.include_router(analytics.router, prefix="/api/v1/analytics", tags=["analytics"])
-app.include_router(utils.router, prefix="/api/v1/utils", tags=["utils"])
-app.include_router(terminals.router, prefix="/api/v1/terminals", tags=["terminals"])
+    app.include_router(analytics.router, prefix='/api/v1/analytics', tags=['analytics'])
+app.include_router(utils.router, prefix='/api/v1/utils', tags=['utils'])
+app.include_router(terminals.router, prefix='/api/v1/terminals', tags=['terminals'])
 
 # SCIM 2.0 API for identity management
 if ENABLE_SCIM:
-    app.include_router(scim.router, prefix="/api/v1/scim/v2", tags=["scim"])
+    app.include_router(scim.router, prefix='/api/v1/scim/v2', tags=['scim'])
 
 
 try:
     audit_level = AuditLevel(AUDIT_LOG_LEVEL)
 except ValueError as e:
-    logger.error(f"Invalid audit level: {AUDIT_LOG_LEVEL}. Error: {e}")
+    logger.error(f'Invalid audit level: {AUDIT_LOG_LEVEL}. Error: {e}')
     audit_level = AuditLevel.NONE
 
 if audit_level != AuditLevel.NONE:
@@ -1600,35 +1546,30 @@ async def inspect_websocket(request: Request, call_next):
 ##################################
 
 
-@app.get("/api/models")
-@app.get("/api/v1/models")  # Experimental: Compatibility with OpenAI API
-async def get_models(
-    request: Request, refresh: bool = False, user=Depends(get_verified_user)
-):
+@app.get('/api/models')
+@app.get('/api/v1/models')  # Experimental: Compatibility with OpenAI API
+async def get_models(request: Request, refresh: bool = False, user=Depends(get_verified_user)):
     all_models = await get_all_models(request, refresh=refresh, user=user)
 
     models = []
     for model in all_models:
         # Filter out filter pipelines
-        if "pipeline" in model and model["pipeline"].get("type", None) == "filter":
+        if 'pipeline' in model and model['pipeline'].get('type', None) == 'filter':
             continue
 
         # Remove profile image URL to reduce payload size
-        if model.get("info", {}).get("meta", {}).get("profile_image_url"):
-            model["info"]["meta"].pop("profile_image_url", None)
+        if model.get('info', {}).get('meta', {}).get('profile_image_url'):
+            model['info']['meta'].pop('profile_image_url', None)
 
         try:
-            model_tags = [
-                tag.get("name")
-                for tag in model.get("info", {}).get("meta", {}).get("tags", [])
-            ]
-            tags = [tag.get("name") for tag in model.get("tags", [])]
+            model_tags = [tag.get('name') for tag in model.get('info', {}).get('meta', {}).get('tags', [])]
+            tags = [tag.get('name') for tag in model.get('tags', [])]
 
             tags = list(set(model_tags + tags))
-            model["tags"] = [{"name": tag} for tag in tags]
+            model['tags'] = [{'name': tag} for tag in tags]
         except Exception as e:
-            log.debug(f"Error processing model tags: {e}")
-            model["tags"] = []
+            log.debug(f'Error processing model tags: {e}')
+            model['tags'] = []
             pass
 
         models.append(model)
@@ -1639,35 +1580,33 @@ async def get_models(
         # Sort models by order list priority, with fallback for those not in the list
         models.sort(
             key=lambda model: (
-                model_order_dict.get(model.get("id", ""), float("inf")),
-                (model.get("name", "") or ""),
+                model_order_dict.get(model.get('id', ''), float('inf')),
+                (model.get('name', '') or ''),
             )
         )
 
     models = get_filtered_models(models, user)
 
     log.debug(
-        f"/api/models returned filtered models accessible to the user: {json.dumps([model.get('id') for model in models])}"
+        f'/api/models returned filtered models accessible to the user: {json.dumps([model.get("id") for model in models])}'
     )
-    return {"data": models}
+    return {'data': models}
 
 
-@app.get("/api/models/base")
+@app.get('/api/models/base')
 async def get_base_models(request: Request, user=Depends(get_admin_user)):
     models = await get_all_base_models(request, user=user)
-    return {"data": models}
+    return {'data': models}
 
 
 ##################################
 # Embeddings
 ##################################
 
 
-@app.post("/api/embeddings")
-@app.post("/api/v1/embeddings")  # Experimental: Compatibility with OpenAI API
-async def embeddings(
-    request: Request, form_data: dict, user=Depends(get_verified_user)
-):
+@app.post('/api/embeddings')
+@app.post('/api/v1/embeddings')  # Experimental: Compatibility with OpenAI API
+async def embeddings(request: Request, form_data: dict, user=Depends(get_verified_user)):
     """
     OpenAI-compatible embeddings endpoint.
 
@@ -1690,8 +1629,8 @@ async def embeddings(
     return await generate_embeddings(request, form_data, user)
 
 
-@app.post("/api/chat/completions")
-@app.post("/api/v1/chat/completions")  # Experimental: Compatibility with OpenAI API
+@app.post('/api/chat/completions')
+@app.post('/api/v1/chat/completions')  # Experimental: Compatibility with OpenAI API
 async def chat_completion(
     request: Request,
     form_data: dict,
@@ -1700,24 +1639,22 @@ async def chat_completion(
     if not request.app.state.MODELS:
         await get_all_models(request, user=user)
 
-    model_id = form_data.get("model", None)
-    model_item = form_data.pop("model_item", {})
-    tasks = form_data.pop("background_tasks", None)
+    model_id = form_data.get('model', None)
+    model_item = form_data.pop('model_item', {})
+    tasks = form_data.pop('background_tasks', None)
 
     metadata = {}
     try:
         model_info = None
-        if not model_item.get("direct", False):
+        if not model_item.get('direct', False):
             if model_id not in request.app.state.MODELS:
-                raise Exception("Model not found")
+                raise Exception('Model not found')
 
             model = request.app.state.MODELS[model_id]
             model_info = Models.get_model_by_id(model_id)
 
             # Check if user has access to the model
-            if not BYPASS_MODEL_ACCESS_CONTROL and (
-                user.role != "admin" or not BYPASS_ADMIN_ACCESS_CONTROL
-            ):
+            if not BYPASS_MODEL_ACCESS_CONTROL and (user.role != 'admin' or not BYPASS_ADMIN_ACCESS_CONTROL):
                 try:
                     check_model_access(user, model)
                 except Exception as e:
@@ -1729,235 +1666,206 @@ async def chat_completion(
             request.state.model = model
 
         # Model params: global defaults as base, per-model overrides win
-        default_model_params = (
-            getattr(request.app.state.config, "DEFAULT_MODEL_PARAMS", None) or {}
-        )
+        default_model_params = getattr(request.app.state.config, 'DEFAULT_MODEL_PARAMS', None) or {}
         model_info_params = {
             **default_model_params,
-            **(
-                model_info.params.model_dump()
-                if model_info and model_info.params
-                else {}
-            ),
+            **(model_info.params.model_dump() if model_info and model_info.params else {}),
         }
 
         # Check base model existence for custom models
         if model_info and model_info.base_model_id:
             base_model_id = model_info.base_model_id
             if base_model_id not in request.app.state.MODELS:
                 if ENABLE_CUSTOM_MODEL_FALLBACK:
-                    default_models = (
-                        request.app.state.config.DEFAULT_MODELS or ""
-                    ).split(",")
+                    default_models = (request.app.state.config.DEFAULT_MODELS or '').split(',')
 
-                    fallback_model_id = (
-                        default_models[0].strip() if default_models[0] else None
-                    )
+                    fallback_model_id = default_models[0].strip() if default_models[0] else None
 
-                    if (
-                        fallback_model_id
-                        and fallback_model_id in request.app.state.MODELS
-                    ):
+                    if fallback_model_id and fallback_model_id in request.app.state.MODELS:
                         # Update model and form_data so routing uses the fallback model's type
                         model = request.app.state.MODELS[fallback_model_id]
-                        form_data["model"] = fallback_model_id
+                        form_data['model'] = fallback_model_id
                     else:
-                        raise Exception("Model not found")
+                        raise Exception('Model not found')
                 else:
-                    raise Exception("Model not found")
+                    raise Exception('Model not found')
 
         # Chat Params
-        stream_delta_chunk_size = form_data.get("params", {}).get(
-            "stream_delta_chunk_size"
-        )
-        reasoning_tags = form_data.get("params", {}).get("reasoning_tags")
+        stream_delta_chunk_size = form_data.get('params', {}).get('stream_delta_chunk_size')
+        reasoning_tags = form_data.get('params', {}).get('reasoning_tags')
 
         # Model Params
-        if model_info_params.get("stream_response") is not None:
-            form_data["stream"] = model_info_params.get("stream_response")
+        if model_info_params.get('stream_response') is not None:
+            form_data['stream'] = model_info_params.get('stream_response')
 
-        if model_info_params.get("stream_delta_chunk_size"):
-            stream_delta_chunk_size = model_info_params.get("stream_delta_chunk_size")
+        if model_info_params.get('stream_delta_chunk_size'):
+            stream_delta_chunk_size = model_info_params.get('stream_delta_chunk_size')
 
-        if model_info_params.get("reasoning_tags") is not None:
-            reasoning_tags = model_info_params.get("reasoning_tags")
+        if model_info_params.get('reasoning_tags') is not None:
+            reasoning_tags = model_info_params.get('reasoning_tags')
 
         metadata = {
-            "user_id": user.id,
-            "chat_id": form_data.pop("chat_id", None),
-            "message_id": form_data.pop("id", None),
-            "parent_message": form_data.pop("parent_message", None),
-            "parent_message_id": form_data.pop("parent_id", None),
-            "session_id": form_data.pop("session_id", None),
-            "filter_ids": form_data.pop("filter_ids", []),
-            "tool_ids": form_data.get("tool_ids", None),
-            "tool_servers": form_data.pop("tool_servers", None),
-            "files": form_data.get("files", None),
-            "features": form_data.get("features", {}),
-            "variables": form_data.get("variables", {}),
-            "model": model,
-            "direct": model_item.get("direct", False),
-            "params": {
-                "stream_delta_chunk_size": stream_delta_chunk_size,
-                "reasoning_tags": reasoning_tags,
-                "function_calling": (
-                    "native"
+            'user_id': user.id,
+            'chat_id': form_data.pop('chat_id', None),
+            'message_id': form_data.pop('id', None),
+            'parent_message': form_data.pop('parent_message', None),
+            'parent_message_id': form_data.pop('parent_id', None),
+            'session_id': form_data.pop('session_id', None),
+            'filter_ids': form_data.pop('filter_ids', []),
+            'tool_ids': form_data.get('tool_ids', None),
+            'tool_servers': form_data.pop('tool_servers', None),
+            'files': form_data.get('files', None),
+            'features': form_data.get('features', {}),
+            'variables': form_data.get('variables', {}),
+            'model': model,
+            'direct': model_item.get('direct', False),
+            'params': {
+                'stream_delta_chunk_size': stream_delta_chunk_size,
+                'reasoning_tags': reasoning_tags,
+                'function_calling': (
+                    'native'
                     if (
-                        form_data.get("params", {}).get("function_calling") == "native"
-                        or model_info_params.get("function_calling") == "native"
+                        form_data.get('params', {}).get('function_calling') == 'native'
+                        or model_info_params.get('function_calling') == 'native'
                     )
-                    else "default"
+                    else 'default'
                 ),
             },
         }
 
-        if metadata.get("chat_id") and user:
-            if not metadata["chat_id"].startswith(
-                "local:"
-            ):  # temporary chats are not stored
-
+        if metadata.get('chat_id') and user:
+            if not metadata['chat_id'].startswith('local:'):  # temporary chats are not stored
                 # Verify chat ownership — lightweight EXISTS check avoids
                 # deserializing the full chat JSON blob just to confirm the row exists
                 if (
-                    not Chats.is_chat_owner(metadata["chat_id"], user.id)
-                    and user.role != "admin"
+                    not Chats.is_chat_owner(metadata['chat_id'], user.id) and user.role != 'admin'
                 ):  # admins can access any chat
                     raise HTTPException(
                         status_code=status.HTTP_404_NOT_FOUND,
                         detail=ERROR_MESSAGES.DEFAULT(),
                     )
 
                 # Insert chat files from parent message if any
-                parent_message = metadata.get("parent_message") or {}
-                parent_message_files = parent_message.get("files", [])
+                parent_message = metadata.get('parent_message') or {}
+                parent_message_files = parent_message.get('files', [])
                 if parent_message_files:
                     try:
                         Chats.insert_chat_files(
-                            metadata["chat_id"],
-                            parent_message.get("id"),
+                            metadata['chat_id'],
+                            parent_message.get('id'),
                             [
-                                file_item.get("id")
+                                file_item.get('id')
                                 for file_item in parent_message_files
-                                if file_item.get("type") == "file"
+                                if file_item.get('type') == 'file'
                             ],
                             user.id,
                         )
                     except Exception as e:
-                        log.debug(f"Error inserting chat files: {e}")
+                        log.debug(f'Error inserting chat files: {e}')
                         pass
 
         request.state.metadata = metadata
-        form_data["metadata"] = metadata
+        form_data['metadata'] = metadata
 
     except Exception as e:
-        log.debug(f"Error processing chat metadata: {e}")
+        log.debug(f'Error processing chat metadata: {e}')
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail=str(e),
         )
 
     async def process_chat(request, form_data, user, metadata, model):
         try:
-            form_data, metadata, events = await process_chat_payload(
-                request, form_data, user, metadata, model
-            )
+            form_data, metadata, events = await process_chat_payload(request, form_data, user, metadata, model)
 
             response = await chat_completion_handler(request, form_data, user)
-            if metadata.get("chat_id") and metadata.get("message_id"):
+            if metadata.get('chat_id') and metadata.get('message_id'):
                 try:
-                    if not metadata["chat_id"].startswith("local:"):
+                    if not metadata['chat_id'].startswith('local:'):
                         Chats.upsert_message_to_chat_by_id_and_message_id(
-                            metadata["chat_id"],
-                            metadata["message_id"],
+                            metadata['chat_id'],
+                            metadata['message_id'],
                             {
-                                "parentId": metadata.get("parent_message_id", None),
-                                "model": model_id,
+                                'parentId': metadata.get('parent_message_id', None),
+                                'model': model_id,
                             },
                         )
                 except Exception:
                     pass
 
-            ctx = build_chat_response_context(
-                request, form_data, user, model, metadata, tasks, events
-            )
+            ctx = build_chat_response_context(request, form_data, user, model, metadata, tasks, events)
 
             return await process_chat_response(response, ctx)
         except asyncio.CancelledError:
-            log.info("Chat processing was cancelled")
+            log.info('Chat processing was cancelled')
             try:
                 event_emitter = get_event_emitter(metadata)
                 await asyncio.shield(
                     event_emitter(
-                        {"type": "chat:tasks:cancel"},
+                        {'type': 'chat:tasks:cancel'},
                     )
                 )
             except Exception as e:
                 pass
             finally:
                 raise  # re-raise to ensure proper task cancellation handling
         except Exception as e:
-            log.debug(f"Error processing chat payload: {e}")
-            if metadata.get("chat_id") and metadata.get("message_id"):
+            log.debug(f'Error processing chat payload: {e}')
+            if metadata.get('chat_id') and metadata.get('message_id'):
                 # Update the chat message with the error
                 try:
-                    if not metadata["chat_id"].startswith("local:"):
+                    if not metadata['chat_id'].startswith('local:'):
                         Chats.upsert_message_to_chat_by_id_and_message_id(
-                            metadata["chat_id"],
-                            metadata["message_id"],
+                            metadata['chat_id'],
+                            metadata['message_id'],
                             {
-                                "parentId": metadata.get("parent_message_id", None),
-                                "error": {"content": str(e)},
+                                'parentId': metadata.get('parent_message_id', None),
+                                'error': {'content': str(e)},
                             },
                         )
 
                     event_emitter = get_event_emitter(metadata)
                     await event_emitter(
                         {
-                            "type": "chat:message:error",
-                            "data": {"error": {"content": str(e)}},
+                            'type': 'chat:message:error',
+                            'data': {'error': {'content': str(e)}},
                         }
                     )
                     await event_emitter(
-                        {"type": "chat:tasks:cancel"},
+                        {'type': 'chat:tasks:cancel'},
                     )
 
                 except Exception:
                     pass
         finally:
             try:
-                if mcp_clients := metadata.get("mcp_clients"):
+                if mcp_clients := metadata.get('mcp_clients'):
                     for client in reversed(mcp_clients.values()):
                         await client.disconnect()
             except Exception as e:
-                log.debug(f"Error cleaning up: {e}")
+                log.debug(f'Error cleaning up: {e}')
                 pass
             # Emit chat:active=false when task completes
             try:
-                if metadata.get("chat_id"):
+                if metadata.get('chat_id'):
                     event_emitter = get_event_emitter(metadata, update_db=False)
                     if event_emitter:
-                        await event_emitter(
-                            {"type": "chat:active", "data": {"active": False}}
-                        )
+                        await event_emitter({'type': 'chat:active', 'data': {'active': False}})
             except Exception as e:
-                log.debug(f"Error emitting chat:active: {e}")
+                log.debug(f'Error emitting chat:active: {e}')
 
-    if (
-        metadata.get("session_id")
-        and metadata.get("chat_id")
-        and metadata.get("message_id")
-    ):
+    if metadata.get('session_id') and metadata.get('chat_id') and metadata.get('message_id'):
         # Asynchronous Chat Processing
         task_id, _ = await create_task(
             request.app.state.redis,
             process_chat(request, form_data, user, metadata, model),
-            id=metadata["chat_id"],
+            id=metadata['chat_id'],
         )
         # Emit chat:active=true when task starts
         event_emitter = get_event_emitter(metadata, update_db=False)
         if event_emitter:
-            await event_emitter({"type": "chat:active", "data": {"active": True}})
-        return {"status": True, "task_id": task_id}
+            await event_emitter({'type': 'chat:active', 'data': {'active': True}})
+        return {'status': True, 'task_id': task_id}
     else:
         return await process_chat(request, form_data, user, metadata, model)
 
@@ -1981,8 +1889,8 @@ async def process_chat(request, form_data, user, metadata, model):
 )
 
 
-@app.post("/api/message")
-@app.post("/api/v1/messages")  # Anthropic Messages API compatible endpoint
+@app.post('/api/message')
+@app.post('/api/v1/messages')  # Anthropic Messages API compatible endpoint
 async def generate_messages(
     request: Request,
     form_data: dict,
@@ -2002,7 +1910,7 @@ async def generate_messages(
     Anthropic's x-api-key header (via middleware translation).
     """
     # Convert Anthropic payload to OpenAI format
-    requested_model = form_data.get("model", "")
+    requested_model = form_data.get('model', '')
 
     openai_payload = convert_anthropic_to_openai_payload(form_data)
 
@@ -2013,13 +1921,11 @@ async def generate_messages(
     if isinstance(response, StreamingResponse):
         # Streaming response: wrap the generator to convert SSE format
         return StreamingResponse(
-            openai_stream_to_anthropic_stream(
-                response.body_iterator, model=requested_model
-            ),
-            media_type="text/event-stream",
+            openai_stream_to_anthropic_stream(response.body_iterator, model=requested_model),
+            media_type='text/event-stream',
             headers={
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
             },
         )
     elif isinstance(response, dict):
@@ -2029,14 +1935,12 @@ async def generate_messages(
         return response
 
 
-@app.post("/api/chat/completed")
-async def chat_completed(
-    request: Request, form_data: dict, user=Depends(get_verified_user)
-):
+@app.post('/api/chat/completed')
+async def chat_completed(request: Request, form_data: dict, user=Depends(get_verified_user)):
     try:
-        model_item = form_data.pop("model_item", {})
+        model_item = form_data.pop('model_item', {})
 
-        if model_item.get("direct", False):
+        if model_item.get('direct', False):
             request.state.direct = True
             request.state.model = model_item
 
@@ -2048,14 +1952,12 @@ async def chat_completed(
         )
 
 
-@app.post("/api/chat/actions/{action_id}")
-async def chat_action(
-    request: Request, action_id: str, form_data: dict, user=Depends(get_verified_user)
-):
+@app.post('/api/chat/actions/{action_id}')
+async def chat_action(request: Request, action_id: str, form_data: dict, user=Depends(get_verified_user)):
     try:
-        model_item = form_data.pop("model_item", {})
+        model_item = form_data.pop('model_item', {})
 
-        if model_item.get("direct", False):
+        if model_item.get('direct', False):
             request.state.direct = True
             request.state.model = model_item
 
@@ -2067,34 +1969,30 @@ async def chat_action(
         )
 
 
-@app.post("/api/tasks/stop/{task_id}")
-async def stop_task_endpoint(
-    request: Request, task_id: str, user=Depends(get_verified_user)
-):
+@app.post('/api/tasks/stop/{task_id}')
+async def stop_task_endpoint(request: Request, task_id: str, user=Depends(get_verified_user)):
     try:
         result = await stop_task(request.app.state.redis, task_id)
         return result
     except ValueError as e:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(e))
 
 
-@app.get("/api/tasks")
+@app.get('/api/tasks')
 async def list_tasks_endpoint(request: Request, user=Depends(get_verified_user)):
-    return {"tasks": await list_tasks(request.app.state.redis)}
+    return {'tasks': await list_tasks(request.app.state.redis)}
 
 
-@app.get("/api/tasks/chat/{chat_id}")
-async def list_tasks_by_chat_id_endpoint(
-    request: Request, chat_id: str, user=Depends(get_verified_user)
-):
+@app.get('/api/tasks/chat/{chat_id}')
+async def list_tasks_by_chat_id_endpoint(request: Request, chat_id: str, user=Depends(get_verified_user)):
     chat = Chats.get_chat_by_id(chat_id)
     if chat is None or chat.user_id != user.id:
-        return {"task_ids": []}
+        return {'task_ids': []}
 
     task_ids = await list_task_ids_by_item_id(request.app.state.redis, chat_id)
 
-    log.debug(f"Task IDs for chat {chat_id}: {task_ids}")
-    return {"task_ids": task_ids}
+    log.debug(f'Task IDs for chat {chat_id}: {task_ids}')
+    return {'task_ids': task_ids}
 
 
 ##################################
@@ -2104,19 +2002,19 @@ async def list_tasks_by_chat_id_endpoint(
 ##################################
 
 
-@app.get("/api/config")
+@app.get('/api/config')
 async def get_app_config(request: Request):
     user = None
     token = None
 
-    auth_header = request.headers.get("Authorization")
+    auth_header = request.headers.get('Authorization')
     if auth_header:
         cred = get_http_authorization_cred(auth_header)
         if cred:
             token = cred.credentials
 
-    if not token and "token" in request.cookies:
-        token = request.cookies.get("token")
+    if not token and 'token' in request.cookies:
+        token = request.cookies.get('token')
 
     if token:
         try:
@@ -2125,10 +2023,10 @@ async def get_app_config(request: Request):
             log.debug(e)
             raise HTTPException(
                 status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Invalid token",
+                detail='Invalid token',
             )
-        if data is not None and "id" in data:
-            user = Users.get_user_by_id(data["id"])
+        if data is not None and 'id' in data:
+            user = Users.get_user_by_id(data['id'])
 
     user_count = Users.get_num_users()
     onboarding = False
@@ -2137,55 +2035,50 @@ async def get_app_config(request: Request):
         onboarding = user_count == 0
 
     return {
-        **({"onboarding": True} if onboarding else {}),
-        "status": True,
-        "name": app.state.WEBUI_NAME,
-        "version": VERSION,
-        "default_locale": str(DEFAULT_LOCALE),
-        "oauth": {
-            "providers": {
-                name: config.get("name", name)
-                for name, config in OAUTH_PROVIDERS.items()
-            }
-        },
-        "features": {
-            "auth": WEBUI_AUTH,
-            "auth_trusted_header": bool(app.state.AUTH_TRUSTED_EMAIL_HEADER),
-            "enable_signup_password_confirmation": ENABLE_SIGNUP_PASSWORD_CONFIRMATION,
-            "enable_ldap": app.state.config.ENABLE_LDAP,
-            "enable_api_keys": app.state.config.ENABLE_API_KEYS,
-            "enable_signup": app.state.config.ENABLE_SIGNUP,
-            "enable_login_form": app.state.config.ENABLE_LOGIN_FORM,
-            "enable_websocket": ENABLE_WEBSOCKET_SUPPORT,
-            "enable_version_update_check": ENABLE_VERSION_UPDATE_CHECK,
-            "enable_public_active_users_count": ENABLE_PUBLIC_ACTIVE_USERS_COUNT,
-            "enable_easter_eggs": ENABLE_EASTER_EGGS,
+        **({'onboarding': True} if onboarding else {}),
+        'status': True,
+        'name': app.state.WEBUI_NAME,
+        'version': VERSION,
+        'default_locale': str(DEFAULT_LOCALE),
+        'oauth': {'providers': {name: config.get('name', name) for name, config in OAUTH_PROVIDERS.items()}},
+        'features': {
+            'auth': WEBUI_AUTH,
+            'auth_trusted_header': bool(app.state.AUTH_TRUSTED_EMAIL_HEADER),
+            'enable_signup_password_confirmation': ENABLE_SIGNUP_PASSWORD_CONFIRMATION,
+            'enable_ldap': app.state.config.ENABLE_LDAP,
+            'enable_api_keys': app.state.config.ENABLE_API_KEYS,
+            'enable_signup': app.state.config.ENABLE_SIGNUP,
+            'enable_login_form': app.state.config.ENABLE_LOGIN_FORM,
+            'enable_websocket': ENABLE_WEBSOCKET_SUPPORT,
+            'enable_version_update_check': ENABLE_VERSION_UPDATE_CHECK,
+            'enable_public_active_users_count': ENABLE_PUBLIC_ACTIVE_USERS_COUNT,
+            'enable_easter_eggs': ENABLE_EASTER_EGGS,
             **(
                 {
-                    "enable_direct_connections": app.state.config.ENABLE_DIRECT_CONNECTIONS,
-                    "enable_folders": app.state.config.ENABLE_FOLDERS,
-                    "folder_max_file_count": app.state.config.FOLDER_MAX_FILE_COUNT,
-                    "enable_channels": app.state.config.ENABLE_CHANNELS,
-                    "enable_notes": app.state.config.ENABLE_NOTES,
-                    "enable_web_search": app.state.config.ENABLE_WEB_SEARCH,
-                    "enable_code_execution": app.state.config.ENABLE_CODE_EXECUTION,
-                    "enable_code_interpreter": app.state.config.ENABLE_CODE_INTERPRETER,
-                    "enable_image_generation": app.state.config.ENABLE_IMAGE_GENERATION,
-                    "enable_autocomplete_generation": app.state.config.ENABLE_AUTOCOMPLETE_GENERATION,
-                    "enable_community_sharing": app.state.config.ENABLE_COMMUNITY_SHARING,
-                    "enable_message_rating": app.state.config.ENABLE_MESSAGE_RATING,
-                    "enable_user_webhooks": app.state.config.ENABLE_USER_WEBHOOKS,
-                    "enable_user_status": app.state.config.ENABLE_USER_STATUS,
-                    "enable_admin_export": ENABLE_ADMIN_EXPORT,
-                    "enable_admin_chat_access": ENABLE_ADMIN_CHAT_ACCESS,
-                    "enable_admin_analytics": ENABLE_ADMIN_ANALYTICS,
-                    "enable_google_drive_integration": app.state.config.ENABLE_GOOGLE_DRIVE_INTEGRATION,
-                    "enable_onedrive_integration": app.state.config.ENABLE_ONEDRIVE_INTEGRATION,
-                    "enable_memories": app.state.config.ENABLE_MEMORIES,
+                    'enable_direct_connections': app.state.config.ENABLE_DIRECT_CONNECTIONS,
+                    'enable_folders': app.state.config.ENABLE_FOLDERS,
+                    'folder_max_file_count': app.state.config.FOLDER_MAX_FILE_COUNT,
+                    'enable_channels': app.state.config.ENABLE_CHANNELS,
+                    'enable_notes': app.state.config.ENABLE_NOTES,
+                    'enable_web_search': app.state.config.ENABLE_WEB_SEARCH,
+                    'enable_code_execution': app.state.config.ENABLE_CODE_EXECUTION,
+                    'enable_code_interpreter': app.state.config.ENABLE_CODE_INTERPRETER,
+                    'enable_image_generation': app.state.config.ENABLE_IMAGE_GENERATION,
+                    'enable_autocomplete_generation': app.state.config.ENABLE_AUTOCOMPLETE_GENERATION,
+                    'enable_community_sharing': app.state.config.ENABLE_COMMUNITY_SHARING,
+                    'enable_message_rating': app.state.config.ENABLE_MESSAGE_RATING,
+                    'enable_user_webhooks': app.state.config.ENABLE_USER_WEBHOOKS,
+                    'enable_user_status': app.state.config.ENABLE_USER_STATUS,
+                    'enable_admin_export': ENABLE_ADMIN_EXPORT,
+                    'enable_admin_chat_access': ENABLE_ADMIN_CHAT_ACCESS,
+                    'enable_admin_analytics': ENABLE_ADMIN_ANALYTICS,
+                    'enable_google_drive_integration': app.state.config.ENABLE_GOOGLE_DRIVE_INTEGRATION,
+                    'enable_onedrive_integration': app.state.config.ENABLE_ONEDRIVE_INTEGRATION,
+                    'enable_memories': app.state.config.ENABLE_MEMORIES,
                     **(
                         {
-                            "enable_onedrive_personal": ENABLE_ONEDRIVE_PERSONAL,
-                            "enable_onedrive_business": ENABLE_ONEDRIVE_BUSINESS,
+                            'enable_onedrive_personal': ENABLE_ONEDRIVE_PERSONAL,
+                            'enable_onedrive_business': ENABLE_ONEDRIVE_BUSINESS,
                         }
                         if app.state.config.ENABLE_ONEDRIVE_INTEGRATION
                         else {}
@@ -2197,78 +2090,74 @@ async def get_app_config(request: Request):
         },
         **(
             {
-                "default_models": app.state.config.DEFAULT_MODELS,
-                "default_pinned_models": app.state.config.DEFAULT_PINNED_MODELS,
-                "default_prompt_suggestions": app.state.config.DEFAULT_PROMPT_SUGGESTIONS,
-                "user_count": user_count,
-                "code": {
-                    "engine": app.state.config.CODE_EXECUTION_ENGINE,
-                    "interpreter_engine": app.state.config.CODE_INTERPRETER_ENGINE,
+                'default_models': app.state.config.DEFAULT_MODELS,
+                'default_pinned_models': app.state.config.DEFAULT_PINNED_MODELS,
+                'default_prompt_suggestions': app.state.config.DEFAULT_PROMPT_SUGGESTIONS,
+                'user_count': user_count,
+                'code': {
+                    'engine': app.state.config.CODE_EXECUTION_ENGINE,
+                    'interpreter_engine': app.state.config.CODE_INTERPRETER_ENGINE,
                 },
-                "audio": {
-                    "tts": {
-                        "engine": app.state.config.TTS_ENGINE,
-                        "voice": app.state.config.TTS_VOICE,
-                        "split_on": app.state.config.TTS_SPLIT_ON,
+                'audio': {
+                    'tts': {
+                        'engine': app.state.config.TTS_ENGINE,
+                        'voice': app.state.config.TTS_VOICE,
+                        'split_on': app.state.config.TTS_SPLIT_ON,
                     },
-                    "stt": {
-                        "engine": app.state.config.STT_ENGINE,
+                    'stt': {
+                        'engine': app.state.config.STT_ENGINE,
                     },
                 },
-                "file": {
-                    "max_size": app.state.config.FILE_MAX_SIZE,
-                    "max_count": app.state.config.FILE_MAX_COUNT,
-                    "image_compression": {
-                        "width": app.state.config.FILE_IMAGE_COMPRESSION_WIDTH,
-                        "height": app.state.config.FILE_IMAGE_COMPRESSION_HEIGHT,
+                'file': {
+                    'max_size': app.state.config.FILE_MAX_SIZE,
+                    'max_count': app.state.config.FILE_MAX_COUNT,
+                    'image_compression': {
+                        'width': app.state.config.FILE_IMAGE_COMPRESSION_WIDTH,
+                        'height': app.state.config.FILE_IMAGE_COMPRESSION_HEIGHT,
                     },
                 },
-                "permissions": {**app.state.config.USER_PERMISSIONS},
-                "google_drive": {
-                    "client_id": GOOGLE_DRIVE_CLIENT_ID.value,
-                    "api_key": GOOGLE_DRIVE_API_KEY.value,
+                'permissions': {**app.state.config.USER_PERMISSIONS},
+                'google_drive': {
+                    'client_id': GOOGLE_DRIVE_CLIENT_ID.value,
+                    'api_key': GOOGLE_DRIVE_API_KEY.value,
                 },
-                "onedrive": {
-                    "client_id_personal": ONEDRIVE_CLIENT_ID_PERSONAL,
-                    
... [truncated]

@@ -16,7 +16,7 @@
     fileConfig(config.config_file_name, disable_existing_loggers=False)
 
 # Re-apply JSON formatter after fileConfig replaces handlers.
-if LOG_FORMAT == "json":
+if LOG_FORMAT == 'json':
     from open_webui.env import JSONFormatter
 
     for handler in logging.root.handlers:
@@ -36,7 +36,7 @@
 DB_URL = DATABASE_URL
 
 if DB_URL:
-    config.set_main_option("sqlalchemy.url", DB_URL.replace("%", "%%"))
+    config.set_main_option('sqlalchemy.url', DB_URL.replace('%', '%%'))
 
 
 def run_migrations_offline() -> None:
@@ -51,12 +51,12 @@ def run_migrations_offline() -> None:
     script output.
 
     """
-    url = config.get_main_option("sqlalchemy.url")
+    url = config.get_main_option('sqlalchemy.url')
     context.configure(
         url=url,
         target_metadata=target_metadata,
         literal_binds=True,
-        dialect_opts={"paramstyle": "named"},
+        dialect_opts={'paramstyle': 'named'},
     )
 
     with context.begin_transaction():
@@ -71,15 +71,13 @@ def run_migrations_online() -> None:
 
     """
     # Handle SQLCipher URLs
-    if DB_URL and DB_URL.startswith("sqlite+sqlcipher://"):
-        if not DATABASE_PASSWORD or DATABASE_PASSWORD.strip() == "":
-            raise ValueError(
-                "DATABASE_PASSWORD is required when using sqlite+sqlcipher:// URLs"
-            )
+    if DB_URL and DB_URL.startswith('sqlite+sqlcipher://'):
+        if not DATABASE_PASSWORD or DATABASE_PASSWORD.strip() == '':
+            raise ValueError('DATABASE_PASSWORD is required when using sqlite+sqlcipher:// URLs')
 
         # Extract database path from SQLCipher URL
-        db_path = DB_URL.replace("sqlite+sqlcipher://", "")
-        if db_path.startswith("/"):
+        db_path = DB_URL.replace('sqlite+sqlcipher://', '')
+        if db_path.startswith('/'):
             db_path = db_path[1:]  # Remove leading slash for relative paths
 
         # Create a custom creator function that uses sqlcipher3
@@ -91,15 +89,15 @@ def create_sqlcipher_connection():
             return conn
 
         connectable = create_engine(
-            "sqlite://",  # Dummy URL since we're using creator
+            'sqlite://',  # Dummy URL since we're using creator
             creator=create_sqlcipher_connection,
             echo=False,
         )
     else:
         # Standard database connection (existing logic)
         connectable = engine_from_config(
             config.get_section(config.config_ini_section, {}),
-            prefix="sqlalchemy.",
+            prefix='sqlalchemy.',
             poolclass=pool.NullPool,
         )
 

@@ -12,4 +12,4 @@ def get_existing_tables():
 def get_revision_id():
     import uuid
 
-    return str(uuid.uuid4()).replace("-", "")[:12]
+    return str(uuid.uuid4()).replace('-', '')[:12]

@@ -9,38 +9,38 @@
 from alembic import op
 import sqlalchemy as sa
 
-revision = "018012973d35"
-down_revision = "d31026856c01"
+revision = '018012973d35'
+down_revision = 'd31026856c01'
 branch_labels = None
 depends_on = None
 
 
 def upgrade():
     # Chat table indexes
-    op.create_index("folder_id_idx", "chat", ["folder_id"])
-    op.create_index("user_id_pinned_idx", "chat", ["user_id", "pinned"])
-    op.create_index("user_id_archived_idx", "chat", ["user_id", "archived"])
-    op.create_index("updated_at_user_id_idx", "chat", ["updated_at", "user_id"])
-    op.create_index("folder_id_user_id_idx", "chat", ["folder_id", "user_id"])
+    op.create_index('folder_id_idx', 'chat', ['folder_id'])
+    op.create_index('user_id_pinned_idx', 'chat', ['user_id', 'pinned'])
+    op.create_index('user_id_archived_idx', 'chat', ['user_id', 'archived'])
+    op.create_index('updated_at_user_id_idx', 'chat', ['updated_at', 'user_id'])
+    op.create_index('folder_id_user_id_idx', 'chat', ['folder_id', 'user_id'])
 
     # Tag table index
-    op.create_index("user_id_idx", "tag", ["user_id"])
+    op.create_index('user_id_idx', 'tag', ['user_id'])
 
     # Function table index
-    op.create_index("is_global_idx", "function", ["is_global"])
+    op.create_index('is_global_idx', 'function', ['is_global'])
 
 
 def downgrade():
     # Chat table indexes
-    op.drop_index("folder_id_idx", table_name="chat")
-    op.drop_index("user_id_pinned_idx", table_name="chat")
-    op.drop_index("user_id_archived_idx", table_name="chat")
-    op.drop_index("updated_at_user_id_idx", table_name="chat")
-    op.drop_index("folder_id_user_id_idx", table_name="chat")
+    op.drop_index('folder_id_idx', table_name='chat')
+    op.drop_index('user_id_pinned_idx', table_name='chat')
+    op.drop_index('user_id_archived_idx', table_name='chat')
+    op.drop_index('updated_at_user_id_idx', table_name='chat')
+    op.drop_index('folder_id_user_id_idx', table_name='chat')
 
     # Tag table index
-    op.drop_index("user_id_idx", table_name="tag")
+    op.drop_index('user_id_idx', table_name='tag')
 
     # Function table index
 
-    op.drop_index("is_global_idx", table_name="function")
+    op.drop_index('is_global_idx', table_name='function')

@@ -13,8 +13,8 @@
 
 import json
 
-revision = "1af9b942657b"
-down_revision = "242a2047eae0"
+revision = '1af9b942657b'
+down_revision = '242a2047eae0'
 branch_labels = None
 depends_on = None
 
@@ -25,43 +25,40 @@ def upgrade():
     inspector = Inspector.from_engine(conn)
 
     # Clean up potential leftover temp table from previous failures
-    conn.execute(sa.text("DROP TABLE IF EXISTS _alembic_tmp_tag"))
+    conn.execute(sa.text('DROP TABLE IF EXISTS _alembic_tmp_tag'))
 
     # Check if the 'tag' table exists
     tables = inspector.get_table_names()
 
     # Step 1: Modify Tag table using batch mode for SQLite support
-    if "tag" in tables:
+    if 'tag' in tables:
         # Get the current columns in the 'tag' table
-        columns = [col["name"] for col in inspector.get_columns("tag")]
+        columns = [col['name'] for col in inspector.get_columns('tag')]
 
         # Get any existing unique constraints on the 'tag' table
-        current_constraints = inspector.get_unique_constraints("tag")
+        current_constraints = inspector.get_unique_constraints('tag')
 
-        with op.batch_alter_table("tag", schema=None) as batch_op:
+        with op.batch_alter_table('tag', schema=None) as batch_op:
             # Check if the unique constraint already exists
-            if not any(
-                constraint["name"] == "uq_id_user_id"
-                for constraint in current_constraints
-            ):
+            if not any(constraint['name'] == 'uq_id_user_id' for constraint in current_constraints):
                 # Create unique constraint if it doesn't exist
-                batch_op.create_unique_constraint("uq_id_user_id", ["id", "user_id"])
+                batch_op.create_unique_constraint('uq_id_user_id', ['id', 'user_id'])
 
             # Check if the 'data' column exists before trying to drop it
-            if "data" in columns:
-                batch_op.drop_column("data")
+            if 'data' in columns:
+                batch_op.drop_column('data')
 
             # Check if the 'meta' column needs to be created
-            if "meta" not in columns:
+            if 'meta' not in columns:
                 # Add the 'meta' column if it doesn't already exist
-                batch_op.add_column(sa.Column("meta", sa.JSON(), nullable=True))
+                batch_op.add_column(sa.Column('meta', sa.JSON(), nullable=True))
 
     tag = table(
-        "tag",
-        column("id", sa.String()),
-        column("name", sa.String()),
-        column("user_id", sa.String()),
-        column("meta", sa.JSON()),
+        'tag',
+        column('id', sa.String()),
+        column('name', sa.String()),
+        column('user_id', sa.String()),
+        column('meta', sa.JSON()),
     )
 
     # Step 2: Migrate tags
@@ -70,12 +67,12 @@ def upgrade():
 
     tag_updates = {}
     for row in result:
-        new_id = row.name.replace(" ", "_").lower()
+        new_id = row.name.replace(' ', '_').lower()
         tag_updates[row.id] = new_id
 
     for tag_id, new_tag_id in tag_updates.items():
-        print(f"Updating tag {tag_id} to {new_tag_id}")
-        if new_tag_id == "pinned":
+        print(f'Updating tag {tag_id} to {new_tag_id}')
+        if new_tag_id == 'pinned':
             # delete tag
             delete_stmt = sa.delete(tag).where(tag.c.id == tag_id)
             conn.execute(delete_stmt)
@@ -86,9 +83,7 @@ def upgrade():
 
             if existing_tag_result:
                 # Handle duplicate case: the new_tag_id already exists
-                print(
-                    f"Tag {new_tag_id} already exists. Removing current tag with ID {tag_id} to avoid duplicates."
-                )
+                print(f'Tag {new_tag_id} already exists. Removing current tag with ID {tag_id} to avoid duplicates.')
                 # Option 1: Delete the current tag if an update to new_tag_id would cause duplication
                 delete_stmt = sa.delete(tag).where(tag.c.id == tag_id)
                 conn.execute(delete_stmt)
@@ -98,19 +93,15 @@ def upgrade():
                 conn.execute(update_stmt)
 
     # Add columns `pinned` and `meta` to 'chat'
-    op.add_column("chat", sa.Column("pinned", sa.Boolean(), nullable=True))
-    op.add_column(
-        "chat", sa.Column("meta", sa.JSON(), nullable=False, server_default="{}")
-    )
+    op.add_column('chat', sa.Column('pinned', sa.Boolean(), nullable=True))
+    op.add_column('chat', sa.Column('meta', sa.JSON(), nullable=False, server_default='{}'))
 
-    chatidtag = table(
-        "chatidtag", column("chat_id", sa.String()), column("tag_name", sa.String())
-    )
+    chatidtag = table('chatidtag', column('chat_id', sa.String()), column('tag_name', sa.String()))
     chat = table(
-        "chat",
-        column("id", sa.String()),
-        column("pinned", sa.Boolean()),
-        column("meta", sa.JSON()),
+        'chat',
+        column('id', sa.String()),
+        column('pinned', sa.Boolean()),
+        column('meta', sa.JSON()),
     )
 
     # Fetch existing tags
@@ -120,29 +111,27 @@ def upgrade():
     chat_updates = {}
     for row in result:
         chat_id = row.chat_id
-        tag_name = row.tag_name.replace(" ", "_").lower()
+        tag_name = row.tag_name.replace(' ', '_').lower()
 
-        if tag_name == "pinned":
+        if tag_name == 'pinned':
             # Specifically handle 'pinned' tag
             if chat_id not in chat_updates:
-                chat_updates[chat_id] = {"pinned": True, "meta": {}}
+                chat_updates[chat_id] = {'pinned': True, 'meta': {}}
             else:
-                chat_updates[chat_id]["pinned"] = True
+                chat_updates[chat_id]['pinned'] = True
         else:
             if chat_id not in chat_updates:
-                chat_updates[chat_id] = {"pinned": False, "meta": {"tags": [tag_name]}}
+                chat_updates[chat_id] = {'pinned': False, 'meta': {'tags': [tag_name]}}
             else:
-                tags = chat_updates[chat_id]["meta"].get("tags", [])
+                tags = chat_updates[chat_id]['meta'].get('tags', [])
                 tags.append(tag_name)
 
-                chat_updates[chat_id]["meta"]["tags"] = list(set(tags))
+                chat_updates[chat_id]['meta']['tags'] = list(set(tags))
 
     # Update chats based on accumulated changes
     for chat_id, updates in chat_updates.items():
         update_stmt = sa.update(chat).where(chat.c.id == chat_id)
-        update_stmt = update_stmt.values(
-            meta=updates.get("meta", {}), pinned=updates.get("pinned", False)
-        )
+        update_stmt = update_stmt.values(meta=updates.get('meta', {}), pinned=updates.get('pinned', False))
         conn.execute(update_stmt)
     pass
 

@@ -12,8 +12,8 @@
 
 import json
 
-revision = "242a2047eae0"
-down_revision = "6a39f3d8e55c"
+revision = '242a2047eae0'
+down_revision = '6a39f3d8e55c'
 branch_labels = None
 depends_on = None
 
@@ -22,39 +22,37 @@ def upgrade():
     conn = op.get_bind()
     inspector = sa.inspect(conn)
 
-    columns = inspector.get_columns("chat")
-    column_dict = {col["name"]: col for col in columns}
+    columns = inspector.get_columns('chat')
+    column_dict = {col['name']: col for col in columns}
 
-    chat_column = column_dict.get("chat")
-    old_chat_exists = "old_chat" in column_dict
+    chat_column = column_dict.get('chat')
+    old_chat_exists = 'old_chat' in column_dict
 
     if chat_column:
-        if isinstance(chat_column["type"], sa.Text):
+        if isinstance(chat_column['type'], sa.Text):
             print("Converting 'chat' column to JSON")
 
             if old_chat_exists:
                 print("Dropping old 'old_chat' column")
-                op.drop_column("chat", "old_chat")
+                op.drop_column('chat', 'old_chat')
 
             # Step 1: Rename current 'chat' column to 'old_chat'
             print("Renaming 'chat' column to 'old_chat'")
-            op.alter_column(
-                "chat", "chat", new_column_name="old_chat", existing_type=sa.Text()
-            )
+            op.alter_column('chat', 'chat', new_column_name='old_chat', existing_type=sa.Text())
 
             # Step 2: Add new 'chat' column of type JSON
             print("Adding new 'chat' column of type JSON")
-            op.add_column("chat", sa.Column("chat", sa.JSON(), nullable=True))
+            op.add_column('chat', sa.Column('chat', sa.JSON(), nullable=True))
         else:
             # If the column is already JSON, no need to do anything
             pass
 
     # Step 3: Migrate data from 'old_chat' to 'chat'
     chat_table = table(
-        "chat",
-        sa.Column("id", sa.String(), primary_key=True),
-        sa.Column("old_chat", sa.Text()),
-        sa.Column("chat", sa.JSON()),
+        'chat',
+        sa.Column('id', sa.String(), primary_key=True),
+        sa.Column('old_chat', sa.Text()),
+        sa.Column('chat', sa.JSON()),
     )
 
     # - Selecting all data from the table
@@ -67,41 +65,33 @@ def upgrade():
         except json.JSONDecodeError:
             json_data = None  # Handle cases where the text cannot be converted to JSON
 
-        connection.execute(
-            sa.update(chat_table)
-            .where(chat_table.c.id == row.id)
-            .values(chat=json_data)
-        )
+        connection.execute(sa.update(chat_table).where(chat_table.c.id == row.id).values(chat=json_data))
 
     # Step 4: Drop 'old_chat' column
     print("Dropping 'old_chat' column")
-    op.drop_column("chat", "old_chat")
+    op.drop_column('chat', 'old_chat')
 
 
 def downgrade():
     # Step 1: Add 'old_chat' column back as Text
-    op.add_column("chat", sa.Column("old_chat", sa.Text(), nullable=True))
+    op.add_column('chat', sa.Column('old_chat', sa.Text(), nullable=True))
 
     # Step 2: Convert 'chat' JSON data back to text and store in 'old_chat'
     chat_table = table(
-        "chat",
-        sa.Column("id", sa.String(), primary_key=True),
-        sa.Column("chat", sa.JSON()),
-        sa.Column("old_chat", sa.Text()),
+        'chat',
+        sa.Column('id', sa.String(), primary_key=True),
+        sa.Column('chat', sa.JSON()),
+        sa.Column('old_chat', sa.Text()),
     )
 
     connection = op.get_bind()
     results = connection.execute(select(chat_table.c.id, chat_table.c.chat))
     for row in results:
         text_data = json.dumps(row.chat) if row.chat is not None else None
-        connection.execute(
-            sa.update(chat_table)
-            .where(chat_table.c.id == row.id)
-            .values(old_chat=text_data)
-        )
+        connection.execute(sa.update(chat_table).where(chat_table.c.id == row.id).values(old_chat=text_data))
 
     # Step 3: Remove the new 'chat' JSON column
-    op.drop_column("chat", "chat")
+    op.drop_column('chat', 'chat')
 
     # Step 4: Rename 'old_chat' back to 'chat'
-    op.alter_column("chat", "old_chat", new_column_name="chat", existing_type=sa.Text())
+    op.alter_column('chat', 'old_chat', new_column_name='chat', existing_type=sa.Text())

@@ -13,19 +13,19 @@
 import open_webui.internal.db
 
 # revision identifiers, used by Alembic.
-revision: str = "2f1211949ecc"
-down_revision: Union[str, None] = "37f288994c47"
+revision: str = '2f1211949ecc'
+down_revision: Union[str, None] = '37f288994c47'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
 
 def upgrade() -> None:
     # New columns to be added to channel_member table
-    op.add_column("channel_member", sa.Column("status", sa.Text(), nullable=True))
+    op.add_column('channel_member', sa.Column('status', sa.Text(), nullable=True))
     op.add_column(
-        "channel_member",
+        'channel_member',
         sa.Column(
-            "is_active",
+            'is_active',
             sa.Boolean(),
             nullable=False,
             default=True,
@@ -34,69 +34,61 @@ def upgrade() -> None:
     )
 
     op.add_column(
-        "channel_member",
+        'channel_member',
         sa.Column(
-            "is_channel_muted",
+            'is_channel_muted',
             sa.Boolean(),
             nullable=False,
             default=False,
             server_default=sa.sql.expression.false(),
         ),
     )
     op.add_column(
-        "channel_member",
+        'channel_member',
         sa.Column(
-            "is_channel_pinned",
+            'is_channel_pinned',
             sa.Boolean(),
             nullable=False,
             default=False,
             server_default=sa.sql.expression.false(),
         ),
     )
 
-    op.add_column("channel_member", sa.Column("data", sa.JSON(), nullable=True))
-    op.add_column("channel_member", sa.Column("meta", sa.JSON(), nullable=True))
+    op.add_column('channel_member', sa.Column('data', sa.JSON(), nullable=True))
+    op.add_column('channel_member', sa.Column('meta', sa.JSON(), nullable=True))
 
-    op.add_column(
-        "channel_member", sa.Column("joined_at", sa.BigInteger(), nullable=False)
-    )
-    op.add_column(
-        "channel_member", sa.Column("left_at", sa.BigInteger(), nullable=True)
-    )
+    op.add_column('channel_member', sa.Column('joined_at', sa.BigInteger(), nullable=False))
+    op.add_column('channel_member', sa.Column('left_at', sa.BigInteger(), nullable=True))
 
-    op.add_column(
-        "channel_member", sa.Column("last_read_at", sa.BigInteger(), nullable=True)
-    )
+    op.add_column('channel_member', sa.Column('last_read_at', sa.BigInteger(), nullable=True))
 
-    op.add_column(
-        "channel_member", sa.Column("updated_at", sa.BigInteger(), nullable=True)
-    )
+    op.add_column('channel_member', sa.Column('updated_at', sa.BigInteger(), nullable=True))
 
     # New columns to be added to message table
     op.add_column(
-        "message",
+        'message',
         sa.Column(
-            "is_pinned",
+            'is_pinned',
             sa.Boolean(),
             nullable=False,
             default=False,
             server_default=sa.sql.expression.false(),
         ),
     )
-    op.add_column("message", sa.Column("pinned_at", sa.BigInteger(), nullable=True))
-    op.add_column("message", sa.Column("pinned_by", sa.Text(), nullable=True))
+    op.add_column('message', sa.Column('pinned_at', sa.BigInteger(), nullable=True))
+    op.add_column('message', sa.Column('pinned_by', sa.Text(), nullable=True))
 
 
 def downgrade() -> None:
-    op.drop_column("channel_member", "updated_at")
-    op.drop_column("channel_member", "last_read_at")
+    op.drop_column('channel_member', 'updated_at')
+    op.drop_column('channel_member', 'last_read_at')
 
-    op.drop_column("channel_member", "meta")
-    op.drop_column("channel_member", "data")
+    op.drop_column('channel_member', 'meta')
+    op.drop_column('channel_member', 'data')
 
-    op.drop_column("channel_member", "is_channel_pinned")
-    op.drop_column("channel_member", "is_channel_muted")
+    op.drop_column('channel_member', 'is_channel_pinned')
+    op.drop_column('channel_member', 'is_channel_muted')
 
-    op.drop_column("message", "pinned_by")
-    op.drop_column("message", "pinned_at")
-    op.drop_column("message", "is_pinned")
+    op.drop_column('message', 'pinned_by')
+    op.drop_column('message', 'pinned_at')
+    op.drop_column('message', 'is_pinned')

@@ -12,8 +12,8 @@
 from alembic import op
 import sqlalchemy as sa
 
-revision: str = "374d2f66af06"
-down_revision: Union[str, None] = "c440947495f3"
+revision: str = '374d2f66af06'
+down_revision: Union[str, None] = 'c440947495f3'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
@@ -26,13 +26,13 @@ def upgrade() -> None:
     # We need to assume the OLD structure.
 
     old_prompt_table = sa.table(
-        "prompt",
-        sa.column("command", sa.Text()),
-        sa.column("user_id", sa.Text()),
-        sa.column("title", sa.Text()),
-        sa.column("content", sa.Text()),
-        sa.column("timestamp", sa.BigInteger()),
-        sa.column("access_control", sa.JSON()),
+        'prompt',
+        sa.column('command', sa.Text()),
+        sa.column('user_id', sa.Text()),
+        sa.column('title', sa.Text()),
+        sa.column('content', sa.Text()),
+        sa.column('timestamp', sa.BigInteger()),
+        sa.column('access_control', sa.JSON()),
     )
 
     # Check if table exists/read data
@@ -53,61 +53,61 @@ def upgrade() -> None:
 
     # Step 2: Create new prompt table with 'id' as PRIMARY KEY
     op.create_table(
-        "prompt_new",
-        sa.Column("id", sa.Text(), primary_key=True),
-        sa.Column("command", sa.String(), unique=True, index=True),
-        sa.Column("user_id", sa.String(), nullable=False),
-        sa.Column("name", sa.Text(), nullable=False),
-        sa.Column("content", sa.Text(), nullable=False),
-        sa.Column("data", sa.JSON(), nullable=True),
-        sa.Column("meta", sa.JSON(), nullable=True),
-        sa.Column("access_control", sa.JSON(), nullable=True),
-        sa.Column("is_active", sa.Boolean(), nullable=False, server_default="1"),
-        sa.Column("version_id", sa.Text(), nullable=True),
-        sa.Column("tags", sa.JSON(), nullable=True),
-        sa.Column("created_at", sa.BigInteger(), nullable=False),
-        sa.Column("updated_at", sa.BigInteger(), nullable=False),
+        'prompt_new',
+        sa.Column('id', sa.Text(), primary_key=True),
+        sa.Column('command', sa.String(), unique=True, index=True),
+        sa.Column('user_id', sa.String(), nullable=False),
+        sa.Column('name', sa.Text(), nullable=False),
+        sa.Column('content', sa.Text(), nullable=False),
+        sa.Column('data', sa.JSON(), nullable=True),
+        sa.Column('meta', sa.JSON(), nullable=True),
+        sa.Column('access_control', sa.JSON(), nullable=True),
+        sa.Column('is_active', sa.Boolean(), nullable=False, server_default='1'),
+        sa.Column('version_id', sa.Text(), nullable=True),
+        sa.Column('tags', sa.JSON(), nullable=True),
+        sa.Column('created_at', sa.BigInteger(), nullable=False),
+        sa.Column('updated_at', sa.BigInteger(), nullable=False),
     )
 
     # Step 3: Create prompt_history table
     op.create_table(
-        "prompt_history",
-        sa.Column("id", sa.Text(), primary_key=True),
-        sa.Column("prompt_id", sa.Text(), nullable=False, index=True),
-        sa.Column("parent_id", sa.Text(), nullable=True),
-        sa.Column("snapshot", sa.JSON(), nullable=False),
-        sa.Column("user_id", sa.Text(), nullable=False),
-        sa.Column("commit_message", sa.Text(), nullable=True),
-        sa.Column("created_at", sa.BigInteger(), nullable=False),
+        'prompt_history',
+        sa.Column('id', sa.Text(), primary_key=True),
+        sa.Column('prompt_id', sa.Text(), nullable=False, index=True),
+        sa.Column('parent_id', sa.Text(), nullable=True),
+        sa.Column('snapshot', sa.JSON(), nullable=False),
+        sa.Column('user_id', sa.Text(), nullable=False),
+        sa.Column('commit_message', sa.Text(), nullable=True),
+        sa.Column('created_at', sa.BigInteger(), nullable=False),
     )
 
     # Step 4: Migrate data
     prompt_new_table = sa.table(
-        "prompt_new",
-        sa.column("id", sa.Text()),
-        sa.column("command", sa.String()),
-        sa.column("user_id", sa.String()),
-        sa.column("name", sa.Text()),
-        sa.column("content", sa.Text()),
-        sa.column("data", sa.JSON()),
-        sa.column("meta", sa.JSON()),
-        sa.column("access_control", sa.JSON()),
-        sa.column("is_active", sa.Boolean()),
-        sa.column("version_id", sa.Text()),
-        sa.column("tags", sa.JSON()),
-        sa.column("created_at", sa.BigInteger()),
-        sa.column("updated_at", sa.BigInteger()),
+        'prompt_new',
+        sa.column('id', sa.Text()),
+        sa.column('command', sa.String()),
+        sa.column('user_id', sa.String()),
+        sa.column('name', sa.Text()),
+        sa.column('content', sa.Text()),
+        sa.column('data', sa.JSON()),
+        sa.column('meta', sa.JSON()),
+        sa.column('access_control', sa.JSON()),
+        sa.column('is_active', sa.Boolean()),
+        sa.column('version_id', sa.Text()),
+        sa.column('tags', sa.JSON()),
+        sa.column('created_at', sa.BigInteger()),
+        sa.column('updated_at', sa.BigInteger()),
     )
 
     prompt_history_table = sa.table(
-        "prompt_history",
-        sa.column("id", sa.Text()),
-        sa.column("prompt_id", sa.Text()),
-        sa.column("parent_id", sa.Text()),
-        sa.column("snapshot", sa.JSON()),
-        sa.column("user_id", sa.Text()),
-        sa.column("commit_message", sa.Text()),
-        sa.column("created_at", sa.BigInteger()),
+        'prompt_history',
+        sa.column('id', sa.Text()),
+        sa.column('prompt_id', sa.Text()),
+        sa.column('parent_id', sa.Text()),
+        sa.column('snapshot', sa.JSON()),
+        sa.column('user_id', sa.Text()),
+        sa.column('commit_message', sa.Text()),
+        sa.column('created_at', sa.BigInteger()),
     )
 
     for row in existing_prompts:
@@ -120,7 +120,7 @@ def upgrade() -> None:
 
         new_uuid = str(uuid.uuid4())
         history_uuid = str(uuid.uuid4())
-        clean_command = command[1:] if command and command.startswith("/") else command
+        clean_command = command[1:] if command and command.startswith('/') else command
 
         # Insert into prompt_new
         conn.execute(
@@ -148,12 +148,12 @@ def upgrade() -> None:
                 prompt_id=new_uuid,
                 parent_id=None,
                 snapshot={
-                    "name": title,
-                    "content": content,
-                    "command": clean_command,
-                    "data": {},
-                    "meta": {},
-                    "access_control": access_control,
+                    'name': title,
+                    'content': content,
+                    'command': clean_command,
+                    'data': {},
+                    'meta': {},
+                    'access_control': access_control,
                 },
                 user_id=user_id,
                 commit_message=None,
@@ -162,22 +162,22 @@ def upgrade() -> None:
         )
 
     # Step 5: Replace old table with new one
-    op.drop_table("prompt")
-    op.rename_table("prompt_new", "prompt")
+    op.drop_table('prompt')
+    op.rename_table('prompt_new', 'prompt')
 
 
 def downgrade() -> None:
     conn = op.get_bind()
 
     # Step 1: Read new data
     prompt_table = sa.table(
-        "prompt",
-        sa.column("command", sa.String()),
-        sa.column("name", sa.Text()),
-        sa.column("created_at", sa.BigInteger()),
-        sa.column("user_id", sa.Text()),
-        sa.column("content", sa.Text()),
-        sa.column("access_control", sa.JSON()),
+        'prompt',
+        sa.column('command', sa.String()),
+        sa.column('name', sa.Text()),
+        sa.column('created_at', sa.BigInteger()),
+        sa.column('user_id', sa.Text()),
+        sa.column('content', sa.Text()),
+        sa.column('access_control', sa.JSON()),
     )
 
     try:
@@ -195,31 +195,31 @@ def downgrade() -> None:
         current_data = []
 
     # Step 2: Drop history and table
-    op.drop_table("prompt_history")
-    op.drop_table("prompt")
+    op.drop_table('prompt_history')
+    op.drop_table('prompt')
 
     # Step 3: Recreate old table (command as PK?)
     # Assuming old schema:
     op.create_table(
-        "prompt",
-        sa.Column("command", sa.String(), primary_key=True),
-        sa.Column("user_id", sa.String()),
-        sa.Column("title", sa.Text()),
-        sa.Column("content", sa.Text()),
-        sa.Column("timestamp", sa.BigInteger()),
-        sa.Column("access_control", sa.JSON()),
-        sa.Column("id", sa.Integer(), nullable=True),
+        'prompt',
+        sa.Column('command', sa.String(), primary_key=True),
+        sa.Column('user_id', sa.String()),
+        sa.Column('title', sa.Text()),
+        sa.Column('content', sa.Text()),
+        sa.Column('timestamp', sa.BigInteger()),
+        sa.Column('access_control', sa.JSON()),
+        sa.Column('id', sa.Integer(), nullable=True),
     )
 
     # Step 4: Restore data
     old_prompt_table = sa.table(
-        "prompt",
-        sa.column("command", sa.String()),
-        sa.column("user_id", sa.String()),
-        sa.column("title", sa.Text()),
-        sa.column("content", sa.Text()),
-        sa.column("timestamp", sa.BigInteger()),
-        sa.column("access_control", sa.JSON()),
+        'prompt',
+        sa.column('command', sa.String()),
+        sa.column('user_id', sa.String()),
+        sa.column('title', sa.Text()),
+        sa.column('content', sa.Text()),
+        sa.column('timestamp', sa.BigInteger()),
+        sa.column('access_control', sa.JSON()),
     )
 
     for row in current_data:
@@ -231,9 +231,7 @@ def downgrade() -> None:
         access_control = row[5]
 
         # Restore leading /
-        old_command = (
-            "/" + command if command and not command.startswith("/") else command
-        )
+        old_command = '/' + command if command and not command.startswith('/') else command
 
         conn.execute(
             sa.insert(old_prompt_table).values(

@@ -9,62 +9,50 @@
 from alembic import op
 import sqlalchemy as sa
 
-revision = "3781e22d8b01"
-down_revision = "7826ab40b532"
+revision = '3781e22d8b01'
+down_revision = '7826ab40b532'
 branch_labels = None
 depends_on = None
 
 
 def upgrade():
     # Add 'type' column to the 'channel' table
     op.add_column(
-        "channel",
+        'channel',
         sa.Column(
-            "type",
+            'type',
             sa.Text(),
             nullable=True,
         ),
     )
 
     # Add 'parent_id' column to the 'message' table for threads
     op.add_column(
-        "message",
-        sa.Column("parent_id", sa.Text(), nullable=True),
+        'message',
+        sa.Column('parent_id', sa.Text(), nullable=True),
     )
 
     op.create_table(
-        "message_reaction",
-        sa.Column(
-            "id", sa.Text(), nullable=False, primary_key=True, unique=True
-        ),  # Unique reaction ID
-        sa.Column("user_id", sa.Text(), nullable=False),  # User who reacted
-        sa.Column(
-            "message_id", sa.Text(), nullable=False
-        ),  # Message that was reacted to
-        sa.Column(
-            "name", sa.Text(), nullable=False
-        ),  # Reaction name (e.g. "thumbs_up")
-        sa.Column(
-            "created_at", sa.BigInteger(), nullable=True
-        ),  # Timestamp of when the reaction was added
+        'message_reaction',
+        sa.Column('id', sa.Text(), nullable=False, primary_key=True, unique=True),  # Unique reaction ID
+        sa.Column('user_id', sa.Text(), nullable=False),  # User who reacted
+        sa.Column('message_id', sa.Text(), nullable=False),  # Message that was reacted to
+        sa.Column('name', sa.Text(), nullable=False),  # Reaction name (e.g. "thumbs_up")
+        sa.Column('created_at', sa.BigInteger(), nullable=True),  # Timestamp of when the reaction was added
     )
 
     op.create_table(
-        "channel_member",
-        sa.Column(
-            "id", sa.Text(), nullable=False, primary_key=True, unique=True
-        ),  # Record ID for the membership row
-        sa.Column("channel_id", sa.Text(), nullable=False),  # Associated channel
-        sa.Column("user_id", sa.Text(), nullable=False),  # Associated user
-        sa.Column(
-            "created_at", sa.BigInteger(), nullable=True
-        ),  # Timestamp of when the user joined the channel
+        'channel_member',
+        sa.Column('id', sa.Text(), nullable=False, primary_key=True, unique=True),  # Record ID for the membership row
+        sa.Column('channel_id', sa.Text(), nullable=False),  # Associated channel
+        sa.Column('user_id', sa.Text(), nullable=False),  # Associated user
+        sa.Column('created_at', sa.BigInteger(), nullable=True),  # Timestamp of when the user joined the channel
     )
 
 
 def downgrade():
     # Revert 'type' column addition to the 'channel' table
-    op.drop_column("channel", "type")
-    op.drop_column("message", "parent_id")
-    op.drop_table("message_reaction")
-    op.drop_table("channel_member")
+    op.drop_column('channel', 'type')
+    op.drop_column('message', 'parent_id')
+    op.drop_table('message_reaction')
+    op.drop_table('channel_member')

@@ -15,59 +15,57 @@
 import sqlalchemy as sa
 
 # revision identifiers, used by Alembic.
-revision: str = "37f288994c47"
-down_revision: Union[str, None] = "a5c220713937"
+revision: str = '37f288994c47'
+down_revision: Union[str, None] = 'a5c220713937'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
 
 def upgrade() -> None:
     # 1. Create new table
     op.create_table(
-        "group_member",
-        sa.Column("id", sa.Text(), primary_key=True, unique=True, nullable=False),
+        'group_member',
+        sa.Column('id', sa.Text(), primary_key=True, unique=True, nullable=False),
         sa.Column(
-            "group_id",
+            'group_id',
             sa.Text(),
-            sa.ForeignKey("group.id", ondelete="CASCADE"),
+            sa.ForeignKey('group.id', ondelete='CASCADE'),
             nullable=False,
         ),
         sa.Column(
-            "user_id",
+            'user_id',
             sa.Text(),
-            sa.ForeignKey("user.id", ondelete="CASCADE"),
+            sa.ForeignKey('user.id', ondelete='CASCADE'),
             nullable=False,
         ),
-        sa.Column("created_at", sa.BigInteger(), nullable=True),
-        sa.Column("updated_at", sa.BigInteger(), nullable=True),
-        sa.UniqueConstraint("group_id", "user_id", name="uq_group_member_group_user"),
+        sa.Column('created_at', sa.BigInteger(), nullable=True),
+        sa.Column('updated_at', sa.BigInteger(), nullable=True),
+        sa.UniqueConstraint('group_id', 'user_id', name='uq_group_member_group_user'),
     )
 
     connection = op.get_bind()
 
     # 2. Read existing group with user_ids JSON column
     group_table = sa.Table(
-        "group",
+        'group',
         sa.MetaData(),
-        sa.Column("id", sa.Text()),
-        sa.Column("user_ids", sa.JSON()),  # JSON stored as text in SQLite + PG
+        sa.Column('id', sa.Text()),
+        sa.Column('user_ids', sa.JSON()),  # JSON stored as text in SQLite + PG
     )
 
-    results = connection.execute(
-        sa.select(group_table.c.id, group_table.c.user_ids)
-    ).fetchall()
+    results = connection.execute(sa.select(group_table.c.id, group_table.c.user_ids)).fetchall()
 
     print(results)
 
     # 3. Insert members into group_member table
     gm_table = sa.Table(
-        "group_member",
+        'group_member',
         sa.MetaData(),
-        sa.Column("id", sa.Text()),
-        sa.Column("group_id", sa.Text()),
-        sa.Column("user_id", sa.Text()),
-        sa.Column("created_at", sa.BigInteger()),
-        sa.Column("updated_at", sa.BigInteger()),
+        sa.Column('id', sa.Text()),
+        sa.Column('group_id', sa.Text()),
+        sa.Column('user_id', sa.Text()),
+        sa.Column('created_at', sa.BigInteger()),
+        sa.Column('updated_at', sa.BigInteger()),
     )
 
     now = int(time.time())
@@ -86,11 +84,11 @@ def upgrade() -> None:
 
         rows = [
             {
-                "id": str(uuid.uuid4()),
-                "group_id": group_id,
-                "user_id": uid,
-                "created_at": now,
-                "updated_at": now,
+                'id': str(uuid.uuid4()),
+                'group_id': group_id,
+                'user_id': uid,
+                'created_at': now,
+                'updated_at': now,
             }
             for uid in user_ids
         ]
@@ -99,47 +97,41 @@ def upgrade() -> None:
             connection.execute(gm_table.insert(), rows)
 
     # 4. Optionally drop the old column
-    with op.batch_alter_table("group") as batch:
-        batch.drop_column("user_ids")
+    with op.batch_alter_table('group') as batch:
+        batch.drop_column('user_ids')
 
 
 def downgrade():
     # Reverse: restore user_ids column
-    with op.batch_alter_table("group") as batch:
-        batch.add_column(sa.Column("user_ids", sa.JSON()))
+    with op.batch_alter_table('group') as batch:
+        batch.add_column(sa.Column('user_ids', sa.JSON()))
 
     connection = op.get_bind()
     gm_table = sa.Table(
-        "group_member",
+        'group_member',
         sa.MetaData(),
-        sa.Column("group_id", sa.Text()),
-        sa.Column("user_id", sa.Text()),
-        sa.Column("created_at", sa.BigInteger()),
-        sa.Column("updated_at", sa.BigInteger()),
+        sa.Column('group_id', sa.Text()),
+        sa.Column('user_id', sa.Text()),
+        sa.Column('created_at', sa.BigInteger()),
+        sa.Column('updated_at', sa.BigInteger()),
     )
 
     group_table = sa.Table(
-        "group",
+        'group',
         sa.MetaData(),
-        sa.Column("id", sa.Text()),
-        sa.Column("user_ids", sa.JSON()),
+        sa.Column('id', sa.Text()),
+        sa.Column('user_ids', sa.JSON()),
     )
 
     # Build JSON arrays again
     results = connection.execute(sa.select(group_table.c.id)).fetchall()
 
     for (group_id,) in results:
-        members = connection.execute(
-            sa.select(gm_table.c.user_id).where(gm_table.c.group_id == group_id)
-        ).fetchall()
+        members = connection.execute(sa.select(gm_table.c.user_id).where(gm_table.c.group_id == group_id)).fetchall()
 
         member_ids = [m[0] for m in members]
 
-        connection.execute(
-            group_table.update()
-            .where(group_table.c.id == group_id)
-            .values(user_ids=member_ids)
-        )
+        connection.execute(group_table.update().where(group_table.c.id == group_id).values(user_ids=member_ids))
 
     # Drop the new table
-    op.drop_table("group_member")
+    op.drop_table('group_member')

@@ -12,68 +12,64 @@
 import sqlalchemy as sa
 
 # revision identifiers, used by Alembic.
-revision: str = "38d63c18f30f"
-down_revision: Union[str, None] = "3af16a1c9fb6"
+revision: str = '38d63c18f30f'
+down_revision: Union[str, None] = '3af16a1c9fb6'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
 
 def upgrade() -> None:
     # Ensure 'id' column in 'user' table is unique and primary key (ForeignKey constraint)
     inspector = sa.inspect(op.get_bind())
-    columns = inspector.get_columns("user")
+    columns = inspector.get_columns('user')
 
-    pk_columns = inspector.get_pk_constraint("user")["constrained_columns"]
-    id_column = next((col for col in columns if col["name"] == "id"), None)
+    pk_columns = inspector.get_pk_constraint('user')['constrained_columns']
+    id_column = next((col for col in columns if col['name'] == 'id'), None)
 
-    if id_column and not id_column.get("unique", False):
-        unique_constraints = inspector.get_unique_constraints("user")
-        unique_columns = {tuple(u["column_names"]) for u in unique_constraints}
+    if id_column and not id_column.get('unique', False):
+        unique_constraints = inspector.get_unique_constraints('user')
+        unique_columns = {tuple(u['column_names']) for u in unique_constraints}
 
-        with op.batch_alter_table("user") as batch_op:
+        with op.batch_alter_table('user') as batch_op:
             # If primary key is wrong, drop it
-            if pk_columns and pk_columns != ["id"]:
-                batch_op.drop_constraint(
-                    inspector.get_pk_constraint("user")["name"], type_="primary"
-                )
+            if pk_columns and pk_columns != ['id']:
+                batch_op.drop_constraint(inspector.get_pk_constraint('user')['name'], type_='primary')
 
             # Add unique constraint if missing
-            if ("id",) not in unique_columns:
-                batch_op.create_unique_constraint("uq_user_id", ["id"])
+            if ('id',) not in unique_columns:
+                batch_op.create_unique_constraint('uq_user_id', ['id'])
 
             # Re-create correct primary key
-            batch_op.create_primary_key("pk_user_id", ["id"])
+            batch_op.create_primary_key('pk_user_id', ['id'])
 
     # Create oauth_session table
     op.create_table(
-        "oauth_session",
-        sa.Column("id", sa.Text(), primary_key=True, nullable=False, unique=True),
+        'oauth_session',
+        sa.Column('id', sa.Text(), primary_key=True, nullable=False, unique=True),
         sa.Column(
-            "user_id",
+            'user_id',
             sa.Text(),
-            sa.ForeignKey("user.id", ondelete="CASCADE"),
+            sa.ForeignKey('user.id', ondelete='CASCADE'),
             nullable=False,
         ),
-        sa.Column("provider", sa.Text(), nullable=False),
-        sa.Column("token", sa.Text(), nullable=False),
-        sa.Column("expires_at", sa.BigInteger(), nullable=False),
-        sa.Column("created_at", sa.BigInteger(), nullable=False),
-        sa.Column("updated_at", sa.BigInteger(), nullable=False),
+        sa.Column('provider', sa.Text(), nullable=False),
+        sa.Column('token', sa.Text(), nullable=False),
+        sa.Column('expires_at', sa.BigInteger(), nullable=False),
+        sa.Column('created_at', sa.BigInteger(), nullable=False),
+        sa.Column('updated_at', sa.BigInteger(), nullable=False),
     )
 
     # Create indexes for better performance
-    op.create_index("idx_oauth_session_user_id", "oauth_session", ["user_id"])
-    op.create_index("idx_oauth_session_expires_at", "oauth_session", ["expires_at"])
-    op.create_index(
-        "idx_oauth_session_user_provider", "oauth_session", ["user_id", "provider"]
-    )
+    op.create_index('idx_oauth_session_user_id', 'oauth_session', ['user_id'])
+    op.create_index('idx_oauth_session_expires_at', 'oauth_session', ['expires_at'])
+    op.create_index('idx_oauth_session_user_provider', 'oauth_session', ['user_id', 'provider'])
 
 
 def downgrade() -> None:
     # Drop indexes first
-    op.drop_index("idx_oauth_session_user_provider", table_name="oauth_session")
-    op.drop_index("idx_oauth_session_expires_at", table_name="oauth_session")
-    op.drop_index("idx_oauth_session_user_id", table_name="oauth_session")
+    op.drop_index('idx_oauth_session_user_provider', table_name='oauth_session')
+    op.drop_index('idx_oauth_session_expires_at', table_name='oauth_session')
+    op.drop_index('idx_oauth_session_user_id', table_name='oauth_session')
 
     # Drop the table
-    op.drop_table("oauth_session")
+    op.drop_table('oauth_session')

@@ -13,8 +13,8 @@
 
 import json
 
-revision = "3ab32c4b8f59"
-down_revision = "1af9b942657b"
+revision = '3ab32c4b8f59'
+down_revision = '1af9b942657b'
 branch_labels = None
 depends_on = None
 
@@ -24,58 +24,55 @@ def upgrade():
     inspector = Inspector.from_engine(conn)
 
     # Inspecting the 'tag' table constraints and structure
-    existing_pk = inspector.get_pk_constraint("tag")
-    unique_constraints = inspector.get_unique_constraints("tag")
-    existing_indexes = inspector.get_indexes("tag")
+    existing_pk = inspector.get_pk_constraint('tag')
+    unique_constraints = inspector.get_unique_constraints('tag')
+    existing_indexes = inspector.get_indexes('tag')
 
-    print(f"Primary Key: {existing_pk}")
-    print(f"Unique Constraints: {unique_constraints}")
-    print(f"Indexes: {existing_indexes}")
+    print(f'Primary Key: {existing_pk}')
+    print(f'Unique Constraints: {unique_constraints}')
+    print(f'Indexes: {existing_indexes}')
 
-    with op.batch_alter_table("tag", schema=None) as batch_op:
+    with op.batch_alter_table('tag', schema=None) as batch_op:
         # Drop existing primary key constraint if it exists
-        if existing_pk and existing_pk.get("constrained_columns"):
-            pk_name = existing_pk.get("name")
+        if existing_pk and existing_pk.get('constrained_columns'):
+            pk_name = existing_pk.get('name')
             if pk_name:
-                print(f"Dropping primary key constraint: {pk_name}")
-                batch_op.drop_constraint(pk_name, type_="primary")
+                print(f'Dropping primary key constraint: {pk_name}')
+                batch_op.drop_constraint(pk_name, type_='primary')
 
         # Now create the new primary key with the combination of 'id' and 'user_id'
         print("Creating new primary key with 'id' and 'user_id'.")
-        batch_op.create_primary_key("pk_id_user_id", ["id", "user_id"])
+        batch_op.create_primary_key('pk_id_user_id', ['id', 'user_id'])
 
         # Drop unique constraints that could conflict with the new primary key
         for constraint in unique_constraints:
             if (
-                constraint["name"] == "uq_id_user_id"
+                constraint['name'] == 'uq_id_user_id'
             ):  # Adjust this name according to what is actually returned by the inspector
-                print(f"Dropping unique constraint: {constraint['name']}")
-                batch_op.drop_constraint(constraint["name"], type_="unique")
+                print(f'Dropping unique constraint: {constraint["name"]}')
+                batch_op.drop_constraint(constraint['name'], type_='unique')
 
         for index in existing_indexes:
-            if index["unique"]:
-                if not any(
-                    constraint["name"] == index["name"]
-                    for constraint in unique_constraints
-                ):
+            if index['unique']:
+                if not any(constraint['name'] == index['name'] for constraint in unique_constraints):
                     # You are attempting to drop unique indexes
-                    print(f"Dropping unique index: {index['name']}")
-                    batch_op.drop_index(index["name"])
+                    print(f'Dropping unique index: {index["name"]}')
+                    batch_op.drop_index(index['name'])
 
 
 def downgrade():
     conn = op.get_bind()
     inspector = Inspector.from_engine(conn)
 
-    current_pk = inspector.get_pk_constraint("tag")
+    current_pk = inspector.get_pk_constraint('tag')
 
-    with op.batch_alter_table("tag", schema=None) as batch_op:
+    with op.batch_alter_table('tag', schema=None) as batch_op:
         # Drop the current primary key first, if it matches the one we know we added in upgrade
-        if current_pk and "pk_id_user_id" == current_pk.get("name"):
-            batch_op.drop_constraint("pk_id_user_id", type_="primary")
+        if current_pk and 'pk_id_user_id' == current_pk.get('name'):
+            batch_op.drop_constraint('pk_id_user_id', type_='primary')
 
         # Restore the original primary key
-        batch_op.create_primary_key("pk_id", ["id"])
+        batch_op.create_primary_key('pk_id', ['id'])
 
         # Since primary key on just 'id' is restored, we now add back any unique constraints if necessary
-        batch_op.create_unique_constraint("uq_id_user_id", ["id", "user_id"])
+        batch_op.create_unique_constraint('uq_id_user_id', ['id', 'user_id'])

@@ -12,21 +12,21 @@
 import sqlalchemy as sa
 
 # revision identifiers, used by Alembic.
-revision: str = "3af16a1c9fb6"
-down_revision: Union[str, None] = "018012973d35"
+revision: str = '3af16a1c9fb6'
+down_revision: Union[str, None] = '018012973d35'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
 
 def upgrade() -> None:
-    op.add_column("user", sa.Column("username", sa.String(length=50), nullable=True))
-    op.add_column("user", sa.Column("bio", sa.Text(), nullable=True))
-    op.add_column("user", sa.Column("gender", sa.Text(), nullable=True))
-    op.add_column("user", sa.Column("date_of_birth", sa.Date(), nullable=True))
+    op.add_column('user', sa.Column('username', sa.String(length=50), nullable=True))
+    op.add_column('user', sa.Column('bio', sa.Text(), nullable=True))
+    op.add_column('user', sa.Column('gender', sa.Text(), nullable=True))
+    op.add_column('user', sa.Column('date_of_birth', sa.Date(), nullable=True))
 
 
 def downgrade() -> None:
-    op.drop_column("user", "username")
-    op.drop_column("user", "bio")
-    op.drop_column("user", "gender")
-    op.drop_column("user", "date_of_birth")
+    op.drop_column('user', 'username')
+    op.drop_column('user', 'bio')
+    op.drop_column('user', 'gender')
+    op.drop_column('user', 'date_of_birth')

@@ -18,74 +18,72 @@
 import uuid
 
 # revision identifiers, used by Alembic.
-revision: str = "3e0e00844bb0"
-down_revision: Union[str, None] = "90ef40d4714e"
+revision: str = '3e0e00844bb0'
+down_revision: Union[str, None] = '90ef40d4714e'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
 
 def upgrade() -> None:
     op.create_table(
-        "knowledge_file",
-        sa.Column("id", sa.Text(), primary_key=True),
-        sa.Column("user_id", sa.Text(), nullable=False),
+        'knowledge_file',
+        sa.Column('id', sa.Text(), primary_key=True),
+        sa.Column('user_id', sa.Text(), nullable=False),
         sa.Column(
-            "knowledge_id",
+            'knowledge_id',
             sa.Text(),
-            sa.ForeignKey("knowledge.id", ondelete="CASCADE"),
+            sa.ForeignKey('knowledge.id', ondelete='CASCADE'),
             nullable=False,
         ),
         sa.Column(
-            "file_id",
+            'file_id',
             sa.Text(),
-            sa.ForeignKey("file.id", ondelete="CASCADE"),
+            sa.ForeignKey('file.id', ondelete='CASCADE'),
             nullable=False,
         ),
-        sa.Column("created_at", sa.BigInteger(), nullable=False),
-        sa.Column("updated_at", sa.BigInteger(), nullable=False),
+        sa.Column('created_at', sa.BigInteger(), nullable=False),
+        sa.Column('updated_at', sa.BigInteger(), nullable=False),
         # indexes
-        sa.Index("ix_knowledge_file_knowledge_id", "knowledge_id"),
-        sa.Index("ix_knowledge_file_file_id", "file_id"),
-        sa.Index("ix_knowledge_file_user_id", "user_id"),
+        sa.Index('ix_knowledge_file_knowledge_id', 'knowledge_id'),
+        sa.Index('ix_knowledge_file_file_id', 'file_id'),
+        sa.Index('ix_knowledge_file_user_id', 'user_id'),
         # unique constraints
         sa.UniqueConstraint(
-            "knowledge_id", "file_id", name="uq_knowledge_file_knowledge_file"
+            'knowledge_id', 'file_id', name='uq_knowledge_file_knowledge_file'
         ),  # prevent duplicate entries
     )
 
     connection = op.get_bind()
 
     # 2. Read existing group with user_ids JSON column
     knowledge_table = sa.Table(
-        "knowledge",
+        'knowledge',
         sa.MetaData(),
-        sa.Column("id", sa.Text()),
-        sa.Column("user_id", sa.Text()),
-        sa.Column("data", sa.JSON()),  # JSON stored as text in SQLite + PG
+        sa.Column('id', sa.Text()),
+        sa.Column('user_id', sa.Text()),
+        sa.Column('data', sa.JSON()),  # JSON stored as text in SQLite + PG
     )
 
     results = connection.execute(
-        sa.select(
-            knowledge_table.c.id, knowledge_table.c.user_id, knowledge_table.c.data
-        )
+        sa.select(knowledge_table.c.id, knowledge_table.c.user_id, knowledge_table.c.data)
     ).fetchall()
 
     # 3. Insert members into group_member table
     kf_table = sa.Table(
-        "knowledge_file",
+        'knowledge_file',
         sa.MetaData(),
-        sa.Column("id", sa.Text()),
-        sa.Column("user_id", sa.Text()),
-        sa.Column("knowledge_id", sa.Text()),
-        sa.Column("file_id", sa.Text()),
-        sa.Column("created_at", sa.BigInteger()),
-        sa.Column("updated_at", sa.BigInteger()),
+        sa.Column('id', sa.Text()),
+        sa.Column('user_id', sa.Text()),
+        sa.Column('knowledge_id', sa.Text()),
+        sa.Column('file_id', sa.Text()),
+        sa.Column('created_at', sa.BigInteger()),
+        sa.Column('updated_at', sa.BigInteger()),
     )
 
     file_table = sa.Table(
-        "file",
+        'file',
         sa.MetaData(),
-        sa.Column("id", sa.Text()),
+        sa.Column('id', sa.Text()),
     )
 
     now = int(time.time())
@@ -102,50 +100,48 @@ def upgrade() -> None:
         if not isinstance(data, dict):
             continue
 
-        file_ids = data.get("file_ids", [])
+        file_ids = data.get('file_ids', [])
 
         for file_id in file_ids:
-            file_exists = connection.execute(
-                sa.select(file_table.c.id).where(file_table.c.id == file_id)
-            ).fetchone()
+            file_exists = connection.execute(sa.select(file_table.c.id).where(file_table.c.id == file_id)).fetchone()
 
             if not file_exists:
                 continue  # skip non-existing files
 
             row = {
-                "id": str(uuid.uuid4()),
-                "user_id": user_id,
-                "knowledge_id": knowledge_id,
-                "file_id": file_id,
-                "created_at": now,
-                "updated_at": now,
+                'id': str(uuid.uuid4()),
+                'user_id': user_id,
+                'knowledge_id': knowledge_id,
+                'file_id': file_id,
+                'created_at': now,
+                'updated_at': now,
             }
             connection.execute(kf_table.insert().values(**row))
 
-    with op.batch_alter_table("knowledge") as batch:
-        batch.drop_column("data")
+    with op.batch_alter_table('knowledge') as batch:
+        batch.drop_column('data')
 
 
 def downgrade() -> None:
     # 1. Add back the old data column
-    op.add_column("knowledge", sa.Column("data", sa.JSON(), nullable=True))
+    op.add_column('knowledge', sa.Column('data', sa.JSON(), nullable=True))
 
     connection = op.get_bind()
 
     # 2. Read knowledge_file entries and reconstruct data JSON
     knowledge_table = sa.Table(
-        "knowledge",
+        'knowledge',
         sa.MetaData(),
-        sa.Column("id", sa.Text()),
-        sa.Column("data", sa.JSON()),
+        sa.Column('id', sa.Text()),
+        sa.Column('data', sa.JSON()),
     )
 
     kf_table = sa.Table(
-        "knowledge_file",
+        'knowledge_file',
         sa.MetaData(),
-        sa.Column("id", sa.Text()),
-        sa.Column("knowledge_id", sa.Text()),
-        sa.Column("file_id", sa.Text()),
+        sa.Column('id', sa.Text()),
+        sa.Column('knowledge_id', sa.Text()),
+        sa.Column('file_id', sa.Text()),
     )
 
     results = connection.execute(sa.select(knowledge_table.c.id)).fetchall()
@@ -157,13 +153,9 @@ def downgrade() -> None:
 
         file_ids_list = [fid for (fid,) in file_ids]
 
-        data_json = {"file_ids": file_ids_list}
+        data_json = {'file_ids': file_ids_list}
 
-        connection.execute(
-            knowledge_table.update()
-            .where(knowledge_table.c.id == knowledge_id)
-            .values(data=data_json)
-        )
+        connection.execute(knowledge_table.update().where(knowledge_table.c.id == knowledge_id).values(data=data_json))
 
     # 3. Drop the knowledge_file table
-    op.drop_table("knowledge_file")
+    op.drop_table('knowledge_file')

@@ -9,56 +9,56 @@
 from alembic import op
 import sqlalchemy as sa
 
-revision = "4ace53fd72c8"
-down_revision = "af906e964978"
+revision = '4ace53fd72c8'
+down_revision = 'af906e964978'
 branch_labels = None
 depends_on = None
 
 
 def upgrade():
     # Perform safe alterations using batch operation
-    with op.batch_alter_table("folder", schema=None) as batch_op:
+    with op.batch_alter_table('folder', schema=None) as batch_op:
         # Step 1: Remove server defaults for created_at and updated_at
         batch_op.alter_column(
-            "created_at",
+            'created_at',
             server_default=None,  # Removing server default
         )
         batch_op.alter_column(
-            "updated_at",
+            'updated_at',
             server_default=None,  # Removing server default
         )
 
         # Step 2: Change the column types to BigInteger for created_at
         batch_op.alter_column(
-            "created_at",
+            'created_at',
             type_=sa.BigInteger(),
             existing_type=sa.DateTime(),
             existing_nullable=False,
-            postgresql_using="extract(epoch from created_at)::bigint",  # Conversion for PostgreSQL
+            postgresql_using='extract(epoch from created_at)::bigint',  # Conversion for PostgreSQL
         )
 
         # Change the column types to BigInteger for updated_at
         batch_op.alter_column(
-            "updated_at",
+            'updated_at',
             type_=sa.BigInteger(),
             existing_type=sa.DateTime(),
             existing_nullable=False,
-            postgresql_using="extract(epoch from updated_at)::bigint",  # Conversion for PostgreSQL
+            postgresql_using='extract(epoch from updated_at)::bigint',  # Conversion for PostgreSQL
         )
 
 
 def downgrade():
     # Downgrade: Convert columns back to DateTime and restore defaults
-    with op.batch_alter_table("folder", schema=None) as batch_op:
+    with op.batch_alter_table('folder', schema=None) as batch_op:
         batch_op.alter_column(
-            "created_at",
+            'created_at',
             type_=sa.DateTime(),
             existing_type=sa.BigInteger(),
             existing_nullable=False,
             server_default=sa.func.now(),  # Restoring server default on downgrade
         )
         batch_op.alter_column(
-            "updated_at",
+            'updated_at',
             type_=sa.DateTime(),
             existing_type=sa.BigInteger(),
             existing_nullable=False,

@@ -9,40 +9,40 @@
 from alembic import op
 import sqlalchemy as sa
 
-revision = "57c599a3cb57"
-down_revision = "922e7a387820"
+revision = '57c599a3cb57'
+down_revision = '922e7a387820'
 branch_labels = None
 depends_on = None
 
 
 def upgrade():
     op.create_table(
-        "channel",
-        sa.Column("id", sa.Text(), nullable=False, primary_key=True, unique=True),
-        sa.Column("user_id", sa.Text()),
-        sa.Column("name", sa.Text()),
-        sa.Column("description", sa.Text(), nullable=True),
-        sa.Column("data", sa.JSON(), nullable=True),
-        sa.Column("meta", sa.JSON(), nullable=True),
-        sa.Column("access_control", sa.JSON(), nullable=True),
-        sa.Column("created_at", sa.BigInteger(), nullable=True),
-        sa.Column("updated_at", sa.BigInteger(), nullable=True),
+        'channel',
+        sa.Column('id', sa.Text(), nullable=False, primary_key=True, unique=True),
+        sa.Column('user_id', sa.Text()),
+        sa.Column('name', sa.Text()),
+        sa.Column('description', sa.Text(), nullable=True),
+        sa.Column('data', sa.JSON(), nullable=True),
+        sa.Column('meta', sa.JSON(), nullable=True),
+        sa.Column('access_control', sa.JSON(), nullable=True),
+        sa.Column('created_at', sa.BigInteger(), nullable=True),
+        sa.Column('updated_at', sa.BigInteger(), nullable=True),
     )
 
     op.create_table(
-        "message",
-        sa.Column("id", sa.Text(), nullable=False, primary_key=True, unique=True),
-        sa.Column("user_id", sa.Text()),
-        sa.Column("channel_id", sa.Text(), nullable=True),
-        sa.Column("content", sa.Text()),
-        sa.Column("data", sa.JSON(), nullable=True),
-        sa.Column("meta", sa.JSON(), nullable=True),
-        sa.Column("created_at", sa.BigInteger(), nullable=True),
-        sa.Column("updated_at", sa.BigInteger(), nullable=True),
+        'message',
+        sa.Column('id', sa.Text(), nullable=False, primary_key=True, unique=True),
+        sa.Column('user_id', sa.Text()),
+        sa.Column('channel_id', sa.Text(), nullable=True),
+        sa.Column('content', sa.Text()),
+        sa.Column('data', sa.JSON(), nullable=True),
+        sa.Column('meta', sa.JSON(), nullable=True),
+        sa.Column('created_at', sa.BigInteger(), nullable=True),
+        sa.Column('updated_at', sa.BigInteger(), nullable=True),
     )
 
 
 def downgrade():
-    op.drop_table("channel")
+    op.drop_table('channel')
 
-    op.drop_table("message")
+    op.drop_table('message')

@@ -13,41 +13,39 @@
 import open_webui.internal.db
 
 # revision identifiers, used by Alembic.
-revision: str = "6283dc0e4d8d"
-down_revision: Union[str, None] = "3e0e00844bb0"
+revision: str = '6283dc0e4d8d'
+down_revision: Union[str, None] = '3e0e00844bb0'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
 
 def upgrade() -> None:
     op.create_table(
-        "channel_file",
-        sa.Column("id", sa.Text(), primary_key=True),
-        sa.Column("user_id", sa.Text(), nullable=False),
+        'channel_file',
+        sa.Column('id', sa.Text(), primary_key=True),
+        sa.Column('user_id', sa.Text(), nullable=False),
         sa.Column(
-            "channel_id",
+            'channel_id',
             sa.Text(),
-            sa.ForeignKey("channel.id", ondelete="CASCADE"),
+            sa.ForeignKey('channel.id', ondelete='CASCADE'),
             nullable=False,
         ),
         sa.Column(
-            "file_id",
+            'file_id',
             sa.Text(),
-            sa.ForeignKey("file.id", ondelete="CASCADE"),
+            sa.ForeignKey('file.id', ondelete='CASCADE'),
             nullable=False,
         ),
-        sa.Column("created_at", sa.BigInteger(), nullable=False),
-        sa.Column("updated_at", sa.BigInteger(), nullable=False),
+        sa.Column('created_at', sa.BigInteger(), nullable=False),
+        sa.Column('updated_at', sa.BigInteger(), nullable=False),
         # indexes
-        sa.Index("ix_channel_file_channel_id", "channel_id"),
-        sa.Index("ix_channel_file_file_id", "file_id"),
-        sa.Index("ix_channel_file_user_id", "user_id"),
+        sa.Index('ix_channel_file_channel_id', 'channel_id'),
+        sa.Index('ix_channel_file_file_id', 'file_id'),
+        sa.Index('ix_channel_file_user_id', 'user_id'),
         # unique constraints
-        sa.UniqueConstraint(
-            "channel_id", "file_id", name="uq_channel_file_channel_file"
-        ),  # prevent duplicate entries
+        sa.UniqueConstraint('channel_id', 'file_id', name='uq_channel_file_channel_file'),  # prevent duplicate entries
     )
 
 
 def downgrade() -> None:
-    op.drop_table("channel_file")
+    op.drop_table('channel_file')

@@ -11,37 +11,37 @@
 from sqlalchemy.sql import table, column, select
 import json
 
-revision = "6a39f3d8e55c"
-down_revision = "c0fbf31ca0db"
+revision = '6a39f3d8e55c'
+down_revision = 'c0fbf31ca0db'
 branch_labels = None
 depends_on = None
 
 
 def upgrade():
     # Creating the 'knowledge' table
-    print("Creating knowledge table")
+    print('Creating knowledge table')
     knowledge_table = op.create_table(
-        "knowledge",
-        sa.Column("id", sa.Text(), primary_key=True),
-        sa.Column("user_id", sa.Text(), nullable=False),
-        sa.Column("name", sa.Text(), nullable=False),
-        sa.Column("description", sa.Text(), nullable=True),
-        sa.Column("data", sa.JSON(), nullable=True),
-        sa.Column("meta", sa.JSON(), nullable=True),
-        sa.Column("created_at", sa.BigInteger(), nullable=False),
-        sa.Column("updated_at", sa.BigInteger(), nullable=True),
+        'knowledge',
+        sa.Column('id', sa.Text(), primary_key=True),
+        sa.Column('user_id', sa.Text(), nullable=False),
+        sa.Column('name', sa.Text(), nullable=False),
+        sa.Column('description', sa.Text(), nullable=True),
+        sa.Column('data', sa.JSON(), nullable=True),
+        sa.Column('meta', sa.JSON(), nullable=True),
+        sa.Column('created_at', sa.BigInteger(), nullable=False),
+        sa.Column('updated_at', sa.BigInteger(), nullable=True),
     )
 
-    print("Migrating data from document table to knowledge table")
+    print('Migrating data from document table to knowledge table')
     # Representation of the existing 'document' table
     document_table = table(
-        "document",
-        column("collection_name", sa.String()),
-        column("user_id", sa.String()),
-        column("name", sa.String()),
-        column("title", sa.Text()),
-        column("content", sa.Text()),
-        column("timestamp", sa.BigInteger()),
+        'document',
+        column('collection_name', sa.String()),
+        column('user_id', sa.String()),
+        column('name', sa.String()),
+        column('title', sa.Text()),
+        column('content', sa.Text()),
+        column('timestamp', sa.BigInteger()),
     )
 
     # Select all from existing document table
@@ -64,9 +64,9 @@ def upgrade():
                 user_id=doc.user_id,
                 description=doc.name,
                 meta={
-                    "legacy": True,
-                    "document": True,
-                    "tags": json.loads(doc.content or "{}").get("tags", []),
+                    'legacy': True,
+                    'document': True,
+                    'tags': json.loads(doc.content or '{}').get('tags', []),
                 },
                 name=doc.title,
                 created_at=doc.timestamp,
@@ -76,4 +76,4 @@ def upgrade():
 
 
 def downgrade():
-    op.drop_table("knowledge")
+    op.drop_table('knowledge')

@@ -9,18 +9,18 @@
 from alembic import op
 import sqlalchemy as sa
 
-revision = "7826ab40b532"
-down_revision = "57c599a3cb57"
+revision = '7826ab40b532'
+down_revision = '57c599a3cb57'
 branch_labels = None
 depends_on = None
 
 
 def upgrade():
     op.add_column(
-        "file",
-        sa.Column("access_control", sa.JSON(), nullable=True),
+        'file',
+        sa.Column('access_control', sa.JSON(), nullable=True),
     )
 
 
 def downgrade():
-    op.drop_column("file", "access_control")
+    op.drop_column('file', 'access_control')

@@ -16,7 +16,7 @@
 from open_webui.migrations.util import get_existing_tables
 
 # revision identifiers, used by Alembic.
-revision: str = "7e5b5dc7342b"
+revision: str = '7e5b5dc7342b'
 down_revision: Union[str, None] = None
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
@@ -26,179 +26,179 @@ def upgrade() -> None:
     existing_tables = set(get_existing_tables())
 
     # ### commands auto generated by Alembic - please adjust! ###
-    if "auth" not in existing_tables:
+    if 'auth' not in existing_tables:
         op.create_table(
-            "auth",
-            sa.Column("id", sa.String(), nullable=False),
-            sa.Column("email", sa.String(), nullable=True),
-            sa.Column("password", sa.Text(), nullable=True),
-            sa.Column("active", sa.Boolean(), nullable=True),
-            sa.PrimaryKeyConstraint("id"),
+            'auth',
+            sa.Column('id', sa.String(), nullable=False),
+            sa.Column('email', sa.String(), nullable=True),
+            sa.Column('password', sa.Text(), nullable=True),
+            sa.Column('active', sa.Boolean(), nullable=True),
+            sa.PrimaryKeyConstraint('id'),
         )
 
-    if "chat" not in existing_tables:
+    if 'chat' not in existing_tables:
         op.create_table(
-            "chat",
-            sa.Column("id", sa.String(), nullable=False),
-            sa.Column("user_id", sa.String(), nullable=True),
-            sa.Column("title", sa.Text(), nullable=True),
-            sa.Column("chat", sa.Text(), nullable=True),
-            sa.Column("created_at", sa.BigInteger(), nullable=True),
-            sa.Column("updated_at", sa.BigInteger(), nullable=True),
-            sa.Column("share_id", sa.Text(), nullable=True),
-            sa.Column("archived", sa.Boolean(), nullable=True),
-            sa.PrimaryKeyConstraint("id"),
-            sa.UniqueConstraint("share_id"),
+            'chat',
+            sa.Column('id', sa.String(), nullable=False),
+            sa.Column('user_id', sa.String(), nullable=True),
+            sa.Column('title', sa.Text(), nullable=True),
+            sa.Column('chat', sa.Text(), nullable=True),
+            sa.Column('created_at', sa.BigInteger(), nullable=True),
+            sa.Column('updated_at', sa.BigInteger(), nullable=True),
+            sa.Column('share_id', sa.Text(), nullable=True),
+            sa.Column('archived', sa.Boolean(), nullable=True),
+            sa.PrimaryKeyConstraint('id'),
+            sa.UniqueConstraint('share_id'),
         )
 
-    if "chatidtag" not in existing_tables:
+    if 'chatidtag' not in existing_tables:
         op.create_table(
-            "chatidtag",
-            sa.Column("id", sa.String(), nullable=False),
-            sa.Column("tag_name", sa.String(), nullable=True),
-            sa.Column("chat_id", sa.String(), nullable=True),
-            sa.Column("user_id", sa.String(), nullable=True),
-            sa.Column("timestamp", sa.BigInteger(), nullable=True),
-            sa.PrimaryKeyConstraint("id"),
+            'chatidtag',
+            sa.Column('id', sa.String(), nullable=False),
+            sa.Column('tag_name', sa.String(), nullable=True),
+            sa.Column('chat_id', sa.String(), nullable=True),
+            sa.Column('user_id', sa.String(), nullable=True),
+            sa.Column('timestamp', sa.BigInteger(), nullable=True),
+            sa.PrimaryKeyConstraint('id'),
         )
 
-    if "document" not in existing_tables:
+    if 'document' not in existing_tables:
         op.create_table(
-            "document",
-            sa.Column("collection_name", sa.String(), nullable=False),
-            sa.Column("name", sa.String(), nullable=True),
-            sa.Column("title", sa.Text(), nullable=True),
-            sa.Column("filename", sa.Text(), nullable=True),
-            sa.Column("content", sa.Text(), nullable=True),
-            sa.Column("user_id", sa.String(), nullable=True),
-            sa.Column("timestamp", sa.BigInteger(), nullable=True),
-            sa.PrimaryKeyConstraint("collection_name"),
-            sa.UniqueConstraint("name"),
+            'document',
+            sa.Column('collection_name', sa.String(), nullable=False),
+            sa.Column('name', sa.String(), nullable=True),
+            sa.Column('title', sa.Text(), nullable=True),
+            sa.Column('filename', sa.Text(), nullable=True),
+            sa.Column('content', sa.Text(), nullable=True),
+            sa.Column('user_id', sa.String(), nullable=True),
+            sa.Column('timestamp', sa.BigInteger(), nullable=True),
+            sa.PrimaryKeyConstraint('collection_name'),
+            sa.UniqueConstraint('name'),
         )
 
-    if "file" not in existing_tables:
+    if 'file' not in existing_tables:
         op.create_table(
-            "file",
-            sa.Column("id", sa.String(), nullable=False),
-            sa.Column("user_id", sa.String(), nullable=True),
-            sa.Column("filename", sa.Text(), nullable=True),
-            sa.Column("meta", JSONField(), nullable=True),
-            sa.Column("created_at", sa.BigInteger(), nullable=True),
-            sa.PrimaryKeyConstraint("id"),
+            'file',
+            sa.Column('id', sa.String(), nullable=False),
+            sa.Column('user_id', sa.String(), nullable=True),
+            sa.Column('filename', sa.Text(), nullable=True),
+            sa.Column('meta', JSONField(), nullable=True),
+            sa.Column('created_at', sa.BigInteger(), nullable=True),
+            sa.PrimaryKeyConstraint('id'),
         )
 
-    if "function" not in existing_tables:
+    if 'function' not in existing_tables:
         op.create_table(
-            "function",
-            sa.Column("id", sa.String(), nullable=False),
-            sa.Column("user_id", sa.String(), nullable=True),
-            sa.Column("name", sa.Text(), nullable=True),
-            sa.Column("type", sa.Text(), nullable=True),
-            sa.Column("content", sa.Text(), nullable=True),
-            sa.Column("meta", JSONField(), nullable=True),
-            sa.Column("valves", JSONField(), nullable=True),
-            sa.Column("is_active", sa.Boolean(), nullable=True),
-            sa.Column("is_global", sa.Boolean(), nullable=True),
-            sa.Column("updated_at", sa.BigInteger(), nullable=True),
-            sa.Column("created_at", sa.BigInteger(), nullable=True),
-            sa.PrimaryKeyConstraint("id"),
+            'function',
+            sa.Column('id', sa.String(), nullable=False),
+            sa.Column('user_id', sa.String(), nullable=True),
+            sa.Column('name', sa.Text(), nullable=True),
+            sa.Column('type', sa.Text(), nullable=True),
+            sa.Column('content', sa.Text(), nullable=True),
+            sa.Column('meta', JSONField(), nullable=True),
+            sa.Column('valves', JSONField(), nullable=True),
+            sa.Column('is_active', sa.Boolean(), nullable=True),
+            sa.Column('is_global', sa.Boolean(), nullable=True),
+            sa.Column('updated_at', sa.BigInteger(), nullable=True),
+            sa.Column('created_at', sa.BigInteger(), nullable=True),
+            sa.PrimaryKeyConstraint('id'),
         )
 
-    if "memory" not in existing_tables:
+    if 'memory' not in existing_tables:
         op.create_table(
-            "memory",
-            sa.Column("id", sa.String(), nullable=False),
-            sa.Column("user_id", sa.String(), nullable=True),
-            sa.Column("content", sa.Text(), nullable=True),
-            sa.Column("updated_at", sa.BigInteger(), nullable=True),
-            sa.Column("created_at", sa.BigInteger(), nullable=True),
-            sa.PrimaryKeyConstraint("id"),
+            'memory',
+            sa.Column('id', sa.String(), nullable=False),
+            sa.Column('user_id', sa.String(), nullable=True),
+            sa.Column('content', sa.Text(), nullable=True),
+            sa.Column('updated_at', sa.BigInteger(), nullable=True),
+            sa.Column('created_at', sa.BigInteger(), nullable=True),
+            sa.PrimaryKeyConstraint('id'),
         )
 
-    if "model" not in existing_tables:
+    if 'model' not in existing_tables:
         op.create_table(
-            "model",
-            sa.Column("id", sa.Text(), nullable=False),
-            sa.Column("user_id", sa.Text(), nullable=True),
-            sa.Column("base_model_id", sa.Text(), nullable=True),
-            sa.Column("name", sa.Text(), nullable=True),
-            sa.Column("params", JSONField(), nullable=True),
-            sa.Column("meta", JSONField(), nullable=True),
-            sa.Column("updated_at", sa.BigInteger(), nullable=True),
-            sa.Column("created_at", sa.BigInteger(), nullable=True),
-            sa.PrimaryKeyConstraint("id"),
+            'model',
+            sa.Column('id', sa.Text(), nullable=False),
+            sa.Column('user_id', sa.Text(), nullable=True),
+            sa.Column('base_model_id', sa.Text(), nullable=True),
+            sa.Column('name', sa.Text(), nullable=True),
+            sa.Column('params', JSONField(), nullable=True),
+            sa.Column('meta', JSONField(), nullable=True),
+            sa.Column('updated_at', sa.BigInteger(), nullable=True),
+            sa.Column('created_at', sa.BigInteger(), nullable=True),
+            sa.PrimaryKeyConstraint('id'),
         )
 
-    if "prompt" not in existing_tables:
+    if 'prompt' not in existing_tables:
         op.create_table(
-            "prompt",
-            sa.Column("command", sa.String(), nullable=False),
-            sa.Column("user_id", sa.String(), nullable=True),
-            sa.Column("title", sa.Text(), nullable=True),
-            sa.Column("content", sa.Text(), nullable=True),
-            sa.Column("timestamp", sa.BigInteger(), nullable=True),
-            sa.PrimaryKeyConstraint("command"),
+            'prompt',
+            sa.Column('command', sa.String(), nullable=False),
+            sa.Column('user_id', sa.String(), nullable=True),
+            sa.Column('title', sa.Text(), nullable=True),
+            sa.Column('content', sa.Text(), nullable=True),
+            sa.Column('timestamp', sa.BigInteger(), nullable=True),
+            sa.PrimaryKeyConstraint('command'),
         )
 
-    if "tag" not in existing_tables:
+    if 'tag' not in existing_tables:
         op.create_table(
-            "tag",
-            sa.Column("id", sa.String(), nullable=False),
-            sa.Column("name", sa.String(), nullable=True),
-            sa.Column("user_id", sa.String(), nullable=True),
-            sa.Column("data", sa.Text(), nullable=True),
-            sa.PrimaryKeyConstraint("id"),
+            'tag',
+            sa.Column('id', sa.String(), nullable=False),
+            sa.Column('name', sa.String(), nullable=True),
+            sa.Column('user_id', sa.String(), nullable=True),
+            sa.Column('data', sa.Text(), nullable=True),
+            sa.PrimaryKeyConstraint('id'),
         )
 
-    if "tool" not in existing_tables:
+    if 'tool' not in existing_tables:
         op.create_table(
-            "tool",
-            sa.Column("id", sa.String(), nullable=False),
-            sa.Column("user_id", sa.String(), nullable=True),
-            sa.Column("name", sa.Text(), nullable=True),
-            sa.Column("content", sa.Text(), nullable=True),
-            sa.Column("specs", JSONField(), nullable=True),
-            sa.Column("meta", JSONField(), nullable=True),
-            sa.Column("valves", JSONField(), nullable=True),
-            sa.Column("updated_at", sa.BigInteger(), nullable=True),
-            sa.Column("created_at", sa.BigInteger(), nullable=True),
-            sa.PrimaryKeyConstraint("id"),
+            'tool',
+            sa.Column('id', sa.String(), nullable=False),
+            sa.Column('user_id', sa.String(), nullable=True),
+            sa.Column('name', sa.Text(), nullable=True),
+            sa.Column('content', sa.Text(), nullable=True),
+            sa.Column('specs', JSONField(), nullable=True),
+            sa.Column('meta', JSONField(), nullable=True),
+            sa.Column('valves', JSONField(), nullable=True),
+            sa.Column('updated_at', sa.BigInteger(), nullable=True),
+            sa.Column('created_at', sa.BigInteger(), nullable=True),
+            sa.PrimaryKeyConstraint('id'),
         )
 
-    if "user" not in existing_tables:
+    if 'user' not in existing_tables:
         op.create_table(
-            "user",
-            sa.Column("id", sa.String(), nullable=False),
-            sa.Column("name", sa.String(), nullable=True),
-            sa.Column("email", sa.String(), nullable=True),
-            sa.Column("role", sa.String(), nullable=True),
-            sa.Column("profile_image_url", sa.Text(), nullable=True),
-            sa.Column("last_active_at", sa.BigInteger(), nullable=True),
-            sa.Column("updated_at", sa.BigInteger(), nullable=True),
-            sa.Column("created_at", sa.BigInteger(), nullable=True),
-            sa.Column("api_key", sa.String(), nullable=True),
-            sa.Column("settings", JSONField(), nullable=True),
-            sa.Column("info", JSONField(), nullable=True),
-            sa.Column("oauth_sub", sa.Text(), nullable=True),
-            sa.PrimaryKeyConstraint("id"),
-            sa.UniqueConstraint("api_key"),
-            sa.UniqueConstraint("oauth_sub"),
+            'user',
+            sa.Column('id', sa.String(), nullable=False),
+            sa.Column('name', sa.String(), nullable=True),
+            sa.Column('email', sa.String(), nullable=True),
+            sa.Column('role', sa.String(), nullable=True),
+            sa.Column('profile_image_url', sa.Text(), nullable=True),
+            sa.Column('last_active_at', sa.BigInteger(), nullable=True),
+            sa.Column('updated_at', sa.BigInteger(), nullable=True),
+            sa.Column('created_at', sa.BigInteger(), nullable=True),
+            sa.Column('api_key', sa.String(), nullable=True),
+            sa.Column('settings', JSONField(), nullable=True),
+            sa.Column('info', JSONField(), nullable=True),
+            sa.Column('oauth_sub', sa.Text(), nullable=True),
+            sa.PrimaryKeyConstraint('id'),
+            sa.UniqueConstraint('api_key'),
+            sa.UniqueConstraint('oauth_sub'),
         )
     # ### end Alembic commands ###
 
 
 def downgrade() -> None:
     # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_table("user")
-    op.drop_table("tool")
-    op.drop_table("tag")
-    op.drop_table("prompt")
-    op.drop_table("model")
-    op.drop_table("memory")
-    op.drop_table("function")
-    op.drop_table("file")
-    op.drop_table("document")
-    op.drop_table("chatidtag")
-    op.drop_table("chat")
-    op.drop_table("auth")
+    op.drop_table('user')
+    op.drop_table('tool')
+    op.drop_table('tag')
+    op.drop_table('prompt')
+    op.drop_table('model')
+    op.drop_table('memory')
+    op.drop_table('function')
+    op.drop_table('file')
+    op.drop_table('document')
+    op.drop_table('chatidtag')
+    op.drop_table('chat')
+    op.drop_table('auth')
     # ### end Alembic commands ###

@@ -13,36 +13,34 @@
 import open_webui.internal.db
 
 # revision identifiers, used by Alembic.
-revision: str = "81cc2ce44d79"
-down_revision: Union[str, None] = "6283dc0e4d8d"
+revision: str = '81cc2ce44d79'
+down_revision: Union[str, None] = '6283dc0e4d8d'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
 
 def upgrade() -> None:
     # Add message_id column to channel_file table
-    with op.batch_alter_table("channel_file", schema=None) as batch_op:
+    with op.batch_alter_table('channel_file', schema=None) as batch_op:
         batch_op.add_column(
             sa.Column(
-                "message_id",
+                'message_id',
                 sa.Text(),
-                sa.ForeignKey(
-                    "message.id", ondelete="CASCADE", name="fk_channel_file_message_id"
-                ),
+                sa.ForeignKey('message.id', ondelete='CASCADE', name='fk_channel_file_message_id'),
                 nullable=True,
             )
         )
 
     # Add data column to knowledge table
-    with op.batch_alter_table("knowledge", schema=None) as batch_op:
-        batch_op.add_column(sa.Column("data", sa.JSON(), nullable=True))
+    with op.batch_alter_table('knowledge', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('data', sa.JSON(), nullable=True))
 
 
 def downgrade() -> None:
     # Remove message_id column from channel_file table
-    with op.batch_alter_table("channel_file", schema=None) as batch_op:
-        batch_op.drop_column("message_id")
+    with op.batch_alter_table('channel_file', schema=None) as batch_op:
+        batch_op.drop_column('message_id')
 
     # Remove data column from knowledge table
-    with op.batch_alter_table("knowledge", schema=None) as batch_op:
-        batch_op.drop_column("data")
+    with op.batch_alter_table('knowledge', schema=None) as batch_op:
+        batch_op.drop_column('data')

@@ -16,8 +16,8 @@
 
 log = logging.getLogger(__name__)
 
-revision: str = "8452d01d26d7"
-down_revision: Union[str, None] = "374d2f66af06"
+revision: str = '8452d01d26d7'
+down_revision: Union[str, None] = '374d2f66af06'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
@@ -51,82 +51,76 @@ def _flush_batch(conn, table, batch):
             except Exception as e:
                 sp.rollback()
                 failed += 1
-                log.warning(f"Failed to insert message {msg['id']}: {e}")
+                log.warning(f'Failed to insert message {msg["id"]}: {e}')
         return inserted, failed
 
 
 def upgrade() -> None:
     # Step 1: Create table
     op.create_table(
-        "chat_message",
-        sa.Column("id", sa.Text(), primary_key=True),
-        sa.Column("chat_id", sa.Text(), nullable=False, index=True),
-        sa.Column("user_id", sa.Text(), index=True),
-        sa.Column("role", sa.Text(), nullable=False),
-        sa.Column("parent_id", sa.Text(), nullable=True),
-        sa.Column("content", sa.JSON(), nullable=True),
-        sa.Column("output", sa.JSON(), nullable=True),
-        sa.Column("model_id", sa.Text(), nullable=True, index=True),
-        sa.Column("files", sa.JSON(), nullable=True),
-        sa.Column("sources", sa.JSON(), nullable=True),
-        sa.Column("embeds", sa.JSON(), nullable=True),
-        sa.Column("done", sa.Boolean(), default=True),
-        sa.Column("status_history", sa.JSON(), nullable=True),
-        sa.Column("error", sa.JSON(), nullable=True),
-        sa.Column("usage", sa.JSON(), nullable=True),
-        sa.Column("created_at", sa.BigInteger(), index=True),
-        sa.Column("updated_at", sa.BigInteger()),
-        sa.ForeignKeyConstraint(["chat_id"], ["chat.id"], ondelete="CASCADE"),
+        'chat_message',
+        sa.Column('id', sa.Text(), primary_key=True),
+        sa.Column('chat_id', sa.Text(), nullable=False, index=True),
+        sa.Column('user_id', sa.Text(), index=True),
+        sa.Column('role', sa.Text(), nullable=False),
+        sa.Column('parent_id', sa.Text(), nullable=True),
+        sa.Column('content', sa.JSON(), nullable=True),
+        sa.Column('output', sa.JSON(), nullable=True),
+        sa.Column('model_id', sa.Text(), nullable=True, index=True),
+        sa.Column('files', sa.JSON(), nullable=True),
+        sa.Column('sources', sa.JSON(), nullable=True),
+        sa.Column('embeds', sa.JSON(), nullable=True),
+        sa.Column('done', sa.Boolean(), default=True),
+        sa.Column('status_history', sa.JSON(), nullable=True),
+        sa.Column('error', sa.JSON(), nullable=True),
+        sa.Column('usage', sa.JSON(), nullable=True),
+        sa.Column('created_at', sa.BigInteger(), index=True),
+        sa.Column('updated_at', sa.BigInteger()),
+        sa.ForeignKeyConstraint(['chat_id'], ['chat.id'], ondelete='CASCADE'),
     )
 
     # Create composite indexes
-    op.create_index(
-        "chat_message_chat_parent_idx", "chat_message", ["chat_id", "parent_id"]
-    )
-    op.create_index(
-        "chat_message_model_created_idx", "chat_message", ["model_id", "created_at"]
-    )
-    op.create_index(
-        "chat_message_user_created_idx", "chat_message", ["user_id", "created_at"]
-    )
+    op.create_index('chat_message_chat_parent_idx', 'chat_message', ['chat_id', 'parent_id'])
+    op.create_index('chat_message_model_created_idx', 'chat_message', ['model_id', 'created_at'])
+    op.create_index('chat_message_user_created_idx', 'chat_message', ['user_id', 'created_at'])
 
     # Step 2: Backfill from existing chats
     conn = op.get_bind()
 
     chat_table = sa.table(
-        "chat",
-        sa.column("id", sa.Text()),
-        sa.column("user_id", sa.Text()),
-        sa.column("chat", sa.JSON()),
+        'chat',
+        sa.column('id', sa.Text()),
+        sa.column('user_id', sa.Text()),
+        sa.column('chat', sa.JSON()),
     )
 
     chat_message_table = sa.table(
-        "chat_message",
-        sa.column("id", sa.Text()),
-        sa.column("chat_id", sa.Text()),
-        sa.column("user_id", sa.Text()),
-        sa.column("role", sa.Text()),
-        sa.column("parent_id", sa.Text()),
-        sa.column("content", sa.JSON()),
-        sa.column("output", sa.JSON()),
-        sa.column("model_id", sa.Text()),
-        sa.column("files", sa.JSON()),
-        sa.column("sources", sa.JSON()),
-        sa.column("embeds", sa.JSON()),
-        sa.column("done", sa.Boolean()),
-        sa.column("status_history", sa.JSON()),
-        sa.column("error", sa.JSON()),
-        sa.column("usage", sa.JSON()),
-        sa.column("created_at", sa.BigInteger()),
-        sa.column("updated_at", sa.BigInteger()),
+        'chat_message',
+        sa.column('id', sa.Text()),
+        sa.column('chat_id', sa.Text()),
+        sa.column('user_id', sa.Text()),
+        sa.column('role', sa.Text()),
+        sa.column('parent_id', sa.Text()),
+        sa.column('content', sa.JSON()),
+        sa.column('output', sa.JSON()),
+        sa.column('model_id', sa.Text()),
+        sa.column('files', sa.JSON()),
+        sa.column('sources', sa.JSON()),
+        sa.column('embeds', sa.JSON()),
+        sa.column('done', sa.Boolean()),
+        sa.column('status_history', sa.JSON()),
+        sa.column('error', sa.JSON()),
+        sa.column('usage', sa.JSON()),
+        sa.column('created_at', sa.BigInteger()),
+        sa.column('updated_at', sa.BigInteger()),
     )
 
     # Stream rows instead of loading all into memory:
     # - yield_per: fetches rows in chunks via cursor.fetchmany() (all backends)
     # - stream_results: enables server-side cursors on PostgreSQL (no-op on SQLite)
     result = conn.execute(
         sa.select(chat_table.c.id, chat_table.c.user_id, chat_table.c.chat)
-        .where(~chat_table.c.user_id.like("shared-%"))
+        .where(~chat_table.c.user_id.like('shared-%'))
         .execution_options(yield_per=1000, stream_results=True)
     )
 
@@ -150,23 +144,23 @@ def upgrade() -> None:
             except Exception:
                 continue
 
-        history = chat_data.get("history", {})
+        history = chat_data.get('history', {})
         if not isinstance(history, dict):
             continue
 
-        messages = history.get("messages", {})
+        messages = history.get('messages', {})
         if not isinstance(messages, dict):
             continue
 
         for message_id, message in messages.items():
             if not isinstance(message, dict):
                 continue
 
-            role = message.get("role")
+            role = message.get('role')
             if not role:
                 continue
 
-            timestamp = message.get("timestamp", now)
+            timestamp = message.get('timestamp', now)
 
             try:
                 timestamp = int(float(timestamp))
@@ -182,37 +176,33 @@ def upgrade() -> None:
 
             messages_batch.append(
                 {
-                    "id": f"{chat_id}-{message_id}",
-                    "chat_id": chat_id,
-                    "user_id": user_id,
-                    "role": role,
-                    "parent_id": message.get("parentId"),
-                    "content": message.get("content"),
-                    "output": message.get("output"),
-                    "model_id": message.get("model"),
-                    "files": message.get("files"),
-                    "sources": message.get("sources"),
-                    "embeds": message.get("embeds"),
-                    "done": message.get("done", True),
-                    "status_history": message.get("statusHistory"),
-                    "error": message.get("error"),
-                    "usage": message.get("usage"),
-                    "created_at": timestamp,
-                    "updated_at": timestamp,
+                    'id': f'{chat_id}-{message_id}',
+                    'chat_id': chat_id,
+                    'user_id': user_id,
+                    'role': role,
+                    'parent_id': message.get('parentId'),
+                    'content': message.get('content'),
+                    'output': message.get('output'),
+                    'model_id': message.get('model'),
+                    'files': message.get('files'),
+                    'sources': message.get('sources'),
+                    'embeds': message.get('embeds'),
+                    'done': message.get('done', True),
+                    'status_history': message.get('statusHistory'),
+                    'error': message.get('error'),
+                    'usage': message.get('usage'),
+                    'created_at': timestamp,
+                    'updated_at': timestamp,
                 }
             )
 
             # Flush batch when full
             if len(messages_batch) >= BATCH_SIZE:
-                inserted, failed = _flush_batch(
-                    conn, chat_message_table, messages_batch
-                )
+                inserted, failed = _flush_batch(conn, chat_message_table, messages_batch)
                 total_inserted += inserted
                 total_failed += failed
                 if total_inserted % 50000 < BATCH_SIZE:
-                    log.info(
-                        f"Migration progress: {total_inserted} messages inserted..."
-                    )
+                    log.info(f'Migration progress: {total_inserted} messages inserted...')
                 messages_batch.clear()
 
     # Flush remaining messages
@@ -221,13 +211,11 @@ def upgrade() -> None:
         total_inserted += inserted
         total_failed += failed
 
-    log.info(
-        f"Backfilled {total_inserted} messages into chat_message table ({total_failed} failed)"
-    )
+    log.info(f'Backfilled {total_inserted} messages into chat_message table ({total_failed} failed)')
 
 
 def downgrade() -> None:
-    op.drop_index("chat_message_user_created_idx", table_name="chat_message")
-    op.drop_index("chat_message_model_created_idx", table_name="chat_message")
-    op.drop_index("chat_message_chat_parent_idx", table_name="chat_message")
-    op.drop_table("chat_message")
+    op.drop_index('chat_message_user_created_idx', table_name='chat_message')
+    op.drop_index('chat_message_model_created_idx', table_name='chat_message')
+    op.drop_index('chat_message_chat_parent_idx', table_name='chat_message')
+    op.drop_table('chat_message')

@@ -13,68 +13,66 @@
 import open_webui.internal.db
 
 # revision identifiers, used by Alembic.
-revision: str = "90ef40d4714e"
-down_revision: Union[str, None] = "b10670c03dd5"
+revision: str = '90ef40d4714e'
+down_revision: Union[str, None] = 'b10670c03dd5'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
 
 def upgrade() -> None:
     # Update 'channel' table
-    op.add_column("channel", sa.Column("is_private", sa.Boolean(), nullable=True))
+    op.add_column('channel', sa.Column('is_private', sa.Boolean(), nullable=True))
 
-    op.add_column("channel", sa.Column("archived_at", sa.BigInteger(), nullable=True))
-    op.add_column("channel", sa.Column("archived_by", sa.Text(), nullable=True))
+    op.add_column('channel', sa.Column('archived_at', sa.BigInteger(), nullable=True))
+    op.add_column('channel', sa.Column('archived_by', sa.Text(), nullable=True))
 
-    op.add_column("channel", sa.Column("deleted_at", sa.BigInteger(), nullable=True))
-    op.add_column("channel", sa.Column("deleted_by", sa.Text(), nullable=True))
+    op.add_column('channel', sa.Column('deleted_at', sa.BigInteger(), nullable=True))
+    op.add_column('channel', sa.Column('deleted_by', sa.Text(), nullable=True))
 
-    op.add_column("channel", sa.Column("updated_by", sa.Text(), nullable=True))
+    op.add_column('channel', sa.Column('updated_by', sa.Text(), nullable=True))
 
     # Update 'channel_member' table
-    op.add_column("channel_member", sa.Column("role", sa.Text(), nullable=True))
-    op.add_column("channel_member", sa.Column("invited_by", sa.Text(), nullable=True))
-    op.add_column(
-        "channel_member", sa.Column("invited_at", sa.BigInteger(), nullable=True)
-    )
+    op.add_column('channel_member', sa.Column('role', sa.Text(), nullable=True))
+    op.add_column('channel_member', sa.Column('invited_by', sa.Text(), nullable=True))
+    op.add_column('channel_member', sa.Column('invited_at', sa.BigInteger(), nullable=True))
 
     #  Create 'channel_webhook' table
     op.create_table(
-        "channel_webhook",
-        sa.Column("id", sa.Text(), primary_key=True, unique=True, nullable=False),
-        sa.Column("user_id", sa.Text(), nullable=False),
+        'channel_webhook',
+        sa.Column('id', sa.Text(), primary_key=True, unique=True, nullable=False),
+        sa.Column('user_id', sa.Text(), nullable=False),
         sa.Column(
-            "channel_id",
+            'channel_id',
             sa.Text(),
-            sa.ForeignKey("channel.id", ondelete="CASCADE"),
+            sa.ForeignKey('channel.id', ondelete='CASCADE'),
             nullable=False,
         ),
-        sa.Column("name", sa.Text(), nullable=False),
-        sa.Column("profile_image_url", sa.Text(), nullable=True),
-        sa.Column("token", sa.Text(), nullable=False),
-        sa.Column("last_used_at", sa.BigInteger(), nullable=True),
-        sa.Column("created_at", sa.BigInteger(), nullable=False),
-        sa.Column("updated_at", sa.BigInteger(), nullable=False),
+        sa.Column('name', sa.Text(), nullable=False),
+        sa.Column('profile_image_url', sa.Text(), nullable=True),
+        sa.Column('token', sa.Text(), nullable=False),
+        sa.Column('last_used_at', sa.BigInteger(), nullable=True),
+        sa.Column('created_at', sa.BigInteger(), nullable=False),
+        sa.Column('updated_at', sa.BigInteger(), nullable=False),
     )
 
     pass
 
 
 def downgrade() -> None:
     # Downgrade 'channel' table
-    op.drop_column("channel", "is_private")
-    op.drop_column("channel", "archived_at")
-    op.drop_column("channel", "archived_by")
-    op.drop_column("channel", "deleted_at")
-    op.drop_column("channel", "deleted_by")
-    op.drop_column("channel", "updated_by")
+    op.drop_column('channel', 'is_private')
+    op.drop_column('channel', 'archived_at')
+    op.drop_column('channel', 'archived_by')
+    op.drop_column('channel', 'deleted_at')
+    op.drop_column('channel', 'deleted_by')
+    op.drop_column('channel', 'updated_by')
 
     # Downgrade 'channel_member' table
-    op.drop_column("channel_member", "role")
-    op.drop_column("channel_member", "invited_by")
-    op.drop_column("channel_member", "invited_at")
+    op.drop_column('channel_member', 'role')
+    op.drop_column('channel_member', 'invited_by')
+    op.drop_column('channel_member', 'invited_at')
 
     # Drop 'channel_webhook' table
-    op.drop_table("channel_webhook")
+    op.drop_table('channel_webhook')
 
     pass

@@ -9,38 +9,38 @@
 from alembic import op
 import sqlalchemy as sa
 
-revision = "922e7a387820"
-down_revision = "4ace53fd72c8"
+revision = '922e7a387820'
+down_revision = '4ace53fd72c8'
 branch_labels = None
 depends_on = None
 
 
 def upgrade():
     op.create_table(
-        "group",
-        sa.Column("id", sa.Text(), nullable=False, primary_key=True, unique=True),
-        sa.Column("user_id", sa.Text(), nullable=True),
-        sa.Column("name", sa.Text(), nullable=True),
-        sa.Column("description", sa.Text(), nullable=True),
-        sa.Column("data", sa.JSON(), nullable=True),
-        sa.Column("meta", sa.JSON(), nullable=True),
-        sa.Column("permissions", sa.JSON(), nullable=True),
-        sa.Column("user_ids", sa.JSON(), nullable=True),
-        sa.Column("created_at", sa.BigInteger(), nullable=True),
-        sa.Column("updated_at", sa.BigInteger(), nullable=True),
+        'group',
+        sa.Column('id', sa.Text(), nullable=False, primary_key=True, unique=True),
+        sa.Column('user_id', sa.Text(), nullable=True),
+        sa.Column('name', sa.Text(), nullable=True),
+        sa.Column('description', sa.Text(), nullable=True),
+        sa.Column('data', sa.JSON(), nullable=True),
+        sa.Column('meta', sa.JSON(), nullable=True),
+        sa.Column('permissions', sa.JSON(), nullable=True),
+        sa.Column('user_ids', sa.JSON(), nullable=True),
+        sa.Column('created_at', sa.BigInteger(), nullable=True),
+        sa.Column('updated_at', sa.BigInteger(), nullable=True),
     )
 
     # Add 'access_control' column to 'model' table
     op.add_column(
-        "model",
-        sa.Column("access_control", sa.JSON(), nullable=True),
+        'model',
+        sa.Column('access_control', sa.JSON(), nullable=True),
     )
 
     # Add 'is_active' column to 'model' table
     op.add_column(
-        "model",
+        'model',
         sa.Column(
-            "is_active",
+            'is_active',
             sa.Boolean(),
             nullable=False,
             server_default=sa.sql.expression.true(),
@@ -49,37 +49,37 @@ def upgrade():
 
     # Add 'access_control' column to 'knowledge' table
     op.add_column(
-        "knowledge",
-        sa.Column("access_control", sa.JSON(), nullable=True),
+        'knowledge',
+        sa.Column('access_control', sa.JSON(), nullable=True),
     )
 
     # Add 'access_control' column to 'prompt' table
     op.add_column(
-        "prompt",
-        sa.Column("access_control", sa.JSON(), nullable=True),
+        'prompt',
+        sa.Column('access_control', sa.JSON(), nullable=True),
     )
 
     # Add 'access_control' column to 'tools' table
     op.add_column(
-        "tool",
-        sa.Column("access_control", sa.JSON(), nullable=True),
+        'tool',
+        sa.Column('access_control', sa.JSON(), nullable=True),
     )
 
 
 def downgrade():
-    op.drop_table("group")
+    op.drop_table('group')
 
     # Drop 'access_control' column from 'model' table
-    op.drop_column("model", "access_control")
+    op.drop_column('model', 'access_control')
 
     # Drop 'is_active' column from 'model' table
-    op.drop_column("model", "is_active")
+    op.drop_column('model', 'is_active')
 
     # Drop 'access_control' column from 'knowledge' table
-    op.drop_column("knowledge", "access_control")
+    op.drop_column('knowledge', 'access_control')
 
     # Drop 'access_control' column from 'prompt' table
-    op.drop_column("prompt", "access_control")
+    op.drop_column('prompt', 'access_control')
 
     # Drop 'access_control' column from 'tools' table
-    op.drop_column("tool", "access_control")
+    op.drop_column('tool', 'access_control')

@@ -9,25 +9,25 @@
 from alembic import op
 import sqlalchemy as sa
 
-revision = "9f0c9cd09105"
-down_revision = "3781e22d8b01"
+revision = '9f0c9cd09105'
+down_revision = '3781e22d8b01'
 branch_labels = None
 depends_on = None
 
 
 def upgrade():
     op.create_table(
-        "note",
-        sa.Column("id", sa.Text(), nullable=False, primary_key=True, unique=True),
-        sa.Column("user_id", sa.Text(), nullable=True),
-        sa.Column("title", sa.Text(), nullable=True),
-        sa.Column("data", sa.JSON(), nullable=True),
-        sa.Column("meta", sa.JSON(), nullable=True),
-        sa.Column("access_control", sa.JSON(), nullable=True),
-        sa.Column("created_at", sa.BigInteger(), nullable=True),
-        sa.Column("updated_at", sa.BigInteger(), nullable=True),
+        'note',
+        sa.Column('id', sa.Text(), nullable=False, primary_key=True, unique=True),
+        sa.Column('user_id', sa.Text(), nullable=True),
+        sa.Column('title', sa.Text(), nullable=True),
+        sa.Column('data', sa.JSON(), nullable=True),
+        sa.Column('meta', sa.JSON(), nullable=True),
+        sa.Column('access_control', sa.JSON(), nullable=True),
+        sa.Column('created_at', sa.BigInteger(), nullable=True),
+        sa.Column('updated_at', sa.BigInteger(), nullable=True),
     )
 
 
 def downgrade():
-    op.drop_table("note")
+    op.drop_table('note')

@@ -13,33 +13,33 @@
 
 from open_webui.migrations.util import get_existing_tables
 
-revision: str = "a1b2c3d4e5f6"
-down_revision: Union[str, None] = "f1e2d3c4b5a6"
+revision: str = 'a1b2c3d4e5f6'
+down_revision: Union[str, None] = 'f1e2d3c4b5a6'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
 
 def upgrade() -> None:
     existing_tables = set(get_existing_tables())
 
-    if "skill" not in existing_tables:
+    if 'skill' not in existing_tables:
         op.create_table(
-            "skill",
-            sa.Column("id", sa.String(), nullable=False, primary_key=True),
-            sa.Column("user_id", sa.String(), nullable=False),
-            sa.Column("name", sa.Text(), nullable=False, unique=True),
-            sa.Column("description", sa.Text(), nullable=True),
-            sa.Column("content", sa.Text(), nullable=False),
-            sa.Column("meta", sa.JSON(), nullable=True),
-            sa.Column("is_active", sa.Boolean(), nullable=False),
-            sa.Column("updated_at", sa.BigInteger(), nullable=False),
-            sa.Column("created_at", sa.BigInteger(), nullable=False),
+            'skill',
+            sa.Column('id', sa.String(), nullable=False, primary_key=True),
+            sa.Column('user_id', sa.String(), nullable=False),
+            sa.Column('name', sa.Text(), nullable=False, unique=True),
+            sa.Column('description', sa.Text(), nullable=True),
+            sa.Column('content', sa.Text(), nullable=False),
+            sa.Column('meta', sa.JSON(), nullable=True),
+            sa.Column('is_active', sa.Boolean(), nullable=False),
+            sa.Column('updated_at', sa.BigInteger(), nullable=False),
+            sa.Column('created_at', sa.BigInteger(), nullable=False),
         )
-        op.create_index("idx_skill_user_id", "skill", ["user_id"])
-        op.create_index("idx_skill_updated_at", "skill", ["updated_at"])
+        op.create_index('idx_skill_user_id', 'skill', ['user_id'])
+        op.create_index('idx_skill_updated_at', 'skill', ['updated_at'])
 
 
 def downgrade() -> None:
-    op.drop_index("idx_skill_updated_at", table_name="skill")
-    op.drop_index("idx_skill_user_id", table_name="skill")
-    op.drop_table("skill")
+    op.drop_index('idx_skill_updated_at', table_name='skill')
+    op.drop_index('idx_skill_user_id', table_name='skill')
+    op.drop_table('skill')

@@ -12,23 +12,23 @@
 import sqlalchemy as sa
 
 # revision identifiers, used by Alembic.
-revision: str = "a5c220713937"
-down_revision: Union[str, None] = "38d63c18f30f"
+revision: str = 'a5c220713937'
+down_revision: Union[str, None] = '38d63c18f30f'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
 
 def upgrade() -> None:
     # Add 'reply_to_id' column to the 'message' table for replying to messages
     op.add_column(
-        "message",
-        sa.Column("reply_to_id", sa.Text(), nullable=True),
+        'message',
+        sa.Column('reply_to_id', sa.Text(), nullable=True),
     )
     pass
 
 
 def downgrade() -> None:
     # Remove 'reply_to_id' column from the 'message' table
-    op.drop_column("message", "reply_to_id")
+    op.drop_column('message', 'reply_to_id')
 
     pass

@@ -10,42 +10,32 @@
 import sqlalchemy as sa
 
 # Revision identifiers, used by Alembic.
-revision = "af906e964978"
-down_revision = "c29facfe716b"
+revision = 'af906e964978'
+down_revision = 'c29facfe716b'
 branch_labels = None
 depends_on = None
 
 
 def upgrade():
     # ### Create feedback table ###
     op.create_table(
-        "feedback",
+        'feedback',
+        sa.Column('id', sa.Text(), primary_key=True),  # Unique identifier for each feedback (TEXT type)
+        sa.Column('user_id', sa.Text(), nullable=True),  # ID of the user providing the feedback (TEXT type)
+        sa.Column('version', sa.BigInteger(), default=0),  # Version of feedback (BIGINT type)
+        sa.Column('type', sa.Text(), nullable=True),  # Type of feedback (TEXT type)
+        sa.Column('data', sa.JSON(), nullable=True),  # Feedback data (JSON type)
+        sa.Column('meta', sa.JSON(), nullable=True),  # Metadata for feedback (JSON type)
+        sa.Column('snapshot', sa.JSON(), nullable=True),  # snapshot data for feedback (JSON type)
         sa.Column(
-            "id", sa.Text(), primary_key=True
-        ),  # Unique identifier for each feedback (TEXT type)
-        sa.Column(
-            "user_id", sa.Text(), nullable=True
-        ),  # ID of the user providing the feedback (TEXT type)
-        sa.Column(
-            "version", sa.BigInteger(), default=0
-        ),  # Version of feedback (BIGINT type)
-        sa.Column("type", sa.Text(), nullable=True),  # Type of feedback (TEXT type)
-        sa.Column("data", sa.JSON(), nullable=True),  # Feedback data (JSON type)
-        sa.Column(
-            "meta", sa.JSON(), nullable=True
-        ),  # Metadata for feedback (JSON type)
-        sa.Column(
-            "snapshot", sa.JSON(), nullable=True
-        ),  # snapshot data for feedback (JSON type)
-        sa.Column(
-            "created_at", sa.BigInteger(), nullable=False
+            'created_at', sa.BigInteger(), nullable=False
         ),  # Feedback creation timestamp (BIGINT representing epoch)
         sa.Column(
-            "updated_at", sa.BigInteger(), nullable=False
+            'updated_at', sa.BigInteger(), nullable=False
         ),  # Feedback update timestamp (BIGINT representing epoch)
     )
 
 
 def downgrade():
     # ### Drop feedback table ###
-    op.drop_table("feedback")
+    op.drop_table('feedback')

@@ -17,8 +17,8 @@
 import time
 
 # revision identifiers, used by Alembic.
-revision: str = "b10670c03dd5"
-down_revision: Union[str, None] = "2f1211949ecc"
+revision: str = 'b10670c03dd5'
+down_revision: Union[str, None] = '2f1211949ecc'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
@@ -33,23 +33,21 @@ def _drop_sqlite_indexes_for_column(table_name, column_name, conn):
     for idx in indexes:
         index_name = idx[1]  # index name
         # Get indexed columns
-        idx_info = conn.execute(
-            sa.text(f"PRAGMA index_info('{index_name}')")
-        ).fetchall()
+        idx_info = conn.execute(sa.text(f"PRAGMA index_info('{index_name}')")).fetchall()
 
         indexed_cols = [row[2] for row in idx_info]  # col names
         if column_name in indexed_cols:
-            conn.execute(sa.text(f"DROP INDEX IF EXISTS {index_name}"))
+            conn.execute(sa.text(f'DROP INDEX IF EXISTS {index_name}'))
 
 
 def _convert_column_to_json(table: str, column: str):
     conn = op.get_bind()
     dialect = conn.dialect.name
 
     # SQLite cannot ALTER COLUMN → must recreate column
-    if dialect == "sqlite":
+    if dialect == 'sqlite':
         # 1. Add temporary column
-        op.add_column(table, sa.Column(f"{column}_json", sa.JSON(), nullable=True))
+        op.add_column(table, sa.Column(f'{column}_json', sa.JSON(), nullable=True))
 
         # 2. Load old data
         rows = conn.execute(sa.text(f'SELECT id, {column} FROM "{table}"')).fetchall()
@@ -66,108 +64,100 @@ def _convert_column_to_json(table: str, column: str):
 
             conn.execute(
                 sa.text(f'UPDATE "{table}" SET {column}_json = :val WHERE id = :id'),
-                {"val": json.dumps(parsed) if parsed else None, "id": uid},
+                {'val': json.dumps(parsed) if parsed else None, 'id': uid},
             )
 
         # 3. Drop old TEXT column
         op.drop_column(table, column)
 
         # 4. Rename new JSON column → original name
-        op.alter_column(table, f"{column}_json", new_column_name=column)
+        op.alter_column(table, f'{column}_json', new_column_name=column)
 
     else:
         # PostgreSQL supports direct CAST
         op.alter_column(
             table,
             column,
             type_=sa.JSON(),
-            postgresql_using=f"{column}::json",
+            postgresql_using=f'{column}::json',
         )
 
 
 def _convert_column_to_text(table: str, column: str):
     conn = op.get_bind()
     dialect = conn.dialect.name
 
-    if dialect == "sqlite":
-        op.add_column(table, sa.Column(f"{column}_text", sa.Text(), nullable=True))
+    if dialect == 'sqlite':
+        op.add_column(table, sa.Column(f'{column}_text', sa.Text(), nullable=True))
 
         rows = conn.execute(sa.text(f'SELECT id, {column} FROM "{table}"')).fetchall()
 
         for uid, raw in rows:
             conn.execute(
                 sa.text(f'UPDATE "{table}" SET {column}_text = :val WHERE id = :id'),
-                {"val": json.dumps(raw) if raw else None, "id": uid},
+                {'val': json.dumps(raw) if raw else None, 'id': uid},
             )
 
         op.drop_column(table, column)
-        op.alter_column(table, f"{column}_text", new_column_name=column)
+        op.alter_column(table, f'{column}_text', new_column_name=column)
 
     else:
         op.alter_column(
             table,
             column,
             type_=sa.Text(),
-            postgresql_using=f"to_json({column})::text",
+            postgresql_using=f'to_json({column})::text',
         )
 
 
 def upgrade() -> None:
-    op.add_column(
-        "user", sa.Column("profile_banner_image_url", sa.Text(), nullable=True)
-    )
-    op.add_column("user", sa.Column("timezone", sa.String(), nullable=True))
+    op.add_column('user', sa.Column('profile_banner_image_url', sa.Text(), nullable=True))
+    op.add_column('user', sa.Column('timezone', sa.String(), nullable=True))
 
-    op.add_column("user", sa.Column("presence_state", sa.String(), nullable=True))
-    op.add_column("user", sa.Column("status_emoji", sa.String(), nullable=True))
-    op.add_column("user", sa.Column("status_message", sa.Text(), nullable=True))
-    op.add_column(
-        "user", sa.Column("status_expires_at", sa.BigInteger(), nullable=True)
-    )
+    op.add_column('user', sa.Column('presence_state', sa.String(), nullable=True))
+    op.add_column('user', sa.Column('status_emoji', sa.String(), nullable=True))
+    op.add_column('user', sa.Column('status_message', sa.Text(), nullable=True))
+    op.add_column('user', sa.Column('status_expires_at', sa.BigInteger(), nullable=True))
 
-    op.add_column("user", sa.Column("oauth", sa.JSON(), nullable=True))
+    op.add_column('user', sa.Column('oauth', sa.JSON(), nullable=True))
 
     # Convert info (TEXT/JSONField) → JSON
-    _convert_column_to_json("user", "info")
+    _convert_column_to_json('user', 'info')
     # Convert settings (TEXT/JSONField) → JSON
-    _convert_column_to_json("user", "settings")
+    _convert_column_to_json('user', 'settings')
 
     op.create_table(
-        "api_key",
-        sa.Column("id", sa.Text(), primary_key=True, unique=True),
-        sa.Column("user_id", sa.Text(), sa.ForeignKey("user.id", ondelete="CASCADE")),
-        sa.Column("key", sa.Text(), unique=True, nullable=False),
-        sa.Column("data", sa.JSON(), nullable=True),
-        sa.Column("expires_at", sa.BigInteger(), nullable=True),
-        sa.Column("last_used_at", sa.BigInteger(), nullable=True),
-        sa.Column("created_at", sa.BigInteger(), nullable=False),
-        sa.Column("updated_at", sa.BigInteger(), nullable=False),
+        'api_key',
+        sa.Column('id', sa.Text(), primary_key=True, unique=True),
+        sa.Column('user_id', sa.Text(), sa.ForeignKey('user.id', ondelete='CASCADE')),
+        sa.Column('key', sa.Text(), unique=True, nullable=False),
+        sa.Column('data', sa.JSON(), nullable=True),
+        sa.Column('expires_at', sa.BigInteger(), nullable=True),
+        sa.Column('last_used_at', sa.BigInteger(), nullable=True),
+        sa.Column('created_at', sa.BigInteger(), nullable=False),
+        sa.Column('updated_at', sa.BigInteger(), nullable=False),
     )
 
     conn = op.get_bind()
-    users = conn.execute(
-        sa.text('SELECT id, oauth_sub FROM "user" WHERE oauth_sub IS NOT NULL')
-    ).fetchall()
+    users = conn.execute(sa.text('SELECT id, oauth_sub FROM "user" WHERE oauth_sub IS NOT NULL')).fetchall()
 
     for uid, oauth_sub in users:
         if oauth_sub:
             # Example formats supported:
             #   provider@sub
             #   plain sub (stored as {"oidc": {"sub": sub}})
-            if "@" in oauth_sub:
-                provider, sub = oauth_sub.split("@", 1)
+            if '@' in oauth_sub:
+                provider, sub = oauth_sub.split('@', 1)
             else:
-                provider, sub = "oidc", oauth_sub
+                provider, sub = 'oidc', oauth_sub
 
-            oauth_json = json.dumps({provider: {"sub": sub}})
+            oauth_json = json.dumps({provider: {'sub': sub}})
             conn.execute(
                 sa.text('UPDATE "user" SET oauth = :oauth WHERE id = :id'),
-                {"oauth": oauth_json, "id": uid},
+                {'oauth': oauth_json, 'id': uid},
             )
 
-    users_with_keys = conn.execute(
-        sa.text('SELECT id, api_key FROM "user" WHERE api_key IS NOT NULL')
-    ).fetchall()
+    users_with_keys = conn.execute(sa.text('SELECT id, api_key FROM "user" WHERE api_key IS NOT NULL')).fetchall()
     now = int(time.time())
 
     for uid, api_key in users_with_keys:
@@ -178,72 +168,70 @@ def upgrade() -> None:
                     VALUES (:id, :user_id, :key, :created_at, :updated_at)
                 """),
                 {
-                    "id": f"key_{uid}",
-                    "user_id": uid,
-                    "key": api_key,
-                    "created_at": now,
-                    "updated_at": now,
+                    'id': f'key_{uid}',
+                    'user_id': uid,
+                    'key': api_key,
+                    'created_at': now,
+                    'updated_at': now,
                 },
             )
 
-    if conn.dialect.name == "sqlite":
-        _drop_sqlite_indexes_for_column("user", "api_key", conn)
-        _drop_sqlite_indexes_for_column("user", "oauth_sub", conn)
+    if conn.dialect.name == 'sqlite':
+        _drop_sqlite_indexes_for_column('user', 'api_key', conn)
+        _drop_sqlite_indexes_for_column('user', 'oauth_sub', conn)
 
-    with op.batch_alter_table("user") as batch_op:
-        batch_op.drop_column("api_key")
-        batch_op.drop_column("oauth_sub")
+    with op.batch_alter_table('user') as batch_op:
+        batch_op.drop_column('api_key')
+        batch_op.drop_column('oauth_sub')
 
 
 def downgrade() -> None:
     # --- 1. Restore old oauth_sub column ---
-    op.add_column("user", sa.Column("oauth_sub", sa.Text(), nullable=True))
+    op.add_column('user', sa.Column('oauth_sub', sa.Text(), nullable=True))
 
     conn = op.get_bind()
-    users = conn.execute(
-        sa.text('SELECT id, oauth FROM "user" WHERE oauth IS NOT NULL')
-    ).fetchall()
+    users = conn.execute(sa.text('SELECT id, oauth FROM "user" WHERE oauth IS NOT NULL')).fetchall()
 
     for uid, oauth in users:
         try:
             data = json.loads(oauth)
             provider = list(data.keys())[0]
-            sub = data[provider].get("sub")
-            oauth_sub = f"{provider}@{sub}"
+            sub = data[provider].get('sub')
+            oauth_sub = f'{provider}@{sub}'
         except Exception:
             oauth_sub = None
 
         conn.execute(
             sa.text('UPDATE "user" SET oauth_sub = :oauth_sub WHERE id = :id'),
-            {"oauth_sub": oauth_sub, "id": uid},
+            {'oauth_sub': oauth_sub, 'id': uid},
         )
 
-    op.drop_column("user", "oauth")
+    op.drop_column('user', 'oauth')
 
     # --- 2. Restore api_key field ---
-    op.add_column("user", sa.Column("api_key", sa.String(), nullable=True))
+    op.add_column('user', sa.Column('api_key', sa.String(), nullable=True))
 
     # Restore values from api_key
-    keys = conn.execute(sa.text("SELECT user_id, key FROM api_key")).fetchall()
+    keys = conn.execute(sa.text('SELECT user_id, key FROM api_key')).fetchall()
     for uid, key in keys:
         conn.execute(
             sa.text('UPDATE "user" SET api_key = :key WHERE id = :id'),
-            {"key": key, "id": uid},
+            {'key': key, 'id': uid},
         )
 
     # Drop new table
-    op.drop_table("api_key")
+    op.drop_table('api_key')
 
-    with op.batch_alter_table("user") as batch_op:
-        batch_op.drop_column("profile_banner_image_url")
-        batch_op.drop_column("timezone")
+    with op.batch_alter_table('user') as batch_op:
+        batch_op.drop_column('profile_banner_image_url')
+        batch_op.drop_column('timezone')
 
-        batch_op.drop_column("presence_state")
-        batch_op.drop_column("status_emoji")
-        batch_op.drop_column("status_message")
-        batch_op.drop_column("status_expires_at")
+        batch_op.drop_column('presence_state')
+        batch_op.drop_column('status_emoji')
+        batch_op.drop_column('status_message')
+        batch_op.drop_column('status_expires_at')
 
     # Convert info (JSON) → TEXT
-    _convert_column_to_text("user", "info")
+    _convert_column_to_text('user', 'info')
     # Convert settings (JSON) → TEXT
-    _convert_column_to_text("user", "settings")
+    _convert_column_to_text('user', 'settings')

@@ -12,15 +12,15 @@
 import sqlalchemy as sa
 
 # revision identifiers, used by Alembic.
-revision: str = "b2c3d4e5f6a7"
-down_revision: Union[str, None] = "a1b2c3d4e5f6"
+revision: str = 'b2c3d4e5f6a7'
+down_revision: Union[str, None] = 'a1b2c3d4e5f6'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
 
 def upgrade() -> None:
-    op.add_column("user", sa.Column("scim", sa.JSON(), nullable=True))
+    op.add_column('user', sa.Column('scim', sa.JSON(), nullable=True))
 
 
 def downgrade() -> None:
-    op.drop_column("user", "scim")
+    op.drop_column('user', 'scim')

@@ -12,21 +12,21 @@
 from alembic import op
 
 # revision identifiers, used by Alembic.
-revision: str = "c0fbf31ca0db"
-down_revision: Union[str, None] = "ca81bd47c050"
+revision: str = 'c0fbf31ca0db'
+down_revision: Union[str, None] = 'ca81bd47c050'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
 
 def upgrade():
     # ### commands auto generated by Alembic - please adjust! ###
-    op.add_column("file", sa.Column("hash", sa.Text(), nullable=True))
-    op.add_column("file", sa.Column("data", sa.JSON(), nullable=True))
-    op.add_column("file", sa.Column("updated_at", sa.BigInteger(), nullable=True))
+    op.add_column('file', sa.Column('hash', sa.Text(), nullable=True))
+    op.add_column('file', sa.Column('data', sa.JSON(), nullable=True))
+    op.add_column('file', sa.Column('updated_at', sa.BigInteger(), nullable=True))
 
 
 def downgrade():
     # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_column("file", "updated_at")
-    op.drop_column("file", "data")
-    op.drop_column("file", "hash")
+    op.drop_column('file', 'updated_at')
+    op.drop_column('file', 'data')
+    op.drop_column('file', 'hash')

@@ -12,35 +12,33 @@
 from sqlalchemy.sql import table, column
 from sqlalchemy import String, Text, JSON, and_
 
-revision = "c29facfe716b"
-down_revision = "c69f45358db4"
+revision = 'c29facfe716b'
+down_revision = 'c69f45358db4'
 branch_labels = None
 depends_on = None
 
 
 def upgrade():
     # 1. Add the `path` column to the "file" table.
-    op.add_column("file", sa.Column("path", sa.Text(), nullable=True))
+    op.add_column('file', sa.Column('path', sa.Text(), nullable=True))
 
     # 2. Convert the `meta` column from Text/JSONField to `JSON()`
     # Use Alembic's default batch_op for dialect compatibility.
-    with op.batch_alter_table("file", schema=None) as batch_op:
+    with op.batch_alter_table('file', schema=None) as batch_op:
         batch_op.alter_column(
-            "meta",
+            'meta',
             type_=sa.JSON(),
             existing_type=sa.Text(),
             existing_nullable=True,
             nullable=True,
-            postgresql_using="meta::json",
+            postgresql_using='meta::json',
         )
 
     # 3. Migrate legacy data from `meta` JSONField
     # Fetch and process `meta` data from the table, add values to the new `path` column as necessary.
     # We will use SQLAlchemy core bindings to ensure safety across different databases.
 
-    file_table = table(
-        "file", column("id", String), column("meta", JSON), column("path", Text)
-    )
+    file_table = table('file', column('id', String), column('meta', JSON), column('path', Text))
 
     # Create connection to the database
     connection = op.get_bind()
@@ -55,24 +53,18 @@ def upgrade():
 
     # Iterate over each row to extract and update the `path` from `meta` column
     for row in results:
-        if "path" in row.meta:
+        if 'path' in row.meta:
             # Extract the `path` field from the `meta` JSON
-            path = row.meta.get("path")
+            path = row.meta.get('path')
 
             # Update the `file` table with the new `path` value
-            connection.execute(
-                file_table.update()
-                .where(file_table.c.id == row.id)
-                .values({"path": path})
-            )
+            connection.execute(file_table.update().where(file_table.c.id == row.id).values({'path': path}))
 
 
 def downgrade():
     # 1. Remove the `path` column
-    op.drop_column("file", "path")
+    op.drop_column('file', 'path')
 
     # 2. Revert the `meta` column back to Text/JSONField
-    with op.batch_alter_table("file", schema=None) as batch_op:
-        batch_op.alter_column(
-            "meta", type_=sa.Text(), existing_type=sa.JSON(), existing_nullable=True
-        )
+    with op.batch_alter_table('file', schema=None) as batch_op:
+        batch_op.alter_column('meta', type_=sa.Text(), existing_type=sa.JSON(), existing_nullable=True)

@@ -12,45 +12,43 @@
 import sqlalchemy as sa
 
 # revision identifiers, used by Alembic.
-revision: str = "c440947495f3"
-down_revision: Union[str, None] = "81cc2ce44d79"
+revision: str = 'c440947495f3'
+down_revision: Union[str, None] = '81cc2ce44d79'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
 
 def upgrade() -> None:
     op.create_table(
-        "chat_file",
-        sa.Column("id", sa.Text(), primary_key=True),
-        sa.Column("user_id", sa.Text(), nullable=False),
+        'chat_file',
+        sa.Column('id', sa.Text(), primary_key=True),
+        sa.Column('user_id', sa.Text(), nullable=False),
         sa.Column(
-            "chat_id",
+            'chat_id',
             sa.Text(),
-            sa.ForeignKey("chat.id", ondelete="CASCADE"),
+            sa.ForeignKey('chat.id', ondelete='CASCADE'),
             nullable=False,
         ),
         sa.Column(
-            "file_id",
+            'file_id',
             sa.Text(),
-            sa.ForeignKey("file.id", ondelete="CASCADE"),
+            sa.ForeignKey('file.id', ondelete='CASCADE'),
             nullable=False,
         ),
-        sa.Column("message_id", sa.Text(), nullable=True),
-        sa.Column("created_at", sa.BigInteger(), nullable=False),
-        sa.Column("updated_at", sa.BigInteger(), nullable=False),
+        sa.Column('message_id', sa.Text(), nullable=True),
+        sa.Column('created_at', sa.BigInteger(), nullable=False),
+        sa.Column('updated_at', sa.BigInteger(), nullable=False),
         # indexes
-        sa.Index("ix_chat_file_chat_id", "chat_id"),
-        sa.Index("ix_chat_file_file_id", "file_id"),
-        sa.Index("ix_chat_file_message_id", "message_id"),
-        sa.Index("ix_chat_file_user_id", "user_id"),
+        sa.Index('ix_chat_file_chat_id', 'chat_id'),
+        sa.Index('ix_chat_file_file_id', 'file_id'),
+        sa.Index('ix_chat_file_message_id', 'message_id'),
+        sa.Index('ix_chat_file_user_id', 'user_id'),
         # unique constraints
-        sa.UniqueConstraint(
-            "chat_id", "file_id", name="uq_chat_file_chat_file"
-        ),  # prevent duplicate entries
+        sa.UniqueConstraint('chat_id', 'file_id', name='uq_chat_file_chat_file'),  # prevent duplicate entries
     )
     pass
 
 
 def downgrade() -> None:
-    op.drop_table("chat_file")
+    op.drop_table('chat_file')
     pass

@@ -9,42 +9,40 @@
 from alembic import op
 import sqlalchemy as sa
 
-revision = "c69f45358db4"
-down_revision = "3ab32c4b8f59"
+revision = 'c69f45358db4'
+down_revision = '3ab32c4b8f59'
 branch_labels = None
 depends_on = None
 
 
 def upgrade():
     op.create_table(
-        "folder",
-        sa.Column("id", sa.Text(), nullable=False),
-        sa.Column("parent_id", sa.Text(), nullable=True),
-        sa.Column("user_id", sa.Text(), nullable=False),
-        sa.Column("name", sa.Text(), nullable=False),
-        sa.Column("items", sa.JSON(), nullable=True),
-        sa.Column("meta", sa.JSON(), nullable=True),
-        sa.Column("is_expanded", sa.Boolean(), default=False, nullable=False),
+        'folder',
+        sa.Column('id', sa.Text(), nullable=False),
+        sa.Column('parent_id', sa.Text(), nullable=True),
+        sa.Column('user_id', sa.Text(), nullable=False),
+        sa.Column('name', sa.Text(), nullable=False),
+        sa.Column('items', sa.JSON(), nullable=True),
+        sa.Column('meta', sa.JSON(), nullable=True),
+        sa.Column('is_expanded', sa.Boolean(), default=False, nullable=False),
+        sa.Column('created_at', sa.DateTime(), server_default=sa.func.now(), nullable=False),
         sa.Column(
-            "created_at", sa.DateTime(), server_default=sa.func.now(), nullable=False
-        ),
-        sa.Column(
-            "updated_at",
+            'updated_at',
             sa.DateTime(),
             nullable=False,
             server_default=sa.func.now(),
             onupdate=sa.func.now(),
         ),
-        sa.PrimaryKeyConstraint("id", "user_id"),
+        sa.PrimaryKeyConstraint('id', 'user_id'),
     )
 
     op.add_column(
-        "chat",
-        sa.Column("folder_id", sa.Text(), nullable=True),
+        'chat',
+        sa.Column('folder_id', sa.Text(), nullable=True),
     )
 
 
 def downgrade():
-    op.drop_column("chat", "folder_id")
+    op.drop_column('chat', 'folder_id')
 
-    op.drop_table("folder")
+    op.drop_table('folder')