infinicode 2.8.83 → 2.8.84

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.83",
+  "version": "2.8.84",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",

package/packages/robopark/scheduler/preview_agent.py

@@ -397,6 +397,10 @@ class PreviewAgent:
         # use the resolved hardware name reported in that same inventory.
         self.audio_capture_device = self.audio_device
         self.audio_output_device = cfg.get("audio_output_device", os.getenv("AUDIO_OUTPUT_DEVICE", "default"))
+        # Keep RoboVision/sounddevice inventory IDs out of PyAudio. Both APIs
+        # number the same ALSA cards differently, so resolve the selected ID
+        # to its hardware name before opening any playback stream.
+        self.audio_playback_device = self.audio_output_device
         self.robovision_url = cfg.get("robovision_url", os.getenv("ROBOVISION_URL", "http://127.0.0.1:5000"))
         self.use_robovision_camera = bool(cfg.get("use_robovision_camera", False))
         self.width = int(cfg.get("video_width", os.getenv("VIDEO_WIDTH", DEFAULT_VIDEO_WIDTH)))
@@ -689,6 +693,16 @@ class PreviewAgent:
             if data.get("audio_output_device") is not None:
                 changed = changed or self.audio_output_device != data["audio_output_device"]
                 self.audio_output_device = data["audio_output_device"]
+                inventory = data.get("device_inventory") or {}
+                selected = str(self.audio_output_device)
+                self.audio_playback_device = next(
+                    (
+                        str(item.get("name"))
+                        for item in inventory.get("audio_output", [])
+                        if str(item.get("id")) == selected and item.get("name")
+                    ),
+                    self.audio_output_device,
+                )
             if changed:
                 await self._sync_robovision_media_config()
         except Exception as e:
@@ -812,7 +826,7 @@ class PreviewAgent:
         self._vision_last_activity = 0.0
         self._remote_session_ended = False
         await self._stop_publisher()
-        await asyncio.to_thread(_play_audio_effect, self.audio_output_device, "disconnect")
+        await asyncio.to_thread(_play_audio_effect, self.audio_playback_device, "disconnect")
         self._current_state = PreviewState()
 
     async def _heartbeat_loop(self) -> None:
@@ -865,7 +879,7 @@ class PreviewAgent:
             restore_state = self._current_state if self._publisher else None
             if restore_state:
                 await self._stop_publisher()
-                await asyncio.sleep(0.35)
+                await asyncio.sleep(1.0)
             try:
                 result = await asyncio.to_thread(_speaker_roundtrip_test, request.get("params") or {})
                 result["media_owner_paused"] = bool(restore_state)
