infinicode 2.8.91 → 2.8.92

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.91",
+  "version": "2.8.92",
   "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

@@ -1257,17 +1257,14 @@ class LiveKitPublisher:
         # — until it finished, so a short "Hello friend!" greeting could be
         # over and gone before we ever got a chance to subscribe to it.
         if audio_enabled:
-            self._tasks.append(asyncio.create_task(self._audio_loop()))
+            self._tasks.append(asyncio.create_task(self._audio_retry_loop()))
             try:
                 await asyncio.wait_for(self._mic_streaming.wait(), timeout=5.0)
-                await self.agent._report_pipeline(
-                    "microphone_published", "ok", "Microphone track published with live PCM frames"
-                )
             except asyncio.TimeoutError:
                 await self.agent._report_pipeline(
                     "microphone_published", "blocked", "Microphone track published but PCM capture did not start"
                 )
-                raise RuntimeError(f"microphone capture did not start for {self.agent.audio_capture_device}")
+                logger.warning("microphone PCM is not ready; keeping the session alive while capture retries")
 
         if self._capture and self.video_source:
             self._tasks.append(asyncio.create_task(self._video_loop()))
@@ -1596,7 +1593,29 @@ class LiveKitPublisher:
         except Exception as e:
             logger.debug(f"preview motion sampling failed: {e}")
 
-    async def _audio_loop(self) -> None:
+    async def _audio_retry_loop(self) -> None:
+        """Keep microphone capture alive across transient ALSA ownership errors."""
+        while not self._stop_event.is_set():
+            try:
+                await self._audio_loop()
+            except asyncio.CancelledError:
+                raise
+            except Exception as e:
+                logger.warning(
+                    f"audio_loop: capture failed on {self.agent.audio_capture_device}: {e}; retrying"
+                )
+            finally:
+                mic = self._mic_capture
+                self._mic_capture = None
+                if mic is not None:
+                    await asyncio.to_thread(mic.stop)
+            if not self._stop_event.is_set():
+                try:
+                    await asyncio.wait_for(self._stop_event.wait(), timeout=1.0)
+                except asyncio.TimeoutError:
+                    pass
+
+    async def _audio_loop(self) -> None:
         assert self.audio_source is not None
         mic = create_audio_capture(self.agent.audio_capture_device)
         if mic is None:
@@ -1642,7 +1661,12 @@ class LiveKitPublisher:
                         data=chunk, sample_rate=48000, num_channels=1, samples_per_channel=samples_per_frame,
                     )
                     await self.audio_source.capture_frame(frame)
-                    self._mic_streaming.set()
+                    if not self._mic_streaming.is_set():
+                        self._mic_streaming.set()
+                        await self.agent._report_pipeline(
+                            "microphone_published", "ok",
+                            "Microphone track published with live PCM frames",
+                        )
                     p = audioop.max(chunk, 2)
                     _diag_peak = max(_diag_peak, p)
                     _diag_count += 1
@@ -1852,7 +1876,7 @@ class AlsaAudioCapture(AudioCapture):
                 "-f", "S16_LE", "-r", "48000", "-c", "1",
             ],
             stdout=subprocess.PIPE,
-            stderr=subprocess.DEVNULL,
+            stderr=subprocess.PIPE,
         )
         if self.process.stdout is None:
             raise RuntimeError("arecord did not provide a PCM stream")
@@ -1865,7 +1889,10 @@ class AlsaAudioCapture(AudioCapture):
         while len(self.buffer) < bytes_needed:
             chunk = self.process.stdout.read(bytes_needed - len(self.buffer))
             if not chunk:
-                raise OSError(f"ALSA capture stopped on {self.alsa_device}")
+                detail = ""
+                if self.process.stderr is not None:
+                    detail = self.process.stderr.read().decode("utf-8", errors="replace").strip()
+                raise OSError(f"ALSA capture stopped on {self.alsa_device}: {detail or 'no PCM data'}")
             self.buffer.extend(chunk)
         data = bytes(self.buffer[:bytes_needed])
         del self.buffer[:bytes_needed]
@@ -1883,6 +1910,7 @@ class AlsaAudioCapture(AudioCapture):
                 self.process.wait(timeout=2)
             except Exception:
                 self.process.kill()
+                self.process.wait(timeout=1)
 
 
 class PyAudioCapture(AudioCapture):