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
61.6 KB
Raw Blame
"""Tests for DeepSeek OpenAI-compatible Chat Completions provider."""

import json
import logging
from types import SimpleNamespace
from unittest.mock import AsyncMock, patch

import httpx2
import pytest
from openai import BadRequestError

from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
from free_claude_code.config.provider_catalog import DEEPSEEK_DEFAULT_BASE
from free_claude_code.core.anthropic.models import (
    ContentBlockDocument,
    ContentBlockImage,
    Message,
    MessagesRequest,
    Tool,
)
from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
from free_claude_code.core.failures import ExecutionFailure, FailureKind
from free_claude_code.core.openai_chat import is_synthetic_chat_tool_turn_boundary
from free_claude_code.core.openai_responses.models import OpenAIResponsesRequest
from free_claude_code.providers.deepseek import DeepSeekProvider
from tests.providers.support import (
    REASONING_OFF,
    REASONING_ON,
    SDKStreamDouble,
    capture_openai_chat_wire_body,
    immediate_admission,
    make_provider_config,
    reasoning_for,
)


@pytest.fixture
def deepseek_config():
    return make_provider_config(
        api_key="test_deepseek_key",
        base_url=DEEPSEEK_DEFAULT_BASE,
    )


@pytest.fixture
def deepseek_provider(deepseek_config):
    return DeepSeekProvider(deepseek_config, admission=immediate_admission())


def test_default_base_url_alias():
    assert DEEPSEEK_DEFAULT_BASE == "https://api.deepseek.com"


def test_init(deepseek_config):
    with patch(
        "free_claude_code.providers.openai_chat.client.AsyncOpenAI"
    ) as mock_client:
        provider = DeepSeekProvider(deepseek_config, admission=immediate_admission())
    assert provider._api_key == "test_deepseek_key"
    assert provider._base_url == "https://api.deepseek.com"
    assert mock_client.called


def test_responses_request_uses_deepseek_chat_policy(deepseek_provider):
    request = OpenAIResponsesRequest.model_validate(
        {
            "model": "deepseek-chat",
            "input": [
                {
                    "type": "function_call",
                    "call_id": "call_1",
                    "name": "Read",
                    "arguments": '{"file_path":"x"}',
                },
                {
                    "type": "function_call_output",
                    "call_id": "call_1",
                    "output": "ok",
                },
                {"role": "user", "content": "Continue"},
            ],
            "tools": [
                {
                    "type": "function",
                    "name": "Read",
                    "parameters": {
                        "type": "object",
                        "properties": {"file_path": {"type": "string"}},
                    },
                }
            ],
            "tool_choice": {"type": "function", "name": "Read"},
        }
    )

    translated = deepseek_provider._chat._build_responses_request_body(
        request, reasoning=REASONING_ON
    )

    assert translated.body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
    assert translated.body["tool_choice"] == "auto"
    assert translated.body["extra_body"] == {"thinking": {"type": "enabled"}}


def test_responses_tool_history_keeps_deepseek_replayable_reasoning(
    deepseek_provider,
):
    request = OpenAIResponsesRequest.model_validate(
        {
            "model": "deepseek-chat",
            "input": [
                {
                    "type": "reasoning",
                    "content": [{"type": "reasoning_text", "text": "Inspect first"}],
                },
                {
                    "type": "function_call",
                    "call_id": "call_1",
                    "name": "Read",
                    "arguments": '{"file_path":"x"}',
                },
                {
                    "type": "function_call_output",
                    "call_id": "call_1",
                    "output": "ok",
                },
            ],
        }
    )

    translated = deepseek_provider._chat._build_responses_request_body(
        request, reasoning=REASONING_ON
    )

    assert translated.body["messages"][0]["reasoning_content"] == "Inspect first"
    assert translated.body["extra_body"] == {"thinking": {"type": "enabled"}}