@@ -1028,7 +1042,7 @@ class PreviewAgent:
         await asyncio.sleep(0.5)
         # I/O. Camera/mic join and the preset greeting are the critical path.
         asyncio.create_task(
-            asyncio.to_thread(_play_audio_effect, self.audio_output_device, "motion")
+            asyncio.to_thread(_play_audio_effect, self.audio_playback_device, "motion")
         )
         try:
             r = await self._session.post(
@@ -1234,7 +1248,7 @@ class LiveKitPublisher:
         # never actually reaching the real speakers. Prefer WASAPI's default output,
         # which is what Windows' own volume mixer/meter is backed by.
         output_device_index = None
-        selected_output = str(self.agent.audio_output_device or "default")
+        selected_output = str(self.agent.audio_playback_device or "default")
         if selected_output.strip().isdigit():
             output_device_index = int(selected_output.strip())
         try:

package/packages/robopark/scheduler/robot_supervisor.py

@@ -578,6 +578,49 @@ def _open_pcm_stream(pa, pyaudio_module, kind: str, device_index: Optional[int],
     )
 
 
+def _linux_aplay_pcm16(raw: bytes, selected_output: str, sample_rate: int,
+                       channels: int = 1) -> tuple[bool, str]:
+    """Play PCM through the same ALSA plughw path proven during Pi setup.
+
+    PortAudio and RoboVision enumerate devices in different index spaces. The
+    inventory name contains the stable ALSA hw tuple, so use it directly and
+    let ALSA's plug layer adapt the cached TTS sample rate/channel count.
+    """
+    import re
+
+    match = re.search(r"hw:(\d+),(\d+)", str(selected_output), re.IGNORECASE)
+    if not match:
+        return False, "selected output has no ALSA hw address"
+    alsa_device = f"plughw:{match.group(1)},{match.group(2)}"
+    command = [
+        "aplay", "-q", "-D", alsa_device, "-t", "raw", "-f", "S16_LE",
+        "-r", str(sample_rate), "-c", str(channels),
+    ]
+    last_error = "aplay failed"
+    # ALSA can retain an exclusive USB handle briefly after the LiveKit
+    # playback stream closes. Retry for a bounded period instead of declaring
+    # a valid device unsupported on the first EBUSY response.
+    for attempt in range(5):
+        if attempt:
+            time.sleep(0.5)
+        try:
+            completed = subprocess.run(
+                command,
+                input=raw,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.PIPE,
+                timeout=max(5.0, len(raw) / max(1, sample_rate * channels * 2) + 3.0),
+                check=False,
+            )
+        except Exception as exc:
+            last_error = f"{type(exc).__name__}: {exc}"
+            continue
+        if completed.returncode == 0:
+            return True, alsa_device
+        last_error = completed.stderr.decode("utf-8", errors="replace").strip() or f"aplay exited {completed.returncode}"
+    return False, f"{alsa_device}: {last_error}"
+
+
 def _speaker_roundtrip_test(params: dict) -> dict:
     """Play a test tone + record the mic simultaneously; return metrics.
 
@@ -618,10 +661,46 @@ def _speaker_roundtrip_test(params: dict) -> dict:
         if dur > 10.0:
             return {"ok": False, "error": "cached TTS audio exceeds the 10 second test limit"}
     n_samples = int(source_rate * dur)
-    if n_samples < 480:
-        return {"ok": False, "error": "duration too short"}
-
-    pa = pyaudio.PyAudio()
+    if n_samples < 480:
+        return {"ok": False, "error": "duration too short"}
+
+    # Cached character voice is output-only. On Linux, bypass PortAudio's
+    # unrelated index space and use the exact ALSA plughw endpoint selected by
+    # RoboVision. This is the same path used by the successful onsite test.
+    if playback_only and mono_pcm is not None and sys.platform.startswith("linux"):
+        t0 = time.monotonic()
+        played, detail = _linux_aplay_pcm16(mono_pcm, str(out_name), source_rate)
+        duration_ms = int((time.monotonic() - t0) * 1000)
+        if not played:
+            return {
+                "ok": False,
+                "error": f"ALSA playback failed: {detail}",
+                "duration_ms": duration_ms,
+                "output_device": str(out_name),
+                "input_device": "not opened (speaker-only test)",
+                "duration": dur,
+            }
+        return {
+            "ok": True,
+            "pass": True,
+            "played": True,
+            "playback_only": True,
+            "mode": mode,
+            "text": params.get("text"),
+            "cache_hit": bool(params.get("cache_hit")),
+            "tts_provider": params.get("tts_provider"),
+            "tts_voice": params.get("tts_voice"),
+            "duration": dur,
+            "duration_ms": duration_ms,
+            "sample_rate": source_rate,
+            "output_sample_rate": source_rate,
+            "output_channels": 1,
+            "output_device": detail,
+            "input_device": "not opened (speaker-only test)",
+            "diagnostic": "cached voice played through the selected ALSA plughw endpoint",
+        }
+
+    pa = pyaudio.PyAudio()
     out_idx = _resolve_audio_device(pa, out_name, "output")
     in_idx = None if playback_only else _resolve_audio_device(pa, in_name, "input")
     def _dev_name(idx):