Merge b5a360be39 into d556ff8df2

* add review padding to explore debug replay api calls

* add semantic search model size widget

disables model_size select with n/a text when an embeddings genai provider is selected

* regenerate zone contours and per-zone filter masks on detect resolution change

* treat null as a clear sentinel in buildOverrides so nullable field edits don't snap back

* extract replay config sheet to new component

* add validation and messages for detect settings

docs/docs/configuration/genai/config.md

@@ -49,15 +49,14 @@ You should have at least 8 GB of RAM available (or VRAM if running on GPU) to ru
 
 ### Model Types: Instruct vs Thinking
 
-Most vision-language models are available as **instruct** models, which are fine-tuned to follow instructions and respond concisely to prompts. However, some models (such as certain Qwen-VL or minigpt variants) offer both **instruct** and **thinking** versions.
+Vision-language models come in **instruct** variants (fine-tuned to follow instructions and respond concisely), **thinking** variants (fine-tuned for free-form, speculative reasoning), and **hybrid** variants that support both modes per request. Most modern vision-language models are hybrid.
 
-- **Instruct models** are always recommended for use with Frigate. These models generate direct, relevant, actionable descriptions that best fit Frigate's object and event summary use case.
-- **Reasoning / Thinking models** are fine-tuned for more free-form, open-ended, and speculative outputs, which are typically not concise and may not provide the practical summaries Frigate expects. For this reason, Frigate does **not** recommend or support using thinking models.
+Frigate manages reasoning per task automatically:
 
-Some models are labeled as **hybrid** (capable of both thinking and instruct tasks). In these cases, it is recommended to disable reasoning / thinking, which is generally model specific (see your models documentation).
+- **Description tasks** (object descriptions, review descriptions, review summaries) are synthesis-only and benefit from concise, direct output, so Frigate disables thinking for these calls when the model exposes a per-request toggle.
+- **Chat** lets you toggle thinking on or off from the composer when the configured model supports it.
 
-**Recommendation:**
-Always select the `-instruct` or documented instruct/tagged variant of any model you use in your Frigate configuration. If in doubt, refer to your model provider's documentation or model library for guidance on the correct model variant to use.
+You can use a pure instruct, hybrid, or thinking-capable model with Frigate — no extra configuration is required to disable thinking for descriptions.
 
 ### llama.cpp
 

docs/docs/configuration/review.md

@@ -23,7 +23,7 @@ In 0.14 and later, all of that is bundled into a single review item which starts
 
 ## Alerts and Detections
 
-Not every segment of video captured by Frigate may be of the same level of interest to you. Video of people who enter your property may be a different priority than those walking by on the sidewalk. For this reason, Frigate 0.14 categorizes review items as _alerts_ and _detections_. By default, all person and car objects are considered alerts. You can refine categorization of your review items by configuring required zones for them.
+Not every segment of video captured by Frigate may be of the same level of interest to you. Video of people who enter your property may be a different priority than those walking by on the sidewalk. For this reason, Frigate categorizes review items as _alerts_ and _detections_. By default, all person and car objects are considered alerts. You can refine categorization of your review items by configuring required zones for them.
 
 :::note
 

docs/docs/troubleshooting/dummy-camera.md

@@ -56,6 +56,7 @@ Only one replay session can be active at a time. If a session is already running
 - The replay will not always produce identical results to the original run. Different frames may be selected on replay, which can change detections and tracking.
 - Motion detection depends on the exact frames used; small frame shifts can change motion regions and therefore what gets passed to the detector.
 - Object detection is not fully deterministic: models and post-processing can yield slightly different results across runs.
+- In cases where a detection is short and a replay may only be a small number of frames, it is recommended to manually add some padding before and after the detection so that the motion and object detectors have time to settle into the scene. Rather than starting Debug Replay from Explore, navigate to History for your camera, choose Debug Replay from the Actions menu, and click the "From Timeline" or "Custom" option.
 
 Treat the replay as a close approximation rather than an exact reproduction. Run multiple loops and examine the debug overlays and logs to understand the behavior.
 

frigate/api/app.py

@@ -43,6 +43,7 @@ from frigate.config.camera.updater import (
     CameraConfigUpdateEnum,
     CameraConfigUpdateTopic,
 )
+from frigate.const import REDACTED_CREDENTIAL_SENTINEL
 from frigate.ffmpeg_presets import FFMPEG_HWACCEL_VAAPI, _gpu_selector
 from frigate.genai import PROVIDERS, load_providers
 from frigate.jobs.media_sync import (
@@ -61,7 +62,11 @@ from frigate.util.builtin import (
     process_config_query_string,
     update_yaml_file_bulk,
 )
-from frigate.util.config import apply_section_update, find_config_file
+from frigate.util.config import (
+    apply_section_update,
+    find_config_file,
+    redact_credential,
+)
 from frigate.util.schema import get_config_schema
 from frigate.util.services import (
     get_nvidia_driver_info,
@@ -284,26 +289,24 @@ def config(request: Request):
     if request.headers.get("remote-role") != "admin":
         config.pop("environment_vars", None)
 
-    # remove mqtt credentials
-    config["mqtt"].pop("password", None)
-    config["mqtt"].pop("user", None)
+    # redact mqtt credentials
+    redact_credential(config["mqtt"], "password")
 
-    # remove the proxy secret
-    config["proxy"].pop("auth_secret", None)
+    # redact proxy secret
+    redact_credential(config["proxy"], "auth_secret")
 
-    # remove genai api keys
-    for genai_name, genai_cfg in config.get("genai", {}).items():
+    # redact genai api keys
+    for _genai_name, genai_cfg in config.get("genai", {}).items():
         if isinstance(genai_cfg, dict):
-            genai_cfg.pop("api_key", None)
+            redact_credential(genai_cfg, "api_key")
 
     for camera_name, camera in request.app.frigate_config.cameras.items():
         camera_dict = config["cameras"][camera_name]
 
-        # remove onvif credentials
+        # redact onvif credentials
         onvif_dict = camera_dict.get("onvif", {})
         if onvif_dict:
-            onvif_dict.pop("user", None)
-            onvif_dict.pop("password", None)
+            redact_credential(onvif_dict, "password")
 
         # clean paths
         for input in camera_dict.get("ffmpeg", {}).get("inputs", []):
@@ -680,6 +683,10 @@ def _config_set_in_memory(request: Request, body: AppConfigSetBody) -> JSONRespo
             _restore_masked_camera_paths(body.config_data, request.app.frigate_config)
             updates = flatten_config_data(body.config_data)
             updates = {k: ("" if v is None else v) for k, v in updates.items()}
+            # Drop any field whose value is still the redaction sentinel
+            updates = {
+                k: v for k, v in updates.items() if v != REDACTED_CREDENTIAL_SENTINEL
+            }
 
         if not updates:
             return JSONResponse(
@@ -743,6 +750,40 @@ def _config_set_in_memory(request: Request, body: AppConfigSetBody) -> JSONRespo
                     settings,
                 )
 
+                # detect resize also republishes motion + objects so other
+                # processes pick up the rebuilt masks, and fires refresh so
+                # the camera maintainer recycles the camera process to pick
+                # up the new ffmpeg cmd / SHM sizing
+                if field == "detect":
+                    cam_cfg = config.cameras.get(camera)
+                    if cam_cfg is not None:
+                        if cam_cfg.motion is not None:
+                            request.app.config_publisher.publish_update(
+                                CameraConfigUpdateTopic(
+                                    CameraConfigUpdateEnum.motion, camera
+                                ),
+                                cam_cfg.motion,
+                            )
+                        request.app.config_publisher.publish_update(
+                            CameraConfigUpdateTopic(
+                                CameraConfigUpdateEnum.objects, camera
+                            ),
+                            cam_cfg.objects,
+                        )
+                        if cam_cfg.zones:
+                            request.app.config_publisher.publish_update(
+                                CameraConfigUpdateTopic(
+                                    CameraConfigUpdateEnum.zones, camera
+                                ),
+                                cam_cfg.zones,
+                            )
+                        request.app.config_publisher.publish_update(
+                            CameraConfigUpdateTopic(
+                                CameraConfigUpdateEnum.refresh, camera
+                            ),
+                            cam_cfg,
+                        )
+
         return JSONResponse(
             content={"success": True, "message": "Config applied in-memory"},
             status_code=200,
@@ -790,6 +831,13 @@ def config_set(request: Request, body: AppConfigSetBody):
                     updates = flatten_config_data(body.config_data)
                     # Convert None values to empty strings for deletion (e.g., when deleting masks)
                     updates = {k: ("" if v is None else v) for k, v in updates.items()}
+                    # Drop sentinel-valued fields so untouched credential
+                    # placeholders don't clobber the saved YAML value.
+                    updates = {
+                        k: v
+                        for k, v in updates.items()
+                        if v != REDACTED_CREDENTIAL_SENTINEL
+                    }
 
                 if not updates:
                     return JSONResponse(

frigate/api/chat.py

@@ -1173,6 +1173,7 @@ async def chat_completion(
                     messages=conversation,
                     tools=tools if tools else None,
                     tool_choice="auto",
+                    enable_thinking=body.enable_thinking,
                 ):
                     if await request.is_disconnected():
                         logger.debug("Client disconnected, stopping chat stream")
@@ -1267,6 +1268,7 @@ async def chat_completion(
                 messages=conversation,
                 tools=tools if tools else None,
                 tool_choice="auto",
+                enable_thinking=body.enable_thinking,
             )
 
             if response.get("finish_reason") == "error":

frigate/api/debug_replay.py

@@ -86,10 +86,15 @@ class DebugReplayStopResponse(BaseModel):
 async def start_debug_replay(request: Request, body: DebugReplayStartBody):
     """Start a debug replay session asynchronously."""
     replay_manager = request.app.replay_manager
+    internal_port = request.app.frigate_config.networking.listen.internal
+    if type(internal_port) is str:
+        internal_port = int(internal_port.split(":")[-1])
+
     source = RecordingDebugReplaySource(
         source_camera=body.camera,
         start_ts=body.start_time,
         end_ts=body.end_time,
+        internal_port=internal_port,
     )
 
     try:

frigate/api/defs/request/chat_body.py

@@ -36,3 +36,10 @@ class ChatCompletionRequest(BaseModel):
         default=False,
         description="If true, stream the final assistant response in the body as newline-delimited JSON.",
     )
+    enable_thinking: Optional[bool] = Field(
+        default=None,
+        description=(
+            "Per-request thinking toggle. None means use the provider default. "
+            "Ignored by providers that do not expose a per-request thinking switch."
+        ),
+    )

frigate/camera/maintainer.py

@@ -14,6 +14,7 @@ from frigate.config.camera.updater import (
     CameraConfigUpdateEnum,
     CameraConfigUpdateSubscriber,
 )
+from frigate.const import REPLAY_CAMERA_PREFIX
 from frigate.models import Regions
 from frigate.util.builtin import empty_and_close_queue
 from frigate.util.image import SharedMemoryFrameManager, UntrackedSharedMemory
@@ -50,6 +51,7 @@ class CameraMaintainer(threading.Thread):
             [
                 CameraConfigUpdateEnum.add,
                 CameraConfigUpdateEnum.remove,
+                CameraConfigUpdateEnum.refresh,
             ],
         )
         self.shm_count = self.__calculate_shm_frame_count()
@@ -202,6 +204,25 @@ class CameraMaintainer(threading.Thread):
                 capture_process.terminate()
                 capture_process.join()
 
+    def __unlink_camera_frame_slots(self, camera: str) -> None:
+        """Drop the camera's per-frame YUV SHM segments from this
+        process's frame_manager and unlink them at the OS level.
+
+        Safe to call after the camera's capture/processor subprocesses
+        have been joined — they no longer hold mappings, so unlink frees
+        the segments immediately. Other long-lived processes that opened
+        these slots will continue using their existing mappings until
+        they call frame_manager.get with a shape that no longer fits
+        (the get path drops and reopens stale refs).
+        """
+        prefix = f"{camera}_frame"
+        names = [n for n in list(self.frame_manager.shm_store) if n.startswith(prefix)]
+        for name in names:
+            try:
+                self.frame_manager.delete(name)
+            except Exception as exc:
+                logger.debug("Could not unlink SHM %s: %s", name, exc)
+
     def __stop_camera_process(self, camera: str) -> None:
         camera_process = self.camera_processes.get(camera)
         if camera_process is not None:
@@ -253,12 +274,45 @@ class CameraMaintainer(threading.Thread):
                     for camera in updated_cameras:
                         self.__stop_camera_capture_process(camera)
                         self.__stop_camera_process(camera)
+                        self.__unlink_camera_frame_slots(camera)
                         self.capture_processes.pop(camera, None)
                         self.camera_processes.pop(camera, None)
                         self.camera_stop_events.pop(camera, None)
                         self.region_grids.pop(camera, None)
                         self.camera_metrics.pop(camera, None)
                         self.ptz_metrics.pop(camera, None)
+                elif update_type == CameraConfigUpdateEnum.refresh.name:
+                    # Recycle replay cameras so detect width/height/fps
+                    # propagate through ffmpeg args, SHM sizing, and the
+                    # region grid. Regular cameras detect change still
+                    # requires a full restart.
+                    for camera in updated_cameras:
+                        if not camera.startswith(REPLAY_CAMERA_PREFIX):
+                            continue
+
+                        new_config = self.update_subscriber.camera_configs.get(camera)
+                        if new_config is None:
+                            # remove arrived in the same batch
+                            continue
+
+                        if (
+                            camera not in self.camera_processes
+                            and camera not in self.capture_processes
+                        ):
+                            continue
+
+                        # rebuild ffmpeg cmds on the shared config so the
+                        # new subprocesses spawn with current args
+                        new_config.recreate_ffmpeg_cmds()
+
+                        self.__stop_camera_capture_process(camera)
+                        self.__stop_camera_process(camera)
+                        self.__unlink_camera_frame_slots(camera)
+                        self.capture_processes.pop(camera, None)
+                        self.camera_processes.pop(camera, None)
+
+                        self.__start_camera_processor(camera, new_config, runtime=True)
+                        self.__start_camera_capture(camera, new_config, runtime=True)
 
         # ensure the capture processes are done
         for camera in self.capture_processes.keys():

frigate/camera/state.py

@@ -45,6 +45,7 @@ class CameraState:
         self.frame_cache: dict[float, dict[str, Any]] = {}
         self.zone_objects: defaultdict[str, list[Any]] = defaultdict(list)
         self._current_frame = np.zeros(self.camera_config.frame_shape_yuv, np.uint8)
+        self._last_frame_shape: tuple[int, int] = self.camera_config.frame_shape_yuv
         self.current_frame_lock = threading.Lock()
         self.current_frame_time = 0.0
         self.motion_boxes: list[tuple[int, int, int, int]] = []
@@ -303,6 +304,42 @@ class CameraState:
     def on(self, event_type: str, callback: Callable[..., Any]) -> None:
         self.callbacks[event_type].append(callback)
 
+    def _discard_stale_resolution_state(
+        self, current_detections: dict[str, dict[str, Any]]
+    ) -> bool:
+        """Drop tracked state when the camera's detect resolution has
+        changed, and signal the caller to skip this batch if it contains
+        out-of-bounds boxes from the pre-recycle detect process.
+
+        Returns True when the batch should be skipped entirely.
+        """
+        # detect resolution changed — drop tracked state so old-grid
+        # boxes don't leak through end-callbacks
+        current_shape = self.camera_config.frame_shape_yuv
+        if current_shape != self._last_frame_shape:
+            logger.debug(
+                f"{self.name}: detect resolution changed {self._last_frame_shape} -> {current_shape}, dropping tracked state"
+            )
+            with self.current_frame_lock:
+                self.tracked_objects.clear()
+                self.motion_boxes = []
+                self.regions = []
+            self._last_frame_shape = current_shape
+
+        # drop in-flight batches from the pre-recycle detect process
+        # whose boxes exceed the current detect resolution
+        detect = self.camera_config.detect
+        if detect.width is not None and detect.height is not None:
+            for obj in current_detections.values():
+                box = obj.get("box")
+                if box and (box[2] > detect.width or box[3] > detect.height):
+                    logger.debug(
+                        f"{self.name}: dropping stale-resolution detection batch (box {box} exceeds {detect.width}x{detect.height})"
+                    )
+                    return True
+
+        return False
+
     def update(
         self,
         frame_name: str,
@@ -311,6 +348,9 @@ class CameraState:
         motion_boxes: list[tuple[int, int, int, int]],
         regions: list[tuple[int, int, int, int]],
     ) -> None:
+        if self._discard_stale_resolution_state(current_detections):
+            return
+
         current_frame = self.frame_manager.get(
             frame_name, self.camera_config.frame_shape_yuv
         )
@@ -332,14 +372,18 @@ class CameraState:
                 current_detections[id],
             )
 
-            # add initial frame to frame cache
-            logger.debug(
-                f"{self.name}: New object, adding {frame_time} to frame cache for {id}"
-            )
-            self.frame_cache[frame_time] = {
-                "frame": np.copy(current_frame),  # type: ignore[arg-type]
-                "object_id": id,
-            }
+            # Skip caching when the frame buffer isn't readable — e.g.
+            # frame_manager.get returned None because the SHM segment was
+            # unlinked or hasn't been recreated yet during a camera
+            # add/remove cycle.
+            if current_frame is not None:
+                logger.debug(
+                    f"{self.name}: New object, adding {frame_time} to frame cache for {id}"
+                )
+                self.frame_cache[frame_time] = {
+                    "frame": np.copy(current_frame),
+                    "object_id": id,
+                }
 
             # save initial thumbnail data and best object
             thumbnail_data = {

frigate/config/camera/updater.py

@@ -26,6 +26,7 @@ class CameraConfigUpdateEnum(str, Enum):
     object_genai = "object_genai"
     onvif = "onvif"
     record = "record"
+    refresh = "refresh"  # signals the camera maintainer to recycle the camera process
     remove = "remove"  # for removing a camera
     review = "review"
     review_genai = "review_genai"
@@ -84,8 +85,8 @@ class CameraConfigUpdateSubscriber:
         self, camera: str, update_type: CameraConfigUpdateEnum, updated_config: Any
     ) -> None:
         if update_type == CameraConfigUpdateEnum.add:
-            self.config.cameras[camera] = updated_config
-            self.camera_configs[camera] = updated_config
+            shared = self.config.cameras.setdefault(camera, updated_config)
+            self.camera_configs[camera] = shared
             return
         elif update_type == CameraConfigUpdateEnum.remove:
             self.config.cameras.pop(camera, None)

frigate/const.py

@@ -21,6 +21,8 @@ PLUS_API_HOST = "https://api.frigate.video"
 
 SHM_FRAMES_VAR = "SHM_MAX_FRAMES"
 
+REDACTED_CREDENTIAL_SENTINEL = "__FRIGATE_SAVED_CREDENTIAL__"
+
 # Attribute & Object constants
 
 DEFAULT_ATTRIBUTE_LABEL_MAP = {

frigate/debug_replay.py

@@ -169,6 +169,7 @@ class DebugReplayManager:
                     CameraConfigUpdateTopic(CameraConfigUpdateEnum.remove, replay_name),
                     frigate_config.cameras[replay_name],
                 )
+                frigate_config.cameras.pop(replay_name, None)
 
             if replay_name is not None:
                 self._cleanup_db(replay_name)
@@ -237,6 +238,10 @@ class DebugReplayManager:
             zone_dump.setdefault("coordinates", zone_config.coordinates)
             zones_dict[zone_name] = zone_dump
 
+        # Extract LPR and face recognition configs
+        lpr_dict = source_config.lpr.model_dump()
+        face_recognition_dict = source_config.face_recognition.model_dump()
+
         # Extract motion config (exclude runtime fields)
         motion_dict = {}
         if source_config.motion is not None:
@@ -245,11 +250,23 @@ class DebugReplayManager:
                     "frame_shape",
                     "raw_mask",
                     "mask",
-                    "improved_contrast_enabled",
+                    "enabled_in_config",
                     "rasterized_mask",
                 }
             )
 
+            if source_config.motion.mask:
+                motion_dict["mask"] = {
+                    mask_id: (
+                        mask_cfg.model_dump(
+                            exclude={"raw_coordinates", "enabled_in_config"}
+                        )
+                        if mask_cfg is not None
+                        else None
+                    )
+                    for mask_id, mask_cfg in source_config.motion.mask.items()
+                }
+
         return {
             "enabled": True,
             "ffmpeg": {
@@ -274,8 +291,8 @@ class DebugReplayManager:
             },
             "birdseye": {"enabled": False},
             "audio": {"enabled": False},
-            "lpr": {"enabled": False},
-            "face_recognition": {"enabled": False},
+            "lpr": lpr_dict,
+            "face_recognition": face_recognition_dict,
         }
 
     def _cleanup_db(self, camera_name: str) -> None:

frigate/embeddings/maintainer.py

@@ -98,10 +98,17 @@ class EmbeddingMaintainer(threading.Thread):
             [
                 CameraConfigUpdateEnum.add,
                 CameraConfigUpdateEnum.remove,
+                CameraConfigUpdateEnum.detect,
+                CameraConfigUpdateEnum.face_recognition,
+                CameraConfigUpdateEnum.ffmpeg,
+                CameraConfigUpdateEnum.lpr,
+                CameraConfigUpdateEnum.motion,
+                CameraConfigUpdateEnum.objects,
                 CameraConfigUpdateEnum.object_genai,
                 CameraConfigUpdateEnum.review,
                 CameraConfigUpdateEnum.review_genai,
                 CameraConfigUpdateEnum.semantic_search,
+                CameraConfigUpdateEnum.zones,
             ],
         )
         self.enrichment_config_subscriber = ConfigSubscriber("config/")

frigate/genai/__init__.py

@@ -5,7 +5,7 @@ import json
 import logging
 import os
 import re
-from typing import Any, Callable, Optional
+from typing import Any, AsyncGenerator, Callable, Optional
 
 import numpy as np
 from pydantic import ValidationError
@@ -222,8 +222,15 @@ class GenAIClient:
         prompt: str,
         images: list[bytes],
         response_format: Optional[dict] = None,
+        enable_thinking: bool = False,
     ) -> Optional[str]:
-        """Submit a request to the provider."""
+        """Submit a request to the provider.
+
+        ``enable_thinking`` is honored only by providers that report
+        ``supports_toggleable_thinking``. Description-style callers leave it
+        at the default (off) since synthesis tasks don't benefit from
+        reasoning traces.
+        """
         return None
 
     @property
@@ -235,6 +242,11 @@ class GenAIClient:
         """
         return True
 
+    @property
+    def supports_toggleable_thinking(self) -> bool:
+        """Whether the configured model exposes a per-request thinking toggle."""
+        return False
+
     def list_models(self) -> list[str]:
         """Return the list of model names available from this provider.
 
@@ -278,6 +290,7 @@ class GenAIClient:
         messages: list[dict[str, Any]],
         tools: Optional[list[dict[str, Any]]] = None,
         tool_choice: Optional[str] = "auto",
+        enable_thinking: Optional[bool] = None,
     ) -> dict[str, Any]:
         """
         Send chat messages to LLM with optional tool definitions.
@@ -301,7 +314,9 @@ class GenAIClient:
                 - 'none': Model must not call tools
                 - 'required': Model must call at least one tool
                 - Or a dict specifying a specific tool to call
-            **kwargs: Additional provider-specific parameters.
+            enable_thinking: Per-request thinking toggle. None means use the
+                provider default. Ignored by providers without a per-request
+                toggle (see `supports_toggleable_thinking`).
 
         Returns:
             Dictionary with:
@@ -344,6 +359,41 @@ class GenAIClient:
             "finish_reason": "error",
         }
 
+    async def chat_with_tools_stream(
+        self,
+        messages: list[dict[str, Any]],
+        tools: Optional[list[dict[str, Any]]] = None,
+        tool_choice: Optional[str] = "auto",
+        enable_thinking: Optional[bool] = None,
+    ) -> AsyncGenerator[tuple[str, Any], None]:
+        """Streaming counterpart to `chat_with_tools`.
+
+        Yields ``(kind, value)`` tuples where ``kind`` is one of:
+            - 'content_delta': value is a string fragment of the answer
+            - 'reasoning_delta': value is a string fragment of the reasoning
+              trace (emitted before content for thinking models)
+            - 'stats': value is a usage stats dict
+            - 'message': value is the final dict shape described in
+              `chat_with_tools`
+
+        Argument semantics — including ``enable_thinking`` — match
+        `chat_with_tools`. Providers that don't support streaming should
+        override this and yield an error 'message' event.
+        """
+        logger.warning(
+            f"{self.__class__.__name__} does not support chat_with_tools_stream. "
+            "This method should be overridden by the provider implementation."
+        )
+        yield (
+            "message",
+            {
+                "content": None,
+                "reasoning": None,
+                "tool_calls": None,
+                "finish_reason": "error",
+            },
+        )
+
 
 def load_providers() -> None:
     plugins_dir = os.path.join(os.path.dirname(__file__), "plugins")

frigate/genai/manager.py

@@ -6,7 +6,7 @@ no chat feature is active) are never initialized.
 """
 
 import logging
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 from frigate.config import FrigateConfig
 from frigate.config.camera.genai import GenAIConfig, GenAIRoleEnum
@@ -108,11 +108,16 @@ class GenAIClientManager:
         name = self._role_map.get(GenAIRoleEnum.embeddings)
         return self._get_client(name) if name else None
 
-    def list_models(self) -> dict[str, list[str]]:
-        """Return available models keyed by config entry name."""
-        result: dict[str, list[str]] = {}
-        for name in self._configs:
+    def list_models(self) -> dict[str, dict[str, Any]]:
+        """Return per-entry model lists and capabilities, keyed by config entry name."""
+        result: dict[str, dict[str, Any]] = {}
+        for name, genai_cfg in self._configs.items():
             client = self._get_client(name)
-            if client:
-                result[name] = client.list_models()
+            if not client:
+                continue
+            result[name] = {
+                "models": client.list_models(),
+                "roles": [r.value for r in genai_cfg.roles],
+                "supports_toggleable_thinking": client.supports_toggleable_thinking,
+            }
         return result

frigate/genai/plugins/gemini.py

@@ -1,5 +1,7 @@
 """Gemini Provider for Frigate AI."""
 
+import base64
+import binascii
 import json
 import logging
 from typing import Any, AsyncGenerator, Optional
@@ -14,6 +16,27 @@ from frigate.genai import GenAIClient, register_genai_provider
 logger = logging.getLogger(__name__)
 
 
+def _decode_thought_signature(value: Any) -> Optional[bytes]:
+    """Decode a base64-encoded thought_signature carried across conversation turns."""
+    if not value:
+        return None
+    if isinstance(value, bytes):
+        return value
+    if isinstance(value, str):
+        try:
+            return base64.b64decode(value)
+        except (binascii.Error, ValueError):
+            return None
+    return None
+
+
+def _encode_thought_signature(signature: Optional[bytes]) -> Optional[str]:
+    """Encode bytes thought_signature as base64 so it survives JSON-friendly transport."""
+    if not signature:
+        return None
+    return base64.b64encode(signature).decode("ascii")
+
+
 def _stats_from_gemini_usage(usage: Any) -> Optional[dict[str, Any]]:
     """Build a stats dict from a Gemini usage_metadata object."""
     prompt_tokens = getattr(usage, "prompt_token_count", None)
@@ -62,6 +85,7 @@ class GeminiClient(GenAIClient):
         prompt: str,
         images: list[bytes],
         response_format: Optional[dict] = None,
+        enable_thinking: bool = False,
     ) -> Optional[str]:
         """Submit a request to Gemini."""
         contents = [prompt] + [
@@ -119,11 +143,14 @@ class GeminiClient(GenAIClient):
         messages: list[dict[str, Any]],
         tools: Optional[list[dict[str, Any]]] = None,
         tool_choice: Optional[str] = "auto",
+        enable_thinking: Optional[bool] = None,
     ) -> dict[str, Any]:
         """
         Send chat messages to Gemini with optional tool definitions.
 
-        Implements function calling/tool usage for Gemini models.
+        Implements function calling/tool usage for Gemini models. Thinking is
+        configured at the model level for Gemini, so ``enable_thinking`` is
+        accepted for interface parity and ignored.
         """
         try:
             # Convert messages to Gemini format
@@ -165,11 +192,17 @@ class GeminiClient(GenAIClient):
                         if not isinstance(tc_args, dict):
                             tc_args = {}
                         if tc_name:
-                            parts.append(
-                                types.Part.from_function_call(
-                                    name=tc_name, args=tc_args
-                                )
+                            fc_part = types.Part.from_function_call(
+                                name=tc_name, args=tc_args
                             )
+                            # Thinking-capable Gemini models require the original
+                            # thought_signature to be echoed back on functionCall
+                            # parts after a tool response, or the next request
+                            # fails with INVALID_ARGUMENT.
+                            sig = _decode_thought_signature(tc.get("thought_signature"))
+                            if sig:
+                                fc_part.thought_signature = sig
+                            parts.append(fc_part)
                     if not parts:
                         parts.append(types.Part.from_text(text=" "))
                     gemini_messages.append(types.Content(role="model", parts=parts))
@@ -306,6 +339,9 @@ class GeminiClient(GenAIClient):
                                 "id": part.function_call.name or "",
                                 "name": part.function_call.name or "",
                                 "arguments": arguments,
+                                "thought_signature": _encode_thought_signature(
+                                    getattr(part, "thought_signature", None)
+                                ),
                             }
                         )
 
@@ -365,11 +401,14 @@ class GeminiClient(GenAIClient):
         messages: list[dict[str, Any]],
         tools: Optional[list[dict[str, Any]]] = None,
         tool_choice: Optional[str] = "auto",
+        enable_thinking: Optional[bool] = None,
     ) -> AsyncGenerator[tuple[str, Any], None]:
         """
         Stream chat with tools; yields content deltas then final message.
 
         Implements streaming function calling/tool usage for Gemini models.
+        ``enable_thinking`` is accepted for interface parity; Gemini configures
+        thinking at the model level, so it is ignored here.
         """
         try:
             # Convert messages to Gemini format
@@ -411,11 +450,17 @@ class GeminiClient(GenAIClient):
                         if not isinstance(tc_args, dict):
                             tc_args = {}
                         if tc_name:
-                            parts.append(
-                                types.Part.from_function_call(
-                                    name=tc_name, args=tc_args
-                                )
+                            fc_part = types.Part.from_function_call(
+                                name=tc_name, args=tc_args
                             )
+                            # Thinking-capable Gemini models require the original
+                            # thought_signature to be echoed back on functionCall
+                            # parts after a tool response, or the next request
+                            # fails with INVALID_ARGUMENT.
+                            sig = _decode_thought_signature(tc.get("thought_signature"))
+                            if sig:
+                                fc_part.thought_signature = sig
+                            parts.append(fc_part)
                     if not parts:
                         parts.append(types.Part.from_text(text=" "))
                     gemini_messages.append(types.Content(role="model", parts=parts))
@@ -581,6 +626,7 @@ class GeminiClient(GenAIClient):
                                     "id": tool_call_id,
                                     "name": tool_call_name,
                                     "arguments": "",
+                                    "thought_signature": None,
                                 }
 
                             # Accumulate arguments
@@ -591,6 +637,13 @@ class GeminiClient(GenAIClient):
                                     else str(arguments)
                                 )
 
+                            # Capture latest thought_signature for this call
+                            chunk_sig = getattr(part, "thought_signature", None)
+                            if chunk_sig:
+                                tool_calls_by_index[found_index][
+                                    "thought_signature"
+                                ] = chunk_sig
+
             # Build final message
             full_content = "".join(content_parts).strip() or None
             full_reasoning = "".join(reasoning_parts).strip() or None
@@ -611,6 +664,9 @@ class GeminiClient(GenAIClient):
                             "id": tc["id"],
                             "name": tc["name"],
                             "arguments": parsed_args,
+                            "thought_signature": _encode_thought_signature(
+                                tc.get("thought_signature")
+                            ),
                         }
                     )
                 finish_reason = "tool_calls"

frigate/genai/plugins/llama_cpp.py

@@ -122,6 +122,7 @@ class LlamaCppClient(GenAIClient):
     _supports_vision: bool
     _supports_audio: bool
     _supports_tools: bool
+    _supports_reasoning: bool
     _image_token_cache: dict[tuple[int, int], int]
     _text_baseline_tokens: int | None
     _media_marker: str
@@ -135,6 +136,7 @@ class LlamaCppClient(GenAIClient):
         self._supports_vision = False
         self._supports_audio = False
         self._supports_tools = False
+        self._supports_reasoning = False
         self._image_token_cache = {}
         self._text_baseline_tokens = None
         self._media_marker = "<__media__>"
@@ -164,15 +166,17 @@ class LlamaCppClient(GenAIClient):
         self._supports_vision = info["supports_vision"]
         self._supports_audio = info["supports_audio"]
         self._supports_tools = info["supports_tools"]
+        self._supports_reasoning = info["supports_reasoning"]
         self._media_marker = info["media_marker"]
 
         logger.info(
-            "llama.cpp model '%s' initialized — context: %s, vision: %s, audio: %s, tools: %s",
+            "llama.cpp model '%s' initialized — context: %s, vision: %s, audio: %s, tools: %s, reasoning: %s",
             configured_model,
             self._context_size or "unknown",
             self._supports_vision,
             self._supports_audio,
             self._supports_tools,
+            self._supports_reasoning,
         )
 
         return base_url
@@ -200,6 +204,7 @@ class LlamaCppClient(GenAIClient):
             "supports_vision": False,
             "supports_audio": False,
             "supports_tools": False,
+            "supports_reasoning": False,
             "media_marker": "<__media__>",
         }
 
@@ -279,10 +284,17 @@ class LlamaCppClient(GenAIClient):
                 info["supports_vision"] = bool(modalities.get("vision", False))
                 info["supports_audio"] = bool(modalities.get("audio", False))
 
+            chat_caps = props.get("chat_template_caps") or {}
+
             if not info["supports_tools"]:
-                chat_caps = props.get("chat_template_caps", {})
                 info["supports_tools"] = bool(chat_caps.get("supports_tools", False))
 
+            # llama.cpp does not advertise per-template reasoning support, so
+            # detect it by looking for the `enable_thinking` toggle variable
+            # in the Jinja chat template itself.
+            chat_template = props.get("chat_template") or ""
+            info["supports_reasoning"] = "enable_thinking" in chat_template
+
             media_marker = props.get("media_marker")
             if isinstance(media_marker, str) and media_marker:
                 info["media_marker"] = media_marker
@@ -300,6 +312,7 @@ class LlamaCppClient(GenAIClient):
         prompt: str,
         images: list[bytes],
         response_format: Optional[dict] = None,
+        enable_thinking: bool = False,
     ) -> Optional[str]:
         """Submit a request to llama.cpp server."""
         if self.provider is None:
@@ -327,7 +340,7 @@ class LlamaCppClient(GenAIClient):
                 )
 
             # Build request payload with llama.cpp native options
-            payload = {
+            payload: dict[str, Any] = {
                 "model": self.genai_config.model,
                 "messages": [
                     {
@@ -341,6 +354,9 @@ class LlamaCppClient(GenAIClient):
             if response_format:
                 payload["response_format"] = response_format
 
+            if self.supports_toggleable_thinking:
+                payload["chat_template_kwargs"] = {"enable_thinking": enable_thinking}
+
             response = requests.post(
                 f"{self.provider}/v1/chat/completions",
                 json=payload,
@@ -377,6 +393,10 @@ class LlamaCppClient(GenAIClient):
         """Whether the loaded model supports tool/function calling."""
         return self._supports_tools
 
+    @property
+    def supports_toggleable_thinking(self) -> bool:
+        return self._supports_reasoning
+
     def list_models(self) -> list[str]:
         """Return available model IDs from the llama.cpp server."""
         base_url = self.provider or (
@@ -504,6 +524,7 @@ class LlamaCppClient(GenAIClient):
         tools: Optional[list[dict[str, Any]]],
         tool_choice: Optional[str],
         stream: bool = False,
+        enable_thinking: Optional[bool] = None,
     ) -> dict[str, Any]:
         """Build request payload for chat completions (sync or stream)."""
         openai_tool_choice = None
@@ -519,14 +540,21 @@ class LlamaCppClient(GenAIClient):
             "messages": messages,
             "model": self.genai_config.model,
         }
+
         if stream:
             payload["stream"] = True
             payload["stream_options"] = {"include_usage": True}
             payload["timings_per_token"] = True
+
         if tools:
             payload["tools"] = tools
+
             if openai_tool_choice is not None:
                 payload["tool_choice"] = openai_tool_choice
+
+        if enable_thinking is not None and self._supports_reasoning:
+            payload["chat_template_kwargs"] = {"enable_thinking": enable_thinking}
+
         provider_opts = {
             k: v for k, v in self.provider_options.items() if k != "context_size"
         }
@@ -732,6 +760,7 @@ class LlamaCppClient(GenAIClient):
         messages: list[dict[str, Any]],
         tools: Optional[list[dict[str, Any]]] = None,
         tool_choice: Optional[str] = "auto",
+        enable_thinking: Optional[bool] = None,
     ) -> dict[str, Any]:
         """
         Send chat messages to llama.cpp server with optional tool definitions.
@@ -749,7 +778,13 @@ class LlamaCppClient(GenAIClient):
                 "finish_reason": "error",
             }
         try:
-            payload = self._build_payload(messages, tools, tool_choice, stream=False)
+            payload = self._build_payload(
+                messages,
+                tools,
+                tool_choice,
+                stream=False,
+                enable_thinking=enable_thinking,
+            )
             response = requests.post(
                 f"{self.provider}/v1/chat/completions",
                 json=payload,
@@ -797,6 +832,7 @@ class LlamaCppClient(GenAIClient):
         messages: list[dict[str, Any]],
         tools: Optional[list[dict[str, Any]]] = None,
         tool_choice: Optional[str] = "auto",
+        enable_thinking: Optional[bool] = None,
     ) -> AsyncGenerator[tuple[str, Any], None]:
         """Stream chat with tools via OpenAI-compatible streaming API."""
         if self.provider is None:
@@ -813,7 +849,13 @@ class LlamaCppClient(GenAIClient):
             )
             return
         try:
-            payload = self._build_payload(messages, tools, tool_choice, stream=True)
+            payload = self._build_payload(
+                messages,
+                tools,
+                tool_choice,
+                stream=True,
+                enable_thinking=enable_thinking,
+            )
             content_parts: list[str] = []
             reasoning_parts: list[str] = []
             tool_calls_by_index: dict[int, dict[str, Any]] = {}

frigate/genai/plugins/ollama.py

@@ -98,6 +98,22 @@ class OllamaClient(GenAIClient):
 
     provider: ApiClient | None
     provider_options: dict[str, Any]
+    _supports_thinking_cache: Optional[bool] = None
+
+    @property
+    def supports_toggleable_thinking(self) -> bool:
+        if self._supports_thinking_cache is not None:
+            return self._supports_thinking_cache
+        if self.provider is None:
+            return False
+        try:
+            response = self.provider.show(self.genai_config.model)
+            capabilities = response.get("capabilities") or []
+            self._supports_thinking_cache = "thinking" in capabilities
+        except Exception as e:
+            logger.debug("Failed to query Ollama model capabilities: %s", e)
+            self._supports_thinking_cache = False
+        return self._supports_thinking_cache
 
     def _auth_headers(self) -> dict | None:
         if self.genai_config.api_key:
@@ -178,6 +194,7 @@ class OllamaClient(GenAIClient):
         prompt: str,
         images: list[bytes],
         response_format: Optional[dict] = None,
+        enable_thinking: bool = False,
     ) -> Optional[str]:
         """Submit a request to Ollama"""
         if self.provider is None:
@@ -194,6 +211,8 @@ class OllamaClient(GenAIClient):
                 schema = response_format.get("json_schema", {}).get("schema")
                 if schema:
                     ollama_options["format"] = self._clean_schema_for_ollama(schema)
+            if self.supports_toggleable_thinking:
+                ollama_options["think"] = enable_thinking
             logger.debug(
                 "Ollama generate request: model=%s, prompt_len=%s, image_count=%s, "
                 "has_format=%s, options=%s",
@@ -274,6 +293,7 @@ class OllamaClient(GenAIClient):
         tools: Optional[list[dict[str, Any]]],
         tool_choice: Optional[str],
         stream: bool = False,
+        enable_thinking: Optional[bool] = None,
     ) -> dict[str, Any]:
         """Build request_messages and params for chat (sync or stream)."""
         request_messages = []
@@ -318,6 +338,8 @@ class OllamaClient(GenAIClient):
             request_params["stream"] = True
         if tools:
             request_params["tools"] = tools
+        if enable_thinking is not None and self.supports_toggleable_thinking:
+            request_params["think"] = enable_thinking
         return request_params
 
     def _message_from_response(self, response: dict[str, Any]) -> dict[str, Any]:
@@ -365,6 +387,7 @@ class OllamaClient(GenAIClient):
         messages: list[dict[str, Any]],
         tools: Optional[list[dict[str, Any]]] = None,
         tool_choice: Optional[str] = "auto",
+        enable_thinking: Optional[bool] = None,
     ) -> dict[str, Any]:
         if self.provider is None:
             logger.warning(
@@ -377,7 +400,11 @@ class OllamaClient(GenAIClient):
             }
         try:
             request_params = self._build_request_params(
-                messages, tools, tool_choice, stream=False
+                messages,
+                tools,
+                tool_choice,
+                stream=False,
+                enable_thinking=enable_thinking,
             )
             response = self.provider.chat(**request_params)
             return self._message_from_response(response)
@@ -401,6 +428,7 @@ class OllamaClient(GenAIClient):
         messages: list[dict[str, Any]],
         tools: Optional[list[dict[str, Any]]] = None,
         tool_choice: Optional[str] = "auto",
+        enable_thinking: Optional[bool] = None,
     ) -> AsyncGenerator[tuple[str, Any], None]:
         """Stream chat with tools; yields content deltas then final message.
 
@@ -430,7 +458,11 @@ class OllamaClient(GenAIClient):
                     "Ollama: tools provided, using non-streaming call for tool support"
                 )
                 request_params = self._build_request_params(
-                    messages, tools, tool_choice, stream=False
+                    messages,
+                    tools,
+                    tool_choice,
+                    stream=False,
+                    enable_thinking=enable_thinking,
                 )
                 async_client = OllamaAsyncClient(
                     host=self.genai_config.base_url,
@@ -452,7 +484,11 @@ class OllamaClient(GenAIClient):
                 return
 
             request_params = self._build_request_params(
-                messages, tools, tool_choice, stream=True
+                messages,
+                tools,
+                tool_choice,
+                stream=True,
+                enable_thinking=enable_thinking,
             )
             async_client = OllamaAsyncClient(
                 host=self.genai_config.base_url,

frigate/genai/plugins/openai.py

@@ -61,6 +61,7 @@ class OpenAIClient(GenAIClient):
         prompt: str,
         images: list[bytes],
         response_format: Optional[dict] = None,
+        enable_thinking: bool = False,
     ) -> Optional[str]:
         """Submit a request to OpenAI."""
         encoded_images = [base64.b64encode(image).decode("utf-8") for image in images]
@@ -187,11 +188,14 @@ class OpenAIClient(GenAIClient):
         messages: list[dict[str, Any]],
         tools: Optional[list[dict[str, Any]]] = None,
         tool_choice: Optional[str] = "auto",
+        enable_thinking: Optional[bool] = None,
     ) -> dict[str, Any]:
         """
         Send chat messages to OpenAI with optional tool definitions.
 
-        Implements function calling/tool usage for OpenAI models.
+        Implements function calling/tool usage for OpenAI models. The OpenAI
+        chat completions API does not expose a per-request thinking toggle,
+        so ``enable_thinking`` is accepted for interface parity and ignored.
         """
         try:
             openai_tool_choice = None
@@ -305,11 +309,15 @@ class OpenAIClient(GenAIClient):
         messages: list[dict[str, Any]],
         tools: Optional[list[dict[str, Any]]] = None,
         tool_choice: Optional[str] = "auto",
+        enable_thinking: Optional[bool] = None,
     ) -> AsyncGenerator[tuple[str, Any], None]:
         """
         Stream chat with tools; yields content deltas then final message.
 
         Implements streaming function calling/tool usage for OpenAI models.
+        The OpenAI chat completions API does not expose a per-request thinking
+        toggle, so ``enable_thinking`` is accepted for interface parity and
+        ignored.
         """
         try:
             openai_tool_choice = None

frigate/genai/prompts.py

@@ -63,8 +63,8 @@ Describe the scene based on observable actions and movements, evaluate the activ
 ## Analysis Guidelines
 
 When forming your description:
-- **CRITICAL: Only describe objects explicitly listed in "Objects in Scene" below.** Do not infer or mention additional people, vehicles, or objects not present in this list, even if visual patterns suggest them. If only a car is listed, do not describe a person interacting with it unless "person" is also in the objects list.
-- **Only describe actions actually visible in the frames.** Do not assume or infer actions that you don't observe happening. If someone walks toward furniture but you never see them sit, do not say they sat. Stick to what you can see across the sequence.
+- **Treat "Objects in Scene" as the list of tracked subjects to describe.** Do not introduce additional people or vehicles that are not present in this list. You may freely reference other items, surfaces, and environmental details visible in the frames when describing what the listed subjects are doing.
+- **Describe the most likely activity from visible cues across the sequence** — the subject's path, what they are carrying, and what they interact with. Avoid asserting completed outcomes you do not observe; describe in-progress actions rather than results.
 - Describe what you observe: actions, movements, interactions with objects and the environment. Include any observable environmental changes (e.g., lighting changes triggered by activity).
 - Note visible details such as clothing, items being carried or placed, tools or equipment present, and how they interact with the property or objects.
 - Consider the full sequence chronologically: what happens from start to finish, how duration and actions relate to the location and objects involved.

frigate/genai/utils.py

@@ -69,6 +69,14 @@ def build_assistant_message_for_conversation(
                     "name": tc["name"],
                     "arguments": json.dumps(tc.get("arguments") or {}),
                 },
+                # Gemini-only: opaque signature that must be echoed back on
+                # the same functionCall part in the next turn. Other providers
+                # do not set or read this.
+                **(
+                    {"thought_signature": tc["thought_signature"]}
+                    if tc.get("thought_signature")
+                    else {}
+                ),
             }
             for tc in tool_calls_raw
         ]

