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
10.8 KB
Raw Blame
"""Tests for Mistral prompt-cache affinity (x-affinity header) wiring."""

from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch

import openai
import pytest
from httpx2 import Request, Response

from free_claude_code.config.provider_catalog import (
    MISTRAL_DEFAULT_BASE,
    XAI_DEFAULT_BASE,
)
from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
from free_claude_code.core.openai_responses.models import OpenAIResponsesRequest
from free_claude_code.providers.mistral import MistralProvider
from free_claude_code.providers.mistral.caching import (
    MISTRAL_AFFINITY_HEADER,
    MISTRAL_SESSION_HEADER_NAMES,
    extract_mistral_affinity_key,
    mistral_affinity_headers,
)
from tests.providers.request_factory import make_messages_request
from tests.providers.support import (
    SDKStreamDouble,
    immediate_admission,
    make_provider_config,
    profiled_provider,
    reasoning_for,
)

SESSION_HEADERS = {"x-opencode-session": "sess-123"}


@pytest.fixture
def mistral_config():
    return make_provider_config(
        api_key="test_mistral_key",
        base_url=MISTRAL_DEFAULT_BASE,
    )


@pytest.fixture
def mistral_provider(mistral_config):
    return MistralProvider(mistral_config, admission=immediate_admission())


def _text_chunk(text: str = "Hello back!"):
    chunk = MagicMock()
    chunk.choices = [
        MagicMock(
            delta=MagicMock(content=text, reasoning_content=None, tool_calls=None),
            finish_reason="stop",
        )
    ]
    chunk.usage = MagicMock(completion_tokens=5, prompt_tokens=10)
    return chunk


async def _single_chunk_stream():
    yield _text_chunk()


def _make_bad_request_error(message: str) -> openai.BadRequestError:
    request = Request("POST", "https://api.mistral.ai/v1/chat/completions")
    response = Response(400, request=request)
    body = {"error": {"message": message}}
    return openai.BadRequestError(message, response=response, body=body)


def test_extract_prefers_the_most_specific_session_header():
    headers = {
        "session-id": "generic",
        "anthropic-session-id": "anthropic",
        "x-opencode-session": "opencode",
    }
    assert extract_mistral_affinity_key(headers) == "opencode"


@pytest.mark.parametrize("name", MISTRAL_SESSION_HEADER_NAMES)
def test_extract_accepts_every_known_session_header(name):
    assert extract_mistral_affinity_key({name: "sess-1"}) == "sess-1"


@pytest.mark.parametrize(
    "name", [name for name in MISTRAL_SESSION_HEADER_NAMES if name != "x-fcc-launch-id"]
)
def test_conversation_identity_takes_precedence_over_launch_identity(name):
    assert (
        extract_mistral_affinity_key(
            {"x-fcc-launch-id": "launch-1", name: "conversation-1"}
        )
        == "conversation-1"
    )


@pytest.mark.parametrize("blank", ["", "   "])
def test_blank_conversation_identity_falls_back_to_launch_identity(blank):
    assert (
        extract_mistral_affinity_key(
            {"x-opencode-session": blank, "x-fcc-launch-id": "launch-1"}
        )
        == "launch-1"
    )


def test_extract_matches_header_names_case_insensitively():
    assert extract_mistral_affinity_key({"X-OpenCode-Session": "sess-2"}) == "sess-2"


def test_extract_strips_surrounding_whitespace():
    assert extract_mistral_affinity_key({"x-opencode-session": "  sess-3 "}) == "sess-3"


@pytest.mark.parametrize(
    "headers",
    [
        {},
        {"x-opencode-session": ""},
        {"x-opencode-session": "   "},
        {"unrelated-header": "value"},
    ],
)
def test_extract_returns_none_without_a_usable_session_header(headers):
    assert extract_mistral_affinity_key(headers) is None


@pytest.mark.parametrize("blank", ["", "   "])
def test_extract_falls_through_blank_preferred_header(blank):
    headers = {
        "x-opencode-session": blank,
        "anthropic-session-id": "anthropic",
    }
    assert extract_mistral_affinity_key(headers) == "anthropic"


@pytest.mark.parametrize("headers", [None, {}])
def test_affinity_headers_are_empty_without_a_session_header(headers):
    assert mistral_affinity_headers(headers) == {}


def test_affinity_headers_forward_only_the_affinity_header():
    headers = {
        "authorization": "Bearer secret",
        "user-agent": "fcc-test/1.0",
        "x-opencode-session": "sess-4",
    }
    assert mistral_affinity_headers(headers) == {MISTRAL_AFFINITY_HEADER: "sess-4"}


