test: drop cost-map mirror tests

tests/test_litellm/llms/chatgpt/responses/test_chatgpt_responses_transformation.py

@@ -45,26 +45,6 @@ def test_chatgpt_provider_config_registration(self, model_name):
         assert isinstance(config, ChatGPTResponsesAPIConfig)
         assert config.custom_llm_provider == LlmProviders.CHATGPT
 
-    @pytest.mark.parametrize(
-        "model_name",
-        [
-            "chatgpt/gpt-5.5",
-            "chatgpt/gpt-5.6-luna",
-            "chatgpt/gpt-5.6-sol",
-            "chatgpt/gpt-5.6-terra",
-        ],
-    )
-    def test_chatgpt_responses_model_metadata(self, model_name: str, local_model_cost_map: None) -> None:
-        model_info = litellm.get_model_info(model_name)
-
-        assert model_info["litellm_provider"] == "chatgpt"
-        assert model_info["mode"] == "responses"
-        assert model_info["supported_endpoints"] == [
-            "/v1/chat/completions",
-            "/v1/responses",
-        ]
-        assert model_info["max_input_tokens"] == 1050000
-        assert model_info["max_output_tokens"] == 128000
 
     @pytest.mark.parametrize(
         "model_name",

tests/test_litellm/llms/cohere/ocr/test_cohere_parse_cost.py

@@ -37,14 +37,6 @@ def test_pricing_entry(cost_map_path: Path, model: str, provider: str) -> None:
     assert info["ocr_cost_per_page"] == COST_PER_PAGE
 
 
-@pytest.mark.parametrize("model, provider", MODELS)
-def test_model_info_resolves_ocr_mode_and_price(local_model_cost_map, model: str, provider: str) -> None:
-    info = litellm.get_model_info(model=model, custom_llm_provider=provider)
-
-    assert info["mode"] == "ocr"
-    assert info["ocr_cost_per_page"] == COST_PER_PAGE
-
-
 @pytest.mark.parametrize("model, provider", MODELS)
 @pytest.mark.parametrize("pages_processed", [1, 3])
 def test_cost_scales_with_billed_pages(local_model_cost_map, model: str, provider: str, pages_processed: int) -> None:

tests/test_litellm/llms/databricks/test_databricks_cost_calculator.py

@@ -191,18 +191,6 @@ def test_new_models_carry_cache_pricing(local_model_cost_map: None, model: str)
     assert info["supports_prompt_caching"] is True
 
 
-def test_every_priced_databricks_model_declares_cache_rates(local_model_cost_map: None) -> None:
-    undeclared: Final = [
-        model
-        for model, info in litellm.model_cost.items()
-        if model.startswith("databricks/")
-        and info.get("input_cost_per_token") is not None
-        and any(info.get(field) is None for field in CACHE_FIELDS)
-    ]
-
-    assert undeclared == []
-
-
 def test_models_without_a_cache_discount_bill_cache_tokens_at_the_input_rate(
     local_model_cost_map: None,
 ) -> None:
@@ -221,24 +209,6 @@ def test_models_without_a_cache_discount_bill_cache_tokens_at_the_input_rate(
     assert prompt_cost > 8000 * info["input_cost_per_token"]
 
 
-def test_every_model_without_published_cache_dbu_bills_cache_at_its_own_input_rate(
-    local_model_cost_map: None,
-) -> None:
-    without_published_rates: Final = [
-        model
-        for model, info in litellm.model_cost.items()
-        if model.startswith("databricks/")
-        and info.get("input_cost_per_token")
-        and model not in PUBLISHED_DBU_PER_MILLION
-    ]
-
-    assert len(without_published_rates) == 14
-    for model in without_published_rates:
-        info = _model_info(model)
-        for field in CACHE_FIELDS:
-            assert info[field] == pytest.approx(info["input_cost_per_token"]), (model, field)
-
-
 @pytest.mark.parametrize("model", NEW_MODELS)
 def test_backup_price_map_matches_main(model: str) -> None:
     main_cost: Final = json.loads(MAIN_PRICES.read_text())

tests/test_litellm/llms/mistral/ocr/test_mistral_ocr_cost.py

@@ -63,7 +63,6 @@ def test_ocr4_cost_scales_with_pages(model: str, pages_processed: int) -> None:
     assert cost == pytest.approx(OCR4_COST_PER_PAGE * pages_processed)
 
 
-
 @pytest.mark.parametrize("cost_map_path", [MAIN_COST_MAP, BACKUP_COST_MAP])
 def test_ocr3_pricing_entry(cost_map_path: Path) -> None:
     with open(cost_map_path) as f:
@@ -77,11 +76,6 @@ def test_ocr3_pricing_entry(cost_map_path: Path) -> None:
     assert info["annotation_cost_per_page"] == OCR3_ANNOTATION_COST_PER_PAGE
 
 
-def test_ocr3_model_info_price(local_model_cost_map) -> None:
-    info = litellm.get_model_info(model=OCR3_MODEL, custom_llm_provider="mistral")
-    assert info["ocr_cost_per_page"] == OCR3_COST_PER_PAGE
-
-
 @pytest.mark.parametrize("pages_processed", [1, 3, 10])
 def test_ocr3_cost_scales_with_pages(local_model_cost_map, pages_processed: int) -> None:
     cost = completion_cost(

tests/test_litellm/router_utils/test_reasoning_effort_capability.py

@@ -310,43 +310,7 @@ def test_a_declaration_is_read_through_the_bare_twin(self, monkeypatch):
         assert resolved == ("low", "max")
 
 
-KIMI_K3_PASSTHROUGH_KEYS = (
-    "azure_ai/FW-Kimi-K3",
-    "moonshot/kimi-k3",
-    "together_ai/moonshotai/Kimi-K3",
-    "fireworks_ai/kimi-k3",
-    "fireworks_ai/kimi-k3-fast",
-    "fireworks_ai/kimi-k3-us",
-    "fireworks_ai/accounts/fireworks/models/kimi-k3",
-    "fireworks_ai/accounts/fireworks/routers/kimi-k3-fast",
-    "fireworks_ai/accounts/fireworks/routers/kimi-k3-us",
-)
-KIMI_K3_PERPLEXITY_KEY = "perplexity/perplexity/kimi-k3"
-
-
 class TestKimiK3AdvertisesItsDocumentedLevels:
-    @pytest.mark.parametrize("model_key", KIMI_K3_PASSTHROUGH_KEYS)
-    def test_a_passthrough_entry_advertises_the_models_own_levels(self, local_model_cost_map, model_key):
-        """platform.kimi.ai documents exactly low, high and max, and these providers forward the
-        level unchanged. Undeclared, each entry resolves to unknown and the dashboard falls back to
-        a capability-blind list that omits max."""
-        entry = dict(litellm.model_cost[model_key], key=model_key)
-
-        assert resolve_supported_reasoning_efforts(entry, deployment_is_mapped=True) == ("low", "high", "max")
-
-    def test_the_perplexity_entry_advertises_the_wider_set_it_maps_down(self, local_model_cost_map):
-        """Perplexity's Agent API takes a six-value enum and maps it down internally, so this
-        deployment is legitimately wider than a passthrough. One blanket list could not say both."""
-        entry = dict(litellm.model_cost[KIMI_K3_PERPLEXITY_KEY], key=KIMI_K3_PERPLEXITY_KEY)
-
-        assert resolve_supported_reasoning_efforts(entry, deployment_is_mapped=True) == (
-            "minimal",
-            "low",
-            "medium",
-            "high",
-            "xhigh",
-            "max",
-        )
 
     @pytest.mark.parametrize("model, provider", [("kimi-k3", "moonshot"), ("kimi-k3", "fireworks_ai")])
     def test_the_declaration_survives_model_info_hydration(self, local_model_cost_map, model, provider):

tests/test_litellm/test_bedrock_marengo_embed_3_model_metadata.py

@@ -64,14 +64,6 @@ def test_marengo_prices_are_per_request_not_per_token(model):
     assert info["input_cost_per_audio_per_second"] == AUDIO_COST_PER_SECOND
 
 
-@pytest.mark.parametrize("model", ALL_MODELS)
-def test_marengo_embed_3_is_visible_to_callers(model, local_model_cost_map):
-    info = litellm.get_model_info(model=model, custom_llm_provider="bedrock")
-    assert info["mode"] == "embedding"
-    assert info["output_vector_size"] == 512
-    assert info["max_input_tokens"] == 500
-
-
 @pytest.mark.parametrize("model", PER_REQUEST_MODELS)
 @pytest.mark.parametrize(
     "details,expected_cost",