cecli-dev 1.5.0rc12__tar.gz → 1.5.0rc14__tar.gz

{cecli_dev-1.5.0rc12 → cecli_dev-1.5.0rc14}/PKG-INFO

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

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.0rc12'
-__version_tuple__ = version_tuple = (1, 5, 0, 'rc12')
+__version__ = version = '1.5.0rc14'
+__version_tuple__ = version_tuple = (1, 5, 0, 'rc14')
 
-__commit_id__ = commit_id = 'gc04433f14'
+__commit_id__ = commit_id = 'gab7479db9'

{cecli_dev-1.5.0rc12 → cecli_dev-1.5.0rc14}/cecli/args.py

@@ -162,6 +162,12 @@ def get_parser(default_config_files, git_root):
         metavar="MODEL",
         help="List known models which match the (partial) MODEL name",
     )
+    group.add_argument(
+        "--configure-provider",
+        action="store_true",
+        default=False,
+        help="Force the interactive provider configuration wizard to run on startup",
+    )
     group.add_argument(
         "--model-settings-file",
         metavar="MODEL_SETTINGS_FILE",

{cecli_dev-1.5.0rc12 → cecli_dev-1.5.0rc14}/cecli/helpers/llms/config.py

@@ -103,7 +103,7 @@ def resolve_model_config(model: str) -> Dict[str, Any]:
     ]
     key_env = next((e for e in key_envs if e), None)
 
-    mode = llm_block.get("mode") or "chat"
+    mode = pcfg.get("mode") or llm_block.get("mode") or "chat"
     endpoints = llm_block.get("supported_endpoints") or []
 
     # API family: responses > anthropic messages > gemini > chat completions

{cecli_dev-1.5.0rc12 → cecli_dev-1.5.0rc14}/cecli/helpers/llms/domains/chat.py

@@ -47,9 +47,13 @@ def chat_payload(
     kwargs: Dict[str, Any],
 ) -> Dict[str, Any]:
     api_block = resolved.get("api_block") or {}
+
+    if resolved.get("_echo_reasoning_content", True):
+        messages = _coerce_reasoning_content(messages, api_block)
+
     payload: Dict[str, Any] = {
         "model": resolved["route"],
-        "messages": _coerce_reasoning_content(messages, api_block),
+        "messages": messages,
         "stream": stream,
     }
 

{cecli_dev-1.5.0rc12 → cecli_dev-1.5.0rc14}/cecli/helpers/llms/domains/responses.py

