Merge remote-tracking branch 'upstream/dev' into dev

Author: github-actions[bot]

Dockerfile

@@ -143,6 +143,7 @@ RUN pip3 install --no-cache-dir uv && \
     python -c "import os; from sentence_transformers import SentenceTransformer; SentenceTransformer(os.environ.get('AUXILIARY_EMBEDDING_MODEL', 'TaylorAI/bge-micro-v2'), device='cpu')" && \
     python -c "import os; from faster_whisper import WhisperModel; WhisperModel(os.environ['WHISPER_MODEL'], device='cpu', compute_type='int8', download_root=os.environ['WHISPER_MODEL_DIR'])"; \
     python -c "import os; import tiktoken; tiktoken.get_encoding(os.environ['TIKTOKEN_ENCODING_NAME'])"; \
+    python -c "import nltk; nltk.download('punkt_tab')"; \
     else \
     pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu --no-cache-dir && \
     uv pip install --system -r requirements.txt --no-cache-dir && \
@@ -151,6 +152,7 @@ RUN pip3 install --no-cache-dir uv && \
     python -c "import os; from sentence_transformers import SentenceTransformer; SentenceTransformer(os.environ.get('AUXILIARY_EMBEDDING_MODEL', 'TaylorAI/bge-micro-v2'), device='cpu')" && \
     python -c "import os; from faster_whisper import WhisperModel; WhisperModel(os.environ['WHISPER_MODEL'], device='cpu', compute_type='int8', download_root=os.environ['WHISPER_MODEL_DIR'])"; \
     python -c "import os; import tiktoken; tiktoken.get_encoding(os.environ['TIKTOKEN_ENCODING_NAME'])"; \
+    python -c "import nltk; nltk.download('punkt_tab')"; \
     fi; \
     fi; \
     mkdir -p /app/backend/data && chown -R $UID:$GID /app/backend/data/ && \

backend/open_webui/env.py

@@ -194,6 +194,15 @@ def parse_section(section):
     os.environ.get("ENABLE_FORWARD_USER_INFO_HEADERS", "False").lower() == "true"
 )
 
+# Header names for user info forwarding (customizable via environment variables)
+FORWARD_USER_INFO_HEADER_USER_NAME = os.environ.get("FORWARD_USER_INFO_HEADER_USER_NAME", "X-OpenWebUI-User-Name")
+FORWARD_USER_INFO_HEADER_USER_ID = os.environ.get("FORWARD_USER_INFO_HEADER_USER_ID", "X-OpenWebUI-User-Id")
+FORWARD_USER_INFO_HEADER_USER_EMAIL = os.environ.get("FORWARD_USER_INFO_HEADER_USER_EMAIL", "X-OpenWebUI-User-Email")
+FORWARD_USER_INFO_HEADER_USER_ROLE = os.environ.get("FORWARD_USER_INFO_HEADER_USER_ROLE", "X-OpenWebUI-User-Role")
+
+# Header name for chat ID forwarding (customizable via environment variable)
+FORWARD_SESSION_INFO_HEADER_CHAT_ID = os.environ.get("FORWARD_SESSION_INFO_HEADER_CHAT_ID", "X-OpenWebUI-Chat-Id")
+
 # Experimental feature, may be removed in future
 ENABLE_STAR_SESSIONS_MIDDLEWARE = (
     os.environ.get("ENABLE_STAR_SESSIONS_MIDDLEWARE", "False").lower() == "true"

backend/open_webui/main.py

@@ -511,7 +511,11 @@
     chat_action as chat_action_handler,
 )
 from open_webui.utils.embeddings import generate_embeddings
