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
16.0 KB
Raw Blame
"""Tests for the OpenRouter OpenAI-chat provider."""

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

import httpx2
import openai
import pytest

from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.anthropic.stream_contracts import (
    parse_sse_text,
    text_content,
    thinking_content,
)
from free_claude_code.core.failures import FailureKind
from free_claude_code.core.model_capabilities import ModelInputModality
from free_claude_code.providers.failure_policy import classify_provider_failure
from free_claude_code.providers.open_router import OpenRouterProvider
from free_claude_code.providers.openai_chat import OpenAIChatProvider
from tests.providers.request_factory import make_messages_request
from tests.providers.support import (
    REASONING_OFF,
    SDKStreamDouble,
    immediate_admission,
    make_provider_config,
    reasoning_for,
)


def image_routing_error_body():
    return {
        "message": "No endpoints found that support image input",
        "code": 404,
        "metadata": {"failed_routing_step": "Filter by Image Support"},
    }


def routing_error(body, status=404):
    return openai.APIStatusError(
        "OpenRouter routing failed",
        response=httpx2.Response(
            status,
            request=httpx2.Request(
                "POST", "https://openrouter.ai/api/v1/chat/completions"
            ),
        ),
        body=body,
    )


@pytest.mark.parametrize("wrapped", [False, True])
@pytest.mark.parametrize(
    "message", ["No endpoints found that support image input", "Image routing rejected"]
)
def test_image_routing_failure_explains_unsupported_input(
    open_router_provider, wrapped, message
):
    body = {**image_routing_error_body(), "message": message}
    error = routing_error({"error": body} if wrapped else body)
    failure = classify_provider_failure(
        error,
        provider_name="OPENROUTER",
        read_timeout_s=30,
        request_id="req_image",
        provider_failure_override=open_router_provider._chat._behavior.failure_override,
    )
    assert failure.kind == FailureKind.INVALID_REQUEST
    assert failure.status_code == 400
    assert failure.retryable is False
    assert "Remove the image" in failure.message
    assert "image-capable" in failure.message
    assert message in failure.message
    assert "HTTP 404" in failure.message
    assert "req_image" in failure.message
    assert (
        classify_provider_failure(
            error, provider_name="OTHER", read_timeout_s=30, request_id=None
        ).status_code
        == 404
    )


@pytest.mark.parametrize(
    "body",
    [
        {"message": "Model not found", "code": 404},
        {**image_routing_error_body(), "metadata": {}},
        {
            **image_routing_error_body(),
            "metadata": {"failed_routing_step": "Filter by Data Policy"},
        },
        {**image_routing_error_body(), "metadata": None},
        {**image_routing_error_body(), "code": "404"},
        {**image_routing_error_body(), "code": 404.0},
        {**image_routing_error_body(), "code": 400},
        {**image_routing_error_body(), "message": None},
        {**image_routing_error_body(), "error": image_routing_error_body()},
        {"error": "malformed"},
        "No endpoints found that support image input",
        None,
    ],
)
def test_unrelated_routing_errors_keep_shared_policy(open_router_provider, body):
    error = routing_error(body)
    override = open_router_provider._chat._behavior.failure_override
    assert override(error) is None
    failure = classify_provider_failure(
        error,
        provider_name="OPENROUTER",
        read_timeout_s=30,
        request_id=None,
        provider_failure_override=override,
    )
    assert failure.status_code == 404


@pytest.mark.parametrize("status", [400, 401, 403, 429, 500, 200])
def test_image_metadata_does_not_override_other_http_status(
    open_router_provider, status
):
    assert (
        open_router_provider._chat._behavior.failure_override(
            routing_error(image_routing_error_body(), status)
        )
        is None
    )


class AsyncStream(SDKStreamDouble):
    def __init__(self, chunks):
        self._chunks = chunks
        self.closed = False
        super().__init__(self._iter(), close=self.aclose)

    async def _iter(self):
        for chunk in self._chunks:
            yield chunk

    async def aclose(self):
        self.closed = True


def make_request(**overrides):
    return make_messages_request("moonshotai/kimi-k2.6:free", **overrides)