@pytest.mark.parametrize(
    ("usage", "anthropic_expected", "responses_cached"),
    [
        (
            {
                "prompt_tokens": 30,
                "prompt_cache_hit_tokens": 10,
                "prompt_cache_miss_tokens": 20,
            },
            {"input_tokens": 20, "cache_read_input_tokens": 10},
            10,
        ),
        (
            {
                "prompt_tokens": 30,
                "prompt_cache_hit_tokens": 0,
                "prompt_cache_miss_tokens": 30,
            },
            {"input_tokens": 30, "cache_read_input_tokens": 0},
            0,
        ),
        (
            {
                "prompt_tokens": 30,
                "prompt_cache_hit_tokens": 30,
                "prompt_cache_miss_tokens": 0,
            },
            {"input_tokens": 0, "cache_read_input_tokens": 30},
            30,
        ),
        (
            {"prompt_cache_hit_tokens": 10, "prompt_cache_miss_tokens": 20},
            {"input_tokens": 20, "cache_read_input_tokens": 10},
            None,
        ),
        (
            {"prompt_tokens": 30, "prompt_cache_miss_tokens": 20},
            {},
            None,
        ),
        (
            {"prompt_tokens": 30, "prompt_cache_hit_tokens": 10},
            {},
            None,
        ),
        (
            {
                "prompt_tokens": 30,
                "prompt_cache_hit_tokens": True,
                "prompt_cache_miss_tokens": 20,
            },
            {},
            None,
        ),
        (
            {
                "prompt_tokens": 30,
                "prompt_cache_hit_tokens": 10,
                "prompt_cache_miss_tokens": 20.0,
            },
            {},
            None,
        ),
        (
            {
                "prompt_tokens": 30,
                "prompt_cache_hit_tokens": -1,
                "prompt_cache_miss_tokens": 31,
            },
            {},
            None,
        ),
        (
            {
                "prompt_tokens": 30,
                "prompt_cache_hit_tokens": 10,
                "prompt_cache_miss_tokens": -1,
            },
            {},
            None,
        ),
        (
            {
                "prompt_tokens": -1,
                "prompt_cache_hit_tokens": 10,
                "prompt_cache_miss_tokens": 20,
            },
            {"input_tokens": 20, "cache_read_input_tokens": 10},
            None,
        ),
        (
            {
                "prompt_tokens": 30,
                "prompt_cache_hit_tokens": 10,
                "prompt_cache_miss_tokens": 19,
            },
            {},
            None,
        ),
    ],
)
def test_maps_only_complete_consistent_cache_usage(
    deepseek_provider, usage, anthropic_expected, responses_cached
) -> None:
    assert (
        deepseek_provider._behavior.anthropic_usage_fields(usage) == anthropic_expected
    )
    assert deepseek_provider._behavior.cached_input_tokens(usage) == responses_cached


def test_build_request_body_openai_chat_shape(deepseek_provider):
    request = MessagesRequest(
        model="deepseek-v4-pro",
        max_tokens=100,
        messages=[Message(role="user", content="Hello")],
        system="S",
    )
    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )
    assert body["model"] == "deepseek-v4-pro"
    assert "stream" not in body
    assert body["messages"][0] == {"role": "system", "content": "S"}
    assert body["messages"][1]["role"] == "user"
    assert body["messages"][1] == {"role": "user", "content": "Hello"}
    assert body["max_tokens"] == 100
    assert "stream_options" not in body


def test_build_request_body_default_max_tokens(deepseek_provider):
    request = MessagesRequest(
        model="m",
        messages=[Message(role="user", content="x")],
    )
    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )
    assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS


def test_build_request_body_thinking_enabled(deepseek_provider):
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [{"role": "user", "content": "x"}],
            "thinking": {"type": "enabled", "budget_tokens": 2000},
        }
    )
    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )
    assert body["extra_body"]["thinking"] == {"type": "enabled"}


def test_build_request_body_tool_list_keeps_thinking(deepseek_provider):
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [{"role": "user", "content": "x"}],
            "tools": [
                {
                    "name": "Read",
                    "description": "Read a file",
                    "input_schema": {"type": "object", "properties": {}},
                }
            ],
            "thinking": {"type": "enabled", "budget_tokens": 2000},
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    assert body["extra_body"]["thinking"] == {"type": "enabled"}
    assert body["tools"][0]["function"]["name"] == "Read"


def test_build_request_body_tool_choice_keeps_thinking(deepseek_provider):
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [{"role": "user", "content": "x"}],
            "tool_choice": {"type": "auto"},
            "tools": [{"name": "Read", "input_schema": {"type": "object"}}],
            "thinking": {"type": "enabled", "budget_tokens": 2000},
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    assert body["extra_body"]["thinking"] == {"type": "enabled"}
    assert body["tool_choice"] == "auto"


def test_build_request_body_forced_tool_choice_downgrades_to_auto(
    deepseek_provider,
):
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [{"role": "user", "content": "x"}],
            "tool_choice": {"type": "tool", "name": "Read"},
            "tools": [
                {
                    "name": "Read",
                    "description": "Read a file",
                    "input_schema": {"type": "object", "properties": {}},
                }
            ],
            "thinking": {"type": "enabled", "budget_tokens": 2000},
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    assert body["extra_body"]["thinking"] == {"type": "enabled"}
    assert body["tool_choice"] == "auto"


def test_build_request_body_encodes_reasoning_off():
    provider = DeepSeekProvider(
        make_provider_config(
            api_key="k",
            base_url=DEEPSEEK_DEFAULT_BASE,
        ),
        admission=immediate_admission(),
    )
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [{"role": "user", "content": "x"}],
            "thinking": {"type": "enabled", "budget_tokens": 1},
        }
    )
    body = provider._chat._build_request_body(request, reasoning=REASONING_OFF)
    assert body["extra_body"]["thinking"] == {"type": "disabled"}
    assert "stream_options" not in body


def test_non_tool_thinking_survives_conversion(deepseek_provider):
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "thinking",
                            "thinking": "plain",
                            "signature": None,
                        },
                        {"type": "text", "text": "out"},
                    ],
                }
            ],
        }
    )
    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )
    assert body["messages"][0] == {
        "role": "assistant",
        "content": "out",
        "reasoning_content": "plain",
    }