@@ -142,13 +142,17 @@ def to_responses_input(
 
             # Assistant turns must use ``output_text`` content blocks; Copilot /
             # OpenAI reject ``input_text`` on assistant messages with HTTP 400
-            # ("Supported values are: 'output_text' and 'refusal'").
+            # ("Supported values are: 'output_text' and 'refusal'"). A synthetic
+            # ``msg_probe_<n>`` id + ``completed`` status round out the
+            # output-message shape (provider-supplied ids must begin with "msg").
             if content:
                 text = content if isinstance(content, str) else json.dumps(content)
                 items.append(
                     {
                         "type": "message",
                         "role": "assistant",
+                        "id": f"msg_probe_{len(items)}",
+                        "status": "completed",
                         "content": [{"type": "output_text", "text": text}],
                     }
                 )

{cecli_dev-1.5.0rc12 → cecli_dev-1.5.0rc14}/cecli/helpers/llms/pipeline.py

@@ -74,8 +74,10 @@ async def acompletion(
     # 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).
+    # The chat payload echoes prior-turn reasoning_content back for providers
+    # that require it (DeepSeek thinking mode); strict providers opt out here so
+    # the coercer cannot re-inject a field the transform just stripped.
+    resolved["_echo_reasoning_content"] = getattr(provider, "echoes_reasoning_content", True)
     messages = provider.transform_messages(messages)
 
     if stream:

{cecli_dev-1.5.0rc12 → cecli_dev-1.5.0rc14}/cecli/helpers/llms/providers/base.py

@@ -24,8 +24,6 @@ class ProviderAdapter:
       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).
     """
@@ -33,6 +31,11 @@ class ProviderAdapter:
     #: Provider slug used by the registry (``openai``, ``github_copilot``, ...).
     provider: str = "openai"
 
+    #: Whether prior-turn ``reasoning_content`` must be echoed back on assistant
+    #: messages (DeepSeek thinking mode). Strict providers that reject the field
+    #: (Mistral) set this False so the chat payload's coercer skips them.
+    echoes_reasoning_content: bool = True
+
     def resolve_api_base(self, resolved: Dict[str, Any]) -> str:
         """Return the api_base for a resolved config (default: as resolved)."""
         return resolved["api_base"]
@@ -67,8 +70,6 @@ class ProviderAdapter:
         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
 

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

@@ -0,0 +1,177 @@
+"""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``).
+
+On the response side Mistral streams ``content`` as a list of typed parts
+(``thinking`` / ``text``); :meth:`normalize` flattens those into the generic
+``text`` / ``reasoning`` fields so the shared chat parser stays provider-agnostic.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Tuple
+
+from ..types import CompletionChunk, CompletionResponse
+from .base import ProviderAdapter
+
+
+class MistralProvider(ProviderAdapter):
+    """Mistral: Bearer auth (default) + strict message-body sanitization."""
+
+    provider: str = "mistral"
+
+    #: Mistral rejects ``reasoning_content`` on assistant turns (see
+    #: :meth:`transform_messages`), so the chat payload must not inject it.
+    echoes_reasoning_content: bool = False
+
+    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 normalize(self, family: str, data: Any, resolved: Dict[str, Any]) -> Any:
+        """Flatten Mistral's typed content parts into the generic shape.
+
+        Mistral streams ``content`` as a list of typed parts, carrying reasoning
+        in ``{"type": "thinking", "thinking": [...]}`` blocks alongside
+        ``{"type": "text", ...}`` ones. The generic OpenAI-compatible parser
+        treats that list as opaque text, which then crashes consumers that
+        concatenate it as a string. Move thinking parts onto ``reasoning``
+        (stream) / ``reasoning_content`` and join text parts into plain text.
+        """
+        if family != "chat":
+            return data
+
+        if isinstance(data, CompletionChunk):
+            return self._normalize_chunk(data)
+
+        if isinstance(data, CompletionResponse):
+            return self._normalize_response(data)
+
+        return data
+
+    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
+
+    def _normalize_chunk(self, chunk: CompletionChunk) -> CompletionChunk:
+        """Flatten a streamed chunk's typed ``content`` parts."""
+        text, reasoning = self._split_content(chunk.text)
+        chunk.text = text
+
+        if reasoning:
+            chunk.reasoning = (chunk.reasoning or "") + reasoning
+
+        return chunk
+
+    def _normalize_response(self, response: CompletionResponse) -> CompletionResponse:
+        """Flatten typed ``content`` parts on each choice's message."""
+        for choice in response.choices:
+            message = choice.message
+            content = message.content
+
+            if isinstance(content, list):
+                text, reasoning = self._split_content(content)
+                message.content = text or None
+
+                if reasoning:
+                    message.reasoning_content = (message.reasoning_content or "") + reasoning
+
+            if isinstance(message.reasoning_content, list):
+                text, reasoning = self._split_content(message.reasoning_content)
+                message.reasoning_content = text or reasoning
+
+        return response
+
+    def _split_content(self, content: Any) -> Tuple[str, str]:
+        """Split a Mistral ``content`` value into ``(text, reasoning)``."""
+        if isinstance(content, str):
+            return content, ""
+
+        if not isinstance(content, list):
+            return "", ""
+
+        texts: List[str] = []
+        reasonings: List[str] = []
+
+        for part in content:
+            if not isinstance(part, dict):
+                continue
+
+            part_type = part.get("type")
+
+            if part_type == "thinking":
+                reasonings.append(self._flatten_thinking(part.get("thinking")))
+            elif part_type == "text":
+                text = part.get("text")
+
+                if isinstance(text, str):
+                    texts.append(text)
+
+        return "".join(texts), "".join(reasonings)
+
+    def _flatten_thinking(self, thinking: Any) -> str:
+        """Join a thinking block (a string or a list of text parts)."""
+        if isinstance(thinking, str):
+            return thinking
+
+        if not isinstance(thinking, list):
+            return ""
+
+        return "".join(item.get("text") or "" for item in thinking if isinstance(item, dict))
+
+
+__all__ = ["MistralProvider"]

{cecli_dev-1.5.0rc12 → cecli_dev-1.5.0rc14}/cecli/helpers/model_config/api.py

@@ -13,7 +13,14 @@ from __future__ import annotations
 
 from typing import Dict, Optional
 
