infinicode 2.8.100 → 2.8.102

package/packages/robopark/scheduler/main.py

@@ -5019,6 +5019,53 @@ async def delete_character_preset(preset_id: str):
     return {"ok": True}
 
 
+class PresetPosition(BaseModel):
+    id: str
+    nx: float
+    ny: float
+
+
+class PresetPositionBatch(BaseModel):
+    positions: List[PresetPosition]
+
+
+@app.put("/api/character-presets/positions")
+async def update_preset_positions(payload: PresetPositionBatch):
+    """Batch-update (id, nx, ny) for the Park map. nx/ny are the
+    normalized [0,1] pad coordinates the dashboard uses to place each
+    robot on the iso park. Bounded + persisted so an operator can
+    Ctrl+drag a robot on the Park map and have its position survive
+    a refresh, server restart, or robot reconnect.
+
+    Designed for small, infrequent updates (a single drag releases
+    one robot, plus an occasional "reset all" tool). The endpoint
+    intentionally ignores all other preset fields — only the
+    coordinates move; voice stack, name, system prompt, etc. are
+    owned by the character-preset editor and are not touched here.
+    """
+    if not payload.positions:
+        return {"updated": 0}
+    now = datetime.utcnow().isoformat()
+    updated = 0
+    async with aiosqlite.connect(DB_PATH) as db:
+        for p in payload.positions:
+            if not p.id:
+                continue
+            # Clamp nx/ny to the visible pad rectangle so a stray
+            # drag can't park a robot off the island. A small inner
+            # margin (0.04) keeps the avatar fully on the grass and
+            # clear of the gold wall on the perimeter.
+            nx = max(0.04, min(0.96, float(p.nx)))
+            ny = max(0.04, min(0.96, float(p.ny)))
+            cur = await db.execute(
+                "UPDATE character_presets SET nx = ?, ny = ?, updated_at = ? WHERE id = ?",
+                (nx, ny, now, p.id),
+            )
+            updated += cur.rowcount or 0
+        await db.commit()
+    return {"updated": updated}
+
+
 class RobotVoiceConfigUpdate(BaseModel):
     character_preset_id: Optional[str] = None
     voice_stack_id: Optional[str] = None

package/packages/robopark/scheduler/preview_agent.py

@@ -541,12 +541,17 @@ class PreviewAgent:
         self.vision_trigger_cooldown = float(cfg.get("vision_trigger_cooldown", os.getenv("VISION_TRIGGER_COOLDOWN", DEFAULT_VISION_TRIGGER_COOLDOWN)))
         self.vision_session_seconds = float(cfg.get("vision_session_seconds", os.getenv("VISION_SESSION_SECONDS", DEFAULT_VISION_SESSION_SECONDS)))
         self.vision_silence_timeout = float(cfg.get("vision_silence_timeout", os.getenv("VISION_SILENCE_TIMEOUT", DEFAULT_VISION_SILENCE_TIMEOUT)))
-        self.local_camera_motion = str(
+        self.local_camera_motion = str(
             # Production needs an always-on detector. The preview publisher
             # remains the single camera owner when a session starts, so this
             # does not require the separate OpenCV vision server.
             cfg.get("local_camera_motion", os.getenv("LOCAL_CAMERA_MOTION", "true"))
-        ).lower() in ("1", "true", "yes", "on")
+        ).lower() in ("1", "true", "yes", "on")
+        # The character greeting is the production acknowledgement. A local
+        # motion beep serializes on the same ALSA output and delays allocation.
+        self.motion_cue_enabled = str(
+            cfg.get("motion_cue_enabled", os.getenv("ROBOPARK_MOTION_CUE", "false"))
+        ).lower() in ("1", "true", "yes", "on")
 
         self._shutdown = asyncio.Event()
         self._task: Optional[asyncio.Task] = None
@@ -1178,20 +1183,19 @@ class PreviewAgent:
             logger.warning("vision motion event received but not enrolled yet — ignoring")
             return
         self._vision_trigger_in_flight = True
-        await self._report_pipeline("motion_detected", "ok", f"Motion received from {payload.get('source', 'camera')}", once=False)
+        # Observability must not add a scheduler round trip before the actual
+        # session request. The reporter handles and logs its own errors.
+        asyncio.create_task(self._report_pipeline(
+            "motion_detected", "ok",
+            f"Motion received from {payload.get('source', 'camera')}", once=False,
+        ))
         logger.info("motion detected by RoboVisionAI_PI — requesting a session")
