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

minor: add Mistral prompt-cache affinity header (#2026)

Kirill Galkin42bf8439cba2
diff --git a/smoke/lib/config.py b/smoke/lib/config.py
index 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.py
index 20a770d2..5256803e 100644
--- a/smoke/product/test_provider_product_live.py
+++ b/smoke/product/test_provider_product_live.py
@@ -1,3 +1,4 @@
+import time
from typing import Any
import 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 RunningServer
from 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 0
diff --git a/src/free_claude_code/providers/mistral/caching.py b/src/free_claude_code/providers/mistral/caching.py
new file mode 100644
index 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.py
index 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, Mapping
from typing import Any
from loguru import logger
+from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.core.anthropic import ReasoningReplayMode
+from free_claude_code.core.anthropic.models import MessagesRequest
from 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 ContinuationSeed
from free_claude_code.providers.admission import ProviderAdmissionController
from free_claude_code.providers.base import ProviderConfig
+from free_claude_code.providers.endpoint_types import EndpointContext
from 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_headers
from .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.py
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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,
+ }