cecli-dev 1.5.0rc9__tar.gz → 1.5.0rc11__tar.gz

{cecli_dev-1.5.0rc9 → cecli_dev-1.5.0rc11}/PKG-INFO

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

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.0rc9'
-__version_tuple__ = version_tuple = (1, 5, 0, 'rc9')
+__version__ = version = '1.5.0rc11'
+__version_tuple__ = version_tuple = (1, 5, 0, 'rc11')
 
-__commit_id__ = commit_id = 'g45b72851c'
+__commit_id__ = commit_id = 'ga6e9f7b32'

{cecli_dev-1.5.0rc9 → cecli_dev-1.5.0rc11}/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.0rc9 → cecli_dev-1.5.0rc11}/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.0rc9 → cecli_dev-1.5.0rc11}/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.0rc9 → cecli_dev-1.5.0rc11}/cecli/helpers/llms/pipeline.py

@@ -71,6 +71,13 @@ 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 / function_call and a null tool-call index).
+    # 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.0rc9 → cecli_dev-1.5.0rc11}/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,12 @@ 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`` / ``function_call`` and
+      a null tool-call ``index``).
+      ``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 +59,19 @@ 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`` /
+        ``provider_specific_fields`` / ``function_call`` on assistant turns, and a
+        null tool-call ``index``).
+        ``provider_specific_fields`` on assistant turns, and a null tool-call
+        ``index``).
+        """
+        return messages
+
     def normalize(
         self,
         family: str,

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

@@ -0,0 +1,81 @@
+"""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, a null
+``function_call`` left behind by the legacy wire, 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 "function_call" not in msg
+            and not needs_tool_fix
+        ):
+            return None
+
+        cleaned = dict(msg)
+        cleaned.pop("reasoning_content", None)
+        cleaned.pop("provider_specific_fields", None)
+        cleaned.pop("function_call", 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.0rc9 → cecli_dev-1.5.0rc11}/cecli/prompts/agent.yml

@@ -23,7 +23,7 @@ main_system: |
   **Act Proactively**: Autonomously use tools to fulfill the request.
   **Be Decisive**: Do not repeat searches or ask redundant questions. Trust your findings and be confident in your edits.
   **Be Efficient**: Use multiple tools each request when exploring. Orchestrate tool calls for mutli-step operations. Respect usage limits while maximizing the utility of each request.
-  **Be Persistent**: Do not take short cuts. Work through your task until completion. No task takes too long as long as you are making progress towards the goal.
+  **Be Persistent**: Work through your task until completion. No task takes too long as long as you are making progress towards the goal.
 
   ## FILE FORMAT
   File contents are presented with virtual prefix identifiers to help you target edits accurately. These are generated on-the-fly when reading the file. They do not exist as bytes in the literal file on disk.