-        # The cue is feedback only; never block session allocation on speaker
-        await self._stop_motion_capture()
-        # DirectShow can return a stale handle for a short interval after
-        # release. Give the driver time to finish teardown before reopening it
-        # for the LiveKit publisher.
-        await asyncio.sleep(0.5)
-        # I/O. Camera/mic join and the preset greeting are the critical path.
-        # The cue and TTS share one physical ALSA output. Finish and release
-        # the cue before LiveKit can deliver the greeting; background playback
-        # races aplay and makes greeting delivery intermittently fail busy.
-        async with self._speaker_operation_lock:
-            await asyncio.to_thread(_play_audio_effect, self.audio_playback_device, "motion")
+        # RoboVision owns the physical camera and exposes a shared stream, so
+        # there is no capture handle to tear down and no reason to sleep here.
+        if self.motion_cue_enabled:
+            logger.warning("ROBOPARK_MOTION_CUE is enabled; the diagnostic cue adds greeting latency")
+            async with self._speaker_operation_lock:
+                await asyncio.to_thread(_play_audio_effect, self.audio_playback_device, "motion")
         try:
             r = await self._session.post(
                 f"{self.scheduler_url.rstrip('/')}/api/devices/{self.device_id}/request-session",
@@ -1294,9 +1298,25 @@ class LiveKitPublisher:
         )
         self._speaker_playback_active = threading.Event()
         self._speaker_gate_until = 0.0
+        self._speaker_started_at = 0.0
+        self._barge_in_until = 0.0
+        self._echo_mic_floor = 0.0
+        self._barge_in_candidate_frames = 0
         self._speaker_echo_tail = max(
             0.1, min(float(os.getenv("ROBOPARK_ECHO_TAIL_MS", "700")) / 1000.0, 2.0)
         )
+        self._adaptive_barge_in = str(
+            os.getenv("ROBOPARK_ADAPTIVE_BARGE_IN", "true")
+        ).lower() in ("1", "true", "yes", "on")
+        self._barge_in_min_peak = max(
+            256, min(int(os.getenv("ROBOPARK_BARGE_IN_MIN_PEAK", "2200")), 20000)
+        )
+        self._barge_in_ratio = max(
+            1.25, min(float(os.getenv("ROBOPARK_BARGE_IN_ECHO_RATIO", "2.4")), 8.0)
+        )
+        self._barge_in_hold = max(
+            0.4, min(float(os.getenv("ROBOPARK_BARGE_IN_HOLD_MS", "1400")) / 1000.0, 3.0)
+        )
         # Motion sampling state belongs to the publisher instance.  Keeping it
         # initialized here prevents shutdown/reopen paths from raising while
         # the camera is being handed between preview and voice sessions.
@@ -1553,6 +1573,10 @@ class LiveKitPublisher:
         def _open_echo_gate() -> None:
             if not self._half_duplex:
                 return
+            if not self._speaker_playback_active.is_set():
+                self._speaker_started_at = time.monotonic()
+                self._echo_mic_floor = 0.0
+                self._barge_in_candidate_frames = 0
             self._speaker_playback_active.set()
             self._speaker_gate_until = time.monotonic() + self._speaker_echo_tail
 
@@ -1841,11 +1865,40 @@ class LiveKitPublisher:
                 _pub_start = time.monotonic()
                 for off in range(0, len(data) - bytes_per_frame + 1, bytes_per_frame):
                     chunk = data[off:off + bytes_per_frame]
+                    now = time.monotonic()
                     echo_gate_active = self._half_duplex and (
                         self._speaker_playback_active.is_set()
-                        or time.monotonic() < self._speaker_gate_until
+                        or now < self._speaker_gate_until
                     )
-                    if echo_gate_active:
+                    # Learn the microphone's speaker-echo floor while output is
+                    # active. A nearby visitor speaking produces a fast peak well
+                    # above that floor; reopen the mic briefly so LiveKit VAD can
+                    # cancel normal TTS. The initial 300 ms remains protected.
+                    _, raw_peak = _pcm16_scale_and_peak(chunk, 1.0)
+                    if echo_gate_active and self._adaptive_barge_in:
+                        if self._echo_mic_floor <= 0:
+                            self._echo_mic_floor = float(raw_peak)
+                        else:
+                            self._echo_mic_floor = self._echo_mic_floor * 0.92 + raw_peak * 0.08
+                        threshold = max(
+                            self._barge_in_min_peak,
+                            int(self._echo_mic_floor * self._barge_in_ratio),
+                        )
+                        warmed = now - self._speaker_started_at >= 0.3
+                        if warmed and raw_peak >= threshold:
+                            self._barge_in_candidate_frames += 1
+                        else:
+                            self._barge_in_candidate_frames = 0
+                        if self._barge_in_candidate_frames >= 3:
+                            if now >= self._barge_in_until:
+                                logger.info(
+                                    "audio_loop: adaptive barge-in opened mic "
+                                    "(peak=%d threshold=%d echo_floor=%d)",
+                                    raw_peak, threshold, int(self._echo_mic_floor),
+                                )
+                            self._barge_in_until = now + self._barge_in_hold
+                    barge_in_active = self._adaptive_barge_in and now < self._barge_in_until
+                    if echo_gate_active and not barge_in_active:
                         # Preserve 20 ms frame cadence; only suppress content.
                         # Stopping publication would create gaps and destabilize
                         # VAD/endpointing when listening resumes.