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
20.2 KB
Raw Blame
import json
import math

import pytest
from fastapi.testclient import TestClient

from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.config.api_keys import normalize_api_keys
from free_claude_code.config.custom_providers import CustomProviderDefinition
from free_claude_code.config.model_refs import ModelFallback
from free_claude_code.config.settings import Settings
from free_claude_code.core.model_capabilities import ModelInputModality
from tests.api.support import create_test_app, provider_manager_for_app


def _settings(
    *,
    model: str = "deepseek/deepseek-chat",
    model_fable: str | None = None,
    model_opus: str | None = "open_router/anthropic/claude-opus",
    model_haiku: str | None = "deepseek/deepseek-chat",
    model_fallbacks: tuple[ModelFallback, ...] | None = None,
) -> Settings:
    return Settings.model_construct(
        model=model,
        model_fable=model_fable,
        model_opus=model_opus,
        model_sonnet=None,
        model_haiku=model_haiku,
        model_fallbacks=model_fallbacks,
        proxy_auth_enabled=False,
        proxy_auth_token="freecc",
        deepseek_api_keys=normalize_api_keys("deepseek-key"),
        open_router_api_keys=normalize_api_keys("open-router-key"),
        wafer_api_keys=normalize_api_keys("wafer-key"),
    )


def _cache_models(app, provider_id: str, *model_ids: str) -> None:
    provider_manager_for_app(app).cache_model_infos(
        provider_id,
        {ProviderModelInfo(model_id) for model_id in model_ids},
    )


@pytest.mark.parametrize("view", ["messages", "responses"])
def test_context_fallback_round_trip_preserves_reported_capabilities(view):
    from free_claude_code.application.model_catalog import read_model_catalog
    from free_claude_code.cli.launchers.catalog_http import model_catalog_from_response
    from free_claude_code.cli.launchers.opencode_config import build_opencode_config

    app = create_test_app(_settings(model_opus=None))
    manager = provider_manager_for_app(app)
    manager.cache_model_infos(
        "deepseek", {ProviderModelInfo("known", context_window_tokens=8000)}
    )
    before = read_model_catalog(manager)
    payload = TestClient(app).get(f"/v1/models?view={view}").json()
    rows = {row["id"]: row for row in payload["data"]}
    assert rows["deepseek/deepseek-chat"]["contextWindow"] == 200000
    assert rows["deepseek/deepseek-chat"]["contextWindowSource"] == "default"
    assert rows["deepseek/known"]["contextWindow"] == 8000
    assert rows["deepseek/known"]["contextWindowSource"] == "provider"
    decoded = model_catalog_from_response(payload)
    assert decoded == before
    config = build_opencode_config(
        decoded.models,
        default_model_id=decoded.default_model_id,
        proxy_root_url="http://localhost:8082",
    )
    models = json.loads(json.dumps(config.file))["providers"]["free-claude-code"][
        "models"
    ]
    assert models["deepseek/deepseek-chat"]["limit"] == {"context": 200000}
    assert models["deepseek/known"]["limit"] == {"context": 8000, "output": 2000}


@pytest.mark.parametrize("view", ["messages", "responses"])
def test_sorted_catalog_retains_an_explicit_no_thinking_server_default(view):
    settings = _settings(
        model="open_router/Zulu",
        model_opus=None,
        model_haiku=None,
        model_fallbacks=(
            ModelFallback(model="wafer/z-fallback"),
            ModelFallback(model="deepseek/a-fallback"),
        ),
    )
    app = create_test_app(settings)
    provider_manager_for_app(app).cache_model_infos(
        "open_router",
        {
            ProviderModelInfo("Zulu", supports_thinking=False),
            ProviderModelInfo("apple"),
        },
    )
    payload = TestClient(app).get(f"/v1/models?view={view}").json()
    assert [row["provider_model_ref"] for row in payload["data"]] == [
        "deepseek/a-fallback",
        "open_router/apple",
        "open_router/Zulu",
        "wafer/z-fallback",
    ]
    assert payload["default_model_id"] == "claude-3-freecc-no-thinking/open_router/Zulu"
    assert payload["first_id"] == "deepseek/a-fallback"
    assert payload["last_id"] == "wafer/z-fallback"
    assert settings.model_fallbacks == (
        ModelFallback(model="wafer/z-fallback"),
        ModelFallback(model="deepseek/a-fallback"),
    )


