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]
Python ai-gatewayanthropicazure-openaibedrockgatewaylangchainlitellmllmllm-gatewayllmopsmcp-gatewayopenaiopenai-proxyrustrust-aivertex-ai
"""
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)