frigate/jobs/debug_replay.py

@@ -1,4 +1,4 @@
-"""Debug replay startup job: ffmpeg concat + camera config publish.
+"""Debug replay startup job: ffmpeg remux + camera config publish.
 
 The runner orchestrates the async portion of starting a debug replay
 session. The DebugReplayManager (in frigate.debug_replay) owns session
@@ -153,15 +153,22 @@ class DebugReplaySource(ABC):
 class RecordingDebugReplaySource(DebugReplaySource):
     """Replay source backed by the Recordings table.
 
-    Builds a concat playlist of recording files covering the time range
-    and feeds it to ffmpeg's concat demuxer.
+    Feeds ffmpeg the internal VOD endpoint so segments with mismatched
+    SPS/PPS (e.g. across day/night transitions) stitch cleanly via HLS
+    discontinuities.
     """
 
-    def __init__(self, source_camera: str, start_ts: float, end_ts: float) -> None:
+    def __init__(
+        self,
+        source_camera: str,
+        start_ts: float,
+        end_ts: float,
+        internal_port: int,
+    ) -> None:
         self._camera = source_camera
         self._start_ts = start_ts
         self._end_ts = end_ts
-        self._concat_file: Optional[str] = None
+        self._internal_port = internal_port
 
     @property
     def source_camera(self) -> str:
@@ -185,18 +192,16 @@ class RecordingDebugReplaySource(DebugReplaySource):
             )
 
     def ffmpeg_input_args(self, working_dir: str) -> list[str]:
-        replay_name = f"{REPLAY_CAMERA_PREFIX}{self._camera}"
-        concat_file = os.path.join(working_dir, f"{replay_name}_concat.txt")
-        recordings = query_recordings(self._camera, self._start_ts, self._end_ts)
-        with open(concat_file, "w") as f:
-            for recording in recordings:
-                f.write(f"file '{recording.path}'\n")
-        self._concat_file = concat_file
-        return ["-f", "concat", "-safe", "0", "-i", concat_file]
-
-    def cleanup(self, working_dir: str) -> None:
-        if self._concat_file:
-            _remove_silent(self._concat_file)
+        playlist_url = (
+            f"http://127.0.0.1:{self._internal_port}/vod/{self._camera}"
+            f"/start/{self._start_ts}/end/{self._end_ts}/index.m3u8"
+        )
+        return [
+            "-protocol_whitelist",
+            "pipe,file,http,tcp",
+            "-i",
+            playlist_url,
+        ]
 
 
 class ExportDebugReplaySource(DebugReplaySource):

frigate/object_detection/base.py

@@ -167,8 +167,9 @@ class DetectorRunner(FrigateProcess):
 
             # detect and send the output
             self.start_time.value = datetime.datetime.now().timestamp()
+            mono_start = time.monotonic()
             detections = object_detector.detect_raw(input_frame)
-            duration = datetime.datetime.now().timestamp() - self.start_time.value
+            duration = time.monotonic() - mono_start
             frame_manager.close(connection_id)
 
             if connection_id not in self.outputs:

frigate/output/birdseye.py

@@ -595,112 +595,92 @@ class BirdsEyeFrameManager:
     ) -> Optional[list[list[Any]]]:
         """Calculate the optimal layout for 2+ cameras."""
 
-        def map_layout(
-            camera_layout: list[list[Any]], row_height: int
-        ) -> tuple[int, int, Optional[list[list[Any]]]]:
-            """Map the calculated layout."""
-            candidate_layout = []
-            starting_x = 0
-            x = 0
-            max_width = 0
-            y = 0
+        def find_available_x(
+            current_x: int,
+            width: int,
+            reserved_ranges: list[tuple[int, int]],
+            max_width: int,
+        ) -> Optional[int]:
+            """Find the first horizontal slot that does not collide with reservations."""
+            x = current_x
 
-            for row in camera_layout:
-                final_row = []
-                max_width = max(max_width, x)
-                x = starting_x
-                for cameras in row:
-                    camera_dims = self.cameras[cameras[0]]["dimensions"].copy()
-                    camera_aspect = cameras[1]
+            for reserved_start, reserved_end in sorted(reserved_ranges):
+                if x >= reserved_end:
+                    continue
 
-                    if camera_dims[1] > camera_dims[0]:
-                        scaled_height = int(row_height * 2)
-                        scaled_width = int(scaled_height * camera_aspect)
-                        starting_x = scaled_width
-                    else:
-                        scaled_height = row_height
-                        scaled_width = int(scaled_height * camera_aspect)
+                if x + width <= reserved_start:
+                    return x
 
-                    # layout is too large
-                    if (
-                        x + scaled_width > self.canvas.width
-                        or y + scaled_height > self.canvas.height
-                    ):
-                        return x + scaled_width, y + scaled_height, None
+                x = max(x, reserved_end)
 
-                    final_row.append((cameras[0], (x, y, scaled_width, scaled_height)))
-                    x += scaled_width
+            if x + width <= max_width:
+                return x
 
-                y += row_height
-                candidate_layout.append(final_row)
-
-            if max_width == 0:
-                max_width = x
-
-            return max_width, y, candidate_layout
-
-        canvas_aspect_x, canvas_aspect_y = self.canvas.get_aspect(coefficient)
-        camera_layout: list[list[Any]] = []
-        camera_layout.append([])
-        starting_x = 0
-        x = starting_x
-        y = 0
-        y_i = 0
-        max_y = 0
-        for camera in cameras_to_add:
-            camera_dims = self.cameras[camera]["dimensions"].copy()
-            camera_aspect_x, camera_aspect_y = self.canvas.get_camera_aspect(
-                camera, camera_dims[0], camera_dims[1]
-            )
-
-            if camera_dims[1] > camera_dims[0]:
-                portrait = True
-            else:
-                portrait = False
-
-            if (x + camera_aspect_x) <= canvas_aspect_x:
-                # insert if camera can fit on current row
-                camera_layout[y_i].append(
-                    (
-                        camera,
-                        camera_aspect_x / camera_aspect_y,
-                    )
-                )
-
-                if portrait:
-                    starting_x = camera_aspect_x
-                else:
-                    max_y = max(
-                        max_y,
-                        camera_aspect_y,
-                    )
-
-                x += camera_aspect_x
-            else:
-                # move on to the next row and insert
-                y += max_y
-                y_i += 1
-                camera_layout.append([])
-                x = starting_x
-
-                if x + camera_aspect_x > canvas_aspect_x:
-                    return None
-
-                camera_layout[y_i].append(
-                    (
-                        camera,
-                        camera_aspect_x / camera_aspect_y,
-                    )
-                )
-                x += camera_aspect_x
-
-        if y + max_y > canvas_aspect_y:
             return None
 
-        row_height = int(self.canvas.height / coefficient)
-        total_width, total_height, standard_candidate_layout = map_layout(
-            camera_layout, row_height
-        )
+        def map_layout(row_height: int) -> tuple[int, int, Optional[list[list[Any]]]]:
+            """Lay out cameras row by row while reserving portrait spans for the next row."""
+            candidate_layout: list[list[Any]] = []
+            reserved_ranges: dict[int, list[tuple[int, int]]] = {}
+            current_row: list[Any] = []
+            row_index = 0
+            row_y = 0
+            row_x = 0
+            max_width = 0
+            max_height = 0
+
+            for camera in cameras_to_add:
+                camera_dims = self.cameras[camera]["dimensions"].copy()
+                camera_aspect_x, camera_aspect_y = self.canvas.get_camera_aspect(
+                    camera, camera_dims[0], camera_dims[1]
+                )
+                portrait = camera_dims[1] > camera_dims[0]
+                scaled_height = row_height * 2 if portrait else row_height
+                scaled_width = int(scaled_height * (camera_aspect_x / camera_aspect_y))
+
+                while True:
+                    x = find_available_x(
+                        row_x,
+                        scaled_width,
+                        reserved_ranges.get(row_index, []),
+                        self.canvas.width,
+                    )
+
+                    if x is not None and row_y + scaled_height <= self.canvas.height:
+                        current_row.append(
+                            (camera, (x, row_y, scaled_width, scaled_height))
+                        )
+                        row_x = x + scaled_width
+                        max_width = max(max_width, row_x)
+                        max_height = max(max_height, row_y + scaled_height)
+
+                        if portrait:
+                            reserved_ranges.setdefault(row_index + 1, []).append(
+                                (x, row_x)
+                            )
+
+                        break
+
+                    if current_row:
+                        candidate_layout.append(current_row)
+                        current_row = []
+
+                    row_index += 1
+                    row_y = row_index * row_height
+                    row_x = 0
+
+                    if row_y + scaled_height > self.canvas.height:
+                        overflow_width = max(max_width, scaled_width)
+                        overflow_height = row_y + scaled_height
+                        return overflow_width, overflow_height, None
+
+            if current_row:
+                candidate_layout.append(current_row)
+
+            return max_width, max_height, candidate_layout
+
+        row_height = max(1, int(self.canvas.height / coefficient))
+        total_width, total_height, standard_candidate_layout = map_layout(row_height)
 
         if not standard_candidate_layout:
             # if standard layout didn't work
@@ -709,9 +689,9 @@ class BirdsEyeFrameManager:
                 total_width / self.canvas.width,
                 total_height / self.canvas.height,
             )
-            row_height = int(row_height / scale_down_percent)
+            row_height = max(1, int(row_height / scale_down_percent))
             total_width, total_height, standard_candidate_layout = map_layout(
-                camera_layout, row_height
+                row_height
             )
 
             if not standard_candidate_layout:
@@ -725,8 +705,8 @@ class BirdsEyeFrameManager:
             1 / (total_width / self.canvas.width),
             1 / (total_height / self.canvas.height),
         )
-        row_height = int(row_height * scale_up_percent)
-        _, _, scaled_layout = map_layout(camera_layout, row_height)
+        row_height = max(1, int(row_height * scale_up_percent))
+        _, _, scaled_layout = map_layout(row_height)
 
         if scaled_layout:
             return scaled_layout

frigate/ptz/autotrack.py

@@ -1331,6 +1331,8 @@ class PtzAutoTracker:
         return self.tracked_object[camera]["region"]
 
     def autotrack_object(self, camera: str, obj: TrackedObject):
+        if camera not in self.config.cameras:
+            return
         camera_config = self.config.cameras[camera]
 
         if camera_config.onvif.autotracking.enabled:

frigate/test/http_api/test_http_app.py

@@ -2,6 +2,7 @@ from unittest.mock import Mock, patch
 
 import frigate.genai
 from frigate.config import GenAIProviderEnum
+from frigate.const import REDACTED_CREDENTIAL_SENTINEL
 from frigate.genai import GenAIClient
 from frigate.models import Event, Recordings, ReviewSegment
 from frigate.stats.emitter import StatsEmitter
@@ -75,6 +76,20 @@ class TestHttpApp(BaseTestHttp):
             assert response.status_code == 200
             assert app.frigate_config.cameras["front_door"].objects.track == ["person"]
 
+    ####################################################################################################################
+    ###################################  Credential redaction sentinel  ################################################
+    ####################################################################################################################
+    def test_config_response_redacts_mqtt_password_with_sentinel(self):
+        self.minimal_config["mqtt"]["user"] = "mqttuser"
+        self.minimal_config["mqtt"]["password"] = "supersecret"
+        app = super().create_app()
+
+        with AuthTestClient(app) as client:
+            response = client.get("/config")
+            assert response.status_code == 200
+            mqtt = response.json()["mqtt"]
+            assert mqtt["password"] == REDACTED_CREDENTIAL_SENTINEL
+
     ####################################################################################################################
     ###################################  POST /genai/probe Endpoint   ##################################################
     ####################################################################################################################

frigate/test/test_birdseye.py

@@ -1,11 +1,64 @@
-"""Test camera user and password cleanup."""
+"""Tests for Birdseye canvas sizing and layout behavior."""
 
 import unittest
+from multiprocessing import Event
 
-from frigate.output.birdseye import get_canvas_shape
+from frigate.config import FrigateConfig
+from frigate.output.birdseye import BirdsEyeFrameManager, get_canvas_shape
 
 
 class TestBirdseye(unittest.TestCase):
+    def _build_manager(
+        self, camera_dimensions: dict[str, tuple[int, int]]
+    ) -> BirdsEyeFrameManager:
+        config = {
+            "mqtt": {"host": "mqtt"},
+            "birdseye": {"width": 1280, "height": 720},
+            "cameras": {},
+        }
+
+        for order, (camera, dimensions) in enumerate(
+            camera_dimensions.items(), start=1
+        ):
+            config["cameras"][camera] = {
+                "ffmpeg": {
+                    "inputs": [
+                        {
+                            "path": f"rtsp://10.0.0.1:554/{camera}",
+                            "roles": ["detect"],
+                        }
+                    ]
+                },
+                "detect": {
+                    "width": dimensions[0],
+                    "height": dimensions[1],
+                    "fps": 5,
+                },
+                "birdseye": {"order": order},
+            }
+
+        return BirdsEyeFrameManager(FrigateConfig(**config), Event())
+
+    def _assert_no_overlaps(
+        self, layout: list[list[tuple[str, tuple[int, int, int, int]]]]
+    ):
+        rectangles = [position for row in layout for _, position in row]
+
+        for index, rect in enumerate(rectangles):
+            x1, y1, width1, height1 = rect
+            for other in rectangles[index + 1 :]:
+                x2, y2, width2, height2 = other
+                overlap = (
+                    x1 < x2 + width2
+                    and x2 < x1 + width1
+                    and y1 < y2 + height2
+                    and y2 < y1 + height1
+                )
+                self.assertFalse(
+                    overlap,
+                    msg=f"Overlapping rectangles found: {rect} and {other}",
+                )
+
     def test_16x9(self):
         """Test 16x9 aspect ratio works as expected for birdseye."""
         width = 1280
@@ -45,3 +98,104 @@ class TestBirdseye(unittest.TestCase):
         canvas_width, canvas_height = get_canvas_shape(width, height)
         assert canvas_width == width  # width will be the same
         assert canvas_height != height
+
+    def test_portrait_camera_does_not_overlap_next_row(self):
+        """Portrait cameras should reserve their real horizontal position on the next row."""
+        manager = self._build_manager(
+            {
+                "cam_a": (1280, 720),
+                "cam_p": (360, 640),
+                "cam_b": (1280, 720),
+                "cam_c": (640, 480),
+            }
+        )
+
+        layout = manager.calculate_layout(["cam_a", "cam_p", "cam_b", "cam_c"], 3)
+
+        self.assertIsNotNone(layout)
+        assert layout is not None
+        self._assert_no_overlaps(layout)
+
+        cam_c = [
+            position for row in layout for camera, position in row if camera == "cam_c"
+        ][0]
+        self.assertEqual(cam_c[0], 0)
+
+    def test_portrait_reservation_only_applies_to_next_row(self):
+        """Portrait reservations should not push later rows after the span ends."""
+        manager = self._build_manager(
+            {
+                "cam_a": (1280, 720),
+                "cam_p": (360, 640),
+                "cam_b": (1280, 720),
+                "cam_c": (1280, 720),
+                "cam_d": (1280, 720),
+                "cam_e": (1280, 720),
+            }
+        )
+
+        layout = manager.calculate_layout(
+            ["cam_a", "cam_p", "cam_b", "cam_c", "cam_d", "cam_e"],
+            3,
+        )
+
+        self.assertIsNotNone(layout)
+        assert layout is not None
+        self._assert_no_overlaps(layout)
+
+        cam_e = [
+            position for row in layout for camera, position in row if camera == "cam_e"
+        ][0]
+        self.assertEqual(cam_e[0], 0)
+
+    def test_multiple_portraits_reserve_distinct_ranges(self):
+        """Multiple portrait cameras in one row should reserve separate spans below them."""
+        manager = self._build_manager(
+            {
+                "cam_a": (640, 480),
+                "cam_p1": (360, 640),
+                "cam_p2": (360, 640),
+                "cam_b": (640, 480),
+                "cam_c": (1280, 720),
+                "cam_d": (640, 480),
+            }
+        )
+
+        layout = manager.calculate_layout(
+            ["cam_a", "cam_p1", "cam_p2", "cam_b", "cam_c", "cam_d"],
+            4,
+        )
+
+        self.assertIsNotNone(layout)
+        assert layout is not None
+        self._assert_no_overlaps(layout)
+
+    def test_two_landscapes_then_portrait_then_two_landscapes(self):
+        """A portrait after two landscapes should reserve only its own tail span."""
+        manager = self._build_manager(
+            {
+                "cam_a": (1280, 720),
+                "cam_b": (1280, 720),
+                "cam_p": (360, 640),
+                "cam_c": (1280, 720),
+                "cam_d": (1280, 720),
+            }
+        )
+
+        layout = manager.calculate_layout(
+            ["cam_a", "cam_b", "cam_p", "cam_c", "cam_d"],
+            3,
+        )
+
+        self.assertIsNotNone(layout)
+        assert layout is not None
+        self._assert_no_overlaps(layout)
+
+        cam_c = [
+            position for row in layout for camera, position in row if camera == "cam_c"
+        ][0]
+        cam_d = [
+            position for row in layout for camera, position in row if camera == "cam_d"
+        ][0]
+        self.assertEqual(cam_c[0], 0)
+        self.assertEqual(cam_d[0], cam_c[0] + cam_c[2])