-from .identifiers import is_anthropic, is_claude_5_plus, is_gemini_2_5, is_glm, is_kimi
+from .identifiers import (
+    is_anthropic,
+    is_claude_5_plus,
+    is_gemini_2_5,
+    is_glm,
+    is_kimi,
+    is_mistral,
+)
 from .registry import get_default
 from .utils import supports_reasoning
 
@@ -51,7 +58,11 @@ def derive_api_config(
     if reasoning and not gemini_2_5:
         default_effort = _DEFAULT_REASONING_EFFORT
 
-        if is_glm(provider, route, record) or is_kimi(provider, route, record):
+        if (
+            is_glm(provider, route, record)
+            or is_kimi(provider, route, record)
+            or is_mistral(provider, route, record)
+        ):
             default_effort = _DEFAULT_HIGH_REASONING_EFFORT
 
         effort = _resolve_reasoning_effort(defaults.get("reasoning"), default_effort)

{cecli_dev-1.5.0rc12 → cecli_dev-1.5.0rc14}/cecli/helpers/model_config/identifiers.py

@@ -74,6 +74,11 @@ def is_kimi(provider, route, record):
     return "kimi" in _haystack(provider, route, record)
 
 
+def is_mistral(provider, route, record):
+    """True when the model is a Mistral-series model (Mistral AI)."""
+    return "mistral" in _haystack(provider, route, record)
+
+
 def gpt_version(route):
     """Return the leading ``gpt-`` model version, or 0 when not a gpt model.
 

{cecli_dev-1.5.0rc12 → cecli_dev-1.5.0rc14}/cecli/models.py

@@ -952,7 +952,7 @@ class Model(ModelSettings):
             self.extra_params = dict(self.extra_params)
 
     def _apply_provider_defaults(self):
-        provider = (self.info.get("litellm_provider") or "").lower()
+        provider = self._configured_provider()
         self.litellm_provider = provider or None
         if self.info.get("supports_stream") is False:
             self.streaming = False
@@ -1772,6 +1772,23 @@ class Model(ModelSettings):
             )
             f.write(",\n")
 
+    def _configured_provider(self) -> str:
+        """Return the provider whose config should apply to this model.
+
+        ``info['litellm_provider']`` is unreliable as a config key: litellm's
+        model-cost table rewrites it to the upstream vendor for known model
+        names (``my-provider/gpt-4o`` -> ``openai``), which hides a user-defined
+        provider's settings such as ``supports_stream``. A configured model-name
+        prefix wins, mirroring ``helpers.llms.config.resolve_model_config``.
+        """
+        provider = (self.info.get("litellm_provider") or "").lower()
+        prefix = self.name.split("/", 1)[0].lower() if "/" in self.name else ""
+
+        if prefix and model_info_manager.provider_manager.supports_provider(prefix):
+            return prefix
+
+        return provider
+
 
 def register_models(model_settings_fnames):
     files_loaded = []

{cecli_dev-1.5.0rc12 → cecli_dev-1.5.0rc14}/cecli/onboarding.py

@@ -94,6 +94,9 @@ async def select_default_model(args, io):
     Selects a default model based on available API keys if no model is specified.
     Launches the inline onboarding wizard when no model or API keys are found.
 
+    When ``args.configure_provider`` is set, the onboarding wizard is always launched
+    first, even if a model or API keys are already configured.
+
     Args:
         args: The command line arguments object.
         io: The InputOutput object for user interaction.
@@ -101,17 +104,27 @@ async def select_default_model(args, io):
     Returns:
         The name of the selected model, or None if no suitable default is found.
     """
+    from cecli.helpers.onboarding import run_onboarding
+
+    configure_provider = getattr(args, "configure_provider", False)
+    onboarded = False
+    if configure_provider:
+        onboarded = True
+        model = await run_onboarding(io)
+        if model:
+            return model
     if args.model:
         return args.model
     model = try_to_select_default_model()
     if model:
         io.tool_warning(f"Using {model} model with API key from environment.")
         return model
+    if onboarded:
+        await io.offer_url(urls.models_and_keys, "Open documentation URL for more info?")
+        return None
     no_model_msg = "No LLM model was specified and no API keys were provided."
     io.tool_warning(no_model_msg)
 
-    from cecli.helpers.onboarding import run_onboarding
-
     model = await run_onboarding(io)
     if model:
         return model