def test_redacted_thinking_is_kept_until_destination_preparation(deepseek_provider):
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {"type": "redacted_thinking", "data": "opaque"},
                        {"type": "text", "text": "out"},
                    ],
                }
            ],
        }
    )
    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )
    assert body["messages"][0]["reasoning_details"] == [
        {"type": "reasoning.encrypted", "data": "opaque"}
    ]
    assert request.model_dump()["messages"][0]["content"][0]["data"] == "opaque"


def test_tool_history_with_replayable_thinking_preserves_thinking(deepseek_provider):
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "thinking",
                            "thinking": "hidden",
                            "signature": "sig_123",
                        },
                        {"type": "redacted_thinking", "data": "opaque"},
                        {
                            "type": "tool_use",
                            "id": "t1",
                            "name": "Read",
                            "input": {"file_path": "x"},
                        },
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "t1",
                            "content": "ok",
                        }
                    ],
                },
            ],
            "thinking": {"type": "enabled", "budget_tokens": 2000},
            "context_management": {
                "edits": [{"type": "clear_thinking_20251015", "keep": "all"}]
            },
            "output_config": {"effort": "high"},
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    assert body["reasoning_effort"] == "high"
    assert "context_management" not in body
    assert "output_config" not in body
    assistant = body["messages"][0]
    assert assistant["content"] == ""
    assert assistant["reasoning_content"] == "hidden"
    assert assistant["tool_calls"][0]["function"]["name"] == "Read"
    assert assistant["tool_calls"][0]["function"]["arguments"] == '{"file_path": "x"}'
    assert body["messages"][1] == {
        "role": "tool",
        "tool_call_id": "t1",
        "content": "ok",
    }


def test_tool_history_with_unsigned_thinking_preserves_thinking(deepseek_provider):
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {"type": "thinking", "thinking": "plain"},
                        {
                            "type": "tool_use",
                            "id": "t1",
                            "name": "Read",
                            "input": {"file_path": "x"},
                        },
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "t1",
                            "content": "ok",
                        }
                    ],
                },
            ],
            "thinking": {"type": "enabled"},
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    assert body["extra_body"]["thinking"] == {"type": "enabled"}
    assert body["messages"][0]["reasoning_content"] == "plain"


def test_tool_history_without_thinking_keeps_selected_effort(deepseek_provider):
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "tool_use",
                            "id": "t1",
                            "name": "Read",
                            "input": {"file_path": "x"},
                        },
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "t1",
                            "content": "ok",
                        }
                    ],
                },
            ],
            "tools": [
                {
                    "name": "Read",
                    "description": "Read a file",
                    "input_schema": {"type": "object", "properties": {}},
                }
            ],
            "tool_choice": {"type": "auto"},
            "thinking": {"type": "enabled", "budget_tokens": 2000},
            "context_management": {
                "edits": [
                    {"type": "clear_thinking_20251015", "keep": "all"},
                    {"type": "other_edit", "keep": "all"},
                ],
                "other": True,
            },
            "output_config": {"effort": "high", "format": "text"},
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    assert body["reasoning_effort"] == "high"
    assert body["extra_body"].get("thinking") != {"type": "disabled"}
    assert body["messages"][0]["reasoning_content"] == ""
    assert "context_management" not in body
    assert "output_config" not in body
    assert body["tools"][0]["function"]["name"] == "Read"
    assert body["tool_choice"] == "auto"
    assert body["messages"][0]["tool_calls"][0]["function"]["name"] == "Read"
    assert body["messages"][1]["role"] == "tool"


def test_tool_history_with_empty_thinking_preserves_reasoning_state(deepseek_provider):
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {"type": "thinking", "thinking": ""},
                        {
                            "type": "tool_use",
                            "id": "t1",
                            "name": "Read",
                            "input": {"file_path": "x"},
                        },
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "t1",
                            "content": "ok",
                        }
                    ],
                },
            ],
            "thinking": {"type": "enabled"},
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    assert body["extra_body"]["thinking"] == {"type": "enabled"}
    assert body["messages"][0]["reasoning_content"] == ""
    assert body["messages"][0]["tool_calls"][0]["function"]["name"] == "Read"


def test_tool_history_with_empty_top_level_reasoning_preserves_reasoning_state(
    deepseek_provider,
):
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "tool_use",
                            "id": "t1",
                            "name": "Read",
                            "input": {"file_path": "x"},
                        },
                    ],
                    "reasoning_content": "",
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "t1",
                            "content": "ok",
                        }
                    ],
                },
            ],
            "thinking": {"type": "enabled"},
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    assert body["extra_body"]["thinking"] == {"type": "enabled"}
    assert body["messages"][0]["reasoning_content"] == ""
    assert body["messages"][0]["tool_calls"][0]["function"]["name"] == "Read"


def test_thinking_off_preserves_historical_reasoning():
    provider = DeepSeekProvider(
        make_provider_config(
            api_key="k",
            base_url=DEEPSEEK_DEFAULT_BASE,
        ),
        admission=immediate_admission(),
    )
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {"type": "thinking", "thinking": "sec"},
                        {"type": "text", "text": "hi"},
                    ],
                }
            ],
        }
    )
    body = provider._chat._build_request_body(request, reasoning=REASONING_OFF)
    assert body["extra_body"]["thinking"] == {"type": "disabled"}
    assert body["messages"][0]["reasoning_content"] == "sec"


