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
minor: add Mistral prompt-cache affinity header (#2026)
Kirill Galkin42bf8439cba2
diff --git a/smoke/lib/config.py b/smoke/lib/config.pyindex e62d9cf2..e5f7d6cf 100644--- a/smoke/lib/config.py+++ b/smoke/lib/config.py@@ -106,6 +106,7 @@ PROVIDER_SMOKE_DEFAULT_MODELS: dict[str, str] = {"wandb": "wandb/openai/gpt-oss-20b",}MISTRAL_REASONING_SMOKE_DEFAULT_MODEL = "mistral/mistral-medium-3-5"+MISTRAL_CACHE_SMOKE_DEFAULT_MODEL = "mistral/mistral-large-latest"NVIDIA_NIM_CLI_DEFAULT_MODELS: tuple[str, ...] = ("nvidia/nemotron-3.5-lightning-30b-a3b",@@ -288,6 +289,21 @@ class SmokeConfig:source = "mistral_reasoning_default"return ProviderModel(provider="mistral", full_model=full_model, source=source)+ def mistral_cache_smoke_model(self) -> ProviderModel | None:+ """Return a Mistral model expected to report prompt-cache reads."""+ if self.provider_matrix and "mistral" not in self.provider_matrix:+ return None+ if not self.has_provider_configuration("mistral"):+ return None+ override_env = "FCC_SMOKE_MODEL_MISTRAL_CACHE"+ if override := os.getenv(override_env):+ full_model = _normalize_provider_model("mistral", override)+ source = override_env+ else:+ full_model = MISTRAL_CACHE_SMOKE_DEFAULT_MODEL+ source = "mistral_cache_default"+ return ProviderModel(provider="mistral", full_model=full_model, source=source)+def _include_provider_in_smoke(self, provider: str, mapped_providers: set[str]) -> bool:diff --git a/smoke/product/test_provider_product_live.py b/smoke/product/test_provider_product_live.pyindex 20a770d2..5256803e 100644--- a/smoke/product/test_provider_product_live.py+++ b/smoke/product/test_provider_product_live.py@@ -1,3 +1,4 @@+import timefrom typing import Anyimport httpx@@ -20,6 +21,7 @@ from smoke.lib.e2e import (tool_use_blocks,)from smoke.lib.http import collect_message_stream, conversation_headers+from smoke.lib.server import RunningServerfrom smoke.lib.skips import (skip_if_upstream_unavailable_events,skip_if_upstream_unavailable_exception,@@ -146,6 +148,60 @@ def test_mistral_native_reasoning_model_e2e(smoke_config: SmokeConfig) -> None:)+def test_mistral_prompt_cache_affinity_e2e(smoke_config: SmokeConfig) -> None:+ """Mistral prompt caching via the x-affinity session header (merge gate).++ The x-affinity mechanism is reverse-engineered from the official Mistral+ CLI (mistral-vibe), not a public API contract. Two requests sharing one+ session id and a long common prefix must report cache reads on the second+ response. Cache support is model-dependent and best-effort, so the gate+ pins a model that consistently reports cache reads and retries the+ follow-up with escalating pauses (the cache is eventually consistent).+ """+ provider_model = smoke_config.mistral_cache_smoke_model()+ if provider_model is None:+ pytest.skip("missing_env: mistral is not configured")++ headers = conversation_headers(session_id="fcc-smoke-mistral-cache-affinity")+ first_payload = {+ # fcc-smoke-default routes to the MODEL override (the Mistral model);+ # tier names like claude-opus-4-7 would route to MODEL_OPUS instead.+ "model": "fcc-smoke-default",+ "max_tokens": 256,+ "system": _long_cacheable_system_prompt(),+ "messages": [{"role": "user", "content": "Say hello in one word."}],+ }+ second_payload = {+ **first_payload,+ "messages": [+ first_payload["messages"][0],+ {"role": "user", "content": "Now say goodbye in one word."},+ ],+ }++ try:+ with SmokeServerDriver(+ smoke_config,+ name="product-provider-mistral-prompt-cache-affinity",+ env_overrides={+ "MODEL": provider_model.full_model,+ "MODEL_FALLBACKS": "",+ "MESSAGING_PLATFORM": "none",+ },+ ).run() as server:+ cached_reads = _mistral_cached_reads_with_retry(+ server, smoke_config, headers, first_payload, second_payload+ )+ except Exception as exc:+ skip_if_upstream_unavailable_exception(exc)+ raise++ assert cached_reads > 0, (+ f"{provider_model.source}={provider_model.full_model}: "+ "no prompt cache reads reported on the second request"+ )++@pytest.mark.smoke_target("rate_limit")def test_provider_disconnect_e2e(smoke_config: SmokeConfig, provider_model: ProviderModel@@ -648,3 +704,58 @@ def _openai_auth_headers(smoke_config: SmokeConfig) -> dict[str, str]:if token:headers["authorization"] = f"Bearer {token}"return conversation_headers(headers)+++def _long_cacheable_system_prompt() -> str:+ """Build a deterministic system prompt far above the minimum cacheable prefix."""+ paragraph = (+ "You are a concise assistant in a long-running support conversation. "+ "Answer every question with a single short sentence and nothing else. "+ )+ return paragraph * 40+++def _mistral_cached_reads_with_retry(+ server: RunningServer,+ smoke_config: SmokeConfig,+ headers: dict[str, str],+ first_payload: dict[str, Any],+ second_payload: dict[str, Any],+ *,+ read_pauses_s: tuple[float, ...] = (3, 3, 5, 8, 13, 21),+) -> int:+ """Warm the cache, then return follow-up cache reads, retrying misses.++ Mistral prompt caching is best-effort and eventually consistent: the+ warm request's cache write becomes visible to later requests only after+ a variable delay (observed from ~3s to ~25s). The first probe matches the+ observed minimum propagation (~3s); later pauses escalate, so the probes+ land at ~3, 6, 11, 19, 32, and 53s after the warm request and the final+ probe covers the observed upper bound with margin.+ """+ warm_events = collect_message_stream(+ server, first_payload, smoke_config, headers=headers+ )+ skip_if_upstream_unavailable_events(warm_events)+ for pause_s in read_pauses_s:+ time.sleep(pause_s)+ followup_events = collect_message_stream(+ server, second_payload, smoke_config, headers=headers+ )+ skip_if_upstream_unavailable_events(followup_events)+ cached_reads = _cache_read_input_tokens(followup_events)+ if cached_reads > 0:+ return cached_reads+ return 0+++def _cache_read_input_tokens(events: list[SSEEvent]) -> int:+ for event in events:+ if event.event != "message_delta":+ continue+ usage = event.data.get("usage")+ if isinstance(usage, dict):+ cached = usage.get("cache_read_input_tokens")+ if isinstance(cached, int) and not isinstance(cached, bool):+ return cached+ return 0diff --git a/src/free_claude_code/providers/mistral/caching.py b/src/free_claude_code/providers/mistral/caching.pynew file mode 100644index 00000000..3e6df094--- /dev/null+++ b/src/free_claude_code/providers/mistral/caching.py@@ -0,0 +1,61 @@+"""Mistral prompt-cache affinity headers.++Mistral's official CLI (mistral-vibe) enables prompt caching by sending the+conversation session id as the ``x-affinity`` HTTP header on every request+(``vibe/core/agent_loop/_loop.py`` in mistralai/mistral-vibe; mirrored by+zed-industries/zed#48584). The header is not part of Mistral's public API+contract, so this module mirrors the official client behavior rather than a+documented request field.+"""++from collections.abc import Mapping++MISTRAL_AFFINITY_HEADER = "x-affinity"++# Ordered by specificity: the first non-empty header wins.+MISTRAL_SESSION_HEADER_NAMES: tuple[str, ...] = (+ "x-opencode-session",+ "anthropic-session-id",+ "x-anthropic-session-id",+ "claude-session-id",+ "x-claude-session-id",+ "x-claude-code-session-id",+ "session-id",+ "x-session-id",+ "session_id",+ "x-grok-session-id",+ "x-meta-ai-gateway-session-id",+ "x-tbh-session-id",+ # Launch identity is less specific than a conversation session.+ "x-fcc-launch-id",+)+++def extract_mistral_affinity_key(headers: Mapping[str, str]) -> str | None:+ """Return the first non-empty session header value, case-insensitive."""+ lowered = {+ str(name).lower(): value+ for name, value in headers.items()+ if isinstance(value, str)+ }+ for name in MISTRAL_SESSION_HEADER_NAMES:+ value = lowered.get(name)+ if value is not None and value.strip():+ return value.strip()+ return None+++def mistral_affinity_headers(+ request_headers: Mapping[str, str] | None,+) -> dict[str, str]:+ """Return upstream headers carrying the Mistral cache-affinity session id.++ Only the affinity header is forwarded; other client headers (credentials,+ user-agent) must never leak upstream through this path.+ """+ if not request_headers:+ return {}+ key = extract_mistral_affinity_key(request_headers)+ if key is None:+ return {}+ return {MISTRAL_AFFINITY_HEADER: key}diff --git a/src/free_claude_code/providers/mistral/client.py b/src/free_claude_code/providers/mistral/client.pyindex cc311ae0..db5ef339 100644--- a/src/free_claude_code/providers/mistral/client.py+++ b/src/free_claude_code/providers/mistral/client.py@@ -1,15 +1,20 @@"""Mistral La Plateforme provider implementation (OpenAI-compatible chat completions)."""-from collections.abc import Mapping+from collections.abc import AsyncIterator, Mappingfrom typing import Anyfrom loguru import logger+from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.core.anthropic import ReasoningReplayMode+from free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.model_capabilities import ModelInputModality-from free_claude_code.core.reasoning import ReasoningPolicy+from free_claude_code.core.openai_responses import OpenAIResponsesRequest+from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy+from free_claude_code.core.stream_recovery import ContinuationSeedfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfig+from free_claude_code.providers.endpoint_types import EndpointContextfrom free_claude_code.providers.openai_chat import (NO_REASONING,OpenAIChatBehavior,@@ -19,6 +24,7 @@ from free_claude_code.providers.openai_chat import (OpenAIModelListing,)+from .caching import mistral_affinity_headersfrom .reasoning import (apply_mistral_reasoning_request_shape,clone_body_without_mistral_reasoning,@@ -89,3 +95,59 @@ class MistralProvider(OpenAIChatProvider):behavior=MistralChatBehavior(_PROFILE),admission=admission,)++ def stream_messages(+ self,+ request: MessagesRequest,+ input_tokens: int = 0,+ *,+ request_id: str | None = None,+ response_model: str | None = None,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,+ endpoint_context: EndpointContext | None = None,+ request_headers: Mapping[str, str] | None = None,+ continuation: ContinuationSeed | None = None,+ ) -> AsyncIterator[str]:+ """Stream with the Mistral prompt-cache affinity header when known.++ The base provider drops ``request_headers``; the transport accepts+ ``extra_headers`` instead, so the affinity header is derived here and+ passed straight through.+ """+ return self._chat.stream_messages(+ request,+ input_tokens=input_tokens,+ request_id=request_id,+ response_model=response_model,+ reasoning=reasoning,+ model_info=model_info,+ endpoint_context=endpoint_context,+ extra_headers=mistral_affinity_headers(request_headers),+ continuation=continuation,+ )++ def stream_responses(+ self,+ request: OpenAIResponsesRequest,+ input_tokens: int = 0,+ *,+ request_id: str | None = None,+ response_model: str | None = None,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ endpoint_context: EndpointContext | None = None,+ request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,+ continuation: ContinuationSeed | None = None,+ ) -> AsyncIterator[str]:+ """Stream Responses with the Mistral prompt-cache affinity header."""+ return self._chat.stream_responses(+ request,+ input_tokens=input_tokens,+ request_id=request_id,+ response_model=response_model,+ reasoning=reasoning,+ endpoint_context=endpoint_context,+ extra_headers=mistral_affinity_headers(request_headers),+ continuation=continuation,+ )diff --git a/src/free_claude_code/providers/openai_chat/transport.py b/src/free_claude_code/providers/openai_chat/transport.pyindex 9f2f75fe..a65b234a 100644--- a/src/free_claude_code/providers/openai_chat/transport.py+++ b/src/free_claude_code/providers/openai_chat/transport.py@@ -1413,6 +1413,7 @@ class _OpenAIChatStreamRunner:corrections=corrections,endpoint=self._endpoint,request_client=self._request_client,+ extra_headers=self._extra_headers,)scope = ProviderAttemptScope(attempt,diff --git a/tests/api/test_mistral_affinity.py b/tests/api/test_mistral_affinity.pynew file mode 100644index 00000000..f652a91e--- /dev/null+++ b/tests/api/test_mistral_affinity.py@@ -0,0 +1,147 @@+"""Mistral affinity reaches upstream requests through both public APIs."""++import json+from contextlib import asynccontextmanager+from unittest.mock import patch++import httpx+import httpx2+import pytest+from openai import AsyncOpenAI++from free_claude_code.config.settings import Settings+from free_claude_code.providers.mistral import MistralProvider+from tests.api.support import create_test_app, provider_manager_for_app+from tests.providers.support import immediate_admission, make_provider_config+from tests.providers.test_opencode import _chat_event_stream+++@asynccontextmanager+async def mistral_wire(handler=None):+ requests = []++ async def generation(request):+ requests.append(request)+ if handler is not None:+ return await handler(request, len(requests))+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=_chat_event_stream("hello"),+ )++ def sdk(**kwargs):+ kwargs["http_client"] = httpx2.AsyncClient(+ transport=httpx2.MockTransport(generation)+ )+ return AsyncOpenAI(**kwargs)++ with patch(+ "free_claude_code.providers.openai_chat.client.AsyncOpenAI", side_effect=sdk+ ):+ provider = MistralProvider(+ make_provider_config(+ api_key="test-mistral-key", base_url="https://api.mistral.ai/v1"+ ),+ admission=immediate_admission(provider_name="mistral"),+ )+ app = create_test_app(+ Settings(+ model="mistral/mistral-large-latest",+ mistral_api_key="test-mistral-key",+ proxy_auth_enabled=False,+ ),+ providers={"mistral": provider},+ )+ try:+ async with httpx.AsyncClient(+ transport=httpx.ASGITransport(app=app), base_url="http://fcc.test"+ ) as client:+ yield client, requests+ finally:+ await provider_manager_for_app(app).close()++[email protected]("ingress", ["messages", "responses"])+ "header",+ [+ "x-opencode-session",+ "x-claude-code-session-id",+ "session-id",+ "session_id",+ "x-grok-session-id",+ "x-meta-ai-gateway-session-id",+ "x-tbh-session-id",+ "x-fcc-launch-id",+ ],+)+async def test_affinity_for_existing_harness_identity(ingress, header):+ payload = {"model": "mistral/mistral-large-latest", "stream": True}+ if ingress == "messages":+ payload.update(messages=[{"role": "user", "content": "hello"}], max_tokens=128)+ else:+ payload["input"] = "hello"+ async with mistral_wire() as (client, requests):+ response = await client.post(+ f"/v1/{ingress}", json=payload, headers={header: "conversation-a"}+ )+ assert response.status_code == 200+ assert len(requests) == 1+ assert requests[0].headers.get("x-affinity") == "conversation-a"+++class InterruptedStream(httpx2.AsyncByteStream):+ async def __aiter__(self):+ event = {+ "id": "chatcmpl-test",+ "object": "chat.completion.chunk",+ "model": "mistral-large-latest",+ "created": 1,+ "choices": [+ {+ "index": 0,+ "delta": {"content": "prefix " * 10000},+ "finish_reason": None,+ }+ ],+ }+ yield ("data: " + json.dumps(event) + "\n\n").encode()+ raise httpx2.ReadError("upstream disconnected after partial text")++[email protected]("session_id", [None, "conversation-a"])+async def test_nonstream_recovery_keeps_affinity(session_id):+ async def handler(request, number):+ if number == 1:+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ stream=InterruptedStream(),+ )+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=_chat_event_stream("recovered"),+ )++ async with mistral_wire(handler) as (client, requests):+ response = await client.post(+ "/v1/messages",+ json={+ "model": "mistral/mistral-large-latest",+ "stream": False,+ "max_tokens": 32768,+ "messages": [{"role": "user", "content": "long answer"}],+ },+ headers={"x-opencode-session": session_id} if session_id else {},+ )+ assert response.status_code == 200+ assert len(requests) == 2+ assert "recovered" in str(response.json()["content"])+ assert [request.headers.get("x-affinity") for request in requests] == [+ session_id,+ session_id,+ ]diff --git a/tests/providers/test_mistral_caching.py b/tests/providers/test_mistral_caching.pynew file mode 100644index 00000000..96d9e728--- /dev/null+++ b/tests/providers/test_mistral_caching.py@@ -0,0 +1,355 @@+"""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"}+++def mistral_config():+ return make_provider_config(+ api_key="test_mistral_key",+ base_url=MISTRAL_DEFAULT_BASE,+ )+++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"++[email protected]("name", MISTRAL_SESSION_HEADER_NAMES)+def test_extract_accepts_every_known_session_header(name):+ assert extract_mistral_affinity_key({name: "sess-1"}) == "sess-1"+++ "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"+ )++[email protected]("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"+++ "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++[email protected]("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"++[email protected]("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"}+++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"+ }+++ "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+++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)+++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"+ }+++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+++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+++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,+ }