-from open_webui.utils.middleware import process_chat_payload, process_chat_response
+from open_webui.utils.middleware import (
+    build_chat_response_context,
+    process_chat_payload,
+    process_chat_response,
+)
 from open_webui.utils.access_control import has_access
 
 from open_webui.utils.auth import (
@@ -1379,9 +1383,9 @@ async def check_url(request: Request, call_next):
     # Fallback to cookie token for browser sessions
     if request.state.token is None and request.cookies.get("token"):
         from fastapi.security import HTTPAuthorizationCredentials
+
         request.state.token = HTTPAuthorizationCredentials(
-            scheme="Bearer",
-            credentials=request.cookies.get("token")
+            scheme="Bearer", credentials=request.cookies.get("token")
         )
 
     request.state.enable_api_keys = app.state.config.ENABLE_API_KEYS
@@ -1456,9 +1460,7 @@ async def inspect_websocket(request: Request, call_next):
 app.include_router(
     evaluations.router, prefix="/api/v1/evaluations", tags=["evaluations"]
 )
-app.include_router(
-    analytics.router, prefix="/api/v1/analytics", tags=["analytics"]
-)
+app.include_router(analytics.router, prefix="/api/v1/analytics", tags=["analytics"])
 app.include_router(utils.router, prefix="/api/v1/utils", tags=["utils"])
 
 # SCIM 2.0 API for identity management
@@ -1746,9 +1748,11 @@ async def process_chat(request, form_data, user, metadata, model):
                 except:
                     pass
 
-            return await process_chat_response(
-                request, response, form_data, user, metadata, model, events, tasks
+            ctx = build_chat_response_context(
+                request, form_data, user, model, metadata, tasks, events
             )
+
+            return await process_chat_response(response, ctx)
         except asyncio.CancelledError:
             log.info("Chat processing was cancelled")
             try:

backend/open_webui/migrations/versions/8452d01d26d7_add_chat_message_table.py

@@ -88,9 +88,11 @@ def upgrade() -> None:
         sa.column("updated_at", sa.BigInteger()),
     )
 
-    # Fetch all chats
+    # Fetch all chats (excluding shared chats which have user_id starting with 'shared-')
     chats = conn.execute(
-        sa.select(chat_table.c.id, chat_table.c.user_id, chat_table.c.chat)
+        sa.select(chat_table.c.id, chat_table.c.user_id, chat_table.c.chat).where(
+            ~chat_table.c.user_id.like("shared-%")
+        )
     ).fetchall()
 
     now = int(time.time())

backend/open_webui/models/chat_messages.py

@@ -111,7 +111,7 @@ class ChatMessageModel(BaseModel):
     embeds: Optional[list] = None
     done: bool = True
     status_history: Optional[list] = None
-    error: Optional[dict] = None
+    error: Optional[dict | str] = None
     usage: Optional[dict] = None
     created_at: int
     updated_at: int
@@ -269,6 +269,36 @@ def get_messages_by_model_id(
             )
             return [ChatMessageModel.model_validate(message) for message in messages]
 
+    def get_chat_ids_by_model_id(
+        self,
+        model_id: str,
+        start_date: Optional[int] = None,
+        end_date: Optional[int] = None,
+        skip: int = 0,
+        limit: int = 50,
+        db: Optional[Session] = None,
+    ) -> list[str]:
+        """Get distinct chat_ids that used a specific model."""
+        from sqlalchemy import distinct
+
+        with get_db_context(db) as db:
+            query = db.query(distinct(ChatMessage.chat_id)).filter(
+                ChatMessage.model_id == model_id
+            )
+            if start_date:
+                query = query.filter(ChatMessage.created_at >= start_date)
+            if end_date:
+                query = query.filter(ChatMessage.created_at <= end_date)
+
+            # Order by most recent message in each chat
+            chat_ids = (
+                query.order_by(ChatMessage.created_at.desc())
+                .offset(skip)
+                .limit(limit)
+                .all()
+            )
+            return [chat_id for (chat_id,) in chat_ids]
+
     def delete_messages_by_chat_id(
         self, chat_id: str, db: Optional[Session] = None
     ) -> bool:
@@ -282,19 +312,28 @@ def get_message_count_by_model(
         self,
         start_date: Optional[int] = None,
         end_date: Optional[int] = None,
+        group_id: Optional[str] = None,
         db: Optional[Session] = None,
     ) -> dict[str, int]:
         with get_db_context(db) as db:
             from sqlalchemy import func
+            from open_webui.models.groups import GroupMember
 
             query = db.query(
                 ChatMessage.model_id, func.count(ChatMessage.id).label("count")
-            ).filter(ChatMessage.role == "assistant", ChatMessage.model_id.isnot(None))
+            ).filter(
+                ChatMessage.role == "assistant",
+                ChatMessage.model_id.isnot(None),
+                ~ChatMessage.user_id.like("shared-%"),
+            )
 
             if start_date:
                 query = query.filter(ChatMessage.created_at >= start_date)
             if end_date:
                 query = query.filter(ChatMessage.created_at <= end_date)
