Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python
11.8 KB
Raw Blame
"""Mistral La Plateforme reasoning compatibility helpers."""

import json
import sys
from collections.abc import AsyncIterator, Mapping, Sequence
from copy import deepcopy
from types import SimpleNamespace
from typing import Any

import openai

from free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicy
from free_claude_code.providers.http import close_provider_stream

MISTRAL_REASONING_EFFORT = "high"

_REASONING_FIELD_NAMES = frozenset(
    {
        "reasoning_content",
        "reasoning_effort",
        "thinkchunk",
    }
)
_REJECTION_WORDS = ("unsupported", "unknown", "invalid", "forbidden", "extra")


def apply_mistral_reasoning_request_shape(
    body: dict[str, Any], *, reasoning: ReasoningPolicy
) -> None:
    """Apply Mistral's native reasoning request shape in-place."""
    if reasoning.control is ReasoningControl.OFF:
        body["reasoning_effort"] = "none"
    elif reasoning.requests_reasoning:
        body["reasoning_effort"] = MISTRAL_REASONING_EFFORT
    else:
        body.pop("reasoning_effort", None)

    messages = body.get("messages")
    if not isinstance(messages, list):
        return

    for message in messages:
        if not isinstance(message, dict) or message.get("role") != "assistant":
            continue
        replayed_reasoning = _clean_text(message.pop("reasoning_content", None))
        if replayed_reasoning:
            message["content"] = _content_with_prepended_thinking(
                message.get("content"), replayed_reasoning
            )


def clone_body_without_mistral_reasoning(
    body: dict[str, Any],
) -> dict[str, Any] | None:
    """Return a body clone with Mistral reasoning fields removed."""
    cloned = deepcopy(body)
    removed = cloned.pop("reasoning_effort", None) is not None

    messages = cloned.get("messages")
    if isinstance(messages, list):
        for message in messages:
            if not isinstance(message, dict):
                continue
            if message.pop("reasoning_content", None) is not None:
                removed = True
            content = message.get("content")
            stripped_content, content_removed = _strip_mistral_thinking_content(content)
            if content_removed:
                message["content"] = stripped_content
                removed = True

    if not removed:
        return None
    return cloned


def is_mistral_reasoning_rejection(error: Exception) -> bool:
    """Return whether an upstream error rejects Mistral reasoning request fields."""
    status_code = getattr(error, "status_code", None)
    if not isinstance(error, openai.BadRequestError) and status_code not in (400, 422):
        return False

    error_body = getattr(error, "body", None)
    if _contains_reasoning_rejection(error_body):
        return True

    error_text_parts = [str(error)]
    response = getattr(error, "response", None)
    if response is not None:
        try:
            response_text = response.text
        except Exception:
            response_text = None
        if response_text:
            if _contains_reasoning_rejection(_json_payload(response_text)):
                return True
            error_text_parts.append(response_text)

    if error_body is not None:
        error_text_parts.append(json.dumps(error_body, default=str))

    return _reasoning_rejection_text(" ".join(error_text_parts))


def normalize_mistral_stream(stream: Any) -> AsyncIterator[Any]:
    """Yield OpenAI-chat chunks with Mistral native thinking chunks normalized."""

    async def _iter() -> AsyncIterator[Any]:
        try:
            async for chunk in stream:
                yield normalize_mistral_chunk(chunk)
        finally:
            await close_provider_stream(
                stream,
                active_error=sys.exception(),
                provider_name="MISTRAL",
                request_id=None,
            )

    return _iter()


def normalize_mistral_chunk(chunk: Any) -> Any:
    """Normalize one Mistral OpenAI-compatible stream chunk."""
    choices = getattr(chunk, "choices", None)
    if not choices:
        return chunk

    normalized_choices: list[Any] = []
    changed = False
    for choice in choices:
        delta = getattr(choice, "delta", None)
        normalized_delta = _normalize_mistral_delta(delta)
        if normalized_delta is delta:
            normalized_choices.append(choice)
            continue
        changed = True
        normalized_choices.append(
            SimpleNamespace(
                delta=normalized_delta,
                finish_reason=getattr(choice, "finish_reason", None),
            )
        )

    if not changed:
        return chunk
    return SimpleNamespace(
        choices=normalized_choices,
        usage=getattr(chunk, "usage", None),
    )


def _normalize_mistral_delta(delta: Any) -> Any:
    if delta is None:
        return delta

    content = _field(delta, "content")
    text, reasoning, changed = _split_mistral_content(content)
    native_reasoning = _extract_native_reasoning(delta)
    if native_reasoning:
        reasoning = "\n".join(part for part in (reasoning, native_reasoning) if part)
        if isinstance(content, str):
            text = content
        changed = True

    existing_reasoning = _field(delta, "reasoning_content")
    if isinstance(existing_reasoning, str) and existing_reasoning:
        reasoning = "\n".join(part for part in (existing_reasoning, reasoning) if part)

    if not changed:
        return delta

    return SimpleNamespace(
        content=text,
        reasoning_content=reasoning or None,
        tool_calls=_field(delta, "tool_calls"),
    )


def _content_with_prepended_thinking(
    content: Any, reasoning: str
) -> list[dict[str, Any]]:
    chunks = [_thinking_chunk(reasoning)]
    chunks.extend(_content_to_mistral_text_chunks(content))
    return chunks