def test_thinking_off_still_replays_required_tool_reasoning():
    provider = DeepSeekProvider(
        make_provider_config(
            api_key="k",
            base_url=DEEPSEEK_DEFAULT_BASE,
        ),
        admission=immediate_admission(),
    )
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {"type": "thinking", "thinking": "required"},
                        {
                            "type": "tool_use",
                            "id": "t1",
                            "name": "Read",
                            "input": {"file_path": "x"},
                        },
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "t1",
                            "content": "ok",
                        }
                    ],
                },
            ],
        }
    )

    body = provider._chat._build_request_body(request, reasoning=REASONING_OFF)

    assert body["extra_body"]["thinking"] == {"type": "disabled"}
    assert body["messages"][0]["reasoning_content"] == "required"


def test_passthrough_tool_use_and_result(deepseek_provider):
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "tool_use",
                            "id": "t1",
                            "name": "n",
                            "input": {"a": 1},
                        }
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "t1",
                            "content": "ok",
                        }
                    ],
                },
            ],
        }
    )
    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )
    assert body["messages"][0]["tool_calls"][0]["function"]["name"] == "n"
    assert body["messages"][1]["role"] == "tool"


@pytest.mark.parametrize(
    "model",
    [
        "deepseek-flash",
        "deepseek-v4-flash-vision-exp",
        "deepseek-v4-flash",
        "deepseek-chat",
        "gateway/future-model",
    ],
)
@pytest.mark.parametrize(
    ("source", "expected_url"),
    [
        (
            {"type": "base64", "media_type": "image/png", "data": "YQ=="},
            "data:image/png;base64,YQ==",
        ),
        (
            {"type": "url", "url": "https://images.example.test/shot.png"},
            "https://images.example.test/shot.png",
        ),
    ],
)
def test_forwards_user_image_for_any_model(
    deepseek_provider, model, source, expected_url
):
    request = MessagesRequest(
        model=model,
        messages=[
            Message(
                role="user",
                content=[ContentBlockImage(type="image", source=source)],
            )
        ],
    )
    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )
    assert body["model"] == model
    assert body["messages"] == [
        {
            "role": "user",
            "content": [{"type": "image_url", "image_url": {"url": expected_url}}],
        }
    ]


def test_vision_model_strips_user_document():
    """Vision models still omit documents; conversion has no document parts."""
    request = MessagesRequest(
        model="deepseek-v4-flash-vision-exp",
        messages=[
            Message(
                role="user",
                content=[
                    ContentBlockDocument(
                        type="document",
                        source={
                            "type": "base64",
                            "media_type": "application/pdf",
                            "data": "YQ==",
                        },
                    )
                ],
            )
        ],
    )
    provider = DeepSeekProvider(
        make_provider_config(
            api_key="k",
            base_url=DEEPSEEK_DEFAULT_BASE,
        ),
        admission=immediate_admission(),
    )
    provider.stream_messages(request, reasoning=REASONING_ON)
    body = provider._chat._build_request_body(request, reasoning=reasoning_for(request))
    content = body["messages"][0]["content"]
    assert content
    if isinstance(content, str):
        lowered = content.lower()
    else:
        texts = [
            part.get("text", "")
            for part in content
            if isinstance(part, dict) and part.get("type") == "text"
        ]
        lowered = "\n".join(texts).lower()
        assert not any(
            isinstance(part, dict) and part.get("type") == "image_url"
            for part in content
        )
    assert "attachment omitted" in lowered
    assert "document inputs" in lowered
    assert "image" not in lowered


def test_startup_rejects_mcp_servers():
    request = MessagesRequest(
        model="m",
        messages=[Message(role="user", content="x")],
        mcp_servers=[{"type": "url", "url": "https://x"}],
    )
    provider = DeepSeekProvider(
        make_provider_config(
            api_key="k",
            base_url=DEEPSEEK_DEFAULT_BASE,
        ),
        admission=immediate_admission(),
    )
    with pytest.raises(InvalidRequestError, match="mcp_servers"):
        provider.stream_messages(request)


def test_startup_rejects_listed_server_tools_in_tools_list():
    request = MessagesRequest(
        model="m",
        messages=[Message(role="user", content="x")],
        tools=[Tool(name="web_search", type="web_search_20250305", input_schema={})],
    )
    provider = DeepSeekProvider(
        make_provider_config(
            api_key="k",
            base_url=DEEPSEEK_DEFAULT_BASE,
        ),
        admission=immediate_admission(),
    )
    with pytest.raises(InvalidRequestError, match="web_search"):
        provider.stream_messages(request)


def test_startup_preserves_completed_server_tool_history():
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "server_tool_use",
                            "id": "s1",
                            "name": "web_search",
                            "input": {"q": "a"},
                        },
                        {
                            "type": "web_search_tool_result",
                            "tool_use_id": "s1",
                            "content": [],
                        },
                    ],
                }
            ],
        }
    )
    provider = DeepSeekProvider(
        make_provider_config(
            api_key="k",
            base_url=DEEPSEEK_DEFAULT_BASE,
        ),
        admission=immediate_admission(),
    )
    provider.stream_messages(request)
    body = provider._chat._build_request_body(request)
    assert "[Earlier tool record]" in body["messages"][0]["content"]


