cecli-dev 1.5.0rc5__tar.gz → 1.5.0rc8__tar.gz

{cecli_dev-1.5.0rc5 → cecli_dev-1.5.0rc8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.5.0rc5
+Version: 1.5.0rc8
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.5.0rc5 → cecli_dev-1.5.0rc8}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.0rc5'
-__version_tuple__ = version_tuple = (1, 5, 0, 'rc5')
+__version__ = version = '1.5.0rc8'
+__version_tuple__ = version_tuple = (1, 5, 0, 'rc8')
 
-__commit_id__ = commit_id = 'g9fb17f68d'
+__commit_id__ = commit_id = 'g82e5aa577'

{cecli_dev-1.5.0rc5 → cecli_dev-1.5.0rc8}/cecli/coders/base_coder.py

@@ -4507,18 +4507,15 @@ class Coder(metaclass=UsageMeta):
             completion_tokens = (
                 nested.getter(usage, ["completion_tokens", "output_tokens", "eval_count"], 0) or 0
             )
-            cache_hit_tokens = (
-                nested.getter(
-                    usage,
-                    [
-                        "prompt_cache_hit_tokens",
-                        "cache_read_input_tokens",
-                        "input_tokens_details.cached_tokens",
-                        "prompt_tokens_details.cached_tokens",
-                    ],
-                    0,
-                )
-                or 0
+            cache_hit_tokens = _first_usage_tokens(
+                usage,
+                [
+                    "prompt_cache_hit_tokens",
+                    "cache_read_input_tokens",
+                    "input_tokens_details.cached_tokens",
+                    "prompt_tokens_details.cached_tokens",
+                ],
+                0,
             )
             cache_write_tokens = nested.getter(usage, "cache_creation_input_tokens", 0) or 0
             self.message_cached_tokens += cache_hit_tokens
@@ -4636,18 +4633,15 @@ class Coder(metaclass=UsageMeta):
             completion_tokens = (
                 nested.getter(usage, ["completion_tokens", "output_tokens", "eval_count"], 0) or 0
             )
-            cache_hit_tokens = (
-                nested.getter(
-                    usage,
-                    [
-                        "prompt_cache_hit_tokens",
-                        "cache_read_input_tokens",
-                        "input_tokens_details.cached_tokens",
-                        "prompt_tokens_details.cached_tokens",
-                    ],
-                    0,
-                )
-                or 0
+            cache_hit_tokens = _first_usage_tokens(
+                usage,
+                [
+                    "prompt_cache_hit_tokens",
+                    "cache_read_input_tokens",
+                    "input_tokens_details.cached_tokens",
+                    "prompt_tokens_details.cached_tokens",
+                ],
+                0,
             )
             cache_write_tokens = nested.getter(usage, "cache_creation_input_tokens", 0) or 0
         elif active_model is not None:
@@ -5346,8 +5340,21 @@ def _function_call_to_dict(function_call):
     """Normalize a function call (dict or litellm-shaped Function) to a dict."""
     if isinstance(function_call, dict):
         return function_call
-
     if hasattr(function_call, "to_dict"):
         return function_call.to_dict()
-
     return function_call
+
+
+def _first_usage_tokens(usage: object, paths: list[str], default: int = 0) -> int:
+    """Return the first non-None token count among ``paths``.
+
+    ``nested.getter`` stops at the first attribute that exists even when its value
+    is None. Anthropic/copilot ``Usage`` always declares ``prompt_cache_hit_tokens``
+    (None) and populates ``cache_read_input_tokens``, so looking only at the first
+    field would report zero cache hits despite the server serving the cached prefix.
+    """
+    for path in paths:
+        value = nested.getter(usage, path, None)
+        if value is not None:
+            return value
+    return default

{cecli_dev-1.5.0rc5 → cecli_dev-1.5.0rc8}/cecli/voice.py

@@ -46,6 +46,24 @@ _STREAMING_LANGUAGES = frozenset(("ar", "de", "es", "en", "ja", "tl", "vi", "zh"
 # Sentinel placed on the cross-process text queue once streaming is finished.
 _STREAM_END = "\0__MOONSHINE_STREAM_END__"
 
+# Hugging Face mirror for Moonshine's native ONNX runtime models.
+_HF_REPO_ID = "moonshine-ai/moonshine-voice-assets"
+_HF_MODELS = {
+    "en": {
+        "path": "model/small-streaming-en/quantized_26_08_21",
+        "files": (
+            "adapter.ort",
+            "cross_kv.ort",
+            "decoder_kv.ort",
+            "encoder.ort",
+            "frontend.model.ort",
+            "frontend.weights.ort",
+            "streaming_config.json",
+            "tokenizer.bin",
+        ),
+    },
+}
+
 
 class SoundDeviceError(Exception):
     """Raised when the audio recording stack cannot be initialized."""
@@ -250,9 +268,8 @@ def _run_record_process(
             temp_path = tmp_file.name
 
         try:
-            with sd.InputStream(
-                samplerate=sample_rate, channels=1, callback=callback, device=device_id
-            ):
+            stream = _open_input_stream(callback, sample_rate, device_id)
+            with stream:
                 _status(status_queue, f"\n⬤ recording: {stop_binding or 'Enter'} to stop")
                 _wait_for_stop(stop_queue)
 
@@ -278,7 +295,7 @@ def _run_record_process(
 
             # On-device transcription.
             _status(status_queue, "\n⬤ Transcribing")
-            return _transcribe_local(temp_path, language)
+            return _transcribe_local(temp_path, language, status_queue)
         finally:
             # Manual cleanup since delete=False was used.
             if os.path.exists(temp_path):
@@ -311,10 +328,9 @@ def _record_and_stream(
     """
     import threading
 
-    import sounddevice as sd
     from moonshine_voice.transcriber import LineCompleted, LineStarted, LineTextChanged
 
-    transcriber = _build_transcriber(language)
+    transcriber = _build_transcriber(language, status_queue)
     completed_lines = []
     current_line = ""
     last_pushed = ""
@@ -379,9 +395,8 @@ def _record_and_stream(
         feed_thread.start()
 
         try:
-            with sd.InputStream(
-                samplerate=sample_rate, channels=1, callback=callback, device=device_id
-            ):
+            stream = _open_input_stream(callback, sample_rate, device_id)
+            with stream:
                 _status(status_queue, f"\n⬤ recording: {stop_binding or 'Enter'} to stop")
                 _wait_for_stop(stop_queue)
         finally:
@@ -401,7 +416,7 @@ def _record_and_stream(
         transcriber.close()
 
 
-def _transcribe_local(wav_path, language="en"):
+def _transcribe_local(wav_path, language="en", status_queue=None):
     """Transcribe a mono WAV on-device using Moonshine.
 
     Downloads and caches the model via ``moonshine_voice`` on first use. The
@@ -410,7 +425,7 @@ def _transcribe_local(wav_path, language="en"):
     from moonshine_voice.utils import load_wav_file
 
     audio_data, sample_rate = load_wav_file(wav_path)
-    transcriber = _build_transcriber(language)
+    transcriber = _build_transcriber(language, status_queue)
 
     try:
         transcript = transcriber.transcribe_without_streaming(audio_data, sample_rate=sample_rate)
@@ -420,19 +435,12 @@ def _transcribe_local(wav_path, language="en"):
     return _join_transcript(transcript)
 
 
-def _build_transcriber(language):
-    from moonshine_voice import Transcriber, get_model_for_language
+def _build_transcriber(language, status_queue=None):
+    from moonshine_voice import Transcriber
 
     language = language or "en"
-
-    model_root, model_arch = get_model_for_language(
-        language,
-        _model_arch_for_language(language),
-        # Moonshine draws tqdm bars to stderr unless a progress callback is
-        # supplied; give it a no-op so the bars don't scribble into the TUI's
-        # captured stderr stream.
-        on_progress=_silent_progress,
-    )
+    model_arch = _model_arch_for_language(language)
+    model_root = _model_root_for_language(language, model_arch, status_queue)
 
     options = None
 
@@ -446,6 +454,31 @@ def _build_transcriber(language):
     )
 
 
+def _model_root_for_language(language, model_arch, status_queue=None):
+    """Return the local model root, preferring the Hugging Face mirror.
+
+    ``en`` is fetched from Hugging Face so corporate networks that block
+    Moonshine's CDN can still download it, falling back to Moonshine's CDN-backed
+    loader when the mirror is unreachable. Other languages use the CDN loader.
+    """
+    from moonshine_voice import get_model_for_language
+
+    if language in _HF_MODELS:
+        try:
+            return _download_model_from_hf(language, status_queue)
+        except Exception:
+            # The Hugging Face mirror is unreachable; fall back to the CDN.
+            pass
+
+    root, _ = get_model_for_language(
+        language,
+        model_arch,
+        on_progress=_download_progress(status_queue),
+    )
+
+    return root
+
+
 def _model_arch_for_language(language):
     from moonshine_voice import ModelArch
 
@@ -523,9 +556,166 @@ def _status(status_queue, message):
         print(message)
 
 
-def _silent_progress(fraction, file):
-    """No-op progress callback used to silence Moonshine's tqdm download bar."""
-    pass
+def _open_input_stream(callback, sample_rate, device_id=None):
+    """Open and start an input stream, falling back to other input devices.
+
+    Tries the requested/default device first, then other input-capable devices
+    at compatible sample rates, so a WSL/PipeWire setup whose default device
+    cannot be opened (or fails to start, e.g. a ``paTimedOut``) still records.
+    The stream is started here so a start timeout is caught and the next
+    candidate is tried rather than surfacing to the caller after a device is
+    selected. Returns the started ``sounddevice.InputStream``; callers should
+    use it as a context manager (``with stream:``). Raises ``SoundDeviceError``
+    with an actionable message when no device opens or starts.
+    """
+    import sounddevice as sd
+
+    last_error = None
+
+    for dev, rate in _input_device_candidates(sample_rate, device_id):
+        stream = None
+
+        try:
+            stream = sd.InputStream(samplerate=rate, channels=1, callback=callback, device=dev)
+            stream.start()
+        except Exception as exc:
+            last_error = exc
+
+            if stream is not None:
+                try:
+                    stream.close()
+                except Exception:
+                    pass
+
+            continue
+
+        return stream
+
+    raise SoundDeviceError(_input_device_error_message(last_error))
+
+
+def _input_device_candidates(sample_rate, device_id):
+    """Yield (device, sample_rate) candidates for the input stream, best first."""
+    import sounddevice as sd
+
+    for rate in _sample_rates(sample_rate):
+        yield (device_id, rate)
+
+    try:
+        devices = sd.query_devices()
+    except Exception:
+        return
+
+    if not isinstance(devices, list):
+        return
+
+    for dev, entry in enumerate(devices):
+        if not isinstance(entry, dict) or entry.get("max_input_channels", 0) <= 0:
+            continue
+
+        if dev == device_id:
+            continue
+
+        for rate in _sample_rates(entry.get("default_samplerate") or sample_rate):
+            yield (dev, rate)
+
+
+def _sample_rates(sample_rate):
+    """Return sample rates to try for a device, preferred first and deduplicated."""
+    rates = []
+
+    for rate in (sample_rate, 44100, 48000, 16000):
+        if rate and rate not in rates:
+            rates.append(rate)
+
+    return rates
+
+
+def _input_device_error_message(err):
+    """Return an actionable message when no microphone input device can be opened."""
+    reason = f" ({err})" if err else ""
+
+    return (
+        "No microphone input device could be opened"
+        + reason
+        + ". Check that your mic is the default input device (Windows: Settings > "
+        "System > Sound > Input) and that Windows grants WSLg microphone access "
+        "(Settings > Privacy & security > Microphone). In WSL, confirm the mic is "
+        "bridged first, e.g. `PULSE_SERVER=unix:/mnt/wslg/PulseServer parec -d RDPSource --channels=1`."
+    )
+
+
+def _download_model_from_hf(language, status_queue=None):
+    """Download the native Moonshine model for ``language`` from Hugging Face.
+
+    Fetches the exact file set the native ``Transcriber`` expects (mirrored in
+    Moonshine's Hugging Face repo) into the Moonshine cache, so a network
+    that blocks ``download.moonshine.ai`` can still load ``en``. Returns
+    the local model root directory.
+    """
+    from pathlib import Path
+
+    import requests
+    from moonshine_voice.download_file import get_cache_dir
+
+    info = _HF_MODELS[language]
+    cache_dir = Path(get_cache_dir())
+
+    # Reuse a model already cached via Moonshine's CDN loader so users on
+    # networks where both endpoints are reachable do not re-download it from
+    # Hugging Face. The CDN cache mirrors the same ``path`` layout.
+    cdn_root = cache_dir / "download.moonshine.ai" / info["path"]
+
+    if all((cdn_root / name).exists() for name in info["files"]):
+        return str(cdn_root)
+
+    model_root = cache_dir / "huggingface" / info["path"]
+    model_root.mkdir(parents=True, exist_ok=True)
+
+    names = [name for name in info["files"] if not (model_root / name).exists()]
+
+    if names:
+        _status(status_queue, "Downloading the Moonshine model from Hugging Face...")
+
+    for name in info["files"]:
+        dest = model_root / name
+
+        if dest.exists():
+            continue
+
+        url = f"https://huggingface.co/{_HF_REPO_ID}/resolve/main/{info['path']}/{name}"
+
+        with requests.get(url, stream=True, timeout=(10, 300)) as response:
+            response.raise_for_status()
+            tmp = dest.with_suffix(dest.suffix + ".partial")
+
+            with open(tmp, "wb") as file:
+                for chunk in response.iter_content(chunk_size=1 << 20):
+                    if chunk:
+                        file.write(chunk)
+
+        os.replace(tmp, dest)
+
+    return str(model_root)
+
+
+def _download_progress(status_queue=None):
+    """Return a progress callback that silences Moonshine's tqdm download bar.
+
+    It also reports a one-time status notice on the first download tick so
+    users know the model is being fetched. When the model is already cached
+    the callback is never invoked, so no misleading notice is shown.
+    """
+    reported = False
+
+    def on_progress(fraction, file):
+        nonlocal reported
+
+        if not reported:
+            reported = True
+            _status(status_queue, "Downloading the Moonshine model...")
+
+    return on_progress
 
 
 def _wait_for_stop(stop_queue):

{cecli_dev-1.5.0rc5 → cecli_dev-1.5.0rc8}/cecli/website/docs/usage/voice.md

@@ -22,20 +22,27 @@ If you run cecli from WSL (Windows Subsystem for Linux), `/voice` needs a little
 
 1. **Check the Windows mic.** Verify your microphone is set as the **default input device** (Settings → System → Sound → Input) and that apps may access it (Settings → Privacy & security → Microphone).
 
-2. **Install the ALSA → Pulse plugin and PulseAudio utilities.**
+2. **Install PortAudio and the ALSA → Pulse plugin plus the PulseAudio utilities.**
 
    - Fedora:
 
        ```bash
-       sudo dnf install -y alsa-utils pulseaudio-utils alsa-plugins-pulseaudio
+       sudo dnf install -y portaudio alsa-utils pulseaudio-utils alsa-plugins-pulseaudio
        ```
 
    - Debian / Ubuntu:
 
        ```bash
-       sudo apt install -y alsa-utils pulseaudio-utils libasound2-plugins
+       sudo apt install -y libportaudio2 alsa-utils pulseaudio-utils libasound2-plugins
        ```
 
+
+> **After installing PortAudio**, close and reopen your terminal (or restart WSL) so
+> `sounddevice` picks up the newly installed PortAudio library — a running Python
+> process keeps whichever PortAudio it loaded first. Also make sure Windows grants
+> microphone access to WSLg (Settings → Privacy & security → Microphone →
+> *allow desktop apps* / "Windows Subsystem for Linux").
+
 3. **Route ALSA through PulseAudio.** Create `~/.asoundrc`:
 
    ```bash
@@ -46,7 +53,8 @@ If you run cecli from WSL (Windows Subsystem for Linux), `/voice` needs a little
 
    ```bash
    PULSE_SERVER=unix:/mnt/wslg/PulseServer \
-   parec -d RDPSource --format=s16le --rate=16000 --channels=1 | \
+   parec -d RDPSource --format=s16le --rate=44100 --channels=1 | \
+     head -c 176400 | \
      python3 -c "import sys, numpy as np; a=np.frombuffer(sys.stdin.buffer.read(), np.int16)/32768.0; print('RMS', round(float(np.sqrt(np.mean(a**2))),4))"
    ```
 

{cecli_dev-1.5.0rc5 → cecli_dev-1.5.0rc8}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.5.0rc5
+Version: 1.5.0rc8
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.5.0rc5 → cecli_dev-1.5.0rc8}/cecli_dev.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "1.5.0rc5",
+  "tag": "1.5.0rc8",
   "distance": 0,
-  "node": "g9fb17f68df5a638e90b029113aacb7bf855b8534",
+  "node": "g82e5aa577faeb61a2d01a2bd180cceb262bef0f7",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-08"

{cecli_dev-1.5.0rc5 → cecli_dev-1.5.0rc8}/tests/basic/test_voice.py

@@ -427,4 +427,40 @@ def test_wait_for_stop_preserves_cli_readline():
 
     with patch("cecli.voice.sys.stdin") as stdin:
         _wait_for_stop(None)
-        stdin.readline.assert_called_once_with()
+    stdin.readline.assert_called_once_with()
+
+
+def test_open_input_stream_retries_after_start_timeout():
+    """When the default device fails to start, ``_open_input_stream`` falls back."""
+    from cecli.voice import _open_input_stream
+
+    sounddevice = MagicMock()
+    sounddevice.query_devices.return_value = [
+        {"name": "default", "max_input_channels": 1, "default_samplerate": 44100},
+        {"name": "fallback", "max_input_channels": 1, "default_samplerate": 48000},
+    ]
+
+    created = []
+
+    def make_stream(device=None, **kwargs):
+        stream = MagicMock()
+        created.append((device, stream))
+
+        if device == 0:
+            stream.start.side_effect = RuntimeError("Wait timed out")
+
+        return stream
+
+    sounddevice.InputStream.side_effect = make_stream
+
+    with patch.dict("sys.modules", {"sounddevice": sounddevice}):
+        stream = _open_input_stream(lambda *a: None, 16000, device_id=0)
+
+    # The default device was tried first (and its streams released) before the fallback.
+    assert [device for device, _ in created] == [0, 0, 0, 1]
+    assert all(s.close.called for device, s in created if device == 0)
+
+    # The returned stream is the started fallback device, not the failing one.
+    assert stream is created[-1][1]
+    assert created[-1][0] == 1
+    stream.start.assert_called_once_with()

{cecli_dev-1.5.0rc5 → cecli_dev-1.5.0rc8}/tests/mcp/test_keepalive_resilience.py

@@ -23,7 +23,11 @@ class TestKeepaliveResilience:
 
         # Simulate temporary disconnection
         running_mock_server.trigger_disconnect()
-        await asyncio.sleep(1.2)  # Wait for failed ping
+
+        # Poll until the keepalive loop's first failed ping marks the server
+        # UNHEALTHY. Polling (rather than a fixed sleep) keeps the test robust
+        # to scheduling/latency differences across CI runners.
+        await self._wait_for_state(inspector, server, ConnectionState.UNHEALTHY)
 
         # Should be UNHEALTHY after first failure
         assert inspector.get_state(server) == ConnectionState.UNHEALTHY
@@ -32,7 +36,9 @@ class TestKeepaliveResilience:
         # Restore server
         running_mock_server.reset()
         running_mock_server.set_status(200)
-        await asyncio.sleep(1.2)  # Wait for successful ping
+
+        # Poll until a successful keepalive ping restores CONNECTED
+        await self._wait_for_state(inspector, server, ConnectionState.CONNECTED)
 
         # Should recover to CONNECTED
         assert inspector.get_state(server) == ConnectionState.CONNECTED
@@ -40,6 +46,24 @@ class TestKeepaliveResilience:
 
         await server.disconnect()
 
+    @staticmethod
+    async def _wait_for_state(inspector, server, expected, timeout=5.0):
+        """Poll until the server reaches the expected connection state.
+
+        Avoids relying on a fixed sleep that can race with the keepalive
+        loop's ping cadence on slower CI runners.
+        """
+        loop = asyncio.get_running_loop()
+        deadline = loop.time() + timeout
+        while loop.time() < deadline:
+            if inspector.get_state(server) == expected:
+                return
+            await asyncio.sleep(0.05)
+        raise AssertionError(
+            f"Timed out after {timeout}s waiting for state {expected}; "
+            f"current state is {inspector.get_state(server)}"
+        )
+
     @pytest.mark.asyncio
     async def test_slow_responses_handled_gracefully(self, http_based_server, running_mock_server):
         """Verify keepalive continues to function with slow server responses."""