@agent-native/core 0.76.12 → 0.76.13

package/corpus/README.md

@@ -28,4 +28,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 ## Generated Counts
 
 - core files: 1929
-- template files: 4250
+- template files: 4251

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @agent-native/core
 
+## 0.76.13
+
+### Patch Changes
+
+- d12772c: Durable background agent-chat: raise the foreground circuit-breaker's claim grace
+  from 8s to 15s (`BACKGROUND_CLAIM_GRACE_MS`). Heavy apps (observed on analytics
+  in prod) take longer than 8s to cold-start the background function and reach
+  `claimBackgroundRun`, so the foreground recovered inline every time — adding ~8s
+  latency per turn and never using the 15-minute background budget. 15s lets the
+  slow-but-alive workers win the claim while staying well within the foreground's
+  ~40s soft-timeout; a genuinely dead worker still falls back to inline.
+
 ## 0.76.12
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.76.12",
+  "version": "0.76.13",
   "type": "module",
   "engines": {
     "node": ">=22"

package/corpus/core/src/agent/production-agent.ts

@@ -153,11 +153,14 @@ export { PROVIDER_TO_ENV };
 /**
  * Grace window + poll interval for the foreground circuit-breaker that confirms
  * a background worker actually CLAIMED a 202-dispatched run before recovering
- * inline. The grace is long enough for a cold-start worker to win the claim
- * (~1-2s typical) and short enough to recover quickly within the foreground's
- * ~40s soft-timeout.
+ * inline. The grace must cover the worker's cold-start + per-request init before
+ * it reaches `claimBackgroundRun`: light apps win the claim in ~1-2s, but heavy
+ * apps (e.g. analytics) were observed in prod taking >8s, so an 8s grace made
+ * their worker lose the race every time and always fall back to inline (adding
+ * ~8s latency with no background budget). 15s covers the slow apps while staying
+ * well within the foreground's ~40s soft-timeout.
  */
-export const BACKGROUND_CLAIM_GRACE_MS = 8_000;
+export const BACKGROUND_CLAIM_GRACE_MS = 15_000;
 export const BACKGROUND_CLAIM_POLL_MS = 400;
 
 export type BackgroundDispatchOutcome =

package/corpus/templates/clips/app/components/recorder/camera-visualizer.tsx

@@ -2,6 +2,11 @@ import { useCallback, useEffect, useRef, useState } from "react";
 
 import { Button } from "@/components/ui/button";
 import { cn } from "@/lib/utils";
+import {
+  createBackgroundBlurStream,
+  DEFAULT_BLUR_PX,
+  type CameraBlurHandle,
+} from "@/lib/camera-blur";
 import type { CameraBubbleSize } from "./camera-bubble";
 
 export type CameraTestStatus = "idle" | "starting" | "live" | "error";
@@ -10,6 +15,10 @@ export interface CameraVisualizerProps {
   deviceId: string | null;
   disabled?: boolean;
   className?: string;
+  /** Mirror the recording's background-blur setting in the live test preview. */
+  blur?: boolean;
+  /** Background blur radius (px) reflected live in the test preview. */
+  blurRadius?: number;
   size?: CameraBubbleSize;
   onSizeChange?: (size: CameraBubbleSize) => void;
   onStatusChange?: (
@@ -119,6 +128,8 @@ export function CameraVisualizer({
   deviceId,
   disabled,
   className,
+  blur = false,
+  blurRadius = DEFAULT_BLUR_PX,
   size = "md",
   onSizeChange,
   onStatusChange,
@@ -126,8 +137,14 @@ export function CameraVisualizer({
 }: CameraVisualizerProps) {
   const videoRef = useRef<HTMLVideoElement | null>(null);
   const streamRef = useRef<MediaStream | null>(null);
+  const blurHandleRef = useRef<CameraBlurHandle | null>(null);
+  // Bumped per attachPreview() so a stale segmenter build (blur toggled mid-load)
+  // bails instead of clobbering the preview.
+  const attachGenRef = useRef(0);
+  const blurRadiusRef = useRef(blurRadius);
   const runIdRef = useRef(0);
   const previousDeviceIdRef = useRef(deviceId);
+  const previousBlurRef = useRef(blur);
 
   const [status, setStatus] = useState<CameraTestStatus>("idle");
   const [error, setError] = useState<string | null>(null);
@@ -144,11 +161,45 @@ export function CameraVisualizer({
   }, [onPreviewChange]);
 
   const stopCurrent = useCallback(() => {
+    blurHandleRef.current?.cleanup();
+    blurHandleRef.current = null;
     stopStream(streamRef.current);
     streamRef.current = null;
     clearVideo();
   }, [clearVideo]);
 
+  // Bind the raw camera or its blurred derivative to the <video> per the current
+  // `blur` setting, so the preview matches what recording bakes in. Each call
+  // claims a generation and bails if a newer attach superseded it during an await.
+  const attachPreview = useCallback(async () => {
+    const gen = ++attachGenRef.current;
+    const raw = streamRef.current;
+    const video = videoRef.current;
+    if (!raw || !video) return;
+
+    let display: MediaStream = raw;
+    if (blur) {
+      blurHandleRef.current?.cleanup();
+      blurHandleRef.current = null;
+      const handle = await createBackgroundBlurStream(raw, {
+        blurPx: blurRadiusRef.current,
+      });
+      if (gen !== attachGenRef.current || streamRef.current !== raw) {
+        handle.cleanup();
+        return;
+      }
+      blurHandleRef.current = handle;
+      display = handle.stream;
+    } else {
+      blurHandleRef.current?.cleanup();
+      blurHandleRef.current = null;
+    }
+
+    if (gen !== attachGenRef.current) return;
+    if (video.srcObject !== display) video.srcObject = display;
+    await video.play().catch(() => {});
+  }, [blur]);
+
   const stopTest = useCallback(() => {
     runIdRef.current += 1;
     stopCurrent();
@@ -216,12 +267,15 @@ export function CameraVisualizer({
       }
 
       streamRef.current = stream;
-      const video = videoRef.current;
-      if (video) {
-        video.srcObject = stream;
-        await video.play().catch(() => {});
+      // Webcam unplugged mid-test: tear down so the preview + blur pipeline
+      // don't keep running frozen. runId guard skips our own stop().
+      for (const track of stream.getVideoTracks()) {
+        track.addEventListener("ended", () => {
+          if (runIdRef.current === runId) stopTest();
+        });
       }
-      // Re-check after play()'s await so a newer startTest can't be clobbered.
+      await attachPreview();
+      // Re-check after the async attach so a newer startTest can't be clobbered.
       if (runIdRef.current !== runId) {
         stopCurrent();
         return;
@@ -239,7 +293,15 @@ export function CameraVisualizer({
       onStatusChange?.("error", { error: message });
       clearVideo();
     }
-  }, [clearVideo, deviceId, disabled, onStatusChange, stopCurrent]);
+  }, [
+    attachPreview,
+    clearVideo,
+    deviceId,
+    disabled,
+    onStatusChange,
+    stopCurrent,
+    stopTest,
+  ]);
 
   useEffect(() => {
     if (disabled) {
@@ -270,10 +332,10 @@ export function CameraVisualizer({
   useEffect(() => {
     if (status !== "live" && status !== "starting") return;
     const video = videoRef.current;
-    const stream = streamRef.current;
-    if (!video || !stream) return;
-    if (video.srcObject !== stream) {
-      video.srcObject = stream;
+    const display = blurHandleRef.current?.stream ?? streamRef.current;
+    if (!video || !display) return;
+    if (video.srcObject !== display) {
+      video.srcObject = display;
     }
     const tryPlay = () => {
       video.play().catch(() => undefined);
@@ -285,6 +347,22 @@ export function CameraVisualizer({
     };
   }, [status]);
 
+  // Toggle blur while live: swap the preview source in place (startTest already
+  // binds the initial value, so skip mount).
+  useEffect(() => {
+    if (previousBlurRef.current === blur) return;
+    previousBlurRef.current = blur;
+    if (status !== "live" && status !== "starting") return;
+    if (!streamRef.current) return;
+    void attachPreview();
+  }, [blur, status, attachPreview]);
+
+  // Slider drags adjust the live pipeline without rebuilding the segmenter.
+  useEffect(() => {
+    blurRadiusRef.current = blurRadius;
+    blurHandleRef.current?.setBlurPx(blurRadius);
+  }, [blurRadius]);
+
   const live = status === "live";
   const starting = status === "starting";
   const showBubble = live || starting;

package/corpus/templates/clips/app/components/recorder/pre-record-panel.tsx

@@ -7,6 +7,7 @@ import {
   type FormEvent,
 } from "react";
 import {
+  IconBlur,
   IconBrowser,
   IconCamera,
   IconChevronDown,
@@ -40,6 +41,7 @@ import {
   SelectValue,
 } from "@/components/ui/select";
 import { Switch } from "@/components/ui/switch";
+import { Slider } from "@/components/ui/slider";
 import { cn } from "@/lib/utils";
 import {
   NO_CAMERA_DEVICE_ID,
@@ -48,6 +50,7 @@ import {
   type RecordingMode,
 } from "./recorder-engine";
 import type { CameraBubbleSize } from "./camera-bubble";
+import { DEFAULT_BLUR_PX, MAX_BLUR_PX, MIN_BLUR_PX } from "@/lib/camera-blur";
 import {
   loadRecorderPreferences,
   saveRecorderPreferences,
@@ -65,6 +68,8 @@ export interface PreRecordPanelProps {
     displaySurface: DisplaySurface;
     micDeviceId: string | null;
     cameraDeviceId: string | null;
+    cameraBlur: boolean;
+    cameraBlurRadius: number;
   }) => void;
   initialMode?: RecordingMode | null;
   initialDisplaySurface?: DisplaySurface | null;
@@ -210,6 +215,12 @@ export function PreRecordPanel({
   const [cameraId, setCameraId] = useState<string>(
     () => savedPrefs.cameraId ?? "default",
   );
+  const [cameraBlur, setCameraBlur] = useState(
+    () => savedPrefs.cameraBlur ?? false,
+  );
+  const [cameraBlurRadius, setCameraBlurRadius] = useState(
+    () => savedPrefs.cameraBlurRadius ?? DEFAULT_BLUR_PX,
+  );
   const [enumError, setEnumError] = useState<string | null>(null);
   const [micAccessStatus, setMicAccessStatus] =
     useState<DeviceAccessStatus>("idle");
@@ -335,6 +346,10 @@ export function PreRecordPanel({
     setCameraId(value);
     saveRecorderPreferences({ cameraId: value });
   }, []);
+  const chooseCameraBlur = useCallback((value: boolean) => {
+    setCameraBlur(value);
+    saveRecorderPreferences({ cameraBlur: value });
+  }, []);
 
   const requestMicrophoneChoices = useCallback(async () => {
     if (!navigator.mediaDevices?.getUserMedia) {
@@ -826,12 +841,59 @@ export function PreRecordPanel({
                     <CameraVisualizer
                       deviceId={cameraId === "default" ? null : cameraId}
                       disabled={busy}
+                      blur={cameraBlur}
+                      blurRadius={cameraBlurRadius}
                       size={cameraSize}
                       onSizeChange={onCameraSizeChange}
                       onStatusChange={handleCameraStatusChange}
                       onPreviewChange={handleCameraPreviewChange}
                     />
                   ) : null}
+
+                  {needsCamera ? (
+                    <label className="flex cursor-pointer items-center gap-2 rounded-lg px-1 py-1.5 hover:bg-muted/45">
+                      <div className="flex h-8 w-8 shrink-0 items-center justify-center rounded-lg bg-muted text-muted-foreground">
+                        <IconBlur className="h-4 w-4" />
+                      </div>
+                      <div className="min-w-0 flex-1">
+                        <p className="text-sm">Blur background</p>
+                        <p className="text-[11px] text-muted-foreground">
+                          Keep yourself sharp, blur what's behind you
+                        </p>
+                      </div>
+                      <Switch
+                        checked={cameraBlur}
+                        onCheckedChange={chooseCameraBlur}
+                        disabled={busy}
+                        aria-label="Blur the camera background"
+                      />
+                    </label>
+                  ) : null}
+
+                  {needsCamera && cameraBlur ? (
+                    <div className="flex items-center gap-3 px-1 pb-1">
+                      <span className="w-14 shrink-0 text-[11px] text-muted-foreground">
+                        Intensity
+                      </span>
+                      <Slider
+                        value={[cameraBlurRadius]}
+                        min={MIN_BLUR_PX}
+                        max={MAX_BLUR_PX}
+                        step={1}
+                        disabled={busy}
+                        onValueChange={(value) =>
+                          setCameraBlurRadius(value[0] ?? DEFAULT_BLUR_PX)
+                        }
+                        onValueCommit={(value) =>
+                          saveRecorderPreferences({
+                            cameraBlurRadius: value[0] ?? DEFAULT_BLUR_PX,
+                          })
+                        }
+                        aria-label="Background blur intensity"
+                        className="flex-1"
+                      />
+                    </div>
+                  ) : null}
                 </div>
               ) : null}
 
@@ -870,6 +932,8 @@ export function PreRecordPanel({
                 micDeviceId: micId === "default" ? null : micId,
                 cameraDeviceId:
                   needsCamera && cameraId !== "default" ? cameraId : null,
+                cameraBlur: needsCamera ? cameraBlur : false,
+                cameraBlurRadius,
               })
             }
             className={cn("h-12 gap-2", onCancel ? "flex-1" : "w-full")}

package/corpus/templates/clips/app/components/recorder/recorder-engine.ts

@@ -19,6 +19,10 @@ import {
   createCameraCompositeStream,
   type CameraCompositeHandle,
 } from "@/lib/camera-composite";
+import {
+  createBackgroundBlurStream,
+  type CameraBlurHandle,
+} from "@/lib/camera-blur";
 import {
   chunkUploadUrl,
   pickMimeType,
@@ -75,6 +79,15 @@ export interface RecorderEngineOptions {
   cameraDeviceId?: string | null;
   /** Camera bubble size selected in the pre-record UI. */
   cameraBubbleSize?: "sm" | "md" | "lg";
+  /**
+   * Blur the camera background (sharp person, blurred surroundings) for both the
+   * live preview bubble and the baked-in recording composite. Resolved at
+   * `acquire()` time. Silently no-ops (records un-blurred) if segmentation is
+   * unavailable in the browser.
+   */
+  cameraBlur?: boolean;
+  /** Background blur radius in px when `cameraBlur` is on. Defaults to ~12. */
+  cameraBlurRadius?: number;
   /** Chunk size in ms (MediaRecorder timeslice). Default 2000. */
   chunkIntervalMs?: number;
   /** Base URL for the chunk upload endpoint. Default `/api/uploads/:id/chunk`. */
@@ -99,6 +112,11 @@ export interface RecorderEngineOptions {
    * `onError`, this does NOT transition the engine into the `error` state.
    */
   onWarning?: (message: string) => void;
+  /**
+   * Fired when the camera ends (unplugged / revoked) any time after acquire,
+   * so the UI can drop the on-page camera bubble to match the recorded output.
+   */
+  onCameraEnded?: () => void;
   /**
    * Called when the display stream's video track ends because the user clicked
    * the browser's native "Stop sharing" button. When provided, the engine
@@ -360,6 +378,17 @@ export class RecorderEngine {
 
   private displayStream: MediaStream | null = null;
   private cameraStream: MediaStream | null = null;
+  /**
+   * Raw getUserMedia camera stream. When background blur is active,
+   * `cameraStream` points at the processed (blurred) derivative and this field
+   * keeps the original so teardown stops the real camera tracks and the
+   * disconnect handler can observe the hardware ending.
+   */
+  private rawCameraStream: MediaStream | null = null;
+  private cameraBlur: CameraBlurHandle | null = null;
+  // True once the camera is acquired, through preview/countdown/recording, until
+  // teardown — gates disconnect handling outside the recording state.
+  private cameraLive = false;
   private micStream: MediaStream | null = null;
   private combinedStream: MediaStream | null = null;
   private previewStream: MediaStream | null = null;
@@ -697,13 +726,10 @@ export class RecorderEngine {
         }
       }
 
-      // Camera / mic disconnects mid-recording (USB webcam unplugged, mic
-      // permission revoked, a Bluetooth input dropping) are NON-fatal: the
-      // recording continues with whatever inputs remain, and we surface a
-      // non-blocking warning. We use the same recording/paused guard as the
-      // display handler so the `ended` events fired by `cleanupTracks()` during
-      // a normal stop()/cancel() (state is `stopping`/`idle` by then) are
-      // ignored rather than treated as a disconnect.
+      // Camera / mic disconnects (USB webcam unplugged, permission revoked,
+      // Bluetooth dropped) are NON-fatal: keep whatever inputs remain and warn.
+      // The handlers gate on `cameraLive`/state so the `ended` events fired by
+      // `cleanupTracks()` during a normal stop/cancel are ignored.
       if (this.cameraStream) {
         for (const track of this.cameraStream.getVideoTracks()) {
           track.addEventListener("ended", () => {
@@ -720,6 +746,37 @@ export class RecorderEngine {
         }
       }
 
+      // Camera is live from here through preview/countdown/recording until
+      // teardown — set before the async blur setup so a disconnect during that
+      // window is handled, not inherited as a dead stream.
+      if (this.cameraStream) this.cameraLive = true;
+
+      // Swap the raw camera for its blurred derivative, which both the preview
+      // bubble and the recording composite read ("what you see is what's
+      // recorded"). createBackgroundBlurStream never throws — it falls back to
+      // the raw stream on failure.
+      if (this.opts.cameraBlur && this.cameraStream) {
+        this.rawCameraStream = this.cameraStream;
+        const handle = await createBackgroundBlurStream(this.cameraStream, {
+          blurPx: this.opts.cameraBlurRadius,
+        });
+        if (this.cameraDisconnectNotified) {
+          // Webcam ended while the pipeline was loading: discard it and drop the
+          // dead camera rather than inheriting a frozen processed stream.
+          handle.cleanup();
+          this.cameraStream = null;
+        } else {
+          this.cameraBlur = handle;
+          this.cameraStream = this.cameraBlur.stream;
+        }
+      }
+
+      if (this.opts.mode === "camera" && !this.cameraStream) {
+        throw new Error(
+          "Camera disconnected before recording could start. Reconnect it and try again.",
+        );
+      }
+
       this.previewStream =
         this.opts.mode === "camera" ? this.cameraStream! : this.displayStream!;
 
@@ -1414,6 +1471,12 @@ export class RecorderEngine {
       return combined;
     }
 
+    // Camera dropped before start (disconnected during setup/countdown):
+    // record screen-only rather than compositing a dead stream.
+    if (!this.cameraStream) {
+      return this.buildDisplayRecordingStream();
+    }
+
     // Screen + camera: display capture does not reliably include our separate
     // DOM bubble once the user records another app/window, so the saved
     // recording must composite the camera feed before MediaRecorder sees it.
@@ -1705,14 +1768,23 @@ export class RecorderEngine {
   }
 
   private cleanupTracks(): void {
+    // Clear before stopping tracks so the `ended` events our own stop() fires
+    // aren't mistaken for a disconnect.
+    this.cameraLive = false;
     this.audioMixSources = [];
     this.audioMixCtx?.close().catch(() => {});
     this.audioMixCtx = null;
     this.cameraComposite?.cleanup();
     this.cameraComposite = null;
+    // Tear down the blur pipeline (segmenter, hidden video, processed capture)
+    // before stopping streams. `rawCameraStream` holds the real hardware tracks
+    // when blur is active; stop those so the camera indicator clears.
+    this.cameraBlur?.cleanup();
+    this.cameraBlur = null;
     for (const s of [
       this.displayStream,
       this.cameraStream,
+      this.rawCameraStream,
       this.micStream,
       this.combinedStream,
     ]) {
@@ -1727,6 +1799,7 @@ export class RecorderEngine {
     }
     this.displayStream = null;
     this.cameraStream = null;
+    this.rawCameraStream = null;
     this.micStream = null;
     this.combinedStream = null;
     this.previewStream = null;
@@ -1764,16 +1837,28 @@ export class RecorderEngine {
    * warn the user.
    */
   private onCameraTrackEnded() {
-    if (this.state !== "recording" && this.state !== "paused") return;
+    if (!this.cameraLive) return;
     if (this.cameraDisconnectNotified) return;
     this.cameraDisconnectNotified = true;
-    for (const track of this.cameraStream?.getVideoTracks() ?? []) {
+    this.cameraLive = false;
+    // Tear down the blur pipeline so the composite's camera <video> sees its
+    // (blurred) track end and self-hides, instead of freezing on a stale frame.
+    if (this.cameraBlur) {
+      this.cameraBlur.cleanup();
+      this.cameraBlur = null;
+    }
+    for (const track of [
+      ...(this.rawCameraStream?.getVideoTracks() ?? []),
+      ...(this.cameraStream?.getVideoTracks() ?? []),
+    ]) {
       try {
         track.stop();
       } catch {
         // ignore — the track has already ended.
       }
     }
+    // Drop the on-page bubble to match the recorded output (screen-only now).
+    this.opts.onCameraEnded?.();
     this.emitWarning(
       "Camera disconnected — recording continues without webcam.",
     );