def test_non_tool_top_level_reasoning_survives_conversion(deepseek_provider):
    request = MessagesRequest(
        model="m",
        messages=[
            Message(
                role="assistant",
                content="hi",
                reasoning_content="r",
            )
        ],
    )
    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )
    assert body["messages"][0] == {
        "role": "assistant",
        "content": "hi",
        "reasoning_content": "r",
    }


def test_tool_call_top_level_reasoning_is_replayed(deepseek_provider):
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "tool_use",
                            "id": "t1",
                            "name": "Read",
                            "input": {"file_path": "x"},
                        }
                    ],
                    "reasoning_content": "required",
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "t1",
                            "content": "ok",
                        }
                    ],
                },
            ],
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    assert body["messages"][0]["reasoning_content"] == "required"


@pytest.mark.asyncio
async def test_wire_messages_keep_prefix_and_effort_when_old_reasoning_is_absent(
    deepseek_provider,
):
    prefix_messages = [
        {"role": "user", "content": "first"},
        {
            "role": "assistant",
            "content": [
                {"type": "thinking", "thinking": "ordinary reasoning"},
                {"type": "text", "text": "answer"},
            ],
        },
        {"role": "user", "content": "use the first tool"},
        {
            "role": "assistant",
            "content": [
                {"type": "thinking", "thinking": "required tool reasoning"},
                {
                    "type": "tool_use",
                    "id": "t1",
                    "name": "Read",
                    "input": {"file_path": "one"},
                },
            ],
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": "t1",
                    "content": "one",
                }
            ],
        },
        {"role": "user", "content": "use the second tool"},
    ]
    continued_messages = [
        *prefix_messages,
        {
            "role": "assistant",
            "content": [
                {
                    "type": "tool_use",
                    "id": "t2",
                    "name": "Read",
                    "input": {"file_path": "two"},
                }
            ],
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": "t2",
                    "content": "two",
                }
            ],
        },
    ]

    def build(messages: list[dict]) -> dict:
        request = MessagesRequest.model_validate(
            {
                "model": "deepseek-v4-pro",
                "messages": messages,
                "thinking": {"type": "enabled"},
            }
        )
        return deepseek_provider._chat._build_request_body(
            request, reasoning=reasoning_for(request)
        )

    first_wire = await capture_openai_chat_wire_body(build(prefix_messages))
    continued_wire = await capture_openai_chat_wire_body(build(continued_messages))
    first_messages = first_wire["messages"]
    continued = continued_wire["messages"]

    assert continued[: len(first_messages)] == first_messages
    assistant_messages = [
        message for message in first_messages if message["role"] == "assistant"
    ]
    assert assistant_messages[0]["reasoning_content"] == "ordinary reasoning"
    assert assistant_messages[1]["reasoning_content"] == "required tool reasoning"
    assert first_wire["thinking"] == {"type": "enabled"}
    assert continued_wire["thinking"] == {"type": "enabled"}


@pytest.mark.asyncio
async def test_stream_uses_chat_completions_and_maps_cache_usage(deepseek_provider):
    request = MessagesRequest(
        model="m",
        messages=[Message(role="user", content="hi")],
    )

    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=3,
                prompt_tokens=30,
                prompt_cache_hit_tokens=10,
                prompt_cache_miss_tokens=20,
            ),
        )

    create = AsyncMock(return_value=SDKStreamDouble(fake_stream()))
    with patch.object(deepseek_provider._client.chat.completions, "create", create):
        chunks = [
            chunk
            async for chunk in deepseek_provider.stream_messages(
                request, input_tokens=7, request_id="r1"
            )
        ]

    create.assert_awaited_once()
    await_args = create.await_args
    assert await_args is not None
    assert await_args.kwargs["model"] == "m"
    assert await_args.kwargs["stream"] is True
    assert await_args.kwargs["stream_options"] == {"include_usage": True}
    parsed = parse_sse_text("".join(chunks))
    usage = next(
        event.data["usage"] for event in parsed if event.event == "message_delta"
    )
    assert "cache_creation_input_tokens" not in usage
    assert usage == {
        "input_tokens": 20,
        "output_tokens": 3,
        "cache_read_input_tokens": 10,
    }


@pytest.mark.asyncio
async def test_responses_stream_maps_deepseek_cache_usage(deepseek_provider):
    request = OpenAIResponsesRequest(model="m", input="hi")

    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=3,
                prompt_tokens=30,
                model_extra={
                    "prompt_cache_hit_tokens": 10,
                    "prompt_cache_miss_tokens": 20,
                },
            ),
        )

    create = AsyncMock(return_value=SDKStreamDouble(fake_stream()))
    with patch.object(deepseek_provider._client.chat.completions, "create", create):
        chunks = [
            chunk
            async for chunk in deepseek_provider.stream_responses(
                request, input_tokens=7, request_id="r1"
            )
        ]

    parsed = parse_sse_text("".join(chunks))
    completed = next(
        event.data["response"]
        for event in parsed
        if event.event == "response.completed"
    )
    assert completed["usage"] == {
        "input_tokens": 30,
        "input_tokens_details": {"cached_tokens": 10},
        "output_tokens": 3,
        "output_tokens_details": {"reasoning_tokens": 0},
        "total_tokens": 33,
    }


