Merge b0588a02f9 into 81b53b7835

* resolve zone friendly names against the correct camera

* Improve handling of zone names in chat prompt

* show a numeric keyboard for numeric config form fields on mobile

* Specify english only for semantic search tool when model is JinaV1

* resolve export hwaccel args global value against the correct config path

---------

Co-authored-by: Nicolas Mowen <nickmowen213@gmail.com>

docker/main/requirements-wheels.txt

@@ -1,4 +1,4 @@
-aiofiles == 24.1.*
+anyio == 4.14.*
 click == 8.1.*
 # FastAPI
 aiohttp == 3.12.*

docker/main/rootfs/usr/local/nginx/conf/nginx.conf

@@ -274,6 +274,13 @@ http {
                 include proxy.conf;
             }
 
+            location /api/logout {
+                auth_request off;
+                rewrite ^/api(/.*)$ $1 break;
+                proxy_pass http://frigate_api;
+                include proxy.conf;
+            }
+
             # Allow unauthenticated access to the first_time_login endpoint
             # so the login page can load help text before authentication.
             location /api/auth/first_time_login {

docs/docs/integrations/home-assistant.md

@@ -9,6 +9,8 @@ The best way to integrate with Home Assistant is to use the [official integratio
 
 ### Preparation
 
+Frigate itself must be installed and running before setting up the integration. See the [installation documentation](../frigate/installation.md) for details.
+
 The Frigate integration requires the `mqtt` integration to be installed and
 manually configured first.
 

docs/docs/troubleshooting/dummy-camera.md

@@ -39,7 +39,9 @@ The per-clip variation is typically quite low and is mostly an artifact of keyfr
 
 Debug Replay lets you re-run Frigate's detection pipeline against a section of recorded video without manually configuring a dummy camera. It automatically extracts the recording, creates a temporary camera with the same detection settings as the original, and loops the clip through the pipeline so you can observe detections in real time.
 
-Debug Replay isn't intended to be a one-stop pane for all Frigate diagnostics or a comprehensive debugging environment for every Frigate feature. It merely makes it easier to spin up a "dummy camera" and perform some common adjustments in real-time. You'll still need to use the normal tools (logs, an MQTT client, etc) to debug your feature.
+The replay camera behaves like a live camera feed rather than History's video player: it loops the clip continuously as Frigate analyzes it and has no playback controls, so you cannot pause, scrub, or step through it frame by frame.
+
+Debug Replay isn't intended to be a one-stop pane for all Frigate diagnostics or a comprehensive debugging environment for every Frigate feature. It merely makes it easier to spin up a "dummy camera" and perform some common adjustments in real time. You'll still need to use the normal tools (logs, an MQTT client, etc) to debug your feature.
 
 ### When to use
 

docs/docs/troubleshooting/recordings.md

@@ -3,6 +3,8 @@ id: recordings
 title: Recordings Errors
 ---
 
+import FaqItem from "@site/src/components/FaqItem";
+
 ## Why are my recordings not working? (empty Recordings, "No recordings found for this time")
 
 If Frigate shows live video but the History view is empty, or you see "No recordings found for this time", the cause is almost always in one of the three categories below. Segments are first written to the RAM cache and are only moved to disk if they match a retention policy _and_ the camera's `record` stream is producing valid, storable video. Work through the categories in order: retention configuration is by far the most common cause.
@@ -19,7 +21,7 @@ A healthy camera logs lines like `Copied /media/frigate/recordings/{segment_path
 
 ### Retention configuration issues
 
-#### Recording is enabled, but nothing is saved
+<FaqItem id="recording-is-enabled-but-nothing-is-saved" question="Recording is enabled, but nothing is saved">
 
 This is the single most common cause. Setting `record.enabled: True` on its own does **not** keep any footage: **continuous recording is disabled by default**, and segments in the cache are only moved to disk if they match a configured retention policy. You must configure at least one of `continuous`, `motion`, `alerts`, or `detections` retention.
 
@@ -34,7 +36,9 @@ record:
 
 See [Recording](/configuration/record) for the full set of common configurations, including reduced-storage and alerts-only setups.
 
-#### Motion or event-only recording keeps less than you expect
+</FaqItem>
+
+<FaqItem id="motion-or-event-only-recording-keeps-less-than-you-expect" question="Motion or event-only recording keeps less than you expect">
 
 If you only configured `motion`, `alerts`, or `detections` retention (with no `continuous`), Frigate keeps footage selectively based on the retention `mode`:
 
@@ -44,20 +48,26 @@ If you only configured `motion`, `alerts`, or `detections` retention (with no `c
 
 If you expected continuous footage but only configured motion/event retention, add a `continuous` retention period as shown above. To verify motion is actually being detected, watch the motion boxes in the debug view or the Motion Tuner in the UI.
 
-#### Alert and detection recordings require working object detection
+</FaqItem>
+
+<FaqItem id="alert-and-detection-recordings-require-working-object-detection" question="Alert and detection recordings require working object detection">
 
 `alerts` and `detections` retention only keep footage that overlaps a tracked object, so they depend on object detection running:
 
 - **Detection must be enabled.** If `detect: enabled: False`, no alerts or detections are ever created, so alert/detection retention keeps nothing. (Continuous and motion retention still work with detection disabled.)
 - **The object must be supported by your model.** If you track an object your model doesn't support (for example `deer` or `license_plate` on the default model), Frigate never detects it and never records for it. Check your logs for warnings such as `... is configured to track ['deer'] objects, which are not supported by the current model` and remove unsupported objects or switch to a model (e.g. [Frigate+](/plus/)) that includes them.
 
-#### You're following an outdated guide
+</FaqItem>
+
+<FaqItem id="youre-following-an-outdated-guide" question="You're following an outdated guide">
 
 Configuration keys change between major versions. The old `clips` config, for example, has not existed for a long time. If you copied a config from an old blog post or video, verify every key against the current [reference config](/configuration/advanced/reference).
 
+</FaqItem>
+
 ### Camera and stream issues
 
-#### Incompatible audio codec (recordings silently fail to save)
+<FaqItem id="incompatible-audio-codec-recordings-silently-fail-to-save" question="Incompatible audio codec (recordings silently fail to save)">
 
 Frigate stores recordings in an MP4 container, and some camera audio codecs (most commonly `pcm_alaw`, `pcm_mulaw`, or other G.711 variants) **cannot be placed in an MP4 container**. When this happens, ffmpeg fails to write the segment and no recording is saved, even though the live view works fine. This is a frequent cause on Tapo, TP-Link VIGI, and some Reolink cameras.
 
@@ -72,7 +82,9 @@ cameras:
         # or preset-record-generic to record with no audio
 ```
 
-#### The record stream isn't connecting
+</FaqItem>
+
+<FaqItem id="the-record-stream-isnt-connecting" question="The record stream isn't connecting">
 
 A message like `No new recording segments were created for <camera> in the last 120s` means ffmpeg cannot read the `record` stream. To diagnose:
 
@@ -81,17 +93,11 @@ A message like `No new recording segments were created for <camera> in the last
 - Test the exact RTSP URL (with the correct path, port, and credentials) in VLC or `ffplay`.
 - If you restream through go2rtc, make sure the `record` input path points at the correct go2rtc stream name. Copying a config between cameras without updating the stream name is a common mistake.
 
-#### Recordings play back with no video (or won't play at all)
-
-Frigate copies the `record` stream directly without re-encoding, so playback depends on your browser supporting the camera's codec. H265/HEVC recordings may not be playable in some browsers. If recordings appear as audio-only or a black screen, your camera is likely sending a codec your browser can't decode. Configure the camera to output **H264** for maximum compatibility.
-
-#### Segments are only ~1 second long
-
-If the record stream uses a "Smart Codec"/H.264+ mode or changes encoding parameters mid-stream, corrupt timestamps cause segments to be split far too frequently and fill the cache. This produces the "Too many unprocessed recording segments" warning. See [that section below](#i-see-the-message-warning--too-many-unprocessed-recording-segments-in-cache-for-camera-this-likely-indicates-an-issue-with-the-detect-stream) for the full diagnosis.
+</FaqItem>
 
 ### Storage and mounting issues
 
-#### The storage volume isn't mounted correctly
+<FaqItem id="the-storage-volume-isnt-mounted-correctly" question="The storage volume isn't mounted correctly">
 
 If the recordings volume (`/media/frigate`) points at the wrong location, isn't writable, or a network/encrypted mount failed to mount at boot, Frigate cannot save recordings, or it silently writes to the boot drive and then purges aggressively because the drive appears far smaller than expected.
 
@@ -100,21 +106,114 @@ If the recordings volume (`/media/frigate`) points at the wrong location, isn't
 - For a mount that may fail intermittently, protecting the mount point with `chattr +i` on an empty directory forces Frigate to error out (rather than silently writing to the boot drive) when the mount is missing.
 - Check `dmesg` and system logs for filesystem or I/O errors around the time recordings disappeared.
 
-If recordings _are_ being written but the copy is too slow to keep up, see the ["Unable to keep up with recording segments"](#i-see-the-message-warning--unable-to-keep-up-with-recording-segments-in-cache-for-camera-keeping-the-5-most-recent-segments-out-of-6-and-discarding-the-rest) section below.
+If recordings _are_ being written but the copy is too slow to keep up, see the ["Unable to keep up with recording segments"](#i-see-the-message-warning--unable-to-keep-up-with-recording-segments-in-cache-for-camera-keeping-the-5-most-recent-segments-out-of-6-and-discarding-the-rest) question below.
 
-## I have Frigate configured for motion recording only, but it still seems to be recording even with no motion. Why?
+</FaqItem>
 
-You'll want to:
+## Recordings won't play back
 
-- Make sure your camera's timestamp is masked out with a motion mask. Even if there is no motion occurring in your scene, your motion settings may be sensitive enough to count your timestamp as motion.
-- If you have audio detection enabled, keep in mind that audio that is heard above `min_volume` is considered motion.
-- [Tune your motion detection settings](/configuration/motion_detection) either by editing your config file or by using the UI's Motion Tuner.
+<FaqItem id="pipeline-error-decode" question={"Recordings won't play back: \"PIPELINE_ERROR_DECODE\" (or \"Media failed to decode\")"}>
 
-## I see the message: WARNING : Unable to keep up with recording segments in cache for camera. Keeping the 5 most recent segments out of 6 and discarding the rest...
+When a recording refuses to play in the Frigate UI and you see an error like `Failed to play recordings (error 3): PIPELINE_ERROR_DECODE`, the message is coming from **your browser**, not from Frigate. `PIPELINE_ERROR_DECODE` is emitted exclusively by the media pipeline in **Chromium-based browsers** (Chrome, Edge, Brave, Vivaldi, Opera, Arc, and the Android WebView used by many in-app browsers) when the browser cannot decode a video or audio packet in the recording. WebKit browsers (Safari) report the same underlying problem with a different message, usually `Media failed to decode` or `DECODER_ERROR_NOT_SUPPORTED`.
+
+Frigate copies the `record` stream to disk **without re-encoding it**, so the browser must decode exactly what your camera produced, and Chromium's decoder is far stricter about malformed or nonstandard media than VLC or ffmpeg.
+
+:::warning
+
+The same recording playing perfectly in VLC, decoding cleanly with `ffprobe`/`ffmpeg`, or having a valid MP4 container does **not** mean the browser can decode it. VLC and ffmpeg are much more tolerant of codec quirks and damaged packets than a browser's media pipeline, so a "valid" file can still trigger `PIPELINE_ERROR_DECODE`. This is outside of Frigate's control, because Frigate never modifies the recording stream.
+
+:::
+
+#### Step 1: Confirm it is a browser issue
+
+Open the same recording in **Firefox** or **Safari**. Firefox and Safari both use a different media engine and cannot produce `PIPELINE_ERROR_DECODE`, so if playback works there you have confirmed a client-side codec or decoder problem rather than a bad recording. Switching browsers is a workaround, not a fix; the remaining steps address the root cause so that Chromium browsers work too.
+
+#### Step 2: Rule out H.265 / HEVC
+
+Browser support for H.265 (HEVC) is limited and depends on the operating system, GPU, hardware acceleration, and browser version, which makes it the most common cause of this error. Options, in order of reliability:
+
+- **Record H.264 instead.** Configure the camera's `record`/main stream to output H.264, the most compatible codec across all browsers. See [camera settings recommendations](/configuration/live#camera-settings-recommendations).
+- **Transcode to H.264 with go2rtc.** If you must keep HEVC on the camera, have go2rtc re-encode the recording stream. This increases CPU usage; add `#hardware` to use the GPU where available:
+
+  ```yaml
+  go2rtc:
+    streams:
+      your_camera:
+        # transcode video to h264 and audio to aac; #hardware uses the GPU if available
+        - "ffmpeg:rtsp://user:password@CAMERA_IP:554/stream#video=h264#audio=aac#hardware"
+  cameras:
+    your_camera:
+      ffmpeg:
+        inputs:
+          - path: rtsp://127.0.0.1:8554/your_camera
+            input_args: preset-rtsp-restream
+            roles:
+              - record
+  ```
+
+  The `#video=h264` parameter only takes effect with the `ffmpeg:` source module; adding it to a plain `rtsp://` go2rtc source does nothing.
+
+- **Keep HEVC but improve compatibility.** If your browser and OS do support HEVC, set [`apple_compatibility`](/configuration/camera_specific#h265-cameras-via-safari) on the camera. Some players (Safari and other clients) require a specific HEVC stream format that this option corrects:
+
+  ```yaml
+  cameras:
+    your_camera:
+      ffmpeg:
+        apple_compatibility: true
+  ```
+
+  You may also need to enable HEVC and hardware decoding in the browser itself (for example, Chrome's Settings → System → "Use hardware acceleration when available"). HEVC hardware support varies widely by GPU, OS, and browser version.
+
+#### Step 3: Clean up damaged packets from the camera
+
+If the error is **intermittent** (the same recording plays after a page refresh, or fails only after playing for a while), the camera is most likely emitting occasional corrupt or malformed packets. Some camera models are more prone to this than others. Routing the stream through go2rtc's `ffmpeg` module often "cleans up" the stream enough for the browser to decode it, even without changing the codec:
+
+```yaml
+go2rtc:
+  streams:
+    your_camera:
+      - "ffmpeg:rtsp://user:password@CAMERA_IP:554/stream#video=h264#audio=aac"
+```
+
+#### Step 4: Fix incompatible or corrupt audio
+
+Audio is one of the most common culprits, and a decode failure on the audio track fails the whole recording. Make sure the camera outputs **AAC** audio, transcode the audio to AAC with go2rtc (`#audio=aac`), or drop audio entirely. See [Incompatible audio codec](#incompatible-audio-codec-recordings-silently-fail-to-save) for a preset-based way to do this.
+
+#### Step 5: Avoid "smart" / "+" codecs and check the keyframe interval
+
+- Disable any **"Smart Codec"**, **"H.264+"**, or **"H.265+"** feature in the camera. These nonstandard modes drop keyframes and change encoding parameters mid-stream, producing exactly the kind of packets a browser refuses to decode. (They also cause [short recording segments](#segments-are-only-1-second-long).)
+- Set the camera's **I-frame (keyframe) interval equal to the frame rate** (for example `20` for a 20 fps stream). Long keyframe intervals slow the start of playback and make decode errors more likely.
+
+#### Step 6: Consider bitrate and the client hardware
+
+The browser decodes the video locally, so a stream that is too demanding can fail on one device while playing on another:
+
+- A **very high bitrate or resolution** (for example a 4K/8MP HEVC main stream) can overwhelm a low-power tablet, phone, or SBC and stall the decoder. Test the same recording on a desktop; if it plays there, lower the camera's bitrate or record a lower-resolution profile.
+- Errors that name the client's GPU decoder, such as `VaapiVideoDecoder: failed Initialize()ing the frame pool`, indicate a browser hardware-decode problem. Toggling the browser's "Use hardware acceleration" setting (on or off) often resolves these.
+
+</FaqItem>
+
+<FaqItem id="recordings-play-back-with-no-video-or-wont-play-at-all" question="Recordings play back with no video (or won't play at all)">
+
+Frigate copies the `record` stream directly without re-encoding, so playback depends on your browser supporting the camera's codec. H265/HEVC recordings may not be playable in some browsers. If recordings appear as audio-only or a black screen, your camera is likely sending a codec your browser can't decode. Configure the camera to output **H264** for maximum compatibility.
+
+If playback instead fails with an explicit `PIPELINE_ERROR_DECODE` or `Media failed to decode` error, see [Recordings won't play back with "PIPELINE_ERROR_DECODE"](#pipeline-error-decode) above.
+
+</FaqItem>
+
+## Recording cache warnings and errors
+
+<FaqItem id="segments-are-only-1-second-long" question="Segments are only ~1 second long">
+
+If the record stream uses a "Smart Codec"/H.264+ mode or changes encoding parameters mid-stream, corrupt timestamps cause segments to be split far too frequently and fill the cache. This produces the "Too many unprocessed recording segments" warning. See [that question below](#i-see-the-message-warning--too-many-unprocessed-recording-segments-in-cache-for-camera-this-likely-indicates-an-issue-with-the-detect-stream) for the full diagnosis.
+
+</FaqItem>
+
+<FaqItem id="i-see-the-message-warning--unable-to-keep-up-with-recording-segments-in-cache-for-camera-keeping-the-5-most-recent-segments-out-of-6-and-discarding-the-rest" question="I see the message: WARNING : Unable to keep up with recording segments in cache for camera. Keeping the 5 most recent segments out of 6 and discarding the rest...">
 
 This warning means the recording maintainer cannot move recording segments from the RAM cache to disk fast enough. When the cache fills up, Frigate discards the oldest segments to avoid running out of memory and crashing, so you lose recorded footage. This is almost always a storage throughput or system resource problem. Work through the steps below to identify which.
 
-### Step 1: Enable recording debug logging
+#### Step 1: Enable recording debug logging
 
 The first step is to measure how long each segment takes to move from the RAM cache to disk. Enable debug logging for the recording maintainer:
 
@@ -132,14 +231,14 @@ DEBUG   : Copied /media/frigate/recordings/{segment_path} in 0.2 seconds.
 
 Let this run until the warnings begin to appear, so you can confirm whether the disk is actually slowing down at the moment the error occurs.
 
-### Step 2: Interpret the copy times
+#### Step 2: Interpret the copy times
 
 The copy duration tells you which direction to investigate:
 
 - **Consistently longer than ~1 second**: your storage cannot keep up with the incoming recordings. Continue with Steps 3–5 to diagnose the slow storage.
 - **Consistently well under 1 second**: storage is fast enough, and the problem is more likely CPU or resource contention. Skip to Step 6.
 
-### Step 3: Check RAM, swap, cache, and disk utilization
+#### Step 3: Check RAM, swap, cache, and disk utilization
 
 If CPU, RAM, disk throughput, or bus I/O is insufficient, nothing inside Frigate will help. Review each aspect of available system resources while the warnings are occurring.
 
@@ -175,19 +274,21 @@ services:
 
 NOTE: These are hard limits for the container, so be sure there is enough headroom above what `docker stats` shows for your container. It will immediately halt if it hits `<MAXRAM>`. In general, keeping all cache and tmp filespace in RAM is preferable to disk I/O where possible.
 
-### Step 4: Check your storage type
+#### Step 4: Check your storage type
 
 Mounting a network share is a popular option for storing recordings, but it can lead to reduced copy times and cause problems. Some users have found that using `NFS` instead of `SMB` considerably decreased copy times and fixed the issue. It is also important to ensure that the network connection between the device running Frigate and the network share is stable and fast. A saturated or unreliable link will stall copies.
 
-### Step 5: Check your mount options
+#### Step 5: Check your mount options
 
 Some users found that mounting a drive via `fstab` with the `sync` option dramatically reduced performance and led to this issue. Using `async` instead greatly reduced copy times.
 
-### Step 6: Rule out CPU load
+#### Step 6: Rule out CPU load
 
 If the copy times are consistently under 1 second but you still see the warning, the machine's CPU load is likely too high for Frigate to have the resources to keep up. Try temporarily shutting down other services, and any resource-intensive Frigate features, to see if the issue improves.
 
-## I see the message: WARNING : Too many unprocessed recording segments in cache for camera. This likely indicates an issue with the detect stream...
+</FaqItem>
+
+<FaqItem id="i-see-the-message-warning--too-many-unprocessed-recording-segments-in-cache-for-camera-this-likely-indicates-an-issue-with-the-detect-stream" question="I see the message: WARNING : Too many unprocessed recording segments in cache for camera. This likely indicates an issue with the detect stream...">
 
 This warning means that the detect stream for the affected camera has fallen behind or stopped processing frames. Frigate's recording cache holds segments waiting to be analyzed by the detector. When more than 6 segments pile up without being processed, Frigate discards the oldest ones to prevent the cache from filling up.
 
@@ -197,11 +298,11 @@ This error is a **symptom**, not the root cause. The actual cause is always logg
 
 :::
 
-### Step 1: Get the full logs
+#### Step 1: Get the full logs
 
 Collect complete Frigate logs from startup through the first occurrence of the error. Look for errors or warnings that appear **before** the "Too many unprocessed" messages begin. That is where the root cause will be found.
 
-### Step 2: Check the cache directory
+#### Step 2: Check the cache directory
 
 Exec into the Frigate container and inspect the recording cache:
 
@@ -211,7 +312,7 @@ docker exec -it frigate ls -la /tmp/cache
 
 Each camera should have a small number of `.mp4` segment files. If one camera has significantly more files than others, that camera is the source of the problem. A problem with a single camera can cascade and cause all cameras to show this error.
 
-### Step 3: Verify segment duration
+#### Step 3: Verify segment duration
 
 Recording segments should be approximately 10 seconds long. Run `ffprobe` on segments in the cache to check:
 
@@ -233,7 +334,7 @@ You don't have to run `ffprobe` by hand to catch this. Open a camera's **Camera
 
 :::
 
-### Step 4: Check for a stuck detector
+#### Step 4: Check for a stuck detector
 
 If the detect stream is not processing frames, segments will accumulate. Common causes:
 
@@ -242,7 +343,7 @@ If the detect stream is not processing frames, segments will accumulate. Common
 - **Model too large**: Use smaller model variants (e.g., YOLO `s` or `t` size, not `e` or `x`). Use 320x320 input size rather than 640x640 unless you have a powerful dedicated detector.
 - **Virtualization**: Running Frigate in a VM (especially Proxmox) can cause the detector to hang or stall. This is a known issue with GPU/TPU passthrough in virtualized environments and is not something Frigate can fix. Running Frigate in Docker on bare metal is recommended.
 
-### Step 5: Check for GPU hangs
+#### Step 5: Check for GPU hangs
 
 On the host machine, check `dmesg` for GPU-related errors:
 
@@ -252,7 +353,7 @@ dmesg | grep -i -E "gpu|drm|reset|hang"
 
 Messages like `trying reset from guc_exec_queue_timedout_job` or similar GPU reset/hang messages indicate a driver or hardware issue. Ensure your kernel and GPU drivers (especially Intel) are up to date.
 
-### Step 6: Verify hardware acceleration configuration
+#### Step 6: Verify hardware acceleration configuration
 
 An incorrect `hwaccel_args` preset can cause ffmpeg to fail silently or consume excessive CPU, starving the detector of resources.
 
@@ -260,11 +361,11 @@ An incorrect `hwaccel_args` preset can cause ffmpeg to fail silently or consume
 - For h265 cameras, use the corresponding h265 preset (e.g., `preset-intel-qsv-h265`).
 - Note that `hwaccel_args` are only relevant for the detect stream. Frigate does not decode the record stream.
 
-### Step 7: Verify go2rtc stream configuration
+#### Step 7: Verify go2rtc stream configuration
 
 Ensure that the ffmpeg source names in your go2rtc configuration match the correct camera stream. A misconfigured stream name (e.g., copying a config from one camera to another without updating the stream reference) will cause the wrong stream to be used or the stream to fail entirely.
 
-### Step 8: Check system resources
+#### Step 8: Check system resources
 
 If none of the above apply, the issue may be a general resource constraint. Monitor the following on your host:
 
@@ -275,7 +376,9 @@ If none of the above apply, the issue may be a general resource constraint. Moni
 
 Try temporarily disabling resource-intensive features like `genai` and `face_recognition` to see if the issue resolves. This can help isolate whether the detector is being starved of resources.
 
-## I see the message: ERROR : Error occurred when attempting to maintain recording cache
+</FaqItem>
+
+<FaqItem id="i-see-the-message-error--error-occurred-when-attempting-to-maintain-recording-cache" question="I see the message: ERROR : Error occurred when attempting to maintain recording cache">
 
 This message means the recording maintainer hit an error while moving segments from the cache to disk. It is a **generic wrapper**: the actual cause is always logged on the **very next line**. Frigate usually recovers and keeps running, but any affected segments are lost, so it is worth resolving.
 
@@ -287,27 +390,41 @@ Always read the line immediately following this message. `Error occurred when at
 
 Because these are operating-system-level errors, they must be resolved on the **host**, not within Frigate's configuration. The most common underlying errors are below.
 
-### [Errno 28] No space left on device
+#### [Errno 28] No space left on device
 
 The filesystem Frigate is writing to is full. Things to check:
 
 - **The recordings volume is genuinely full.** Check free space on the host with `df -h` for the path mapped to `/media/frigate`, and review the **Storage** page in the Frigate UI.
 - **The disk shows free space but is still "full".** This usually means the filesystem has run out of **inodes** (check with `df -i`), or recordings are landing on a different, smaller filesystem than you expect because of an incorrect bind mount. See [The storage volume isn't mounted correctly](#the-storage-volume-isnt-mounted-correctly) above.
-- **`/tmp/cache` is full.** If you mounted `/tmp/cache` as a small `tmpfs`, a backlog of segments can fill it. Increase the tmpfs size, or address whatever is causing segments to pile up (see the [Too many unprocessed recording segments](#i-see-the-message-warning--too-many-unprocessed-recording-segments-in-cache-for-camera-this-likely-indicates-an-issue-with-the-detect-stream) section above).
+- **`/tmp/cache` is full.** If you mounted `/tmp/cache` as a small `tmpfs`, a backlog of segments can fill it. Increase the tmpfs size, or address whatever is causing segments to pile up (see the [Too many unprocessed recording segments](#i-see-the-message-warning--too-many-unprocessed-recording-segments-in-cache-for-camera-this-likely-indicates-an-issue-with-the-detect-stream) question above).
 - **The host blocks writes before Frigate can purge.** On some systems (for example Unraid with a fill-up threshold), the host stops writes before Frigate's emergency cleanup can run. Leave more headroom on the volume, or lower your retention so Frigate purges sooner.
 
-### [Errno 17] File exists (with ffmpeg "Error writing trailer" or "unable to re-open output file")
+#### [Errno 17] File exists (with ffmpeg "Error writing trailer" or "unable to re-open output file")
 
 Errors like `[Errno 17] File exists: '/media/frigate/recordings/.../<camera>'`, often alongside ffmpeg errors such as `Unable to re-open ... output file for shifting data` or `Error writing trailer: No such file or directory`, are a hallmark of an **unreliable network share** (NFS or SMB). The mount is dropping, serving stale directory entries, or mishandling file locking.
 
 - Confirm the network connection to the NAS is stable and fast. An intermittent link produces these errors sporadically.
 - Prefer **NFS over SMB** for the recordings mount; several users have found NFS more reliable and faster.
-- Review your `fstab`/mount options for settings that hurt consistency or performance (see the `sync` vs `async` note in the [Unable to keep up with recording segments](#i-see-the-message-warning--unable-to-keep-up-with-recording-segments-in-cache-for-camera-keeping-the-5-most-recent-segments-out-of-6-and-discarding-the-rest) section above).
+- Review your `fstab`/mount options for settings that hurt consistency or performance (see the `sync` vs `async` note in the [Unable to keep up with recording segments](#i-see-the-message-warning--unable-to-keep-up-with-recording-segments-in-cache-for-camera-keeping-the-5-most-recent-segments-out-of-6-and-discarding-the-rest) question above).
 - Enable `frigate.record.maintainer` debug logging to confirm whether the errors line up with the share becoming unavailable.
 
-### Errors referencing a camera you manually renamed or removed
+#### Errors referencing a camera you manually renamed or removed
 
 If the next-line error references a camera name that no longer exists in your config, orphaned data is left over from a rename or removal in a persistent `/tmp/cache` volume.
 
 - Using a `tmpfs` mount for `/tmp/cache` as recommended in the [installation docs](/frigate/installation#storage) prevents stale cache files under the old camera name from surviving a restart, which avoids this issue entirely.
 - If errors persist, stop Frigate and remove any leftover segments for the old camera name from `/tmp/cache`.
+
+</FaqItem>
+
+## Other recording questions
+
+<FaqItem id="i-have-frigate-configured-for-motion-recording-only-but-it-still-seems-to-be-recording-even-with-no-motion-why" question="I have Frigate configured for motion recording only, but it still seems to be recording even with no motion. Why?">
+
+You'll want to:
+
+- Make sure your camera's timestamp is masked out with a motion mask. Even if there is no motion occurring in your scene, your motion settings may be sensitive enough to count your timestamp as motion.
+- If you have audio detection enabled, keep in mind that audio that is heard above `min_volume` is considered motion.
+- [Tune your motion detection settings](/configuration/motion_detection) either by editing your config file or by using the UI's Motion Tuner.
+
+</FaqItem>

docs/src/components/FaqItem/index.jsx

@@ -55,7 +55,7 @@ export default function FaqItem({ id, question, children }) {
           aria-controls={`${id}-content`}
           onClick={toggle}
         >
-          {question}
+          <span className={styles.question}>{question}</span>
         </button>
       </Heading>
       <div id={`${id}-content`} className={styles.content}>

docs/src/components/FaqItem/styles.module.css

@@ -44,6 +44,11 @@
   transform: rotate(45deg);
 }
 
+.question {
+  flex: 1;
+  min-width: 0;
+}
+
 .content {
   display: none;
   padding: 0 0 0.85rem;
@@ -61,7 +66,7 @@
 /* Desktop: render as a normal expanded heading + answer. */
 @media (min-width: 997px) {
   .heading {
-    margin: 1.75rem 0 0.5rem;
+    margin: 1.75rem 0 0.85rem;
   }
 
   .toggle {
@@ -78,7 +83,8 @@
 
   .content {
     display: block;
-    padding: 0;
+    padding: 0 0 0.5rem 1rem;
+    border-left: 2px solid var(--ifm-color-emphasis-200);
   }
 
   .heading :global(.hash-link) {

frigate/api/app.py

@@ -14,8 +14,8 @@ from io import StringIO
 from pathlib import Path as FilePath
 from typing import Any
 
-import aiofiles
 import ruamel.yaml
+from anyio import open_file as aopen
 from fastapi import APIRouter, Body, Path, Request, Response
 from fastapi.encoders import jsonable_encoder
 from fastapi.params import Depends
@@ -1052,7 +1052,7 @@ async def logs(
         """Asynchronously stream log lines."""
         buffer = ""
         try:
-            async with aiofiles.open(file_path) as file:
+            async with await aopen(file_path) as file:
                 await file.seek(0, 2)
                 while True:
                     line = await file.readline()
@@ -1090,7 +1090,7 @@ async def logs(
 
     # For full logs initially
     try:
-        async with aiofiles.open(service_location) as file:
+        async with await aopen(service_location) as file:
             contents = await file.read()
 
         total_lines, log_lines = process_logs(contents, service, start, end)

frigate/api/auth.py

@@ -415,7 +415,7 @@ def create_encoded_jwt(user, role, expiration, secret):
     )
 
 
-def set_jwt_cookie(response: Response, cookie_name, encoded_jwt, expiration, secure):
+def set_jwt_cookie(response: Response, cookie_name, encoded_jwt, max_age, secure):
     # TODO: ideally this would set secure as well, but that requires TLS
     # SameSite is intentionally left unset (browsers default to Lax). Setting
     # SameSite=Lax/Strict would stop the cookie from being sent in cross-origin
@@ -427,7 +427,7 @@ def set_jwt_cookie(response: Response, cookie_name, encoded_jwt, expiration, sec
         key=cookie_name,
         value=encoded_jwt,
         httponly=True,
-        expires=expiration,
+        max_age=max_age,
         secure=secure,
     )
 
@@ -762,7 +762,7 @@ def auth(request: Request):
                 success_response,
                 JWT_COOKIE_NAME,
                 new_encoded_jwt,
-                new_expiration,
+                JWT_SESSION_LENGTH,
                 JWT_COOKIE_SECURE,
             )
 
@@ -875,7 +875,11 @@ def login(request: Request, body: AppPostLoginBody):
         encoded_jwt = create_encoded_jwt(user, role, expiration, request.app.jwt_token)
         response = Response("", 200)
         set_jwt_cookie(
-            response, JWT_COOKIE_NAME, encoded_jwt, expiration, JWT_COOKIE_SECURE
+            response,
+            JWT_COOKIE_NAME,
+            encoded_jwt,
+            JWT_SESSION_LENGTH,
+            JWT_COOKIE_SECURE,
         )
         # Clear admin_first_time_login flag after successful admin login so the
         # UI stops showing the first-time login documentation link.
@@ -1037,7 +1041,11 @@ async def update_password(
         )
         # Set new JWT cookie on response
         set_jwt_cookie(
-            response, JWT_COOKIE_NAME, encoded_jwt, expiration, JWT_COOKIE_SECURE
+            response,
+            JWT_COOKIE_NAME,
+            encoded_jwt,
+            JWT_SESSION_LENGTH,
+            JWT_COOKIE_SECURE,
         )
 
     return response

frigate/api/camera.py

@@ -10,6 +10,7 @@ from urllib.parse import quote_plus
 
 import httpx
 import requests
+from anyio import open_file as aopen
 from fastapi import APIRouter, Depends, Query, Request, Response
 from fastapi.responses import JSONResponse
 from filelock import FileLock, Timeout
@@ -1187,15 +1188,17 @@ async def delete_camera(
 
     try:
         with lock:
-            with open(config_file) as f:
-                old_raw_config = f.read()
+            async with await aopen(config_file) as f:
+                old_raw_config = await f.read()
 
             try:
                 yaml = YAML()
                 yaml.indent(mapping=2, sequence=4, offset=2)
 
-                with open(config_file) as f:
-                    data = yaml.load(f)
+                async with await aopen(config_file) as f:
+                    text = await f.read()
+
+                data = yaml.load(text)
 
                 # Remove camera from config
                 if "cameras" in data and camera_name in data["cameras"]:
@@ -1220,17 +1223,17 @@ async def delete_camera(
                     for role_name in empty_roles:
                         del auth["roles"][role_name]
 
-                with open(config_file, "w") as f:
+                async with await aopen(config_file, "w") as f:
                     yaml.dump(data, f)
 
-                with open(config_file) as f:
-                    new_raw_config = f.read()
+                async with await aopen(config_file) as f:
+                    new_raw_config = await f.read()
 
                 try:
                     config = FrigateConfig.parse(new_raw_config)
                 except Exception:
-                    with open(config_file, "w") as f:
-                        f.write(old_raw_config)
+                    async with await aopen(config_file, "w") as f:
+                        await f.write(old_raw_config)
                     logger.exception(
                         "Config error after removing camera %s",
                         camera_name,

frigate/api/chat.py

@@ -7,7 +7,7 @@ import operator
 import time
 from datetime import datetime
 from functools import reduce
-from typing import Any
+from typing import Any, Literal
 
 import cv2
 from fastapi import APIRouter, Body, Depends, HTTPException, Request
@@ -37,6 +37,7 @@ from frigate.api.defs.response.chat_response import (
 from frigate.api.defs.tags import Tags
 from frigate.api.event import _build_attribute_filter_clause, events
 from frigate.config import FrigateConfig
+from frigate.config.classification import SemanticSearchModelEnum
 from frigate.genai.prompts import (
     build_chat_system_prompt,
     get_attribute_classifications,
@@ -86,10 +87,23 @@ def get_tools(request: Request) -> JSONResponse:
     tools = get_tool_definitions(
         semantic_search_enabled=semantic_search_enabled,
         attribute_classifications=attribute_classifications,
+        embeddings_language=_embeddings_language(config),
     )
     return JSONResponse(content={"tools": tools})
 
 
+def _embeddings_language(config: FrigateConfig) -> Literal["english", "multi"]:
+    """Return the language capability of the configured embeddings model.
+
+    JinaV1 is English-only; every other option (JinaV2 or a GenAI embeddings
+    provider) handles multiple languages.
+    """
+    if config.semantic_search.model == SemanticSearchModelEnum.jinav1:
+        return "english"
+
+    return "multi"
+
+
 def _resolve_zones(
     zones: list[str],
     config: FrigateConfig,
@@ -98,11 +112,14 @@ def _resolve_zones(
     """Map zone names to their canonical config keys, case-insensitively.
 
     LLMs frequently echo a user's casing ("Front Yard") instead of the
-    configured key ("front_yard"). The downstream zone filter is a SQLite GLOB
-    over the JSON-encoded zones column, which is case-sensitive — so an
-    unnormalized name silently returns zero matches. Build a lookup over the
-    relevant cameras' configured zones and substitute when we find a match;
-    unknown names pass through so behavior matches what the model asked for.
+    configured key ("front_yard"), or fall back to a zone's friendly name
+    ("Front Walkway") instead of its ID ("front_walk"). The downstream zone
+    filter is a SQLite GLOB over the JSON-encoded zones column, which stores
+    config keys and is case-sensitive — so an unnormalized name silently
+    returns zero matches. Build a lookup over the relevant cameras' configured
+    zones, keyed by both the config key and the friendly name, and substitute
+    when we find a match; unknown names pass through so behavior matches what
+    the model asked for.
     """
     if not zones:
         return zones
@@ -112,8 +129,11 @@ def _resolve_zones(
         camera_config = config.cameras.get(camera_id)
         if camera_config is None:
             continue
-        for zone_name in camera_config.zones.keys():
+        for zone_name, zone_config in camera_config.zones.items():
             lookup.setdefault(zone_name.lower(), zone_name)
+            lookup.setdefault(
+                zone_config.get_formatted_name(zone_name).lower(), zone_name
+            )
 
     return [lookup.get(z.lower(), z) for z in zones]
 
@@ -1134,6 +1154,7 @@ async def chat_completion(
     tools = get_tool_definitions(
         semantic_search_enabled=semantic_search_enabled,
         attribute_classifications=attribute_classifications,
+        embeddings_language=_embeddings_language(config),
     )
     conversation = []
 

frigate/api/event.py

@@ -13,6 +13,7 @@ from pathlib import Path
 from urllib.parse import unquote
 
 import numpy as np
+from anyio import Path as AsyncPath
 from fastapi import APIRouter, Request
 from fastapi.params import Depends
 from fastapi.responses import JSONResponse
@@ -1455,10 +1456,10 @@ async def set_attributes(
         dataset_dir = os.path.join(CLIPS_DIR, sanitize_filename(model_key), "dataset")
         available_labels = set()
 
-        if os.path.exists(dataset_dir):
+        if await AsyncPath(dataset_dir).exists():
             for category_name in os.listdir(dataset_dir):
                 category_dir = os.path.join(dataset_dir, category_name)
-                if os.path.isdir(category_dir):
+                if await AsyncPath(category_dir).is_dir():
                     available_labels.add(category_name)
 
         if not available_labels:

frigate/api/media.py

@@ -15,6 +15,8 @@ from urllib.parse import unquote
 import cv2
 import numpy as np
 import pytz
+from anyio import Path as AsyncPath
+from anyio import open_file as aopen
 from fastapi import APIRouter, Depends, Path, Query, Request, Response
 from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
 from pathvalidate import sanitize_filename
@@ -497,18 +499,18 @@ async def recording_clip(
 
     file_name = sanitize_filename(f"playlist_{camera_name}_{start_ts}-{end_ts}.txt")
     file_path = os.path.join(CACHE_DIR, file_name)
-    with open(file_path, "w") as file:
+    async with await aopen(file_path, "w") as file:
         clip: Recordings
         for clip in recordings:
-            file.write(f"file '{clip.path}'\n")
+            await file.write(f"file '{clip.path}'\n")
 
             # if this is the starting clip, add an inpoint
             if clip.start_time < start_ts:
-                file.write(f"inpoint {int(start_ts - clip.start_time)}\n")
+                await file.write(f"inpoint {int(start_ts - clip.start_time)}\n")
 
             # if this is the ending clip, add an outpoint
             if clip.end_time > end_ts:
-                file.write(f"outpoint {int(end_ts - clip.start_time)}\n")
+                await file.write(f"outpoint {int(end_ts - clip.start_time)}\n")
 
     if len(file_name) > 1000:
         return JSONResponse(
@@ -1149,8 +1151,8 @@ async def event_snapshot_clean(request: Request, event_id: str, download: bool =
                 )
 
             if image_path.endswith(".webp"):
-                with open(image_path, "rb") as image_file:
-                    webp_bytes = image_file.read()
+                async with await aopen(image_path, "rb") as image_file:
+                    webp_bytes = await image_file.read()
             else:
                 image = load_event_snapshot_image(event, clean_only=True)[0]
                 if image is None:
@@ -1366,7 +1368,7 @@ async def preview_gif(
         # need to generate from existing images
         preview_dir = os.path.join(CACHE_DIR, "preview_frames")
 
-        if not os.path.isdir(preview_dir):
+        if not await AsyncPath(preview_dir).is_dir():
             return JSONResponse(
                 content={"success": False, "message": "Preview not found"},
                 status_code=404,
@@ -1555,7 +1557,7 @@ async def preview_mp4(
         # need to generate from existing images
         preview_dir = os.path.join(CACHE_DIR, "preview_frames")
 
-        if not os.path.isdir(preview_dir):
+        if not await AsyncPath(preview_dir).is_dir():
             return JSONResponse(
                 content={"success": False, "message": "Preview not found"},
                 status_code=404,
@@ -1633,7 +1635,7 @@ async def preview_mp4(
         "Content-Description": "File Transfer",
         "Cache-Control": f"private, max-age={_resolve_cache_age(max_cache_age)}",
         "Content-Type": "video/mp4",
-        "Content-Length": str(os.path.getsize(path)),
+        "Content-Length": str((await AsyncPath(path).stat()).st_size),
         # nginx: https://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_ignore_headers
         "X-Accel-Redirect": f"/cache/{file_name}",
     }
@@ -1707,10 +1709,10 @@ async def preview_thumbnail(request: Request, file_name: str):
     preview_dir = os.path.join(CACHE_DIR, "preview_frames")
 
     try:
-        with open(
+        async with await aopen(
             os.path.join(preview_dir, safe_file_name_current), "rb"
         ) as image_file:
-            jpg_bytes = image_file.read()
+            jpg_bytes = await image_file.read()
     except FileNotFoundError:
         return JSONResponse(
             content=({"success": False, "message": "Image file not found"}),

frigate/api/record.py

@@ -4,9 +4,9 @@ import datetime as dt
 import logging
 from datetime import datetime, timedelta
 from functools import reduce
-from pathlib import Path
 from urllib.parse import unquote
 
+from anyio import Path as AsyncPath
 from fastapi import APIRouter, Depends, Request
 from fastapi import Path as PathParam
 from fastapi.responses import JSONResponse
@@ -443,7 +443,7 @@ async def delete_recordings(
         recording_ids.append(recording["id"])
 
         try:
-            Path(recording["path"]).unlink(missing_ok=True)
+            await AsyncPath(recording["path"]).unlink(missing_ok=True)
             deleted_count += 1
         except Exception as e:
             logger.error(f"Failed to delete recording file {recording['path']}: {e}")

frigate/config/config.py

@@ -400,6 +400,9 @@ def verify_objects_track(
         )
         camera_config.objects.track = valid_objects
 
+        for label in invalid_objects:
+            camera_config.objects.filters.pop(label, None)
+
 
 def verify_lpr_and_face(
     frigate_config: FrigateConfig, camera_config: CameraConfig

frigate/db/sqlitevecq.py

@@ -1,9 +1,11 @@
-import re
 import sqlite3
 from typing import Any
 
+import regex
 from playhouse.sqliteq import SqliteQueueDatabase
 
+REGEXP_TIMEOUT_SECONDS = 1.0
+
 
 class SqliteVecQueueDatabase(SqliteQueueDatabase):
     def __init__(
@@ -34,8 +36,10 @@ class SqliteVecQueueDatabase(SqliteQueueDatabase):
             if item is None:
                 return False
             try:
-                return re.search(expr, item) is not None
-            except re.error:
+                return (
+                    regex.search(expr, item, timeout=REGEXP_TIMEOUT_SECONDS) is not None
+                )
+            except (regex.error, TimeoutError):
                 return False
 
         conn.create_function("REGEXP", 2, regexp)

frigate/embeddings/onnx/base_embedding.py

@@ -57,6 +57,12 @@ class BaseEmbedding(ABC):
     def _preprocess_inputs(self, raw_inputs: Any) -> Any:
         pass
 
+    @staticmethod
+    def _bgr_to_rgb(frame: Any) -> Any:
+        if isinstance(frame, np.ndarray) and frame.ndim == 3:
+            return np.ascontiguousarray(frame[:, :, ::-1])
+        return frame
+
     def _process_image(self, image, output: str = "RGB") -> Image.Image:
         if isinstance(image, str):
             if image.startswith("http"):

frigate/embeddings/onnx/face_embedding.py

@@ -73,7 +73,7 @@ class FaceNetEmbedding(BaseEmbedding):
             self.tensor_output_details = self.runner.get_output_details()
 
     def _preprocess_inputs(self, raw_inputs):
-        pil = self._process_image(raw_inputs[0])
+        pil = self._process_image(self._bgr_to_rgb(raw_inputs[0]))
 
         # handle images larger than input size
         width, height = pil.size
@@ -159,7 +159,7 @@ class ArcfaceEmbedding(BaseEmbedding):
             )
 
     def _preprocess_inputs(self, raw_inputs):
-        pil = self._process_image(raw_inputs[0])
+        pil = self._process_image(self._bgr_to_rgb(raw_inputs[0]))
 
         # handle images larger than input size
         width, height = pil.size

frigate/genai/__init__.py

@@ -281,6 +281,11 @@ class GenAIClient:
         """Whether the configured model exposes a per-request thinking toggle."""
         return False
 
+    @property
+    def supports_embeddings(self) -> bool:
+        """Whether the configured model can generate embeddings via embed()."""
+        return False
+
     def list_models(self) -> list[str]:
         """Return the list of model names available from this provider.
 

frigate/genai/manager.py

@@ -121,5 +121,6 @@ class GenAIClientManager:
                 "models": client.list_models(),
                 "roles": [r.value for r in genai_cfg.roles],
                 "supports_toggleable_thinking": client.supports_toggleable_thinking,
+                "supports_embeddings": client.supports_embeddings,
             }
         return result

frigate/genai/plugins/gemini.py

@@ -38,6 +38,37 @@ def _encode_thought_signature(signature: bytes | None) -> str | None:
     return base64.b64encode(signature).decode("ascii")
 
 
+def _decode_data_uri(url: str) -> tuple[str, bytes] | None:
+    """Decode a ``data:`` URI into ``(mime_type, bytes)``; None if not a data URI."""
+    if not isinstance(url, str) or not url.startswith("data:"):
+        return None
+    try:
+        header, b64 = url.split(",", 1)
+        mime = header[len("data:") :].split(";")[0] or "image/jpeg"
+        return mime, base64.b64decode(b64)
+    except (ValueError, binascii.Error):
+        return None
+
+
+def _parts_from_content(content: Any) -> list[types.Part]:
+    """Convert OpenAI-style message content (str or multimodal list) to Gemini parts."""
+    if isinstance(content, list):
+        parts: list[types.Part] = []
+        for item in content:
+            if not isinstance(item, dict):
+                continue
+            if item.get("type") == "text":
+                parts.append(types.Part.from_text(text=item.get("text") or ""))
+            elif item.get("type") == "image_url":
+                decoded = _decode_data_uri((item.get("image_url") or {}).get("url", ""))
+                if decoded is not None:
+                    mime, data = decoded
+                    parts.append(types.Part.from_bytes(data=data, mime_type=mime))
+        # Gemini rejects empty parts; fall back to a single space.
+        return parts or [types.Part.from_text(text=" ")]
+    return [types.Part.from_text(text=content or "")]
+
+
 def _stats_from_gemini_usage(usage: Any) -> dict[str, Any] | None:
     """Build a stats dict from a Gemini usage_metadata object."""
     prompt_tokens = getattr(usage, "prompt_token_count", None)
@@ -227,9 +258,7 @@ class GeminiClient(GenAIClient):
                     )
                 else:  # user
                     gemini_messages.append(
-                        types.Content(
-                            role="user", parts=[types.Part.from_text(text=content)]
-                        )
+                        types.Content(role="user", parts=_parts_from_content(content))
                     )
 
             # Convert tools to Gemini format
@@ -485,9 +514,7 @@ class GeminiClient(GenAIClient):
                     )
                 else:  # user
                     gemini_messages.append(
-                        types.Content(
-                            role="user", parts=[types.Part.from_text(text=content)]
-                        )
+                        types.Content(role="user", parts=_parts_from_content(content))
                     )
 
             # Convert tools to Gemini format
@@ -553,7 +580,7 @@ class GeminiClient(GenAIClient):
             # Use streaming API
             content_parts: list[str] = []
             reasoning_parts: list[str] = []
-            tool_calls_by_index: dict[int, dict[str, Any]] = {}
+            tool_calls_accum: list[dict[str, Any]] = []
             finish_reason = "stop"
             usage_stats: dict[str, Any] | None = None
 
@@ -600,7 +627,11 @@ class GeminiClient(GenAIClient):
                                 content_parts.append(part.text)
                                 yield ("content_delta", part.text)
                         elif part.function_call:
-                            # Handle function call
+                            # Gemini streams complete function calls (not partial
+                            # argument deltas), so each part is a distinct tool
+                            # call. Append rather than accumulate by name — the
+                            # latter concatenated parallel/repeated calls into one
+                            # invalid arguments string (e.g. `{...}{...}`).
                             try:
                                 arguments = (
                                     dict(part.function_call.args)
@@ -610,40 +641,16 @@ class GeminiClient(GenAIClient):
                             except Exception:
                                 arguments = {}
 
-                            # Store tool call
-                            tool_call_id = part.function_call.name or ""
-                            tool_call_name = part.function_call.name or ""
-
-                            # Check if we already have this tool call
-                            found_index = None
-                            for idx, tc in tool_calls_by_index.items():
-                                if tc["name"] == tool_call_name:
-                                    found_index = idx
-                                    break
-
-                            if found_index is None:
-                                found_index = len(tool_calls_by_index)
-                                tool_calls_by_index[found_index] = {
-                                    "id": tool_call_id,
-                                    "name": tool_call_name,
-                                    "arguments": "",
-                                    "thought_signature": None,
+                            tool_calls_accum.append(
+                                {
+                                    "id": part.function_call.name or "",
+                                    "name": part.function_call.name or "",
+                                    "arguments": arguments,
+                                    "thought_signature": getattr(
+                                        part, "thought_signature", None
+                                    ),
                                 }
-
-                            # Accumulate arguments
-                            if arguments:
-                                tool_calls_by_index[found_index]["arguments"] += (
-                                    json.dumps(arguments)
-                                    if isinstance(arguments, dict)
-                                    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
@@ -651,25 +658,20 @@ class GeminiClient(GenAIClient):
 
             # Convert tool calls to list format
             tool_calls_list = None
-            if tool_calls_by_index:
-                tool_calls_list = []
-                for tc in tool_calls_by_index.values():
-                    try:
-                        # Try to parse accumulated arguments as JSON
-                        parsed_args = json.loads(tc["arguments"])
-                    except (json.JSONDecodeError, Exception):
-                        parsed_args = tc["arguments"]
-
-                    tool_calls_list.append(
-                        {
-                            "id": tc["id"],
-                            "name": tc["name"],
-                            "arguments": parsed_args,
-                            "thought_signature": _encode_thought_signature(
-                                tc.get("thought_signature")
-                            ),
-                        }
-                    )
+            if tool_calls_accum:
+                tool_calls_list = [
+                    {
+                        "id": tc["id"],
+                        "name": tc["name"],
+                        "arguments": tc["arguments"]
+                        if isinstance(tc["arguments"], dict)
+                        else {},
+                        "thought_signature": _encode_thought_signature(
+                            tc.get("thought_signature")
+                        ),
+                    }
+                    for tc in tool_calls_accum
+                ]
                 finish_reason = "tool_calls"
 
             if usage_stats is not None:

frigate/genai/plugins/llama_cpp.py

@@ -128,6 +128,11 @@ class LlamaCppClient(GenAIClient):
     _text_baseline_tokens: int | None
     _media_marker: str
 
+    @property
+    def supports_embeddings(self) -> bool:
+        """llama.cpp exposes an /embeddings endpoint for any loaded model."""
+        return True
+
     def _init_provider(self) -> str | None:
         """Initialize the client and query model metadata from the server."""
         self.provider_options = {

frigate/genai/plugins/openai.py

@@ -423,9 +423,18 @@ class OpenAIClient(GenAIClient):
                 for tc in tool_calls_by_index.values():
                     try:
                         # Parse accumulated arguments as JSON
-                        parsed_args = json.loads(tc["arguments"])
-                    except (json.JSONDecodeError, Exception):
-                        parsed_args = tc["arguments"]
+                        parsed_args = json.loads(tc["arguments"] or "{}")
+                    except (json.JSONDecodeError, ValueError):
+                        logger.warning(
+                            "Failed to parse streamed tool call arguments for %s",
+                            tc["name"],
+                        )
+                        parsed_args = {}
+
+                    # Downstream (ToolCall model) requires a dict; never leak a
+                    # partial/invalid arguments string.
+                    if not isinstance(parsed_args, dict):
+                        parsed_args = {}
 
                     tool_calls_list.append(
                         {

frigate/genai/prompts.py

@@ -6,7 +6,7 @@ transport.
 """
 
 import datetime
-from typing import Any
+from typing import Any, Literal
 
 from playhouse.shortcuts import model_to_dict
 
@@ -249,6 +249,7 @@ def get_attribute_classifications(config: FrigateConfig) -> list[dict[str, Any]]
 def get_tool_definitions(
     semantic_search_enabled: bool = False,
     attribute_classifications: list[dict[str, Any]] | None = None,
+    embeddings_language: Literal["english", "multi"] = "multi",
 ) -> list[dict[str, Any]]:
     """
     Get OpenAI-compatible tool definitions for Frigate.
@@ -258,7 +259,9 @@ def get_tool_definitions(
     tool exposes an additional `semantic_query` parameter for descriptive
     queries (e.g. "person riding a lawn mower") and find_similar_objects is
     included. When attribute classification models are configured, an
-    `attribute` parameter is exposed for filtering by their labels.
+    `attribute` parameter is exposed for filtering by their labels. When the
+    embeddings model only understands English (JinaV1), the `semantic_query`
+    description instructs the model to write the query in English.
     """
     search_objects_properties: dict[str, Any] = {
         "camera": {
@@ -349,6 +352,14 @@ def get_tool_definitions(
                 "When set, combine with label/time/camera/zone filters as "
                 "usual (e.g. label='person', semantic_query='riding a lawn "
                 "mower', after='2024-05-01T00:00:00Z')."
+                + (
+                    " The configured embeddings model only understands "
+                    "English, so always write semantic_query in English, "
+                    "translating the user's description if they phrased it "
+                    "in another language."
+                    if embeddings_language == "english"
+                    else ""
+                )
             ),
         }
 
@@ -682,14 +693,17 @@ def build_chat_system_prompt(
             if camera_config.friendly_name
             else camera_id.replace("_", " ").title()
         )
-        zone_names = list(camera_config.zones.keys())
+        zone_descriptors = [
+            f"{zone_config.get_formatted_name(zone_name)} (ID: {zone_name})"
+            for zone_name, zone_config in camera_config.zones.items()
+        ]
         if not has_speed_zone:
             has_speed_zone = any(
                 zone.distances for zone in camera_config.zones.values()
             )
-        if zone_names:
+        if zone_descriptors:
             cameras_info.append(
-                f"  - {friendly_name} (ID: {camera_id}, zones: {', '.join(zone_names)})"
+                f"  - {friendly_name} (ID: {camera_id}, zones: {', '.join(zone_descriptors)})"
             )
         else:
             cameras_info.append(f"  - {friendly_name} (ID: {camera_id})")
@@ -699,7 +713,7 @@ def build_chat_system_prompt(
         cameras_section = (
             "\n\nAvailable cameras:\n"
             + "\n".join(cameras_info)
-            + "\n\nWhen users refer to cameras by their friendly name (e.g., 'Back Deck Camera'), use the corresponding camera ID (e.g., 'back_deck_cam') in tool calls."
+            + "\n\nWhen users refer to cameras or zones by their friendly name (e.g., 'Back Deck Camera', 'Front Walkway'), use the corresponding ID (e.g., 'back_deck_cam', 'front_walk') in tool calls. Tool results also identify zones by their ID, so when presenting cameras or zones back to the user, translate the ID to its friendly name."
         )
 
     speed_units_section = ""

frigate/record/maintainer.py

@@ -15,6 +15,7 @@ from typing import Any
 
 import numpy as np
 import psutil
+from anyio import Path as AsyncPath
 
 from frigate.comms.detections_updater import DetectionSubscriber, DetectionTypeEnum
 from frigate.comms.inter_process import InterProcessRequestor
@@ -105,11 +106,11 @@ class RecordingMaintainer(threading.Thread):
 
     async def move_files(self) -> None:
         cache_files = [
-            d
-            for d in os.listdir(CACHE_DIR)
-            if os.path.isfile(os.path.join(CACHE_DIR, d))
-            and d.endswith(".mp4")
-            and not d.startswith("preview_")
+            path.name
+            async for path in AsyncPath(CACHE_DIR).iterdir()
+            if await path.is_file()
+            and path.suffix == ".mp4"
+            and not path.name.startswith("preview_")
         ]
 
         # publish newest cached segment per camera (including in use files)
@@ -229,7 +230,7 @@ class RecordingMaintainer(threading.Thread):
                 to_remove = grouped_recordings[camera][:-keep_count]
                 for rec in to_remove:
                     cache_path = rec["cache_path"]
-                    Path(cache_path).unlink(missing_ok=True)
+                    await AsyncPath(cache_path).unlink(missing_ok=True)
                     self.end_time_cache.pop(cache_path, None)
                 grouped_recordings[camera] = grouped_recordings[camera][-keep_count:]
 
@@ -244,7 +245,7 @@ class RecordingMaintainer(threading.Thread):
                 to_remove = grouped_recordings[camera][:-keep_count]
                 for rec in to_remove:
                     cache_path = rec["cache_path"]
-                    Path(cache_path).unlink(missing_ok=True)
+                    await AsyncPath(cache_path).unlink(missing_ok=True)
                     self.end_time_cache.pop(cache_path, None)
                 grouped_recordings[camera] = grouped_recordings[camera][-keep_count:]
 
@@ -634,7 +635,7 @@ class RecordingMaintainer(threading.Thread):
         file_path = os.path.join(directory, file_name)
 
         try:
-            if not os.path.exists(file_path):
+            if not await AsyncPath(file_path).exists():
                 start_frame = datetime.datetime.now().timestamp()
 
                 # add faststart to kept segments to improve metadata reading
@@ -670,7 +671,9 @@ class RecordingMaintainer(threading.Thread):
                     # get the segment size of the cache file
                     # file without faststart is same size
                     segment_size = round(
-                        float(os.path.getsize(cache_path)) / pow(2, 20), 2
+                        float((await AsyncPath(cache_path).stat()).st_size)
+                        / pow(2, 20),
+                        2,
                     )
                 except OSError:
                     segment_size = 0
@@ -698,7 +701,7 @@ class RecordingMaintainer(threading.Thread):
                 }
         except Exception as e:
             logger.error(f"Unable to store recording segment {cache_path}")
-            Path(cache_path).unlink(missing_ok=True)
+            await AsyncPath(cache_path).unlink(missing_ok=True)
             logger.error(e)
 
         # clear end_time cache

frigate/test/test_config.py

@@ -397,6 +397,43 @@ class TestConfig(unittest.TestCase):
         assert "dog" in frigate_config.cameras["back"].objects.filters
         assert frigate_config.cameras["back"].objects.filters["dog"].threshold == 0.7
 
+    def test_unsupported_tracked_object_pruned_from_track_and_filters(self):
+        # "unicorn" is not in the model labelmap, so it must be removed from the
+        # tracked objects AND from the object filters, otherwise a stale filter
+        # entry lingers in the parsed config.
+        config = {
+            "mqtt": {"host": "mqtt"},
+            "cameras": {
+                "back": {
+                    "ffmpeg": {
+                        "inputs": [
+                            {"path": "rtsp://10.0.0.1:554/video", "roles": ["detect"]}
+                        ]
+                    },
+                    "detect": {
+                        "height": 1080,
+                        "width": 1920,
+                        "fps": 5,
+                    },
+                    "objects": {
+                        "track": ["person", "unicorn"],
+                        "filters": {
+                            "person": {"threshold": 0.7},
+                            "unicorn": {"threshold": 0.7},
+                        },
+                    },
+                }
+            },
+        }
+
+        frigate_config = FrigateConfig(**config)
+        objects = frigate_config.cameras["back"].objects
+        assert "unicorn" not in objects.track
+        assert "unicorn" not in objects.filters
+        # supported entries are left untouched
+        assert "person" in objects.track
+        assert "person" in objects.filters
+
     def test_global_object_mask(self):
         config = {
             "mqtt": {"host": "mqtt"},

frigate/test/test_genai_providers.py

@@ -0,0 +1,496 @@
+"""Smoke tests for GenAI chat providers.
+
+Each provider's ``chat_with_tools_stream`` is driven with a canned "test
+response" so the two conversion layers are exercised without any network:
+
+  1. Frigate (OpenAI-style) messages -> provider-native request format
+  2. provider-native response -> Frigate ``("kind", value)`` stream events
+
+These guard against regressions such as tool-call arguments arriving as raw
+strings instead of dicts (which crash the ``ToolCall`` model), and multimodal
+user content (a list of text/image parts, as injected by ``get_live_context``)
+crashing message conversion.
+"""
+
+import asyncio
+import base64
+import json
+import unittest
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from frigate.config import GenAIConfig, GenAIProviderEnum
+from frigate.genai import PROVIDERS, load_providers
+
+load_providers()
+
+# A minimal but valid JPEG data URI, mirroring what get_live_context injects.
+_TINY_JPEG = base64.b64encode(b"\xff\xd8\xff\xd9").decode("ascii")
+_IMAGE_DATA_URI = f"data:image/jpeg;base64,{_TINY_JPEG}"
+
+# Conversation ending in a multimodal user message (text + live image), the
+# exact shape the chat endpoint builds after a get_live_context tool result.
+MULTIMODAL_MESSAGES = [
+    {"role": "system", "content": "You are a test assistant."},
+    {"role": "user", "content": "what do you see on the front camera?"},
+    {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+            {
+                "id": "call_1",
+                "type": "function",
+                "function": {
+                    "name": "get_live_context",
+                    "arguments": json.dumps({"camera": "front"}),
+                },
+            }
+        ],
+    },
+    {
+        "role": "tool",
+        "tool_call_id": "call_1",
+        "name": "get_live_context",
+        "content": json.dumps({"camera": "front"}),
+    },
+    {
+        "role": "user",
+        "content": [
+            {
+                "type": "text",
+                "text": "Here is the current live image from camera 'front'.",
+            },
+            {"type": "image_url", "image_url": {"url": _IMAGE_DATA_URI}},
+        ],
+    },
+]
+
+SIMPLE_MESSAGES = [
+    {"role": "system", "content": "You are a test assistant."},
+    {"role": "user", "content": "hello"},
+]
+
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "search_objects",
+            "description": "Search tracked objects",
+            "parameters": {
+                "type": "object",
+                "properties": {"label": {"type": "string"}},
+            },
+        },
+    }
+]
+
+
+def _make_client(provider: str, **cfg_overrides):
+    """Build a provider client offline (no model validation, no network)."""
+    cfg = GenAIConfig(provider=provider, **cfg_overrides)
+    cls = PROVIDERS[GenAIProviderEnum(provider)]
+    return cls(cfg, timeout=5, validate_model=False)
+
+
+def _collect(client, messages, tools=TOOLS):
+    """Drain chat_with_tools_stream into a list of (kind, value) events."""
+
+    async def _run():
+        events = []
+        async for event in client.chat_with_tools_stream(
+            messages=messages, tools=tools, tool_choice="auto"
+        ):
+            events.append(event)
+        return events
+
+    return asyncio.run(_run())
+
+
+def _final_message(events) -> dict:
+    messages = [value for (kind, value) in events if kind == "message"]
+    assert messages, f"stream produced no final message: {events}"
+    return messages[-1]
+
+
+def _assert_tool_args_are_dicts(final: dict) -> None:
+    """Every returned tool call must expose arguments as a dict, never a string."""
+    for tool_call in final.get("tool_calls") or []:
+        assert isinstance(tool_call["arguments"], dict), (
+            f"tool call arguments must be a dict, got "
+            f"{type(tool_call['arguments']).__name__}: {tool_call['arguments']!r}"
+        )
+
+
+# ---------------------------------------------------------------------------
+# OpenAI
+# ---------------------------------------------------------------------------
+def _openai_tc(index, id=None, name=None, arguments=None):
+    return SimpleNamespace(
+        index=index,
+        id=id,
+        function=SimpleNamespace(name=name, arguments=arguments),
+    )
+
+
+def _openai_chunk(content=None, tool_calls=None, finish_reason=None, usage=None):
+    delta = SimpleNamespace(
+        content=content,
+        tool_calls=tool_calls,
+        reasoning_content=None,
+        reasoning=None,
+    )
+    choice = SimpleNamespace(delta=delta, finish_reason=finish_reason)
+    return SimpleNamespace(choices=[choice], usage=usage)
+
+
+class TestOpenAIProvider(unittest.TestCase):
+    def _client(self):
+        return _make_client(
+            "openai", model="gpt-4o", api_key="k", base_url="http://localhost:9999/v1"
+        )
+
+    def test_stream_tool_call_arguments_are_dict(self):
+        # Arguments arrive split across chunks, as the real API streams them.
+        chunks = [
+            _openai_chunk(
+                tool_calls=[
+                    _openai_tc(0, id="c1", name="search_objects", arguments='{"label":')
+                ]
+            ),
+            _openai_chunk(tool_calls=[_openai_tc(0, arguments=' "person"}')]),
+            _openai_chunk(finish_reason="tool_calls"),
+        ]
+        client = self._client()
+        client.provider.chat.completions.create = MagicMock(return_value=iter(chunks))
+
+        final = _final_message(_collect(client, SIMPLE_MESSAGES))
+        self.assertEqual(final["finish_reason"], "tool_calls")
+        self.assertEqual(len(final["tool_calls"]), 1)
+        _assert_tool_args_are_dicts(final)
+        self.assertEqual(final["tool_calls"][0]["arguments"], {"label": "person"})
+
+    def test_stream_content_response(self):
+        chunks = [
+            _openai_chunk(content="hel"),
+            _openai_chunk(content="lo"),
+            _openai_chunk(finish_reason="stop"),
+        ]
+        client = self._client()
+        client.provider.chat.completions.create = MagicMock(return_value=iter(chunks))
+
+        events = _collect(client, SIMPLE_MESSAGES)
+        deltas = [v for (k, v) in events if k == "content_delta"]
+        self.assertEqual("".join(deltas), "hello")
+        self.assertEqual(_final_message(events)["content"], "hello")
+
+    def test_multimodal_message_does_not_crash(self):
+        client = self._client()
+        client.provider.chat.completions.create = MagicMock(
+            return_value=iter([_openai_chunk(content="ok", finish_reason="stop")])
+        )
+        # Passing the OpenAI-native multimodal list through must not raise.
+        final = _final_message(_collect(client, MULTIMODAL_MESSAGES))
+        self.assertEqual(final["content"], "ok")
+
+
+# ---------------------------------------------------------------------------
+# Gemini
+# ---------------------------------------------------------------------------
+def _gemini_part(text=None, thought=False, function_call=None, thought_signature=None):
+    return SimpleNamespace(
+        text=text,
+        thought=thought,
+        function_call=function_call,
+        thought_signature=thought_signature,
+    )
+
+
+def _gemini_chunk(parts, finish_reason=None, usage_metadata=None):
+    candidate = SimpleNamespace(
+        content=SimpleNamespace(parts=parts), finish_reason=finish_reason
+    )
+    return SimpleNamespace(candidates=[candidate], usage_metadata=usage_metadata)
+
+
+def _gemini_stream(chunks):
+    async def _agen(*args, **kwargs):
+        for chunk in chunks:
+            yield chunk
+
+    return _agen
+
+
+class TestGeminiProvider(unittest.TestCase):
+    def _client(self):
+        return _make_client("gemini", model="gemini-2.5-flash", api_key="k")
+
+    def _patch_stream(self, client, chunks):
+        client.provider = MagicMock()
+        client.provider.aio.models.generate_content_stream = AsyncMock(
+            side_effect=_gemini_stream(chunks)
+        )
+
+    def test_stream_parallel_tool_calls_stay_separate_dicts(self):
+        # Regression: Gemini streams complete function calls. Two calls to the
+        # same tool must NOT be merged into one concatenated arguments string.
+        from google.genai.types import FinishReason
+
+        chunks = [
+            _gemini_chunk(
+                parts=[
+                    _gemini_part(
+                        function_call=SimpleNamespace(
+                            name="search_objects", args={"label": "person"}
+                        )
+                    ),
+                    _gemini_part(
+                        function_call=SimpleNamespace(
+                            name="search_objects", args={"limit": 1}
+                        )
+                    ),
+                ],
+                finish_reason=FinishReason.STOP,
+            ),
+        ]
+        client = self._client()
+        self._patch_stream(client, chunks)
+
+        final = _final_message(_collect(client, SIMPLE_MESSAGES))
+        self.assertEqual(final["finish_reason"], "tool_calls")
+        self.assertEqual(len(final["tool_calls"]), 2)
+        _assert_tool_args_are_dicts(final)
+        self.assertEqual(final["tool_calls"][0]["arguments"], {"label": "person"})
+        self.assertEqual(final["tool_calls"][1]["arguments"], {"limit": 1})
+
+    def test_stream_content_response(self):
+        from google.genai.types import FinishReason
+
+        chunks = [
+            _gemini_chunk(parts=[_gemini_part(text="hel")]),
+            _gemini_chunk(
+                parts=[_gemini_part(text="lo")], finish_reason=FinishReason.STOP
+            ),
+        ]
+        client = self._client()
+        self._patch_stream(client, chunks)
+
+        events = _collect(client, SIMPLE_MESSAGES)
+        deltas = [v for (k, v) in events if k == "content_delta"]
+        self.assertEqual("".join(deltas), "hello")
+        self.assertEqual(_final_message(events)["content"], "hello")
+
+    def test_multimodal_message_converts_without_crash(self):
+        # Regression: a user message with list content (text + image_url) used
+        # to be handed to Part.from_text(text=<list>) and raise ValidationError.
+        from google.genai.types import FinishReason
+
+        client = self._client()
+        self._patch_stream(
+            client,
+            [
+                _gemini_chunk(
+                    parts=[_gemini_part(text="ok")], finish_reason=FinishReason.STOP
+                )
+            ],
+        )
+        final = _final_message(_collect(client, MULTIMODAL_MESSAGES))
+        self.assertEqual(final["content"], "ok")
+
+
+# ---------------------------------------------------------------------------
+# Ollama
+# ---------------------------------------------------------------------------
+class TestOllamaProvider(unittest.TestCase):
+    def _client(self):
+        return _make_client("ollama", model="llama3", base_url="http://localhost:9999")
+
+    def _run_with_response(self, client, response, messages):
+        # Ollama uses a non-streaming call when tools are present, via an
+        # internally-constructed async client.
+        fake_async = MagicMock()
+        fake_async.chat = AsyncMock(return_value=response)
+        with patch(
+            "frigate.genai.plugins.ollama.OllamaAsyncClient",
+            return_value=fake_async,
+        ):
+            return _collect(client, messages)
+
+    def test_tool_call_arguments_are_dict(self):
+        response = {
+            "message": {
+                "content": "",
+                "tool_calls": [
+                    {
+                        "function": {
+                            "name": "search_objects",
+                            "arguments": {"label": "person"},
+                        }
+                    }
+                ],
+            },
+            "done": True,
+            "done_reason": "stop",
+            "eval_count": 5,
+            "prompt_eval_count": 3,
+            "eval_duration": 1_000_000,
+        }
+        client = self._client()
+        final = _final_message(
+            self._run_with_response(client, response, SIMPLE_MESSAGES)
+        )
+        self.assertEqual(final["finish_reason"], "tool_calls")
+        _assert_tool_args_are_dicts(final)
+        self.assertEqual(final["tool_calls"][0]["arguments"], {"label": "person"})
+
+    def test_multimodal_message_normalizes_image(self):
+        # Ollama needs content as a string with images pulled into a separate
+        # field; the normalizer must extract both without crashing.
+        response = {
+            "message": {"content": "ok"},
+            "done": True,
+            "done_reason": "stop",
+        }
+        client = self._client()
+        final = _final_message(
+            self._run_with_response(client, response, MULTIMODAL_MESSAGES)
+        )
+        self.assertEqual(final["content"], "ok")
+
+    def test_normalize_multimodal_content(self):
+        from frigate.genai.plugins.ollama import _normalize_multimodal_content
+
+        text, images = _normalize_multimodal_content(MULTIMODAL_MESSAGES[-1]["content"])
+        self.assertIn("live image", text)
+        self.assertEqual(len(images), 1)
+        self.assertEqual(images[0], b"\xff\xd8\xff\xd9")
+
+
+# ---------------------------------------------------------------------------
+# llama.cpp
+# ---------------------------------------------------------------------------
+class _FakeStreamResponse:
+    def __init__(self, lines):
+        self._lines = lines
+
+    def raise_for_status(self):
+        return None
+
+    async def aiter_lines(self):
+        for line in self._lines:
+            yield line
+
+
+class _FakeStreamCtx:
+    def __init__(self, lines):
+        self._resp = _FakeStreamResponse(lines)
+
+    async def __aenter__(self):
+        return self._resp
+
+    async def __aexit__(self, *exc):
+        return False
+
+
+class _FakeAsyncClient:
+    def __init__(self, lines):
+        self._lines = lines
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *exc):
+        return False
+
+    def stream(self, method, url, json=None):
+        return _FakeStreamCtx(self._lines)
+
+
+class TestLlamaCppProvider(unittest.TestCase):
+    def _client(self):
+        return _make_client("llamacpp", model="m", base_url="http://localhost:9999")
+
+    def _run_with_lines(self, client, lines, messages):
+        with patch(
+            "frigate.genai.plugins.llama_cpp.httpx.AsyncClient",
+            return_value=_FakeAsyncClient(lines),
+        ):
+            return _collect(client, messages)
+
+    def test_stream_tool_call_arguments_are_dict(self):
+        lines = [
+            "data: "
+            + json.dumps(
+                {
+                    "choices": [
+                        {
+                            "delta": {
+                                "tool_calls": [
+                                    {
+                                        "index": 0,
+                                        "id": "c1",
+                                        "function": {
+                                            "name": "search_objects",
+                                            "arguments": '{"label":',
+                                        },
+                                    }
+                                ]
+                            }
+                        }
+                    ]
+                }
+            ),
+            "data: "
+            + json.dumps(
+                {
+                    "choices": [
+                        {
+                            "delta": {
+                                "tool_calls": [
+                                    {
+                                        "index": 0,
+                                        "function": {"arguments": ' "person"}'},
+                                    }
+                                ]
+                            }
+                        }
+                    ]
+                }
+            ),
+            "data: "
+            + json.dumps({"choices": [{"delta": {}, "finish_reason": "tool_calls"}]}),
+            "data: [DONE]",
+        ]
+        client = self._client()
+        final = _final_message(self._run_with_lines(client, lines, SIMPLE_MESSAGES))
+        self.assertEqual(final["finish_reason"], "tool_calls")
+        _assert_tool_args_are_dicts(final)
+        self.assertEqual(final["tool_calls"][0]["arguments"], {"label": "person"})
+
+    def test_stream_content_response(self):
+        lines = [
+            "data: " + json.dumps({"choices": [{"delta": {"content": "hel"}}]}),
+            "data: " + json.dumps({"choices": [{"delta": {"content": "lo"}}]}),
+            "data: "
+            + json.dumps({"choices": [{"delta": {}, "finish_reason": "stop"}]}),
+            "data: [DONE]",
+        ]
+        client = self._client()
+        events = self._run_with_lines(client, lines, SIMPLE_MESSAGES)
+        deltas = [v for (k, v) in events if k == "content_delta"]
+        self.assertEqual("".join(deltas), "hello")
+        self.assertEqual(_final_message(events)["content"], "hello")
+
+    def test_multimodal_message_does_not_crash(self):
+        lines = [
+            "data: " + json.dumps({"choices": [{"delta": {"content": "ok"}}]}),
+            "data: "
+            + json.dumps({"choices": [{"delta": {}, "finish_reason": "stop"}]}),
+            "data: [DONE]",
+        ]
+        client = self._client()
+        final = _final_message(self._run_with_lines(client, lines, MULTIMODAL_MESSAGES))
+        self.assertEqual(final["content"], "ok")
+
+
+if __name__ == "__main__":
+    unittest.main()

frigate/test/test_gpu_stats.py

@@ -40,18 +40,18 @@ class TestGpuStats(unittest.TestCase):
                 "driver": "i915",
                 "pid": "100",
                 "engines": {
-                    "render": (1_000_000_000, 0),
-                    "video": (5_000_000_000, 0),
-                    "video-enhance": (200_000_000, 0),
-                    "compute": (0, 0),
+                    "render": (1_000_000_000, 0, 1),
+                    "video": (5_000_000_000, 0, 1),
+                    "video-enhance": (200_000_000, 0, 1),
+                    "compute": (0, 0, 1),
                 },
             },
             ("0000:00:02.0", "2", "200"): {
                 "driver": "i915",
                 "pid": "200",
                 "engines": {
-                    "render": (0, 0),
-                    "compute": (2_000_000_000, 0),
+                    "render": (0, 0, 1),
+                    "compute": (2_000_000_000, 0, 1),
                 },
             },
         }
@@ -60,18 +60,18 @@ class TestGpuStats(unittest.TestCase):
                 "driver": "i915",
                 "pid": "100",
                 "engines": {
-                    "render": (1_200_000_000, 0),
-                    "video": (5_500_000_000, 0),
-                    "video-enhance": (300_000_000, 0),
-                    "compute": (0, 0),
+                    "render": (1_200_000_000, 0, 1),
+                    "video": (5_500_000_000, 0, 1),
+                    "video-enhance": (300_000_000, 0, 1),
+                    "compute": (0, 0, 1),
                 },
             },
             ("0000:00:02.0", "2", "200"): {
                 "driver": "i915",
                 "pid": "200",
                 "engines": {
-                    "render": (0, 0),
-                    "compute": (2_100_000_000, 0),
+                    "render": (0, 0, 1),
+                    "compute": (2_100_000_000, 0, 1),
                 },
             },
         }
@@ -92,6 +92,64 @@ class TestGpuStats(unittest.TestCase):
             },
         }
 
+    @patch("frigate.stats.intel_gpu_info.intel_gpu_name_resolver.get_names")
+    @patch("frigate.util.services.time.sleep")
+    @patch("frigate.util.services.time.monotonic")
+    @patch("frigate.util.services._read_intel_drm_fdinfo")
+    def test_intel_gpu_stats_xe_capacity(
+        self, read_fdinfo, monotonic, sleep, get_names
+    ):
+        # Xe engines report cumulative cycles paired with total cycles, plus a
+        # per-class capacity. drm-cycles-* is summed across every instance of a
+        # class, so on Battlemage (capacity 2 for vcs/vecs) busy/total must be
+        # divided by capacity to land in 0-100%.
+        monotonic.side_effect = [0.0, 1.0]
+        get_names.return_value = {"0000:03:00.0": "Intel Arc"}
+
+        # Deltas over the window (busy, total): render 200/1000 cap 1 = 20%,
+        # video 800/1000 cap 2 = 40%, video-enhance 400/1000 cap 2 = 20%,
+        # compute 100/1000 cap 1 = 10%. Without the capacity divisor video/
+        # video-enhance would read 80%/40% and dec would clamp at 100%.
+        snapshot_a = {
+            ("0000:03:00.0", "1", "300"): {
+                "driver": "xe",
+                "pid": "300",
+                "engines": {
+                    "render": (0, 0, 1),
+                    "video": (0, 0, 2),
+                    "video-enhance": (0, 0, 2),
+                    "compute": (0, 0, 1),
+                },
+            },
+        }
+        snapshot_b = {
+            ("0000:03:00.0", "1", "300"): {
+                "driver": "xe",
+                "pid": "300",
+                "engines": {
+                    "render": (200, 1000, 1),
+                    "video": (800, 1000, 2),
+                    "video-enhance": (400, 1000, 2),
+                    "compute": (100, 1000, 1),
+                },
+            },
+        }
+        read_fdinfo.side_effect = [snapshot_a, snapshot_b]
+
+        intel_stats = get_intel_gpu_stats(None)
+
+        assert intel_stats == {
+            "0000:03:00.0": {
+                "name": "Intel Arc",
+                "vendor": "intel",
+                "gpu": "90.0%",
+                "mem": "-%",
+                "compute": "30.0%",
+                "dec": "60.0%",
+                "clients": {"300": "90.0%"},
+            },
+        }
+
     @patch("frigate.util.services._read_intel_drm_fdinfo")
     def test_intel_gpu_stats_no_clients(self, read_fdinfo):
         read_fdinfo.return_value = {}

frigate/test/test_maintainer.py

@@ -1,7 +1,7 @@
 import datetime
 import sys
 import unittest
-from unittest.mock import MagicMock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
 
 # Mock complex imports before importing maintainer, saving originals so we can
 # restore them after import and avoid polluting sys.modules for other tests.
@@ -42,38 +42,51 @@ class TestMaintainer(unittest.IsolatedAsyncioTestCase):
         # One bad file, one good file
         files = ["bad_filename.mp4", "camera@20210101000000+0000.mp4"]
 
-        with patch("os.listdir", return_value=files):
-            with patch("os.path.isfile", return_value=True):
-                with patch(
-                    "frigate.record.maintainer.psutil.process_iter", return_value=[]
-                ):
-                    with patch("frigate.record.maintainer.logger.warning") as warn:
-                        # Mock validate_and_move_segment to avoid further logic
-                        maintainer.validate_and_move_segment = MagicMock()
+        mock_paths = []
+        for filename in files:
+            path = MagicMock()
+            path.name = filename
+            path.suffix = ".mp4"
+            path.is_file = AsyncMock(return_value=True)
+            mock_paths.append(path)
 
-                        try:
-                            await maintainer.move_files()
-                        except ValueError as e:
-                            if "not enough values to unpack" in str(e):
-                                self.fail("move_files() crashed on bad filename!")
-                            raise e
-                        except Exception:
-                            # Ignore other errors (like DB connection) as we only care about the unpack crash
-                            pass
+        async def mock_iterdir():
+            for path in mock_paths:
+                yield path
 
-                        # The bad filename is encountered in multiple loops, but should only warn once.
-                        matching = [
-                            c
-                            for c in warn.call_args_list
-                            if c.args
-                            and isinstance(c.args[0], str)
-                            and "Skipping unexpected files in cache" in c.args[0]
-                        ]
-                        self.assertEqual(
-                            1,
-                            len(matching),
-                            f"Expected a single warning for unexpected files, got {len(matching)}",
-                        )
+        with patch("frigate.record.maintainer.AsyncPath") as mock_async_path:
+            mock_async_path.return_value.iterdir = mock_iterdir
+
+            with patch(
+                "frigate.record.maintainer.psutil.process_iter", return_value=[]
+            ):
+                with patch("frigate.record.maintainer.logger.warning") as warn:
+                    # Mock validate_and_move_segment to avoid further logic
+                    maintainer.validate_and_move_segment = MagicMock()
+
+                    try:
+                        await maintainer.move_files()
+                    except ValueError as e:
+                        if "not enough values to unpack" in str(e):
+                            self.fail("move_files() crashed on bad filename!")
+                        raise e
+                    except Exception:
+                        # Ignore other errors (like DB connection) as we only care about the unpack crash
+                        pass
+
+                    # The bad filename is encountered in multiple loops, but should only warn once.
+                    matching = [
+                        c
+                        for c in warn.call_args_list
+                        if c.args
+                        and isinstance(c.args[0], str)
+                        and "Skipping unexpected files in cache" in c.args[0]
+                    ]
+                    self.assertEqual(
+                        1,
+                        len(matching),
+                        f"Expected a single warning for unexpected files, got {len(matching)}",
+                    )
 
     async def test_drops_quiet_segment_when_only_motion_retention(self):
         # Regression: when motion retention is enabled but a segment has no

frigate/test/test_sqlitevecq_regexp.py

@@ -0,0 +1,54 @@
+"""Tests for the REGEXP function registered on the main Frigate database.
+
+Regression coverage for GHSA-q8jx-q884-jcq9: an attacker-controlled
+catastrophic (ReDoS) pattern reaching the REGEXP sink must not be able to
+stall the serialized database worker thread.
+"""
+
+import sqlite3
+import time
+import unittest
+
+from frigate.db.sqlitevecq import REGEXP_TIMEOUT_SECONDS, SqliteVecQueueDatabase
+
+
+class TestRegexpFunction(unittest.TestCase):
+    def setUp(self) -> None:
+        # autostart=False keeps the queue worker thread from spinning up; we
+        # only need the REGEXP registration, exercised on our own connection.
+        self.db = SqliteVecQueueDatabase(":memory:", autostart=False)
+        self.conn = sqlite3.connect(":memory:")
+        self.db._register_regexp(self.conn)
+
+    def tearDown(self) -> None:
+        self.conn.close()
+
+    def _regexp(self, value: str | None, pattern: str) -> int | None:
+        # SQLite maps "value REGEXP pattern" to regexp(pattern, value).
+        return self.conn.execute("SELECT ? REGEXP ?", (value, pattern)).fetchone()[0]
+
+    def test_normal_patterns_still_match(self) -> None:
+        self.assertTrue(self._regexp("ABC123", "^ABC"))
+        self.assertTrue(self._regexp("ABC123", "ABC.*"))
+        self.assertTrue(self._regexp("ABC123", "[0-9]+$"))
+        self.assertFalse(self._regexp("ABC123", "^XYZ"))
+
+    def test_null_value_does_not_match(self) -> None:
+        self.assertFalse(self._regexp(None, ".*"))
+
+    def test_invalid_pattern_does_not_raise(self) -> None:
+        self.assertFalse(self._regexp("ABC123", "(unclosed"))
+
+    def test_catastrophic_pattern_is_time_bounded(self) -> None:
+        # Without the timeout this evaluation backtracks for minutes to hours
+        # and wedges the whole database thread (GHSA-q8jx-q884-jcq9).
+        catastrophic = "(a{2,})+c"
+        subject = "a" * 4000
+
+        start = time.monotonic()
+        result = self._regexp(subject, catastrophic)
+        elapsed = time.monotonic() - start
+
+        # The pattern does not match; the guarantee is that it returns quickly.
+        self.assertFalse(result)
+        self.assertLess(elapsed, REGEXP_TIMEOUT_SECONDS + 2.0)

frigate/util/services.py

@@ -360,7 +360,7 @@ def _read_intel_drm_fdinfo(target_pdev: str | None) -> dict:
             if key in snapshot:
                 continue
 
-            engines: dict[str, tuple[int, int]] = {}
+            engines: dict[str, tuple[int, int, int]] = {}
 
             if driver == "i915":
                 for fkey, engine in _I915_ENGINE_KEYS.items():
@@ -368,19 +368,34 @@ def _read_intel_drm_fdinfo(target_pdev: str | None) -> dict:
                     if not raw:
                         continue
                     try:
-                        engines[engine] = (int(raw.split()[0]), 0)
+                        engines[engine] = (int(raw.split()[0]), 0, 1)
                     except (ValueError, IndexError):
                         continue
             else:
                 for suffix, engine in _XE_ENGINE_KEYS.items():
                     busy_raw = fields.get(f"drm-cycles-{suffix}")
                     total_raw = fields.get(f"drm-total-cycles-{suffix}")
+
                     if not (busy_raw and total_raw):
                         continue
+
+                    # drm-cycles-* is summed across every instance of the engine
+                    # class while drm-total-cycles-* tracks a single instance, so
+                    # busy/total scales up to the capacity (e.g. Battlemage
+                    # reports 2 for vcs/vecs). Capture it to divide back out;
+                    # absent means a single engine, so default to 1.
+                    capacity_raw = fields.get(f"drm-engine-capacity-{suffix}")
+
+                    try:
+                        capacity = int(capacity_raw.split()[0]) if capacity_raw else 1
+                    except (ValueError, IndexError):
+                        capacity = 1
+
                     try:
                         engines[engine] = (
                             int(busy_raw.split()[0]),
                             int(total_raw.split()[0]),
+                            max(1, capacity),
                         )
                     except (ValueError, IndexError):
                         continue
@@ -450,11 +465,13 @@ def get_intel_gpu_stats(
         pid_pct = per_pdev_pid_pct.setdefault(pdev, {})
 
         client_total = 0.0
-        for engine, (busy_b, total_b) in data_b["engines"].items():
+        for engine, (busy_b, total_b, capacity) in data_b["engines"].items():
             if engine not in engine_pct:
                 continue
 
-            busy_a, total_a = data_a["engines"].get(engine, (busy_b, total_b))
+            busy_a, total_a, _ = data_a["engines"].get(
+                engine, (busy_b, total_b, capacity)
+            )
 
             if data_b["driver"] == "i915":
                 delta = max(0, busy_b - busy_a)
@@ -464,7 +481,9 @@ def get_intel_gpu_stats(
                 delta_total = total_b - total_a
                 if delta_total <= 0:
                     continue
-                pct = min(100.0, delta_busy / delta_total * 100.0)
+                # Normalize by capacity so a class with N engine instances
+                # (busy summed across all N) reports 0-100%, not 0-N*100%.
+                pct = min(100.0, delta_busy / (delta_total * capacity) * 100.0)
 
             engine_pct[engine] += pct
             client_total += pct

pyproject.toml

@@ -2,5 +2,20 @@
 target-version = "py311"
 
 [tool.ruff.lint]
-ignore = ["E501","E711","E712","UP031","UP032","UP042","G004"]
-extend-select = ["I", "UP", "G", "ASYNC210", "B904"]
+ignore = [
+  "ASYNC109", # Async function definition with a timeout parameter
+  "E501",     # line-too-long
+  "E711",     # none-comparison
+  "E712",     # true-false-comparison
+  "UP031",    # printf-string-formatting
+  "UP032",    # f-string
+  "UP042",    # replace-str-enum
+  "G004",     # logging-f-string
+]
+extend-select = [
+  "ASYNC", # https://docs.astral.sh/ruff/rules/#flake8-async-async
+  "B904",  # https://docs.astral.sh/ruff/rules/raise-without-from-inside-except/
+  "G",     # https://docs.astral.sh/ruff/rules/#flake8-logging-format-g
+  "I",     # https://docs.astral.sh/ruff/rules/#isort-i
+  "UP",    # https://docs.astral.sh/ruff/rules/#pyupgrade-up
+]

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

@@ -169,6 +169,13 @@ const detect: SectionConfigOverrides = {
       resolution: ["width", "height", "fps"],
       tracking: ["min_initialized", "max_disappeared"],
     },
+    uiSchema: {
+      annotation_offset: {
+        "ui:options": {
+          signed: true,
+        },
+      },
+    },
     hiddenFields: ["enabled_in_config"],
     advancedFields: [
       "min_initialized",

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

@@ -57,6 +57,7 @@ const record: SectionConfigOverrides = {
           "ui:options": {
             suppressMultiSchema: true,
             ffmpegPresetField: "hwaccel_args",
+            ffmpegGlobalFieldPath: "export.hwaccel_args",
           },
         },
       },

web/src/components/config-form/theme/utils/index.ts

@@ -17,3 +17,4 @@ export {
   isSubtreeModified,
 } from "./overrides";
 export { getSizedFieldClassName } from "./fieldSizing";
+export { getNumericInputMode } from "./inputMode";

web/src/components/config-form/theme/utils/inputMode.ts

@@ -0,0 +1,51 @@
+import type { RJSFSchema } from "@rjsf/utils";
+
+type NumericInputOptions = {
+  signed?: boolean;
+};
+
+/**
+ * Derive the on-screen keyboard hint for a schema field.
+ *
+ * Numeric config fields render as text inputs because RJSF's NumberField
+ * relies on the widget echoing raw strings back, so that trailing "." and "0"
+ * characters survive while a value is being typed. That means the numeric
+ * keypad has to be requested explicitly. Desktop browsers ignore inputMode, so
+ * this only affects virtual keyboards.
+ *
+ * Fields accepting negative values opt out, since the iOS numeric and decimal
+ * keypads have no minus key. Most numeric fields declare no minimum even
+ * though they are non-negative, so signed fields are marked explicitly with
+ * ui:options.signed.
+ *
+ * Args:
+ *     schema: The JSON schema for the field being rendered
+ *     options: The resolved ui:options for the field
+ *
+ * Returns:
+ *     The inputMode to apply, or undefined to leave the keyboard alone
+ */
+export function getNumericInputMode(
+  schema: RJSFSchema,
+  options: unknown,
+): "numeric" | "decimal" | undefined {
+  const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+  const isInteger = types.includes("integer");
+
+  if (!isInteger && !types.includes("number")) {
+    return undefined;
+  }
+
+  const numericOptions =
+    typeof options === "object" && options !== null
+      ? (options as NumericInputOptions)
+      : undefined;
+
+  const minimum = schema.minimum ?? schema.exclusiveMinimum;
+
+  if (numericOptions?.signed || (minimum ?? 0) < 0) {
+    return undefined;
+  }
+
+  return isInteger ? "numeric" : "decimal";
+}

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

@@ -120,6 +120,12 @@ export function FfmpegArgsWidget(props: WidgetProps) {
     id,
   } = props;
   const presetField = options?.ffmpegPresetField as PresetField | undefined;
+  // Path to this field within its config section. This is usually the same as
+  // the preset field, but the two diverge when the field sits below the
+  // section root: record.export.hwaccel_args uses the hwaccel_args preset list
+  // while living at export.hwaccel_args inside the record section.
+  const globalFieldPath =
+    (options?.ffmpegGlobalFieldPath as string | undefined) ?? presetField;
   const allowInherit = options?.allowInherit === true;
   const hideDescription = options?.hideDescription === true;
   const useSplitLayout = options?.splitLayout !== false;
@@ -131,11 +137,18 @@ export function FfmpegArgsWidget(props: WidgetProps) {
 
   // Extract the global value for this specific field to detect inheritance
   const globalFieldValue = useMemo(() => {
-    if (!showUseGlobalSetting || !formContext?.globalValue || !presetField) {
+    if (
+      !showUseGlobalSetting ||
+      !formContext?.globalValue ||
+      !globalFieldPath
+    ) {
       return undefined;
     }
-    return get(formContext.globalValue as Record<string, unknown>, presetField);
-  }, [showUseGlobalSetting, formContext?.globalValue, presetField]);
+    return get(
+      formContext.globalValue as Record<string, unknown>,
+      globalFieldPath,
+    );
+  }, [showUseGlobalSetting, formContext?.globalValue, globalFieldPath]);
 
   const { data } = useSWR<FfmpegPresetResponse>("ffmpeg/presets");
 

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

@@ -1,8 +1,10 @@
 import type { WidgetProps } from "@rjsf/utils";
-import { useMemo } from "react";
+import { useEffect, useMemo } from "react";
 import { useTranslation } from "react-i18next";
+import useSWR from "swr";
 import { Switch } from "@/components/ui/switch";
 import type { ConfigFormContext } from "@/types/configForm";
+import type { GenAIModelsResponse } from "@/types/chat";
 
 const GENAI_ROLES = ["embeddings", "descriptions", "chat"] as const;
 
@@ -37,10 +39,24 @@ export function GenAIRolesWidget(props: WidgetProps) {
   const selectedRoles = useMemo(() => normalizeValue(value), [value]);
   const providerKey = useMemo(() => getProviderKey(id), [id]);
 
-  // Compute occupied roles directly from formData. The computation is
-  // trivially cheap (iterate providers × 3 roles max) so we skip an
-  // intermediate memoization layer whose formData dependency would
-  // never produce a cache hit (new object reference on every change).
+  const { data: genaiInfo } = useSWR<GenAIModelsResponse>("genai/models", {
+    revalidateOnFocus: false,
+  });
+
+  const embeddingsSupported = useMemo(() => {
+    if (!providerKey) return true;
+    const info = genaiInfo?.[providerKey];
+    return info ? info.supports_embeddings : true;
+  }, [genaiInfo, providerKey]);
+
+  const availableRoles = useMemo(
+    () =>
+      embeddingsSupported
+        ? GENAI_ROLES
+        : GENAI_ROLES.filter((role) => role !== "embeddings"),
+    [embeddingsSupported],
+  );
+
   const occupiedRoles = useMemo(() => {
     const occupied = new Set<string>();
     const fd = formContext?.formData;
@@ -64,6 +80,12 @@ export function GenAIRolesWidget(props: WidgetProps) {
     return occupied;
   }, [formContext?.formData, providerKey]);
 
+  useEffect(() => {
+    if (!embeddingsSupported && selectedRoles.includes("embeddings")) {
+      onChange(selectedRoles.filter((role) => role !== "embeddings"));
+    }
+  }, [embeddingsSupported, selectedRoles, onChange]);
+
   const toggleRole = (role: string, enabled: boolean) => {
     if (enabled) {
       if (!selectedRoles.includes(role)) {
@@ -78,7 +100,7 @@ export function GenAIRolesWidget(props: WidgetProps) {
   return (
     <div className="rounded-lg border border-secondary-highlight bg-background_alt p-2 pr-0 md:max-w-md">
       <div className="grid gap-2">
-        {GENAI_ROLES.map((role) => {
+        {availableRoles.map((role) => {
           const checked = selectedRoles.includes(role);
           const roleDisabled = !checked && occupiedRoles.has(role);
           const label = t(`configForm.genaiRoles.options.${role}`, {

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

@@ -2,7 +2,7 @@
 import type { WidgetProps } from "@rjsf/utils";
 import { Input } from "@/components/ui/input";
 import { cn } from "@/lib/utils";
-import { getSizedFieldClassName } from "../utils";
+import { getNumericInputMode, getSizedFieldClassName } from "../utils";
 
 export function TextWidget(props: WidgetProps) {
   const {
@@ -28,6 +28,7 @@ export function TextWidget(props: WidgetProps) {
       id={id}
       className={cn(fieldClassName)}
       type="text"
+      inputMode={getNumericInputMode(schema, options)}
       value={value ?? ""}
       disabled={disabled || readonly}
       placeholder={placeholder || (options.placeholder as string) || ""}

web/src/components/overlay/ObjectTrackOverlay.tsx

@@ -127,8 +127,12 @@ export default function ObjectTrackOverlay({
     },
   );
 
-  const getZonesFriendlyNames = (zones: string[], config: FrigateConfig) => {
-    return zones?.map((zone) => resolveZoneName(config, zone)) ?? [];
+  const getZonesFriendlyNames = (
+    zones: string[],
+    config: FrigateConfig,
+    cameraId?: string,
+  ) => {
+    return zones?.map((zone) => resolveZoneName(config, zone, cameraId)) ?? [];
   };
 
   const timelineResults = useMemo(() => {
@@ -151,7 +155,7 @@ export default function ObjectTrackOverlay({
         data: {
           ...event.data,
           zones_friendly_names: config
-            ? getZonesFriendlyNames(event.data?.zones, config)
+            ? getZonesFriendlyNames(event.data?.zones, config, event.camera)
             : [],
         },
       }));

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

@@ -61,7 +61,11 @@ export function ObjectPath({
                 ...pos.lifecycle_item?.data,
                 zones_friendly_names: pos.lifecycle_item?.data.zones.map(
                   (zone) => {
-                    return resolveZoneName(config, zone);
+                    return resolveZoneName(
+                      config,
+                      zone,
+                      pos.lifecycle_item?.camera,
+                    );
                   },
                 ),
               },

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

@@ -301,11 +301,19 @@ export function TrackingDetails({
     [recordings, actualVideoStart],
   );
 
-  eventSequence?.map((event) => {
-    event.data.zones_friendly_names = event.data?.zones?.map((zone) => {
-      return resolveZoneName(config, zone);
-    });
-  });
+  const sequence = useMemo(
+    () =>
+      eventSequence?.map((item) => ({
+        ...item,
+        data: {
+          ...item.data,
+          zones_friendly_names: item.data?.zones?.map((zone) =>
+            resolveZoneName(config, zone, item.camera),
+          ),
+        },
+      })),
+    [eventSequence, config],
+  );
 
   // Use manualOverride (set when seeking in image mode) if present so
   // lifecycle rows and overlays follow image-mode seeks. Otherwise fall
@@ -849,9 +857,9 @@ export function TrackingDetails({
             </div>
 
             <div className="mt-2">
-              {!eventSequence ? (
+              {!sequence ? (
                 <ActivityIndicator className="size-2" size={2} />
-              ) : eventSequence.length === 0 ? (
+              ) : sequence.length === 0 ? (
                 <div className="py-2 text-muted-foreground">
                   {t("detail.noObjectDetailData", { ns: "views/events" })}
                 </div>
@@ -871,7 +879,7 @@ export function TrackingDetails({
                     />
                   )}
                   <div className="space-y-2">
-                    {eventSequence.map((item, idx) => {
+                    {sequence.map((item, idx) => {
                       return (
                         <div
                           key={`${item.timestamp}-${item.source_id ?? ""}-${idx}`}

web/src/components/settings/PolygonItem.tsx

@@ -27,7 +27,7 @@ import axios from "axios";
 import { toast } from "sonner";
 import useSWR from "swr";
 import { FrigateConfig } from "@/types/frigateConfig";
-import { reviewQueries } from "@/utils/zoneEdutUtil";
+import { removeRequiredZoneQuery, reviewQueries } from "@/utils/zoneEdutUtil";
 import IconWrapper from "../ui/icon-wrapper";
 import { buttonVariants } from "@/components/ui/button";
 import { Trans, useTranslation } from "react-i18next";
@@ -153,6 +153,30 @@ export default function PolygonItem({
             cameraConfig?.review.alerts.required_zones || [],
             cameraConfig?.review.detections.required_zones || [],
           );
+          const genaiQueries = removeRequiredZoneQuery(
+            polygon.name,
+            polygon.camera,
+            "objects.genai",
+            cameraConfig?.objects.genai.required_zones || [],
+          );
+          const snapshotQueries = removeRequiredZoneQuery(
+            polygon.name,
+            polygon.camera,
+            "snapshots",
+            cameraConfig?.snapshots.required_zones || [],
+          );
+          const mqttQueries = removeRequiredZoneQuery(
+            polygon.name,
+            polygon.camera,
+            "mqtt",
+            cameraConfig?.mqtt.required_zones || [],
+          );
+          const autotrackQueries = removeRequiredZoneQuery(
+            polygon.name,
+            polygon.camera,
+            "onvif.autotracking",
+            cameraConfig?.onvif.autotracking.required_zones || [],
+          );
           // Also delete from profiles that have overrides for this zone
           let profileQueries = "";
           if (allProfileNames && cameraConfig) {
@@ -165,7 +189,7 @@ export default function PolygonItem({
               }
             }
           }
-          url = `cameras.${polygon.camera}.zones.${polygon.name}${alertQueries}${detectionQueries}${profileQueries}`;
+          url = `cameras.${polygon.camera}.zones.${polygon.name}${alertQueries}${detectionQueries}${genaiQueries}${snapshotQueries}${mqttQueries}${autotrackQueries}${profileQueries}`;
         }
 
         await axios

web/src/components/settings/ZoneEditPane.tsx

@@ -108,7 +108,11 @@ export default function ZoneEditPane({
     }
     const inRequiredZones =
       cam.review.alerts.required_zones.includes(polygon.name) ||
-      cam.review.detections.required_zones.includes(polygon.name);
+      cam.review.detections.required_zones.includes(polygon.name) ||
+      cam.objects.genai.required_zones.includes(polygon.name) ||
+      cam.snapshots.required_zones.includes(polygon.name) ||
+      cam.mqtt.required_zones.includes(polygon.name) ||
+      cam.onvif.autotracking.required_zones.includes(polygon.name);
     const hasProfileOverride = Object.values(cam.profiles ?? {}).some(
       (profile) => profile?.zones && polygon.name in profile.zones,
     );

web/src/components/timeline/DetailStream.tsx

@@ -1032,7 +1032,7 @@ function ObjectTimeline({
         data: {
           ...event.data,
           zones_friendly_names: event.data?.zones?.map((zone) =>
-            resolveZoneName(config, zone),
+            resolveZoneName(config, zone, event.camera),
           ),
         },
       }));

web/src/types/chat.ts

@@ -43,6 +43,7 @@ export type GenAIProviderInfo = {
   models: string[];
   roles: string[];
   supports_toggleable_thinking: boolean;
+  supports_embeddings: boolean;
 };
 
 export type GenAIModelsResponse = Record<string, GenAIProviderInfo>;

web/src/utils/zoneEdutUtil.ts

@@ -1,3 +1,33 @@
+// Build a config/set query fragment that removes `name` from a
+// required_zones list on the given camera section (e.g. "snapshots",
+// "mqtt", "objects.genai", "onvif.autotracking"), rebuilding the
+// remaining entries. When removing the name empties the list, the
+// required_zones key itself is deleted so the field reverts to its
+// default instead of retaining the now-stale zone name. Returns an empty
+// string when `name` is not present so unrelated sections are untouched.
+export const removeRequiredZoneQuery = (
+  name: string,
+  camera: string,
+  section: string,
+  zones: string[],
+) => {
+  const remaining = new Set<string>(zones || []);
+
+  if (!remaining.has(name)) {
+    return "";
+  }
+
+  remaining.delete(name);
+
+  const key = `cameras.${camera}.${section}.required_zones`;
+
+  if (remaining.size === 0) {
+    return `&${key}`;
+  }
+
+  return [...remaining].map((zone) => `&${key}=${zone}`).join("");
+};
+
 export const reviewQueries = (
   name: string,
   review_alerts: boolean,