+            if group_id:
+                group_users = db.query(GroupMember.user_id).filter(GroupMember.group_id == group_id).subquery()
+                query = query.filter(ChatMessage.user_id.in_(group_users))
 
             results = query.group_by(ChatMessage.model_id).all()
             return {row.model_id: row.count for row in results}
@@ -303,11 +342,13 @@ def get_token_usage_by_model(
         self,
         start_date: Optional[int] = None,
         end_date: Optional[int] = None,
+        group_id: Optional[str] = None,
         db: Optional[Session] = None,
     ) -> dict[str, dict]:
         """Aggregate token usage by model using database-level aggregation."""
         with get_db_context(db) as db:
             from sqlalchemy import func, cast, Integer
+            from open_webui.models.groups import GroupMember
 
             dialect = db.bind.dialect.name
 
@@ -338,12 +379,16 @@ def get_token_usage_by_model(
                 ChatMessage.role == "assistant",
                 ChatMessage.model_id.isnot(None),
                 ChatMessage.usage.isnot(None),
+                ~ChatMessage.user_id.like("shared-%"),
             )
 
             if start_date:
                 query = query.filter(ChatMessage.created_at >= start_date)
             if end_date:
                 query = query.filter(ChatMessage.created_at <= end_date)
+            if group_id:
+                group_users = db.query(GroupMember.user_id).filter(GroupMember.group_id == group_id).subquery()
+                query = query.filter(ChatMessage.user_id.in_(group_users))
 
             results = query.group_by(ChatMessage.model_id).all()
 
@@ -396,6 +441,7 @@ def get_token_usage_by_user(
                 ChatMessage.role == "assistant",
                 ChatMessage.user_id.isnot(None),
                 ChatMessage.usage.isnot(None),
+                ~ChatMessage.user_id.like("shared-%"),
             )
 
             if start_date:
@@ -419,19 +465,24 @@ def get_message_count_by_user(
         self,
         start_date: Optional[int] = None,
         end_date: Optional[int] = None,
+        group_id: Optional[str] = None,
         db: Optional[Session] = None,
     ) -> dict[str, int]:
         with get_db_context(db) as db:
             from sqlalchemy import func
+            from open_webui.models.groups import GroupMember
 
             query = db.query(
                 ChatMessage.user_id, func.count(ChatMessage.id).label("count")
-            )
+            ).filter(~ChatMessage.user_id.like("shared-%"))
 
             if start_date:
                 query = query.filter(ChatMessage.created_at >= start_date)
             if end_date:
                 query = query.filter(ChatMessage.created_at <= end_date)
+            if group_id:
+                group_users = db.query(GroupMember.user_id).filter(GroupMember.group_id == group_id).subquery()
+                query = query.filter(ChatMessage.user_id.in_(group_users))
 
             results = query.group_by(ChatMessage.user_id).all()
             return {row.user_id: row.count for row in results}
@@ -440,19 +491,24 @@ def get_message_count_by_chat(
         self,
         start_date: Optional[int] = None,
         end_date: Optional[int] = None,
+        group_id: Optional[str] = None,
         db: Optional[Session] = None,
     ) -> dict[str, int]:
         with get_db_context(db) as db:
             from sqlalchemy import func
+            from open_webui.models.groups import GroupMember
 
             query = db.query(
                 ChatMessage.chat_id, func.count(ChatMessage.id).label("count")
-            )
+            ).filter(~ChatMessage.user_id.like("shared-%"))
 
             if start_date:
                 query = query.filter(ChatMessage.created_at >= start_date)
             if end_date:
                 query = query.filter(ChatMessage.created_at <= end_date)
+            if group_id:
+                group_users = db.query(GroupMember.user_id).filter(GroupMember.group_id == group_id).subquery()
+                query = query.filter(ChatMessage.user_id.in_(group_users))
 
             results = query.group_by(ChatMessage.chat_id).all()
             return {row.chat_id: row.count for row in results}
@@ -461,21 +517,27 @@ def get_daily_message_counts_by_model(
         self,
         start_date: Optional[int] = None,
         end_date: Optional[int] = None,
+        group_id: Optional[str] = None,
         db: Optional[Session] = None,
     ) -> dict[str, dict[str, int]]:
         """Get message counts grouped by day and model."""
         with get_db_context(db) as db:
             from datetime import datetime, timedelta