def test_preserves_extra_body_for_openai_chat_request(deepseek_provider):
    raw = {
        "model": "m",
        "max_tokens": 3,
        "messages": [{"role": "user", "content": "x"}],
        "extra_body": {"note": 1},
    }
    r = MessagesRequest.model_validate(raw)
    body = deepseek_provider._chat._build_request_body(r, reasoning=reasoning_for(r))
    assert body["extra_body"] == {"note": 1}


def test_normalizes_tool_result_content_array_to_string(deepseek_provider):
    """Test that tool_result content arrays are normalized to strings for DeepSeek API."""
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "tool_use",
                            "id": "t1",
                            "name": "list_dir",
                            "input": {"path": "/"},
                        }
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "t1",
                            "content": [
                                {"type": "text", "text": "file1.txt"},
                                {"type": "text", "text": "file2.txt"},
                            ],
                        }
                    ],
                },
            ],
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    tool_result = body["messages"][1]
    assert tool_result["role"] == "tool"
    assert isinstance(tool_result["content"], str)
    assert "file1.txt" in tool_result["content"]
    assert "file2.txt" in tool_result["content"]


def test_strips_document_blocks_for_deepseek(deepseek_provider):
    """Document blocks (e.g. PDFs from Claude Code) are stripped since DeepSeek can't process them."""
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "t1",
                            "content": "PDF text extracted",
                        },
                        {
                            "type": "document",
                            "source": {"type": "file", "file_id": "file_abc"},
                            "cache_control": {"type": "ephemeral"},
                        },
                    ],
                },
            ],
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    assert body["messages"][0] == {
        "role": "tool",
        "tool_call_id": "t1",
        "content": "PDF text extracted",
    }


def test_preserves_user_image_and_text_order(deepseek_provider):
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "user",
                    "content": [
                        {"type": "text", "text": "describe this"},
                        {
                            "type": "image",
                            "source": {
                                "type": "base64",
                                "media_type": "image/png",
                                "data": "YQ==",
                            },
                        },
                        {"type": "text", "text": "then explain"},
                    ],
                },
            ],
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    assert body["messages"] == [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "describe this"},
                {
                    "type": "image_url",
                    "image_url": {"url": "data:image/png;base64,YQ=="},
                },
                {"type": "text", "text": "then explain"},
            ],
        }
    ]


def test_normalizes_tool_result_content_dict_to_string(deepseek_provider):
    """Test that tool_result content dicts are normalized to JSON strings."""
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "tool_use",
                            "id": "t1",
                            "name": "get_data",
                            "input": {},
                        }
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "t1",
                            "content": {"status": "success", "data": [1, 2, 3]},
                        }
                    ],
                },
            ],
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    tool_result = body["messages"][1]
    assert tool_result["role"] == "tool"
    assert isinstance(tool_result["content"], str)
    assert "status" in tool_result["content"]
    assert "success" in tool_result["content"]


@pytest.mark.parametrize("model", ["deepseek-flash", "deepseek-v4-flash-vision-exp"])
def test_preserves_image_and_text_inside_tool_result(deepseek_provider, model):
    request = MessagesRequest.model_validate(
        {
            "model": model,
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "tool_use",
                            "id": "t1",
                            "name": "Read",
                            "input": {"path": "shot.png"},
                        }
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "t1",
                            "content": [
                                {"type": "text", "text": "screenshot saved"},
                                {
                                    "type": "image",
                                    "source": {
                                        "type": "base64",
                                        "media_type": "image/png",
                                        "data": "YQ==",
                                    },
                                },
                                {"type": "text", "text": "inspect the screenshot"},
                            ],
                        }
                    ],
                },
            ],
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    assert [message["role"] for message in body["messages"]] == [
        "assistant",
        "tool",
        "assistant",
        "user",
    ]
    assert body["messages"][1] == {
        "role": "tool",
        "tool_call_id": "t1",
        "content": "[Image-bearing tool output follows in user content.]",
    }
    assert is_synthetic_chat_tool_turn_boundary(body["messages"][2])
    assert body["messages"][3]["content"] == [
        {"type": "text", "text": 'Image-bearing output for tool call "t1":'},
        {"type": "text", "text": "screenshot saved"},
        {"type": "image_url", "image_url": {"url": "data:image/png;base64,YQ=="}},
        {"type": "text", "text": "inspect the screenshot"},
    ]


