infinicode 2.8.99 → 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",
@@ -1284,6 +1288,35 @@ class LiveKitPublisher:
         self._mic_capture: Optional["AudioCapture"] = None
         self._mic_streaming = asyncio.Event()
         self._mic_error: Optional[str] = None
+        # The launch hardware has no acoustic echo cancellation. Publishing
+        # the amplified USB microphone while the robot speaker plays TTS makes
+        # the voice worker hear itself and trigger barge-in, truncating or
+        # chopping its own response. Keep the track alive with silence while
+        # playback is active, plus a short room-echo decay tail.
+        self._half_duplex = str(os.getenv("ROBOPARK_HALF_DUPLEX", "true")).lower() in (
+            "1", "true", "yes", "on",
+        )
+        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.
@@ -1524,12 +1557,45 @@ class LiveKitPublisher:
         stream_failed = threading.Event()
         playback_reported = threading.Event()
         event_loop = asyncio.get_running_loop()
+        echo_gate_peak = max(16, min(int(os.getenv("ROBOPARK_ECHO_GATE_PEAK", "96")), 4096))
+
+        def _outbound_peak(chunk: bytes) -> int:
+            if len(chunk) < 2:
+                return 0
+            try:
+                samples = memoryview(chunk).cast("h")
+                # Stereo duplication means sampling every eighth value is
+                # sufficient and keeps the writer thread lightweight.
+                return max((abs(int(value)) for value in samples[::8]), default=0)
+            except (TypeError, ValueError):
+                return 0
+
+        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
+
+        def _extend_echo_gate() -> None:
+            if self._half_duplex:
+                self._speaker_gate_until = time.monotonic() + self._speaker_echo_tail
 
-        def _safe_write(chunk: bytes) -> bool:
-            if stream_failed.is_set():
-                return False
+        def _safe_write(chunk: bytes) -> bool:
+            if stream_failed.is_set():
+                return False
             try:
+                audible = _outbound_peak(chunk) >= echo_gate_peak
+                if audible:
+                    _open_echo_gate()
+                elif time.monotonic() >= self._speaker_gate_until:
+                    self._speaker_playback_active.clear()
                 out.write(chunk)
+                if audible:
+                    _extend_echo_gate()
                 if not playback_reported.is_set():
                     playback_reported.set()
                     asyncio.run_coroutine_threadsafe(
@@ -1661,6 +1727,9 @@ class LiveKitPublisher:
                 pa.terminate()
             if speaker_guard is not None:
                 speaker_guard.release()
+            if self._half_duplex:
+                self._speaker_gate_until = time.monotonic() + self._speaker_echo_tail
+                self._speaker_playback_active.clear()
 
     async def stop(self) -> None:
         self._stop_event.set()
@@ -1783,8 +1852,9 @@ class LiveKitPublisher:
         _diag_count = 0
         _diag_last_log = time.monotonic()
         _diag_read_ms = 0.0
-        _diag_publish_ms = 0.0
-        batch_interval = BATCH_MS / 1000
+        _diag_publish_ms = 0.0
+        _echo_gate_was_active = False
+        batch_interval = BATCH_MS / 1000
         while not self._stop_event.is_set():
             _iter_start = time.monotonic()
             _t0 = time.monotonic()
@@ -1792,10 +1862,56 @@ class LiveKitPublisher:
             _t1 = time.monotonic()
             if batch is not None:
                 data = bytes(batch.data)
-                _pub_start = time.monotonic()
-                for off in range(0, len(data) - bytes_per_frame + 1, bytes_per_frame):
+                _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]
-                    chunk, p = _pcm16_scale_and_peak(chunk, mic_gain)
+                    now = time.monotonic()
+                    echo_gate_active = self._half_duplex and (
+                        self._speaker_playback_active.is_set()
+                        or now < self._speaker_gate_until
+                    )
+                    # 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.
+                        chunk = b"\x00" * len(chunk)
+                        p = 0
+                    else:
+                        chunk, p = _pcm16_scale_and_peak(chunk, mic_gain)
+                    if echo_gate_active != _echo_gate_was_active:
+                        logger.info(
+                            "audio_loop: speaker echo gate %s",
+                            "active" if echo_gate_active else "released",
+                        )
+                        _echo_gate_was_active = echo_gate_active
                     frame = self.rtc.AudioFrame(
                         data=chunk, sample_rate=48000, num_channels=1, samples_per_channel=samples_per_frame,
                     )