def test_models_list_includes_configured_refs_cached_provider_models_and_aliases():
    app = create_test_app(_settings())
    _cache_models(app, "deepseek", "deepseek-chat")
    _cache_models(
        app,
        "open_router",
        "meta/llama-3.3",
        "anthropic/claude-opus",
    )

    response = TestClient(app).get("/v1/models")

    assert response.status_code == 200
    data = response.json()
    ids = [item["id"] for item in data["data"]]
    assert ids[0] == "claude-fable-5"
    assert [model_id for model_id in ids if "/" in model_id] == [
        "anthropic/deepseek/deepseek-chat",
        "claude-3-freecc-no-thinking/deepseek/deepseek-chat",
        "anthropic/open_router/anthropic/claude-opus",
        "claude-3-freecc-no-thinking/open_router/anthropic/claude-opus",
        "anthropic/open_router/meta/llama-3.3",
        "claude-3-freecc-no-thinking/open_router/meta/llama-3.3",
    ]
    assert ids.count("anthropic/deepseek/deepseek-chat") == 1
    assert ids.count("anthropic/open_router/anthropic/claude-opus") == 1
    display_names = {item["id"]: item["display_name"] for item in data["data"]}
    assert (
        display_names["anthropic/open_router/meta/llama-3.3"]
        == "open_router/meta/llama-3.3"
    )
    assert (
        display_names["claude-3-freecc-no-thinking/open_router/meta/llama-3.3"]
        == "open_router/meta/llama-3.3 (no thinking)"
    )
    assert "claude-sonnet-4-20250514" in ids
    assert "claude-fable-5" in ids
    assert data["first_id"] == ids[0]
    assert data["last_id"] == ids[-1]
    assert data["has_more"] is False
    assert all(
        "provider_model_ref" not in item and "apiBackend" not in item
        for item in data["data"]
    )


def test_claude_models_use_custom_provider_display_name_without_changing_ids():
    provider_id = "custom_f526dba2aa0a472f9c506ba236056d57"
    model_ref = f"{provider_id}/deepseek-v4.1-flash"
    definition = CustomProviderDefinition(
        provider_id=provider_id,
        display_name="Phoenix",
        base_url="https://gateway.example/v1",
    )
    settings = _settings(model=model_ref, model_opus=None, model_haiku=None).model_copy(
        update={"custom_providers": (definition,)}
    )
    app = create_test_app(settings)
    provider_manager_for_app(app).cache_model_infos(
        provider_id,
        {
            ProviderModelInfo("deepseek-v4.1-flash", supports_thinking=True),
            ProviderModelInfo("deepseek-plain", supports_thinking=False),
        },
    )

    response = TestClient(app).get("/v1/models")

    assert response.status_code == 200
    rows = {row["id"]: row for row in response.json()["data"]}
    assert rows[f"anthropic/{model_ref}"]["display_name"] == (
        "Phoenix/deepseek-v4.1-flash"
    )
    assert rows[f"claude-3-freecc-no-thinking/{model_ref}"]["display_name"] == (
        "Phoenix/deepseek-v4.1-flash (no thinking)"
    )
    plain_ref = f"{provider_id}/deepseek-plain"
    assert rows[f"claude-3-freecc-no-thinking/{plain_ref}"]["display_name"] == (
        "Phoenix/deepseek-plain (no thinking)"
    )


def test_models_list_uses_thinking_metadata_for_cached_models():
    app = create_test_app(_settings(model_opus=None))
    manager = provider_manager_for_app(app)
    _cache_models(app, "deepseek", "deepseek-chat")
    manager.cache_model_infos(
        "open_router",
        {
            ProviderModelInfo("reasoning-model", supports_thinking=True),
            ProviderModelInfo("plain-model", supports_thinking=False),
        },
    )

    response = TestClient(app).get("/v1/models")

    assert response.status_code == 200
    ids = [item["id"] for item in response.json()["data"]]
    assert "anthropic/open_router/reasoning-model" in ids
    assert "claude-3-freecc-no-thinking/open_router/reasoning-model" in ids
    assert "anthropic/open_router/plain-model" not in ids
    assert "claude-3-freecc-no-thinking/open_router/plain-model" in ids