+            from open_webui.models.groups import GroupMember
 
             query = db.query(ChatMessage.created_at, ChatMessage.model_id).filter(
                 ChatMessage.role == "assistant",
-                ChatMessage.model_id.isnot(None)
+                ChatMessage.model_id.isnot(None),
+                ~ChatMessage.user_id.like("shared-%"),
             )
 
             if start_date:
                 query = query.filter(ChatMessage.created_at >= start_date)
             if end_date:
                 query = query.filter(ChatMessage.created_at <= end_date)
+            if group_id:
+                group_users = db.query(GroupMember.user_id).filter(GroupMember.group_id == group_id).subquery()
+                query = query.filter(ChatMessage.user_id.in_(group_users))
 
             results = query.all()
 
@@ -511,7 +573,8 @@ def get_hourly_message_counts_by_model(
 
             query = db.query(ChatMessage.created_at, ChatMessage.model_id).filter(
                 ChatMessage.role == "assistant",
-                ChatMessage.model_id.isnot(None)
+                ChatMessage.model_id.isnot(None),
+                ~ChatMessage.user_id.like("shared-%"),
             )
 
             if start_date:

backend/open_webui/models/feedbacks.py

@@ -191,6 +191,23 @@ def get_feedback_by_id_and_user_id(
         except Exception:
             return None
 
+    def get_feedbacks_by_chat_id(
+        self, chat_id: str, db: Optional[Session] = None
+    ) -> list[FeedbackModel]:
+        """Get all feedbacks for a specific chat."""
+        try:
+            with get_db_context(db) as db:
+                # meta.chat_id stores the chat reference
+                feedbacks = (
+                    db.query(Feedback)
+                    .filter(Feedback.meta["chat_id"].as_string() == chat_id)
+                    .order_by(Feedback.created_at.desc())
+                    .all()
+                )
+                return [FeedbackModel.model_validate(fb) for fb in feedbacks]
+        except Exception:
+            return []
+
     def get_feedback_items(
         self,
         filter: dict = {},

backend/open_webui/retrieval/web/external.py

@@ -8,6 +8,7 @@
 
 from open_webui.retrieval.web.main import SearchResult, get_filtered_results
 from open_webui.utils.headers import include_user_info_headers
+from open_webui.env import FORWARD_SESSION_INFO_HEADER_CHAT_ID
 
 
 log = logging.getLogger(__name__)
@@ -31,7 +32,7 @@ def search_external(
 
         chat_id = getattr(request.state, "chat_id", None)
         if chat_id:
-            headers["X-OpenWebUI-Chat-Id"] = str(chat_id)
+            headers[FORWARD_SESSION_INFO_HEADER_CHAT_ID] = str(chat_id)
 
         response = requests.post(
             external_url,

backend/open_webui/retrieval/web/utils.py

@@ -174,7 +174,7 @@ async def _safe_process_url(self, url: str) -> bool:
 
     def _safe_process_url_sync(self, url: str) -> bool:
         """Synchronous version of safety checks."""
-        if self.verify_ssl and not self._verify_ssl_cert(url):
+        if self.verify_ssl and not verify_ssl_cert(url):
             raise ValueError(f"SSL certificate verification failed for {url}")
         self._sync_wait_for_rate_limit()
         return True

backend/open_webui/retrieval/web/yandex.py

@@ -11,6 +11,7 @@
 
 from open_webui.retrieval.web.main import SearchResult, get_filtered_results
 from open_webui.utils.headers import include_user_info_headers
+from open_webui.env import FORWARD_SESSION_INFO_HEADER_CHAT_ID
 
 from xml.etree import ElementTree as ET
 from xml.etree.ElementTree import Element
@@ -50,7 +51,7 @@ def search_yandex(
 
         chat_id = getattr(request.state, "chat_id", None)
         if chat_id:
-            headers["X-OpenWebUI-Chat-Id"] = str(chat_id)
+            headers[FORWARD_SESSION_INFO_HEADER_CHAT_ID] = str(chat_id)
 
         payload = {} if yandex_search_config == "" else json.loads(yandex_search_config)