feat: bg tasks via fastapi

backend/alembic/versions/57122d037335_add_python_tool_on_default.py

@@ -1,69 +0,0 @@
-"""add python tool on default
-
-Revision ID: 57122d037335
-Revises: c0c937d5c9e5
-Create Date: 2026-02-27 10:10:40.124925
-
-"""
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = "57122d037335"
-down_revision = "c0c937d5c9e5"
-branch_labels = None
-depends_on = None
-
-
-PYTHON_TOOL_NAME = "python"
-
-
-def upgrade() -> None:
-    conn = op.get_bind()
-
-    # Look up the PythonTool id
-    result = conn.execute(
-        sa.text("SELECT id FROM tool WHERE name = :name"),
-        {"name": PYTHON_TOOL_NAME},
-    ).fetchone()
-
-    if not result:
-        return
-
-    tool_id = result[0]
-
-    # Attach to the default persona (id=0) if not already attached
-    conn.execute(
-        sa.text(
-            """
-            INSERT INTO persona__tool (persona_id, tool_id)
-            VALUES (0, :tool_id)
-            ON CONFLICT DO NOTHING
-            """
-        ),
-        {"tool_id": tool_id},
-    )
-
-
-def downgrade() -> None:
-    conn = op.get_bind()
-
-    result = conn.execute(
-        sa.text("SELECT id FROM tool WHERE name = :name"),
-        {"name": PYTHON_TOOL_NAME},
-    ).fetchone()
-
-    if not result:
-        return
-
-    conn.execute(
-        sa.text(
-            """
-            DELETE FROM persona__tool
-            WHERE persona_id = 0 AND tool_id = :tool_id
-            """
-        ),
-        {"tool_id": result[0]},
-    )

backend/onyx/background/celery/tasks/beat_schedule.py

@@ -241,8 +241,7 @@ _VECTOR_DB_BEAT_TASK_NAMES: set[str] = {
     "check-for-index-attempt-cleanup",
     "check-for-doc-permissions-sync",
     "check-for-external-group-sync",
-    "check-for-documents-for-opensearch-migration",
-    "migrate-documents-from-vespa-to-opensearch",
+    "migrate-chunks-from-vespa-to-opensearch",
 }
 
 if DISABLE_VECTOR_DB:

backend/onyx/background/celery/tasks/user_file_processing/tasks.py