def test_models_list_uses_cached_metadata_for_configured_refs():
    app = create_test_app(
        _settings(
            model="open_router/plain-model",
            model_opus=None,
            model_haiku=None,
        )
    )
    provider_manager_for_app(app).cache_model_infos(
        "open_router",
        {ProviderModelInfo("plain-model", supports_thinking=False)},
    )

    response = TestClient(app).get("/v1/models")

    ids = [item["id"] for item in response.json()["data"]]
    assert "anthropic/open_router/plain-model" not in ids
    assert ids[-1] == "claude-3-freecc-no-thinking/open_router/plain-model"


def test_models_list_includes_cached_wafer_models():
    app = create_test_app(
        _settings(
            model="wafer/DeepSeek-V4-Pro",
            model_opus=None,
            model_haiku=None,
        )
    )
    _cache_models(app, "wafer", "DeepSeek-V4-Pro", "MiniMax-M2.7")

    response = TestClient(app).get("/v1/models")

    ids = [item["id"] for item in response.json()["data"]]
    assert "anthropic/wafer/DeepSeek-V4-Pro" in ids
    assert "claude-3-freecc-no-thinking/wafer/DeepSeek-V4-Pro" in ids
    assert "anthropic/wafer/MiniMax-M2.7" in ids
    assert "claude-3-freecc-no-thinking/wafer/MiniMax-M2.7" in ids


def test_models_list_includes_fallback_refs_without_cached_discovery():
    app = create_test_app(
        _settings(
            model_opus=None,
            model_haiku=None,
            model_fallbacks=(ModelFallback(model="wafer/DeepSeek-V4-Pro"),),
        )
    )

    response = TestClient(app).get("/v1/models")

    assert response.status_code == 200
    ids = [item["id"] for item in response.json()["data"]]
    assert "anthropic/wafer/DeepSeek-V4-Pro" in ids
    assert "claude-3-freecc-no-thinking/wafer/DeepSeek-V4-Pro" in ids


def test_models_list_works_with_empty_discovery_catalog():
    app = create_test_app(_settings())

    response = TestClient(app).get("/v1/models")

    assert response.status_code == 200
    ids = [item["id"] for item in response.json()["data"]]
    assert ids[0] == "claude-fable-5"
    assert [model_id for model_id in ids if "/" in model_id] == [
        "anthropic/deepseek/deepseek-chat",
        "claude-3-freecc-no-thinking/deepseek/deepseek-chat",
        "anthropic/open_router/anthropic/claude-opus",
        "claude-3-freecc-no-thinking/open_router/anthropic/claude-opus",
    ]
    assert "claude-sonnet-4-20250514" in ids


def test_direct_model_views_exclude_claude_aliases_and_duplicate_variants():
    app = create_test_app(_settings(model_opus=None, model_haiku=None))
    manager = provider_manager_for_app(app)
    manager.cache_model_infos(
        "open_router",
        {
            ProviderModelInfo("reasoning-model", supports_thinking=True),
            ProviderModelInfo("plain-model", supports_thinking=False),
        },
    )

    messages = TestClient(app).get("/v1/models?view=messages").json()
    responses = TestClient(app).get("/v1/models?view=responses").json()

    assert [row["id"] for row in messages["data"]] == [
        "deepseek/deepseek-chat",
        "claude-3-freecc-no-thinking/open_router/plain-model",
        "open_router/reasoning-model",
    ]
    assert "claude-sonnet-4-20250514" not in {row["id"] for row in messages["data"]}
    assert all("apiBackend" not in row for row in messages["data"])
    assert responses["data"][0] == {
        "object": "model",
        "created": 0,
        "owned_by": "free-claude-code",
        "created_at": "1970-01-01T00:00:00Z",
        "display_name": "deepseek/deepseek-chat",
        "id": "deepseek/deepseek-chat",
        "type": "model",
        "provider_model_ref": "deepseek/deepseek-chat",
        "apiBackend": "responses",
        "maxRetries": 0,
        "contextWindow": 200000,
        "contextWindowSource": "default",
        "supportsReasoningEffort": True,
        "reasoningEfforts": [
            "none",
            "minimal",
            "low",
            "medium",
            "high",
            "xhigh",
            "max",
        ],
        "inferenceIdleTimeoutSecs": 660,
    }
    plain = responses["data"][1]
    assert plain["supportsReasoningEffort"] is False
    assert "reasoningEfforts" not in plain