def test_image_only_tool_result_reaches_user_content(deepseek_provider):
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "tool_use",
                            "id": "t1",
                            "name": "Screenshot",
                            "input": {},
                        }
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "t1",
                            "content": [
                                {
                                    "type": "image",
                                    "source": {
                                        "type": "url",
                                        "url": "https://images.example.test/shot.png",
                                    },
                                },
                            ],
                        }
                    ],
                },
            ],
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    assert [message["role"] for message in body["messages"]] == [
        "assistant",
        "tool",
        "assistant",
        "user",
    ]
    assert body["messages"][1] == {
        "role": "tool",
        "tool_call_id": "t1",
        "content": "[Image-bearing tool output follows in user content.]",
    }
    assert is_synthetic_chat_tool_turn_boundary(body["messages"][2])
    assert body["messages"][3]["content"] == [
        {"type": "text", "text": 'Image-bearing output for tool call "t1":'},
        {
            "type": "image_url",
            "image_url": {"url": "https://images.example.test/shot.png"},
        },
    ]


@pytest.mark.parametrize(
    "tool_content",
    [
        [],
        [{"type": "document", "source": {"type": "file", "file_id": "file_pdf"}}],
    ],
)
def test_document_or_empty_tool_result_keeps_placeholder(
    deepseek_provider,
    tool_content,
):
    """Document-only and empty tool results retain their omission marker."""
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "tool_use",
                            "id": "t1",
                            "name": "Read",
                            "input": {"file_path": "paper.pdf"},
                        }
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "t1",
                            "content": tool_content,
                        }
                    ],
                },
            ],
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    tool_result = body["messages"][1]
    assert tool_result["role"] == "tool"
    assert isinstance(tool_result["content"], str)
    assert "attachment omitted" in tool_result["content"].lower()
    assert "document inputs" in tool_result["content"].lower()
    assert "image omitted" not in tool_result["content"].lower()


def test_document_only_message_replaced_with_placeholder(deepseek_provider):
    """A top-level document-only message remains non-empty after stripping."""
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "document",
                            "source": {"type": "file", "file_id": "file_pdf"},
                        },
                    ],
                },
            ],
        }
    )

    body = deepseek_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    content = body["messages"][0]["content"]
    assert "attachment omitted" in content.lower()
    assert "document inputs" in content.lower()


def test_warns_when_stripping_document_blocks(deepseek_provider, caplog):
    """A warning identifies documents omitted from user and tool content."""
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "user",
                    "content": [
                        {"type": "text", "text": "look"},
                        {
                            "type": "document",
                            "source": {
                                "type": "base64",
                                "media_type": "application/pdf",
                                "data": "abc",
                            },
                        },
                    ],
                },
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "tool_use",
                            "id": "t1",
                            "name": "Screenshot",
                            "input": {},
                        }
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "t1",
                            "content": [
                                {
                                    "type": "document",
                                    "source": {
                                        "type": "base64",
                                        "media_type": "application/pdf",
                                        "data": "abc",
                                    },
                                },
                            ],
                        }
                    ],
                },
            ],
        }
    )

    with caplog.at_level(logging.WARNING):
        deepseek_provider._chat._build_request_body(
            request, reasoning=reasoning_for(request)
        )

    warnings = [r for r in caplog.records if r.levelno == logging.WARNING]
    assert any("stripped unsupported document blocks" in r.message for r in warnings)
    assert not any("no vision" in r.message for r in warnings)


@pytest.mark.parametrize(
    "content",
    [
        "hello",
        [
            {
                "type": "image",
                "source": {
                    "type": "url",
                    "url": "https://images.example.test/shot.png",
                },
            }
        ],
    ],
)
def test_no_warning_when_no_documents(deepseek_provider, caplog, content):
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [{"role": "user", "content": content}],
        }
    )

    with caplog.at_level(logging.WARNING):
        deepseek_provider._chat._build_request_body(
            request, reasoning=reasoning_for(request)
        )

    assert not any(r.levelno == logging.WARNING for r in caplog.records)


def test_parallel_tool_results_close_before_image_content(deepseek_provider):
    request = MessagesRequest.model_validate(
        {
            "model": "deepseek-flash",
            "tools": [{"name": "Read", "input_schema": {"type": "object"}}],
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {"type": "tool_use", "id": "t1", "name": "Read", "input": {}},
                        {"type": "tool_use", "id": "t2", "name": "Read", "input": {}},
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "t2",
                            "content": "text result",
                        },
                        {
                            "type": "tool_result",
                            "tool_use_id": "t1",
                            "content": [
                                {
                                    "type": "image",
                                    "source": {
                                        "type": "base64",
                                        "media_type": "image/png",
                                        "data": "YQ==",
                                    },
                                }
                            ],
                        },
                    ],
                },
            ],
        }
    )

    body = deepseek_provider._chat._build_request_body(request, reasoning=REASONING_ON)

    messages = body["messages"]
    assert [message["role"] for message in messages] == [
        "assistant",
        "tool",
        "tool",
        "assistant",
        "user",
    ]
    assert [message["tool_call_id"] for message in messages[1:3]] == ["t1", "t2"]
    assert (
        messages[1]["content"] == "[Image-bearing tool output follows in user content.]"
    )
    assert messages[2]["content"] == "text result"
    assert is_synthetic_chat_tool_turn_boundary(messages[3])
    assert messages[3]["reasoning_content"] == ""
    assert messages[4]["content"] == [
        {"type": "text", "text": 'Image-bearing output for tool call "t1":'},
        {"type": "image_url", "image_url": {"url": "data:image/png;base64,YQ=="}},
    ]