def _strip_mistral_thinking_content(content: Any) -> tuple[Any, bool]:
    if not _is_sequence(content):
        return content, False

    text_parts: list[str] = []
    kept_chunks: list[Any] = []
    removed = False
    can_collapse_to_text = True

    for chunk in content:
        chunk_type = _chunk_type(chunk)
        if _is_thinking_chunk_type(chunk_type):
            removed = True
            continue
        if chunk_type == "text":
            text = _chunk_text(chunk)
            if text:
                text_parts.append(text)
            continue
        kept_chunks.append(chunk)
        can_collapse_to_text = False

    if can_collapse_to_text:
        return "".join(text_parts), removed
    return kept_chunks, removed


def _content_to_mistral_text_chunks(content: Any) -> list[dict[str, Any]]:
    if isinstance(content, str):
        return [_text_chunk(content)] if content else []
    if not _is_sequence(content):
        text = _clean_text(content)
        return [_text_chunk(text)] if text else []

    chunks: list[dict[str, Any]] = []
    for chunk in content:
        chunk_type = _chunk_type(chunk)
        if _is_thinking_chunk_type(chunk_type):
            continue
        text = _chunk_text(chunk)
        if text:
            chunks.append(_text_chunk(text))
    return chunks


def _split_mistral_content(content: Any) -> tuple[str | None, str | None, bool]:
    if not _is_sequence(content):
        return None, None, False

    text_parts: list[str] = []
    reasoning_parts: list[str] = []
    for chunk in content:
        chunk_type = _chunk_type(chunk)
        if _is_thinking_chunk_type(chunk_type):
            reasoning = _chunk_reasoning(chunk)
            if reasoning:
                reasoning_parts.append(reasoning)
            continue
        text = _chunk_text(chunk)
        if text:
            text_parts.append(text)

    return (
        "".join(text_parts) or None,
        "".join(reasoning_parts) or None,
        True,
    )


def _extract_native_reasoning(delta: Any) -> str | None:
    for name in ("thinking", "reasoning"):
        value = _field(delta, name)
        text = _chunk_reasoning(value)
        if text:
            return text
    return None


def _contains_reasoning_rejection(value: Any) -> bool:
    if value is None:
        return False
    if isinstance(value, Mapping):
        for key, item in value.items():
            key_text = str(key).lower()
            if key_text in _REASONING_FIELD_NAMES:
                return True
            if key_text in {"loc", "param"} and _is_reasoning_field_path(item):
                return True
            if _contains_reasoning_rejection(item):
                return True
        return False
    if _is_sequence(value):
        if _is_reasoning_field_path(value):
            return True
        return any(_contains_reasoning_rejection(item) for item in value)
    if isinstance(value, str):
        return _reasoning_rejection_text(value)
    return False


def _is_reasoning_field_path(value: Any) -> bool:
    if not _is_sequence(value):
        return False
    parts = [str(part).lower() for part in value]
    if any(part in _REASONING_FIELD_NAMES for part in parts):
        return True
    return "thinking" in parts and bool(
        {"body", "messages", "assistant", "content"} & set(parts)
    )


def _reasoning_rejection_text(value: str) -> bool:
    lowered = value.lower()
    if "reasoning input" in lowered and any(
        phrase in lowered
        for phrase in (
            "not enabled",
            "not supported",
            "unsupported",
            "disabled",
        )
    ):
        return True
    if any(field in lowered for field in _REASONING_FIELD_NAMES):
        return True
    if "thinking" not in lowered or not any(
        word in lowered for word in _REJECTION_WORDS
    ):
        return False
    return any(
        marker in lowered
        for marker in (
            "body.messages",
            "assistant.thinking",
            "messages.assistant",
            "content.thinking",
            "field: thinking",
            "field 'thinking'",
            'field "thinking"',
            "property: thinking",
            "property 'thinking'",
            'property "thinking"',
            "parameter: thinking",
            "parameter 'thinking'",
            'parameter "thinking"',
            "param: thinking",
            "param 'thinking'",
            'param "thinking"',
        )
    )


def _json_payload(value: str) -> Any:
    try:
        return json.loads(value)
    except json.JSONDecodeError:
        return None


def _thinking_chunk(reasoning: str) -> dict[str, Any]:
    return {
        "type": "thinking",
        "thinking": [_text_chunk(reasoning)],
    }


def _text_chunk(text: str) -> dict[str, str]:
    return {"type": "text", "text": text}


def _chunk_reasoning(chunk: Any) -> str | None:
    if isinstance(chunk, str):
        return chunk or None
    thinking = _field(chunk, "thinking")
    if thinking is not None:
        text = _chunk_text(thinking)
        if text:
            return text
    text = _chunk_text(chunk)
    return text or None


def _chunk_text(chunk: Any) -> str:
    if isinstance(chunk, str):
        return chunk
    if _is_sequence(chunk):
        return "".join(_chunk_text(part) for part in chunk)
    text = _field(chunk, "text")
    if isinstance(text, str):
        return text
    content = _field(chunk, "content")
    if isinstance(content, str):
        return content
    return ""


def _chunk_type(chunk: Any) -> str | None:
    value = _field(chunk, "type")
    if isinstance(value, str):
        return value
    return None


def _is_thinking_chunk_type(chunk_type: str | None) -> bool:
    return chunk_type in {"thinking", "reasoning"}


def _clean_text(value: Any) -> str | None:
    if isinstance(value, str):
        return value if value else None
    return None


def _field(item: Any, name: str) -> Any:
    if isinstance(item, Mapping):
        return item.get(name)
    return getattr(item, name, None)


def _is_sequence(value: Any) -> bool:
    return isinstance(value, Sequence) and not isinstance(
        value, str | bytes | bytearray
    )