Add multiple fallback paths for model system prompt and enhanced logging

Co-authored-by: owndev <69784886+owndev@users.noreply.github.com>

Author: Copilot

docs/google-gemini-integration.md

@@ -259,7 +259,10 @@ The Google Gemini pipeline supports a hierarchical system prompt configuration t
 
 1. **Default System Prompt** (`GOOGLE_DEFAULT_SYSTEM_PROMPT`): Global default applied to all chats, configurable via environment variable or Admin UI valves.
 
-2. **Model System Prompt**: The system prompt configured in the model settings (Admin > Models > Select Model > System Prompt). This is accessed via `__model__["info"]["params"]["system"]`.
+2. **Model System Prompt**: The system prompt configured in the model settings (Admin > Models > Select Model > System Prompt). The pipeline attempts to retrieve this from multiple sources in order:
+   - `__model__["info"]["params"]["system"]` (primary)
+   - `__model__["params"]["system"]` (alternative)
+   - `__metadata__["chat"]["params"]["system"]` (fallback)
 
 3. **User System Prompt**: The user's personalized system prompt from either:
    - **Chat Controls**: The system message passed with individual chat messages

pipelines/google/google_gemini.py

@@ -321,71 +321,138 @@ def _get_user_personalization_prompt(
         return None
 
     def _get_model_system_prompt(
-        self, __model__: Optional[dict] = None
+        self,
+        __model__: Optional[dict] = None,
+        __metadata__: Optional[dict] = None,
+        body: Optional[dict] = None,
     ) -> Optional[str]:
         """Get the model's system prompt from model settings.
 
         In Open WebUI, each model can have its own system prompt configured
         in Admin > Models > Select Model > System Prompt. This is accessed
-        via __model__["info"]["params"]["system"].
+        via __model__["info"]["params"]["system"] or alternative paths.
 
         Args:
             __model__: The model dict passed to the pipe method
+            __metadata__: The metadata dict passed to the pipe method (fallback)
+            body: The request body (fallback)
 
         Returns:
             The model's system prompt or None if not set
         """
-        if __model__ is None:
-            self.log.debug("__model__ is None - model system prompt not available")
-            return None
+        # Try __model__ first (the official reserved argument)
+        if __model__ is not None:
+            self.log.debug(
+                f"__model__ received: {type(__model__)}, "
+                f"keys: {list(__model__.keys()) if isinstance(__model__, dict) else 'not a dict'}"
+            )
 
-        self.log.debug(f"__model__ received: {type(__model__)}, keys: {list(__model__.keys()) if isinstance(__model__, dict) else 'not a dict'}")
+            try:
+                # Try path: __model__["info"]["params"]["system"]
+                info = __model__.get("info")
+                if info and isinstance(info, dict):
+                    self.log.debug(f"__model__['info'] keys: {list(info.keys())}")
+                    params = info.get("params")
+                    if params and isinstance(params, dict):
+                        self.log.debug(
+                            f"__model__['info']['params'] keys: {list(params.keys())}"
+                        )
+                        system_prompt = params.get("system")
+                        if system_prompt and isinstance(system_prompt, str):
+                            self.log.debug(
+                                f"Found model system prompt via __model__['info']['params']['system'] ({len(system_prompt)} chars)"
+                            )
+                            return system_prompt.strip() or None
 
-        try:
-            info = __model__.get("info")
-            if info and isinstance(info, dict):
-                self.log.debug(f"__model__['info'] keys: {list(info.keys())}")
-                params = info.get("params")
+                # Try alternative path: __model__["params"]["system"] (directly)
+                params = __model__.get("params")
                 if params and isinstance(params, dict):
-                    self.log.debug(f"__model__['info']['params'] keys: {list(params.keys())}")
+                    self.log.debug(f"__model__['params'] keys: {list(params.keys())}")
                     system_prompt = params.get("system")
                     if system_prompt and isinstance(system_prompt, str):
-                        self.log.debug(f"Found model system prompt ({len(system_prompt)} chars)")
+                        self.log.debug(
+                            f"Found model system prompt via __model__['params']['system'] ({len(system_prompt)} chars)"
+                        )
                         return system_prompt.strip() or None
-                    else:
-                        self.log.debug("No system prompt in __model__['info']['params']['system']")
-                else:
-                    self.log.debug("No params in __model__['info']")
-            else:
-                self.log.debug("No info in __model__")
-        except Exception as e:
-            self.log.debug(f"Could not retrieve model system prompt: {e}")
+            except Exception as e:
+                self.log.debug(f"Could not retrieve model system prompt from __model__: {e}")
+        else:
+            self.log.debug("__model__ is None - trying fallback paths")
+
+        # Fallback: Try __metadata__["chat"]["params"]["system"]
+        if __metadata__ is not None:
+            self.log.debug(
+                f"__metadata__ keys: {list(__metadata__.keys()) if isinstance(__metadata__, dict) else 'not a dict'}"
+            )
+            try:
+                chat = __metadata__.get("chat")
+                if chat and isinstance(chat, dict):
+                    self.log.debug(f"__metadata__['chat'] keys: {list(chat.keys())}")
+                    params = chat.get("params")
+                    if params and isinstance(params, dict):
+                        self.log.debug(
+                            f"__metadata__['chat']['params'] keys: {list(params.keys())}"
+                        )
+                        system_prompt = params.get("system")
+                        if system_prompt and isinstance(system_prompt, str):
+                            self.log.debug(
+                                f"Found model system prompt via __metadata__['chat']['params']['system'] ({len(system_prompt)} chars)"
+                            )
+                            return system_prompt.strip() or None
+            except Exception as e:
+                self.log.debug(f"Could not retrieve model system prompt from __metadata__: {e}")
+
+        # Fallback: Try body["model_info"]["params"]["system"] or similar
+        if body is not None:
+            self.log.debug(f"body keys: {list(body.keys()) if isinstance(body, dict) else 'not a dict'}")
+            try:
+                # Check if model info is embedded in body
+                model_info = body.get("model_info") or body.get("model")
+                if model_info and isinstance(model_info, dict):
+                    self.log.debug(f"body model_info keys: {list(model_info.keys())}")
+                    info = model_info.get("info")
+                    if info and isinstance(info, dict):
+                        params = info.get("params")
+                        if params and isinstance(params, dict):
+                            system_prompt = params.get("system")
+                            if system_prompt and isinstance(system_prompt, str):
+                                self.log.debug(
+                                    f"Found model system prompt via body['model_info']['info']['params']['system'] ({len(system_prompt)} chars)"
+                                )
+                                return system_prompt.strip() or None
+            except Exception as e:
+                self.log.debug(f"Could not retrieve model system prompt from body: {e}")
 
+        self.log.debug("No model system prompt found in any source")
         return None
 
     def _combine_system_prompts(
         self,
         chat_system_prompt: Optional[str],
         __user__: Optional[dict] = None,
         __model__: Optional[dict] = None,
+        __metadata__: Optional[dict] = None,
+        body: Optional[dict] = None,
     ) -> Optional[str]:
         """Combine default, model, and user system prompts.
 
         Prompt hierarchy (all prompts are combined if set):
         1. DEFAULT_SYSTEM_PROMPT (environment/valve setting)
-        2. Model system prompt (from model settings - __model__["info"]["system"])
+        2. Model system prompt (from model settings)
         3. User system prompt (from chat controls OR user settings - chat controls take precedence)
 
         Args:
             chat_system_prompt: The chat-level system prompt from messages (may be None)
             __user__: The user dict passed to the pipe method
             __model__: The model dict passed to the pipe method
+            __metadata__: The metadata dict passed to the pipe method
+            body: The request body
 
         Returns:
             Combined system prompt or None if none are set
         """
         default_prompt = self.valves.DEFAULT_SYSTEM_PROMPT.strip() or None
-        model_prompt = self._get_model_system_prompt(__model__)
+        model_prompt = self._get_model_system_prompt(__model__, __metadata__, body)
         user_personalization = self._get_user_personalization_prompt(__user__)
         chat_prompt = chat_system_prompt.strip() if chat_system_prompt else None
 
@@ -498,6 +565,8 @@ async def _build_image_generation_contents(
         __event_emitter__: Callable,
         __user__: Optional[dict] = None,
         __model__: Optional[dict] = None,
+        __metadata__: Optional[dict] = None,
+        body: Optional[dict] = None,
     ) -> Tuple[List[Dict[str, Any]], Optional[str]]:
         """Construct the contents payload for image-capable models.
 
@@ -511,7 +580,7 @@ async def _build_image_generation_contents(
 
         # Combine with default system prompt if configured
         system_instruction = self._combine_system_prompts(
-            user_system_instruction, __user__, __model__
+            user_system_instruction, __user__, __model__, __metadata__, body
         )
 
         last_user_msg = next(
@@ -975,6 +1044,8 @@ def _prepare_content(
         messages: List[Dict[str, Any]],
         __user__: Optional[dict] = None,
         __model__: Optional[dict] = None,
+        __metadata__: Optional[dict] = None,
+        body: Optional[dict] = None,
     ) -> Tuple[List[Dict[str, Any]], Optional[str]]:
         """
         Prepare messages content for the API and extract system message if present.
@@ -983,6 +1054,8 @@ def _prepare_content(
             messages: List of message objects from the request
             __user__: The user dict passed to the pipe method
             __model__: The model dict passed to the pipe method
+            __metadata__: The metadata dict passed to the pipe method
+            body: The request body
 
         Returns:
             Tuple of (prepared content list, system message string or None)
@@ -995,7 +1068,7 @@ def _prepare_content(
 
         # Combine with default system prompt if configured
         system_message = self._combine_system_prompts(
-            user_system_message, __user__, __model__
+            user_system_message, __user__, __model__, __metadata__, body
         )
 
         # Prepare contents for the API
@@ -2260,7 +2333,7 @@ async def pipe(
                         contents,
                         system_instruction,
                     ) = await self._build_image_generation_contents(
-                        messages, __event_emitter__, __user__, __model__
+                        messages, __event_emitter__, __user__, __model__, __metadata__, body
                     )
                     # For image generation, system_instruction is integrated into the prompt
                     # so it will be None here (this is expected and correct)
@@ -2273,7 +2346,7 @@ async def pipe(
                 # For non-image generation models, use the full conversation history
                 # Prepare content and extract system message normally
                 contents, system_instruction = self._prepare_content(
-                    messages, __user__, __model__
+                    messages, __user__, __model__, __metadata__, body
                 )
                 if not contents:
                     return "Error: No valid message content found"