@pytest.mark.parametrize("inside_tool_result", [False, True])
def test_mixed_attachment_content_omits_only_document(
    deepseek_provider, inside_tool_result
):
    content = [
        {
            "type": "image",
            "source": {"type": "base64", "media_type": "image/png", "data": "YQ=="},
        },
        {"type": "document", "source": {"type": "file", "file_id": "private_pdf"}},
    ]
    messages = [{"role": "user", "content": content}]
    if inside_tool_result:
        messages = [
            {
                "role": "assistant",
                "content": [
                    {"type": "tool_use", "id": "t1", "name": "Read", "input": {}}
                ],
            },
            {
                "role": "user",
                "content": [
                    {"type": "tool_result", "tool_use_id": "t1", "content": content}
                ],
            },
        ]
    request = MessagesRequest.model_validate(
        {"model": "deepseek-flash", "messages": messages}
    )
    original = request.model_dump()

    body = deepseek_provider._chat._build_request_body(request, reasoning=REASONING_OFF)

    images = [
        part
        for message in body["messages"]
        if isinstance(message.get("content"), list)
        for part in message["content"]
        if part.get("type") == "image_url"
    ]
    assert images == [
        {"type": "image_url", "image_url": {"url": "data:image/png;base64,YQ=="}}
    ]
    assert "private_pdf" not in json.dumps(body["messages"])
    assert request.model_dump() == original


@pytest.mark.parametrize(
    ("source", "error"),
    [
        (
            {
                "type": "base64",
                "media_type": "image/png",
                "data": "private_invalid_base64",
            },
            "Image data is not valid base64",
        ),
        (
            {"type": "file", "file_id": "private_file"},
            "cannot cross this protocol boundary",
        ),
        ({"type": "url", "url": ""}, "Image URL must be a non-empty string"),
    ],
)
def test_rejects_unportable_image_without_exposing_source(
    deepseek_provider, source, error
):
    request = MessagesRequest(
        model="deepseek-flash",
        messages=[
            Message(
                role="user", content=[ContentBlockImage(type="image", source=source)]
            )
        ],
    )

    with pytest.raises(InvalidRequestError, match=error) as exc_info:
        deepseek_provider._chat._build_request_body(request, reasoning=REASONING_OFF)

    assert "private_" not in str(exc_info.value)


def test_shared_conversion_rejects_assistant_image(deepseek_provider):
    image = {
        "type": "image",
        "source": {"type": "url", "url": "https://images.example.test/shot.png"},
    }
    request = MessagesRequest.model_validate(
        {
            "model": "deepseek-flash",
            "messages": [{"role": "assistant", "content": [image]}],
        }
    )

    with pytest.raises(InvalidRequestError, match="Assistant image blocks"):
        deepseek_provider._chat._build_request_body(request, reasoning=REASONING_OFF)


@pytest.mark.asyncio
@pytest.mark.parametrize("wire_api", ["messages", "responses"])
async def test_upstream_image_rejection_preserves_image_and_fails_once(
    deepseek_provider, wire_api
):
    if wire_api == "messages":
        request = MessagesRequest(
            model="deepseek-flash",
            messages=[
                Message(
                    role="user",
                    content=[
                        ContentBlockImage(
                            type="image",
                            source={
                                "type": "base64",
                                "media_type": "image/png",
                                "data": "YQ==",
                            },
                        )
                    ],
                )
            ],
        )
        stream = deepseek_provider.stream_messages(request, reasoning=REASONING_OFF)
    else:
        responses_request = OpenAIResponsesRequest.model_validate(
            {
                "model": "deepseek-flash",
                "input": [
                    {
                        "role": "user",
                        "content": [
                            {
                                "type": "input_image",
                                "image_url": "data:image/png;base64,YQ==",
                            }
                        ],
                    }
                ],
            }
        )
        stream = deepseek_provider.stream_responses(
            responses_request, reasoning=REASONING_OFF
        )
    error = BadRequestError(
        "This model does not support image inputs",
        response=httpx2.Response(
            400,
            request=httpx2.Request("POST", "https://provider.invalid/chat/completions"),
        ),
        body={
            "error": {
                "type": "invalid_request_error",
                "message": "This model does not support image inputs",
            }
        },
    )

    try:
        with (
            patch.object(
                deepseek_provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                side_effect=error,
            ) as create,
            pytest.raises(ExecutionFailure) as exc_info,
        ):
            async for _ in stream:
                pass

        assert create.call_count == 1
        assert create.call_args.kwargs["messages"] == [
            {
                "role": "user",
                "content": [
                    {
                        "type": "image_url",
                        "image_url": {"url": "data:image/png;base64,YQ=="},
                    }
                ],
            }
        ]
        assert exc_info.value.kind is FailureKind.INVALID_REQUEST
        assert exc_info.value.status_code == 400
        assert exc_info.value.retryable is False
        assert "does not support image inputs" in exc_info.value.message
    finally:
        await deepseek_provider.cleanup()