@@ -414,34 +414,31 @@ def _process_user_file_with_indexing(
         raise RuntimeError(f"Indexing pipeline failed for user file {user_file_id}")
 
 
-@shared_task(
-    name=OnyxCeleryTask.PROCESS_SINGLE_USER_FILE,
-    bind=True,
-    ignore_result=True,
-)
-def process_single_user_file(
-    self: Task, *, user_file_id: str, tenant_id: str  # noqa: ARG001
+def _process_user_file_impl(
+    *, user_file_id: str, tenant_id: str, redis_locking: bool
 ) -> None:
-    task_logger.info(f"process_single_user_file - Starting id={user_file_id}")
+    """Core implementation for processing a single user file.
+
+    When redis_locking=True, acquires a per-file Redis lock and clears the
+    queued-key guard (Celery path).  When redis_locking=False, skips all Redis
+    operations (BackgroundTask path).
+    """
+    task_logger.info(f"_process_user_file_impl - Starting id={user_file_id}")
     start = time.monotonic()
 
-    redis_client = get_redis_client(tenant_id=tenant_id)
-
-    # Clear the "queued" guard set by the beat generator so that the next beat
-    # cycle can re-enqueue this file if it is still in PROCESSING state after
-    # this task completes or fails.
-    redis_client.delete(_user_file_queued_key(user_file_id))
-
-    file_lock: RedisLock = redis_client.lock(
-        _user_file_lock_key(user_file_id),
-        timeout=CELERY_USER_FILE_PROCESSING_LOCK_TIMEOUT,
-    )
-
-    if not file_lock.acquire(blocking=False):
-        task_logger.info(
-            f"process_single_user_file - Lock held, skipping user_file_id={user_file_id}"
+    file_lock: RedisLock | None = None
+    if redis_locking:
+        redis_client = get_redis_client(tenant_id=tenant_id)
+        redis_client.delete(_user_file_queued_key(user_file_id))
+        file_lock = redis_client.lock(
+            _user_file_lock_key(user_file_id),
+            timeout=CELERY_USER_FILE_PROCESSING_LOCK_TIMEOUT,
         )
-        return None
+        if not file_lock.acquire(blocking=False):
+            task_logger.info(
+                f"_process_user_file_impl - Lock held, skipping user_file_id={user_file_id}"
+            )
+            return
 
     documents: list[Document] = []
     try:
@@ -449,15 +446,15 @@ def process_single_user_file(
             uf = db_session.get(UserFile, _as_uuid(user_file_id))
             if not uf:
                 task_logger.warning(
-                    f"process_single_user_file - UserFile not found id={user_file_id}"
+                    f"_process_user_file_impl - UserFile not found id={user_file_id}"
                 )
-                return None
+                return
 
             if uf.status != UserFileStatus.PROCESSING:
                 task_logger.info(
-                    f"process_single_user_file - Skipping id={user_file_id} status={uf.status}"
+                    f"_process_user_file_impl - Skipping id={user_file_id} status={uf.status}"
                 )
-                return None
+                return
 
             connector = LocalFileConnector(
                 file_locations=[uf.file_id],
@@ -471,7 +468,6 @@ def process_single_user_file(
                         [doc for doc in batch if not isinstance(doc, HierarchyNode)]
                     )
 
-                # update the document id to userfile id in the documents
                 for document in documents:
                     document.id = str(user_file_id)
                     document.source = DocumentSource.USER_FILE
@@ -493,9 +489,8 @@ def process_single_user_file(
 
             except Exception as e:
                 task_logger.exception(
-                    f"process_single_user_file - Error processing file id={user_file_id} - {e.__class__.__name__}"
+                    f"_process_user_file_impl - Error processing file id={user_file_id} - {e.__class__.__name__}"
                 )
-                # don't update the status if the user file is being deleted
                 current_user_file = db_session.get(UserFile, _as_uuid(user_file_id))
                 if (
                     current_user_file
@@ -504,33 +499,42 @@ def process_single_user_file(
                     uf.status = UserFileStatus.FAILED
                     db_session.add(uf)
                     db_session.commit()
-                return None
+                return
 
         elapsed = time.monotonic() - start
         task_logger.info(
-            f"process_single_user_file - Finished id={user_file_id} docs={len(documents)} elapsed={elapsed:.2f}s"
+            f"_process_user_file_impl - Finished id={user_file_id} docs={len(documents)} elapsed={elapsed:.2f}s"
         )
-        return None
     except Exception as e:
-        # Attempt to mark the file as failed
         with get_session_with_current_tenant() as db_session:
             uf = db_session.get(UserFile, _as_uuid(user_file_id))
             if uf:
-                # don't update the status if the user file is being deleted
                 if uf.status != UserFileStatus.DELETING:
                     uf.status = UserFileStatus.FAILED
                 db_session.add(uf)
                 db_session.commit()
 
         task_logger.exception(
-            f"process_single_user_file - Error processing file id={user_file_id} - {e.__class__.__name__}"
+            f"_process_user_file_impl - Error processing file id={user_file_id} - {e.__class__.__name__}"
         )
-        return None
     finally:
-        if file_lock.owned():
+        if file_lock is not None and file_lock.owned():
             file_lock.release()
 
 
+@shared_task(
+    name=OnyxCeleryTask.PROCESS_SINGLE_USER_FILE,
+    bind=True,
+    ignore_result=True,
+)
+def process_single_user_file(
+    self: Task, *, user_file_id: str, tenant_id: str  # noqa: ARG001
+) -> None:
+    _process_user_file_impl(
+        user_file_id=user_file_id, tenant_id=tenant_id, redis_locking=True
+    )
+
+
 @shared_task(
     name=OnyxCeleryTask.CHECK_FOR_USER_FILE_DELETE,
     soft_time_limit=300,
@@ -581,36 +585,38 @@ def check_for_user_file_delete(self: Task, *, tenant_id: str) -> None:
     return None
 
 
-@shared_task(
-    name=OnyxCeleryTask.DELETE_SINGLE_USER_FILE,
-    bind=True,
-    ignore_result=True,
-)
-def process_single_user_file_delete(
-    self: Task, *, user_file_id: str, tenant_id: str  # noqa: ARG001
+def _delete_user_file_impl(
+    *, user_file_id: str, tenant_id: str, redis_locking: bool
 ) -> None:
-    """Process a single user file delete."""
-    task_logger.info(f"process_single_user_file_delete - Starting id={user_file_id}")
-    redis_client = get_redis_client(tenant_id=tenant_id)
-    file_lock: RedisLock = redis_client.lock(
-        _user_file_delete_lock_key(user_file_id),
-        timeout=CELERY_GENERIC_BEAT_LOCK_TIMEOUT,
-    )
-    if not file_lock.acquire(blocking=False):
-        task_logger.info(
-            f"process_single_user_file_delete - Lock held, skipping user_file_id={user_file_id}"
+    """Core implementation for deleting a single user file.
+
+    When redis_locking=True, acquires a per-file Redis lock (Celery path).
+    When redis_locking=False, skips Redis operations (BackgroundTask path).
+    """
+    task_logger.info(f"_delete_user_file_impl - Starting id={user_file_id}")
+
+    file_lock: RedisLock | None = None
+    if redis_locking:
+        redis_client = get_redis_client(tenant_id=tenant_id)
+        file_lock = redis_client.lock(
+            _user_file_delete_lock_key(user_file_id),
+            timeout=CELERY_GENERIC_BEAT_LOCK_TIMEOUT,
         )
-        return None
+        if not file_lock.acquire(blocking=False):
+            task_logger.info(
+                f"_delete_user_file_impl - Lock held, skipping user_file_id={user_file_id}"
+            )
+            return
+
     try:
         with get_session_with_current_tenant() as db_session:
             user_file = db_session.get(UserFile, _as_uuid(user_file_id))
             if not user_file:
                 task_logger.info(
-                    f"process_single_user_file_delete - User file not found id={user_file_id}"
+                    f"_delete_user_file_impl - User file not found id={user_file_id}"
                 )
-                return None
+                return
 
-            # 1) Delete vector DB chunks (skip when disabled)
             if not DISABLE_VECTOR_DB:
                 if MANAGED_VESPA:
                     httpx_init_vespa_pool(
@@ -648,7 +654,6 @@ def process_single_user_file_delete(
                         chunk_count=chunk_count,
                     )
 
-            # 2) Delete the user-uploaded file content from filestore (blob + metadata)
             file_store = get_default_file_store()
             try:
                 file_store.delete_file(user_file.file_id)
@@ -656,26 +661,33 @@ def process_single_user_file_delete(
                     user_file_id_to_plaintext_file_name(user_file.id)
                 )
             except Exception as e:
-                # This block executed only if the file is not found in the filestore
                 task_logger.exception(
-                    f"process_single_user_file_delete - Error deleting file id={user_file.id} - {e.__class__.__name__}"
+                    f"_delete_user_file_impl - Error deleting file id={user_file.id} - {e.__class__.__name__}"
                 )
 
-            # 3) Finally, delete the UserFile row
             db_session.delete(user_file)
             db_session.commit()
-            task_logger.info(
-                f"process_single_user_file_delete - Completed id={user_file_id}"
-            )
+            task_logger.info(f"_delete_user_file_impl - Completed id={user_file_id}")
     except Exception as e:
         task_logger.exception(
-            f"process_single_user_file_delete - Error processing file id={user_file_id} - {e.__class__.__name__}"
+            f"_delete_user_file_impl - Error processing file id={user_file_id} - {e.__class__.__name__}"
         )
-        return None
     finally:
-        if file_lock.owned():
+        if file_lock is not None and file_lock.owned():
             file_lock.release()
-    return None
+
+
+@shared_task(
+    name=OnyxCeleryTask.DELETE_SINGLE_USER_FILE,
+    bind=True,
+    ignore_result=True,
+)
+def process_single_user_file_delete(
+    self: Task, *, user_file_id: str, tenant_id: str  # noqa: ARG001
+) -> None:
+    _delete_user_file_impl(
+        user_file_id=user_file_id, tenant_id=tenant_id, redis_locking=True
+    )
 
 
 @shared_task(
@@ -747,32 +759,30 @@ def check_for_user_file_project_sync(self: Task, *, tenant_id: str) -> None:
     return None
 
 
-@shared_task(
-    name=OnyxCeleryTask.PROCESS_SINGLE_USER_FILE_PROJECT_SYNC,
-    bind=True,
-    ignore_result=True,
-)
-def process_single_user_file_project_sync(
-    self: Task, *, user_file_id: str, tenant_id: str  # noqa: ARG001
+def _project_sync_user_file_impl(
+    *, user_file_id: str, tenant_id: str, redis_locking: bool
 ) -> None:
-    """Process a single user file project sync."""
-    task_logger.info(
-        f"process_single_user_file_project_sync - Starting id={user_file_id}"
-    )
+    """Core implementation for syncing a user file's project/persona metadata.
 
-    redis_client = get_redis_client(tenant_id=tenant_id)
-    redis_client.delete(_user_file_project_sync_queued_key(user_file_id))
+    When redis_locking=True, acquires a per-file Redis lock and clears the
+    queued-key guard (Celery path).  When redis_locking=False, skips Redis
+    operations (BackgroundTask path).
+    """
+    task_logger.info(f"_project_sync_user_file_impl - Starting id={user_file_id}")
 
-    file_lock: RedisLock = redis_client.lock(
-        user_file_project_sync_lock_key(user_file_id),
-        timeout=CELERY_USER_FILE_PROJECT_SYNC_LOCK_TIMEOUT,
-    )
-
-    if not file_lock.acquire(blocking=False):
-        task_logger.info(
-            f"process_single_user_file_project_sync - Lock held, skipping user_file_id={user_file_id}"
+    file_lock: RedisLock | None = None
+    if redis_locking:
+        redis_client = get_redis_client(tenant_id=tenant_id)
+        redis_client.delete(_user_file_project_sync_queued_key(user_file_id))
+        file_lock = redis_client.lock(
+            user_file_project_sync_lock_key(user_file_id),
+            timeout=CELERY_USER_FILE_PROJECT_SYNC_LOCK_TIMEOUT,
         )
-        return None
+        if not file_lock.acquire(blocking=False):
+            task_logger.info(
+                f"_project_sync_user_file_impl - Lock held, skipping user_file_id={user_file_id}"
+            )
+            return
 
     try:
         with get_session_with_current_tenant() as db_session:
@@ -783,11 +793,10 @@ def process_single_user_file_project_sync(
             ).scalar_one_or_none()
             if not user_file:
                 task_logger.info(
-                    f"process_single_user_file_project_sync - User file not found id={user_file_id}"
+                    f"_project_sync_user_file_impl - User file not found id={user_file_id}"
                 )
-                return None
+                return
 
-            # Sync project metadata to vector DB (skip when disabled)
             if not DISABLE_VECTOR_DB:
                 if MANAGED_VESPA:
                     httpx_init_vespa_pool(
@@ -822,7 +831,7 @@ def process_single_user_file_project_sync(
                     )
 
             task_logger.info(
-                f"process_single_user_file_project_sync - User file id={user_file_id}"
+                f"_project_sync_user_file_impl - User file id={user_file_id}"
             )
 
             user_file.needs_project_sync = False
@@ -835,11 +844,21 @@ def process_single_user_file_project_sync(
 
     except Exception as e:
         task_logger.exception(
-            f"process_single_user_file_project_sync - Error syncing project for file id={user_file_id} - {e.__class__.__name__}"
+            f"_project_sync_user_file_impl - Error syncing project for file id={user_file_id} - {e.__class__.__name__}"
         )
-        return None
     finally:
-        if file_lock.owned():
+        if file_lock is not None and file_lock.owned():
             file_lock.release()
 
-    return None
+
+@shared_task(
+    name=OnyxCeleryTask.PROCESS_SINGLE_USER_FILE_PROJECT_SYNC,
+    bind=True,
+    ignore_result=True,
+)
+def process_single_user_file_project_sync(
+    self: Task, *, user_file_id: str, tenant_id: str  # noqa: ARG001
+) -> None:
+    _project_sync_user_file_impl(
+        user_file_id=user_file_id, tenant_id=tenant_id, redis_locking=True
+    )

backend/onyx/background/task_utils.py

@@ -1,3 +1,35 @@
+"""Background task utilities.
+
+Contains query-history report helpers (used by all deployment modes) and
+in-process background task execution helpers for NO_VECTOR_DB mode:
+
+- Postgres advisory lock-based concurrency semaphore (10d)
+- Drain loops that process all pending user file work (10e)
+- Entry points wired to FastAPI BackgroundTasks (10c)
+
+Advisory locks are session-level: they persist until explicitly released via
+``pg_advisory_unlock`` or until the DB connection closes.  The semaphore
+session is kept open for the entire drain loop so the slot stays held, and
+released in a ``finally`` block before the connection returns to the pool.
+"""
+
+from uuid import UUID
+
+import sqlalchemy as sa
+from sqlalchemy import select
+from sqlalchemy import text
+from sqlalchemy.orm import Session
+
+from onyx.db.enums import UserFileStatus
+from onyx.db.models import UserFile
+from onyx.utils.logger import setup_logger
+
+logger = setup_logger()
+
+# ------------------------------------------------------------------
+# Query-history report helpers (pre-existing, used by all modes)
+# ------------------------------------------------------------------
+
 QUERY_REPORT_NAME_PREFIX = "query-history"
 
 
@@ -9,3 +41,173 @@ def construct_query_history_report_name(
 
 def extract_task_id_from_query_history_report_name(name: str) -> str:
     return name.removeprefix(f"{QUERY_REPORT_NAME_PREFIX}-").removesuffix(".csv")
+
+
+# ------------------------------------------------------------------
+# Postgres advisory lock semaphore (NO_VECTOR_DB mode)
+# ------------------------------------------------------------------
+
+BACKGROUND_TASK_SLOT_BASE = 10_000
+BACKGROUND_TASK_MAX_CONCURRENCY = 4
+
+
+def try_acquire_semaphore_slot(db_session: Session) -> int | None:
+    """Try to acquire one of N advisory lock slots.
+
+    Returns the slot number (0-based) if acquired, ``None`` if all slots are
+    taken.  ``pg_try_advisory_lock`` is non-blocking — returns ``false``
+    immediately when the lock is held by another session.
+    """
+    for slot in range(BACKGROUND_TASK_MAX_CONCURRENCY):
+        lock_id = BACKGROUND_TASK_SLOT_BASE + slot
+        acquired = db_session.execute(
+            text("SELECT pg_try_advisory_lock(:id)"),
+            {"id": lock_id},
+        ).scalar()
+        if acquired:
+            return slot
+    return None
+
+
+def release_semaphore_slot(db_session: Session, slot: int) -> None:
+    """Release a previously acquired advisory lock slot."""
+    lock_id = BACKGROUND_TASK_SLOT_BASE + slot
+    db_session.execute(
+        text("SELECT pg_advisory_unlock(:id)"),
+        {"id": lock_id},
+    )
+
+
+# ------------------------------------------------------------------
+# Work-claiming helpers (FOR UPDATE SKIP LOCKED)
+# ------------------------------------------------------------------
+
+
+def _claim_next_processing_file(db_session: Session) -> UUID | None:
+    """Claim the next file in PROCESSING status."""
+    return db_session.execute(
+        select(UserFile.id)
+        .where(UserFile.status == UserFileStatus.PROCESSING)
+        .order_by(UserFile.created_at)
+        .limit(1)
+        .with_for_update(skip_locked=True)
+    ).scalar_one_or_none()
+
+
+def _claim_next_deleting_file(db_session: Session) -> UUID | None:
+    """Claim the next file in DELETING status."""
+    return db_session.execute(
+        select(UserFile.id)
+        .where(UserFile.status == UserFileStatus.DELETING)
+        .order_by(UserFile.created_at)
+        .limit(1)
+        .with_for_update(skip_locked=True)
+    ).scalar_one_or_none()
+
+
+def _claim_next_sync_file(db_session: Session) -> UUID | None:
+    """Claim the next file needing project/persona sync."""
+    return db_session.execute(
+        select(UserFile.id)
+        .where(
+            sa.and_(
+                sa.or_(
+                    UserFile.needs_project_sync.is_(True),
+                    UserFile.needs_persona_sync.is_(True),
+                ),
+                UserFile.status == UserFileStatus.COMPLETED,
+            )
+        )
+        .order_by(UserFile.created_at)
+        .limit(1)
+        .with_for_update(skip_locked=True)
+    ).scalar_one_or_none()
+
+
+# ------------------------------------------------------------------
+# Drain loops — acquire a semaphore slot then process *all* pending work
+# ------------------------------------------------------------------
+
+
+def drain_processing_loop(tenant_id: str) -> None:
+    """Process all pending PROCESSING user files."""
+    from onyx.background.celery.tasks.user_file_processing.tasks import (
+        _process_user_file_impl,
+    )
+    from onyx.db.engine.sql_engine import get_session_with_current_tenant
+
+    with get_session_with_current_tenant() as sem_session:
+        slot = try_acquire_semaphore_slot(sem_session)
+        if slot is None:
+            logger.info("drain_processing_loop - All semaphore slots taken, skipping")
+            return
+
+        try:
+            while True:
+                with get_session_with_current_tenant() as claim_session:
+                    file_id = _claim_next_processing_file(claim_session)
+                if file_id is None:
+                    break
+                _process_user_file_impl(
+                    user_file_id=str(file_id),
+                    tenant_id=tenant_id,
+                    redis_locking=False,
+                )
+        finally:
+            release_semaphore_slot(sem_session, slot)
+
+
+def drain_delete_loop(tenant_id: str) -> None:
+    """Delete all pending DELETING user files."""
+    from onyx.background.celery.tasks.user_file_processing.tasks import (
+        _delete_user_file_impl,
+    )
+    from onyx.db.engine.sql_engine import get_session_with_current_tenant
+
+    with get_session_with_current_tenant() as sem_session:
+        slot = try_acquire_semaphore_slot(sem_session)
+        if slot is None:
+            logger.info("drain_delete_loop - All semaphore slots taken, skipping")
+            return
+
+        try:
+            while True:
+                with get_session_with_current_tenant() as claim_session:
+                    file_id = _claim_next_deleting_file(claim_session)
+                if file_id is None:
+                    break
+                _delete_user_file_impl(
+                    user_file_id=str(file_id),
+                    tenant_id=tenant_id,
+                    redis_locking=False,
+                )
+        finally:
+            release_semaphore_slot(sem_session, slot)
+
+
+def drain_project_sync_loop(tenant_id: str) -> None:
+    """Sync all pending project/persona metadata for user files."""
+    from onyx.background.celery.tasks.user_file_processing.tasks import (
+        _project_sync_user_file_impl,
+    )
+    from onyx.db.engine.sql_engine import get_session_with_current_tenant
+
+    with get_session_with_current_tenant() as sem_session:
+        slot = try_acquire_semaphore_slot(sem_session)
+        if slot is None:
+            logger.info("drain_project_sync_loop - All semaphore slots taken, skipping")
+            return
+
+        try:
+            while True:
+                with get_session_with_current_tenant() as claim_session:
+                    file_id = _claim_next_sync_file(claim_session)
+                if file_id is None:
+                    break
+                _project_sync_user_file_impl(
+                    user_file_id=str(file_id),
+                    tenant_id=tenant_id,
+                    redis_locking=False,
+                )
+        finally:
+            release_semaphore_slot(sem_session, slot)

backend/onyx/db/projects.py

@@ -1,6 +1,7 @@
 import datetime
 import uuid
 from typing import List
+from typing import TYPE_CHECKING
 from uuid import UUID
 
 from fastapi import HTTPException
@@ -10,7 +11,10 @@ from pydantic import ConfigDict
 from sqlalchemy import func
 from sqlalchemy.orm import Session
 
-from onyx.background.celery.versioned_apps.client import app as client_app
+if TYPE_CHECKING:
+    from starlette.background import BackgroundTasks
+
+from onyx.configs.app_configs import DISABLE_VECTOR_DB
 from onyx.configs.constants import FileOrigin
 from onyx.configs.constants import OnyxCeleryPriority
 from onyx.configs.constants import OnyxCeleryQueues
@@ -105,8 +109,8 @@ def upload_files_to_user_files_with_indexing(
     user: User,
     temp_id_map: dict[str, str] | None,
     db_session: Session,
+    background_tasks: BackgroundTasks | None = None,
 ) -> CategorizedFilesResult:
-    # Validate project ownership if a project_id is provided
     if project_id is not None and user is not None:
         if not check_project_ownership(project_id, user.id, db_session):
             raise HTTPException(status_code=404, detail="Project not found")
@@ -127,16 +131,27 @@ def upload_files_to_user_files_with_indexing(
         logger.warning(
             f"File {rejected_file.filename} rejected for {rejected_file.reason}"
         )
-    for user_file in user_files:
-        task = client_app.send_task(
-            OnyxCeleryTask.PROCESS_SINGLE_USER_FILE,
-            kwargs={"user_file_id": user_file.id, "tenant_id": tenant_id},
-            queue=OnyxCeleryQueues.USER_FILE_PROCESSING,
-            priority=OnyxCeleryPriority.HIGH,
-        )
-        logger.info(
-            f"Triggered indexing for user_file_id={user_file.id} with task_id={task.id}"
-        )
+
+    if DISABLE_VECTOR_DB and background_tasks is not None:
+        from onyx.background.task_utils import drain_processing_loop
+
+        background_tasks.add_task(drain_processing_loop, tenant_id)
+        for user_file in user_files:
+            logger.info(f"Queued in-process processing for user_file_id={user_file.id}")
+    else:
+        from onyx.background.celery.versioned_apps.client import app as client_app
+
+        for user_file in user_files:
+            task = client_app.send_task(
+                OnyxCeleryTask.PROCESS_SINGLE_USER_FILE,
+                kwargs={"user_file_id": user_file.id, "tenant_id": tenant_id},
+                queue=OnyxCeleryQueues.USER_FILE_PROCESSING,
+                priority=OnyxCeleryPriority.HIGH,
+            )
+            logger.info(
+                f"Triggered indexing for user_file_id={user_file.id} "
+                f"with task_id={task.id}"
+            )
 
     return CategorizedFilesResult(
         user_files=user_files,

backend/onyx/main.py

@@ -37,6 +37,7 @@ from onyx.configs.app_configs import APP_HOST
 from onyx.configs.app_configs import APP_PORT
 from onyx.configs.app_configs import AUTH_RATE_LIMITING_ENABLED
 from onyx.configs.app_configs import AUTH_TYPE
+from onyx.configs.app_configs import DISABLE_VECTOR_DB
 from onyx.configs.app_configs import LOG_ENDPOINT_LATENCY
 from onyx.configs.app_configs import OAUTH_CLIENT_ID
 from onyx.configs.app_configs import OAUTH_CLIENT_SECRET
@@ -254,8 +255,38 @@ def include_auth_router_with_prefix(
     )
 
 
+def validate_no_vector_db_settings() -> None:
+    """Validate that DISABLE_VECTOR_DB is not combined with incompatible settings.
+
+    Raises RuntimeError if DISABLE_VECTOR_DB is set alongside MULTI_TENANT or ENABLE_CRAFT,
+    since these modes require infrastructure that is removed in no-vector-DB deployments.
+    """
+    if not DISABLE_VECTOR_DB:
+        return
+
+    if MULTI_TENANT:
+        raise RuntimeError(
+            "DISABLE_VECTOR_DB cannot be used with MULTI_TENANT. "
+            "Multi-tenant deployments require the vector database for "
+            "per-tenant document indexing and search. Run in single-tenant "
+            "mode when disabling the vector database."
+        )
+
+    from onyx.server.features.build.configs import ENABLE_CRAFT
+
+    if ENABLE_CRAFT:
+        raise RuntimeError(
+            "DISABLE_VECTOR_DB cannot be used with ENABLE_CRAFT. "
+            "Onyx Craft requires background workers for sandbox lifecycle "
+            "management, which are removed in no-vector-DB deployments. "
+            "Disable Craft (ENABLE_CRAFT=false) when disabling the vector database."
+        )
+
+
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:  # noqa: ARG001
+    validate_no_vector_db_settings()
+
     # Set recursion limit
     if SYSTEM_RECURSION_LIMIT is not None:
         sys.setrecursionlimit(SYSTEM_RECURSION_LIMIT)

backend/onyx/server/features/projects/api.py

@@ -2,6 +2,7 @@ import json
 from uuid import UUID
 
 from fastapi import APIRouter
+from fastapi import BackgroundTasks
 from fastapi import Depends
 from fastapi import File
 from fastapi import Form
@@ -12,13 +13,7 @@ from pydantic import BaseModel
 from sqlalchemy.orm import Session
 
 from onyx.auth.users import current_user
-from onyx.background.celery.tasks.user_file_processing.tasks import (
-    enqueue_user_file_project_sync_task,
-)
-from onyx.background.celery.tasks.user_file_processing.tasks import (
-    get_user_file_project_sync_queue_depth,
-)
-from onyx.background.celery.versioned_apps.client import app as client_app
+from onyx.configs.app_configs import DISABLE_VECTOR_DB
 from onyx.configs.constants import OnyxCeleryPriority
 from onyx.configs.constants import OnyxCeleryQueues
 from onyx.configs.constants import OnyxCeleryTask
@@ -34,7 +29,6 @@ from onyx.db.models import UserProject
 from onyx.db.persona import get_personas_by_ids
 from onyx.db.projects import get_project_token_count
 from onyx.db.projects import upload_files_to_user_files_with_indexing
-from onyx.redis.redis_pool import get_redis_client
 from onyx.server.features.projects.models import CategorizedFilesSnapshot
 from onyx.server.features.projects.models import ChatSessionRequest
 from onyx.server.features.projects.models import TokenCountResponse
@@ -55,7 +49,27 @@ class UserFileDeleteResult(BaseModel):
     assistant_names: list[str] = []
 
 
-def _trigger_user_file_project_sync(user_file_id: UUID, tenant_id: str) -> None:
+def _trigger_user_file_project_sync(
+    user_file_id: UUID,
+    tenant_id: str,
+    background_tasks: BackgroundTasks | None = None,
+) -> None:
+    if DISABLE_VECTOR_DB and background_tasks is not None:
+        from onyx.background.task_utils import drain_project_sync_loop
+
+        background_tasks.add_task(drain_project_sync_loop, tenant_id)
+        logger.info(f"Queued in-process project sync for user_file_id={user_file_id}")
+        return
+
+    from onyx.background.celery.tasks.user_file_processing.tasks import (
+        enqueue_user_file_project_sync_task,
+    )
+    from onyx.background.celery.tasks.user_file_processing.tasks import (
+        get_user_file_project_sync_queue_depth,
+    )
+    from onyx.background.celery.versioned_apps.client import app as client_app
+    from onyx.redis.redis_pool import get_redis_client
+
     queue_depth = get_user_file_project_sync_queue_depth(client_app)
     if queue_depth > USER_FILE_PROJECT_SYNC_MAX_QUEUE_DEPTH:
         logger.warning(
@@ -111,6 +125,7 @@ def create_project(
 
 @router.post("/file/upload", tags=PUBLIC_API_TAGS)
 def upload_user_files(
+    bg_tasks: BackgroundTasks,
     files: list[UploadFile] = File(...),
     project_id: int | None = Form(None),
     temp_id_map: str | None = Form(None),  # JSON string mapping hashed key -> temp_id
@@ -137,12 +152,12 @@ def upload_user_files(
             user=user,
             temp_id_map=parsed_temp_id_map,
             db_session=db_session,
+            background_tasks=bg_tasks if DISABLE_VECTOR_DB else None,
         )
 
         return CategorizedFilesSnapshot.from_result(categorized_files_result)
 
     except Exception as e:
-        # Log error with type, message, and stack for easier debugging
         logger.exception(f"Error uploading files - {type(e).__name__}: {str(e)}")
         raise HTTPException(
             status_code=500,
@@ -192,6 +207,7 @@ def get_files_in_project(
 def unlink_user_file_from_project(
     project_id: int,
     file_id: UUID,
+    bg_tasks: BackgroundTasks,
     user: User = Depends(current_user),
     db_session: Session = Depends(get_session),
 ) -> Response:
@@ -208,7 +224,6 @@ def unlink_user_file_from_project(
     if project is None:
         raise HTTPException(status_code=404, detail="Project not found")
 
-    user_id = user.id
     user_file = (
         db_session.query(UserFile)
         .filter(UserFile.id == file_id, UserFile.user_id == user_id)
@@ -224,7 +239,7 @@ def unlink_user_file_from_project(
         db_session.commit()
 
     tenant_id = get_current_tenant_id()
-    _trigger_user_file_project_sync(user_file.id, tenant_id)
+    _trigger_user_file_project_sync(user_file.id, tenant_id, bg_tasks)
 
     return Response(status_code=204)
 
@@ -237,6 +252,7 @@ def unlink_user_file_from_project(
 def link_user_file_to_project(
     project_id: int,
     file_id: UUID,
+    bg_tasks: BackgroundTasks,
     user: User = Depends(current_user),
     db_session: Session = Depends(get_session),
 ) -> UserFileSnapshot:
@@ -268,7 +284,7 @@ def link_user_file_to_project(
         db_session.commit()
 
     tenant_id = get_current_tenant_id()
-    _trigger_user_file_project_sync(user_file.id, tenant_id)
+    _trigger_user_file_project_sync(user_file.id, tenant_id, bg_tasks)
 
     return UserFileSnapshot.from_model(user_file)
 
@@ -426,6 +442,7 @@ def delete_project(
 @router.delete("/file/{file_id}", tags=PUBLIC_API_TAGS)
 def delete_user_file(
     file_id: UUID,
+    bg_tasks: BackgroundTasks,
     user: User = Depends(current_user),
     db_session: Session = Depends(get_session),
 ) -> UserFileDeleteResult:
@@ -458,15 +475,25 @@ def delete_user_file(
     db_session.commit()
 
     tenant_id = get_current_tenant_id()
-    task = client_app.send_task(
-        OnyxCeleryTask.DELETE_SINGLE_USER_FILE,
-        kwargs={"user_file_id": str(user_file.id), "tenant_id": tenant_id},
-        queue=OnyxCeleryQueues.USER_FILE_DELETE,
-        priority=OnyxCeleryPriority.HIGH,
-    )
-    logger.info(
-        f"Triggered delete for user_file_id={user_file.id} with task_id={task.id}"
-    )
+    if DISABLE_VECTOR_DB:
+        from onyx.background.task_utils import drain_delete_loop
+
+        bg_tasks.add_task(drain_delete_loop, tenant_id)
+        logger.info(f"Queued in-process delete for user_file_id={user_file.id}")
+    else:
+        from onyx.background.celery.versioned_apps.client import app as client_app
+
+        task = client_app.send_task(
+            OnyxCeleryTask.DELETE_SINGLE_USER_FILE,
+            kwargs={"user_file_id": str(user_file.id), "tenant_id": tenant_id},
+            queue=OnyxCeleryQueues.USER_FILE_DELETE,
+            priority=OnyxCeleryPriority.HIGH,
+        )
+        logger.info(
+            f"Triggered delete for user_file_id={user_file.id} "
+            f"with task_id={task.id}"
+        )
+
     return UserFileDeleteResult(
         has_associations=False, project_names=[], assistant_names=[]
     )

backend/tests/integration/tests/migrations/test_assistant_consolidation_migration.py

@@ -72,9 +72,6 @@ def test_cold_startup_default_assistant() -> None:
         assert (
             "read_file" in tool_names
         ), "Default assistant should have FileReaderTool attached"
-        assert (
-            "python" in tool_names
-        ), "Default assistant should have PythonTool attached"
 
         # Also verify by display names for clarity
         assert (
@@ -89,11 +86,8 @@ def test_cold_startup_default_assistant() -> None:
         assert (
             "File Reader" in tool_display_names
         ), "Default assistant should have File Reader tool"
-        assert (
-            "Code Interpreter" in tool_display_names
-        ), "Default assistant should have Code Interpreter tool"
 
-        # Should have exactly 6 tools
+        # Should have exactly 5 tools
         assert (
-            len(tool_associations) == 6
-        ), f"Default assistant should have exactly 6 tools attached, got {len(tool_associations)}"
+            len(tool_associations) == 5
+        ), f"Default assistant should have exactly 5 tools attached, got {len(tool_associations)}"

backend/tests/unit/onyx/background/celery/tasks/test_user_file_impl_redis_locking.py

@@ -0,0 +1,291 @@
+"""Tests for the _impl functions' redis_locking parameter.
+
+Verifies that:
+- redis_locking=True acquires/releases Redis locks and clears queued keys
+- redis_locking=False skips all Redis operations entirely
+- Both paths execute the same business logic (DB lookup, status check)
+"""
+
+from unittest.mock import MagicMock
+from unittest.mock import patch
+from uuid import uuid4
+
+from onyx.background.celery.tasks.user_file_processing.tasks import (
+    _delete_user_file_impl,
+)
+from onyx.background.celery.tasks.user_file_processing.tasks import (
+    _process_user_file_impl,
+)
+from onyx.background.celery.tasks.user_file_processing.tasks import (
+    _project_sync_user_file_impl,
+)
+
+TASKS_MODULE = "onyx.background.celery.tasks.user_file_processing.tasks"
+
+
+def _mock_session_returning_none() -> MagicMock:
+    """Return a mock session whose .get() returns None (file not found)."""
+    session = MagicMock()
+    session.get.return_value = None
+    session.execute.return_value.scalar_one_or_none.return_value = None
+    return session
+
+
+# ------------------------------------------------------------------
+# _process_user_file_impl
+# ------------------------------------------------------------------
+
+
+class TestProcessUserFileImpl:
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    @patch(f"{TASKS_MODULE}.get_redis_client")
+    def test_redis_locking_true_acquires_and_releases_lock(
+        self,
+        mock_get_redis: MagicMock,
+        mock_get_session: MagicMock,
+    ) -> None:
+        redis_client = MagicMock()
+        lock = MagicMock()
+        lock.acquire.return_value = True
+        lock.owned.return_value = True
+        redis_client.lock.return_value = lock
+        mock_get_redis.return_value = redis_client
+
+        session = _mock_session_returning_none()
+        mock_get_session.return_value.__enter__.return_value = session
+
+        user_file_id = str(uuid4())
+        _process_user_file_impl(
+            user_file_id=user_file_id,
+            tenant_id="test-tenant",
+            redis_locking=True,
+        )
+
+        mock_get_redis.assert_called_once_with(tenant_id="test-tenant")
+        redis_client.delete.assert_called_once()
+        lock.acquire.assert_called_once_with(blocking=False)
+        lock.release.assert_called_once()
+
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    @patch(f"{TASKS_MODULE}.get_redis_client")
+    def test_redis_locking_true_skips_when_lock_held(
+        self,
+        mock_get_redis: MagicMock,
+        mock_get_session: MagicMock,
+    ) -> None:
+        redis_client = MagicMock()
+        lock = MagicMock()
+        lock.acquire.return_value = False
+        redis_client.lock.return_value = lock
+        mock_get_redis.return_value = redis_client
+
+        _process_user_file_impl(
+            user_file_id=str(uuid4()),
+            tenant_id="test-tenant",
+            redis_locking=True,
+        )
+
+        lock.acquire.assert_called_once()
+        mock_get_session.assert_not_called()
+
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    @patch(f"{TASKS_MODULE}.get_redis_client")
+    def test_redis_locking_false_skips_redis_entirely(
+        self,
+        mock_get_redis: MagicMock,
+        mock_get_session: MagicMock,
+    ) -> None:
+        session = _mock_session_returning_none()
+        mock_get_session.return_value.__enter__.return_value = session
+
+        _process_user_file_impl(
+            user_file_id=str(uuid4()),
+            tenant_id="test-tenant",
+            redis_locking=False,
+        )
+
+        mock_get_redis.assert_not_called()
+        mock_get_session.assert_called_once()
+
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    @patch(f"{TASKS_MODULE}.get_redis_client")
+    def test_both_paths_call_db_get(
+        self,
+        mock_get_redis: MagicMock,
+        mock_get_session: MagicMock,
+    ) -> None:
+        """Both redis_locking=True and False should call db_session.get(UserFile, ...)."""
+        redis_client = MagicMock()
+        lock = MagicMock()
+        lock.acquire.return_value = True
+        lock.owned.return_value = True
+        redis_client.lock.return_value = lock
+        mock_get_redis.return_value = redis_client
+
+        session = _mock_session_returning_none()
+        mock_get_session.return_value.__enter__.return_value = session
+
+        uid = str(uuid4())
+
+        _process_user_file_impl(user_file_id=uid, tenant_id="t", redis_locking=True)
+        call_count_true = session.get.call_count
+
+        session.reset_mock()
+        mock_get_session.reset_mock()
+        mock_get_session.return_value.__enter__.return_value = session
+
+        _process_user_file_impl(user_file_id=uid, tenant_id="t", redis_locking=False)
+        call_count_false = session.get.call_count
+
+        assert call_count_true == call_count_false == 1
+
+
+# ------------------------------------------------------------------
+# _delete_user_file_impl
+# ------------------------------------------------------------------
+
+
+class TestDeleteUserFileImpl:
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    @patch(f"{TASKS_MODULE}.get_redis_client")
+    def test_redis_locking_true_acquires_and_releases_lock(
+        self,
+        mock_get_redis: MagicMock,
+        mock_get_session: MagicMock,
+    ) -> None:
+        redis_client = MagicMock()
+        lock = MagicMock()
+        lock.acquire.return_value = True
+        lock.owned.return_value = True
+        redis_client.lock.return_value = lock
+        mock_get_redis.return_value = redis_client
+
+        session = _mock_session_returning_none()
+        mock_get_session.return_value.__enter__.return_value = session
+
+        _delete_user_file_impl(
+            user_file_id=str(uuid4()),
+            tenant_id="test-tenant",
+            redis_locking=True,
+        )
+
+        mock_get_redis.assert_called_once()
+        lock.acquire.assert_called_once_with(blocking=False)
+        lock.release.assert_called_once()
+
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    @patch(f"{TASKS_MODULE}.get_redis_client")
+    def test_redis_locking_true_skips_when_lock_held(
+        self,
+        mock_get_redis: MagicMock,
+        mock_get_session: MagicMock,
+    ) -> None:
+        redis_client = MagicMock()
+        lock = MagicMock()
+        lock.acquire.return_value = False
+        redis_client.lock.return_value = lock
+        mock_get_redis.return_value = redis_client
+
+        _delete_user_file_impl(
+            user_file_id=str(uuid4()),
+            tenant_id="test-tenant",
+            redis_locking=True,
+        )
+
+        lock.acquire.assert_called_once()
+        mock_get_session.assert_not_called()
+
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    @patch(f"{TASKS_MODULE}.get_redis_client")
+    def test_redis_locking_false_skips_redis_entirely(
+        self,
+        mock_get_redis: MagicMock,
+        mock_get_session: MagicMock,
+    ) -> None:
+        session = _mock_session_returning_none()
+        mock_get_session.return_value.__enter__.return_value = session
+
+        _delete_user_file_impl(
+            user_file_id=str(uuid4()),
+            tenant_id="test-tenant",
+            redis_locking=False,
+        )
+
+        mock_get_redis.assert_not_called()
+        mock_get_session.assert_called_once()
+
+
+# ------------------------------------------------------------------
+# _project_sync_user_file_impl
+# ------------------------------------------------------------------
+
+
+class TestProjectSyncUserFileImpl:
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    @patch(f"{TASKS_MODULE}.get_redis_client")
+    def test_redis_locking_true_acquires_and_releases_lock(
+        self,
+        mock_get_redis: MagicMock,
+        mock_get_session: MagicMock,
+    ) -> None:
+        redis_client = MagicMock()
+        lock = MagicMock()
+        lock.acquire.return_value = True
+        lock.owned.return_value = True
+        redis_client.lock.return_value = lock
+        mock_get_redis.return_value = redis_client
+
+        session = _mock_session_returning_none()
+        mock_get_session.return_value.__enter__.return_value = session
+
+        _project_sync_user_file_impl(
+            user_file_id=str(uuid4()),
+            tenant_id="test-tenant",
+            redis_locking=True,
+        )
+
+        mock_get_redis.assert_called_once()
+        redis_client.delete.assert_called_once()
+        lock.acquire.assert_called_once_with(blocking=False)
+        lock.release.assert_called_once()
+
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    @patch(f"{TASKS_MODULE}.get_redis_client")
+    def test_redis_locking_true_skips_when_lock_held(
+        self,
+        mock_get_redis: MagicMock,
+        mock_get_session: MagicMock,
+    ) -> None:
+        redis_client = MagicMock()
+        lock = MagicMock()
+        lock.acquire.return_value = False
+        redis_client.lock.return_value = lock
+        mock_get_redis.return_value = redis_client
+
+        _project_sync_user_file_impl(
+            user_file_id=str(uuid4()),
+            tenant_id="test-tenant",
+            redis_locking=True,
+        )
+
+        lock.acquire.assert_called_once()
+        mock_get_session.assert_not_called()
+
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    @patch(f"{TASKS_MODULE}.get_redis_client")
+    def test_redis_locking_false_skips_redis_entirely(
+        self,
+        mock_get_redis: MagicMock,
+        mock_get_session: MagicMock,
+    ) -> None:
+        session = _mock_session_returning_none()
+        mock_get_session.return_value.__enter__.return_value = session
+
+        _project_sync_user_file_impl(
+            user_file_id=str(uuid4()),
+            tenant_id="test-tenant",
+            redis_locking=False,
+        )
+
+        mock_get_redis.assert_not_called()
+        mock_get_session.assert_called_once()

backend/tests/unit/onyx/background/celery/tasks/test_user_file_processing_no_vectordb.py

@@ -0,0 +1,421 @@
+"""Tests for no-vector-DB user file processing paths.
+
+Verifies that when DISABLE_VECTOR_DB is True:
+- _process_user_file_impl calls _process_user_file_without_vector_db (not indexing)
+- _process_user_file_without_vector_db extracts text, counts tokens, stores plaintext,
+  sets status=COMPLETED and chunk_count=0
+- _delete_user_file_impl skips vector DB chunk deletion
+- _project_sync_user_file_impl skips vector DB metadata update
+"""
+
+from unittest.mock import MagicMock
+from unittest.mock import patch
+from uuid import uuid4
+
+from onyx.background.celery.tasks.user_file_processing.tasks import (
+    _delete_user_file_impl,
+)
+from onyx.background.celery.tasks.user_file_processing.tasks import (
+    _process_user_file_impl,
+)
+from onyx.background.celery.tasks.user_file_processing.tasks import (
+    _process_user_file_without_vector_db,
+)
+from onyx.background.celery.tasks.user_file_processing.tasks import (
+    _project_sync_user_file_impl,
+)
+from onyx.configs.constants import DocumentSource
+from onyx.connectors.models import Document
+from onyx.connectors.models import TextSection
+from onyx.db.enums import UserFileStatus
+
+TASKS_MODULE = "onyx.background.celery.tasks.user_file_processing.tasks"
+LLM_FACTORY_MODULE = "onyx.llm.factory"
+
+
+def _make_documents(texts: list[str]) -> list[Document]:
+    """Build a list of Document objects with the given section texts."""
+    return [
+        Document(
+            id=str(uuid4()),
+            source=DocumentSource.USER_FILE,
+            sections=[TextSection(text=t)],
+            semantic_identifier=f"test-doc-{i}",
+            metadata={},
+        )
+        for i, t in enumerate(texts)
+    ]
+
+
+def _make_user_file(
+    *,
+    status: UserFileStatus = UserFileStatus.PROCESSING,
+    file_id: str = "test-file-id",
+    name: str = "test.txt",
+) -> MagicMock:
+    """Return a MagicMock mimicking a UserFile ORM instance."""
+    uf = MagicMock()
+    uf.id = uuid4()
+    uf.file_id = file_id
+    uf.name = name
+    uf.status = status
+    uf.token_count = None
+    uf.chunk_count = None
+    uf.last_project_sync_at = None
+    uf.projects = []
+    uf.assistants = []
+    uf.needs_project_sync = True
+    uf.needs_persona_sync = True
+    return uf
+
+
+# ------------------------------------------------------------------
+# _process_user_file_without_vector_db — direct tests
+# ------------------------------------------------------------------
+
+
+class TestProcessUserFileWithoutVectorDb:
+    @patch(f"{TASKS_MODULE}.store_user_file_plaintext")
+    @patch(f"{LLM_FACTORY_MODULE}.get_llm_tokenizer_encode_func")
+    @patch(f"{LLM_FACTORY_MODULE}.get_default_llm")
+    def test_extracts_and_combines_text(
+        self,
+        mock_get_llm: MagicMock,  # noqa: ARG002
+        mock_get_encode: MagicMock,
+        mock_store_plaintext: MagicMock,
+    ) -> None:
+        mock_encode = MagicMock(return_value=[1, 2, 3, 4, 5])
+        mock_get_encode.return_value = mock_encode
+
+        uf = _make_user_file()
+        docs = _make_documents(["hello world", "foo bar"])
+        db_session = MagicMock()
+
+        _process_user_file_without_vector_db(uf, docs, db_session)
+
+        stored_text = mock_store_plaintext.call_args.kwargs["plaintext_content"]
+        assert "hello world" in stored_text
+        assert "foo bar" in stored_text
+
+    @patch(f"{TASKS_MODULE}.store_user_file_plaintext")
+    @patch(f"{LLM_FACTORY_MODULE}.get_llm_tokenizer_encode_func")
+    @patch(f"{LLM_FACTORY_MODULE}.get_default_llm")
+    def test_computes_token_count(
+        self,
+        mock_get_llm: MagicMock,  # noqa: ARG002
+        mock_get_encode: MagicMock,
+        mock_store_plaintext: MagicMock,  # noqa: ARG002
+    ) -> None:
+        mock_encode = MagicMock(return_value=list(range(42)))
+        mock_get_encode.return_value = mock_encode
+
+        uf = _make_user_file()
+        docs = _make_documents(["some text content"])
+        db_session = MagicMock()
+
+        _process_user_file_without_vector_db(uf, docs, db_session)
+
+        assert uf.token_count == 42
+
+    @patch(f"{TASKS_MODULE}.store_user_file_plaintext")
+    @patch(f"{LLM_FACTORY_MODULE}.get_llm_tokenizer_encode_func")
+    @patch(f"{LLM_FACTORY_MODULE}.get_default_llm")
+    def test_token_count_falls_back_to_none_on_error(
+        self,
+        mock_get_llm: MagicMock,
+        mock_get_encode: MagicMock,  # noqa: ARG002
+        mock_store_plaintext: MagicMock,  # noqa: ARG002
+    ) -> None:
+        mock_get_llm.side_effect = RuntimeError("No LLM configured")
+
+        uf = _make_user_file()
+        docs = _make_documents(["text"])
+        db_session = MagicMock()
+
+        _process_user_file_without_vector_db(uf, docs, db_session)
+
+        assert uf.token_count is None
+
+    @patch(f"{TASKS_MODULE}.store_user_file_plaintext")
+    @patch(f"{LLM_FACTORY_MODULE}.get_llm_tokenizer_encode_func")
+    @patch(f"{LLM_FACTORY_MODULE}.get_default_llm")
+    def test_stores_plaintext(
+        self,
+        mock_get_llm: MagicMock,  # noqa: ARG002
+        mock_get_encode: MagicMock,
+        mock_store_plaintext: MagicMock,
+    ) -> None:
+        mock_get_encode.return_value = MagicMock(return_value=[1])
+
+        uf = _make_user_file()
+        docs = _make_documents(["content to store"])
+        db_session = MagicMock()
+
+        _process_user_file_without_vector_db(uf, docs, db_session)
+
+        mock_store_plaintext.assert_called_once_with(
+            user_file_id=uf.id,
+            plaintext_content="content to store",
+        )
+
+    @patch(f"{TASKS_MODULE}.store_user_file_plaintext")
+    @patch(f"{LLM_FACTORY_MODULE}.get_llm_tokenizer_encode_func")
+    @patch(f"{LLM_FACTORY_MODULE}.get_default_llm")
+    def test_sets_completed_status_and_zero_chunk_count(
+        self,
+        mock_get_llm: MagicMock,  # noqa: ARG002
+        mock_get_encode: MagicMock,
+        mock_store_plaintext: MagicMock,  # noqa: ARG002
+    ) -> None:
+        mock_get_encode.return_value = MagicMock(return_value=[1])
+
+        uf = _make_user_file()
+        docs = _make_documents(["text"])
+        db_session = MagicMock()
+
+        _process_user_file_without_vector_db(uf, docs, db_session)
+
+        assert uf.status == UserFileStatus.COMPLETED
+        assert uf.chunk_count == 0
+        assert uf.last_project_sync_at is not None
+        db_session.add.assert_called_once_with(uf)
+        db_session.commit.assert_called_once()
+
+    @patch(f"{TASKS_MODULE}.store_user_file_plaintext")
+    @patch(f"{LLM_FACTORY_MODULE}.get_llm_tokenizer_encode_func")
+    @patch(f"{LLM_FACTORY_MODULE}.get_default_llm")
+    def test_preserves_deleting_status(
+        self,
+        mock_get_llm: MagicMock,  # noqa: ARG002
+        mock_get_encode: MagicMock,
+        mock_store_plaintext: MagicMock,  # noqa: ARG002
+    ) -> None:
+        mock_get_encode.return_value = MagicMock(return_value=[1])
+
+        uf = _make_user_file(status=UserFileStatus.DELETING)
+        docs = _make_documents(["text"])
+        db_session = MagicMock()
+
+        _process_user_file_without_vector_db(uf, docs, db_session)
+
+        assert uf.status == UserFileStatus.DELETING
+        assert uf.chunk_count == 0
+
+
+# ------------------------------------------------------------------
+# _process_user_file_impl — branching on DISABLE_VECTOR_DB
+# ------------------------------------------------------------------
+
+
+class TestProcessImplBranching:
+    @patch(f"{TASKS_MODULE}._process_user_file_without_vector_db")
+    @patch(f"{TASKS_MODULE}._process_user_file_with_indexing")
+    @patch(f"{TASKS_MODULE}.DISABLE_VECTOR_DB", True)
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    def test_calls_without_vector_db_when_disabled(
+        self,
+        mock_get_session: MagicMock,
+        mock_with_indexing: MagicMock,
+        mock_without_vdb: MagicMock,
+    ) -> None:
+        uf = _make_user_file()
+        session = MagicMock()
+        session.get.return_value = uf
+        mock_get_session.return_value.__enter__.return_value = session
+
+        connector_mock = MagicMock()
+        connector_mock.load_from_state.return_value = [_make_documents(["hello"])]
+
+        with patch(f"{TASKS_MODULE}.LocalFileConnector", return_value=connector_mock):
+            _process_user_file_impl(
+                user_file_id=str(uf.id),
+                tenant_id="test-tenant",
+                redis_locking=False,
+            )
+
+        mock_without_vdb.assert_called_once()
+        mock_with_indexing.assert_not_called()
+
+    @patch(f"{TASKS_MODULE}._process_user_file_without_vector_db")
+    @patch(f"{TASKS_MODULE}._process_user_file_with_indexing")
+    @patch(f"{TASKS_MODULE}.DISABLE_VECTOR_DB", False)
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    def test_calls_with_indexing_when_vector_db_enabled(
+        self,
+        mock_get_session: MagicMock,
+        mock_with_indexing: MagicMock,
+        mock_without_vdb: MagicMock,
+    ) -> None:
+        uf = _make_user_file()
+        session = MagicMock()
+        session.get.return_value = uf
+        mock_get_session.return_value.__enter__.return_value = session
+
+        connector_mock = MagicMock()
+        connector_mock.load_from_state.return_value = [_make_documents(["hello"])]
+
+        with patch(f"{TASKS_MODULE}.LocalFileConnector", return_value=connector_mock):
+            _process_user_file_impl(
+                user_file_id=str(uf.id),
+                tenant_id="test-tenant",
+                redis_locking=False,
+            )
+
+        mock_with_indexing.assert_called_once()
+        mock_without_vdb.assert_not_called()
+
+    @patch(f"{TASKS_MODULE}.run_indexing_pipeline")
+    @patch(f"{TASKS_MODULE}.store_user_file_plaintext")
+    @patch(f"{TASKS_MODULE}.DISABLE_VECTOR_DB", True)
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    def test_indexing_pipeline_not_called_when_disabled(
+        self,
+        mock_get_session: MagicMock,
+        mock_store_plaintext: MagicMock,  # noqa: ARG002
+        mock_run_pipeline: MagicMock,
+    ) -> None:
+        """End-to-end: verify run_indexing_pipeline is never invoked."""
+        uf = _make_user_file()
+        session = MagicMock()
+        session.get.return_value = uf
+        mock_get_session.return_value.__enter__.return_value = session
+
+        connector_mock = MagicMock()
+        connector_mock.load_from_state.return_value = [_make_documents(["content"])]
+
+        with (
+            patch(f"{TASKS_MODULE}.LocalFileConnector", return_value=connector_mock),
+            patch(f"{LLM_FACTORY_MODULE}.get_default_llm"),
+            patch(
+                f"{LLM_FACTORY_MODULE}.get_llm_tokenizer_encode_func",
+                return_value=MagicMock(return_value=[1, 2, 3]),
+            ),
+        ):
+            _process_user_file_impl(
+                user_file_id=str(uf.id),
+                tenant_id="test-tenant",
+                redis_locking=False,
+            )
+
+        mock_run_pipeline.assert_not_called()
+
+
+# ------------------------------------------------------------------
+# _delete_user_file_impl — vector DB skip
+# ------------------------------------------------------------------
+
+
+class TestDeleteImplNoVectorDb:
+    @patch(f"{TASKS_MODULE}.DISABLE_VECTOR_DB", True)
+    @patch(f"{TASKS_MODULE}.get_default_file_store")
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    def test_skips_vector_db_deletion(
+        self,
+        mock_get_session: MagicMock,
+        mock_get_file_store: MagicMock,
+    ) -> None:
+        uf = _make_user_file(status=UserFileStatus.DELETING)
+        session = MagicMock()
+        session.get.return_value = uf
+        mock_get_session.return_value.__enter__.return_value = session
+        mock_get_file_store.return_value = MagicMock()
+
+        with (
+            patch(f"{TASKS_MODULE}.get_all_document_indices") as mock_get_indices,
+            patch(f"{TASKS_MODULE}.get_active_search_settings") as mock_get_ss,
+            patch(f"{TASKS_MODULE}.httpx_init_vespa_pool") as mock_vespa_pool,
+        ):
+            _delete_user_file_impl(
+                user_file_id=str(uf.id),
+                tenant_id="test-tenant",
+                redis_locking=False,
+            )
+
+            mock_get_indices.assert_not_called()
+            mock_get_ss.assert_not_called()
+            mock_vespa_pool.assert_not_called()
+
+        session.delete.assert_called_once_with(uf)
+        session.commit.assert_called_once()
+
+    @patch(f"{TASKS_MODULE}.DISABLE_VECTOR_DB", True)
+    @patch(f"{TASKS_MODULE}.get_default_file_store")
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    def test_still_deletes_file_store_and_db_record(
+        self,
+        mock_get_session: MagicMock,
+        mock_get_file_store: MagicMock,
+    ) -> None:
+        uf = _make_user_file(status=UserFileStatus.DELETING)
+        session = MagicMock()
+        session.get.return_value = uf
+        mock_get_session.return_value.__enter__.return_value = session
+
+        file_store = MagicMock()
+        mock_get_file_store.return_value = file_store
+
+        _delete_user_file_impl(
+            user_file_id=str(uf.id),
+            tenant_id="test-tenant",
+            redis_locking=False,
+        )
+
+        assert file_store.delete_file.call_count == 2
+        session.delete.assert_called_once_with(uf)
+        session.commit.assert_called_once()
+
+
+# ------------------------------------------------------------------
+# _project_sync_user_file_impl — vector DB skip
+# ------------------------------------------------------------------
+
+
+class TestProjectSyncImplNoVectorDb:
+    @patch(f"{TASKS_MODULE}.DISABLE_VECTOR_DB", True)
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    def test_skips_vector_db_update(
+        self,
+        mock_get_session: MagicMock,
+    ) -> None:
+        uf = _make_user_file(status=UserFileStatus.COMPLETED)
+        session = MagicMock()
+        session.execute.return_value.scalar_one_or_none.return_value = uf
+        mock_get_session.return_value.__enter__.return_value = session
+
+        with (
+            patch(f"{TASKS_MODULE}.get_all_document_indices") as mock_get_indices,
+            patch(f"{TASKS_MODULE}.get_active_search_settings") as mock_get_ss,
+            patch(f"{TASKS_MODULE}.httpx_init_vespa_pool") as mock_vespa_pool,
+        ):
+            _project_sync_user_file_impl(
+                user_file_id=str(uf.id),
+                tenant_id="test-tenant",
+                redis_locking=False,
+            )
+
+            mock_get_indices.assert_not_called()
+            mock_get_ss.assert_not_called()
+            mock_vespa_pool.assert_not_called()
+
+    @patch(f"{TASKS_MODULE}.DISABLE_VECTOR_DB", True)
+    @patch(f"{TASKS_MODULE}.get_session_with_current_tenant")
+    def test_still_clears_sync_flags(
+        self,
+        mock_get_session: MagicMock,
+    ) -> None:
+        uf = _make_user_file(status=UserFileStatus.COMPLETED)
+        session = MagicMock()
+        session.execute.return_value.scalar_one_or_none.return_value = uf
+        mock_get_session.return_value.__enter__.return_value = session
+
+        _project_sync_user_file_impl(
+            user_file_id=str(uf.id),
+            tenant_id="test-tenant",
+            redis_locking=False,
+        )
+
+        assert uf.needs_project_sync is False
+        assert uf.needs_persona_sync is False
+        assert uf.last_project_sync_at is not None
+        session.add.assert_called_once_with(uf)
+        session.commit.assert_called_once()

backend/tests/unit/onyx/test_startup_validation.py

@@ -0,0 +1,52 @@
+"""Tests for startup validation in no-vector-DB mode.
+
+Verifies that DISABLE_VECTOR_DB raises RuntimeError when combined with
+incompatible settings (MULTI_TENANT, ENABLE_CRAFT).
+"""
+
+from unittest.mock import patch
+
+import pytest
+
+
+class TestValidateNoVectorDbSettings:
+    @patch("onyx.main.DISABLE_VECTOR_DB", False)
+    def test_no_error_when_vector_db_enabled(self) -> None:
+        from onyx.main import validate_no_vector_db_settings
+
+        validate_no_vector_db_settings()
+
+    @patch("onyx.main.DISABLE_VECTOR_DB", True)
+    @patch("onyx.main.MULTI_TENANT", False)
+    @patch("onyx.server.features.build.configs.ENABLE_CRAFT", False)
+    def test_no_error_when_no_conflicts(self) -> None:
+        from onyx.main import validate_no_vector_db_settings
+
+        validate_no_vector_db_settings()
+
+    @patch("onyx.main.DISABLE_VECTOR_DB", True)
+    @patch("onyx.main.MULTI_TENANT", True)
+    def test_raises_on_multi_tenant(self) -> None:
+        from onyx.main import validate_no_vector_db_settings
+
+        with pytest.raises(RuntimeError, match="MULTI_TENANT"):
+            validate_no_vector_db_settings()
+
+    @patch("onyx.main.DISABLE_VECTOR_DB", True)
+    @patch("onyx.main.MULTI_TENANT", False)
+    @patch("onyx.server.features.build.configs.ENABLE_CRAFT", True)
+    def test_raises_on_enable_craft(self) -> None:
+        from onyx.main import validate_no_vector_db_settings
+
+        with pytest.raises(RuntimeError, match="ENABLE_CRAFT"):
+            validate_no_vector_db_settings()
+
+    @patch("onyx.main.DISABLE_VECTOR_DB", True)
+    @patch("onyx.main.MULTI_TENANT", True)
+    @patch("onyx.server.features.build.configs.ENABLE_CRAFT", True)
+    def test_multi_tenant_checked_before_craft(self) -> None:
+        """MULTI_TENANT is checked first, so it should be the error raised."""
+        from onyx.main import validate_no_vector_db_settings
+
+        with pytest.raises(RuntimeError, match="MULTI_TENANT"):
+            validate_no_vector_db_settings()

backend/tests/unit/onyx/tools/test_construct_tools_no_vectordb.py

@@ -0,0 +1,196 @@
+"""Tests for tool construction when DISABLE_VECTOR_DB is True.
+
+Verifies that:
+- SearchTool.is_available() returns False when vector DB is disabled
+- OpenURLTool.is_available() returns False when vector DB is disabled
+- The force-add SearchTool block is suppressed when DISABLE_VECTOR_DB
+- FileReaderTool.is_available() returns True when vector DB is disabled
+"""
+
+from unittest.mock import MagicMock
+from unittest.mock import patch
+
+from onyx.tools.tool_implementations.file_reader.file_reader_tool import FileReaderTool
+
+APP_CONFIGS_MODULE = "onyx.configs.app_configs"
+FILE_READER_MODULE = "onyx.tools.tool_implementations.file_reader.file_reader_tool"
+
+
+# ------------------------------------------------------------------
+# SearchTool.is_available()
+# ------------------------------------------------------------------
+
+
+class TestSearchToolAvailability:
+    @patch(f"{APP_CONFIGS_MODULE}.DISABLE_VECTOR_DB", True)
+    def test_unavailable_when_vector_db_disabled(self) -> None:
+        from onyx.tools.tool_implementations.search.search_tool import SearchTool
+
+        assert SearchTool.is_available(MagicMock()) is False
+
+    @patch("onyx.db.connector.check_user_files_exist", return_value=True)
+    @patch(
+        "onyx.tools.tool_implementations.search.search_tool.check_federated_connectors_exist",
+        return_value=False,
+    )
+    @patch(
+        "onyx.tools.tool_implementations.search.search_tool.check_connectors_exist",
+        return_value=False,
+    )
+    @patch(f"{APP_CONFIGS_MODULE}.DISABLE_VECTOR_DB", False)
+    def test_available_when_vector_db_enabled_and_files_exist(
+        self,
+        mock_connectors: MagicMock,  # noqa: ARG002
+        mock_federated: MagicMock,  # noqa: ARG002
+        mock_user_files: MagicMock,  # noqa: ARG002
+    ) -> None:
+        from onyx.tools.tool_implementations.search.search_tool import SearchTool
+
+        assert SearchTool.is_available(MagicMock()) is True
+
+
+# ------------------------------------------------------------------
+# OpenURLTool.is_available()
+# ------------------------------------------------------------------
+
+
+class TestOpenURLToolAvailability:
+    @patch(f"{APP_CONFIGS_MODULE}.DISABLE_VECTOR_DB", True)
+    def test_unavailable_when_vector_db_disabled(self) -> None:
+        from onyx.tools.tool_implementations.open_url.open_url_tool import OpenURLTool
+
+        assert OpenURLTool.is_available(MagicMock()) is False
+
+    @patch(f"{APP_CONFIGS_MODULE}.DISABLE_VECTOR_DB", False)
+    def test_available_when_vector_db_enabled(self) -> None:
+        from onyx.tools.tool_implementations.open_url.open_url_tool import OpenURLTool
+
+        assert OpenURLTool.is_available(MagicMock()) is True
+
+
+# ------------------------------------------------------------------
+# FileReaderTool.is_available()
+# ------------------------------------------------------------------
+
+
+class TestFileReaderToolAvailability:
+    @patch(f"{FILE_READER_MODULE}.DISABLE_VECTOR_DB", True)
+    def test_available_when_vector_db_disabled(self) -> None:
+        assert FileReaderTool.is_available(MagicMock()) is True
+
+    @patch(f"{FILE_READER_MODULE}.DISABLE_VECTOR_DB", False)
+    def test_unavailable_when_vector_db_enabled(self) -> None:
+        assert FileReaderTool.is_available(MagicMock()) is False
+
+
+# ------------------------------------------------------------------
+# Force-add SearchTool suppression
+# ------------------------------------------------------------------
+
+
+class TestForceAddSearchToolGuard:
+    def test_force_add_block_checks_disable_vector_db(self) -> None:
+        """The force-add SearchTool block in construct_tools should include
+        `not DISABLE_VECTOR_DB` so that forced search is also suppressed
+        without a vector DB."""
+        import inspect
+
+        from onyx.tools.tool_constructor import construct_tools
+
+        source = inspect.getsource(construct_tools)
+        assert "DISABLE_VECTOR_DB" in source, (
+            "construct_tools should reference DISABLE_VECTOR_DB "
+            "to suppress force-adding SearchTool"
+        )
+
+
+# ------------------------------------------------------------------
+# Persona API — _validate_vector_db_knowledge
+# ------------------------------------------------------------------
+
+
+class TestValidateVectorDbKnowledge:
+    @patch(
+        "onyx.server.features.persona.api.DISABLE_VECTOR_DB",
+        True,
+    )
+    def test_rejects_document_set_ids(self) -> None:
+        from fastapi import HTTPException
+
+        from onyx.server.features.persona.api import _validate_vector_db_knowledge
+
+        request = MagicMock()
+        request.document_set_ids = [1]
+        request.hierarchy_node_ids = []
+        request.document_ids = []
+
+        with __import__("pytest").raises(HTTPException) as exc_info:
+            _validate_vector_db_knowledge(request)
+        assert exc_info.value.status_code == 400
+        assert "document sets" in exc_info.value.detail
+
+    @patch(
+        "onyx.server.features.persona.api.DISABLE_VECTOR_DB",
+        True,
+    )
+    def test_rejects_hierarchy_node_ids(self) -> None:
+        from fastapi import HTTPException
+
+        from onyx.server.features.persona.api import _validate_vector_db_knowledge
+
+        request = MagicMock()
+        request.document_set_ids = []
+        request.hierarchy_node_ids = [1]
+        request.document_ids = []
+
+        with __import__("pytest").raises(HTTPException) as exc_info:
+            _validate_vector_db_knowledge(request)
+        assert exc_info.value.status_code == 400
+        assert "hierarchy nodes" in exc_info.value.detail
+
+    @patch(
+        "onyx.server.features.persona.api.DISABLE_VECTOR_DB",
+        True,
+    )
+    def test_rejects_document_ids(self) -> None:
+        from fastapi import HTTPException
+
+        from onyx.server.features.persona.api import _validate_vector_db_knowledge
+
+        request = MagicMock()
+        request.document_set_ids = []
+        request.hierarchy_node_ids = []
+        request.document_ids = ["doc-abc"]
+
+        with __import__("pytest").raises(HTTPException) as exc_info:
+            _validate_vector_db_knowledge(request)
+        assert exc_info.value.status_code == 400
+        assert "documents" in exc_info.value.detail
+
+    @patch(
+        "onyx.server.features.persona.api.DISABLE_VECTOR_DB",
+        True,
+    )
+    def test_allows_user_files_only(self) -> None:
+        from onyx.server.features.persona.api import _validate_vector_db_knowledge
+
+        request = MagicMock()
+        request.document_set_ids = []
+        request.hierarchy_node_ids = []
+        request.document_ids = []
+
+        _validate_vector_db_knowledge(request)
+
+    @patch(
+        "onyx.server.features.persona.api.DISABLE_VECTOR_DB",
+        False,
+    )
+    def test_allows_everything_when_vector_db_enabled(self) -> None:
+        from onyx.server.features.persona.api import _validate_vector_db_knowledge
+
+        request = MagicMock()
+        request.document_set_ids = [1, 2]
+        request.hierarchy_node_ids = [3]
+        request.document_ids = ["doc-x"]
+
+        _validate_vector_db_knowledge(request)

backend/tests/unit/onyx/tools/test_file_reader_tool.py

@@ -0,0 +1,237 @@
+"""Tests for the FileReaderTool.
+
+Verifies:
+- Tool definition schema is well-formed
+- File ID validation (allowlist, UUID format)
+- Character range extraction and clamping
+- Error handling for missing parameters and non-text files
+- is_available() reflects DISABLE_VECTOR_DB
+"""
+
+from unittest.mock import MagicMock
+from unittest.mock import patch
+from uuid import uuid4
+
+import pytest
+
+from onyx.file_store.models import ChatFileType
+from onyx.file_store.models import InMemoryChatFile
+from onyx.server.query_and_chat.placement import Placement
+from onyx.tools.models import ToolCallException
+from onyx.tools.tool_implementations.file_reader.file_reader_tool import FILE_ID_FIELD
+from onyx.tools.tool_implementations.file_reader.file_reader_tool import FileReaderTool
+from onyx.tools.tool_implementations.file_reader.file_reader_tool import MAX_NUM_CHARS
+from onyx.tools.tool_implementations.file_reader.file_reader_tool import NUM_CHARS_FIELD
+from onyx.tools.tool_implementations.file_reader.file_reader_tool import (
+    START_CHAR_FIELD,
+)
+
+TOOL_MODULE = "onyx.tools.tool_implementations.file_reader.file_reader_tool"
+_PLACEMENT = Placement(turn_index=0)
+
+
+def _make_tool(
+    user_file_ids: list | None = None,
+    chat_file_ids: list | None = None,
+) -> FileReaderTool:
+    emitter = MagicMock()
+    return FileReaderTool(
+        tool_id=99,
+        emitter=emitter,
+        user_file_ids=user_file_ids or [],
+        chat_file_ids=chat_file_ids or [],
+    )
+
+
+def _text_file(content: str, filename: str = "test.txt") -> InMemoryChatFile:
+    return InMemoryChatFile(
+        file_id="some-file-id",
+        content=content.encode("utf-8"),
+        file_type=ChatFileType.PLAIN_TEXT,
+        filename=filename,
+    )
+
+
+# ------------------------------------------------------------------
+# Tool metadata
+# ------------------------------------------------------------------
+
+
+class TestToolMetadata:
+    def test_tool_name(self) -> None:
+        tool = _make_tool()
+        assert tool.name == "read_file"
+
+    def test_tool_definition_schema(self) -> None:
+        tool = _make_tool()
+        defn = tool.tool_definition()
+        assert defn["type"] == "function"
+        func = defn["function"]
+        assert func["name"] == "read_file"
+        props = func["parameters"]["properties"]
+        assert FILE_ID_FIELD in props
+        assert START_CHAR_FIELD in props
+        assert NUM_CHARS_FIELD in props
+        assert func["parameters"]["required"] == [FILE_ID_FIELD]
+
+
+# ------------------------------------------------------------------
+# File ID validation
+# ------------------------------------------------------------------
+
+
+class TestFileIdValidation:
+    def test_rejects_invalid_uuid(self) -> None:
+        tool = _make_tool()
+        with pytest.raises(ToolCallException, match="Invalid file_id"):
+            tool._validate_file_id("not-a-uuid")
+
+    def test_rejects_file_not_in_allowlist(self) -> None:
+        tool = _make_tool(user_file_ids=[uuid4()])
+        other_id = uuid4()
+        with pytest.raises(ToolCallException, match="not in available files"):
+            tool._validate_file_id(str(other_id))
+
+    def test_accepts_user_file_id(self) -> None:
+        uid = uuid4()
+        tool = _make_tool(user_file_ids=[uid])
+        assert tool._validate_file_id(str(uid)) == uid
+
+    def test_accepts_chat_file_id(self) -> None:
+        cid = uuid4()
+        tool = _make_tool(chat_file_ids=[cid])
+        assert tool._validate_file_id(str(cid)) == cid
+
+
+# ------------------------------------------------------------------
+# run() — character range extraction
+# ------------------------------------------------------------------
+
+
+class TestRun:
+    @patch(f"{TOOL_MODULE}.get_session_with_current_tenant")
+    @patch(f"{TOOL_MODULE}.load_user_file")
+    def test_returns_full_content_by_default(
+        self,
+        mock_load_user_file: MagicMock,
+        mock_get_session: MagicMock,
+    ) -> None:
+        uid = uuid4()
+        content = "Hello, world!"
+        mock_load_user_file.return_value = _text_file(content)
+        mock_get_session.return_value.__enter__.return_value = MagicMock()
+
+        tool = _make_tool(user_file_ids=[uid])
+        resp = tool.run(
+            placement=_PLACEMENT,
+            override_kwargs=MagicMock(),
+            **{FILE_ID_FIELD: str(uid)},
+        )
+        assert content in resp.llm_facing_response
+
+    @patch(f"{TOOL_MODULE}.get_session_with_current_tenant")
+    @patch(f"{TOOL_MODULE}.load_user_file")
+    def test_respects_start_char_and_num_chars(
+        self,
+        mock_load_user_file: MagicMock,
+        mock_get_session: MagicMock,
+    ) -> None:
+        uid = uuid4()
+        content = "abcdefghijklmnop"
+        mock_load_user_file.return_value = _text_file(content)
+        mock_get_session.return_value.__enter__.return_value = MagicMock()
+
+        tool = _make_tool(user_file_ids=[uid])
+        resp = tool.run(
+            placement=_PLACEMENT,
+            override_kwargs=MagicMock(),
+            **{FILE_ID_FIELD: str(uid), START_CHAR_FIELD: 4, NUM_CHARS_FIELD: 6},
+        )
+        assert "efghij" in resp.llm_facing_response
+
+    @patch(f"{TOOL_MODULE}.get_session_with_current_tenant")
+    @patch(f"{TOOL_MODULE}.load_user_file")
+    def test_clamps_num_chars_to_max(
+        self,
+        mock_load_user_file: MagicMock,
+        mock_get_session: MagicMock,
+    ) -> None:
+        uid = uuid4()
+        content = "x" * (MAX_NUM_CHARS + 500)
+        mock_load_user_file.return_value = _text_file(content)
+        mock_get_session.return_value.__enter__.return_value = MagicMock()
+
+        tool = _make_tool(user_file_ids=[uid])
+        resp = tool.run(
+            placement=_PLACEMENT,
+            override_kwargs=MagicMock(),
+            **{FILE_ID_FIELD: str(uid), NUM_CHARS_FIELD: MAX_NUM_CHARS + 9999},
+        )
+        assert f"Characters 0-{MAX_NUM_CHARS}" in resp.llm_facing_response
+
+    @patch(f"{TOOL_MODULE}.get_session_with_current_tenant")
+    @patch(f"{TOOL_MODULE}.load_user_file")
+    def test_includes_continuation_hint(
+        self,
+        mock_load_user_file: MagicMock,
+        mock_get_session: MagicMock,
+    ) -> None:
+        uid = uuid4()
+        content = "x" * 100
+        mock_load_user_file.return_value = _text_file(content)
+        mock_get_session.return_value.__enter__.return_value = MagicMock()
+
+        tool = _make_tool(user_file_ids=[uid])
+        resp = tool.run(
+            placement=_PLACEMENT,
+            override_kwargs=MagicMock(),
+            **{FILE_ID_FIELD: str(uid), NUM_CHARS_FIELD: 10},
+        )
+        assert "use start_char=10 to continue reading" in resp.llm_facing_response
+
+    def test_raises_on_missing_file_id(self) -> None:
+        tool = _make_tool()
+        with pytest.raises(ToolCallException, match="Missing required"):
+            tool.run(
+                placement=_PLACEMENT,
+                override_kwargs=MagicMock(),
+            )
+
+    @patch(f"{TOOL_MODULE}.get_session_with_current_tenant")
+    @patch(f"{TOOL_MODULE}.load_user_file")
+    def test_raises_on_non_text_file(
+        self,
+        mock_load_user_file: MagicMock,
+        mock_get_session: MagicMock,
+    ) -> None:
+        uid = uuid4()
+        mock_load_user_file.return_value = InMemoryChatFile(
+            file_id="img",
+            content=b"\x89PNG",
+            file_type=ChatFileType.IMAGE,
+            filename="photo.png",
+        )
+        mock_get_session.return_value.__enter__.return_value = MagicMock()
+
+        tool = _make_tool(user_file_ids=[uid])
+        with pytest.raises(ToolCallException, match="not a text file"):
+            tool.run(
+                placement=_PLACEMENT,
+                override_kwargs=MagicMock(),
+                **{FILE_ID_FIELD: str(uid)},
+            )
+
+
+# ------------------------------------------------------------------
+# is_available()
+# ------------------------------------------------------------------
+
+
+class TestIsAvailable:
+    @patch(f"{TOOL_MODULE}.DISABLE_VECTOR_DB", True)
+    def test_available_when_vector_db_disabled(self) -> None:
+        assert FileReaderTool.is_available(MagicMock()) is True
+
+    @patch(f"{TOOL_MODULE}.DISABLE_VECTOR_DB", False)
+    def test_unavailable_when_vector_db_enabled(self) -> None:
+        assert FileReaderTool.is_available(MagicMock()) is False

contributing_guides/best_practices.md

@@ -163,16 +163,3 @@ Add clear comments:
 - Any TODOs you add in the code must be accompanied by either the name/username
   of the owner of that TODO, or an issue number for an issue referencing that
   piece of work.
-- Avoid module-level logic that runs on import, which leads to import-time side
-  effects. Essentially every piece of meaningful logic should exist within some
-  function that has to be explicitly invoked. Acceptable exceptions to this may
-  include loading environment variables or setting up loggers.
-  - If you find yourself needing something like this, you may want that logic to
-    exist in a file dedicated for manual execution (contains `if __name__ ==
-    "__main__":`) which should not be imported by anything else.
-- Related to the above, do not conflate Python scripts you intend to run from
-  the command line (contains `if __name__ == "__main__":`) with modules you
-  intend to import from elsewhere. If for some unlikely reason they have to be
-  the same file, any logic specific to executing the file (including imports)
-  should be contained in the `if __name__ == "__main__":` block.
-  - Generally these executable files exist in `backend/scripts/`.

web/src/app/admin/actions/mcp/page.tsx

@@ -10,7 +10,7 @@ export default function Main() {
       <SettingsLayouts.Header
         icon={SvgMcp}
         title="MCP Actions"
-        description="Connect MCP (Model Context Protocol) servers to add custom actions and tools for your agents."
+        description="Connect MCP (Model Context Protocol) servers to add custom actions and tools for your assistants."
         separator
       />
       <SettingsLayouts.Body>

web/src/app/admin/actions/open-api/page.tsx

@@ -10,7 +10,7 @@ export default function Main() {
       <SettingsLayouts.Header
         icon={SvgActions}
         title="OpenAPI Actions"
-        description="Connect OpenAPI servers to add custom actions and tools for your agents."
+        description="Connect OpenAPI servers to add custom actions and tools for your assistants."
         separator
       />
       <SettingsLayouts.Body>

web/src/app/admin/assistants/PersonaTable.tsx

@@ -170,7 +170,7 @@ export function PersonasTable({
       {deleteModalOpen && personaToDelete && (
         <ConfirmationModalLayout
           icon={SvgAlertCircle}
-          title="Delete Agent"
+          title="Delete Assistant"
           onClose={closeDeleteModal}
           submit={<Button onClick={handleDeletePersona}>Delete</Button>}
         >
@@ -183,15 +183,15 @@ export function PersonasTable({
           const isDefault = personaToToggleDefault.is_default_persona;
 
           const title = isDefault
-            ? "Remove Featured Agent"
-            : "Set Featured Agent";
+            ? "Remove Featured Assistant"
+            : "Set Featured Assistant";
           const buttonText = isDefault ? "Remove Feature" : "Set as Featured";
           const text = isDefault
             ? `Are you sure you want to remove the featured status of ${personaToToggleDefault.name}?`
             : `Are you sure you want to set the featured status of ${personaToToggleDefault.name}?`;
           const additionalText = isDefault
-            ? `Removing "${personaToToggleDefault.name}" as a featured agent will not affect its visibility or accessibility.`
-            : `Setting "${personaToToggleDefault.name}" as a featured agent will make it public and visible to all users. This action cannot be undone.`;
+            ? `Removing "${personaToToggleDefault.name}" as a featured assistant will not affect its visibility or accessibility.`
+            : `Setting "${personaToToggleDefault.name}" as a featured assistant will make it public and visible to all users. This action cannot be undone.`;
 
           return (
             <ConfirmationModalLayout
@@ -217,7 +217,7 @@ export function PersonasTable({
           "Name",
           "Description",
           "Type",
-          "Featured Agent",
+          "Featured Assistant",
           "Is Visible",
           "Delete",
         ]}

web/src/app/admin/assistants/page.tsx

@@ -47,8 +47,8 @@ function MainContent({
   return (
     <div>
       <Text className="mb-2">
-        Agents are a way to build custom search/question-answering experiences
-        for different use cases.
+        Assistants are a way to build custom search/question-answering
+        experiences for different use cases.
       </Text>
       <Text className="mt-2">They allow you to customize:</Text>
       <div className="text-sm">
@@ -63,21 +63,21 @@ function MainContent({
       <div>
         <Separator />
 
-        <Title>Create an Agent</Title>
+        <Title>Create an Assistant</Title>
         <CreateButton href="/app/agents/create?admin=true">
-          New Agent
+          New Assistant
         </CreateButton>
 
         <Separator />
 
-        <Title>Existing Agents</Title>
+        <Title>Existing Assistants</Title>
         {totalItems > 0 ? (
           <>
             <SubLabel>
-              Agents will be displayed as options on the Chat / Search
-              interfaces in the order they are displayed below. Agents marked as
-              hidden will not be displayed. Editable agents are shown at the
-              top.
+              Assistants will be displayed as options on the Chat / Search
+              interfaces in the order they are displayed below. Assistants
+              marked as hidden will not be displayed. Editable assistants are
+              shown at the top.
             </SubLabel>
             <PersonasTable
               personas={customPersonas}
@@ -96,21 +96,21 @@ function MainContent({
         ) : (
           <div className="mt-6 p-8 border border-border rounded-lg bg-background-weak text-center">
             <Text className="text-lg font-medium mb-2">
-              No custom agents yet
+              No custom assistants yet
             </Text>
             <Text className="text-subtle mb-3">
-              Create your first agent to:
+              Create your first assistant to:
             </Text>
             <ul className="text-subtle text-sm list-disc text-left inline-block mb-3">
               <li>Build department-specific knowledge bases</li>
-              <li>Create specialized research agents</li>
+              <li>Create specialized research assistants</li>
               <li>Set up compliance and policy advisors</li>
             </ul>
             <Text className="text-subtle text-sm mb-4">
               ...and so much more!
             </Text>
             <CreateButton href="/app/agents/create?admin=true">
-              Create Your First Agent
+              Create Your First Assistant
             </CreateButton>
           </div>
         )}
@@ -128,13 +128,13 @@ export default function Page() {
 
   return (
     <>
-      <AdminPageTitle icon={SvgOnyxOctagon} title="Agents" />
+      <AdminPageTitle icon={SvgOnyxOctagon} title="Assistants" />
 
       {isLoading && <ThreeDotsLoader />}
 
       {error && (
         <ErrorCallout
-          errorTitle="Failed to load agents"
+          errorTitle="Failed to load assistants"
           errorMsg={
             error?.info?.message ||
             error?.info?.detail ||

web/src/app/admin/bots/[bot-id]/channels/SlackChannelConfigCreationForm.tsx

@@ -156,7 +156,7 @@ export const SlackChannelConfigCreationForm = ({
               is: "assistant",
               then: (schema) =>
                 schema.required(
-                  "An agent is required when using the 'Agent' knowledge source"
+                  "A persona is required when using the'Assistant' knowledge source"
                 ),
             }),
           standard_answer_categories: Yup.array(),

web/src/app/admin/bots/[bot-id]/channels/SlackChannelConfigFormFields.tsx

@@ -224,14 +224,14 @@ export function SlackChannelConfigFormFields({
             <RadioGroupItemField
               value="assistant"
               id="assistant"
-              label="Search Agent"
+              label="Search Assistant"
               sublabel="Control both the documents and the prompt to use for answering questions"
             />
             <RadioGroupItemField
               value="non_search_assistant"
               id="non_search_assistant"
-              label="Non-Search Agent"
-              sublabel="Chat with an agent that does not use documents"
+              label="Non-Search Assistant"
+              sublabel="Chat with an assistant that does not use documents"
             />
           </RadioGroup>
         </div>
@@ -327,15 +327,15 @@ export function SlackChannelConfigFormFields({
           <div className="mt-4">
             <SubLabel>
               <>
-                Select the search-enabled agent OnyxBot will use while answering
-                questions in Slack.
+                Select the search-enabled assistant OnyxBot will use while
+                answering questions in Slack.
                 {syncEnabledAssistants.length > 0 && (
                   <>
                     <br />
                     <span className="text-sm text-text-dark/80">
-                      Note: Some of your agents have auto-synced connectors in
-                      their document sets. You cannot select these agents as
-                      they will not be able to answer questions in Slack.{" "}
+                      Note: Some of your assistants have auto-synced connectors
+                      in their document sets. You cannot select these assistants
+                      as they will not be able to answer questions in Slack.{" "}
                       <button
                         type="button"
                         onClick={() =>
@@ -349,7 +349,7 @@ export function SlackChannelConfigFormFields({
                         {viewSyncEnabledAssistants
                           ? "Hide un-selectable "
                           : "View all "}
-                        agents
+                        assistants
                       </button>
                     </span>
                   </>
@@ -367,7 +367,7 @@ export function SlackChannelConfigFormFields({
             {viewSyncEnabledAssistants && syncEnabledAssistants.length > 0 && (
               <div className="mt-4">
                 <p className="text-sm text-text-dark/80">
-                  Un-selectable agents:
+                  Un-selectable assistants:
                 </p>
                 <div className="mb-3 mt-2 flex gap-2 flex-wrap text-sm">
                   {syncEnabledAssistants.map(
@@ -394,15 +394,15 @@ export function SlackChannelConfigFormFields({
           <div className="mt-4">
             <SubLabel>
               <>
-                Select the non-search agent OnyxBot will use while answering
+                Select the non-search assistant OnyxBot will use while answering
                 questions in Slack.
                 {syncEnabledAssistants.length > 0 && (
                   <>
                     <br />
                     <span className="text-sm text-text-dark/80">
-                      Note: Some of your agents have auto-synced connectors in
-                      their document sets. You cannot select these agents as
-                      they will not be able to answer questions in Slack.{" "}
+                      Note: Some of your assistants have auto-synced connectors
+                      in their document sets. You cannot select these assistants
+                      as they will not be able to answer questions in Slack.{" "}
                       <button
                         type="button"
                         onClick={() =>
@@ -416,7 +416,7 @@ export function SlackChannelConfigFormFields({
                         {viewSyncEnabledAssistants
                           ? "Hide un-selectable "
                           : "View all "}
-                        agents
+                        assistants
                       </button>
                     </span>
                   </>
@@ -524,7 +524,7 @@ export function SlackChannelConfigFormFields({
                 name="is_ephemeral"
                 label="Respond to user in a private (ephemeral) message"
                 tooltip="If set, OnyxBot will respond only to the user in a private (ephemeral) message. If you also
-                chose 'Search' Agent above, selecting this option will make documents that are private to the user
+                chose 'Search' Assistant above, selecting this option will make documents that are private to the user
                 available for their queries."
               />
 

web/src/app/admin/configuration/code-interpreter/page.tsx

@@ -1,7 +0,0 @@
-"use client";
-
-import CodeInterpreterPage from "@/refresh-pages/admin/CodeInterpreterPage";
-
-export default function Page() {
-  return <CodeInterpreterPage />;
-}

web/src/app/admin/configuration/llm/forms/components/AdvancedOptions.tsx

@@ -39,10 +39,10 @@ export function AdvancedOptions({
               agents={agents}
               isLoading={agentsLoading}
               error={agentsError}
-              label="Agent Whitelist"
-              subtext="Restrict this provider to specific agents."
+              label="Assistant Whitelist"
+              subtext="Restrict this provider to specific assistants."
               disabled={formikProps.values.is_public}
-              disabledMessage="This LLM Provider is public and available to all agents."
+              disabledMessage="This LLM Provider is public and available to all assistants."
             />
           </div>
         </>

web/src/app/admin/discord-bot/[guild-id]/page.tsx

@@ -299,11 +299,11 @@ export default function Page({ params }: Props) {
       });
       refreshGuild();
       toast.success(
-        personaId ? "Default agent updated" : "Default agent cleared"
+        personaId ? "Default assistant updated" : "Default assistant cleared"
       );
     } catch (err) {
       toast.error(
-        err instanceof Error ? err.message : "Failed to update agent"
+        err instanceof Error ? err.message : "Failed to update assistant"
       );
     } finally {
       setIsUpdating(false);
@@ -355,7 +355,7 @@ export default function Page({ params }: Props) {
                 <InputSelect.Trigger placeholder="Select agent" />
                 <InputSelect.Content>
                   <InputSelect.Item value="default">
-                    Default Agent
+                    Default Assistant
                   </InputSelect.Item>
                   {personas.map((persona) => (
                     <InputSelect.Item

web/src/app/ee/admin/groups/[groupId]/GroupDisplay.tsx

@@ -427,7 +427,7 @@ export const GroupDisplay = ({
 
       <Separator />
 
-      <h2 className="text-xl font-bold mt-8 mb-2">Agents</h2>
+      <h2 className="text-xl font-bold mt-8 mb-2">Assistants</h2>
 
       <div>
         {userGroup.document_sets.length > 0 ? (
@@ -445,7 +445,7 @@ export const GroupDisplay = ({
           </div>
         ) : (
           <>
-            <Text>No Agents in this group...</Text>
+            <Text>No Assistants in this group...</Text>
           </>
         )}
       </div>

web/src/app/ee/admin/performance/usage/PersonaMessagesChart.tsx

@@ -152,14 +152,14 @@ export function PersonaMessagesChart({
   } else if (selectedPersonaId === undefined) {
     content = (
       <div className="h-80 text-text-500 flex flex-col">
-        <p className="m-auto">Select an agent to view analytics</p>
+        <p className="m-auto">Select an assistant to view analytics</p>
       </div>
     );
   } else if (!personaMessagesData?.length) {
     content = (
       <div className="h-80 text-text-500 flex flex-col">
         <p className="m-auto">
-          No data found for selected agent in the specified time range
+          No data found for selected assistant in the specified time range
         </p>
       </div>
     );
@@ -178,9 +178,11 @@ export function PersonaMessagesChart({
 
   return (
     <CardSection className="mt-8">
-      <Title>Agent Analytics</Title>
+      <Title>Assistant Analytics</Title>
       <div className="flex flex-col gap-4">
-        <Text>Messages and unique users per day for the selected agent</Text>
+        <Text>
+          Messages and unique users per day for the selected assistant
+        </Text>
         <div className="flex items-center gap-4">
           <Select
             value={selectedPersonaId?.toString() ?? ""}
@@ -189,14 +191,14 @@ export function PersonaMessagesChart({
             }}
           >
             <SelectTrigger className="flex w-full max-w-xs">
-              <SelectValue placeholder="Select an agent to display" />
+              <SelectValue placeholder="Select an assistant to display" />
             </SelectTrigger>
             <SelectContent>
               <div className="flex items-center px-2 pb-2 sticky top-0 bg-background border-b">
                 <Search className="h-4 w-4 mr-2 shrink-0 opacity-50" />
                 <input
                   className="flex h-8 w-full rounded-sm bg-transparent py-3 text-sm outline-none placeholder:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-50"
-                  placeholder="Search agents..."
+                  placeholder="Search assistants..."
                   value={searchQuery}
                   onChange={(e) => setSearchQuery(e.target.value)}
                   onClick={(e) => e.stopPropagation()}

web/src/app/ee/assistants/stats/[id]/AssistantStats.tsx

@@ -146,7 +146,7 @@ export function AssistantStats({ assistantId }: { assistantId: number }) {
   return (
     <Card className="w-full">
       <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
-        <p className="text-base font-normal text-2xl">Agent Analytics</p>
+        <p className="text-base font-normal text-2xl">Assistant Analytics</p>
         <AdminDateRangeSelector
           value={dateRange}
           onValueChange={setDateRange}

web/src/components/modals/NoAssistantModal.tsx

@@ -12,17 +12,17 @@ export default function NoAssistantModal() {
   return (
     <Modal open>
       <Modal.Content width="sm" height="sm">
-        <Modal.Header icon={SvgUser} title="No Agent Available" />
+        <Modal.Header icon={SvgUser} title="No Assistant Available" />
         <Modal.Body>
           <Text as="p">
-            You currently have no agent configured. To use this feature, you
+            You currently have no assistant configured. To use this feature, you
             need to take action.
           </Text>
           {isAdmin ? (
             <>
               <Text as="p">
-                As an administrator, you can create a new agent by visiting the
-                admin panel.
+                As an administrator, you can create a new assistant by visiting
+                the admin panel.
               </Text>
               <Button className="w-full" href="/admin/assistants">
                 Go to Admin Panel
@@ -30,7 +30,8 @@ export default function NoAssistantModal() {
             </>
           ) : (
             <Text as="p">
-              Please contact your administrator to configure an agent for you.
+              Please contact your administrator to configure an assistant for
+              you.
             </Text>
           )}
         </Modal.Body>

web/src/hooks/useCodeInterpreter.ts

@@ -1,44 +0,0 @@
-import useSWR from "swr";
-import { errorHandlingFetcher } from "@/lib/fetcher";
-
-const HEALTH_ENDPOINT = "/api/admin/code-interpreter/health";
-const STATUS_ENDPOINT = "/api/admin/code-interpreter";
-
-interface CodeInterpreterHealth {
-  healthy: boolean;
-}
-
-interface CodeInterpreterStatus {
-  enabled: boolean;
-}
-
-export default function useCodeInterpreter() {
-  const {
-    data: healthData,
-    error: healthError,
-    isLoading: isHealthLoading,
-    mutate: refetchHealth,
-  } = useSWR<CodeInterpreterHealth>(HEALTH_ENDPOINT, errorHandlingFetcher, {
-    refreshInterval: 30000,
-  });
-
-  const {
-    data: statusData,
-    error: statusError,
-    isLoading: isStatusLoading,
-    mutate: refetchStatus,
-  } = useSWR<CodeInterpreterStatus>(STATUS_ENDPOINT, errorHandlingFetcher);
-
-  function refetch() {
-    refetchHealth();
-    refetchStatus();
-  }
-
-  return {
-    isHealthy: healthData?.healthy ?? false,
-    isEnabled: statusData?.enabled ?? false,
-    isLoading: isHealthLoading || isStatusLoading,
-    error: healthError || statusError,
-    refetch,
-  };
-}

web/src/lib/admin/code-interpreter/svc.ts

@@ -1,15 +0,0 @@
-const UPDATE_ENDPOINT = "/api/admin/code-interpreter";
-
-interface CodeInterpreterUpdateRequest {
-  enabled: boolean;
-}
-
-export async function updateCodeInterpreter(
-  request: CodeInterpreterUpdateRequest
-): Promise<Response> {
-  return fetch(UPDATE_ENDPOINT, {
-    method: "PUT",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(request),
-  });
-}

web/src/refresh-pages/AgentsNavigationPage.tsx

@@ -425,7 +425,7 @@ export default function AgentsNavigationPage() {
     >
       <SettingsLayouts.Header
         icon={SvgOnyxOctagon}
-        title="Agents"
+        title="Agents & Assistants"
         description="Customize AI behavior and knowledge for you and your team's use cases."
         rightChildren={
           <Button

web/src/refresh-pages/admin/CodeInterpreterPage.tsx

@@ -1,241 +0,0 @@
-"use client";
-
-import React, { useState } from "react";
-import * as SettingsLayouts from "@/layouts/settings-layouts";
-import { Card, type CardProps } from "@/refresh-components/cards";
-import {
-  SvgArrowExchange,
-  SvgCheckCircle,
-  SvgRefreshCw,
-  SvgTerminal,
-  SvgUnplug,
-  SvgXOctagon,
-} from "@opal/icons";
-import { Section } from "@/layouts/general-layouts";
-import { Button } from "@opal/components";
-import Text from "@/refresh-components/texts/Text";
-import SimpleLoader from "@/refresh-components/loaders/SimpleLoader";
-import ConfirmationModalLayout from "@/refresh-components/layouts/ConfirmationModalLayout";
-import useCodeInterpreter from "@/hooks/useCodeInterpreter";
-import { updateCodeInterpreter } from "@/lib/admin/code-interpreter/svc";
-import { ContentAction } from "@opal/layouts";
-import { toast } from "@/hooks/useToast";
-
-interface CodeInterpreterCardProps {
-  variant?: CardProps["variant"];
-  title: string;
-  middleText?: string;
-  strikethrough?: boolean;
-  rightContent: React.ReactNode;
-}
-
-function CodeInterpreterCard({
-  variant,
-  title,
-  middleText,
-  strikethrough,
-  rightContent,
-}: CodeInterpreterCardProps) {
-  return (
-    // TODO (@raunakab): Allow Content to accept strikethrough and middleText
-    <Card variant={variant} padding={0.5}>
-      <ContentAction
-        icon={SvgTerminal}
-        title={middleText ? `${title} ${middleText}` : title}
-        description="Built-in Python runtime"
-        variant="section"
-        sizePreset="main-ui"
-        rightChildren={rightContent}
-      />
-    </Card>
-  );
-}
-
-function CheckingStatus() {
-  return (
-    <Section
-      flexDirection="row"
-      justifyContent="end"
-      alignItems="center"
-      gap={0.25}
-      padding={0.5}
-    >
-      <Text mainUiAction text03>
-        Checking...
-      </Text>
-      <SimpleLoader />
-    </Section>
-  );
-}
-
-interface ConnectionStatusProps {
-  healthy: boolean;
-  isLoading: boolean;
-}
-
-function ConnectionStatus({ healthy, isLoading }: ConnectionStatusProps) {
-  if (isLoading) {
-    return <CheckingStatus />;
-  }
-
-  const label = healthy ? "Connected" : "Connection Lost";
-  const Icon = healthy ? SvgCheckCircle : SvgXOctagon;
-  const iconColor = healthy ? "text-status-success-05" : "text-status-error-05";
-
-  return (
-    <Section
-      flexDirection="row"
-      justifyContent="end"
-      alignItems="center"
-      gap={0.25}
-      padding={0.5}
-    >
-      <Text mainUiAction text03>
-        {label}
-      </Text>
-      <Icon size={16} className={iconColor} />
-    </Section>
-  );
-}
-
-interface ActionButtonsProps {
-  onDisconnect: () => void;
-  onRefresh: () => void;
-  disabled?: boolean;
-}
-
-function ActionButtons({
-  onDisconnect,
-  onRefresh,
-  disabled,
-}: ActionButtonsProps) {
-  return (
-    <Section
-      flexDirection="row"
-      justifyContent="end"
-      alignItems="center"
-      gap={0.25}
-      padding={0.25}
-    >
-      <Button
-        prominence="tertiary"
-        size="sm"
-        icon={SvgUnplug}
-        onClick={onDisconnect}
-        tooltip="Disconnect"
-        disabled={disabled}
-      />
-      <Button
-        prominence="tertiary"
-        size="sm"
-        icon={SvgRefreshCw}
-        onClick={onRefresh}
-        tooltip="Refresh"
-        disabled={disabled}
-      />
-    </Section>
-  );
-}
-
-export default function CodeInterpreterPage() {
-  const { isHealthy, isEnabled, isLoading, refetch } = useCodeInterpreter();
-  const [showDisconnectModal, setShowDisconnectModal] = useState(false);
-  const [isReconnecting, setIsReconnecting] = useState(false);
-
-  async function handleToggle(enabled: boolean) {
-    const action = enabled ? "reconnect" : "disconnect";
-    setIsReconnecting(enabled);
-    try {
-      const response = await updateCodeInterpreter({ enabled });
-      if (!response.ok) {
-        toast.error(`Failed to ${action} Code Interpreter`);
-        return;
-      }
-      setShowDisconnectModal(false);
-      refetch();
-    } finally {
-      setIsReconnecting(false);
-    }
-  }
-
-  return (
-    <SettingsLayouts.Root>
-      <SettingsLayouts.Header
-        icon={SvgTerminal}
-        title="Code Interpreter"
-        description="Safe and sandboxed Python runtime available to your LLM. See docs for more details."
-        separator
-      />
-
-      <SettingsLayouts.Body>
-        {isEnabled || isLoading ? (
-          <CodeInterpreterCard
-            title="Code Interpreter"
-            variant={isHealthy ? "primary" : "secondary"}
-            strikethrough={!isHealthy}
-            rightContent={
-              <Section
-                flexDirection="column"
-                justifyContent="center"
-                alignItems="end"
-                gap={0}
-                padding={0}
-              >
-                <ConnectionStatus healthy={isHealthy} isLoading={isLoading} />
-                <ActionButtons
-                  onDisconnect={() => setShowDisconnectModal(true)}
-                  onRefresh={refetch}
-                  disabled={isLoading}
-                />
-              </Section>
-            }
-          />
-        ) : (
-          <CodeInterpreterCard
-            variant="secondary"
-            title="Code Interpreter"
-            middleText="(Disconnected)"
-            strikethrough={true}
-            rightContent={
-              <Section flexDirection="row" alignItems="center" padding={0.5}>
-                {isReconnecting ? (
-                  <CheckingStatus />
-                ) : (
-                  <Button
-                    prominence="tertiary"
-                    rightIcon={SvgArrowExchange}
-                    onClick={() => handleToggle(true)}
-                  >
-                    Reconnect
-                  </Button>
-                )}
-              </Section>
-            }
-          />
-        )}
-      </SettingsLayouts.Body>
-
-      {showDisconnectModal && (
-        <ConfirmationModalLayout
-          icon={SvgUnplug}
-          title="Disconnect Code Interpreter"
-          onClose={() => setShowDisconnectModal(false)}
-          submit={
-            <Button variant="danger" onClick={() => handleToggle(false)}>
-              Disconnect
-            </Button>
-          }
-        >
-          <Text as="p" text03>
-            All running sessions connected to{" "}
-            <Text as="span" mainContentEmphasis text03>
-              Code Interpreter
-            </Text>{" "}
-            will stop working. Note that this will not remove any data from your
-            runtime. You can reconnect to this runtime later if needed.
-          </Text>
-        </ConfirmationModalLayout>
-      )}
-    </SettingsLayouts.Root>
-  );
-}

web/src/sections/modals/NewTenantModal.tsx

@@ -119,7 +119,7 @@ export default function NewTenantModal({
     : `Your request to join ${tenantInfo.number_of_users} other users of ${APP_DOMAIN} has been approved.`;
 
   const description = isInvite
-    ? `By accepting this invitation, you will join the existing ${APP_DOMAIN} team and lose access to your current team. Note: you will lose access to your current agents, prompts, chats, and connected sources.`
+    ? `By accepting this invitation, you will join the existing ${APP_DOMAIN} team and lose access to your current team. Note: you will lose access to your current assistants, prompts, chats, and connected sources.`
     : `To finish joining your team, please reauthenticate with ${user?.email}.`;
 
   return (

web/src/sections/sidebar/AdminSidebar.tsx

@@ -50,7 +50,6 @@ import {
   SvgPaintBrush,
   SvgDiscordMono,
   SvgWallet,
-  SvgTerminal,
 } from "@opal/icons";
 import SvgMcp from "@opal/icons/mcp";
 import UserAvatarPopover from "@/sections/sidebar/UserAvatarPopover";
@@ -92,7 +91,7 @@ const custom_assistants_items = (
 ) => {
   const items = [
     {
-      name: "Agents",
+      name: "Assistants",
       icon: SvgOnyxOctagon,
       link: "/admin/assistants",
     },
@@ -166,7 +165,7 @@ const collections = (
         ]
       : []),
     {
-      name: "Custom Agents",
+      name: "Custom Assistants",
       items: custom_assistants_items(isCurator, enableEnterprise),
     },
     ...(isCurator && enableEnterprise
@@ -208,11 +207,6 @@ const collections = (
                 icon: SvgImage,
                 link: "/admin/configuration/image-generation",
               },
-              {
-                name: "Code Interpreter",
-                icon: SvgTerminal,
-                link: "/admin/configuration/code-interpreter",
-              },
               ...(!enableCloud && vectorDbEnabled
                 ? [
                     {

web/tests/e2e/admin/admin_pages.spec.ts

@@ -29,12 +29,12 @@ const ADMIN_PAGES: AdminPageSnapshot[] = [
     pageTitle: "Add Connector",
   },
   {
-    name: "Custom Agents - Agents",
+    name: "Custom Assistants - Assistants",
     path: "assistants",
-    pageTitle: "Agents",
+    pageTitle: "Assistants",
     options: {
       paragraphText:
-        "Agents are a way to build custom search/question-answering experiences for different use cases.",
+        "Assistants are a way to build custom search/question-answering experiences for different use cases.",
     },
   },
   {
@@ -52,7 +52,7 @@ const ADMIN_PAGES: AdminPageSnapshot[] = [
     },
   },
   {
-    name: "Custom Agents - Slack Bots",
+    name: "Custom Assistants - Slack Bots",
     path: "bots",
     pageTitle: "Slack Bots",
     options: {
@@ -61,7 +61,7 @@ const ADMIN_PAGES: AdminPageSnapshot[] = [
     },
   },
   {
-    name: "Custom Agents - Standard Answers",
+    name: "Custom Assistants - Standard Answers",
     path: "standard-answer",
     pageTitle: "Standard Answers",
   },
@@ -101,12 +101,12 @@ const ADMIN_PAGES: AdminPageSnapshot[] = [
     pageTitle: "Search Settings",
   },
   {
-    name: "Custom Agents - MCP Actions",
+    name: "Custom Assistants - MCP Actions",
     path: "actions/mcp",
     pageTitle: "MCP Actions",
   },
   {
-    name: "Custom Agents - OpenAPI Actions",
+    name: "Custom Assistants - OpenAPI Actions",
     path: "actions/open-api",
     pageTitle: "OpenAPI Actions",
   },

web/tests/e2e/admin/code-interpreter/code_interpreter.spec.ts

@@ -1,268 +0,0 @@
-import { test, expect } from "@playwright/test";
-import type { Page } from "@playwright/test";
-import { loginAs } from "@tests/e2e/utils/auth";
-
-const CODE_INTERPRETER_URL = "/admin/configuration/code-interpreter";
-const API_STATUS_URL = "**/api/admin/code-interpreter";
-const API_HEALTH_URL = "**/api/admin/code-interpreter/health";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Intercept the status (GET /) and health (GET /health) endpoints with the
- * given values so the page renders deterministically.
- *
- * Also handles PUT requests — by default they succeed (200). Pass
- * `putStatus` to simulate failures.
- */
-async function mockCodeInterpreterApi(
-  page: Page,
-  opts: { enabled: boolean; healthy: boolean; putStatus?: number }
-) {
-  const putStatus = opts.putStatus ?? 200;
-
-  await page.route(API_HEALTH_URL, async (route) => {
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify({ healthy: opts.healthy }),
-    });
-  });
-
-  await page.route(API_STATUS_URL, async (route) => {
-    if (route.request().method() === "PUT") {
-      await route.fulfill({
-        status: putStatus,
-        contentType: "application/json",
-        body:
-          putStatus >= 400
-            ? JSON.stringify({ detail: "Server Error" })
-            : JSON.stringify(null),
-      });
-    } else {
-      await route.fulfill({
-        status: 200,
-        contentType: "application/json",
-        body: JSON.stringify({ enabled: opts.enabled }),
-      });
-    }
-  });
-}
-
-/**
- * The disconnect icon button is an icon-only opal Button whose tooltip text
- * is not exposed as an accessible name. Locate it by finding the first
- * icon-only button (no label span) inside the card area.
- */
-function getDisconnectIconButton(page: Page) {
-  return page
-    .locator("button:has(.opal-button):not(:has(.opal-button-label))")
-    .first();
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-test.describe("Code Interpreter Admin Page", () => {
-  test.beforeEach(async ({ page }) => {
-    await page.context().clearCookies();
-    await loginAs(page, "admin");
-  });
-
-  test("page loads with header and description", async ({ page }) => {
-    await mockCodeInterpreterApi(page, { enabled: true, healthy: true });
-    await page.goto(CODE_INTERPRETER_URL);
-
-    await expect(page.locator('[aria-label="admin-page-title"]')).toHaveText(
-      /^Code Interpreter/,
-      { timeout: 10000 }
-    );
-
-    await expect(page.getByText("Built-in Python runtime")).toBeVisible();
-  });
-
-  test("shows Connected status when enabled and healthy", async ({ page }) => {
-    await mockCodeInterpreterApi(page, { enabled: true, healthy: true });
-    await page.goto(CODE_INTERPRETER_URL);
-
-    await expect(page.getByText("Connected")).toBeVisible({ timeout: 10000 });
-  });
-
-  test("shows Connection Lost when enabled but unhealthy", async ({ page }) => {
-    await mockCodeInterpreterApi(page, { enabled: true, healthy: false });
-    await page.goto(CODE_INTERPRETER_URL);
-
-    await expect(page.getByText("Connection Lost")).toBeVisible({
-      timeout: 10000,
-    });
-  });
-
-  test("shows Reconnect button when disabled", async ({ page }) => {
-    await mockCodeInterpreterApi(page, { enabled: false, healthy: false });
-    await page.goto(CODE_INTERPRETER_URL);
-
-    await expect(page.getByRole("button", { name: "Reconnect" })).toBeVisible({
-      timeout: 10000,
-    });
-    await expect(page.getByText("(Disconnected)")).toBeVisible();
-  });
-
-  test("disconnect flow opens modal and sends PUT request", async ({
-    page,
-  }) => {
-    await mockCodeInterpreterApi(page, { enabled: true, healthy: true });
-    await page.goto(CODE_INTERPRETER_URL);
-
-    await expect(page.getByText("Connected")).toBeVisible({ timeout: 10000 });
-
-    // Click the disconnect icon button
-    await getDisconnectIconButton(page).click();
-
-    // Modal should appear
-    await expect(page.getByText("Disconnect Code Interpreter")).toBeVisible();
-    await expect(
-      page.getByText("All running sessions connected to")
-    ).toBeVisible();
-
-    // Click the danger Disconnect button in the modal
-    const modal = page.getByRole("dialog");
-    await modal.getByRole("button", { name: "Disconnect" }).click();
-
-    // Modal should close after successful disconnect
-    await expect(page.getByText("Disconnect Code Interpreter")).not.toBeVisible(
-      { timeout: 5000 }
-    );
-  });
-
-  test("disconnect modal can be closed without disconnecting", async ({
-    page,
-  }) => {
-    await mockCodeInterpreterApi(page, { enabled: true, healthy: true });
-    await page.goto(CODE_INTERPRETER_URL);
-
-    await expect(page.getByText("Connected")).toBeVisible({ timeout: 10000 });
-
-    // Open modal
-    await getDisconnectIconButton(page).click();
-    await expect(page.getByText("Disconnect Code Interpreter")).toBeVisible();
-
-    // Close modal via Cancel button
-    const modal = page.getByRole("dialog");
-    await modal.getByRole("button", { name: "Cancel" }).click();
-
-    // Modal should be gone, page still shows Connected
-    await expect(
-      page.getByText("Disconnect Code Interpreter")
-    ).not.toBeVisible();
-    await expect(page.getByText("Connected")).toBeVisible();
-  });
-
-  test("reconnect flow sends PUT with enabled=true", async ({ page }) => {
-    await mockCodeInterpreterApi(page, { enabled: false, healthy: false });
-    await page.goto(CODE_INTERPRETER_URL);
-
-    await expect(page.getByRole("button", { name: "Reconnect" })).toBeVisible({
-      timeout: 10000,
-    });
-
-    // Intercept the PUT and verify the payload
-    const putPromise = page.waitForRequest(
-      (req) =>
-        req.url().includes("/api/admin/code-interpreter") &&
-        req.method() === "PUT"
-    );
-
-    await page.getByRole("button", { name: "Reconnect" }).click();
-
-    const putReq = await putPromise;
-    expect(putReq.postDataJSON()).toEqual({ enabled: true });
-  });
-
-  test("shows Checking... while reconnect is in progress", async ({ page }) => {
-    // Use a single route handler that delays PUT responses
-    await page.route(API_HEALTH_URL, async (route) => {
-      await route.fulfill({
-        status: 200,
-        contentType: "application/json",
-        body: JSON.stringify({ healthy: false }),
-      });
-    });
-
-    await page.route(API_STATUS_URL, async (route) => {
-      if (route.request().method() === "PUT") {
-        await new Promise((resolve) => setTimeout(resolve, 2000));
-        await route.fulfill({
-          status: 200,
-          contentType: "application/json",
-          body: JSON.stringify(null),
-        });
-      } else {
-        await route.fulfill({
-          status: 200,
-          contentType: "application/json",
-          body: JSON.stringify({ enabled: false }),
-        });
-      }
-    });
-
-    await page.goto(CODE_INTERPRETER_URL);
-
-    await expect(page.getByRole("button", { name: "Reconnect" })).toBeVisible({
-      timeout: 10000,
-    });
-
-    await page.getByRole("button", { name: "Reconnect" }).click();
-
-    // Should show Checking... while the request is in flight
-    await expect(page.getByText("Checking...")).toBeVisible({ timeout: 3000 });
-  });
-
-  test("shows error toast when disconnect fails", async ({ page }) => {
-    await mockCodeInterpreterApi(page, {
-      enabled: true,
-      healthy: true,
-      putStatus: 500,
-    });
-    await page.goto(CODE_INTERPRETER_URL);
-
-    await expect(page.getByText("Connected")).toBeVisible({ timeout: 10000 });
-
-    // Open modal and click disconnect
-    await getDisconnectIconButton(page).click();
-    const modal = page.getByRole("dialog");
-    await modal.getByRole("button", { name: "Disconnect" }).click();
-
-    // Error toast should appear
-    await expect(
-      page.getByText("Failed to disconnect Code Interpreter")
-    ).toBeVisible({ timeout: 5000 });
-  });
-
-  test("shows error toast when reconnect fails", async ({ page }) => {
-    await mockCodeInterpreterApi(page, {
-      enabled: false,
-      healthy: false,
-      putStatus: 500,
-    });
-    await page.goto(CODE_INTERPRETER_URL);
-
-    await expect(page.getByRole("button", { name: "Reconnect" })).toBeVisible({
-      timeout: 10000,
-    });
-
-    await page.getByRole("button", { name: "Reconnect" }).click();
-
-    // Error toast should appear
-    await expect(
-      page.getByText("Failed to reconnect Code Interpreter")
-    ).toBeVisible({ timeout: 5000 });
-
-    // Reconnect button should reappear (not stuck in Checking...)
-    await expect(page.getByRole("button", { name: "Reconnect" })).toBeVisible({
-      timeout: 5000,
-    });
-  });
-});

web/tests/e2e/auth/password_managements.spec.ts

@@ -46,7 +46,7 @@ test.skip("User changes password and logs in with new password", async ({
 
   // Verify successful login
   await expect(page).toHaveURL("http://localhost:3000/app");
-  await expect(page.getByText("Explore Agents")).toBeVisible();
+  await expect(page.getByText("Explore Assistants")).toBeVisible();
 });
 
 test.use({ storageState: "admin2_auth.json" });
@@ -115,5 +115,5 @@ test.skip("Admin resets own password and logs in with new password", async ({
 
   // Verify successful login
   await expect(page).toHaveURL("http://localhost:3000/app");
-  await expect(page.getByText("Explore Agents")).toBeVisible();
+  await expect(page.getByText("Explore Assistants")).toBeVisible();
 });

web/tests/e2e/chat/default_assistant.spec.ts

@@ -16,7 +16,7 @@ import { OnyxApiClient } from "@tests/e2e/utils/onyxApiClient";
 
 // Tool-related test selectors now imported from shared utils
 
-test.describe("Default Agent Tests", () => {
+test.describe("Default Assistant Tests", () => {
   let imageGenConfigId: string | null = null;
 
   test.beforeAll(async ({ browser }) => {
@@ -69,7 +69,7 @@ test.describe("Default Agent Tests", () => {
   });
 
   test.describe("Greeting Message Display", () => {
-    test("should display greeting message when opening new chat with default agent", async ({
+    test("should display greeting message when opening new chat with default assistant", async ({
       page,
     }) => {
       // Look for greeting message - should be one from the predefined list
@@ -95,21 +95,23 @@ test.describe("Default Agent Tests", () => {
       expect(GREETING_MESSAGES).toContain(greetingAfterReload?.trim());
     });
 
-    test("greeting should only appear for default agent", async ({ page }) => {
-      // First verify greeting appears for default agent
+    test("greeting should only appear for default assistant", async ({
+      page,
+    }) => {
+      // First verify greeting appears for default assistant
       const greetingElement = await page.waitForSelector(
         '[data-testid="onyx-logo"]',
         { timeout: 5000 }
       );
       expect(greetingElement).toBeTruthy();
 
-      // Create a custom agent to test non-default behavior
+      // Create a custom assistant to test non-default behavior
       await page.getByTestId("AppSidebar/more-agents").click();
       await page.getByLabel("AgentsPage/new-agent-button").click();
       await page
         .locator('input[name="name"]')
         .waitFor({ state: "visible", timeout: 10000 });
-      await page.locator('input[name="name"]').fill("Custom Test Agent");
+      await page.locator('input[name="name"]').fill("Custom Test Assistant");
       await page
         .locator('textarea[name="description"]')
         .fill("Test Description");
@@ -118,17 +120,17 @@ test.describe("Default Agent Tests", () => {
         .fill("Test Instructions");
       await page.getByRole("button", { name: "Create" }).click();
 
-      // Wait for agent to be created and selected
-      await verifyAssistantIsChosen(page, "Custom Test Agent");
+      // Wait for assistant to be created and selected
+      await verifyAssistantIsChosen(page, "Custom Test Assistant");
 
-      // Greeting should NOT appear for custom agent
+      // Greeting should NOT appear for custom assistant
       const customGreeting = await page.$('[data-testid="onyx-logo"]');
       expect(customGreeting).toBeNull();
     });
   });
 
-  test.describe("Default Agent Branding", () => {
-    test("should display Onyx logo for default agent", async ({ page }) => {
+  test.describe("Default Assistant Branding", () => {
+    test("should display Onyx logo for default assistant", async ({ page }) => {
       // Look for Onyx logo
       const logoElement = await page.waitForSelector(
         '[data-testid="onyx-logo"]',
@@ -136,23 +138,23 @@ test.describe("Default Agent Tests", () => {
       );
       expect(logoElement).toBeTruthy();
 
-      // Should NOT show agent name for default agent
+      // Should NOT show assistant name for default assistant
       const assistantNameElement = await page.$(
         '[data-testid="assistant-name-display"]'
       );
       expect(assistantNameElement).toBeNull();
     });
 
-    test("custom agents should show name and icon instead of logo", async ({
+    test("custom assistants should show name and icon instead of logo", async ({
       page,
     }) => {
-      // Create a custom agent
+      // Create a custom assistant
       await page.getByTestId("AppSidebar/more-agents").click();
       await page.getByLabel("AgentsPage/new-agent-button").click();
       await page
         .locator('input[name="name"]')
         .waitFor({ state: "visible", timeout: 10000 });
-      await page.locator('input[name="name"]').fill("Custom Agent");
+      await page.locator('input[name="name"]').fill("Custom Assistant");
       await page
         .locator('textarea[name="description"]')
         .fill("Test Description");
@@ -161,16 +163,16 @@ test.describe("Default Agent Tests", () => {
         .fill("Test Instructions");
       await page.getByRole("button", { name: "Create" }).click();
 
-      // Wait for agent to be created and selected
-      await verifyAssistantIsChosen(page, "Custom Agent");
+      // Wait for assistant to be created and selected
+      await verifyAssistantIsChosen(page, "Custom Assistant");
 
-      // Should show agent name and icon, not Onyx logo
+      // Should show assistant name and icon, not Onyx logo
       const assistantNameElement = await page.waitForSelector(
         '[data-testid="assistant-name-display"]',
         { timeout: 5000 }
       );
       const nameText = await assistantNameElement.textContent();
-      expect(nameText).toContain("Custom Agent");
+      expect(nameText).toContain("Custom Assistant");
 
       // Onyx logo should NOT be shown
       const logoElement = await page.$('[data-testid="onyx-logo"]');
@@ -179,8 +181,10 @@ test.describe("Default Agent Tests", () => {
   });
 
   test.describe("Starter Messages", () => {
-    test("default agent should NOT have starter messages", async ({ page }) => {
-      // Check that starter messages container does not exist for default agent
+    test("default assistant should NOT have starter messages", async ({
+      page,
+    }) => {
+      // Check that starter messages container does not exist for default assistant
       const starterMessagesContainer = await page.$(
         '[data-testid="starter-messages"]'
       );
@@ -191,14 +195,18 @@ test.describe("Default Agent Tests", () => {
       expect(starterButtons.length).toBe(0);
     });
 
-    test("custom agents should display starter messages", async ({ page }) => {
-      // Create a custom agent with starter messages
+    test("custom assistants should display starter messages", async ({
+      page,
+    }) => {
+      // Create a custom assistant with starter messages
       await page.getByTestId("AppSidebar/more-agents").click();
       await page.getByLabel("AgentsPage/new-agent-button").click();
       await page
         .locator('input[name="name"]')
         .waitFor({ state: "visible", timeout: 10000 });
-      await page.locator('input[name="name"]').fill("Test Agent with Starters");
+      await page
+        .locator('input[name="name"]')
+        .fill("Test Assistant with Starters");
       await page
         .locator('textarea[name="description"]')
         .fill("Test Description");
@@ -211,9 +219,9 @@ test.describe("Default Agent Tests", () => {
       await page.getByRole("button", { name: "Create" }).click();
 
       // Wait for assistant to be created and selected
-      await verifyAssistantIsChosen(page, "Test Agent with Starters");
+      await verifyAssistantIsChosen(page, "Test Assistant with Starters");
 
-      // Starter messages container might exist but be empty for custom agents
+      // Starter messages container might exist but be empty for custom assistants
       const starterMessagesContainer = await page.$(
         '[data-testid="starter-messages"]'
       );
@@ -222,22 +230,24 @@ test.describe("Default Agent Tests", () => {
         const starterButtons = await page.$$(
           '[data-testid^="starter-message-"]'
         );
-        // Custom agent without configured starter messages should have none
+        // Custom assistant without configured starter messages should have none
         expect(starterButtons.length).toBe(0);
       }
     });
   });
 
-  test.describe("Agent Selection", () => {
-    test("default agent should be selected for new chats", async ({ page }) => {
-      // Verify the input placeholder indicates default agent (Onyx)
+  test.describe("Assistant Selection", () => {
+    test("default assistant should be selected for new chats", async ({
+      page,
+    }) => {
+      // Verify the input placeholder indicates default assistant (Onyx)
       await verifyDefaultAssistantIsChosen(page);
     });
 
-    test("default agent should NOT appear in agent selector", async ({
+    test("default assistant should NOT appear in assistant selector", async ({
       page,
     }) => {
-      // Open agent selector
+      // Open assistant selector
       await page.getByTestId("AppSidebar/more-agents").click();
 
       // Wait for modal or assistant list to appear
@@ -246,13 +256,13 @@ test.describe("Default Agent Tests", () => {
         .getByLabel("AgentsPage/new-agent-button")
         .waitFor({ state: "visible", timeout: 5000 });
 
-      // Look for default agent by name - it should NOT be there
+      // Look for default assistant by name - it should NOT be there
       const assistantElements = await page.$$('[data-testid^="assistant-"]');
       const assistantTexts = await Promise.all(
         assistantElements.map((el) => el.textContent())
       );
 
-      // Check that the default agent is not in the list
+      // Check that "Assistant" (the default assistant name) is not in the list
       const hasDefaultAssistant = assistantTexts.some(
         (text) =>
           text?.includes("Assistant") &&
@@ -265,16 +275,16 @@ test.describe("Default Agent Tests", () => {
       await page.keyboard.press("Escape");
     });
 
-    test("should be able to switch from default to custom agent", async ({
+    test("should be able to switch from default to custom assistant", async ({
       page,
     }) => {
-      // Create a custom agent
+      // Create a custom assistant
       await page.getByTestId("AppSidebar/more-agents").click();
       await page.getByLabel("AgentsPage/new-agent-button").click();
       await page
         .locator('input[name="name"]')
         .waitFor({ state: "visible", timeout: 10000 });
-      await page.locator('input[name="name"]').fill("Switch Test Agent");
+      await page.locator('input[name="name"]').fill("Switch Test Assistant");
       await page
         .locator('textarea[name="description"]')
         .fill("Test Description");
@@ -283,13 +293,13 @@ test.describe("Default Agent Tests", () => {
         .fill("Test Instructions");
       await page.getByRole("button", { name: "Create" }).click();
 
-      // Verify switched to custom agent
-      await verifyAssistantIsChosen(page, "Switch Test Agent");
+      // Verify switched to custom assistant
+      await verifyAssistantIsChosen(page, "Switch Test Assistant");
 
       // Start new chat to go back to default
       await startNewChat(page);
 
-      // Should be back to default agent
+      // Should be back to default assistant
       await verifyDefaultAssistantIsChosen(page);
     });
   });
@@ -369,7 +379,7 @@ test.describe("Default Agent Tests", () => {
         );
       }
 
-      // Enable the tools in default agent config via API
+      // Enable the tools in default assistant config via API
       // Get current tools to find their IDs
       const toolsListResp = await page.request.get(
         "http://localhost:3000/api/tool"
@@ -532,7 +542,7 @@ test.describe("Default Agent Tests", () => {
   });
 });
 
-test.describe("End-to-End Default Agent Flow", () => {
+test.describe("End-to-End Default Assistant Flow", () => {
   let imageGenConfigId: string | null = null;
 
   test.beforeAll(async ({ browser }) => {
@@ -574,7 +584,7 @@ test.describe("End-to-End Default Agent Flow", () => {
     }
   });
 
-  test("complete user journey with default agent", async ({ page }) => {
+  test("complete user journey with default assistant", async ({ page }) => {
     // Clear cookies and log in as a random user
     await page.context().clearCookies();
     await loginAsRandomUser(page);
@@ -601,7 +611,7 @@ test.describe("End-to-End Default Agent Flow", () => {
     // Start a new chat
     await startNewChat(page);
 
-    // Verify we're back to default agent with greeting
+    // Verify we're back to default assistant with greeting
     await expect(page.locator('[data-testid="onyx-logo"]')).toBeVisible();
   });
 });