Skip to content

The fastest, litest AI Gateway. Rust core with Python SDK. Call 100+ LLM APIs in OpenAI (or native) format with cost tracking, guardrails, load balancing, and logging [Bedrock, Azure, OpenAI, Anthropic, OpenAI, VertexAI, vLLM, Nvidia NIM]

49.0 KB
Raw Blame
"""
Test suite for Dashscope cost calculation functionality.

Tests the cost calculation for Dashscope models including:
- All-or-nothing tiered pricing, selected by the request's total input tokens.
- Falls back to flat-rate pricing for non-tiered models.
- Handles cache read and cache creation tokens.
- Correctly prices requests exceeding the highest defined tier.
"""

import math
import os
from datetime import datetime, timezone

import pytest

# Add the project root to Python path
import litellm
from litellm.litellm_core_utils.llm_cost_calc.utils import (
    resolve_explicit_cache_read_cost_rate,
    calculate_prompt_caching_savings,
    generic_cost_per_token,
    get_token_type_cost_breakdown,
)
from litellm.llms.dashscope.cost_calculator import (
    cost_per_token as dashscope_cost_per_token,
)
from litellm.types.utils import (
    CompletionTokensDetailsWrapper,
    ModelInfo,
    PromptTokensDetailsWrapper,
    Usage,
)