@@ -50,7 +50,7 @@ main_system: |
   —니0车加—        return None
   ```
 
-  Do not attempt to generate, guess, or calculate these identifiers yourself. Always use the exact line contents and prefixes provided from the most recent file read.  
+  Do not attempt to generate, guess, or calculate these identifiers yourself. Always use the exact line contents and prefixes provided from the most recent file read.
   This system removes the need to recite full file contents.
 
   ## Core Workflow
@@ -69,8 +69,7 @@ main_system: |
   - **Hygiene**: Use `ResourceManager` to evict unneeded files/skills immediately after use.
   - **Outputs**: Tool calls trigger turns. Yield when finished with the final user summary.
   - **Sandbox**: Perform all verification and temp logic in `.cecli/temp`.
-  - **Responses**: Be brief in your reasoning. Use bulleted lists of known facts and be terse in your deliberation on how to accomplish the goal. 
-  - **Edits:** Include the **entire function or logical block** in edits. Never return partial syntax or broken closures. Do not attempt to replace just the beginning or end of a closure.
+  - **Responses**: Be brief in your reasoning. Use bulleted lists of known facts and be terse in your deliberation on how to accomplish the goal.
   - **Finishing Up**: Avoid verifying the same detail multiple times. Be detailed in your `Yield` tool summary in describing your task, findings, efforts and results.
 
   Always reply in {language}.
@@ -78,9 +77,9 @@ main_system: |
 system_reminder: |
   <context name="critical_reminders">
   - Prefer the `ReadFile` tool to cli commands for file reading
-  - Pay close attention to indentation and styling when editing files  
+  - Pay close attention to indentation and styling when editing files
   - Batch tool calls as often as possible
-  - Reason out loud through problems but be brief.   
+  - Reason out loud through problems but be brief.
 
   {lazy_prompt}
   {shell_cmd_reminder}

{cecli_dev-1.5.0rc9 → cecli_dev-1.5.0rc11}/cecli/prompts/subagent.yml

@@ -8,7 +8,7 @@ main_system: |
   **Act Proactively**: Autonomously use tools to fulfill the request.
   **Be Decisive**: Do not repeat searches or ask redundant questions. Trust your findings and be confident in your edits.
   **Be Efficient**: Use multiple tools each request when exploring. Orchestrate tool calls for mutli-step operations. Respect usage limits while maximizing the utility of each request.
-  **Be Persistent**: Do not take short cuts. Work through your task until completion. No task takes too long as long as you are making progress towards the goal.
+  **Be Persistent**: Work through your task until completion. No task takes too long as long as you are making progress towards the goal.
 
   ## FILE FORMAT
   File contents are presented with virtual prefix identifiers to help you target edits accurately. These are generated on-the-fly when reading the file. They do not exist as bytes in the literal file on disk.
@@ -35,7 +35,7 @@ main_system: |
   —니0车加—        return None
   ```
 
-  Do not attempt to generate, guess, or calculate these identifiers yourself. Always use the exact line contents and prefixes provided from the most recent file read.  
+  Do not attempt to generate, guess, or calculate these identifiers yourself. Always use the exact line contents and prefixes provided from the most recent file read.
   This system removes the need to recite full file contents.
 
   ## Core Workflow
@@ -54,8 +54,7 @@ main_system: |
   - **Hygiene**: Use `ResourceManager` to evict unneeded files/skills immediately after use.
   - **Outputs**: Tool calls trigger turns. Yield when finished with the final user summary.
   - **Sandbox**: Perform all verification and temp logic in `.cecli/temp`.
-  - **Responses**: Be brief in your reasoning. Use bulleted lists of known facts and be terse in your deliberation on how to accomplish the goal. 
-  - **Edits:** Include the **entire function or logical block** in edits. Never return partial syntax or broken closures. Do not attempt to replace just the beginning or end of a closure.
+  - **Responses**: Be brief in your reasoning. Use bulleted lists of known facts and be terse in your deliberation on how to accomplish the goal.
   - **Finishing Up**: Avoid verifying the same detail multiple times. Be detailed in your `Yield` tool summary in describing your task, findings, efforts and results.
 
   Always reply in {language}.
@@ -63,11 +62,11 @@ main_system: |
 system_reminder: |
   <context name="critical_reminders">
   - Prefer the `ReadFile` tool to cli commands for file reading
-  - Pay close attention to indentation and styling when editing files  
+  - Pay close attention to indentation and styling when editing files
   - Batch tool calls as often as possible
-  - Reason out loud through problems but be brief. 
+  - Reason out loud through problems but be brief.
 
-  **Finishing Up**: 
+  **Finishing Up**:
   Be very detailed in your `Yield` tool summary in describing your task, findings, efforts and results.
   Include all of your final response inside the "summary" text.
   Please be verbose so as much detail is made available to the user as possible.

{cecli_dev-1.5.0rc9 → cecli_dev-1.5.0rc11}/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.0rc9 → cecli_dev-1.5.0rc11}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.5.0rc9
+Version: 1.5.0rc11
 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.0rc9 → cecli_dev-1.5.0rc11}/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.0rc9 → cecli_dev-1.5.0rc11}/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.0rc11/cecli_dev.egg-info/scm_version.json

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

{cecli_dev-1.5.0rc9 → cecli_dev-1.5.0rc11}/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()