frigate/test/test_camera_maintainer.py

@@ -0,0 +1,79 @@
+"""Tests for CameraMaintainer SHM cleanup on camera remove.
+
+Regression coverage for the case where a camera is removed and then a
+new camera is added with the same name. Without unlinking the per-frame
+YUV SHM slots, the maintainer's frame_manager.create call hits
+FileExistsError and falls back to reopening the existing segment at the
+*old* size, which the new ffmpeg process then writes mismatched-size
+frames into.
+"""
+
+import unittest
+from unittest.mock import MagicMock, patch
+
+from frigate.camera.maintainer import CameraMaintainer
+
+
+class TestMaintainerUnlinkFrameSlotsOnRemove(unittest.TestCase):
+    def _make_maintainer(self) -> CameraMaintainer:
+        """Build a maintainer without invoking __init__ (avoids needing real
+        FrigateConfig, queues, multiprocessing manager, etc.). We're only
+        exercising the SHM-cleanup helper, so the surrounding init is
+        irrelevant."""
+        maintainer = CameraMaintainer.__new__(CameraMaintainer)
+        maintainer.frame_manager = MagicMock()
+        return maintainer
+
+    def test_unlinks_only_segments_with_matching_prefix(self) -> None:
+        maintainer = self._make_maintainer()
+        maintainer.frame_manager.shm_store = {
+            "front_frame0": object(),
+            "front_frame1": object(),
+            "front_frame2": object(),
+            # Different camera; must not be touched.
+            "side_frame0": object(),
+            # Detector input/output buffers are sized by the model and
+            # cached by the long-lived DetectorRunner — must not be
+            # touched even when their owning camera is removed.
+            "front": object(),
+            "out-front": object(),
+        }
+
+        # __name-mangled access from outside the class.
+        maintainer._CameraMaintainer__unlink_camera_frame_slots("front")
+
+        deleted = [c.args[0] for c in maintainer.frame_manager.delete.call_args_list]
+        self.assertEqual(
+            sorted(deleted),
+            ["front_frame0", "front_frame1", "front_frame2"],
+        )
+
+    def test_handles_camera_with_no_slots(self) -> None:
+        """Cameras that were removed before any frame slot was ever
+        created (e.g. cancelled during preparing_clip) should be a no-op."""
+        maintainer = self._make_maintainer()
+        maintainer.frame_manager.shm_store = {"other_frame0": object()}
+
+        maintainer._CameraMaintainer__unlink_camera_frame_slots("front")
+
+        maintainer.frame_manager.delete.assert_not_called()
+
+    def test_swallows_delete_errors(self) -> None:
+        """Unlink failures shouldn't abort the remove loop — best-effort."""
+        maintainer = self._make_maintainer()
+        maintainer.frame_manager.shm_store = {
+            "front_frame0": object(),
+            "front_frame1": object(),
+        }
+        maintainer.frame_manager.delete.side_effect = OSError("simulated")
+
+        # Both slots are attempted; the OSError on the first doesn't
+        # prevent the second from being tried.
+        with patch("frigate.camera.maintainer.logger"):
+            maintainer._CameraMaintainer__unlink_camera_frame_slots("front")
+
+        self.assertEqual(maintainer.frame_manager.delete.call_count, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

frigate/test/test_debug_replay_job.py

@@ -101,7 +101,10 @@ class TestStartDebugReplayJob(unittest.TestCase):
         with self.assertRaises(ValueError):
             start_debug_replay_job(
                 source=RecordingDebugReplaySource(
-                    source_camera="missing", start_ts=100.0, end_ts=200.0
+                    source_camera="missing",
+                    start_ts=100.0,
+                    end_ts=200.0,
+                    internal_port=5000,
                 ),
                 frigate_config=self.frigate_config,
                 config_publisher=self.publisher,
@@ -112,7 +115,10 @@ class TestStartDebugReplayJob(unittest.TestCase):
         with self.assertRaises(ValueError):
             start_debug_replay_job(
                 source=RecordingDebugReplaySource(
-                    source_camera="front", start_ts=200.0, end_ts=100.0
+                    source_camera="front",
+                    start_ts=200.0,
+                    end_ts=100.0,
+                    internal_port=5000,
                 ),
                 frigate_config=self.frigate_config,
                 config_publisher=self.publisher,
@@ -126,7 +132,10 @@ class TestStartDebugReplayJob(unittest.TestCase):
             with self.assertRaises(ValueError):
                 start_debug_replay_job(
                     source=RecordingDebugReplaySource(
-                        source_camera="front", start_ts=100.0, end_ts=200.0
+                        source_camera="front",
+                        start_ts=100.0,
+                        end_ts=200.0,
+                        internal_port=5000,
                     ),
                     frigate_config=self.frigate_config,
                     config_publisher=self.publisher,
@@ -156,7 +165,10 @@ class TestStartDebugReplayJob(unittest.TestCase):
         ):
             job_id = start_debug_replay_job(
                 source=RecordingDebugReplaySource(
-                    source_camera="front", start_ts=100.0, end_ts=200.0
+                    source_camera="front",
+                    start_ts=100.0,
+                    end_ts=200.0,
+                    internal_port=5000,
                 ),
                 frigate_config=self.frigate_config,
                 config_publisher=self.publisher,
@@ -193,7 +205,10 @@ class TestStartDebugReplayJob(unittest.TestCase):
         ):
             start_debug_replay_job(
                 source=RecordingDebugReplaySource(
-                    source_camera="front", start_ts=100.0, end_ts=200.0
+                    source_camera="front",
+                    start_ts=100.0,
+                    end_ts=200.0,
+                    internal_port=5000,
                 ),
                 frigate_config=self.frigate_config,
                 config_publisher=self.publisher,
@@ -203,7 +218,10 @@ class TestStartDebugReplayJob(unittest.TestCase):
             with self.assertRaises(RuntimeError):
                 start_debug_replay_job(
                     source=RecordingDebugReplaySource(
-                        source_camera="front", start_ts=100.0, end_ts=200.0
+                        source_camera="front",
+                        start_ts=100.0,
+                        end_ts=200.0,
+                        internal_port=5000,
                     ),
                     frigate_config=self.frigate_config,
                     config_publisher=self.publisher,
@@ -271,7 +289,10 @@ class TestRunnerHappyPath(unittest.TestCase):
         ):
             start_debug_replay_job(
                 source=RecordingDebugReplaySource(
-                    source_camera="front", start_ts=100.0, end_ts=200.0
+                    source_camera="front",
+                    start_ts=100.0,
+                    end_ts=200.0,
+                    internal_port=5000,
                 ),
                 frigate_config=self.frigate_config,
                 config_publisher=self.publisher,
@@ -342,7 +363,10 @@ class TestRunnerFailurePath(unittest.TestCase):
         ):
             start_debug_replay_job(
                 source=RecordingDebugReplaySource(
-                    source_camera="front", start_ts=100.0, end_ts=200.0
+                    source_camera="front",
+                    start_ts=100.0,
+                    end_ts=200.0,
+                    internal_port=5000,
                 ),
                 frigate_config=self.frigate_config,
                 config_publisher=self.publisher,
@@ -420,7 +444,10 @@ class TestRunnerCancellation(unittest.TestCase):
         ):
             start_debug_replay_job(
                 source=RecordingDebugReplaySource(
-                    source_camera="front", start_ts=100.0, end_ts=200.0
+                    source_camera="front",
+                    start_ts=100.0,
+                    end_ts=200.0,
+                    internal_port=5000,
                 ),
                 frigate_config=self.frigate_config,
                 config_publisher=self.publisher,

frigate/test/test_shared_memory_frame_manager.py

@@ -0,0 +1,156 @@
+"""Tests for SharedMemoryFrameManager cache invalidation.
+
+Covers the case where a SHM segment is unlinked and recreated at a
+different size across a camera add/remove cycle while a long-lived
+in-process cache (e.g. TrackedObjectProcessor) still holds a ref to
+the old, smaller segment.
+"""
+
+import unittest
+from types import SimpleNamespace
+from unittest.mock import patch
+
+import numpy as np
+
+from frigate.util.image import SharedMemoryFrameManager
+
+
+def _fake_shm(size: int) -> SimpleNamespace:
+    """A minimal stand-in for UntrackedSharedMemory with .size and .buf."""
+    return SimpleNamespace(size=size, buf=bytearray(size), close=lambda: None)
+
+
+class TestSharedMemoryFrameManagerGet(unittest.TestCase):
+    def test_get_reopens_when_cached_segment_is_smaller_than_shape(self) -> None:
+        """A cached ref to an older smaller segment must be dropped and the
+        current (correctly sized) segment reopened. Without this, np.ndarray
+        would raise "buffer is too small for requested array" when the
+        in-memory cache pointed at an old SHM after a same-name resize."""
+        manager = SharedMemoryFrameManager()
+
+        small = _fake_shm(size=100)
+        current = _fake_shm(size=2_500)
+        manager.shm_store["cam_frame0"] = small
+
+        with patch("frigate.util.image.UntrackedSharedMemory", return_value=current):
+            arr = manager.get("cam_frame0", (50, 50))
+
+        self.assertIsNotNone(arr)
+        self.assertEqual(arr.shape, (50, 50))
+        self.assertIs(manager.shm_store["cam_frame0"], current)
+
+    def test_get_reopens_when_cached_segment_is_larger_than_shape(self) -> None:
+        """Symmetric to the smaller-cache case: when detect resolution drops,
+        the SHM is unlinked and recreated at a smaller size. A cached ref to
+        the old, larger segment still satisfies any size check but points at
+        an orphaned inode whose stale bytes get reinterpreted at the new
+        shape — producing miscolored, distorted YUV frames downstream. Drop
+        the cache so we reopen by name and bind to the current segment."""
+        manager = SharedMemoryFrameManager()
+
+        old_large = _fake_shm(size=10_000)
+        current = _fake_shm(size=2_500)
+        manager.shm_store["cam_frame0"] = old_large
+
+        with patch("frigate.util.image.UntrackedSharedMemory", return_value=current):
+            arr = manager.get("cam_frame0", (50, 50))
+
+        self.assertIsNotNone(arr)
+        self.assertEqual(arr.shape, (50, 50))
+        self.assertIs(manager.shm_store["cam_frame0"], current)
+
+    def test_get_keeps_cached_segment_when_size_matches(self) -> None:
+        """Don't pay the reopen cost when the cached ref is the right size."""
+        manager = SharedMemoryFrameManager()
+
+        cached = _fake_shm(size=2_500)
+        manager.shm_store["cam_frame0"] = cached
+
+        with patch("frigate.util.image.UntrackedSharedMemory") as untracked_shm_cls:
+            arr = manager.get("cam_frame0", (50, 50))
+            untracked_shm_cls.assert_not_called()
+
+        self.assertIsNotNone(arr)
+        self.assertIs(manager.shm_store["cam_frame0"], cached)
+
+    def test_get_opens_fresh_when_no_cache_entry(self) -> None:
+        manager = SharedMemoryFrameManager()
+        fresh = _fake_shm(size=2_500)
+
+        with patch("frigate.util.image.UntrackedSharedMemory", return_value=fresh):
+            arr = manager.get("cam_frame0", (50, 50))
+
+        self.assertIsNotNone(arr)
+        self.assertIs(manager.shm_store["cam_frame0"], fresh)
+
+    def test_get_returns_none_when_segment_missing(self) -> None:
+        manager = SharedMemoryFrameManager()
+
+        with patch(
+            "frigate.util.image.UntrackedSharedMemory",
+            side_effect=FileNotFoundError,
+        ):
+            arr = manager.get("cam_frame0", (50, 50))
+
+        self.assertIsNone(arr)
+
+    def test_get_returns_none_when_reopened_segment_is_still_too_small(self) -> None:
+        """Race during a same-name SHM recreate: cache is stale, we reopen
+        by name, but the maintainer hasn't allocated the new segment yet —
+        the reopened ref is also too small. Skip the frame (return None)
+        rather than crash on np.ndarray."""
+        manager = SharedMemoryFrameManager()
+
+        small_cached = _fake_shm(size=100)
+        still_small_after_reopen = _fake_shm(size=100)
+        manager.shm_store["cam_frame0"] = small_cached
+
+        with patch(
+            "frigate.util.image.UntrackedSharedMemory",
+            return_value=still_small_after_reopen,
+        ):
+            arr = manager.get("cam_frame0", (50, 50))
+
+        self.assertIsNone(arr)
+        # Don't cache the too-small reopened ref — next call will re-open
+        # once the maintainer has finished recreating the segment.
+        self.assertNotIn("cam_frame0", manager.shm_store)
+
+    def test_get_handles_n_dimensional_shape(self) -> None:
+        """np.prod must be used (not raw multiplication) for tuple shapes."""
+        manager = SharedMemoryFrameManager()
+        # YUV-shaped frame: (height * 3/2, width) for 1920x1080 = 3,110,400
+        big_enough = _fake_shm(size=3_110_400)
+        manager.shm_store["cam_frame0"] = big_enough
+
+        with patch("frigate.util.image.UntrackedSharedMemory") as untracked_shm_cls:
+            arr = manager.get("cam_frame0", (1620, 1920))
+            untracked_shm_cls.assert_not_called()
+
+        self.assertIsNotNone(arr)
+        self.assertEqual(arr.shape, (1620, 1920))
+
+
+class TestSharedMemoryFrameManagerGetRecreatesLargerSegment(unittest.TestCase):
+    """End-to-end-style: simulates the full unlink-and-recreate cycle."""
+
+    def test_segment_grows_then_get_succeeds(self) -> None:
+        manager = SharedMemoryFrameManager()
+
+        # Phase 1: existing camera at 320x240 YUV — 320 * 240 * 1.5 = 115_200
+        small = _fake_shm(size=115_200)
+        manager.shm_store["cam_frame0"] = small
+        arr_small = np.ndarray((360, 320), dtype=np.uint8, buffer=small.buf)
+        self.assertEqual(arr_small.shape, (360, 320))
+
+        # Phase 2: restart at 1920x1080 — new SHM segment, larger size.
+        large = _fake_shm(size=3_110_400)
+        with patch("frigate.util.image.UntrackedSharedMemory", return_value=large):
+            arr_large = manager.get("cam_frame0", (1620, 1920))
+
+        self.assertIsNotNone(arr_large)
+        self.assertEqual(arr_large.shape, (1620, 1920))
+
+
+if __name__ == "__main__":
+    unittest.main()

frigate/util/config.py

@@ -8,7 +8,7 @@ from typing import Any, Optional, Union
 
 from ruamel.yaml import YAML
 
-from frigate.const import CONFIG_DIR, EXPORT_DIR
+from frigate.const import CONFIG_DIR, EXPORT_DIR, REDACTED_CREDENTIAL_SENTINEL
 from frigate.util.builtin import deep_merge
 from frigate.util.services import get_video_properties
 
@@ -18,6 +18,21 @@ CURRENT_CONFIG_VERSION = "0.18-0"
 DEFAULT_CONFIG_FILE = os.path.join(CONFIG_DIR, "config.yml")
 
 
+def redact_credential(obj: dict[str, Any], key: str) -> None:
+    """Replace obj[key] with the redaction sentinel if a value is saved, else drop.
+
+    Used when shaping the /config response so saved credentials never leave
+    the server. The frontend recognizes REDACTED_CREDENTIAL_SENTINEL, renders
+    the field as empty with a "saved — leave blank to keep" placeholder, and
+    /config/set strips it from any incoming payload so the YAML value is
+    preserved when the user doesn't touch the field.
+    """
+    if obj.get(key):
+        obj[key] = REDACTED_CREDENTIAL_SENTINEL
+    else:
+        obj.pop(key, None)
+
+
 def find_config_file() -> str:
     config_path = os.environ.get("CONFIG_FILE", DEFAULT_CONFIG_FILE)
 
@@ -773,6 +788,45 @@ def apply_section_update(camera_config, section: str, update: dict) -> Optional[
                 )
             camera_config.objects = new_objects
 
+        elif section == "detect":
+            # apply detect first so frame_shape reflects the new resolution
+            # before we rebuild mask-dependent runtime configs below
+            merged = deep_merge(current.model_dump(), update, override=True)
+            camera_config.detect = current.__class__.model_validate(merged)
+
+            new_frame_shape = camera_config.frame_shape
+
+            # rebuild motion's rasterized_mask at the new frame_shape
+            if camera_config.motion is not None:
+                camera_config.motion = RuntimeMotionConfig(
+                    frame_shape=new_frame_shape,
+                    **camera_config.motion.model_dump(exclude_unset=True),
+                )
+
+            # rebuild per-object filter masks at the new frame_shape
+            for obj_name, filt in camera_config.objects.filters.items():
+                merged_mask = dict(filt.mask)
+                if camera_config.objects.mask:
+                    for gid, gmask in camera_config.objects.mask.items():
+                        merged_mask[f"global_{gid}"] = gmask
+
+                camera_config.objects.filters[obj_name] = RuntimeFilterConfig(
+                    frame_shape=new_frame_shape,
+                    mask=merged_mask,
+                    **filt.model_dump(exclude_unset=True, exclude={"mask", "raw_mask"}),
+                )
+
+            # Regenerate zone contours and per-zone filter masks at the new
+            # frame_shape so zone outlines and membership stay relative
+            for zone in camera_config.zones.values():
+                if zone.filters:
+                    for zone_obj_name, zone_filter in zone.filters.items():
+                        zone.filters[zone_obj_name] = RuntimeFilterConfig(
+                            frame_shape=new_frame_shape,
+                            **zone_filter.model_dump(exclude_unset=True),
+                        )
+                zone.generate_contour(new_frame_shape)
+
         else:
             merged = deep_merge(current.model_dump(), update, override=True)
             setattr(camera_config, section, current.__class__.model_validate(merged))

frigate/util/image.py

@@ -1089,10 +1089,25 @@ class SharedMemoryFrameManager(FrameManager):
 
     def get(self, name: str, shape) -> Optional[np.ndarray]:
         try:
-            if name in self.shm_store:
-                shm = self.shm_store[name]
-            else:
+            required = int(np.prod(shape))
+            shm = self.shm_store.get(name)
+            if shm is not None and shm.size != required:
+                # stale cached ref from a same-name recreate — drop and reopen
+                try:
+                    shm.close()
+                except Exception:
+                    pass
+                self.shm_store.pop(name, None)
+                shm = None
+            if shm is None:
                 shm = UntrackedSharedMemory(name=name)
+                if shm.size != required:
+                    # mid-recreate: OS segment doesn't match shape yet; skip
+                    try:
+                        shm.close()
+                    except Exception:
+                        pass
+                    return None
                 self.shm_store[name] = shm
             return np.ndarray(shape, dtype=np.uint8, buffer=shm.buf)
         except FileNotFoundError:

web/public/locales/en/common.json

@@ -316,5 +316,8 @@
     "pixels": "{{area}}px"
   },
   "no_items": "No items",
-  "validation_errors": "Validation Errors"
+  "validation_errors": "Validation Errors",
+  "credentialField": {
+    "savedPlaceholder": "Saved — leave blank to keep current"
+  }
 }

web/public/locales/en/config/validation.json

@@ -28,5 +28,8 @@
       "detectRequired": "At least one input stream must be assigned the 'detect' role.",
       "hwaccelDetectOnly": "Only the input stream with the detect role can define hardware acceleration arguments."
     }
+  },
+  "detect": {
+    "dimensionMustBeEven": "Must be an even number."
   }
 }