@pytest.fixture
def open_router_provider():
    return OpenRouterProvider(
        make_provider_config(
            api_key="test_openrouter_key",
            base_url="https://openrouter.ai/api/v1",
        ),
        admission=immediate_admission(),
    )


def _chunk(
    *,
    content: str | None = None,
    reasoning_content: str | None = None,
    reasoning_details: list[dict] | None = None,
    finish_reason: str | None = None,
):
    delta = SimpleNamespace(
        content=content,
        reasoning_content=reasoning_content,
        tool_calls=None,
    )
    if reasoning_details is not None:
        delta.reasoning_details = reasoning_details
    choice = SimpleNamespace(delta=delta, finish_reason=finish_reason)
    return SimpleNamespace(choices=[choice], usage=None)


def test_init_uses_openai_chat_provider(open_router_provider):
    assert isinstance(open_router_provider, OpenAIChatProvider)
    assert open_router_provider._api_key == "test_openrouter_key"
    assert open_router_provider._base_url == "https://openrouter.ai/api/v1"


def test_build_request_body_uses_openai_chat_shape(open_router_provider):
    body = open_router_provider._chat._build_request_body(make_request())

    assert body["model"] == "moonshotai/kimi-k2.6:free"
    assert body["temperature"] == 0.5
    assert body["messages"] == [
        {"role": "system", "content": "System prompt"},
        {"role": "user", "content": "Hello"},
    ]
    assert body["max_tokens"] == 100
    assert "extra_body" not in body


def test_build_request_body_default_max_tokens(open_router_provider):
    body = open_router_provider._chat._build_request_body(make_request(max_tokens=None))

    assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS


def test_openrouter_extra_body_rejects_overriding_reserved_fields(
    open_router_provider,
):
    with pytest.raises(InvalidRequestError, match="model"):
        open_router_provider._chat._build_request_body(
            make_request(extra_body={"model": "hijack"})
        )


def test_openrouter_extra_body_allows_provider_keys(open_router_provider):
    body = open_router_provider._chat._build_request_body(
        make_request(extra_body={"transforms": ["no-web"], "plugins": []}),
        reasoning=REASONING_OFF,
    )

    assert body["extra_body"] == {
        "transforms": ["no-web"],
        "plugins": [],
        "reasoning": {"enabled": False},
    }


def test_build_request_body_disables_reasoning_when_client_disables_it(
    open_router_provider,
):
    request = make_request(thinking={"type": "disabled"})
    body = open_router_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    assert body["extra_body"]["reasoning"] == {"enabled": False}


def test_build_request_body_maps_thinking_budget_to_reasoning_max_tokens(
    open_router_provider,
):
    request = make_request(thinking={"type": "enabled", "budget_tokens": 4096})
    body = open_router_provider._chat._build_request_body(
        request, reasoning=reasoning_for(request)
    )

    assert body["extra_body"]["reasoning"] == {"max_tokens": 4096}


def test_build_request_body_replays_openrouter_reasoning_details(
    open_router_provider,
):
    detail = {"type": "reasoning.encrypted", "data": "opaque"}
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "redacted_thinking",
                            "data": '{"type":"reasoning.encrypted","data":"opaque"}',
                        },
                        {"type": "text", "text": "Need a tool."},
                    ],
                },
                {"role": "user", "content": "continue"},
            ],
        }
    )

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

    assistant = next(msg for msg in body["messages"] if msg["role"] == "assistant")
    assert assistant["reasoning_details"] == [detail]


def test_reasoning_details_skip_neutral_tool_turn_boundary(open_router_provider):
    first_detail = {"type": "reasoning.encrypted", "data": "first"}
    second_detail = {"type": "reasoning.encrypted", "data": "second"}
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "redacted_thinking",
                            "data": json.dumps(first_detail),
                        },
                        {
                            "type": "tool_use",
                            "id": "call_read",
                            "name": "Read",
                            "input": {},
                        },
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "call_read",
                            "content": "contents",
                        }
                    ],
                },
                {"role": "user", "content": "continue"},
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "redacted_thinking",
                            "data": json.dumps(second_detail),
                        },
                        {"type": "text", "text": "done"},
                    ],
                },
            ],
        }
    )

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

    assistants = [
        message for message in body["messages"] if message["role"] == "assistant"
    ]
    assert assistants[0]["reasoning_details"] == [first_detail]
    assert assistants[1] == {"role": "assistant", "content": " "}
    assert assistants[2]["reasoning_details"] == [second_detail]