class TestDashscopeCostCalculator:
    """Test suite for Dashscope cost calculation functionality."""

    @pytest.fixture(autouse=True)
    def setup_model_cost_map(self):
        """Set up the model cost map for testing by loading it locally."""
        os.environ["LITELLM_LOCAL_MODEL_COST_MAP"] = "True"
        litellm.model_cost = litellm.get_model_cost_map(url="")

    @pytest.mark.parametrize(
        "prompt_tokens_details",
        [
            {"cached_tokens": 0, "cache_type": "ephemeral"},
            {"cached_tokens": 600},
            {"cached_tokens": 600, "cache_type": "unknown-future-type"},
        ],
    )
    def test_explicit_cache_rate_requires_an_ephemeral_cache_hit(
        self,
        prompt_tokens_details: dict[str, int | str],
    ):
        assert (
            resolve_explicit_cache_read_cost_rate(
                model_info={
                    "key": "qwen-cache-rate-guard-test",
                    "explicit_cache_read_input_token_cost": 1e-07,
                },
                usage=Usage(
                    prompt_tokens=1000,
                    completion_tokens=0,
                    prompt_tokens_details=prompt_tokens_details,
                ),
                current_time=None,
            )
            is None
        )

    @pytest.mark.parametrize(
        ("model_info", "current_time", "expected_cache_rate"),
        [
            (
                {
                    "key": "qwen-tier-mode-rate-test",
                    "tiered_pricing": [
                        {
                            "range": [0, 2000],
                            "input_cost_per_token": 1e-06,
                            "cache_read_input_token_cost": 2e-07,
                            "explicit_cache_read_input_token_cost": 1e-07,
                        }
                    ],
                },
                None,
                1e-07,
            ),
            (
                {
                    "key": "qwen-tier-generic-fallback-test",
                    "tiered_pricing": [
                        {
                            "range": [0, 2000],
                            "input_cost_per_token": 1e-06,
                            "cache_read_input_token_cost": 2e-07,
                        }
                    ],
                },
                None,
                None,
            ),
            (
                {
                    "key": "qwen-flat-generic-fallback-test",
                    "input_cost_per_token": 1e-06,
                    "cache_read_input_token_cost": 2e-07,
                },
                None,
                None,
            ),
            (
                {
                    "key": "qwen-invalid-explicit-rate-test",
                    "input_cost_per_token": 1e-06,
                    "off_peak_pricing": {
                        "hours_utc": "00:00-00:00",
                        "explicit_cache_read_input_token_cost": True,
                    },
                },
                datetime(2026, 9, 3, 17, 25, tzinfo=timezone.utc),
                None,
            ),
            (
                {
                    "key": "qwen-tier-off-peak-mode-rate-test",
                    "tiered_pricing": [
                        {
                            "range": [0, 2000],
                            "input_cost_per_token": 1e-06,
                            "cache_read_input_token_cost": 2e-07,
                        }
                    ],
                    "off_peak_pricing": {
                        "hours_utc": "00:00-00:00",
                        "explicit_cache_read_input_token_cost": 5e-08,
                    },
                },
                datetime(2026, 9, 3, 17, 25, tzinfo=timezone.utc),
                5e-08,
            ),
            (
                {
                    "key": "qwen-flat-off-peak-mode-rate-test",
                    "input_cost_per_token": 1e-06,
                    "cache_read_input_token_cost": 2e-07,
                    "off_peak_pricing": {
                        "hours_utc": "00:00-00:00",
                        "explicit_cache_read_input_token_cost": 5e-08,
                    },
                },
                datetime(2026, 9, 3, 17, 25, tzinfo=timezone.utc),
                5e-08,
            ),
            (
                {
                    "key": "qwen-off-peak-mode-rate-test",
                    "input_cost_per_token": 1e-06,
                    "explicit_cache_read_input_token_cost": 1e-07,
                    "off_peak_pricing": {
                        "hours_utc": "00:00-00:00",
                        "explicit_cache_read_input_token_cost": 5e-08,
                    },
                },
                datetime(2026, 9, 3, 17, 25, tzinfo=timezone.utc),
                5e-08,
            ),
            (
                {
                    "key": "qwen-off-peak-generic-rate-test",
                    "input_cost_per_token": 1e-06,
                    "explicit_cache_read_input_token_cost": 1e-07,
                    "off_peak_pricing": {
                        "hours_utc": "00:00-00:00",
                        "explicit_cache_read_input_token_cost": "invalid",
                        "cache_read_input_token_cost": 8e-08,
                    },
                },
                datetime(2026, 9, 3, 17, 25, tzinfo=timezone.utc),
                8e-08,
            ),
            (
                {
                    "key": "qwen-off-peak-standard-fallback-test",
                    "input_cost_per_token": 1e-06,
                    "explicit_cache_read_input_token_cost": 1e-07,
                    "off_peak_pricing": {
                        "hours_utc": "00:00-00:00",
                    },
                },
                datetime(2026, 9, 3, 17, 25, tzinfo=timezone.utc),
                1e-07,
            ),
        ],
    )
    def test_provider_neutral_cache_rate_resolver_handles_qwen_rate_fallbacks(
        self,
        model_info: ModelInfo,
        current_time: datetime | None,
        expected_cache_rate: float | None,
    ):
        usage = Usage(
            prompt_tokens=1000,
            completion_tokens=0,
            prompt_tokens_details={"cached_tokens": 600, "cache_type": "ephemeral"},
        )

        cache_rate = resolve_explicit_cache_read_cost_rate(
            model_info=model_info,
            usage=usage,
            current_time=current_time,
        )

        assert cache_rate == expected_cache_rate

    def test_provider_neutral_cache_rate_resolver_handles_service_tier_rate(self):
        cache_rate = resolve_explicit_cache_read_cost_rate(
            model_info={
                "key": "qwen-service-tier-mode-rate-test",
                "explicit_cache_read_input_token_cost_priority": 3e-07,
            },
            usage=Usage(
                prompt_tokens=1000,
                completion_tokens=0,
                prompt_tokens_details={"cached_tokens": 600, "cache_type": "ephemeral"},
            ),
            current_time=None,
            service_tier="priority",
        )

        assert cache_rate == 3e-07

    def test_dashscope_flat_pricing_fallback(self):
        """
        Tests that the dashscope calculator falls back to flat pricing for models
        without a 'tiered_pricing' key (e.g., qwen-max).
        """
        usage = Usage(prompt_tokens=1000, completion_tokens=500)

        prompt_cost, completion_cost = dashscope_cost_per_token(
            model="qwen-max", usage=usage
        )

        model_info = litellm.get_model_info("dashscope/qwen-max")
        expected_prompt_cost = 1000 * model_info["input_cost_per_token"]
        expected_completion_cost = 500 * model_info["output_cost_per_token"]

        assert math.isclose(prompt_cost, expected_prompt_cost, rel_tol=1e-10)
        assert math.isclose(completion_cost, expected_completion_cost, rel_tol=1e-10)

    @pytest.mark.parametrize("explicit_cache_rate", [1e-07, "1e-7"])
    @pytest.mark.parametrize(
        ("cache_type", "expected_cache_rate"),
        [
            ("ephemeral", 1e-07),
            (None, 2e-07),
            ("unknown-future-type", 2e-07),
        ],
    )
    def test_dashscope_flat_pricing_distinguishes_explicit_and_implicit_cache_reads(
        self, cache_type: str | None, expected_cache_rate: float, explicit_cache_rate: float | str
    ) -> None:
        litellm.model_cost["dashscope/qwen-context-cache-mode-test"] = {
            "litellm_provider": "dashscope",
            "mode": "chat",
            "input_cost_per_token": 1e-06,
            "output_cost_per_token": 4e-06,
            "explicit_cache_read_input_token_cost": explicit_cache_rate,
            "cache_read_input_token_cost": 2e-07,
        }
        prompt_tokens_details: dict[str, int | str] = {"cached_tokens": 600}
        if cache_type is not None:
            prompt_tokens_details["cache_type"] = cache_type
        usage = Usage(
            prompt_tokens=1000,
            completion_tokens=0,
            prompt_tokens_details=prompt_tokens_details,
        )

        prompt_cost, _ = dashscope_cost_per_token(model="qwen-context-cache-mode-test", usage=usage)

        assert math.isclose(
            prompt_cost,
            (400 * 1e-06) + (600 * expected_cache_rate),
            rel_tol=1e-10,
        )

    def test_dashscope_explicit_cache_read_falls_back_to_existing_cache_read_rate(self):
        litellm.model_cost["dashscope/qwen-explicit-cache-fallback-test"] = {
            "litellm_provider": "dashscope",
            "mode": "chat",
            "input_cost_per_token": 1e-06,
            "output_cost_per_token": 4e-06,
            "cache_read_input_token_cost": 1e-07,
        }
        usage = Usage(
            prompt_tokens=1000,
            completion_tokens=0,
            prompt_tokens_details={"cached_tokens": 600, "cache_type": "ephemeral"},
        )

        prompt_cost, _ = dashscope_cost_per_token(
            model="qwen-explicit-cache-fallback-test",
            usage=usage,
        )

        assert math.isclose(prompt_cost, (400 * 1e-06) + (600 * 1e-07), rel_tol=1e-10)

    @pytest.mark.parametrize(
        ("prompt_tokens_details", "expected_cache_rate"),
        [
            ({"cached_tokens": 600, "cache_type": "ephemeral"}, 1e-07),
            ({"cached_tokens": 600}, 2e-07),
        ],
    )
    def test_completion_cost_routes_dashscope_cache_mode_pricing(
        self,
        prompt_tokens_details: dict[str, int | str],
        expected_cache_rate: float,
    ):
        litellm.model_cost["dashscope/qwen-completion-cache-mode-test"] = {
            "litellm_provider": "dashscope",
            "mode": "chat",
            "input_cost_per_token": 1e-06,
            "output_cost_per_token": 4e-06,
            "cache_read_input_token_cost": 2e-07,
            "explicit_cache_read_input_token_cost": 1e-07,
        }
        response = litellm.ModelResponse(
            model="qwen-completion-cache-mode-test",
            usage=Usage(
                prompt_tokens=1000,
                completion_tokens=100,
                total_tokens=1100,
                prompt_tokens_details=prompt_tokens_details,
            ),
        )

        cost = litellm.completion_cost(
            completion_response=response,
            model="qwen-completion-cache-mode-test",
            custom_llm_provider="dashscope",
        )

        assert math.isclose(
            cost,
            (400 * 1e-06) + (600 * expected_cache_rate) + (100 * 4e-06),
            rel_tol=1e-10,
        )

    def test_dashscope_tiered_pricing_uses_mode_specific_cache_read_rate(self):
        self._register_tiered_model(
            "dashscope/qwen-tiered-cache-mode-test",
            [
                {
                    "range": [0, 1000],
                    "input_cost_per_token": 1e-06,
                    "output_cost_per_token": 4e-06,
                    "explicit_cache_read_input_token_cost": 1e-07,
                    "cache_read_input_token_cost": 2e-07,
                }
            ],
        )
        usage = Usage(
            prompt_tokens=1000,
            completion_tokens=0,
            prompt_tokens_details={"cached_tokens": 600, "cache_type": "ephemeral"},
        )

        prompt_cost, _ = dashscope_cost_per_token(model="qwen-tiered-cache-mode-test", usage=usage)

        assert math.isclose(prompt_cost, (400 * 1e-06) + (600 * 1e-07), rel_tol=1e-10)

    @pytest.mark.parametrize(
        ("explicit_cache_rate", "expected_cache_rate"),
        [(1e-07, 1e-07), ("1e-7", 1e-07), (0.0, 0.0), ("0", 0.0)],
    )
    def test_dashscope_flat_explicit_cache_read_rate_wins_even_at_zero(
        self, explicit_cache_rate: float | str, expected_cache_rate: float
    ) -> None:
        litellm.model_cost["dashscope/qwen-flat-explicit-zero-rate-test"] = {
            "litellm_provider": "dashscope",
            "mode": "chat",
            "input_cost_per_token": 1e-06,
            "output_cost_per_token": 4e-06,
            "cache_read_input_token_cost": 2e-07,
            "explicit_cache_read_input_token_cost": explicit_cache_rate,
        }
        usage = Usage(
            prompt_tokens=1000,
            completion_tokens=0,
            prompt_tokens_details={"cached_tokens": 600, "cache_type": "ephemeral"},
        )

        prompt_cost, _ = dashscope_cost_per_token(
            model="qwen-flat-explicit-zero-rate-test",
            usage=usage,
        )

        assert math.isclose(prompt_cost, (400 * 1e-06) + (600 * expected_cache_rate), rel_tol=1e-10)

    def test_dashscope_tier_without_an_explicit_rate_bills_that_tiers_cache_read_rate(self):
        litellm.model_cost["dashscope/qwen-two-tier-explicit-fallback-test"] = {
            "litellm_provider": "dashscope",
            "mode": "chat",
            "explicit_cache_read_input_token_cost": 4e-08,
            "tiered_pricing": [
                {
                    "range": [0, 1000],
                    "input_cost_per_token": 4e-07,
                    "output_cost_per_token": 1.6e-06,
                    "cache_read_input_token_cost": 8e-08,
                },
                {
                    "range": [1000, 10000],
                    "input_cost_per_token": 1.2e-06,
                    "output_cost_per_token": 4.8e-06,
                    "cache_read_input_token_cost": 2.4e-07,
                },
            ],
        }
        usage = Usage(
            prompt_tokens=3000,
            completion_tokens=0,
            prompt_tokens_details={"cached_tokens": 2000, "cache_type": "ephemeral"},
        )

        prompt_cost, _ = dashscope_cost_per_token(model="qwen-two-tier-explicit-fallback-test", usage=usage)
        breakdown = get_token_type_cost_breakdown(
            model="qwen-two-tier-explicit-fallback-test",
            custom_llm_provider="dashscope",
            usage=usage,
        )

        assert math.isclose(breakdown.cache_read_cost, 2000 * 2.4e-07, rel_tol=1e-10)
        assert math.isclose(prompt_cost, (1000 * 1.2e-06) + breakdown.cache_read_cost, rel_tol=1e-10)

    def test_dashscope_prompt_caching_savings_uses_explicit_cache_read_rate(self):
        model_info: ModelInfo = {
            "key": "qwen-cache-savings-mode-test",
            "litellm_provider": "dashscope",
            "mode": "chat",
            "input_cost_per_token": 1e-06,
            "output_cost_per_token": 4e-06,
            "cache_read_input_token_cost": 2e-07,
            "explicit_cache_read_input_token_cost": 1e-07,
        }
        usage = Usage(
            prompt_tokens=1000,
            completion_tokens=0,
            prompt_tokens_details={"cached_tokens": 600, "cache_type": "ephemeral"},
        )

        savings = calculate_prompt_caching_savings(
            model_info=model_info,
            usage=usage,
            custom_llm_provider="dashscope",
        )

        assert math.isclose(savings, 600 * (1e-06 - 1e-07), rel_tol=1e-10)

    def test_openai_compatible_qwen_total_uses_explicit_cache_read_rate(self):
        model_info: ModelInfo = {
            "key": "qwen-generic-cache-mode-test",
            "input_cost_per_token": 1e-06,
            "output_cost_per_token": 4e-06,
            "cache_read_input_token_cost": 2e-07,
            "explicit_cache_read_input_token_cost": 1e-07,
        }
        usage = Usage(
            prompt_tokens=1000,
            completion_tokens=0,
            prompt_tokens_details={"cached_tokens": 600, "cache_type": "ephemeral"},
        )

        prompt_cost, _ = generic_cost_per_token(
            model="custom-qwen",
            usage=usage,
            custom_llm_provider="openai",
            model_info=model_info,
        )

        assert math.isclose(prompt_cost, (400 * 1e-06) + (600 * 1e-07), rel_tol=1e-10)

    @pytest.mark.parametrize(
        ("cache_type", "expected_cache_rate"),
        [("ephemeral", 1e-07), (None, 2e-07)],
    )
    def test_dashscope_cost_breakdown_matches_mode_specific_total(
        self,
        cache_type: str | None,
        expected_cache_rate: float,
    ):
        litellm.model_cost["dashscope/qwen-cache-breakdown-mode-test"] = {
            "litellm_provider": "dashscope",
            "mode": "chat",
            "input_cost_per_token": 1e-06,
            "output_cost_per_token": 4e-06,
            "cache_read_input_token_cost": 2e-07,
            "explicit_cache_read_input_token_cost": 1e-07,
        }
        prompt_tokens_details: dict[str, int | str] = {"cached_tokens": 600}
        if cache_type is not None:
            prompt_tokens_details["cache_type"] = cache_type
        usage = Usage(
            prompt_tokens=1000,
            completion_tokens=0,
            prompt_tokens_details=prompt_tokens_details,
        )

        prompt_cost, _ = dashscope_cost_per_token(model="qwen-cache-breakdown-mode-test", usage=usage)
        breakdown = get_token_type_cost_breakdown(
            model="qwen-cache-breakdown-mode-test",
            custom_llm_provider="dashscope",
            usage=usage,
        )

        assert math.isclose(breakdown.cache_read_cost, 600 * expected_cache_rate, rel_tol=1e-10)
        assert math.isclose(prompt_cost, (400 * 1e-06) + breakdown.cache_read_cost, rel_tol=1e-10)

    def test_dashscope_tiered_pricing_within_first_tier(self):
        """
        Tests the dashscope tiered pricing when the request's input falls in the first tier.
        Uses 'dashscope/qwen-flash' as a real-world example.
        """
        # Tier 1 for qwen-flash is [0, 256,000] tokens
        usage = Usage(prompt_tokens=100000, completion_tokens=50000)
        prompt_cost, completion_cost = dashscope_cost_per_token(
            model="qwen-flash", usage=usage
        )

        model_info = litellm.get_model_info("dashscope/qwen-flash")
        tier_1_pricing = model_info["tiered_pricing"][0]

        expected_prompt_cost = 100000 * tier_1_pricing["input_cost_per_token"]
        expected_completion_cost = 50000 * tier_1_pricing["output_cost_per_token"]

        assert math.isclose(prompt_cost, expected_prompt_cost, rel_tol=1e-10)
        assert math.isclose(completion_cost, expected_completion_cost, rel_tol=1e-10)

    def test_dashscope_tiered_pricing_bills_whole_request_at_selected_tier(self):
        """
        Regression: Model Studio tiered pricing is all-or-nothing, not graduated. An input
        above the first tier's range must bill every token at the higher tier's rate.
        """
        # Tiering for qwen-flash: Tier 1: [0, 256k], Tier 2: [256k, 1M]
        usage = Usage(prompt_tokens=300000, completion_tokens=300000)
        prompt_cost, completion_cost = dashscope_cost_per_token(
            model="qwen-flash", usage=usage
        )

        model_info = litellm.get_model_info("dashscope/qwen-flash")
        tier_1 = model_info["tiered_pricing"][0]
        tier_2 = model_info["tiered_pricing"][1]

        expected_prompt_cost = 300000 * tier_2["input_cost_per_token"]
        expected_completion_cost = 300000 * tier_2["output_cost_per_token"]

        assert math.isclose(prompt_cost, expected_prompt_cost, rel_tol=1e-10)
        assert math.isclose(completion_cost, expected_completion_cost, rel_tol=1e-10)

        graduated_prompt_cost = (256000 * tier_1["input_cost_per_token"]) + (
            44000 * tier_2["input_cost_per_token"]
        )
        assert prompt_cost > graduated_prompt_cost

    def test_dashscope_tiered_pricing_boundary_stays_in_lower_tier(self):
        """
        A request of exactly range_end tokens stays in the lower tier, matching the
        official `0 < Token <= 256K` phrasing.
        """
        usage = Usage(prompt_tokens=256000, completion_tokens=1000)
        prompt_cost, completion_cost = dashscope_cost_per_token(
            model="qwen-flash", usage=usage
        )

        tier_1 = litellm.get_model_info("dashscope/qwen-flash")["tiered_pricing"][0]

        assert math.isclose(
            prompt_cost, 256000 * tier_1["input_cost_per_token"], rel_tol=1e-10
        )
        assert math.isclose(
            completion_cost, 1000 * tier_1["output_cost_per_token"], rel_tol=1e-10
        )

    def test_dashscope_tiered_pricing_output_uses_input_selected_tier(self):
        """
        The tier is chosen by input volume only: a small input with a huge output stays
        on the first tier's output rate.
        """
        usage = Usage(prompt_tokens=1000, completion_tokens=400000)
        _, completion_cost = dashscope_cost_per_token(model="qwen-flash", usage=usage)

        tier_1 = litellm.get_model_info("dashscope/qwen-flash")["tiered_pricing"][0]

        assert math.isclose(
            completion_cost, 400000 * tier_1["output_cost_per_token"], rel_tol=1e-10
        )

    def test_dashscope_tiered_pricing_with_caching(self):
        """
        Tests tiered pricing with cached tokens: the tier is selected from the total
        input (text + cached), and cache reads bill at that tier's cache rate.
        """
        usage = Usage(
            prompt_tokens=50000,  # 10k cached + 40k new
            completion_tokens=1000,
            total_tokens=51000,
            prompt_tokens_details=PromptTokensDetailsWrapper(cached_tokens=10000),
        )

        prompt_cost, _ = dashscope_cost_per_token(model="qwen3-coder-plus", usage=usage)

        # 50k total input falls in qwen3-coder-plus tier 2 ([32k, 128k])
        tier_2 = litellm.get_model_info("dashscope/qwen3-coder-plus")["tiered_pricing"][1]

        expected_prompt_cost = (40000 * tier_2["input_cost_per_token"]) + (
            10000 * tier_2["cache_read_input_token_cost"]
        )

        assert math.isclose(prompt_cost, expected_prompt_cost, rel_tol=1e-10)

    def test_dashscope_tiered_pricing_exceeding_highest_tier(self):
        """
        Requests above the highest declared range bill entirely at the last tier's rate.
        """
        usage = Usage(
            prompt_tokens=1200000, completion_tokens=1000
        )  # Max defined range for qwen-flash is 1M

        prompt_cost, _ = dashscope_cost_per_token(model="qwen-flash", usage=usage)

        tier_2 = litellm.get_model_info("dashscope/qwen-flash")["tiered_pricing"][1]

        assert math.isclose(
            prompt_cost, 1200000 * tier_2["input_cost_per_token"], rel_tol=1e-10
        )

    def _register_tiered_model(self, model_key: str, tiered_pricing: list[dict]) -> None:
        litellm.model_cost[model_key] = {
            "litellm_provider": "dashscope",
            "mode": "chat",
            "tiered_pricing": tiered_pricing,
        }

    def _register_string_valued_tiered_model(self, model_key: str) -> None:
        """Register a model whose tier costs are strings, mimicking YAML config parsing."""
        self._register_tiered_model(
            model_key,
            [
                {
                    "range": [0, 1000],
                    "input_cost_per_token": "4e-07",
                    "output_cost_per_token": "1.6e-06",
                },
                {
                    "range": [1000, 2000],
                    "input_cost_per_token": "8e-07",
                    "output_cost_per_token": "3.2e-06",
                },
            ],
        )

    def test_dashscope_tiered_pricing_string_costs_within_tier(self):
        """
        Regression: YAML-parsed tier costs can be strings (e.g. "4e-07") and must still
        be computed as floats.
        """
        self._register_string_valued_tiered_model("dashscope/qwen-str-tier-test")

        usage = Usage(prompt_tokens=500, completion_tokens=200)
        prompt_cost, completion_cost = dashscope_cost_per_token(
            model="qwen-str-tier-test", usage=usage
        )

        assert math.isclose(prompt_cost, 500 * float("4e-07"), rel_tol=1e-10)
        assert math.isclose(completion_cost, 200 * float("1.6e-06"), rel_tol=1e-10)

    def test_dashscope_tiered_pricing_string_costs_exceeding_highest_tier(self):
        """
        Regression: string-valued tier costs must also be coerced on the last-tier
        fallback path used by requests above the highest range.
        """
        self._register_string_valued_tiered_model("dashscope/qwen-str-tier-test")

        usage = Usage(prompt_tokens=2500, completion_tokens=3000)
        prompt_cost, completion_cost = dashscope_cost_per_token(
            model="qwen-str-tier-test", usage=usage
        )

        assert math.isclose(prompt_cost, 2500 * float("8e-07"), rel_tol=1e-10)
        assert math.isclose(completion_cost, 3000 * float("3.2e-06"), rel_tol=1e-10)

    def test_dashscope_tiered_cache_creation_tokens_use_tier_rate(self):
        """
        Regression (tiered cache creation): cache-creation tokens must bill at the
        selected tier's cache_creation_input_token_cost, not the input rate.
        """
        self._register_tiered_model(
            "dashscope/qwen-cache-write-test",
            [
                {
                    "range": [0, 256000],
                    "input_cost_per_token": 3.25e-07,
                    "output_cost_per_token": 1.95e-06,
                    "cache_creation_input_token_cost": 4.063e-07,
                    "cache_read_input_token_cost": 3.25e-08,
                },
                {
                    "range": [256000, 1000000],
                    "input_cost_per_token": 6.5e-07,
                    "output_cost_per_token": 3.9e-06,
                    "cache_creation_input_token_cost": 8.125e-07,
                    "cache_read_input_token_cost": 6.5e-08,
                },
            ],
        )

        usage = Usage(
            prompt_tokens=300000,  # 200k new + 60k cache creation + 40k cache read
            completion_tokens=1000,
            prompt_tokens_details=PromptTokensDetailsWrapper(
                cached_tokens=40000, cache_creation_tokens=60000
            ),
        )

        prompt_cost, _ = dashscope_cost_per_token(
            model="qwen-cache-write-test", usage=usage
        )

        expected_prompt_cost = (
            (200000 * 6.5e-07) + (60000 * 8.125e-07) + (40000 * 6.5e-08)
        )

        assert math.isclose(prompt_cost, expected_prompt_cost, rel_tol=1e-10)

    def test_dashscope_nested_cache_creation_input_tokens_bill_at_cache_write_rate(self):
        """
        Regression (LIT-5757): DashScope nests cache_creation_input_tokens inside
        prompt_tokens_details; those tokens must bill at the tier's cache-creation
        rate instead of being folded into text tokens at the input rate.
        """
        self._register_tiered_model(
            "dashscope/qwen-nested-cache-write-test",
            [
                {
                    "range": [0, 128000],
                    "input_cost_per_token": 4e-07,
                    "cache_read_input_token_cost": 1.6e-07,
                    "cache_creation_input_token_cost": 5e-07,
                    "output_cost_per_token": 1.6e-06,
                }
            ],
        )

        usage = Usage(
            prompt_tokens=2059,
            completion_tokens=201,
            total_tokens=2260,
            prompt_tokens_details={
                "cached_tokens": 0,
                "text_tokens": 2059,
                "cache_type": "ephemeral",
                "cache_creation_input_tokens": 2048,
                "cache_creation": {"ephemeral_5m_input_tokens": 2048},
            },
            completion_tokens_details={"reasoning_tokens": 170},
        )

        prompt_cost, _ = dashscope_cost_per_token(
            model="qwen-nested-cache-write-test", usage=usage
        )

        assert math.isclose(
            prompt_cost, (2048 * 5e-07) + (11 * 4e-07), rel_tol=1e-10
        )

    def test_dashscope_tiered_cache_creation_falls_back_to_tier_input_rate(self):
        """
        Tiers without a cache_creation_input_token_cost bill cache-creation tokens at
        that tier's input rate.
        """
        self._register_tiered_model(
            "dashscope/qwen-no-cache-write-test",
            [
                {
                    "range": [0, 256000],
                    "input_cost_per_token": 3.25e-07,
                    "output_cost_per_token": 1.95e-06,
                }
            ],
        )

        usage = Usage(
            prompt_tokens=10000,
            completion_tokens=100,
            prompt_tokens_details=PromptTokensDetailsWrapper(cache_creation_tokens=4000),
        )

        prompt_cost, _ = dashscope_cost_per_token(
            model="qwen-no-cache-write-test", usage=usage
        )

        assert math.isclose(prompt_cost, 10000 * 3.25e-07, rel_tol=1e-10)

    def test_dashscope_flat_cache_creation_tokens_use_flat_rate(self):
        """Flat-priced models bill cache-creation tokens at their cache-creation rate."""
        litellm.model_cost["dashscope/qwen-flat-cache-write-test"] = {
            "litellm_provider": "dashscope",
            "mode": "chat",
            "input_cost_per_token": 3.25e-07,
            "output_cost_per_token": 1.95e-06,
            "cache_creation_input_token_cost": 4.063e-07,
            "cache_read_input_token_cost": 3.25e-08,
        }

        usage = Usage(
            prompt_tokens=10000,
            completion_tokens=100,
            prompt_tokens_details=PromptTokensDetailsWrapper(
                cached_tokens=2000, cache_creation_tokens=3000
            ),
        )

        prompt_cost, _ = dashscope_cost_per_token(
            model="qwen-flat-cache-write-test", usage=usage
        )

        expected_prompt_cost = (
            (5000 * 3.25e-07) + (3000 * 4.063e-07) + (2000 * 3.25e-08)
        )

        assert math.isclose(prompt_cost, expected_prompt_cost, rel_tol=1e-10)

    def test_dashscope_tier_without_an_output_rate_bills_the_model_rate(self):
        """
        Regression: a tier declaring only an input rate served every completion for free,
        since a missing tier output rate had no tier-level fallback to stand in for it.
        """
        litellm.model_cost["dashscope/qwen-input-only-tier-test"] = {
            "litellm_provider": "dashscope",
            "mode": "chat",
            "output_cost_per_token": 1.6e-06,
            "tiered_pricing": [{"range": [0, 1000], "input_cost_per_token": 4e-07}],
        }

        usage = Usage(prompt_tokens=500, completion_tokens=200)
        prompt_cost, completion_cost = dashscope_cost_per_token(
            model="qwen-input-only-tier-test", usage=usage
        )

        assert math.isclose(prompt_cost, 500 * 4e-07, rel_tol=1e-10)
        assert math.isclose(completion_cost, 200 * 1.6e-06, rel_tol=1e-10)

    def test_dashscope_tier_without_an_output_rate_bills_the_model_reasoning_rate(self):
        """
        Regression: a tier declaring only an input rate billed reasoning tokens at the model's
        plain output rate, ignoring the model's dedicated reasoning rate.
        """
        litellm.model_cost["dashscope/qwen-input-only-reasoning-test"] = {
            "litellm_provider": "dashscope",
            "mode": "chat",
            "output_cost_per_token": 1.6e-06,
            "output_cost_per_reasoning_token": 4e-06,
            "tiered_pricing": [{"range": [0, 1000], "input_cost_per_token": 4e-07}],
        }

        usage = Usage(
            prompt_tokens=500,
            completion_tokens=200,
            completion_tokens_details=CompletionTokensDetailsWrapper(reasoning_tokens=150),
        )
        _, completion_cost = dashscope_cost_per_token(
            model="qwen-input-only-reasoning-test", usage=usage
        )

        assert math.isclose(
            completion_cost, (50 * 1.6e-06) + (150 * 4e-06), rel_tol=1e-10
        )

    def test_dashscope_tier_output_rate_wins_over_the_model_reasoning_rate(self):
        """
        A tier declaring its own output rate keeps reasoning tokens on that tier rather than
        mixing in a model-level reasoning rate.
        """
        litellm.model_cost["dashscope/qwen-tier-output-reasoning-test"] = {
            "litellm_provider": "dashscope",
            "mode": "chat",
            "output_cost_per_reasoning_token": 4e-06,
            "tiered_pricing": [
                {
                    "range": [0, 1000],
                    "input_cost_per_token": 4e-07,
                    "output_cost_per_token": 1.6e-06,
                }
            ],
        }

        usage = Usage(
            prompt_tokens=500,
            completion_tokens=200,
            completion_tokens_details=CompletionTokensDetailsWrapper(reasoning_tokens=150),
        )
        _, completion_cost = dashscope_cost_per_token(
            model="qwen-tier-output-reasoning-test", usage=usage
        )

        assert math.isclose(completion_cost, 200 * 1.6e-06, rel_tol=1e-10)

    def test_dashscope_model_zero_reasoning_rate_bills_reasoning_free(self):
        """
        Regression: a model declaring an explicit zero reasoning rate had it treated as
        missing, billing reasoning tokens at the plain output rate instead of free.
        """
        litellm.model_cost["dashscope/qwen-zero-reasoning-test"] = {
            "litellm_provider": "dashscope",
            "mode": "chat",
            "input_cost_per_token": 4e-07,
            "output_cost_per_token": 1.6e-06,
            "output_cost_per_reasoning_token": 0,
        }

        usage = Usage(
            prompt_tokens=500,
            completion_tokens=200,
            completion_tokens_details=CompletionTokensDetailsWrapper(reasoning_tokens=150),
        )
        _, completion_cost = dashscope_cost_per_token(
            model="qwen-zero-reasoning-test", usage=usage
        )

        assert math.isclose(completion_cost, 50 * 1.6e-06, rel_tol=1e-10)

    def test_dashscope_tier_zero_reasoning_rate_bills_reasoning_free(self):
        """
        Regression: a tier declaring an explicit zero reasoning rate had it treated as
        missing, billing reasoning tokens at the tier's output rate instead of free.
        """
        litellm.model_cost["dashscope/qwen-tier-zero-reasoning-test"] = {
            "litellm_provider": "dashscope",
            "mode": "chat",
            "tiered_pricing": [
                {
                    "range": [0, 1000],
                    "input_cost_per_token": 4e-07,
                    "output_cost_per_token": 1.6e-06,
                    "output_cost_per_reasoning_token": 0,
                }
            ],
        }

        usage = Usage(
            prompt_tokens=500,
            completion_tokens=200,
            completion_tokens_details=CompletionTokensDetailsWrapper(reasoning_tokens=150),
        )
        _, completion_cost = dashscope_cost_per_token(
            model="qwen-tier-zero-reasoning-test", usage=usage
        )

        assert math.isclose(completion_cost, 50 * 1.6e-06, rel_tol=1e-10)

    def test_dashscope_tiered_pricing_zero_input_falls_back_to_flat_rates(self):
        """
        No tier can be selected without input tokens, so an empty-prompt request must
        not be charged at the most expensive tier.
        """
        litellm.model_cost["dashscope/qwen-zero-input-test"] = {
            "litellm_provider": "dashscope",
            "mode": "chat",
            "input_cost_per_token": 4e-07,
            "output_cost_per_token": 1.6e-06,
            "tiered_pricing": [
                {
                    "range": [0, 1000],
                    "input_cost_per_token": 4e-07,
                    "output_cost_per_token": 1.6e-06,
                },
                {
                    "range": [1000, 2000],
                    "input_cost_per_token": 8e-07,
                    "output_cost_per_token": 3.2e-06,
                },
            ],
        }

        usage = Usage(prompt_tokens=0, completion_tokens=500)
        prompt_cost, completion_cost = dashscope_cost_per_token(
            model="qwen-zero-input-test", usage=usage
        )

        assert prompt_cost == 0.0
        assert math.isclose(completion_cost, 500 * 1.6e-06, rel_tol=1e-10)

    OFF_PEAK_WINDOW = "14:00-00:00"
    INSIDE_WINDOW = datetime(2026, 9, 3, 17, 25, tzinfo=timezone.utc)
    OUTSIDE_WINDOW = datetime(2026, 9, 3, 9, 0, tzinfo=timezone.utc)

    def _register_off_peak_flat_model(self, model_key: str, off_peak_pricing: dict) -> None:
        litellm.model_cost[model_key] = {
            "litellm_provider": "dashscope",
            "mode": "chat",
            "input_cost_per_token": 2.4e-06,
            "output_cost_per_token": 4.8e-06,
            "cache_read_input_token_cost": 2e-07,
            "cache_creation_input_token_cost": 3e-06,
            "off_peak_pricing": off_peak_pricing,
        }

    def test_dashscope_off_peak_window_swaps_in_the_off_peak_rates(self):
        """
        Regression (LIT-6782): a deployment configured with off_peak_pricing kept billing the
        standard dashscope rates inside its window, while the same block on a deepseek
        deployment billed the off-peak rates.
        """
        self._register_off_peak_flat_model(
            "dashscope/deepseek-off-peak-test",
            {
                "hours_utc": self.OFF_PEAK_WINDOW,
                "input_cost_per_token": 1.2e-06,
                "output_cost_per_token": 2.4e-06,
                "cache_read_input_token_cost": 1e-07,
            },
        )
        usage = Usage(
            prompt_tokens=1000,
            completion_tokens=200,
            prompt_tokens_details=PromptTokensDetailsWrapper(cached_tokens=300, cache_creation_tokens=100),
        )

        prompt_cost, completion_cost = dashscope_cost_per_token(
            model="deepseek-off-peak-test", usage=usage, current_time=self.INSIDE_WINDOW
        )

        assert math.isclose(prompt_cost, (600 * 1.2e-06) + (300 * 1e-07) + (100 * 3e-06), rel_tol=1e-10)
        assert math.isclose(completion_cost, 200 * 2.4e-06, rel_tol=1e-10)

        peak_prompt_cost, peak_completion_cost = dashscope_cost_per_token(
            model="deepseek-off-peak-test", usage=usage, current_time=self.OUTSIDE_WINDOW
        )

        assert math.isclose(peak_prompt_cost, (600 * 2.4e-06) + (300 * 2e-07) + (100 * 3e-06), rel_tol=1e-10)
        assert math.isclose(peak_completion_cost, 200 * 4.8e-06, rel_tol=1e-10)

    @pytest.mark.parametrize(
        ("cache_type", "expected_cache_rate"),
        [("ephemeral", 5e-08), (None, 8e-08)],
    )
    def test_dashscope_off_peak_uses_mode_specific_cache_read_rate(
        self, cache_type: str | None, expected_cache_rate: float
    ):
        model_key = "dashscope/qwen-cache-mode-off-peak-test"
        litellm.model_cost[model_key] = {
            "litellm_provider": "dashscope",
            "mode": "chat",
            "input_cost_per_token": 2e-06,
            "output_cost_per_token": 4e-06,
            "cache_read_input_token_cost": 2e-07,
            "explicit_cache_read_input_token_cost": 1e-07,
            "off_peak_pricing": {
                "hours_utc": self.OFF_PEAK_WINDOW,
                "input_cost_per_token": 1e-06,
                "cache_read_input_token_cost": 8e-08,
                "explicit_cache_read_input_token_cost": 5e-08,
            },
        }
        prompt_tokens_details: dict[str, int | str] = {"cached_tokens": 600}
        if cache_type is not None:
            prompt_tokens_details["cache_type"] = cache_type
        usage = Usage(
            prompt_tokens=1000,
            completion_tokens=0,
            prompt_tokens_details=prompt_tokens_details,
        )

        prompt_cost, _ = dashscope_cost_per_token(
            model="qwen-cache-mode-off-peak-test",
            usage=usage,
            current_time=self.INSIDE_WINDOW,
        )

        assert math.isclose(prompt_cost, (400 * 1e-06) + (600 * expected_cache_rate), rel_tol=1e-10)

    def test_dashscope_off_peak_window_overrides_the_selected_tier(self):
        """An open off-peak window bills the whole request at the flat off-peak rates, whichever tier
        the input volume selected."""
        self._register_tiered_model(
            "dashscope/qwen-tiered-off-peak-test",
            [
                {"range": [0, 1000], "input_cost_per_token": 4e-07, "output_cost_per_token": 1.6e-06},
                {"range": [1000, 2000], "input_cost_per_token": 8e-07, "output_cost_per_token": 3.2e-06},
            ],
        )
        litellm.model_cost["dashscope/qwen-tiered-off-peak-test"]["off_peak_pricing"] = {
            "hours_utc": self.OFF_PEAK_WINDOW,
            "input_cost_per_token": 1e-07,
            "output_cost_per_token": 4e-07,
        }
        usage = Usage(prompt_tokens=1500, completion_tokens=300)

        prompt_cost, completion_cost = dashscope_cost_per_token(
            model="qwen-tiered-off-peak-test", usage=usage, current_time=self.INSIDE_WINDOW
        )

        assert math.isclose(prompt_cost, 1500 * 1e-07, rel_tol=1e-10)
        assert math.isclose(completion_cost, 300 * 4e-07, rel_tol=1e-10)

        peak_prompt_cost, peak_completion_cost = dashscope_cost_per_token(
            model="qwen-tiered-off-peak-test", usage=usage, current_time=self.OUTSIDE_WINDOW
        )

        assert math.isclose(peak_prompt_cost, 1500 * 8e-07, rel_tol=1e-10)
        assert math.isclose(peak_completion_cost, 300 * 3.2e-06, rel_tol=1e-10)

    def test_dashscope_off_peak_rates_left_unset_keep_the_standard_rates(self):
        """A block that only overrides the input rate leaves output and cache reads on the standard
        rates, and an explicit reasoning rate is never swapped out."""
        self._register_off_peak_flat_model(
            "dashscope/qwen-partial-off-peak-test",
            {"hours_utc": self.OFF_PEAK_WINDOW, "input_cost_per_token": 1.2e-06},
        )
        litellm.model_cost["dashscope/qwen-partial-off-peak-test"]["output_cost_per_reasoning_token"] = 9e-06
        usage = Usage(
            prompt_tokens=1000,
            completion_tokens=200,
            prompt_tokens_details=PromptTokensDetailsWrapper(cached_tokens=300),
            completion_tokens_details=CompletionTokensDetailsWrapper(reasoning_tokens=50),
        )

        prompt_cost, completion_cost = dashscope_cost_per_token(
            model="qwen-partial-off-peak-test", usage=usage, current_time=self.INSIDE_WINDOW
        )

        assert math.isclose(prompt_cost, (700 * 1.2e-06) + (300 * 2e-07), rel_tol=1e-10)
        assert math.isclose(completion_cost, (150 * 4.8e-06) + (50 * 9e-06), rel_tol=1e-10)

    def test_dashscope_off_peak_output_rate_covers_reasoning_without_a_dedicated_rate(self):
        """Reasoning tokens on a model with no dedicated reasoning rate follow the off-peak output
        rate, the same way they follow the standard output rate outside the window."""
        self._register_off_peak_flat_model(
            "dashscope/qwen-reasoning-off-peak-test",
            {"hours_utc": self.OFF_PEAK_WINDOW, "output_cost_per_token": 2.4e-06},
        )
        usage = Usage(
            prompt_tokens=100,
            completion_tokens=200,
            completion_tokens_details=CompletionTokensDetailsWrapper(reasoning_tokens=50),
        )

        _, completion_cost = dashscope_cost_per_token(
            model="qwen-reasoning-off-peak-test", usage=usage, current_time=self.INSIDE_WINDOW
        )

        assert math.isclose(completion_cost, 200 * 2.4e-06, rel_tol=1e-10)

    def test_dashscope_off_peak_reasoning_rate_replaces_the_dedicated_reasoning_rate(self):
        self._register_off_peak_flat_model(
            "dashscope/qwen-reasoning-rate-off-peak-test",
            {
                "hours_utc": self.OFF_PEAK_WINDOW,
                "output_cost_per_token": 2.4e-06,
                "output_cost_per_reasoning_token": 4.5e-06,
            },
        )
        litellm.model_cost["dashscope/qwen-reasoning-rate-off-peak-test"]["output_cost_per_reasoning_token"] = 9e-06
        usage = Usage(
            prompt_tokens=100,
            completion_tokens=200,
            completion_tokens_details=CompletionTokensDetailsWrapper(reasoning_tokens=50),
        )

        _, completion_cost = dashscope_cost_per_token(
            model="qwen-reasoning-rate-off-peak-test", usage=usage, current_time=self.INSIDE_WINDOW
        )
        assert math.isclose(completion_cost, (150 * 2.4e-06) + (50 * 4.5e-06), rel_tol=1e-10)

        _, peak_completion_cost = dashscope_cost_per_token(
            model="qwen-reasoning-rate-off-peak-test", usage=usage, current_time=self.OUTSIDE_WINDOW
        )
        assert math.isclose(peak_completion_cost, (150 * 4.8e-06) + (50 * 9e-06), rel_tol=1e-10)

    def test_dashscope_off_peak_cache_creation_rate_replaces_the_standard_rate(self):
        self._register_off_peak_flat_model(
            "dashscope/qwen-cache-creation-off-peak-test",
            {"hours_utc": self.OFF_PEAK_WINDOW, "cache_creation_input_token_cost": 1.5e-06},
        )
        usage = Usage(
            prompt_tokens=1000,
            completion_tokens=10,
            prompt_tokens_details=PromptTokensDetailsWrapper(cached_tokens=300, cache_creation_tokens=100),
        )

        prompt_cost, _ = dashscope_cost_per_token(
            model="qwen-cache-creation-off-peak-test", usage=usage, current_time=self.INSIDE_WINDOW
        )
        assert math.isclose(prompt_cost, (600 * 2.4e-06) + (300 * 2e-07) + (100 * 1.5e-06), rel_tol=1e-10)

        peak_prompt_cost, _ = dashscope_cost_per_token(
            model="qwen-cache-creation-off-peak-test", usage=usage, current_time=self.OUTSIDE_WINDOW
        )
        assert math.isclose(peak_prompt_cost, (600 * 2.4e-06) + (300 * 2e-07) + (100 * 3e-06), rel_tol=1e-10)

    def test_dashscope_off_peak_reasoning_and_cache_creation_rates_override_the_selected_tier(self):
        self._register_tiered_model(
            "dashscope/qwen-tiered-reasoning-off-peak-test",
            [
                {
                    "range": [0, 1000],
                    "input_cost_per_token": 4e-07,
                    "cache_creation_input_token_cost": 3e-07,
                    "output_cost_per_token": 1.6e-06,
                    "output_cost_per_reasoning_token": 3.2e-06,
                },
            ],
        )
        litellm.model_cost["dashscope/qwen-tiered-reasoning-off-peak-test"]["off_peak_pricing"] = {
            "hours_utc": self.OFF_PEAK_WINDOW,
            "cache_creation_input_token_cost": 1e-07,
            "output_cost_per_reasoning_token": 8e-07,
        }
        usage = Usage(
            prompt_tokens=500,
            completion_tokens=100,
            prompt_tokens_details=PromptTokensDetailsWrapper(cache_creation_tokens=200),
            completion_tokens_details=CompletionTokensDetailsWrapper(reasoning_tokens=40),
        )

        prompt_cost, completion_cost = dashscope_cost_per_token(
            model="qwen-tiered-reasoning-off-peak-test", usage=usage, current_time=self.INSIDE_WINDOW
        )
        assert math.isclose(prompt_cost, (300 * 4e-07) + (200 * 1e-07), rel_tol=1e-10)
        assert math.isclose(completion_cost, (60 * 1.6e-06) + (40 * 8e-07), rel_tol=1e-10)

        peak_prompt_cost, peak_completion_cost = dashscope_cost_per_token(
            model="qwen-tiered-reasoning-off-peak-test", usage=usage, current_time=self.OUTSIDE_WINDOW
        )
        assert math.isclose(peak_prompt_cost, (300 * 4e-07) + (200 * 3e-07), rel_tol=1e-10)
        assert math.isclose(peak_completion_cost, (60 * 1.6e-06) + (40 * 3.2e-06), rel_tol=1e-10)

    def test_dashscope_off_peak_defaults_to_the_current_time(self):
        """The proxy's cost dispatch passes no clock, so an all-day window has to apply on the
        default current time."""
        self._register_off_peak_flat_model(
            "dashscope/qwen-all-day-off-peak-test",
            {"hours_utc": "00:00-00:00", "input_cost_per_token": 1.2e-06, "output_cost_per_token": 2.4e-06},
        )
        usage = Usage(prompt_tokens=1000, completion_tokens=200)

        prompt_cost, completion_cost = dashscope_cost_per_token(model="qwen-all-day-off-peak-test", usage=usage)

        assert math.isclose(prompt_cost, 1000 * 1.2e-06, rel_tol=1e-10)
        assert math.isclose(completion_cost, 200 * 2.4e-06, rel_tol=1e-10)