@pytest.mark.asyncio
async def test_stream_messages_sends_affinity_header(mistral_provider):
    req = make_messages_request("devstral-small-latest")

    with patch.object(
        mistral_provider._client.chat.completions, "create", new_callable=AsyncMock
    ) as mock_create:
        mock_create.return_value = SDKStreamDouble(_single_chunk_stream())

        events = [
            event
            async for event in mistral_provider.stream_messages(
                req, request_headers=SESSION_HEADERS
            )
        ]

    assert any("Hello back!" in event for event in events)
    assert mock_create.await_args is not None
    assert mock_create.await_args.kwargs["extra_headers"] == {
        MISTRAL_AFFINITY_HEADER: "sess-123"
    }


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "request_headers",
    [
        None,
        {},
        {"authorization": "Bearer secret", "user-agent": "fcc-test/1.0"},
    ],
)
async def test_stream_messages_without_session_header_sends_no_extra_headers(
    mistral_provider, request_headers
):
    req = make_messages_request("devstral-small-latest")

    with patch.object(
        mistral_provider._client.chat.completions, "create", new_callable=AsyncMock
    ) as mock_create:
        mock_create.return_value = SDKStreamDouble(_single_chunk_stream())

        events = [
            event
            async for event in mistral_provider.stream_messages(
                req, request_headers=request_headers
            )
        ]

    assert any("Hello back!" in event for event in events)
    assert mock_create.await_args is not None
    assert "extra_headers" not in mock_create.await_args.kwargs


@pytest.mark.asyncio
async def test_stream_messages_affinity_header_survives_reasoning_retry(
    mistral_provider,
):
    req = make_messages_request("devstral-small-latest")
    error = _make_bad_request_error("Unsupported field: reasoning_effort")

    with patch.object(
        mistral_provider._client.chat.completions, "create", new_callable=AsyncMock
    ) as mock_create:
        mock_create.side_effect = [error, SDKStreamDouble(_single_chunk_stream())]

        events = [
            event
            async for event in mistral_provider.stream_messages(
                req,
                reasoning=reasoning_for(req),
                request_headers=SESSION_HEADERS,
            )
        ]

    assert mock_create.await_count == 2
    for call in mock_create.await_args_list:
        assert call.kwargs["extra_headers"] == {MISTRAL_AFFINITY_HEADER: "sess-123"}
    assert any("Hello back!" in event for event in events)


@pytest.mark.asyncio
async def test_stream_responses_sends_affinity_header(mistral_provider):
    request = OpenAIResponsesRequest(model="devstral-small-latest", input="hi")

    with patch.object(
        mistral_provider._client.chat.completions, "create", new_callable=AsyncMock
    ) as mock_create:
        mock_create.return_value = SDKStreamDouble(_single_chunk_stream())

        chunks = [
            chunk
            async for chunk in mistral_provider.stream_responses(
                request, request_headers=SESSION_HEADERS
            )
        ]

    assert chunks
    assert mock_create.await_args is not None
    assert mock_create.await_args.kwargs["extra_headers"] == {
        MISTRAL_AFFINITY_HEADER: "sess-123"
    }


@pytest.mark.asyncio
async def test_stream_responses_without_session_header_sends_no_extra_headers(
    mistral_provider,
):
    request = OpenAIResponsesRequest(model="devstral-small-latest", input="hi")

    with patch.object(
        mistral_provider._client.chat.completions, "create", new_callable=AsyncMock
    ) as mock_create:
        mock_create.return_value = SDKStreamDouble(_single_chunk_stream())

        chunks = [chunk async for chunk in mistral_provider.stream_responses(request)]

    assert chunks
    assert mock_create.await_args is not None
    assert "extra_headers" not in mock_create.await_args.kwargs


@pytest.mark.asyncio
async def test_other_openai_chat_providers_do_not_send_affinity_headers():
    provider = profiled_provider(
        "xai",
        make_provider_config(api_key="test-xai-key", base_url=XAI_DEFAULT_BASE),
        admission=immediate_admission(provider_name="xai"),
    )
    req = make_messages_request("grok-4.5")

    with patch.object(
        provider._client.chat.completions, "create", new_callable=AsyncMock
    ) as mock_create:
        mock_create.return_value = SDKStreamDouble(_single_chunk_stream())

        events = [
            event
            async for event in provider.stream_messages(
                req, request_headers=SESSION_HEADERS
            )
        ]

    assert any("Hello back!" in event for event in events)
    assert mock_create.await_args is not None
    assert "extra_headers" not in mock_create.await_args.kwargs


@pytest.mark.asyncio
async def test_stream_messages_maps_cached_usage_to_anthropic_fields(mistral_provider):
    req = make_messages_request("devstral-small-latest")

    async def fake_stream():
        yield SimpleNamespace(
            choices=[
                SimpleNamespace(
                    delta=SimpleNamespace(
                        content="hello", reasoning_content=None, tool_calls=None
                    ),
                    finish_reason=None,
                )
            ],
            usage=None,
        )
        yield SimpleNamespace(
            choices=[
                SimpleNamespace(
                    delta=SimpleNamespace(
                        content=None, reasoning_content=None, tool_calls=None
                    ),
                    finish_reason="stop",
                )
            ],
            usage=None,
        )
        yield SimpleNamespace(
            choices=[],
            usage=SimpleNamespace(
                completion_tokens=5,
                prompt_tokens=1000,
                prompt_tokens_details={"cached_tokens": 640},
            ),
        )

    with patch.object(
        mistral_provider._client.chat.completions, "create", new_callable=AsyncMock
    ) as mock_create:
        mock_create.return_value = SDKStreamDouble(fake_stream())

        chunks = [
            chunk
            async for chunk in mistral_provider.stream_messages(
                req, request_headers=SESSION_HEADERS
            )
        ]

    parsed = parse_sse_text("".join(chunks))
    usage = next(
        event.data["usage"] for event in parsed if event.event == "message_delta"
    )
    assert usage == {
        "input_tokens": 360,
        "output_tokens": 5,
        "cache_read_input_tokens": 640,
    }