def test_reasoning_details_preserve_redacted_only_assistant_after_tool(
    open_router_provider,
):
    first_detail = {"type": "reasoning.encrypted", "data": "first"}
    second_detail = {"type": "reasoning.encrypted", "data": "second"}
    request = MessagesRequest.model_validate(
        {
            "model": "m",
            "messages": [
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "redacted_thinking",
                            "data": json.dumps(first_detail),
                        },
                        {
                            "type": "tool_use",
                            "id": "call_read",
                            "name": "Read",
                            "input": {},
                        },
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "call_read",
                            "content": "contents",
                        }
                    ],
                },
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "redacted_thinking",
                            "data": json.dumps(second_detail),
                        }
                    ],
                },
                {"role": "user", "content": "continue"},
                {"role": "assistant", "content": "done"},
            ],
        }
    )

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

    assistants = [
        message for message in body["messages"] if message["role"] == "assistant"
    ]
    assert assistants[0]["reasoning_details"] == [first_detail]
    assert assistants[1] == {
        "role": "assistant",
        "content": " ",
        "reasoning_details": [second_detail],
    }
    assert "reasoning_details" not in assistants[2]


@pytest.mark.asyncio
async def test_stream_maps_reasoning_content_and_details(open_router_provider):
    redacted = {"type": "reasoning.encrypted", "data": "opaque"}
    stream = AsyncStream(
        [
            _chunk(reasoning_details=[{"type": "reasoning.text", "text": "plan "}]),
            _chunk(reasoning_content="plan "),
            _chunk(reasoning_details=[redacted]),
            _chunk(content="done", finish_reason="stop"),
        ]
    )
    with patch.object(
        open_router_provider._client.chat.completions,
        "create",
        new_callable=AsyncMock,
        return_value=stream,
    ):
        events = [
            event
            async for event in open_router_provider.stream_messages(make_request())
        ]

    event_text = "".join(events)
    parsed = parse_sse_text(event_text)
    assert thinking_content(parsed) == "plan "
    carriers = [
        event.data["content_block"]["data"]
        for event in parsed
        if event.event == "content_block_start"
        and event.data["content_block"]["type"] == "redacted_thinking"
    ]
    assert carriers == [redacted["data"]]
    assert text_content(parsed) == "done"
    assert stream.closed


@pytest.mark.asyncio
async def test_model_infos_filter_tool_models_and_thinking_metadata(
    open_router_provider,
):
    open_router_provider._client.models.list = AsyncMock(
        return_value=SimpleNamespace(
            data=[
                SimpleNamespace(
                    id="tool-model",
                    supported_parameters=["tools", "reasoning"],
                    architecture=SimpleNamespace(input_modalities=["text", "image"]),
                    context_length=262144,
                    top_provider=SimpleNamespace(
                        context_length=999999,
                        max_completion_tokens=32768,
                    ),
                ),
                SimpleNamespace(
                    id="tool-model-with-malformed-capabilities",
                    supported_parameters=["tools", 7],
                    architecture=SimpleNamespace(input_modalities=["text"]),
                ),
                SimpleNamespace(id="plain-model", supported_parameters=[]),
            ]
        )
    )

    infos = await open_router_provider.list_model_infos()

    assert infos == frozenset(
        {
            ProviderModelInfo(
                "tool-model",
                supports_thinking=True,
                input_modalities=frozenset(
                    {ModelInputModality.TEXT, ModelInputModality.IMAGE}
                ),
                context_window_tokens=262144,
                max_output_tokens=32768,
            ),
            ProviderModelInfo(
                "tool-model-with-malformed-capabilities",
                input_modalities=frozenset({ModelInputModality.TEXT}),
            ),
        }
    )


@pytest.mark.asyncio
async def test_cleanup_closes_openai_client(open_router_provider):
    open_router_provider._client = MagicMock()
    open_router_provider._client.close = AsyncMock()

    await open_router_provider.cleanup()

    open_router_provider._client.close.assert_awaited_once()