def test_direct_model_views_serialize_known_capabilities_and_omit_unknowns():
    app = create_test_app(_settings(model_opus=None, model_haiku=None))
    provider_manager_for_app(app).cache_model_infos(
        "open_router",
        {
            ProviderModelInfo(
                "vision-reasoning",
                supports_thinking=True,
                input_modalities=frozenset(
                    {ModelInputModality.TEXT, ModelInputModality.IMAGE}
                ),
                context_window_tokens=131072,
                max_output_tokens=8192,
            ),
            ProviderModelInfo(
                "text-only",
                supports_thinking=False,
                input_modalities=frozenset({ModelInputModality.TEXT}),
                context_window_tokens=65536,
            ),
            ProviderModelInfo("unknown"),
        },
    )
    client = TestClient(app)

    messages = {
        row["provider_model_ref"]: row
        for row in client.get("/v1/models?view=messages").json()["data"]
    }
    responses = {
        row["provider_model_ref"]: row
        for row in client.get("/v1/models?view=responses").json()["data"]
    }

    assert messages["open_router/vision-reasoning"]["supportsReasoning"] is True
    assert messages["open_router/vision-reasoning"]["inputModalities"] == [
        "text",
        "image",
    ]
    assert messages["open_router/vision-reasoning"]["contextWindow"] == 131072
    assert messages["open_router/vision-reasoning"]["maxCompletionTokens"] == 8192
    assert messages["open_router/text-only"]["supportsReasoning"] is False
    assert messages["open_router/text-only"]["inputModalities"] == ["text"]
    assert messages["open_router/text-only"]["contextWindow"] == 65536
    assert "maxCompletionTokens" not in messages["open_router/text-only"]
    assert "supportsReasoning" not in messages["open_router/unknown"]
    assert "inputModalities" not in messages["open_router/unknown"]
    assert messages["open_router/unknown"]["contextWindow"] == 200000
    assert messages["open_router/unknown"]["contextWindowSource"] == "default"
    assert "maxCompletionTokens" not in messages["open_router/unknown"]
    assert responses["open_router/text-only"]["supportsReasoningEffort"] is False
    assert "reasoningEfforts" not in responses["open_router/text-only"]
    assert responses["open_router/vision-reasoning"]["contextWindow"] == 131072
    assert responses["open_router/vision-reasoning"]["maxCompletionTokens"] == 8192


def test_claude_model_view_does_not_expose_capability_fields():
    app = create_test_app(_settings(model_opus=None, model_haiku=None))
    provider_manager_for_app(app).cache_model_infos(
        "open_router",
        {
            ProviderModelInfo(
                "vision-reasoning",
                supports_thinking=True,
                input_modalities=frozenset(
                    {ModelInputModality.TEXT, ModelInputModality.IMAGE}
                ),
                context_window_tokens=131072,
                max_output_tokens=8192,
            )
        },
    )

    rows = TestClient(app).get("/v1/models").json()["data"]

    assert all(
        "supportsReasoning" not in row
        and "inputModalities" not in row
        and "contextWindow" not in row
        and "maxCompletionTokens" not in row
        for row in rows
    )


