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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.5.0rc8
+Version: 1.5.0rc10
 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.0rc8 → cecli_dev-1.5.0rc10}/cecli/_version.py

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

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

@@ -2673,7 +2673,10 @@ class Coder(metaclass=UsageMeta):
         max_input_tokens = self.get_active_model().info.get("max_input_tokens") or 0
 
         if max_input_tokens and input_tokens >= max_input_tokens:
-            if self.enable_context_compaction:
+            if (
+                self.enable_context_compaction
+                and input_tokens >= self.context_compaction_max_tokens * 0.95
+            ):
                 self.io.tool_output(
                     f"Estimated chat context of {input_tokens:,} tokens exceeds the"
                     f" {max_input_tokens:,} token limit. Attempting to compact..."
@@ -2685,21 +2688,29 @@ class Coder(metaclass=UsageMeta):
                 input_tokens = self.get_active_model().token_count(messages)
 
             if max_input_tokens and input_tokens >= max_input_tokens:
-                self.io.tool_error(
-                    f"Your estimated chat context of {input_tokens:,} tokens still exceeds the"
-                    f" {max_input_tokens:,} token limit for {self.get_active_model().name}!"
-                )
-                self.io.tool_output("To reduce the chat context:")
-                self.io.tool_output("- Use /drop to remove unneeded files from the chat")
-                self.io.tool_output("- Use /clear to clear the chat history")
-                self.io.tool_output("- Break your code into smaller files")
-                self.io.tool_output(
-                    "It's probably safe to try and send the request, most providers won't charge if"
-                    " the context limit is exceeded."
-                )
+                if not hasattr(self, "_last_compaction_warning_time"):
+                    self._last_compaction_warning_time = time.time()
 
-                if not await self.io.confirm_ask("Try to proceed anyway?"):
-                    return None
+                if getattr(self, "_last_compaction_warning_time", 0) + 300 < time.time():
+                    self._last_compaction_warning_time = time.time()
+                    self.io.tool_error(
+                        f"Your estimated chat context of {input_tokens:,} tokens still exceeds the"
+                        f" {max_input_tokens:,} token limit for {self.get_active_model().name}!"
+                    )
+                    self.io.tool_output("To reduce the chat context:")
+                    self.io.tool_output("- Use /drop to remove unneeded files from the chat")
+                    self.io.tool_output("- Use /clear to clear the chat history")
+                    self.io.tool_output("- Break your code into smaller files")
+                    self.io.tool_output(
+                        "It's probably safe to try and send the request, most providers won't charge if"
+                        " the context limit is exceeded."
+                    )
+
+                    if not await self.io.confirm_ask("Try to proceed anyway?"):
+                        self._last_compaction_warning_time = 0
+                        return None
+            else:
+                self._last_compaction_warning_time = 0
 
         return messages
 

{cecli_dev-1.5.0rc8 → cecli_dev-1.5.0rc10}/cecli/helpers/llms/domains/messages.py

@@ -315,7 +315,15 @@ async def anthropic_stream(
                         ordered = [blocks[key] for key in sorted(blocks)]
 
                         if ordered:
-                            chunk.provider_specific_fields = {"anthropic": ordered}
+                            provider_fields: Dict[str, Any] = {"anthropic": ordered}
+
+                            if any(
+                                b.get("type") == "thinking" and (b.get("thinking") or "").strip()
+                                for b in ordered
+                            ):
+                                provider_fields["use_thinking_summaries"] = True
+
+                            chunk.provider_specific_fields = provider_fields
 
                     yield chunk
 
@@ -379,6 +387,12 @@ def normalize_anthropic_response(data: Dict[str, Any], model: str) -> Completion
 
     provider_fields = {"anthropic": blocks} if blocks else {}
 
+    if any(b.get("type") == "thinking" and (b.get("thinking") or "").strip() for b in blocks):
+        # The assistant turn carries a readable thinking summary; mark it so the
+        # replay path can strip the summary text (keeping the signature) and keep
+        # the cached prefix stable across turns.
+        provider_fields["use_thinking_summaries"] = True
+
     pm = PartsMessage(role="assistant", parts=parts, provider_metadata=provider_fields)
     message = parts_message_to_message(pm)
 
@@ -554,7 +568,11 @@ def _anthropic_message_content(msg: Dict[str, Any]) -> Optional[List[Dict[str, A
             content.append({"type": "text", "text": block.get("text") or ""})
 
         elif btype == "thinking":
-            entry: Dict[str, Any] = {"type": "thinking", "thinking": block.get("thinking") or ""}
+            # Summary text is display-only; strip it on replay (keeping the
+            # signature, which carries the encrypted chain-of-thought for
+            # continuity) so prior-turn reasoning doesn't churn the cached prefix.
+            thinking = "" if psf.get("use_thinking_summaries") else block.get("thinking") or ""
+            entry: Dict[str, Any] = {"type": "thinking", "thinking": thinking}
 
             if block.get("signature"):
                 entry["signature"] = block["signature"]

{cecli_dev-1.5.0rc8 → cecli_dev-1.5.0rc10}/cecli/helpers/llms/domains/responses.py

@@ -58,13 +58,22 @@ def responses_payload(
         payload["tools"] = [responses_tool(t) for t in tools]
 
     api_block = resolved.get("api_block") or {}
+
+    # Responses-mode models (gpt-5 / meta) are reasoning models: always opt in
+    # to a readable reasoning ``summary`` so the response (and the stream) expose
+    # the summary block the capture logic consumes. An ``effort`` rides along when
+    # the api_block configures one; without it the model uses its default effort.
+    reasoning_config: Dict[str, Any] = {"summary": "auto"}
+
     if api_block.get("reasoning_effort"):
-        payload["reasoning"] = {"effort": api_block["reasoning_effort"], "summary": "auto"}
+        reasoning_config["effort"] = api_block["reasoning_effort"]
         # Encrypted reasoning blobs (meta muse-spark) are only returned when
         # explicitly requested; without them prior reasoning items cannot be
         # replayed on the next turn.
         payload["include"] = ["reasoning.encrypted_content"]
 
+    payload["reasoning"] = reasoning_config
+
     if api_block.get("parallel_tool_calls") is not None:
         payload["parallel_tool_calls"] = api_block["parallel_tool_calls"]
 
@@ -90,6 +99,13 @@ def responses_payload(
     extra_body.pop("thinking", None)
     payload.update(resolved.get("extra_body") or {})
     payload.update(extra_body)
+
+    # A caller-supplied ``reasoning`` object (e.g. ``set_reasoning_effort``)
+    # overwrites the built ``reasoning``; keep the summary opt-in intact so
+    # summaries are always requested when reasoning is configured.
+    if isinstance(payload.get("reasoning"), dict):
+        payload["reasoning"].setdefault("summary", "auto")
+
     return payload
 
 
@@ -117,8 +133,12 @@ def to_responses_input(
             # Replay stashed reasoning items BEFORE the assistant message item
             # so the provider can continue its OWN encrypted reasoning state
             # (stateless round-trip: the whole conversation is re-sent).
+            strip_summary = bool(
+                (msg.get("provider_specific_fields") or {}).get("use_reasoning_summaries")
+            )
+
             for r_item in _stashed_reasoning_items(msg, current_model):
-                items.append(_reasoning_input_item(r_item))
+                items.append(_reasoning_input_item(r_item, strip_summary=strip_summary))
 
             # Assistant turns must use ``output_text`` content blocks; Copilot /
             # OpenAI reject ``input_text`` on assistant messages with HTTP 400
@@ -260,6 +280,10 @@ def normalize_responses_response(data: Dict[str, Any], model: str) -> Completion
             for block in item.get("summary") or []:
                 if block.get("type") == "summary_text" and block.get("text"):
                     parts.append(ReasoningPart(text=block["text"]))
+                    # Mark the turn as carrying a readable reasoning summary so
+                    # the replay path can strip it (keeping the id +
+                    # encrypted_content) and keep the cached prefix stable.
+                    provider_fields["use_reasoning_summaries"] = True
 
             # Encrypted reasoning (e.g. meta muse-spark): an opaque blob that
             # must be echoed back verbatim on the next turn. Stash the whole
@@ -365,11 +389,17 @@ def parse_responses_chunk(data: Dict[str, Any]) -> Optional[CompletionChunk]:
         # Reasoning metadata rides on the authoritative completed event; the
         # per-event ciphertext differs, so only the final items are emitted.
         if _stream_state["reasoning_items"]:
-            chunk.provider_specific_fields = {
-                "reasoning_items": list(_stream_state["reasoning_items"].values()),
+            reasoning_items = list(_stream_state["reasoning_items"].values())
+            provider_fields = {
+                "reasoning_items": reasoning_items,
                 "reasoning_items_origin": _stream_state.get("model"),
             }
 
+            if any((item.get("summary") or []) for item in reasoning_items):
+                provider_fields["use_reasoning_summaries"] = True
+
+            chunk.provider_specific_fields = provider_fields
+
         chunk.usage = _build_usage(resp.get("usage") or {})
         return chunk
 
@@ -486,13 +516,18 @@ def _stashed_reasoning_items(
     return []
 
 
-def _reasoning_input_item(item: Dict[str, Any]) -> Dict[str, Any]:
-    """Build the responses-API input item that replays a prior reasoning item."""
+def _reasoning_input_item(item: Dict[str, Any], *, strip_summary: bool = False) -> Dict[str, Any]:
+    """Build the responses-API input item that replays a prior reasoning item.
+
+    ``strip_summary`` drops the display-only summary text (keeping the id +
+    encrypted_content) so the reasoning artifact stays in context for the model
+    without churning the cached prompt prefix with per-turn summary text.
+    """
     return {
         "type": "reasoning",
         "id": item.get("id"),
         "encrypted_content": item.get("encrypted_content"),
-        "summary": item.get("summary") or [],
+        "summary": [] if strip_summary else item.get("summary") or [],
     }
 
 

{cecli_dev-1.5.0rc8 → cecli_dev-1.5.0rc10}/cecli/helpers/llms/formatters/thinking.py

@@ -52,17 +52,30 @@ def gemini_thinking(payload: Dict[str, Any], api_block: Dict[str, Any]) -> Dict[
 
 
 def anthropic_5_thinking(payload: Dict[str, Any], api_block: Dict[str, Any]) -> Dict[str, Any]:
-    """Claude 5+: adaptive thinking via ``output_config.effort``."""
+    """Claude 5+: adaptive thinking via ``output_config.effort`` + summarized display.
+
+    Claude 5+ defaults ``thinking.display`` to ``"omitted"``, which withholds the
+    readable thinking summary. Opting in to ``"summarized"`` returns the summary
+    text so it can be surfaced to the user.
+    """
     if api_block.get("reasoning_effort"):
         payload["output_config"] = {"effort": api_block["reasoning_effort"]}
+        payload["thinking"] = {"type": "adaptive", "display": "summarized"}
 
     return payload
 
 
 def anthropic_thinking(payload: Dict[str, Any], api_block: Dict[str, Any]) -> Dict[str, Any]:
-    """Pre-Claude-5: the ``thinking`` block (type enabled + budget)."""
-    if api_block.get("thinking"):
-        payload["thinking"] = api_block["thinking"]
+    """Pre-Claude-5: the ``thinking`` block (type enabled + budget) with summarized display.
+
+    ``display`` works alongside ``type: "enabled"``; defaulting it to
+    ``"summarized"`` returns the readable thinking summary (older models already
+    default to it, newer 4.x models default to ``"omitted"``).
+    """
+    thinking = api_block.get("thinking")
+
+    if isinstance(thinking, dict):
+        payload["thinking"] = {**thinking, "display": "summarized"}
 
     return payload
 

{cecli_dev-1.5.0rc8 → cecli_dev-1.5.0rc10}/cecli/helpers/llms/pipeline.py

@@ -71,6 +71,11 @@ async def acompletion(
 
     headers = provider.build_headers(resolved, key, family, headers)
 
+    # Allow the provider adapter to transform the outgoing message body before
+    # dispatch (e.g. Mistral's strict schema rejects reasoning_content /
+    # provider_specific_fields and a null tool-call index).
+    messages = provider.transform_messages(messages)
+
     if stream:
         gen = _stream_family(family, resolved, messages, tools, key, headers, kwargs)
 

{cecli_dev-1.5.0rc8 → cecli_dev-1.5.0rc10}/cecli/helpers/llms/providers/base.py

@@ -8,7 +8,7 @@ delegate to the generic family adapters in :mod:`cecli.helpers.llms.domains`.
 
 from __future__ import annotations
 
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 
 class ProviderAdapter:
@@ -20,6 +20,10 @@ class ProviderAdapter:
       authenticated session's ``endpoints.api``).
     - :meth:`resolve_api_key` - key source (env, auth cache, oauth refresh).
     - :meth:`build_headers` - auth scheme + provider-specific headers.
+    - :meth:`transform_messages` - transform the outgoing message body to
+      normalize fields a stricter provider rejects (e.g. Mistral rejects
+      ``reasoning_content`` / ``provider_specific_fields`` and a null tool-call
+      ``index``).
     - :meth:`normalize` - post-process a family-normalized response
       (e.g. meta encrypted-reasoning marker).
     """
@@ -53,6 +57,17 @@ class ProviderAdapter:
         merged.setdefault("Content-Type", "application/json")
         return merged
 
+    def transform_messages(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Transform the outgoing message body to normalize provider-specific fields.
+
+        The default is a no-op. Providers with a stricter request schema override
+        this to strip fields the generic OpenAI-compatible wire tolerates but the
+        provider rejects (e.g. Mistral rejects ``reasoning_content`` and
+        ``provider_specific_fields`` on assistant turns, and a null tool-call
+        ``index``).
+        """
+        return messages
+
     def normalize(
         self,
         family: str,

cecli_dev-1.5.0rc10/cecli/helpers/llms/providers/mistral.py

@@ -0,0 +1,79 @@
+"""Mistral provider adapter for the llms package.
+
+Mistral speaks OpenAI-compatible /v1/chat/completions with Bearer auth, but its
+request body is validated by a strict Pydantic schema that rejects fields the
+generic OpenAI-compatible wire tolerates. Assistant turns built by cecli carry
+``reasoning_content`` and ``provider_specific_fields`` on the message, and
+``provider_specific_fields`` plus a null ``index`` on tool calls (a streaming
+artifact); Mistral rejects each of these with a 422 on the relevant
+``messages[i]`` path.
+
+This adapter iterates over the message body before dispatch and strips those
+fields, leaving tool calls in the request wire shape (``id`` / ``type`` /
+``function``).
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from .base import ProviderAdapter
+
+
+class MistralProvider(ProviderAdapter):
+    """Mistral: Bearer auth (default) + strict message-body sanitization."""
+
+    provider: str = "mistral"
+
+    def transform_messages(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Strip fields Mistral's strict chat-completions schema rejects."""
+        changed = False
+        out: List[Dict[str, Any]] = []
+
+        for msg in messages:
+            cleaned = self._clean_message(msg)
+
+            if cleaned is not None:
+                out.append(cleaned)
+                changed = True
+            else:
+                out.append(msg)
+
+        return out if changed else messages
+
+    def _clean_message(self, msg: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Return a sanitized copy of ``msg``, or ``None`` when unchanged."""
+        tool_calls = msg.get("tool_calls")
+        needs_tool_fix = any(
+            isinstance(tc, dict) and ("index" in tc or "provider_specific_fields" in tc)
+            for tc in tool_calls or []
+        )
+
+        if (
+            "reasoning_content" not in msg
+            and "provider_specific_fields" not in msg
+            and not needs_tool_fix
+        ):
+            return None
+
+        cleaned = dict(msg)
+        cleaned.pop("reasoning_content", None)
+        cleaned.pop("provider_specific_fields", None)
+
+        if tool_calls:
+            cleaned["tool_calls"] = [self._clean_tool_call(tc) for tc in tool_calls]
+
+        return cleaned
+
+    def _clean_tool_call(self, tc: Any) -> Any:
+        """Drop streaming-only fields from a tool call."""
+        if not isinstance(tc, dict):
+            return tc
+
+        cleaned = dict(tc)
+        cleaned.pop("index", None)
+        cleaned.pop("provider_specific_fields", None)
+        return cleaned
+
+
+__all__ = ["MistralProvider"]

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

@@ -268,8 +268,9 @@ def _run_record_process(
             temp_path = tmp_file.name
 
         try:
-            stream = _open_input_stream(callback, sample_rate, device_id)
-            with stream:
+            with sd.InputStream(
+                samplerate=sample_rate, channels=1, callback=callback, device=device_id
+            ):
                 _status(status_queue, f"\n⬤ recording: {stop_binding or 'Enter'} to stop")
                 _wait_for_stop(stop_queue)
 
@@ -328,6 +329,7 @@ def _record_and_stream(
     """
     import threading
 
+    import sounddevice as sd
     from moonshine_voice.transcriber import LineCompleted, LineStarted, LineTextChanged
 
     transcriber = _build_transcriber(language, status_queue)
@@ -395,8 +397,9 @@ def _record_and_stream(
         feed_thread.start()
 
         try:
-            stream = _open_input_stream(callback, sample_rate, device_id)
-            with stream:
+            with sd.InputStream(
+                samplerate=sample_rate, channels=1, callback=callback, device=device_id
+            ):
                 _status(status_queue, f"\n⬤ recording: {stop_binding or 'Enter'} to stop")
                 _wait_for_stop(stop_queue)
         finally:
@@ -556,95 +559,6 @@ def _status(status_queue, message):
         print(message)
 
 
-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.
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.5.0rc8
+Version: 1.5.0rc10
 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.0rc8 → cecli_dev-1.5.0rc10}/cecli_dev.egg-info/SOURCES.txt

@@ -293,6 +293,7 @@ cecli/helpers/llms/providers/deepseek.py
 cecli/helpers/llms/providers/gemini.py
 cecli/helpers/llms/providers/github_copilot.py
 cecli/helpers/llms/providers/meta.py
+cecli/helpers/llms/providers/mistral.py
 cecli/helpers/llms/providers/openai.py
 cecli/helpers/llms/providers/openrouter.py
 cecli/helpers/memory/__init__.py
@@ -763,9 +764,11 @@ tests/helpers/test_llms_github_copilot_auth.py
 tests/helpers/test_llms_hyperscalers.py
 tests/helpers/test_llms_messages_stream.py
 tests/helpers/test_llms_messages_wire.py
+tests/helpers/test_llms_mistral_adapter.py
 tests/helpers/test_llms_providers_json.py
 tests/helpers/test_llms_reasoning_config.py
 tests/helpers/test_llms_reasoning_extract.py
+tests/helpers/test_llms_reasoning_summaries.py
 tests/helpers/test_llms_vision.py
 tests/helpers/test_loop_detect.py
 tests/helpers/test_memory_control.py

{cecli_dev-1.5.0rc8 → cecli_dev-1.5.0rc10}/cecli_dev.egg-info/scm_file_list.json

@@ -247,6 +247,7 @@
     "cecli/helpers/llms/providers/gemini.py",
     "cecli/helpers/llms/providers/github_copilot.py",
     "cecli/helpers/llms/providers/meta.py",
+    "cecli/helpers/llms/providers/mistral.py",
     "cecli/helpers/llms/providers/openai.py",
     "cecli/helpers/llms/providers/openrouter.py",
     "cecli/helpers/llms/runtime.py",
@@ -1010,9 +1011,11 @@
     "tests/helpers/test_llms_hyperscalers.py",
     "tests/helpers/test_llms_messages_stream.py",
     "tests/helpers/test_llms_messages_wire.py",
+    "tests/helpers/test_llms_mistral_adapter.py",
     "tests/helpers/test_llms_providers_json.py",
     "tests/helpers/test_llms_reasoning_config.py",
     "tests/helpers/test_llms_reasoning_extract.py",
+    "tests/helpers/test_llms_reasoning_summaries.py",
     "tests/helpers/test_llms_vision.py",
     "tests/helpers/test_loop_detect.py",
     "tests/helpers/test_memory_control.py",

cecli_dev-1.5.0rc10/cecli_dev.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.5.0rc10",
+  "distance": 0,
+  "node": "ge1dd0a190f632b061d26ca348e2ec9ea6e6ca0dd",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-09"
+}

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

@@ -428,39 +428,3 @@ 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()
-
-
-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()