web/public/locales/en/views/chat.json

@@ -65,5 +65,8 @@
     "active": "Reasoning…",
     "show": "Show reasoning",
     "hide": "Hide reasoning"
+  },
+  "thinking": {
+    "toggle": "Toggle thinking"
   }
 }

web/public/locales/en/views/settings.json

@@ -484,11 +484,15 @@
       "reorderHandle": "Drag to reorder",
       "saving": "Saving…",
       "saved": "Saved",
-      "friendlyName": {
-        "edit": "Edit camera display name",
-        "title": "Edit Display Name",
-        "description": "Set the friendly name shown for this camera throughout the Frigate UI. Leave blank to use the camera ID.",
-        "rename": "Rename"
+      "details": {
+        "edit": "Edit camera details",
+        "title": "Edit Camera Details",
+        "description": "Update the display name and external URL used for this camera throughout the Frigate UI.",
+        "friendlyNameLabel": "Display Name",
+        "friendlyNameHelp": "Friendly name shown for this camera throughout the Frigate UI. Leave blank to use the camera ID.",
+        "webuiUrlLabel": "Camera Web UI URL",
+        "webuiUrlHelp": "URL to visit the camera's web UI directly from the Debug view. Leave blank to disable the link.",
+        "webuiUrlInvalid": "Must be a valid URL (e.g., https://example.com)."
       }
     },
     "cameraConfig": {
@@ -1539,6 +1543,9 @@
       "builtIn": "Built-in Models",
       "genaiProviders": "GenAI Providers"
     },
+    "semanticSearchModelSize": {
+      "notApplicable": "Not applicable for GenAI providers"
+    },
     "review": {
       "title": "Review Settings"
     },
@@ -1787,7 +1794,9 @@
     },
     "detect": {
       "fpsGreaterThanFive": "Setting the detect FPS higher than 5 is not recommended. Higher values may cause performance issues and will not provide any benefit.",
-      "disabled": "Object detection is disabled. Snapshots, review items, and enrichments such as face recognition, license plate recognition, and Generative AI will not function."
+      "disabled": "Object detection is disabled. Snapshots, review items, and enrichments such as face recognition, license plate recognition, and Generative AI will not function.",
+      "resolutionShouldBeMultipleOfFour": "For best results, detect width and height should be multiples of 4. Other even values may produce visual artifacts or slight distortion in the detect stream.",
+      "aspectRatioMismatch": "The width and height you've entered don't match the aspect ratio of your current detect resolution. This may produce a stretched or distorted image."
     },
     "objects": {
       "genaiNoDescriptionsProvider": "You must configure a GenAI provider with the 'descriptions' role for descriptions to be generated."

web/src/components/chat/ChatComposer.tsx

@@ -0,0 +1,147 @@
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { FaArrowUpLong, FaStop } from "react-icons/fa6";
+import { LuBrain } from "react-icons/lu";
+import { useTranslation } from "react-i18next";
+import { cn } from "@/lib/utils";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { ChatAttachmentChip } from "@/components/chat/ChatAttachmentChip";
+import { ChatQuickReplies } from "@/components/chat/ChatQuickReplies";
+import { ChatPaperclipButton } from "@/components/chat/ChatPaperclipButton";
+
+type ChatComposerProps = {
+  input: string;
+  setInput: (value: string) => void;
+  sendMessage: (textOverride?: string) => void;
+  placeholder: string;
+
+  supportsThinking: boolean;
+  thinkingEnabled: boolean;
+  setThinkingEnabled: (value: boolean | undefined) => void;
+
+  isLoading?: boolean;
+  onStop?: () => void;
+
+  attachedEventId?: string | null;
+  onClearAttachment?: () => void;
+  onAttach?: (eventId: string) => void;
+  recentEventIds?: string[];
+
+  large?: boolean;
+};
+
+export function ChatComposer({
+  input,
+  setInput,
+  sendMessage,
+  placeholder,
+  supportsThinking,
+  thinkingEnabled,
+  setThinkingEnabled,
+  isLoading = false,
+  onStop,
+  attachedEventId,
+  onClearAttachment,
+  onAttach,
+  recentEventIds,
+  large = false,
+}: ChatComposerProps) {
+  const { t } = useTranslation(["views/chat"]);
+
+  const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
+    if (e.key === "Enter" && !e.shiftKey) {
+      e.preventDefault();
+      sendMessage();
+    }
+  };
+
+  const showPaperclip = !!onAttach;
+  const showStop = isLoading && !!onStop;
+
+  return (
+    <div className="flex w-full flex-col items-stretch justify-center gap-2 rounded-xl bg-secondary p-3">
+      {attachedEventId && onClearAttachment && (
+        <div className="flex items-center">
+          <ChatAttachmentChip
+            eventId={attachedEventId}
+            mode="composer"
+            onRemove={onClearAttachment}
+          />
+        </div>
+      )}
+      {attachedEventId && (
+        <ChatQuickReplies
+          onSend={(text) => sendMessage(text)}
+          disabled={isLoading}
+        />
+      )}
+      <div className="flex w-full flex-row items-center gap-2">
+        {showPaperclip && (
+          <ChatPaperclipButton
+            recentEventIds={recentEventIds ?? []}
+            onAttach={onAttach!}
+            disabled={isLoading || attachedEventId != null}
+          />
+        )}
+        {supportsThinking && (
+          <TooltipProvider>
+            <Tooltip>
+              <TooltipTrigger asChild>
+                <Button
+                  type="button"
+                  size="sm"
+                  variant={thinkingEnabled ? "select" : "ghost"}
+                  aria-pressed={thinkingEnabled}
+                  aria-label={t("thinking.toggle")}
+                  className={cn(
+                    "flex size-9 shrink-0 items-center justify-center rounded-full p-0",
+                    !thinkingEnabled && "text-secondary-foreground",
+                  )}
+                  onClick={() => setThinkingEnabled(!thinkingEnabled)}
+                  disabled={isLoading}
+                >
+                  <LuBrain className="size-4" />
+                </Button>
+              </TooltipTrigger>
+              <TooltipContent>{t("thinking.toggle")}</TooltipContent>
+            </Tooltip>
+          </TooltipProvider>
+        )}
+        <Input
+          className={cn(
+            "w-full flex-1 border-transparent bg-transparent shadow-none focus-visible:ring-0 dark:bg-transparent",
+            large && "h-12 text-base",
+          )}
+          placeholder={placeholder}
+          value={input}
+          onChange={(e) => setInput(e.target.value)}
+          onKeyDown={handleKeyDown}
+          aria-busy={isLoading}
+        />
+        {showStop ? (
+          <Button
+            variant="destructive"
+            className="size-10 shrink-0 rounded-full"
+            onClick={onStop}
+          >
+            <FaStop className="size-3" />
+          </Button>
+        ) : (
+          <Button
+            variant="select"
+            className="size-10 shrink-0 rounded-full"
+            disabled={!input.trim() || isLoading}
+            onClick={() => sendMessage()}
+          >
+            <FaArrowUpLong className="size-4" />
+          </Button>
+        )}
+      </div>
+    </div>
+  );
+}

web/src/components/chat/ChatStartingState.tsx

@@ -1,15 +1,22 @@
 import { Button } from "@/components/ui/button";
-import { Input } from "@/components/ui/input";
-import { FaArrowUpLong } from "react-icons/fa6";
 import { useTranslation } from "react-i18next";
 import { useState } from "react";
 import type { StartingRequest } from "@/types/chat";
+import { ChatComposer } from "@/components/chat/ChatComposer";
 
 type ChatStartingStateProps = {
   onSendMessage: (message: string) => void;
+  supportsThinking: boolean;
+  thinkingEnabled: boolean;
+  setThinkingEnabled: (value: boolean | undefined) => void;
 };
 