def test_muse_model_catalog_marks_every_routable_model_visible():
    app = create_test_app(_settings(model_opus=None, model_haiku=None))
    manager = provider_manager_for_app(app)
    manager.cache_model_infos(
        "open_router",
        {
            ProviderModelInfo("reasoning-model", supports_thinking=True),
            ProviderModelInfo("plain-model", supports_thinking=False),
        },
    )
    client = TestClient(app)

    responses = client.get("/v1/models?view=responses")
    muse = client.get("/muse-code/models?view=claude")

    assert responses.status_code == 200
    assert muse.status_code == 200
    assert all("metadata" not in row for row in responses.json()["data"])
    for row in muse.json()["data"]:
        metadata = row["metadata"]["muse-code"]
        assert metadata["is_hidden"] is False
        assert metadata["name"] == row["display_name"]
        assert metadata["limit"] == {"context": 200000}
        original = {key: value for key, value in row.items() if key != "metadata"}
        assert original in responses.json()["data"]
    assert [row["id"] for row in muse.json()["data"]] == [
        "deepseek/deepseek-chat",
        "claude-3-freecc-no-thinking/open_router/plain-model",
        "open_router/reasoning-model",
    ]


def test_muse_catalog_uses_native_metadata_for_known_limits_and_reasoning():
    app = create_test_app(_settings(model_opus=None, model_haiku=None))
    provider_manager_for_app(app).cache_model_infos(
        "open_router",
        {
            ProviderModelInfo(
                "reasoning-model",
                supports_thinking=True,
                context_window_tokens=131072,
                max_output_tokens=8192,
            ),
            ProviderModelInfo(
                "plain-model",
                supports_thinking=False,
                context_window_tokens=65536,
            ),
        },
    )
    rows = {
        row["provider_model_ref"]: row["metadata"]["muse-code"]
        for row in TestClient(app).get("/muse-code/models").json()["data"]
    }

    assert rows["open_router/reasoning-model"] == {
        "name": "open_router/reasoning-model",
        "is_hidden": False,
        "reasoning": True,
        "limit": {"context": 131072, "output": 8192},
    }
    assert rows["open_router/plain-model"] == {
        "name": "open_router/plain-model (no thinking)",
        "is_hidden": False,
        "reasoning": False,
        "limit": {"context": 65536},
    }
    assert rows["deepseek/deepseek-chat"] == {
        "name": "deepseek/deepseek-chat",
        "is_hidden": False,
        "limit": {"context": 200000},
    }


def test_responses_model_view_rounds_timeout_up_before_margin():
    app = create_test_app(
        _settings().model_copy(update={"provider_progress_timeout": 1.1})
    )

    response = TestClient(app).get("/v1/models?view=responses")

    assert response.status_code == 200
    assert {row["inferenceIdleTimeoutSecs"] for row in response.json()["data"]} == {62}


def test_responses_model_view_timeout_fits_unsigned_range():
    largest_accepted_timeout = math.nextafter(float(1 << 64), 0.0)
    app = create_test_app(
        _settings().model_copy(
            update={"provider_progress_timeout": largest_accepted_timeout}
        )
    )

    response = TestClient(app).get("/v1/models?view=responses")

    assert response.status_code == 200
    assert all(
        row["inferenceIdleTimeoutSecs"] <= (1 << 64) - 1
        for row in response.json()["data"]
    )


def test_unknown_model_view_is_rejected():
    response = TestClient(create_test_app(_settings())).get("/v1/models?view=other")

    assert response.status_code == 422


@pytest.mark.parametrize("view", ["messages", "responses"])
def test_real_json_catalog_agrees_with_application_identity_and_known_metadata(view):
    from free_claude_code.application.model_catalog import read_model_catalog
    from free_claude_code.cli.launchers.catalog_http import model_catalog_from_response

    app = create_test_app(
        _settings(model="open_router/Zulu", model_opus=None, model_haiku=None)
    )
    provider_manager_for_app(app).cache_model_infos(
        "open_router",
        {
            ProviderModelInfo(
                "Zulu", supports_thinking=False, context_window_tokens=32000
            ),
            ProviderModelInfo(
                "vendor/vision ",
                input_modalities=frozenset(
                    {ModelInputModality.TEXT, ModelInputModality.IMAGE}
                ),
                max_output_tokens=4096,
            ),
        },
    )
    expected = read_model_catalog(app.state.services.requests)
    payload = TestClient(app).get(f"/v1/models?view={view}").json()
    assert model_catalog_from_response(payload) == expected