-export function ChatStartingState({ onSendMessage }: ChatStartingStateProps) {
+export function ChatStartingState({
+  onSendMessage,
+  supportsThinking,
+  thinkingEnabled,
+  setThinkingEnabled,
+}: ChatStartingStateProps) {
   const { t } = useTranslation(["views/chat"]);
   const [input, setInput] = useState("");
 
@@ -36,20 +43,13 @@ export function ChatStartingState({ onSendMessage }: ChatStartingStateProps) {
     onSendMessage(prompt);
   };
 
-  const handleSubmit = () => {
-    const text = input.trim();
+  const handleSend = (textOverride?: string) => {
+    const text = (textOverride ?? input).trim();
     if (!text) return;
     onSendMessage(text);
     setInput("");
   };
 
-  const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
-    if (e.key === "Enter" && !e.shiftKey) {
-      e.preventDefault();
-      handleSubmit();
-    }
-  };
-
   return (
     <div className="flex size-full flex-col items-center justify-center gap-6 p-8">
       <div className="flex flex-col items-center gap-2">
@@ -77,22 +77,17 @@ export function ChatStartingState({ onSendMessage }: ChatStartingStateProps) {
         </div>
       </div>
 
-      <div className="flex w-full max-w-2xl flex-row items-center gap-2 rounded-xl bg-secondary p-3">
-        <Input
-          className="h-12 w-full flex-1 border-transparent bg-transparent text-base shadow-none focus-visible:ring-0 dark:bg-transparent"
+      <div className="w-full max-w-2xl">
+        <ChatComposer
+          input={input}
+          setInput={setInput}
+          sendMessage={handleSend}
           placeholder={t("placeholder")}
-          value={input}
-          onChange={(e) => setInput(e.target.value)}
-          onKeyDown={handleKeyDown}
+          supportsThinking={supportsThinking}
+          thinkingEnabled={thinkingEnabled}
+          setThinkingEnabled={setThinkingEnabled}
+          large
         />
-        <Button
-          variant="select"
-          className="size-10 shrink-0 rounded-full"
-          disabled={!input.trim()}
-          onClick={handleSubmit}
-        >
-          <FaArrowUpLong size="18" />
-        </Button>
       </div>
     </div>
   );

web/src/components/chat/ReasoningBubble.tsx

@@ -8,6 +8,12 @@ import {
 } from "@/components/ui/collapsible";
 import { Button } from "@/components/ui/button";
 import { cn } from "@/lib/utils";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+} from "@/components/ui/tooltip";
 
 type ReasoningBubbleProps = {
   /** The accumulated reasoning text from the model. */
@@ -54,34 +60,42 @@ export function ReasoningBubble({
 
   return (
     <div className="self-start rounded-2xl bg-muted/60 px-3 py-2 text-muted-foreground">
-      <Collapsible open={open} onOpenChange={handleOpenChange}>
-        <CollapsibleTrigger asChild>
-          <Button
-            variant="ghost"
-            size="sm"
-            className="h-auto w-full min-w-0 justify-start gap-2 whitespace-normal p-0 text-left text-xs hover:bg-transparent"
-          >
-            <LuBrain
-              className={cn(
-                "size-3 shrink-0",
-                !answerStarted && "animate-pulse",
-              )}
-            />
-            <span className="break-words font-medium">{label}</span>
-            {answerStarted &&
-              (open ? (
-                <LuChevronDown className="ml-auto size-3 shrink-0" />
-              ) : (
-                <LuChevronRight className="ml-auto size-3 shrink-0" />
-              ))}
-          </Button>
-        </CollapsibleTrigger>
-        <CollapsibleContent>
-          <pre className="scrollbar-container mt-2 max-h-64 overflow-auto whitespace-pre-wrap break-words rounded bg-muted/50 p-2 font-sans text-xs leading-relaxed">
-            {reasoning}
-          </pre>
-        </CollapsibleContent>
-      </Collapsible>
+      <TooltipProvider>
+        <Collapsible open={open} onOpenChange={handleOpenChange}>
+          <CollapsibleTrigger asChild>
+            <Button
+              variant="ghost"
+              size="sm"
+              className="h-auto w-full min-w-0 justify-start gap-2 whitespace-normal p-0 text-left text-xs hover:bg-transparent"
+            >
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <div className="flex items-center gap-2">
+                    <LuBrain
+                      className={cn(
+                        "size-3 shrink-0",
+                        !answerStarted && "animate-pulse",
+                      )}
+                    />
+                  </div>
+                </TooltipTrigger>
+                <TooltipContent>{label}</TooltipContent>
+              </Tooltip>
+              {answerStarted &&
+                (open ? (
+                  <LuChevronDown className="ml-auto size-3 shrink-0" />
+                ) : (
+                  <LuChevronRight className="ml-auto size-3 shrink-0" />
+                ))}
+            </Button>
+          </CollapsibleTrigger>
+          <CollapsibleContent>
+            <pre className="scrollbar-container mt-2 max-h-64 overflow-auto whitespace-pre-wrap break-words rounded bg-muted/50 p-2 font-sans text-xs leading-relaxed">
+              {reasoning}
+            </pre>
+          </CollapsibleContent>
+        </Collapsible>
+      </TooltipProvider>
     </div>
   );
 }

web/src/components/classification/wizard/Step2StateArea.tsx

@@ -14,6 +14,7 @@ import Konva from "konva";
 import { useResizeObserver } from "@/hooks/resize-observer";
 import { useApiHost } from "@/api";
 import { resolveCameraName } from "@/hooks/use-camera-friendly-name";
+import { isReplayCamera } from "@/utils/cameraUtil";
 import Heading from "@/components/ui/heading";
 import { isMobile } from "react-device-detect";
 import { cn } from "@/lib/utils";
@@ -67,6 +68,7 @@ export default function Step2StateArea({
         ([name, cam]) =>
           cam.enabled &&
           cam.enabled_in_config &&
+          !isReplayCamera(name) &&
           !selectedCameraNames.includes(name),
       )
       .map(([name]) => ({

web/src/components/config-form/FieldMessagesContext.ts

@@ -0,0 +1,13 @@
+import { createContext } from "react";
+import type { FieldConditionalMessage } from "./section-configs/types";
+
+// Provides currently-active field messages to FieldTemplate without going
+// through RJSF's per-field uiSchema. RJSF caches state.uiSchema across renders
+// in a way that can leave stale ui:messages attached to a field when the
+// triggering condition flips back to false (see processPendingChange in
+// @rjsf/core Form.js — formData is updated immediately, uiSchema is not).
+// useContext re-runs consumers directly on provider value change, sidestepping
+// that staleness.
+export const FieldMessagesContext = createContext<FieldConditionalMessage[]>(
+  [],
+);

web/src/components/config-form/LiveFormDataContext.ts

@@ -0,0 +1,13 @@
+import { createContext } from "react";
+import type { ConfigSectionData } from "@/types/configForm";
+
+// Mirrors the current section's in-flight form data so widgets can react
+// to changes that RJSF wouldn't otherwise re-render them for. RJSF's
+// Form memoizes SchemaField via deep equality and, in some transitions
+// (notably reverting a field to its saved value), can skip re-rendering
+// a widget even though the form data it depends on changed. useContext
+// re-runs consumers directly on every provider value update, sidestepping
+// that.
+export const LiveFormDataContext = createContext<ConfigSectionData | null>(
+  null,
+);

web/src/components/config-form/section-configs/detect.ts

@@ -11,6 +11,50 @@ const detect: SectionConfigOverrides = {
         condition: (ctx) =>
           ctx.level === "camera" && ctx.formData?.enabled === false,
       },
+      {
+        key: "detect-resolution-not-multiple-of-four",
+        messageKey: "configMessages.detect.resolutionShouldBeMultipleOfFour",
+        severity: "warning",
+        condition: (ctx) => {
+          const width = ctx.formData?.width as number | null | undefined;
+          const height = ctx.formData?.height as number | null | undefined;
+          const isEvenButNotFour = (v: unknown) =>
+            typeof v === "number" && v % 2 === 0 && v % 4 !== 0;
+          return isEvenButNotFour(width) || isEvenButNotFour(height);
+        },
+      },
+      {
+        key: "detect-aspect-ratio-mismatch",
+        messageKey: "configMessages.detect.aspectRatioMismatch",
+        severity: "warning",
+        condition: (ctx) => {
+          const newWidth = ctx.formData?.width as number | null | undefined;
+          const newHeight = ctx.formData?.height as number | null | undefined;
+          if (typeof newWidth !== "number" || typeof newHeight !== "number") {
+            return false;
+          }
+          const saved =
+            ctx.level === "camera"
+              ? ctx.fullCameraConfig?.detect
+              : ctx.fullConfig?.detect;
+          const savedWidth = saved?.width;
+          const savedHeight = saved?.height;
+          if (
+            typeof savedWidth !== "number" ||
+            typeof savedHeight !== "number" ||
+            savedWidth <= 0 ||
+            savedHeight <= 0
+          ) {
+            return false;
+          }
+          if (newWidth === savedWidth && newHeight === savedHeight) {
+            return false;
+          }
+          const newRatio = newWidth / newHeight;
+          const savedRatio = savedWidth / savedHeight;
+          return Math.abs(newRatio - savedRatio) > 0.01;
+        },
+      },
     ],
     fieldMessages: [
       {
@@ -72,6 +116,25 @@ const detect: SectionConfigOverrides = {
       "max_disappeared",
     ],
   },
+  replay: {
+    restartRequired: [],
+    fieldOrder: ["width", "height", "fps"],
+    fieldGroups: {
+      resolution: ["width", "height", "fps"],
+    },
+    hiddenFields: [
+      "enabled",
+      "enabled_in_config",
+      "min_initialized",
+      "max_disappeared",
+      "annotation_offset",
+      "stationary",
+      "interval",
+      "threshold",
+      "max_frames",
+    ],
+    advancedFields: [],
+  },
 };
 
 export default detect;

web/src/components/config-form/section-configs/genai.ts

@@ -24,6 +24,7 @@ const genai: SectionConfigOverrides = {
         "ui:widget": "genaiRoles",
       },
       "*.api_key": {
+        "ui:widget": "password",
         "ui:options": { size: "lg" },
       },
       "*.base_url": {

web/src/components/config-form/section-configs/mqtt.ts

@@ -64,6 +64,7 @@ const mqtt: SectionConfigOverrides = {
     liveValidate: true,
     uiSchema: {
       password: {
+        "ui:widget": "password",
         "ui:options": { size: "xs" },
       },
     },

web/src/components/config-form/section-configs/onvif.ts

@@ -29,6 +29,9 @@ const onvif: SectionConfigOverrides = {
       host: {
         "ui:options": { size: "sm" },
       },
+      password: {
+        "ui:widget": "password",
+      },
       profile: {
         "ui:widget": "onvifProfile",
       },

web/src/components/config-form/section-configs/proxy.ts

@@ -18,6 +18,7 @@ const proxy: SectionConfigOverrides = {
         "ui:options": { size: "lg" },
       },
       auth_secret: {
+        "ui:widget": "password",
         "ui:options": { size: "md" },
       },
       header_map: {

web/src/components/config-form/section-configs/semantic_search.ts

@@ -35,6 +35,7 @@ const semanticSearch: SectionConfigOverrides = {
         "ui:widget": "semanticSearchModel",
       },
       model_size: {
+        "ui:widget": "semanticSearchModelSize",
         "ui:options": { size: "xs", enumI18nPrefix: "modelSize" },
       },
     },

web/src/components/config-form/section-validations/detect.ts

@@ -0,0 +1,36 @@
+import type { FormValidation } from "@rjsf/utils";
+import type { TFunction } from "i18next";
+import { isJsonObject } from "@/lib/utils";
+import type { JsonObject } from "@/types/configForm";
+
+export function validateDetectDimensions(
+  formData: unknown,
+  errors: FormValidation,
+  t: TFunction,
+): FormValidation {
+  if (!isJsonObject(formData as JsonObject)) {
+    return errors;
+  }
+
+  const data = formData as JsonObject;
+  const width = data.width;
+  const height = data.height;
+
+  const widthErrors = errors.width as
+    | { addError?: (message: string) => void }
+    | undefined;
+  const heightErrors = errors.height as
+    | { addError?: (message: string) => void }
+    | undefined;
+
+  const message = t("detect.dimensionMustBeEven", { ns: "config/validation" });
+
+  if (typeof width === "number" && width % 2 !== 0) {
+    widthErrors?.addError?.(message);
+  }
+  if (typeof height === "number" && height % 2 !== 0) {
+    heightErrors?.addError?.(message);
+  }
+
+  return errors;
+}

web/src/components/config-form/section-validations/index.ts

@@ -1,5 +1,6 @@
 import type { FormValidation } from "@rjsf/utils";
 import type { TFunction } from "i18next";
+import { validateDetectDimensions } from "./detect";
 import { validateFfmpegInputRoles } from "./ffmpeg";
 import { validateProxyRoleHeader } from "./proxy";
 
@@ -19,6 +20,10 @@ export function getSectionValidation({
   level,
   t,
 }: SectionValidationOptions): SectionValidation | undefined {
+  if (sectionPath === "detect") {
+    return (formData, errors) => validateDetectDimensions(formData, errors, t);
+  }
+
   if (sectionPath === "ffmpeg" && level === "camera") {
     return (formData, errors) => validateFfmpegInputRoles(formData, errors, t);
   }

web/src/components/config-form/sectionExtras/NotificationsSettingsExtras.tsx

@@ -57,6 +57,7 @@ import isEqual from "lodash/isEqual";
 import set from "lodash/set";
 import type { ConfigSectionData, JsonObject } from "@/types/configForm";
 import { sanitizeSectionData } from "@/utils/configUtil";
+import { isReplayCamera } from "@/utils/cameraUtil";
 import type { SectionRendererProps } from "./registry";
 
 const NOTIFICATION_SERVICE_WORKER = "/notifications-worker.js";
@@ -94,7 +95,7 @@ export default function NotificationsSettingsExtras({
 
     return Object.values(config.cameras)
       .sort((aConf, bConf) => aConf.ui.order - bConf.ui.order)
-      .filter((c) => c.enabled_in_config);
+      .filter((c) => c.enabled_in_config && !isReplayCamera(c.name));
   }, [config]);
 
   const notificationCameras = useMemo(() => {
@@ -106,6 +107,7 @@ export default function NotificationsSettingsExtras({
       .filter(
         (conf) =>
           conf.enabled_in_config &&
+          !isReplayCamera(conf.name) &&
           conf.notifications &&
           conf.notifications.enabled_in_config,
       )
@@ -359,6 +361,7 @@ export default function NotificationsSettingsExtras({
       Object.values(config.cameras).some(
         (c) =>
           c.enabled_in_config &&
+          !isReplayCamera(c.name) &&
           c.notifications &&
           c.notifications.enabled_in_config,
       ),

web/src/components/config-form/sections/BaseSection.tsx

@@ -86,6 +86,8 @@ import type {
 } from "../section-configs/types";
 import { useConfigMessages } from "@/hooks/use-config-messages";
 import { ConfigMessageBanner } from "../ConfigMessageBanner";
+import { FieldMessagesContext } from "../FieldMessagesContext";
+import { LiveFormDataContext } from "../LiveFormDataContext";
 
 export interface SectionConfig {
   /** Field ordering within the section */
@@ -627,44 +629,6 @@ export function ConfigSection({
     messageContext,
   );
 
-  // Merge field-level conditional messages into uiSchema
-  const effectiveUiSchema = useMemo(() => {
-    if (activeFieldMessages.length === 0) return sectionConfig.uiSchema;
-    const merged = { ...(sectionConfig.uiSchema ?? {}) };
-    for (const msg of activeFieldMessages) {
-      const segments = msg.field.split(".");
-      // Navigate to the nested uiSchema node, shallow-cloning along the way
-      let node = merged;
-      for (let i = 0; i < segments.length - 1; i++) {
-        const seg = segments[i];
-        node[seg] = { ...(node[seg] as Record<string, unknown>) };
-        node = node[seg] as Record<string, unknown>;
-      }
-      const leafKey = segments[segments.length - 1];
-      const existing = node[leafKey] as Record<string, unknown> | undefined;
-      const existingMessages = ((existing?.["ui:messages"] as unknown[]) ??
-        []) as Array<{
-        key: string;
-        messageKey: string;
-        severity: string;
-        position?: string;
-      }>;
-      node[leafKey] = {
-        ...existing,
-        "ui:messages": [
-          ...existingMessages,
-          {
-            key: msg.key,
-            messageKey: msg.messageKey,
-            severity: msg.severity,
-            position: msg.position ?? "before",
-          },
-        ],
-      };
-    }
-    return merged;
-  }, [sectionConfig.uiSchema, activeFieldMessages]);
-
   const currentOverrides = useMemo(() => {
     if (!currentFormData || typeof currentFormData !== "object") {
       return undefined;
@@ -1034,59 +998,65 @@ export function ConfigSection({
   const sectionContent = (
     <div className="space-y-6">
       <ConfigMessageBanner messages={activeMessages} />
-      <ConfigForm
-        key={formKey}
-        schema={modifiedSchema}
-        formData={currentFormData}
-        onChange={handleChange}
-        onValidationChange={setHasValidationErrors}
-        fieldOrder={sectionConfig.fieldOrder}
-        fieldGroups={sectionConfig.fieldGroups}
-        hiddenFields={effectiveHiddenFields}
-        advancedFields={sectionConfig.advancedFields}
-        liveValidate={sectionConfig.liveValidate}
-        uiSchema={effectiveUiSchema}
-        disabled={disabled || isSaving}
-        readonly={readonly}
-        showSubmit={false}
-        i18nNamespace={configNamespace}
-        customValidate={customValidate}
-        formContext={{
-          level: effectiveLevel,
-          cameraName,
-          globalValue,
-          cameraValue,
-          hasChanges,
-          extraHasChanges,
-          setExtraHasChanges,
-          overrides: uiOverrides as JsonValue | undefined,
-          formData: currentFormData as ConfigSectionData,
-          baselineFormData: effectiveBaselineFormData as ConfigSectionData,
-          pendingDataBySection,
-          onPendingDataChange,
-          onFormDataChange: (data: ConfigSectionData) => handleChange(data),
-          // For widgets that need access to full camera config (e.g., zone names)
-          fullCameraConfig:
-            effectiveLevel === "camera" && cameraName
-              ? config?.cameras?.[cameraName]
-              : undefined,
-          fullConfig: config,
-          // When rendering camera-level sections, provide the section path so
-          // field templates can look up keys under the `config/cameras` namespace
-          // When using a consolidated global namespace, keys are nested
-          // under the section name (e.g., `audio.label`) so provide the
-          // section prefix to templates so they can attempt `${section}.${field}` lookups.
-          sectionI18nPrefix: sectionPath,
-          t,
-          renderers: wrappedRenderers,
-          sectionDocs: sectionConfig.sectionDocs,
-          fieldDocs: sectionConfig.fieldDocs,
-          hiddenFields: effectiveHiddenFields,
-          restartRequired: sectionConfig.restartRequired,
-          requiresRestart,
-          isProfile: !!profileName,
-        }}
-      />
+      <FieldMessagesContext.Provider value={activeFieldMessages}>
+        <LiveFormDataContext.Provider
+          value={(currentFormData as ConfigSectionData | null) ?? null}
+        >
+          <ConfigForm
+            key={formKey}
+            schema={modifiedSchema}
+            formData={currentFormData}
+            onChange={handleChange}
+            onValidationChange={setHasValidationErrors}
+            fieldOrder={sectionConfig.fieldOrder}
+            fieldGroups={sectionConfig.fieldGroups}
+            hiddenFields={effectiveHiddenFields}
+            advancedFields={sectionConfig.advancedFields}
+            liveValidate={sectionConfig.liveValidate}
+            uiSchema={sectionConfig.uiSchema}
+            disabled={disabled || isSaving}
+            readonly={readonly}
+            showSubmit={false}
+            i18nNamespace={configNamespace}
+            customValidate={customValidate}
+            formContext={{
+              level: effectiveLevel,
+              cameraName,
+              globalValue,
+              cameraValue,
+              hasChanges,
+              extraHasChanges,
+              setExtraHasChanges,
+              overrides: uiOverrides as JsonValue | undefined,
+              formData: currentFormData as ConfigSectionData,
+              baselineFormData: effectiveBaselineFormData as ConfigSectionData,
+              pendingDataBySection,
+              onPendingDataChange,
+              onFormDataChange: (data: ConfigSectionData) => handleChange(data),
+              // For widgets that need access to full camera config (e.g., zone names)
+              fullCameraConfig:
+                effectiveLevel === "camera" && cameraName
+                  ? config?.cameras?.[cameraName]
+                  : undefined,
+              fullConfig: config,
+              // When rendering camera-level sections, provide the section path so
+              // field templates can look up keys under the `config/cameras` namespace
+              // When using a consolidated global namespace, keys are nested
+              // under the section name (e.g., `audio.label`) so provide the
+              // section prefix to templates so they can attempt `${section}.${field}` lookups.
+              sectionI18nPrefix: sectionPath,
+              t,
+              renderers: wrappedRenderers,
+              sectionDocs: sectionConfig.sectionDocs,
+              fieldDocs: sectionConfig.fieldDocs,
+              hiddenFields: effectiveHiddenFields,
+              restartRequired: sectionConfig.restartRequired,
+              requiresRestart,
+              isProfile: !!profileName,
+            }}
+          />
+        </LiveFormDataContext.Provider>
+      </FieldMessagesContext.Provider>
 
       {!embedded && (
         <div
@@ -1288,7 +1258,12 @@ export function ConfigSection({
             <CollapsibleTrigger asChild>
               <div className="flex cursor-pointer items-center justify-between">
                 <div className="flex items-center gap-3">
-                  <Heading as="h4">{title}</Heading>
+                  <Heading
+                    as="h4"
+                    className={level === "replay" ? "text-base" : undefined}
+                  >
+                    {title}
+                  </Heading>
                   {showOverrideIndicator &&
                     effectiveLevel === "camera" &&
                     (profileOverridesSection || isOverridden) &&

web/src/components/config-form/theme/frigateTheme.ts

@@ -31,6 +31,7 @@ import { TimezoneSelectWidget } from "./widgets/TimezoneSelectWidget";
 import { CameraPathWidget } from "./widgets/CameraPathWidget";
 import { OptionalFieldWidget } from "./widgets/OptionalFieldWidget";
 import { SemanticSearchModelWidget } from "./widgets/SemanticSearchModelWidget";
+import { SemanticSearchModelSizeWidget } from "./widgets/SemanticSearchModelSizeWidget";
 import { OnvifProfileWidget } from "./widgets/OnvifProfileWidget";
 
 import { FieldTemplate } from "./templates/FieldTemplate";
@@ -86,6 +87,7 @@ export const frigateTheme: FrigateTheme = {
     timezoneSelect: TimezoneSelectWidget,
     optionalField: OptionalFieldWidget,
     semanticSearchModel: SemanticSearchModelWidget,
+    semanticSearchModelSize: SemanticSearchModelSizeWidget,
     onvifProfile: OnvifProfileWidget,
   },
   templates: {

web/src/components/config-form/theme/templates/FieldTemplate.tsx

@@ -5,8 +5,9 @@ import {
   getUiOptions,
   ADDITIONAL_PROPERTY_FLAG,
 } from "@rjsf/utils";
-import { ComponentType, ReactNode } from "react";
+import { ComponentType, ReactNode, useContext } from "react";
 import { isValidElement } from "react";
+import { FieldMessagesContext } from "../../FieldMessagesContext";
 import { Label } from "@/components/ui/label";
 import { cn } from "@/lib/utils";
 import { useTranslation } from "react-i18next";
@@ -95,6 +96,7 @@ export function FieldTemplate(props: FieldTemplateProps) {
     "views/settings",
   ]);
   const { getLocaleDocUrl } = useDocDomain();
+  const allFieldMessages = useContext(FieldMessagesContext);
 
   if (hidden) {
     return <div className="hidden">{children}</div>;
@@ -384,21 +386,15 @@ export function FieldTemplate(props: FieldTemplateProps) {
   const beforeContent = renderCustom(beforeSpec);
   const afterContent = renderCustom(afterSpec);
 
-  // Render conditional field messages from ui:messages
-  const fieldMessageSpecs = uiSchema?.["ui:messages"] as
-    | Array<{
-        key: string;
-        messageKey: string;
-        severity: string;
-        position?: string;
-      }>
-    | undefined;
-  const beforeMessages = fieldMessageSpecs?.filter(
+  // Read field-level conditional messages from FieldMessagesContext
+  const fieldPathStr = pathSegments.join(".");
+  const fieldMessageSpecs = allFieldMessages.filter(
+    (m) => m.field === fieldPathStr,
+  );
+  const beforeMessages = fieldMessageSpecs.filter(
     (m) => (m.position ?? "before") === "before",
   );
-  const afterMessages = fieldMessageSpecs?.filter(
-    (m) => m.position === "after",
-  );
+  const afterMessages = fieldMessageSpecs.filter((m) => m.position === "after");
   const beforeMessagesContent =
     beforeMessages && beforeMessages.length > 0 ? (
       <div className="space-y-2">

web/src/components/config-form/theme/widgets/GenAIModelWidget.tsx

@@ -23,6 +23,7 @@ import {
   PopoverTrigger,
 } from "@/components/ui/popover";
 import type { ConfigFormContext, JsonObject } from "@/types/configForm";
+import type { GenAIModelsResponse } from "@/types/chat";
 import { getSizedFieldClassName } from "../utils";
 
 type ProbeResponse =
@@ -73,11 +74,12 @@ export function GenAIModelWidget(props: WidgetProps) {
     return `${e.provider ?? ""}|${e.base_url ?? ""}`;
   }, [providerKey, formContext?.fullConfig]);
 
-  const { data: allModels, mutate: mutateModels } = useSWR<
-    Record<string, string[]>
-  >("genai/models", {
-    revalidateOnFocus: false,
-  });
+  const { data: allModels, mutate: mutateModels } = useSWR<GenAIModelsResponse>(
+    "genai/models",
+    {
+      revalidateOnFocus: false,
+    },
+  );
 
   // Revalidate models when the saved config fingerprint changes (e.g. after
   // switching provider or base_url and saving).
@@ -89,9 +91,9 @@ export function GenAIModelWidget(props: WidgetProps) {
     }
   }, [configFingerprint, mutateModels]);
 
-  const fetchedModels = useMemo(() => {
+  const fetchedModels = useMemo<string[]>(() => {
     if (!allModels || !providerKey) return [];
-    return allModels[providerKey] ?? [];
+    return allModels[providerKey]?.models ?? [];
   }, [allModels, providerKey]);
 
   const [probeStatus, setProbeStatus] = useState<ProbeStatus>("idle");

web/src/components/config-form/theme/widgets/PasswordWidget.tsx

@@ -3,8 +3,10 @@ import type { WidgetProps } from "@rjsf/utils";
 import { Input } from "@/components/ui/input";
 import { Button } from "@/components/ui/button";
 import { useState } from "react";
+import { useTranslation } from "react-i18next";
 import { LuEye, LuEyeOff } from "react-icons/lu";
 import { cn } from "@/lib/utils";
+import { REDACTED_CREDENTIAL_SENTINEL } from "@/lib/const";
 import { getSizedFieldClassName } from "../utils";
 
 export function PasswordWidget(props: WidgetProps) {
@@ -21,17 +23,31 @@ export function PasswordWidget(props: WidgetProps) {
     options,
   } = props;
 
+  const { t } = useTranslation(["common"]);
   const [showPassword, setShowPassword] = useState(false);
   const fieldClassName = getSizedFieldClassName(options, "sm");
 
+  // When the backend returns the sentinel, hide it visually and prompt the
+  // user that a value is already saved. The value stays as the sentinel in
+  // form state — backend /config/set strips it so the saved YAML is
+  // preserved when the user doesn't touch the field.
+  const isRedacted = value === REDACTED_CREDENTIAL_SENTINEL;
+  const displayValue = isRedacted ? "" : (value ?? "");
+  const effectivePlaceholder = isRedacted
+    ? t("credentialField.savedPlaceholder", {
+        ns: "common",
+        defaultValue: "Saved — leave blank to keep current",
+      })
+    : placeholder || "";
+
   return (
     <div className={cn("relative", fieldClassName)}>
       <Input
         id={id}
         type={showPassword ? "text" : "password"}
-        value={value ?? ""}
+        value={displayValue}
         disabled={disabled || readonly}
-        placeholder={placeholder || ""}
+        placeholder={effectivePlaceholder}
         onChange={(e) =>
           onChange(e.target.value === "" ? undefined : e.target.value)
         }
@@ -46,7 +62,7 @@ export function PasswordWidget(props: WidgetProps) {
         size="sm"
         className="absolute right-0 top-0 h-full px-3 hover:bg-transparent"
         onClick={() => setShowPassword(!showPassword)}
-        disabled={disabled}
+        disabled={disabled || isRedacted}
       >
         {showPassword ? (
           <LuEyeOff className="h-4 w-4" />

web/src/components/config-form/theme/widgets/SemanticSearchModelSizeWidget.tsx

@@ -0,0 +1,57 @@
+// Disables model_size and shows "N/A" when a GenAI provider is selected.
+// Reads model via LiveFormDataContext so it re-runs even when RJSF's
+// SchemaField memoization would skip this widget.
+import type { WidgetProps } from "@rjsf/utils";
+import { useContext, useEffect } from "react";
+import { useTranslation } from "react-i18next";
+import {
+  Select,
+  SelectContent,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { LiveFormDataContext } from "../../LiveFormDataContext";
+import { getSizedFieldClassName } from "../utils";
+import { SelectWidget } from "./SelectWidget";
+
+export function SemanticSearchModelSizeWidget(props: WidgetProps) {
+  const { t } = useTranslation(["views/settings"]);
+  const liveFormData = useContext(LiveFormDataContext);
+  const model = liveFormData?.model;
+  const isProvider =
+    typeof model === "string" &&
+    model !== "" &&
+    model !== "jinav1" &&
+    model !== "jinav2";
+
+  // Clear model_size while on a provider (buildOverrides converts to ""
+  // which the backend treats as "remove"). Restore the schema default
+  // when returning to a Jina model so the field isn't left empty.
+  const { value, onChange, schema } = props;
+  const schemaDefault = schema?.default as string | undefined;
+  useEffect(() => {
+    if (isProvider && value !== undefined) {
+      onChange(undefined);
+    } else if (!isProvider && value === undefined && schemaDefault) {
+      onChange(schemaDefault);
+    }
+  }, [isProvider, value, onChange, schemaDefault]);
+
+  if (isProvider) {
+    const fieldClassName = getSizedFieldClassName(props.options ?? {}, "sm");
+    return (
+      <Select value="" disabled>
+        <SelectTrigger className={fieldClassName}>
+          <SelectValue
+            placeholder={t("configForm.semanticSearchModelSize.notApplicable", {
+              defaultValue: "Not applicable for GenAI providers",
+            })}
+          />
+        </SelectTrigger>
+        <SelectContent />
+      </Select>
+    );
+  }
+
+  return <SelectWidget {...props} />;
+}

web/src/components/menu/SearchResultActions.tsx

@@ -1,5 +1,6 @@
 import { useState, ReactNode, useCallback } from "react";
 import { SearchResult } from "@/types/search";
+import { REVIEW_PADDING } from "@/types/review";
 import { FrigateConfig } from "@/types/frigateConfig";
 import { baseUrl } from "@/api/baseUrl";
 import { toast } from "sonner";
@@ -94,8 +95,8 @@ export default function SearchResultActions({
       axios
         .post("debug_replay/start", {
           camera: event.camera,
-          start_time: event.start_time,
-          end_time: event.end_time,
+          start_time: (event.start_time ?? 0) - REVIEW_PADDING,
+          end_time: (event.end_time ?? Date.now() / 1000) + REVIEW_PADDING,
         })
         .then((response) => {
           if (response.status === 202 || response.status === 200) {

web/src/components/overlay/CreateRoleDialog.tsx

@@ -26,6 +26,7 @@ import {
 import { useTranslation } from "react-i18next";
 import { FrigateConfig } from "@/types/frigateConfig";
 import { CameraNameLabel } from "../camera/FriendlyNameLabel";
+import { isReplayCamera } from "@/utils/cameraUtil";
 import { isDesktop, isMobile } from "react-device-detect";
 import { cn } from "@/lib/utils";
 import {
@@ -52,7 +53,9 @@ export default function CreateRoleDialog({
   const { t } = useTranslation(["views/settings"]);
   const [isLoading, setIsLoading] = useState<boolean>(false);
 
-  const cameras = Object.keys(config.cameras || {});
+  const cameras = Object.keys(config.cameras || {}).filter(
+    (name) => !isReplayCamera(name),
+  );
 
   const existingRoles = Object.keys(config.auth?.roles || {});
 

web/src/components/overlay/DebugReplayConfigSheet.tsx

@@ -0,0 +1,120 @@
+import { useState } from "react";
+import { useTranslation } from "react-i18next";
+import { LuSettings } from "react-icons/lu";
+import useSWR from "swr";
+import ActivityIndicator from "@/components/indicators/activity-indicator";
+import { ConfigSectionTemplate } from "@/components/config-form/sections/ConfigSectionTemplate";
+import { Button } from "@/components/ui/button";
+import { PlatformAwareSheet } from "@/components/overlay/dialog/PlatformAwareDialog";
+import { useConfigSchema } from "@/hooks/use-config-schema";
+import type { FrigateConfig } from "@/types/frigateConfig";
+
+type DebugReplayConfigSheetProps = {
+  replayCamera: string | undefined;
+};
+
+export function DebugReplayConfigSheet({
+  replayCamera,
+}: DebugReplayConfigSheetProps) {
+  const { t } = useTranslation(["views/replay"]);
+  const configSchema = useConfigSchema();
+  const { data: config } = useSWR<FrigateConfig>("config", {
+    revalidateOnFocus: false,
+  });
+  const [open, setOpen] = useState(false);
+
+  return (
+    <PlatformAwareSheet
+      trigger={
+        <Button variant="outline" size="sm" className="flex items-center gap-2">
+          <LuSettings className="size-4" />
+          <span className="hidden md:inline">{t("page.configuration")}</span>
+        </Button>
+      }
+      title={t("page.configuration")}
+      titleClassName="text-lg font-semibold"
+      contentClassName="scrollbar-container flex flex-col gap-0 overflow-y-auto px-6 pb-6 sm:max-w-xl md:max-w-2xl xl:max-w-3xl"
+      content={
+        <>
+          <p className="mb-5 text-sm text-muted-foreground">
+            {t("page.configurationDesc")}
+          </p>
+          {configSchema == null ? (
+            <div className="flex h-40 items-center justify-center">
+              <ActivityIndicator />
+            </div>
+          ) : (
+            <div className="space-y-6">
+              <ConfigSectionTemplate
+                sectionKey="detect"
+                level="replay"
+                cameraName={replayCamera}
+                skipSave
+                noStickyButtons
+                requiresRestart={false}
+                collapsible
+                defaultCollapsed={false}
+                showTitle
+                showOverrideIndicator={false}
+              />
+              <ConfigSectionTemplate
+                sectionKey="motion"
+                level="replay"
+                cameraName={replayCamera}
+                skipSave
+                noStickyButtons
+                requiresRestart={false}
+                collapsible
+                defaultCollapsed={false}
+                showTitle
+                showOverrideIndicator={false}
+              />
+              <ConfigSectionTemplate
+                sectionKey="objects"
+                level="replay"
+                cameraName={replayCamera}
+                skipSave
+                noStickyButtons
+                requiresRestart={false}
+                collapsible
+                defaultCollapsed={false}
+                showTitle
+                showOverrideIndicator={false}
+              />
+              {config?.face_recognition?.enabled && (
+                <ConfigSectionTemplate
+                  sectionKey="face_recognition"
+                  level="replay"
+                  cameraName={replayCamera}
+                  skipSave
+                  noStickyButtons
+                  requiresRestart={false}
+                  collapsible
+                  defaultCollapsed={false}
+                  showTitle
+                  showOverrideIndicator={false}
+                />
+              )}
+              {config?.lpr?.enabled && (
+                <ConfigSectionTemplate
+                  sectionKey="lpr"
+                  level="replay"
+                  cameraName={replayCamera}
+                  skipSave
+                  noStickyButtons
+                  requiresRestart={false}
+                  collapsible
+                  defaultCollapsed={false}
+                  showTitle
+                  showOverrideIndicator={false}
+                />
+              )}
+            </div>
+          )}
+        </>
+      }
+      open={open}
+      onOpenChange={setOpen}
+    />
+  );
+}

web/src/components/overlay/EditRoleCamerasDialog.tsx

@@ -25,6 +25,7 @@ import {
 import { Trans, useTranslation } from "react-i18next";
 import { FrigateConfig } from "@/types/frigateConfig";
 import { CameraNameLabel } from "@/components/camera/FriendlyNameLabel";
+import { isReplayCamera } from "@/utils/cameraUtil";
 
 type EditRoleCamerasOverlayProps = {
   show: boolean;
@@ -46,7 +47,9 @@ export default function EditRoleCamerasDialog({
   const { t } = useTranslation(["views/settings"]);
   const [isLoading, setIsLoading] = useState<boolean>(false);
 
-  const cameras = Object.keys(config.cameras || {});
+  const cameras = Object.keys(config.cameras || {}).filter(
+    (name) => !isReplayCamera(name),
+  );
 
   const formSchema = z.object({
     cameras: z

web/src/components/overlay/ExportDialog.tsx

@@ -54,6 +54,7 @@ import { Tabs, TabsContent, TabsList, TabsTrigger } from "../ui/tabs";
 import { Textarea } from "../ui/textarea";
 import { useNavigate } from "react-router-dom";
 import { useIsAdmin } from "@/hooks/use-is-admin";
+import { isReplayCamera } from "@/utils/cameraUtil";
 
 const EXPORT_OPTIONS = [
   "1",
@@ -448,7 +449,9 @@ export function ExportContent({
   );
 
   const cameraActivities = useMemo<CameraActivity[]>(() => {
-    const allCameraIds = Object.keys(config?.cameras ?? {});
+    const allCameraIds = Object.keys(config?.cameras ?? {}).filter(
+      (name) => !isReplayCamera(name),
+    );
     const byCamera = new Map<string, Event[]>();
 
     events?.forEach((event) => {

web/src/components/overlay/detail/DetailActionsMenu.tsx

@@ -63,8 +63,8 @@ export default function DetailActionsMenu({
     axios
       .post("debug_replay/start", {
         camera: search.camera,
-        start_time: search.start_time,
-        end_time: search.end_time,
+        start_time: (search.start_time ?? 0) - REVIEW_PADDING,
+        end_time: (search.end_time ?? Date.now() / 1000) + REVIEW_PADDING,
       })
       .then((response) => {
         if (response.status === 202 || response.status === 200) {

web/src/components/overlay/detail/ObjectPathPlotter.tsx

@@ -13,6 +13,7 @@ import {
 } from "@/components/ui/select";
 import { Card, CardContent } from "@/components/ui/card";
 import { formatUnixTimestampToDateTime } from "@/utils/dateUtil";
+import { isReplayCamera } from "@/utils/cameraUtil";
 import { useTimezone } from "@/hooks/use-date-utils";
 import { Button } from "@/components/ui/button";
 import { LuX } from "react-icons/lu";
@@ -36,11 +37,16 @@ export default function ObjectPathPlotter() {
   const [currentPage, setCurrentPage] = useState(1);
   const eventsPerPage = 20;
 
+  const cameraNames = useMemo(() => {
+    if (!config) return [];
+    return Object.keys(config.cameras).filter((name) => !isReplayCamera(name));
+  }, [config]);
+
   useEffect(() => {
-    if (config && !selectedCamera) {
-      setSelectedCamera(Object.keys(config.cameras)[0]);
+    if (cameraNames.length > 0 && !selectedCamera) {
+      setSelectedCamera(cameraNames[0]);
     }
-  }, [config, selectedCamera]);
+  }, [cameraNames, selectedCamera]);
 
   const searchQuery = useMemo(() => {
     if (!selectedCamera) return null;
@@ -143,12 +149,11 @@ export default function ObjectPathPlotter() {
                 <SelectValue placeholder="Select camera" />
               </SelectTrigger>
               <SelectContent>
-                {config &&
-                  Object.keys(config.cameras).map((cameraName) => (
-                    <SelectItem key={cameraName} value={cameraName}>
-                      {cameraName}
-                    </SelectItem>
-                  ))}
+                {cameraNames.map((cameraName) => (
+                  <SelectItem key={cameraName} value={cameraName}>
+                    {cameraName}
+                  </SelectItem>
+                ))}
               </SelectContent>
             </Select>
             <Select value={timeRange} onValueChange={setTimeRange}>

web/src/components/timeline/EventMenu.tsx

@@ -12,6 +12,7 @@ import { baseUrl } from "@/api/baseUrl";
 import { useNavigate } from "react-router-dom";
 import { useTranslation } from "react-i18next";
 import { Event } from "@/types/event";
+import { REVIEW_PADDING } from "@/types/review";
 import { FrigateConfig } from "@/types/frigateConfig";
 import { useCallback, useState } from "react";
 import { useIsAdmin } from "@/hooks/use-is-admin";
@@ -58,8 +59,8 @@ export default function EventMenu({
       axios
         .post("debug_replay/start", {
           camera: event.camera,
-          start_time: event.start_time,
-          end_time: event.end_time,
+          start_time: (event.start_time ?? 0) - REVIEW_PADDING,
+          end_time: (event.end_time ?? Date.now() / 1000) + REVIEW_PADDING,
         })
         .then((response) => {
           if (response.status === 202 || response.status === 200) {

web/src/hooks/use-config-override.ts

@@ -18,6 +18,7 @@ import {
 } from "@/utils/configUtil";
 import { extractSectionSchema } from "@/hooks/use-config-schema";
 import { applySchemaDefaults } from "@/lib/config-schema";
+import { isReplayCamera } from "@/utils/cameraUtil";
 
 const INTERNAL_FIELD_SUFFIXES = ["enabled_in_config", "raw_mask"];
 
@@ -602,9 +603,13 @@ function getEffectiveGlobalBaseline(
       return normalizeConfigValue(defaults as JsonValue);
     }
   }
-  const cameraSectionValues = Object.keys(config.cameras ?? {}).map((name) =>
-    normalizeConfigValue(getBaseCameraSectionValue(config, name, sectionPath)),
-  );
+  const cameraSectionValues = Object.keys(config.cameras ?? {})
+    .filter((name) => !isReplayCamera(name))
+    .map((name) =>
+      normalizeConfigValue(
+        getBaseCameraSectionValue(config, name, sectionPath),
+      ),
+    );
   return deriveSyntheticGlobalValue(cameraSectionValues, compareFields);
 }
 
@@ -684,7 +689,9 @@ export function useCamerasOverridingSection(
     const sectionMeta = OVERRIDABLE_SECTIONS.find((s) => s.key === sectionPath);
     const compareFields = sectionMeta?.compareFields;
 
-    const cameraNames = Object.keys(config.cameras);
+    const cameraNames = Object.keys(config.cameras).filter(
+      (name) => !isReplayCamera(name),
+    );
     const cameraSectionValues = cameraNames.map((name) =>
       normalizeConfigValue(
         getBaseCameraSectionValue(config, name, sectionPath),

web/src/hooks/use-has-full-camera-access.ts

@@ -1,6 +1,7 @@
 import { useAllowedCameras } from "@/hooks/use-allowed-cameras";
 import useSWR from "swr";
 import { FrigateConfig } from "@/types/frigateConfig";
+import { isReplayCamera } from "@/utils/cameraUtil";
 
 /**
  * Returns true if the current user has access to all cameras.
@@ -16,7 +17,7 @@ export function useHasFullCameraAccess() {
   if (!config?.cameras) return false;
 
   const enabledCameraNames = Object.entries(config.cameras)
-    .filter(([, cam]) => cam.enabled_in_config)
+    .filter(([name, cam]) => cam.enabled_in_config && !isReplayCamera(name))
     .map(([name]) => name);
 
   return (

web/src/lib/const.ts

@@ -1,6 +1,16 @@
 /** ONNX embedding models that require local model downloads. GenAI providers are not in this list. */
 export const JINA_EMBEDDING_MODELS = ["jinav1", "jinav2"] as const;
 
+/**
+ * Sentinel the backend substitutes for saved credentials (api keys,
+ * passwords, secrets) in /config responses. The credential widget renders
+ * this value as an empty input with a "saved — leave blank to keep" hint,
+ * and stripRedactedCredentials() removes any field still equal to this
+ * value before sending a config/set payload so the saved YAML value is
+ * preserved. Mirror of frigate.const.REDACTED_CREDENTIAL_SENTINEL.
+ */
+export const REDACTED_CREDENTIAL_SENTINEL = "__FRIGATE_SAVED_CREDENTIAL__";
+
 export const ANNOTATION_OFFSET_MIN = -10000;
 export const ANNOTATION_OFFSET_MAX = 5000;
 export const ANNOTATION_OFFSET_STEP = 50;

web/src/pages/Chat.tsx

@@ -1,20 +1,21 @@
 import { Button } from "@/components/ui/button";
-import { Input } from "@/components/ui/input";
-import { FaArrowUpLong, FaStop } from "react-icons/fa6";
 import { LuCircleAlert, LuMessageSquarePlus } from "react-icons/lu";
 import { useTranslation } from "react-i18next";
 import { useState, useCallback, useRef, useEffect, useMemo } from "react";
 import axios from "axios";
+import useSWR from "swr";
 import { ChatEventThumbnailsRow } from "@/components/chat/ChatEventThumbnailsRow";
 import { MessageBubble } from "@/components/chat/ChatMessage";
 import { ReasoningBubble } from "@/components/chat/ReasoningBubble";
 import { ToolCallsGroup } from "@/components/chat/ToolCallsGroup";
 import { ChatStartingState } from "@/components/chat/ChatStartingState";
-import { ChatAttachmentChip } from "@/components/chat/ChatAttachmentChip";
-import { ChatQuickReplies } from "@/components/chat/ChatQuickReplies";
-import { ChatPaperclipButton } from "@/components/chat/ChatPaperclipButton";
+import { ChatComposer } from "@/components/chat/ChatComposer";
 import ChatSettings from "@/components/chat/ChatSettings";
-import type { ChatMessage, ShowStatsMode } from "@/types/chat";
+import type {
+  ChatMessage,
+  GenAIModelsResponse,
+  ShowStatsMode,
+} from "@/types/chat";
 import { usePersistence } from "@/hooks/use-persistence";
 import {
   getEventIdsFromSearchObjectsToolCalls,
@@ -38,9 +39,26 @@ export default function ChatPage() {
     "chat-auto-scroll",
     true,
   );
+  const [thinkingEnabled, setThinkingEnabled] = usePersistence<boolean>(
+    "chat-thinking-enabled",
+    false,
+  );
   const scrollRef = useRef<HTMLDivElement>(null);
   const abortRef = useRef<AbortController | null>(null);
 
+  const { data: genaiInfo } = useSWR<GenAIModelsResponse>("genai/models", {
+    revalidateOnFocus: false,
+  });
+  const supportsThinking = useMemo(() => {
+    if (!genaiInfo) return false;
+    for (const entry of Object.values(genaiInfo)) {
+      if (entry.roles?.includes("chat") && entry.supports_toggleable_thinking) {
+        return true;
+      }
+    }
+    return false;
+  }, [genaiInfo]);
+
   useEffect(() => {
     document.title = t("documentTitle");
   }, [t]);
@@ -100,9 +118,10 @@ export default function ChatPage() {
           defaultErrorMessage: t("error"),
         },
         controller.signal,
+        supportsThinking ? { enableThinking: !!thinkingEnabled } : {},
       );
     },
-    [isLoading, t],
+    [isLoading, supportsThinking, t, thinkingEnabled],
   );
 
   const recentEventIds = useMemo(() => {
@@ -305,6 +324,9 @@ export default function ChatPage() {
                   setInput("");
                   submitConversation([{ role: "user", content: message }]);
                 }}
+                supportsThinking={supportsThinking}
+                thinkingEnabled={!!thinkingEnabled}
+                setThinkingEnabled={setThinkingEnabled}
               />
             )}
           </div>
@@ -313,7 +335,7 @@ export default function ChatPage() {
       {hasStarted && (
         <div className="flex shrink-0 justify-center p-2 md:px-4 md:pb-4">
           <div className="flex w-full xl:w-[50%] 3xl:w-[35%]">
-            <ChatEntry
+            <ChatComposer
               input={input}
               setInput={setInput}
               sendMessage={sendMessage}
@@ -324,6 +346,9 @@ export default function ChatPage() {
               onAttach={setAttachedEventId}
               onStop={stopGeneration}
               recentEventIds={recentEventIds}
+              supportsThinking={supportsThinking}
+              thinkingEnabled={!!thinkingEnabled}
+              setThinkingEnabled={setThinkingEnabled}
             />
           </div>
         </div>
@@ -331,89 +356,3 @@ export default function ChatPage() {
     </div>
   );
 }
-
-type ChatEntryProps = {
-  input: string;
-  setInput: (value: string) => void;
-  sendMessage: (textOverride?: string) => void;
-  isLoading: boolean;
-  placeholder: string;
-  attachedEventId: string | null;
-  onClearAttachment: () => void;
-  onAttach: (eventId: string) => void;
-  onStop: () => void;
-  recentEventIds: string[];
-};
-
-function ChatEntry({
-  input,
-  setInput,
-  sendMessage,
-  isLoading,
-  placeholder,
-  attachedEventId,
-  onClearAttachment,
-  onAttach,
-  onStop,
-  recentEventIds,
-}: ChatEntryProps) {
-  const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
-    if (e.key === "Enter" && !e.shiftKey) {
-      e.preventDefault();
-      sendMessage();
-    }
-  };
-
-  return (
-    <div className="flex w-full flex-col items-stretch justify-center gap-2 rounded-xl bg-secondary p-3">
-      {attachedEventId && (
-        <div className="flex items-center">
-          <ChatAttachmentChip
-            eventId={attachedEventId}
-            mode="composer"
-            onRemove={onClearAttachment}
-          />
-        </div>
-      )}
-      {attachedEventId && (
-        <ChatQuickReplies
-          onSend={(text) => sendMessage(text)}
-          disabled={isLoading}
-        />
-      )}
-      <div className="flex w-full flex-row items-center gap-2">
-        <ChatPaperclipButton
-          recentEventIds={recentEventIds}
-          onAttach={onAttach}
-          disabled={isLoading || attachedEventId != null}
-        />
-        <Input
-          className="w-full flex-1 border-transparent bg-transparent shadow-none focus-visible:ring-0 dark:bg-transparent"
-          placeholder={placeholder}
-          value={input}
-          onChange={(e) => setInput(e.target.value)}
-          onKeyDown={handleKeyDown}
-          aria-busy={isLoading}
-        />
-        {isLoading ? (
-          <Button
-            variant="destructive"
-            className="size-10 shrink-0 rounded-full"
-            onClick={onStop}
-          >
-            <FaStop className="size-3" />
-          </Button>
-        ) : (
-          <Button
-            variant="select"
-            className="size-10 shrink-0 rounded-full"
-            disabled={!input.trim()}
-            onClick={() => sendMessage()}
-          >
-            <FaArrowUpLong className="size-4" />
-          </Button>
-        )}
-      </div>
-    </div>
-  );
-}

web/src/pages/Events.tsx

@@ -637,7 +637,7 @@ export default function Events() {
     }
 
     setStartTime(recording.startTime);
-    const allCameras = reviewFilter?.cameras ?? Object.keys(config.cameras);
+    const allCameras = reviewFilter?.cameras ?? allowedCameras;
 
     return {
       camera: recording.camera,

web/src/pages/Replay.tsx

@@ -27,7 +27,7 @@ import {
   PopoverContent,
   PopoverTrigger,
 } from "@/components/ui/popover";
-import { PlatformAwareSheet } from "@/components/overlay/dialog/PlatformAwareDialog";
+import { DebugReplayConfigSheet } from "@/components/overlay/DebugReplayConfigSheet";
 import { useCameraActivity } from "@/hooks/use-camera-activity";
 import { cn } from "@/lib/utils";
 import Heading from "@/components/ui/heading";
@@ -40,16 +40,14 @@ import { Progress } from "@/components/ui/progress";
 import { ObjectType } from "@/types/ws";
 import { useJobStatus } from "@/api/ws";
 import WsMessageFeed from "@/components/ws/WsMessageFeed";
-import { ConfigSectionTemplate } from "@/components/config-form/sections/ConfigSectionTemplate";
 
-import { LuExternalLink, LuInfo, LuSettings } from "react-icons/lu";
+import { LuExternalLink, LuInfo } from "react-icons/lu";
 import { LuSquare } from "react-icons/lu";
 import { MdReplay } from "react-icons/md";
 import { isDesktop, isMobile } from "react-device-detect";
 import Logo from "@/components/Logo";
 import { Separator } from "@/components/ui/separator";
 import { useDocDomain } from "@/hooks/use-doc-domain";
-import { useConfigSchema } from "@/hooks/use-config-schema";
 import DebugDrawingLayer from "@/components/overlay/DebugDrawingLayer";
 import { IoMdArrowRoundBack } from "react-icons/io";
 
@@ -121,11 +119,10 @@ export default function Replay() {
     mutate: refreshStatus,
     isLoading,
   } = useSWR<DebugReplayStatus>("debug_replay/status", {
-    refreshInterval: 1000,
+    refreshInterval: (latestData) => (latestData?.live_ready ? 0 : 1000),
   });
   const { payload: replayJob } =
     useJobStatus<DebugReplayJobResults>("debug_replay");
-  const configSchema = useConfigSchema();
   const [isInitializing, setIsInitializing] = useState(true);
 
   // Refresh status immediately on mount to avoid showing "no session" briefly
@@ -139,7 +136,6 @@ export default function Replay() {
 
   const [options, setOptions] = useState<DebugOptions>(DEFAULT_OPTIONS);
   const [isStopping, setIsStopping] = useState(false);
-  const [configDialogOpen, setConfigDialogOpen] = useState(false);
 
   const searchParams = useMemo(() => {
     const params = new URLSearchParams();
@@ -327,63 +323,8 @@ export default function Replay() {
           )}
         </Button>
         <div className="flex items-center gap-2">
-          <PlatformAwareSheet
-            trigger={
-              <Button
-                variant="outline"
-                size="sm"
-                className="flex items-center gap-2"
-              >
-                <LuSettings className="size-4" />
-                <span className="hidden md:inline">
-                  {t("page.configuration")}
-                </span>
-              </Button>
-            }
-            title={t("page.configuration")}
-            titleClassName="text-lg font-semibold"
-            contentClassName="scrollbar-container flex flex-col gap-0 overflow-y-auto px-6 pb-6 sm:max-w-xl md:max-w-2xl xl:max-w-3xl"
-            content={
-              <>
-                <p className="mb-5 text-sm text-muted-foreground">
-                  {t("page.configurationDesc")}
-                </p>
-                {configSchema == null ? (
-                  <div className="flex h-40 items-center justify-center">
-                    <ActivityIndicator />
-                  </div>
-                ) : (
-                  <div className="space-y-6">
-                    <ConfigSectionTemplate
-                      sectionKey="motion"
-                      level="replay"
-                      cameraName={status.replay_camera ?? undefined}
-                      skipSave
-                      noStickyButtons
-                      requiresRestart={false}
-                      collapsible
-                      defaultCollapsed={false}
-                      showTitle
-                      showOverrideIndicator={false}
-                    />
-                    <ConfigSectionTemplate
-                      sectionKey="objects"
-                      level="replay"
-                      cameraName={status.replay_camera ?? undefined}
-                      skipSave
-                      noStickyButtons
-                      requiresRestart={false}
-                      collapsible
-                      defaultCollapsed={false}
-                      showTitle
-                      showOverrideIndicator={false}
-                    />
-                  </div>
-                )}
-              </>
-            }
-            open={configDialogOpen}
-            onOpenChange={setConfigDialogOpen}
+          <DebugReplayConfigSheet
+            replayCamera={status.replay_camera ?? undefined}
           />
 
           <AlertDialog>

web/src/pages/Settings.tsx

@@ -100,6 +100,7 @@ import {
 } from "@/utils/configUtil";
 import type { ProfileState, ProfilesApiResponse } from "@/types/profile";
 import { getProfileColor } from "@/utils/profileColors";
+import { isReplayCamera } from "@/utils/cameraUtil";
 import { ProfileSectionDropdown } from "@/components/settings/ProfileSectionDropdown";
 import ActivityIndicator from "@/components/indicators/activity-indicator";
 import RestartDialog from "@/components/overlay/dialog/RestartDialog";
@@ -661,7 +662,12 @@ export default function Settings() {
     }
 
     return Object.values(config.cameras)
-      .filter((conf) => conf.ui.dashboard && conf.enabled_in_config)
+      .filter(
+        (conf) =>
+          conf.ui.dashboard &&
+          conf.enabled_in_config &&
+          !isReplayCamera(conf.name),
+      )
       .sort((aConf, bConf) => aConf.ui.order - bConf.ui.order);
   }, [config]);
 

web/src/types/chat.ts

@@ -25,3 +25,11 @@ export type ChatStats = {
 };
 
 export type ShowStatsMode = "while_generating" | "always";
+
+export type GenAIProviderInfo = {
+  models: string[];
+  roles: string[];
+  supports_toggleable_thinking: boolean;
+};
+
+export type GenAIModelsResponse = Record<string, GenAIProviderInfo>;

web/src/utils/chatUtil.ts

@@ -34,12 +34,17 @@ type StreamChunk =
  * POST to chat/completion with stream: true, parse NDJSON stream, and invoke
  * callbacks so the caller can update UI (e.g. React state).
  */
+export type StreamChatOptions = {
+  enableThinking?: boolean;
+};
+
 export async function streamChatCompletion(
   url: string,
   headers: Record<string, string>,
   apiMessages: { role: string; content: string }[],
   callbacks: StreamChatCallbacks,
   signal?: AbortSignal,
+  options: StreamChatOptions = {},
 ): Promise<void> {
   const {
     updateMessages,
@@ -50,10 +55,17 @@ export async function streamChatCompletion(
   } = callbacks;
 
   try {
+    const body: Record<string, unknown> = {
+      messages: apiMessages,
+      stream: true,
+    };
+    if (options.enableThinking !== undefined) {
+      body.enable_thinking = options.enableThinking;
+    }
     const res = await fetch(url, {
       method: "POST",
       headers,
-      body: JSON.stringify({ messages: apiMessages, stream: true }),
+      body: JSON.stringify(body),
       signal,
     });
 

web/src/utils/configUtil.ts

@@ -11,6 +11,7 @@ import isEqual from "lodash/isEqual";
 import mergeWith from "lodash/mergeWith";
 import set from "lodash/set";
 import { isJsonObject } from "@/lib/utils";
+import { REDACTED_CREDENTIAL_SENTINEL } from "@/lib/const";
 import { applySchemaDefaults } from "@/lib/config-schema";
 import { normalizeConfigValue } from "@/hooks/use-config-override";
 import {
@@ -29,6 +30,33 @@ import type {
 import type { SectionConfig } from "../components/config-form/sections/BaseSection";
 import { sectionConfigs } from "../components/config-form/sectionConfigs";
 
+/**
+ * Recursively strip any key whose value is the redaction sentinel from a
+ * config_data payload. Use just before sending to /config/set so untouched
+ * credential placeholder fields don't clobber the saved YAML value. Mutates
+ * and returns the input.
+ */
+export function stripRedactedCredentials<T>(value: T): T {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      stripRedactedCredentials(item);
+    }
+    return value;
+  }
+  if (value && typeof value === "object") {
+    const obj = value as Record<string, unknown>;
+    for (const key of Object.keys(obj)) {
+      const v = obj[key];
+      if (v === REDACTED_CREDENTIAL_SENTINEL) {
+        delete obj[key];
+      } else if (v && typeof v === "object") {
+        stripRedactedCredentials(v);
+      }
+    }
+  }
+  return value;
+}
+
 // ---------------------------------------------------------------------------
 // cameraUpdateTopicMap — maps config section paths to MQTT/WS update topics
 // ---------------------------------------------------------------------------
@@ -201,7 +229,12 @@ export function buildOverrides(
 
     const result: JsonObject = {};
     for (const [key, value] of Object.entries(currentObj)) {
-      if (value === undefined && baseObj && baseObj[key] !== undefined) {
+      if (
+        (value === undefined || value === null) &&
+        baseObj &&
+        baseObj[key] !== undefined &&
+        baseObj[key] !== null
+      ) {
         result[key] = "";
         continue;
       }

web/src/views/events/EventView.tsx

@@ -32,6 +32,7 @@ import {
   ZoomLevel,
 } from "@/types/review";
 import { getChunkedTimeRange } from "@/utils/timelineUtil";
+import { isReplayCamera } from "@/utils/cameraUtil";
 import { getEndOfDayTimestamp } from "@/utils/dateUtil";
 import axios from "axios";
 import {
@@ -1015,12 +1016,14 @@ function MotionReview({
 
     let cameras;
     if (!filter || !filter.cameras) {
-      cameras = Object.values(config.cameras);
+      cameras = Object.values(config.cameras).filter(
+        (cam) => !isReplayCamera(cam.name),
+      );
     } else {
       const filteredCams = filter.cameras;
 
-      cameras = Object.values(config.cameras).filter((cam) =>
-        filteredCams.includes(cam.name),
+      cameras = Object.values(config.cameras).filter(
+        (cam) => filteredCams.includes(cam.name) && !isReplayCamera(cam.name),
       );
     }
 

web/src/views/settings/CameraManagementView.tsx

@@ -36,7 +36,15 @@ import axios from "axios";
 import ActivityIndicator from "@/components/indicators/activity-indicator";
 import RestartDialog from "@/components/overlay/dialog/RestartDialog";
 import RestartRequiredIndicator from "@/components/indicators/RestartRequiredIndicator";
-import TextEntryDialog from "@/components/overlay/dialog/TextEntryDialog";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
 import {
   Tooltip,
   TooltipContent,
@@ -44,6 +52,7 @@ import {
 } from "@/components/ui/tooltip";
 import type { ProfileState } from "@/types/profile";
 import { getProfileColor } from "@/utils/profileColors";
+import { isReplayCamera } from "@/utils/cameraUtil";
 import { cn } from "@/lib/utils";
 import {
   Select,
@@ -52,6 +61,17 @@ import {
   SelectTrigger,
   SelectValue,
 } from "@/components/ui/select";
+import {
+  Form,
+  FormControl,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+} from "@/components/ui/form";
+import { useForm } from "react-hook-form";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { z } from "zod";
 
 const REORDER_SAVED_INDICATOR_MS = 1500;
 
@@ -87,7 +107,10 @@ export default function CameraManagementView({
   const enabledCameras = useMemo(() => {
     if (config) {
       return Object.keys(config.cameras)
-        .filter((camera) => config.cameras[camera].enabled_in_config)
+        .filter(
+          (camera) =>
+            config.cameras[camera].enabled_in_config && !isReplayCamera(camera),
+        )
         .sort((a, b) => {
           const orderA = config.cameras[a].ui?.order ?? 0;
           const orderB = config.cameras[b].ui?.order ?? 0;
@@ -180,7 +203,11 @@ export default function CameraManagementView({
   const disabledCameras = useMemo(() => {
     if (config) {
       return Object.keys(config.cameras)
-        .filter((camera) => !config.cameras[camera].enabled_in_config)
+        .filter(
+          (camera) =>
+            !config.cameras[camera].enabled_in_config &&
+            !isReplayCamera(camera),
+        )
         .sort();
     }
     return [];
@@ -188,7 +215,9 @@ export default function CameraManagementView({
 
   const allCameras = useMemo(() => {
     if (config) {
-      return Object.keys(config.cameras).sort();
+      return Object.keys(config.cameras)
+        .filter((camera) => !isReplayCamera(camera))
+        .sort();
     }
     return [];
   }, [config]);
@@ -472,7 +501,7 @@ function EnabledCameraRow({
           <LuGripVertical className="size-4" />
         </button>
         <CameraNameLabel camera={camera} />
-        <CameraFriendlyNameEditor
+        <CameraDetailsEditor
           cameraName={camera}
           onConfigChanged={onConfigChanged}
         />
@@ -509,25 +538,91 @@ function CameraEnableSwitch({ cameraName }: CameraEnableSwitchProps) {
   );
 }
 
-type CameraFriendlyNameEditorProps = {
+type CameraDetailsEditorProps = {
   cameraName: string;
   onConfigChanged: () => Promise<unknown>;
 };
 
-function CameraFriendlyNameEditor({
+type CameraDetailsFormValues = {
+  friendlyName: string;
+  webuiUrl: string;
+};
+
+function CameraDetailsEditor({
   cameraName,
   onConfigChanged,
-}: CameraFriendlyNameEditorProps) {
+}: CameraDetailsEditorProps) {
   const { t } = useTranslation(["views/settings", "common"]);
   const { data: config } = useSWR<FrigateConfig>("config");
   const [open, setOpen] = useState(false);
   const [isSaving, setIsSaving] = useState(false);
 
   const currentFriendlyName = config?.cameras?.[cameraName]?.friendly_name;
+  const currentWebuiUrl = config?.cameras?.[cameraName]?.webui_url;
 
-  const onSave = useCallback(
-    async (text: string) => {
+  const formSchema = useMemo(
+    () =>
+      z.object({
+        friendlyName: z.string(),
+        webuiUrl: z.string().refine(
+          (val) => {
+            const trimmed = val.trim();
+            if (!trimmed) return true;
+            try {
+              new URL(trimmed);
+              return true;
+            } catch {
+              return false;
+            }
+          },
+          {
+            message: t("cameraManagement.streams.details.webuiUrlInvalid", {
+              ns: "views/settings",
+            }),
+          },
+        ),
+      }),
+    [t],
+  );
+
+  const form = useForm<CameraDetailsFormValues>({
+    resolver: zodResolver(formSchema),
+    defaultValues: {
+      friendlyName: currentFriendlyName ?? "",
+      webuiUrl: currentWebuiUrl ?? "",
+    },
+  });
+
+  // Reset form values from config whenever the dialog is opened.
+  useEffect(() => {
+    if (open) {
+      form.reset({
+        friendlyName: currentFriendlyName ?? "",
+        webuiUrl: currentWebuiUrl ?? "",
+      });
+    }
+  }, [open, currentFriendlyName, currentWebuiUrl, form]);
+
+  const onSubmit = useCallback(
+    async (values: CameraDetailsFormValues) => {
       if (isSaving) return;
+
+      // only send fields the user actually changed
+      const newFriendly = values.friendlyName.trim() || null;
+      const newWebui = values.webuiUrl.trim() || null;
+      const cameraUpdate: Record<string, string | null> = {};
+      if (newFriendly !== (currentFriendlyName ?? null)) {
+        cameraUpdate.friendly_name = newFriendly;
+      }
+      if (newWebui !== (currentWebuiUrl ?? null)) {
+        cameraUpdate.webui_url = newWebui;
+      }
+
+      if (Object.keys(cameraUpdate).length === 0) {
+        setOpen(false);
+        return;
+      }
+
       setIsSaving(true);
 
       try {
@@ -535,9 +630,7 @@ function CameraFriendlyNameEditor({
           requires_restart: 0,
           config_data: {
             cameras: {
-              [cameraName]: {
-                friendly_name: text.trim() || null,
-              },
+              [cameraName]: cameraUpdate,
             },
           },
         });
@@ -563,10 +656,17 @@ function CameraFriendlyNameEditor({
         setIsSaving(false);
       }
     },
-    [cameraName, isSaving, onConfigChanged, t],
+    [
+      cameraName,
+      currentFriendlyName,
+      currentWebuiUrl,
+      isSaving,
+      onConfigChanged,
+      t,
+    ],
   );
 
-  const renameLabel = t("cameraManagement.streams.friendlyName.rename", {
+  const editLabel = t("cameraManagement.streams.details.edit", {
     ns: "views/settings",
   });
 
@@ -578,30 +678,107 @@ function CameraFriendlyNameEditor({
             variant="ghost"
             size="icon"
             className="size-7"
-            aria-label={renameLabel}
+            aria-label={editLabel}
             onClick={() => setOpen(true)}
             disabled={isSaving}
           >
             <LuPencil className="size-3.5" />
           </Button>
         </TooltipTrigger>
-        <TooltipContent>{renameLabel}</TooltipContent>
+        <TooltipContent>{editLabel}</TooltipContent>
       </Tooltip>
-      <TextEntryDialog
-        open={open}
-        setOpen={setOpen}
-        title={t("cameraManagement.streams.friendlyName.title", {
-          ns: "views/settings",
-        })}
-        description={t("cameraManagement.streams.friendlyName.description", {
-          ns: "views/settings",
-        })}
-        defaultValue={currentFriendlyName ?? ""}
-        placeholder={currentFriendlyName ? undefined : cameraName}
-        allowEmpty
-        isSaving={isSaving}
-        onSave={onSave}
-      />
+      <Dialog open={open} onOpenChange={setOpen}>
+        <DialogContent>
+          <DialogHeader>
+            <DialogTitle>
+              {t("cameraManagement.streams.details.title", {
+                ns: "views/settings",
+              })}
+            </DialogTitle>
+            <DialogDescription>
+              {t("cameraManagement.streams.details.description", {
+                ns: "views/settings",
+              })}
+            </DialogDescription>
+          </DialogHeader>
+          <Form {...form}>
+            <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-4">
+              <FormField
+                control={form.control}
+                name="friendlyName"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>
+                      {t("cameraManagement.streams.details.friendlyNameLabel", {
+                        ns: "views/settings",
+                      })}
+                    </FormLabel>
+                    <FormControl>
+                      <Input
+                        {...field}
+                        placeholder={cameraName}
+                        disabled={isSaving}
+                        autoFocus
+                      />
+                    </FormControl>
+                    <p className="text-xs text-muted-foreground">
+                      {t("cameraManagement.streams.details.friendlyNameHelp", {
+                        ns: "views/settings",
+                      })}
+                    </p>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+              <FormField
+                control={form.control}
+                name="webuiUrl"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>
+                      {t("cameraManagement.streams.details.webuiUrlLabel", {
+                        ns: "views/settings",
+                      })}
+                    </FormLabel>
+                    <FormControl>
+                      <Input
+                        {...field}
+                        placeholder="https://"
+                        disabled={isSaving}
+                      />
+                    </FormControl>
+                    <p className="text-xs text-muted-foreground">
+                      {t("cameraManagement.streams.details.webuiUrlHelp", {
+                        ns: "views/settings",
+                      })}
+                    </p>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+              <DialogFooter className="pt-2">
+                <Button
+                  type="button"
+                  disabled={isSaving}
+                  onClick={() => setOpen(false)}
+                >
+                  {t("button.cancel", { ns: "common" })}
+                </Button>
+                <Button variant="select" type="submit" disabled={isSaving}>
+                  {isSaving ? (
+                    <div className="flex flex-row items-center gap-2">
+                      <ActivityIndicator className="size-4" />
+                      <span>{t("button.saving", { ns: "common" })}</span>
+                    </div>
+                  ) : (
+                    t("button.save", { ns: "common" })
+                  )}
+                </Button>
+              </DialogFooter>
+            </form>
+          </Form>
+        </DialogContent>
+      </Dialog>
     </>
   );
 }

web/src/views/settings/FrigatePlusSettingsView.tsx

@@ -16,6 +16,7 @@ import FrigatePlusCurrentModelSummary from "@/views/settings/components/FrigateP
 import { useDocDomain } from "@/hooks/use-doc-domain";
 import { CameraNameLabel } from "@/components/camera/FriendlyNameLabel";
 import { FrigateConfig } from "@/types/frigateConfig";
+import { isReplayCamera } from "@/utils/cameraUtil";
 import type { SettingsPageProps } from "@/views/settings/SingleSectionPage";
 
 export default function FrigatePlusSettingsView(_props: SettingsPageProps) {
@@ -139,8 +140,9 @@ export default function FrigatePlusSettingsView(_props: SettingsPageProps) {
                         </tr>
                       </thead>
                       <tbody>
-                        {Object.entries(config.cameras).map(
-                          ([name, camera]) => (
+                        {Object.entries(config.cameras)
+                          .filter(([name]) => !isReplayCamera(name))
+                          .map(([name, camera]) => (
                             <tr
                               key={name}
                               className="border-b border-secondary"
@@ -156,8 +158,7 @@ export default function FrigatePlusSettingsView(_props: SettingsPageProps) {
                                 )}
                               </td>
                             </tr>
-                          ),
-                        )}
+                          ))}
                       </tbody>
                     </table>
                   </div>

web/src/views/settings/ProfilesView.tsx

@@ -19,6 +19,7 @@ import type { JsonObject } from "@/types/configForm";
 import type { ProfileState, ProfilesApiResponse } from "@/types/profile";
 import { getProfileColor } from "@/utils/profileColors";
 import { PROFILE_ELIGIBLE_SECTIONS } from "@/utils/configUtil";
+import { isReplayCamera } from "@/utils/cameraUtil";
 import { resolveCameraName } from "@/hooks/use-camera-friendly-name";
 import { useDocDomain } from "@/hooks/use-doc-domain";
 import { cn } from "@/lib/utils";
@@ -145,7 +146,9 @@ export default function ProfilesView({
     if (!config || allProfileNames.length === 0) return {};
 
     const data: Record<string, Record<string, string[]>> = {};
-    const cameras = Object.keys(config.cameras).sort();
+    const cameras = Object.keys(config.cameras)
+      .filter((name) => !isReplayCamera(name))
+      .sort();
 
     for (const profile of allProfileNames) {
       data[profile] = {};

web/src/views/system/CameraMetrics.tsx

@@ -25,6 +25,7 @@ import useSWR from "swr";
 import { useTranslation } from "react-i18next";
 import { CameraNameLabel } from "@/components/camera/FriendlyNameLabel";
 import { resolveCameraName } from "@/hooks/use-camera-friendly-name";
+import { isReplayCamera } from "@/utils/cameraUtil";
 
 type CameraMetricsProps = {
   lastUpdated: number;
@@ -316,7 +317,7 @@ export default function CameraMetrics({
       <div className="grid grid-cols-1 gap-6 md:grid-cols-2">
         {config &&
           Object.values(config.cameras).map((camera) => {
-            if (camera.enabled) {
+            if (camera.enabled && !isReplayCamera(camera.name)) {
               return (
                 <Fragment key={camera.name}>
                   {probeCameraName == camera.name && (