From e2595e7acf9fb5f8383278a190dc66517c4f607f Mon Sep 17 00:00:00 2001
From: Mihidum Hettiyahandi <55163074+mihidumh@users.noreply.github.com>
Date: Wed, 12 Aug 2026 13:21:42 +1000
Subject: [PATCH 01/12] fix(cost): honour deployment custom pricing for OCR
 calls
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ocr_cost() resolved pricing only via litellm.get_model_info(), a cost map
lookup keyed by model name. Custom pricing for a router deployment is
registered under the deployment id, and _register_custom_pricing_for_request
strips pricing fields from the shared {provider}/{model} key, so the lookup
could never see it. An OCR model absent from the cost map therefore billed
$0 regardless of configuration, even though ocr_cost_per_page and
ocr_cost_per_credit are declared CustomPricingLiteLLMParams fields.

Let ocr_cost() take deployment model_info and prefer it over the map when it
carries OCR pricing, with completion_cost() extracting it from
litellm_logging_obj.litellm_params["metadata"]["model_info"] — the same
extraction the video generation path already performs for the same reason.

Behaviour is unchanged when no custom pricing is set: the map lookup still
runs, and an unpriced model still returns 0.0.

Fixes #36608
---
 litellm/cost_calculator.py                    |  40 ++++++-
 tests/test_litellm/test_ocr_custom_pricing.py | 113 ++++++++++++++++++
 2 files changed, 149 insertions(+), 4 deletions(-)
 create mode 100644 tests/test_litellm/test_ocr_custom_pricing.py

diff --git a/litellm/cost_calculator.py b/litellm/cost_calculator.py
index 6536941a094..fb415d69fdf 100644
--- a/litellm/cost_calculator.py
+++ b/litellm/cost_calculator.py
@@ -334,6 +334,8 @@ def cost_per_token(
     response: Any | None = None,
     ### REQUEST MODEL ###
     request_model: str | None = None,  # original request model for router detection
+    ### DEPLOYMENT-SPECIFIC PRICING ###
+    custom_model_info: ModelInfo | None = None,  # deployment model_info, for non-token custom pricing
 ) -> tuple[float, float]:
     """
     Calculates the cost per token for a given model, prompt tokens, and completion tokens.
@@ -541,6 +543,7 @@ def cost_per_token(
             model=model,
             custom_llm_provider=custom_llm_provider,
             response=response,
+            model_info=custom_model_info,
         )
     elif (
         call_type == "aretrieve_batch"
@@ -1585,6 +1588,16 @@ def completion_cost(
                 if litellm_logging_obj is not None:
                     request_model_for_cost = litellm_logging_obj.model
 
+                # Deployment-specific model_info, for modalities whose pricing is
+                # not token-based and so cannot travel via custom_cost_per_token
+                # (e.g. OCR per-page pricing). Same extraction as the video path.
+                _custom_model_info: ModelInfo | None = None
+                if custom_pricing and litellm_logging_obj is not None:
+                    _cm_litellm_params = getattr(litellm_logging_obj, "litellm_params", None)
+                    if _cm_litellm_params is not None:
+                        _cm_metadata = _cm_litellm_params.get("metadata", {}) or {}
+                        _custom_model_info = _cm_metadata.get("model_info", None)
+
                 (
                     prompt_tokens_cost_usd_dollar,
                     completion_tokens_cost_usd_dollar,
@@ -1610,6 +1623,7 @@ def completion_cost(
                     vertex_location=vertex_location,
                     response=completion_response,
                     request_model=request_model_for_cost,
+                    custom_model_info=_custom_model_info,
                 )
 
                 # Get additional costs from provider (e.g., routing fees, infrastructure costs)
@@ -1843,12 +1857,16 @@ def ocr_cost(
     model: str,
     custom_llm_provider: str | None,
     response: object | None = None,
+    model_info: ModelInfo | None = None,
 ) -> tuple[float, float]:
     """
     Args:
         model: str - model name
         custom_llm_provider: Optional[str] - custom LLM provider
         response: Optional[Any] - response object
+        model_info: Optional[ModelInfo] - deployment-specific model info, used for
+            custom pricing. Takes precedence over the model cost map, mirroring
+            the video generation cost path.
 
     Returns:
         Tuple[float, float]: cost of OCR processing
@@ -1866,10 +1884,24 @@ def ocr_cost(
     if response.usage_info is None:
         raise ValueError("OCR response usage_info is None")
 
-    try:
-        model_info: ModelInfo | None = litellm.get_model_info(model=model, custom_llm_provider=custom_llm_provider)
-    except Exception:
-        model_info = None
+    #########################################################
+    # Deployment-specific pricing wins over the cost map.
+    #
+    # Custom pricing set on a deployment is registered under the router's
+    # deployment id, while the shared "{provider}/{model}" key has its pricing
+    # fields stripped (see _register_custom_pricing_for_request). A cost map
+    # lookup therefore cannot see it, so an OCR model that is not in the map
+    # bills $0 no matter how it is priced in config. Prefer the caller-supplied
+    # model_info when it carries OCR pricing.
+    #########################################################
+    has_custom_ocr_pricing: Final[bool] = model_info is not None and (
+        model_info.get("ocr_cost_per_page") is not None or model_info.get("ocr_cost_per_credit") is not None
+    )
+    if not has_custom_ocr_pricing:
+        try:
+            model_info = litellm.get_model_info(model=model, custom_llm_provider=custom_llm_provider)
+        except Exception:
+            model_info = None
 
     credits: Final = getattr(response.usage_info, "credits", None)
     cost_per_credit = None
diff --git a/tests/test_litellm/test_ocr_custom_pricing.py b/tests/test_litellm/test_ocr_custom_pricing.py
new file mode 100644
index 00000000000..7cd4fc1dec1
--- /dev/null
+++ b/tests/test_litellm/test_ocr_custom_pricing.py
@@ -0,0 +1,113 @@
+"""
+Regression tests: OCR cost must honour deployment-specific custom pricing.
+
+Before the fix, `ocr_cost()` resolved pricing exclusively through
+`litellm.get_model_info(model=..., custom_llm_provider=...)`, i.e. a cost map
+lookup keyed by model name. Custom pricing set on a deployment is registered
+under the router's deployment id, and the shared "{provider}/{model}" key has
+its pricing fields stripped, so the lookup could never see it. An OCR model
+absent from the cost map therefore billed $0 no matter how it was priced in
+config, even though `ocr_cost_per_page` / `ocr_cost_per_credit` are declared
+fields of `CustomPricingLiteLLMParams`.
+"""
+
+import pytest
+
+import litellm
+from litellm.cost_calculator import completion_cost, ocr_cost
+from litellm.llms.base_llm.ocr.transformation import OCRPage, OCRResponse, OCRUsageInfo
+
+# A model deliberately absent from the cost map.
+UNMAPPED_MODEL = "azure_ai/some-unmapped-ocr-model-for-testing"
+CUSTOM_COST_PER_PAGE = 0.004
+CUSTOM_COST_PER_CREDIT = 0.25
+
+
+def _ocr_response(model: str, pages_processed: int = 1, credits: int | None = None) -> OCRResponse:
+    # NOTE: model_construct() is used rather than OCRResponse(...) because the
+    # OCRResponse field `object: str = "ocr"` shadows the builtin `object` used
+    # in the `tables` / `keyValuePairs` annotations above it, so pydantic tries
+    # to resolve "ocr" as a forward-referenced type and schema building fails.
+    # That is an unrelated defect; validation is not what these tests exercise.
+    usage_info = OCRUsageInfo(pages_processed=pages_processed)
+    if credits is not None:
+        usage_info.credits = credits
+    return OCRResponse.model_construct(
+        pages=[OCRPage(index=i, markdown=f"page {i}") for i in range(pages_processed)],
+        model=model,
+        usage_info=usage_info,
+    )
+
+
+def test_unmapped_ocr_model_has_no_map_pricing() -> None:
+    """Guard the premise: the model really is absent from the cost map."""
+    assert UNMAPPED_MODEL not in litellm.model_cost
+
+
+@pytest.mark.parametrize("pages_processed", [1, 3, 10])
+def test_ocr_cost_uses_custom_per_page_pricing(pages_processed: int) -> None:
+    cost, _ = ocr_cost(
+        model=UNMAPPED_MODEL,
+        custom_llm_provider="azure_ai",
+        response=_ocr_response(UNMAPPED_MODEL, pages_processed=pages_processed),
+        model_info={"ocr_cost_per_page": CUSTOM_COST_PER_PAGE},
+    )
+    assert cost == pytest.approx(CUSTOM_COST_PER_PAGE * pages_processed)
+
+
+def test_ocr_cost_uses_custom_per_credit_pricing() -> None:
+    cost, _ = ocr_cost(
+        model=UNMAPPED_MODEL,
+        custom_llm_provider="azure_ai",
+        response=_ocr_response(UNMAPPED_MODEL, pages_processed=2, credits=4),
+        model_info={"ocr_cost_per_credit": CUSTOM_COST_PER_CREDIT},
+    )
+    assert cost == pytest.approx(CUSTOM_COST_PER_CREDIT * 4)
+
+
+def test_unmapped_ocr_model_without_custom_pricing_still_bills_zero() -> None:
+    """Unchanged behaviour when nothing is configured — no map entry, no override."""
+    cost, _ = ocr_cost(
+        model=UNMAPPED_MODEL,
+        custom_llm_provider="azure_ai",
+        response=_ocr_response(UNMAPPED_MODEL, pages_processed=5),
+    )
+    assert cost == 0.0
+
+
+def test_custom_pricing_does_not_override_a_mapped_model_when_absent() -> None:
+    """model_info without OCR pricing must fall through to the cost map."""
+    mapped_model = "mistral/mistral-ocr-4-0"
+    cost, _ = ocr_cost(
+        model=mapped_model,
+        custom_llm_provider="mistral",
+        response=_ocr_response(mapped_model, pages_processed=2),
+        model_info={"id": "some-deployment-id"},
+    )
+    assert cost == pytest.approx(0.004 * 2)
+
+
+def test_ocr_custom_pricing_end_to_end_through_completion_cost() -> None:
+    """The whole path: litellm_params.metadata.model_info -> ocr_cost."""
+    from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLogging
+
+    logging_obj = LiteLLMLogging(
+        model=UNMAPPED_MODEL,
+        messages=[],
+        stream=False,
+        call_type="ocr",
+        start_time=None,
+        litellm_call_id="test-ocr-custom-pricing",
+        function_id="1234",
+    )
+    logging_obj.litellm_params = {"metadata": {"model_info": {"ocr_cost_per_page": CUSTOM_COST_PER_PAGE}}}
+
+    cost = completion_cost(
+        completion_response=_ocr_response(UNMAPPED_MODEL, pages_processed=3),
+        model=UNMAPPED_MODEL,
+        custom_llm_provider="azure_ai",
+        call_type="ocr",
+        custom_pricing=True,
+        litellm_logging_obj=logging_obj,
+    )
+    assert cost == pytest.approx(CUSTOM_COST_PER_PAGE * 3)

From c77b5bada5435d56ce3f77d3e04572f1b5b08dab Mon Sep 17 00:00:00 2001
From: Mihidum Hettiyahandi <55163074+mihidumh@users.noreply.github.com>
Date: Mon, 17 Aug 2026 13:50:49 +1000
Subject: [PATCH 02/12] fix(cost): drop the `or {}` default so the metadata
 read adds no LIT002

The type-discipline gate failed on this PR: LIT002 (mutable-collection
construction) totalled 27149 against a ceiling of 27146, both new hits on
the `_cm_litellm_params.get("metadata", {}) or {}` line.

The two dict literals were only there to make the read total; a truthiness
check on the value does the same job and constructs nothing. Behaviour is
unchanged for every input: a missing, None or empty `metadata` leaves
`_custom_model_info` as None either way.

This copies the extraction in the video-generation path a few lines above,
which still carries the `or {}` form. That one is inside the gate's existing
budget, so it is left alone rather than reformatted in an unrelated PR.

scripts/type_discipline_gate.py --base b4f5e46a now reports "every LIT rule
is within its codebase ceiling"; tests/test_litellm/test_ocr_custom_pricing.py
is 8 passed.
---
 litellm/cost_calculator.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/litellm/cost_calculator.py b/litellm/cost_calculator.py
index fb415d69fdf..cb268513e00 100644
--- a/litellm/cost_calculator.py
+++ b/litellm/cost_calculator.py
@@ -1590,13 +1590,16 @@ def completion_cost(
 
                 # Deployment-specific model_info, for modalities whose pricing is
                 # not token-based and so cannot travel via custom_cost_per_token
-                # (e.g. OCR per-page pricing). Same extraction as the video path.
+                # (e.g. OCR per-page pricing). Same extraction as the video path
+                # above, minus its `or {}` default: truthiness on the value adds
+                # no mutable-collection construction (LIT002) and reads the same.
                 _custom_model_info: ModelInfo | None = None
                 if custom_pricing and litellm_logging_obj is not None:
                     _cm_litellm_params = getattr(litellm_logging_obj, "litellm_params", None)
                     if _cm_litellm_params is not None:
-                        _cm_metadata = _cm_litellm_params.get("metadata", {}) or {}
-                        _custom_model_info = _cm_metadata.get("model_info", None)
+                        _cm_metadata = _cm_litellm_params.get("metadata")
+                        if _cm_metadata:
+                            _custom_model_info = _cm_metadata.get("model_info", None)
 
                 (
                     prompt_tokens_cost_usd_dollar,

From 78ec018052f4332b38ad7889cc6878ed7ff8f31b Mon Sep 17 00:00:00 2001
From: Mihidum Hettiyahandi <55163074+mihidumh@users.noreply.github.com>
Date: Mon, 24 Aug 2026 09:23:39 +1000
Subject: [PATCH 03/12] fix(cost): read deployment model_info from
 litellm_metadata too

Router OCR calls go through _ageneric_api_call_with_fallbacks, which stores the
deployment's model_info under litellm_metadata rather than metadata, so the
custom OCR pricing was still unreachable on that path. Check both keys, metadata
first, mirroring _get_base_model_from_litellm_call_metadata. Adds an end-to-end
test for the litellm_metadata shape.
---
 litellm/cost_calculator.py                    | 11 +++++--
 tests/test_litellm/test_ocr_custom_pricing.py | 30 +++++++++++++++++++
 2 files changed, 38 insertions(+), 3 deletions(-)

diff --git a/litellm/cost_calculator.py b/litellm/cost_calculator.py
index cb268513e00..182c176121d 100644
--- a/litellm/cost_calculator.py
+++ b/litellm/cost_calculator.py
@@ -1593,13 +1593,18 @@ def completion_cost(
                 # (e.g. OCR per-page pricing). Same extraction as the video path
                 # above, minus its `or {}` default: truthiness on the value adds
                 # no mutable-collection construction (LIT002) and reads the same.
+                # Checked under both keys: router calls that go through
+                # `_ageneric_api_call_with_fallbacks` (OCR included) store the
+                # deployment's model_info under `litellm_metadata`, not `metadata`.
                 _custom_model_info: ModelInfo | None = None
                 if custom_pricing and litellm_logging_obj is not None:
                     _cm_litellm_params = getattr(litellm_logging_obj, "litellm_params", None)
                     if _cm_litellm_params is not None:
-                        _cm_metadata = _cm_litellm_params.get("metadata")
-                        if _cm_metadata:
-                            _custom_model_info = _cm_metadata.get("model_info", None)
+                        for _cm_metadata_key in ("metadata", "litellm_metadata"):
+                            _cm_metadata = _cm_litellm_params.get(_cm_metadata_key)
+                            if _cm_metadata and _cm_metadata.get("model_info") is not None:
+                                _custom_model_info = _cm_metadata.get("model_info")
+                                break
 
                 (
                     prompt_tokens_cost_usd_dollar,
diff --git a/tests/test_litellm/test_ocr_custom_pricing.py b/tests/test_litellm/test_ocr_custom_pricing.py
index 7cd4fc1dec1..4dffc43c23f 100644
--- a/tests/test_litellm/test_ocr_custom_pricing.py
+++ b/tests/test_litellm/test_ocr_custom_pricing.py
@@ -111,3 +111,33 @@ def test_ocr_custom_pricing_end_to_end_through_completion_cost() -> None:
         litellm_logging_obj=logging_obj,
     )
     assert cost == pytest.approx(CUSTOM_COST_PER_PAGE * 3)
+
+
+def test_ocr_custom_pricing_end_to_end_via_litellm_metadata() -> None:
+    """Router OCR calls go through `_ageneric_api_call_with_fallbacks`, which
+    stores the deployment's model_info under `litellm_metadata` rather than
+    `metadata`. The extraction must read that key too."""
+    from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLogging
+
+    logging_obj = LiteLLMLogging(
+        model=UNMAPPED_MODEL,
+        messages=[],
+        stream=False,
+        call_type="ocr",
+        start_time=None,
+        litellm_call_id="test-ocr-custom-pricing-litellm-metadata",
+        function_id="1234",
+    )
+    logging_obj.litellm_params = {
+        "litellm_metadata": {"model_info": {"ocr_cost_per_page": CUSTOM_COST_PER_PAGE}},
+    }
+
+    cost = completion_cost(
+        completion_response=_ocr_response(UNMAPPED_MODEL, pages_processed=3),
+        model=UNMAPPED_MODEL,
+        custom_llm_provider="azure_ai",
+        call_type="ocr",
+        custom_pricing=True,
+        litellm_logging_obj=logging_obj,
+    )
+    assert cost == pytest.approx(CUSTOM_COST_PER_PAGE * 3)

From 39239ab974374b52d37dafb944852c6ce62369f8 Mon Sep 17 00:00:00 2001
From: mateo-berri <277851410+mateo-berri@users.noreply.github.com>
Date: Tue, 8 Sep 2026 18:36:05 -0700
Subject: [PATCH 04/12] refactor(cost): share the deployment model_info lookup
 between video and OCR cost paths

Extract one immutable helper for reading the deployment's model_info off the
logging object, stop rebinding the model_info parameter inside ocr_cost, drop
the explanatory comment blocks, and move the OCR custom pricing regression
tests into tests/test_litellm/test_cost_calculator.py
---
 litellm/cost_calculator.py                    |  94 +++++-------
 tests/test_litellm/test_cost_calculator.py    | 130 ++++++++++++++++
 tests/test_litellm/test_ocr_custom_pricing.py | 143 ------------------
 3 files changed, 166 insertions(+), 201 deletions(-)
 delete mode 100644 tests/test_litellm/test_ocr_custom_pricing.py

diff --git a/litellm/cost_calculator.py b/litellm/cost_calculator.py
index 496f060d5ca..9aed82f37e3 100644
--- a/litellm/cost_calculator.py
+++ b/litellm/cost_calculator.py
@@ -341,7 +341,7 @@ def cost_per_token(
     ### REQUEST MODEL ###
     request_model: str | None = None,  # original request model for router detection
     ### DEPLOYMENT-SPECIFIC PRICING ###
-    custom_model_info: ModelInfo | None = None,  # deployment model_info, for non-token custom pricing
+    custom_model_info: ModelInfo | None = None,
 ) -> tuple[float, float]:
     """
     Calculates the cost per token for a given model, prompt tokens, and completion tokens.
@@ -1429,20 +1429,7 @@ def completion_cost(
                     )
                 elif call_type in _VIDEO_CALL_TYPES:
                     ### VIDEO GENERATION COST CALCULATION ###
-                    # Extract custom model_info for deployment-specific pricing
-                    _video_model_info: ModelInfo | None = None
-                    if custom_pricing and litellm_logging_obj is not None:
-                        _litellm_params = getattr(litellm_logging_obj, "litellm_params", None)
-                        if _litellm_params is not None:
-                            _video_model_info = next(
-                                (
-                                    model_info
-                                    for _metadata_key in ("metadata", "litellm_metadata")
-                                    if (model_info := (_litellm_params.get(_metadata_key) or {}).get("model_info"))
-                                    is not None
-                                ),
-                                None,
-                            )
+                    _video_model_info: ModelInfo | None = _deployment_model_info(litellm_logging_obj, custom_pricing)
 
                     usage_obj = getattr(completion_response, "usage", None)
                     duration_seconds: float | None = None
@@ -1638,24 +1625,6 @@ def completion_cost(
                 if litellm_logging_obj is not None:
                     request_model_for_cost = litellm_logging_obj.model
 
-                # Deployment-specific model_info, for modalities whose pricing is
-                # not token-based and so cannot travel via custom_cost_per_token
-                # (e.g. OCR per-page pricing). Same extraction as the video path
-                # above, minus its `or {}` default: truthiness on the value adds
-                # no mutable-collection construction (LIT002) and reads the same.
-                # Checked under both keys: router calls that go through
-                # `_ageneric_api_call_with_fallbacks` (OCR included) store the
-                # deployment's model_info under `litellm_metadata`, not `metadata`.
-                _custom_model_info: ModelInfo | None = None
-                if custom_pricing and litellm_logging_obj is not None:
-                    _cm_litellm_params = getattr(litellm_logging_obj, "litellm_params", None)
-                    if _cm_litellm_params is not None:
-                        for _cm_metadata_key in ("metadata", "litellm_metadata"):
-                            _cm_metadata = _cm_litellm_params.get(_cm_metadata_key)
-                            if _cm_metadata and _cm_metadata.get("model_info") is not None:
-                                _custom_model_info = _cm_metadata.get("model_info")
-                                break
-
                 (
                     prompt_tokens_cost_usd_dollar,
                     completion_tokens_cost_usd_dollar,
@@ -1681,7 +1650,7 @@ def completion_cost(
                     vertex_location=vertex_location,
                     response=completion_response,
                     request_model=request_model_for_cost,
-                    custom_model_info=_custom_model_info,
+                    custom_model_info=_deployment_model_info(litellm_logging_obj, custom_pricing),
                 )
 
                 # Get additional costs from provider (e.g., routing fees, infrastructure costs)
@@ -1911,6 +1880,32 @@ def response_cost_calculator(
         raise e
 
 
+def _deployment_model_info(
+    litellm_logging_obj: LitellmLoggingObject | None,
+    custom_pricing: bool | None,
+) -> ModelInfo | None:
+    if not custom_pricing or litellm_logging_obj is None:
+        return None
+    litellm_params: Final = getattr(litellm_logging_obj, "litellm_params", None)
+    if litellm_params is None:
+        return None
+    return next(
+        (
+            model_info
+            for metadata_key in ("metadata", "litellm_metadata")
+            if (metadata := litellm_params.get(metadata_key)) and (model_info := metadata.get("model_info")) is not None
+        ),
+        None,
+    )
+
+
+def _cost_map_model_info(model: str, custom_llm_provider: str | None) -> ModelInfo | None:
+    try:
+        return litellm.get_model_info(model=model, custom_llm_provider=custom_llm_provider)
+    except Exception:
+        return None
+
+
 def ocr_cost(
     model: str,
     custom_llm_provider: str | None,
@@ -1922,9 +1917,8 @@ def ocr_cost(
         model: str - model name
         custom_llm_provider: Optional[str] - custom LLM provider
         response: Optional[Any] - response object
-        model_info: Optional[ModelInfo] - deployment-specific model info, used for
-            custom pricing. Takes precedence over the model cost map, mirroring
-            the video generation cost path.
+        model_info: Optional[ModelInfo] - deployment-specific model info; its OCR pricing
+            takes precedence over the model cost map
 
     Returns:
         Tuple[float, float]: cost of OCR processing
@@ -1942,34 +1936,18 @@ def ocr_cost(
     if response.usage_info is None:
         raise ValueError("OCR response usage_info is None")
 
-    #########################################################
-    # Deployment-specific pricing wins over the cost map.
-    #
-    # Custom pricing set on a deployment is registered under the router's
-    # deployment id, while the shared "{provider}/{model}" key has its pricing
-    # fields stripped (see _register_custom_pricing_for_request). A cost map
-    # lookup therefore cannot see it, so an OCR model that is not in the map
-    # bills $0 no matter how it is priced in config. Prefer the caller-supplied
-    # model_info when it carries OCR pricing.
-    #########################################################
-    has_custom_ocr_pricing: Final[bool] = model_info is not None and (
+    has_custom_ocr_pricing: Final = model_info is not None and (
         model_info.get("ocr_cost_per_page") is not None or model_info.get("ocr_cost_per_credit") is not None
     )
-    if not has_custom_ocr_pricing:
-        try:
-            model_info = litellm.get_model_info(model=model, custom_llm_provider=custom_llm_provider)
-        except Exception:
-            model_info = None
+    pricing: Final = model_info if has_custom_ocr_pricing else _cost_map_model_info(model, custom_llm_provider)
 
     credits: Final = getattr(response.usage_info, "credits", None)
-    cost_per_credit = None
-    if model_info is not None:
-        cost_per_credit = model_info.get("ocr_cost_per_credit")
+    cost_per_credit: Final = pricing.get("ocr_cost_per_credit") if pricing is not None else None
     if credits is not None and cost_per_credit is not None:
         return cost_per_credit * credits, 0.0
 
-    ocr_cost_per_page: Final = model_info.get("ocr_cost_per_page") if model_info is not None else None
-    annotation_cost_per_page: Final = model_info.get("annotation_cost_per_page") if model_info is not None else None
+    ocr_cost_per_page: Final = pricing.get("ocr_cost_per_page") if pricing is not None else None
+    annotation_cost_per_page: Final = pricing.get("annotation_cost_per_page") if pricing is not None else None
     annotation_rate: Final = annotation_cost_per_page if annotation_cost_per_page is not None else ocr_cost_per_page
 
     pages_processed: Final = response.usage_info.pages_processed
diff --git a/tests/test_litellm/test_cost_calculator.py b/tests/test_litellm/test_cost_calculator.py
index f8fa2231597..824108ab0ec 100644
--- a/tests/test_litellm/test_cost_calculator.py
+++ b/tests/test_litellm/test_cost_calculator.py
@@ -4645,3 +4645,133 @@ def test_collect_and_combine_realtime_usage_stores_partitioned_text_tokens() ->
     assert combined.completion_tokens_details.reasoning_tokens == 95
     assert combined.completion_tokens_details.text_tokens == 38
     assert combined.completion_tokens_details.audio_tokens == 0
+
+
+UNMAPPED_OCR_MODEL: Final = "azure_ai/some-unmapped-ocr-model-for-testing"
+MAPPED_OCR_MODEL: Final = "mistral/mistral-ocr-4-0"
+
+
+def _ocr_response(model: str, pages_processed: int, credits: float | None = None):
+    from litellm.llms.base_llm.ocr.transformation import OCRPage, OCRResponse, OCRUsageInfo
+
+    return OCRResponse(
+        pages=[OCRPage(index=index, markdown=f"page {index}") for index in range(pages_processed)],
+        model=model,
+        usage_info=OCRUsageInfo(pages_processed=pages_processed, credits=credits),
+    )
+
+
+def _ocr_logging_obj(litellm_params: dict):
+    from litellm.litellm_core_utils.litellm_logging import Logging
+
+    logging_obj = Logging(
+        model=UNMAPPED_OCR_MODEL,
+        messages=[],
+        stream=False,
+        call_type="ocr",
+        start_time=None,
+        litellm_call_id="test-ocr-custom-pricing",
+        function_id="1234",
+    )
+    logging_obj.litellm_params = litellm_params
+    return logging_obj
+
+
+@pytest.mark.parametrize("pages_processed", [1, 3, 10])
+def test_ocr_cost_uses_deployment_per_page_pricing_for_unmapped_model(pages_processed: int):
+    from litellm.cost_calculator import ocr_cost
+
+    assert UNMAPPED_OCR_MODEL not in litellm.model_cost
+    cost, _ = ocr_cost(
+        model=UNMAPPED_OCR_MODEL,
+        custom_llm_provider="azure_ai",
+        response=_ocr_response(UNMAPPED_OCR_MODEL, pages_processed=pages_processed),
+        model_info={"ocr_cost_per_page": 0.004},
+    )
+    assert cost == pytest.approx(0.004 * pages_processed)
+
+
+def test_ocr_cost_uses_deployment_per_credit_pricing_for_unmapped_model():
+    from litellm.cost_calculator import ocr_cost
+
+    cost, _ = ocr_cost(
+        model=UNMAPPED_OCR_MODEL,
+        custom_llm_provider="azure_ai",
+        response=_ocr_response(UNMAPPED_OCR_MODEL, pages_processed=2, credits=4),
+        model_info={"ocr_cost_per_credit": 0.25},
+    )
+    assert cost == pytest.approx(0.25 * 4)
+
+
+def test_ocr_cost_unmapped_model_without_deployment_pricing_bills_zero():
+    from litellm.cost_calculator import ocr_cost
+
+    cost, _ = ocr_cost(
+        model=UNMAPPED_OCR_MODEL,
+        custom_llm_provider="azure_ai",
+        response=_ocr_response(UNMAPPED_OCR_MODEL, pages_processed=5),
+        model_info={"id": "some-deployment-id"},
+    )
+    assert cost == 0.0
+
+
+@pytest.mark.usefixtures("_local_model_cost_map")
+def test_ocr_cost_deployment_pricing_overrides_cost_map_for_mapped_model():
+    from litellm.cost_calculator import ocr_cost
+
+    map_price: Final = litellm.get_model_info(MAPPED_OCR_MODEL)["ocr_cost_per_page"]
+    assert map_price is not None
+    override_price: Final = map_price * 10
+
+    cost, _ = ocr_cost(
+        model=MAPPED_OCR_MODEL,
+        custom_llm_provider="mistral",
+        response=_ocr_response(MAPPED_OCR_MODEL, pages_processed=2),
+        model_info={"ocr_cost_per_page": override_price},
+    )
+    assert cost == pytest.approx(override_price * 2)
+
+
+@pytest.mark.usefixtures("_local_model_cost_map")
+def test_ocr_cost_falls_through_to_cost_map_when_deployment_has_no_ocr_pricing():
+    from litellm.cost_calculator import ocr_cost
+
+    map_price: Final = litellm.get_model_info(MAPPED_OCR_MODEL)["ocr_cost_per_page"]
+    assert map_price is not None
+
+    cost, _ = ocr_cost(
+        model=MAPPED_OCR_MODEL,
+        custom_llm_provider="mistral",
+        response=_ocr_response(MAPPED_OCR_MODEL, pages_processed=2),
+        model_info={"id": "some-deployment-id"},
+    )
+    assert cost == pytest.approx(map_price * 2)
+
+
+@pytest.mark.parametrize("metadata_key", ["metadata", "litellm_metadata"])
+def test_completion_cost_ocr_reads_deployment_pricing_from_logging_metadata(metadata_key: str):
+    logging_obj = _ocr_logging_obj({metadata_key: {"model_info": {"ocr_cost_per_page": 0.004}}})
+
+    cost = completion_cost(
+        completion_response=_ocr_response(UNMAPPED_OCR_MODEL, pages_processed=3),
+        model=UNMAPPED_OCR_MODEL,
+        custom_llm_provider="azure_ai",
+        call_type="ocr",
+        custom_pricing=True,
+        litellm_logging_obj=logging_obj,
+    )
+    assert cost == pytest.approx(0.004 * 3)
+
+
+def test_completion_cost_ocr_ignores_deployment_pricing_without_custom_pricing_flag():
+    logging_obj = _ocr_logging_obj({"metadata": {"model_info": {"ocr_cost_per_page": 0.004}}})
+
+    cost = completion_cost(
+        completion_response=_ocr_response(UNMAPPED_OCR_MODEL, pages_processed=3),
+        model=UNMAPPED_OCR_MODEL,
+        custom_llm_provider="azure_ai",
+        call_type="ocr",
+        custom_pricing=False,
+        litellm_logging_obj=logging_obj,
+    )
+    assert cost == 0.0
diff --git a/tests/test_litellm/test_ocr_custom_pricing.py b/tests/test_litellm/test_ocr_custom_pricing.py
deleted file mode 100644
index 4dffc43c23f..00000000000
--- a/tests/test_litellm/test_ocr_custom_pricing.py
+++ /dev/null
@@ -1,143 +0,0 @@
-"""
-Regression tests: OCR cost must honour deployment-specific custom pricing.
-
-Before the fix, `ocr_cost()` resolved pricing exclusively through
-`litellm.get_model_info(model=..., custom_llm_provider=...)`, i.e. a cost map
-lookup keyed by model name. Custom pricing set on a deployment is registered
-under the router's deployment id, and the shared "{provider}/{model}" key has
-its pricing fields stripped, so the lookup could never see it. An OCR model
-absent from the cost map therefore billed $0 no matter how it was priced in
-config, even though `ocr_cost_per_page` / `ocr_cost_per_credit` are declared
-fields of `CustomPricingLiteLLMParams`.
-"""
-
-import pytest
-
-import litellm
-from litellm.cost_calculator import completion_cost, ocr_cost
-from litellm.llms.base_llm.ocr.transformation import OCRPage, OCRResponse, OCRUsageInfo
-
-# A model deliberately absent from the cost map.
-UNMAPPED_MODEL = "azure_ai/some-unmapped-ocr-model-for-testing"
-CUSTOM_COST_PER_PAGE = 0.004
-CUSTOM_COST_PER_CREDIT = 0.25
-
-
-def _ocr_response(model: str, pages_processed: int = 1, credits: int | None = None) -> OCRResponse:
-    # NOTE: model_construct() is used rather than OCRResponse(...) because the
-    # OCRResponse field `object: str = "ocr"` shadows the builtin `object` used
-    # in the `tables` / `keyValuePairs` annotations above it, so pydantic tries
-    # to resolve "ocr" as a forward-referenced type and schema building fails.
-    # That is an unrelated defect; validation is not what these tests exercise.
-    usage_info = OCRUsageInfo(pages_processed=pages_processed)
-    if credits is not None:
-        usage_info.credits = credits
-    return OCRResponse.model_construct(
-        pages=[OCRPage(index=i, markdown=f"page {i}") for i in range(pages_processed)],
-        model=model,
-        usage_info=usage_info,
-    )
-
-
-def test_unmapped_ocr_model_has_no_map_pricing() -> None:
-    """Guard the premise: the model really is absent from the cost map."""
-    assert UNMAPPED_MODEL not in litellm.model_cost
-
-
-@pytest.mark.parametrize("pages_processed", [1, 3, 10])
-def test_ocr_cost_uses_custom_per_page_pricing(pages_processed: int) -> None:
-    cost, _ = ocr_cost(
-        model=UNMAPPED_MODEL,
-        custom_llm_provider="azure_ai",
-        response=_ocr_response(UNMAPPED_MODEL, pages_processed=pages_processed),
-        model_info={"ocr_cost_per_page": CUSTOM_COST_PER_PAGE},
-    )
-    assert cost == pytest.approx(CUSTOM_COST_PER_PAGE * pages_processed)
-
-
-def test_ocr_cost_uses_custom_per_credit_pricing() -> None:
-    cost, _ = ocr_cost(
-        model=UNMAPPED_MODEL,
-        custom_llm_provider="azure_ai",
-        response=_ocr_response(UNMAPPED_MODEL, pages_processed=2, credits=4),
-        model_info={"ocr_cost_per_credit": CUSTOM_COST_PER_CREDIT},
-    )
-    assert cost == pytest.approx(CUSTOM_COST_PER_CREDIT * 4)
-
-
-def test_unmapped_ocr_model_without_custom_pricing_still_bills_zero() -> None:
-    """Unchanged behaviour when nothing is configured — no map entry, no override."""
-    cost, _ = ocr_cost(
-        model=UNMAPPED_MODEL,
-        custom_llm_provider="azure_ai",
-        response=_ocr_response(UNMAPPED_MODEL, pages_processed=5),
-    )
-    assert cost == 0.0
-
-
-def test_custom_pricing_does_not_override_a_mapped_model_when_absent() -> None:
-    """model_info without OCR pricing must fall through to the cost map."""
-    mapped_model = "mistral/mistral-ocr-4-0"
-    cost, _ = ocr_cost(
-        model=mapped_model,
-        custom_llm_provider="mistral",
-        response=_ocr_response(mapped_model, pages_processed=2),
-        model_info={"id": "some-deployment-id"},
-    )
-    assert cost == pytest.approx(0.004 * 2)
-
-
-def test_ocr_custom_pricing_end_to_end_through_completion_cost() -> None:
-    """The whole path: litellm_params.metadata.model_info -> ocr_cost."""
-    from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLogging
-
-    logging_obj = LiteLLMLogging(
-        model=UNMAPPED_MODEL,
-        messages=[],
-        stream=False,
-        call_type="ocr",
-        start_time=None,
-        litellm_call_id="test-ocr-custom-pricing",
-        function_id="1234",
-    )
-    logging_obj.litellm_params = {"metadata": {"model_info": {"ocr_cost_per_page": CUSTOM_COST_PER_PAGE}}}
-
-    cost = completion_cost(
-        completion_response=_ocr_response(UNMAPPED_MODEL, pages_processed=3),
-        model=UNMAPPED_MODEL,
-        custom_llm_provider="azure_ai",
-        call_type="ocr",
-        custom_pricing=True,
-        litellm_logging_obj=logging_obj,
-    )
-    assert cost == pytest.approx(CUSTOM_COST_PER_PAGE * 3)
-
-
-def test_ocr_custom_pricing_end_to_end_via_litellm_metadata() -> None:
-    """Router OCR calls go through `_ageneric_api_call_with_fallbacks`, which
-    stores the deployment's model_info under `litellm_metadata` rather than
-    `metadata`. The extraction must read that key too."""
-    from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLogging
-
-    logging_obj = LiteLLMLogging(
-        model=UNMAPPED_MODEL,
-        messages=[],
-        stream=False,
-        call_type="ocr",
-        start_time=None,
-        litellm_call_id="test-ocr-custom-pricing-litellm-metadata",
-        function_id="1234",
-    )
-    logging_obj.litellm_params = {
-        "litellm_metadata": {"model_info": {"ocr_cost_per_page": CUSTOM_COST_PER_PAGE}},
-    }
-
-    cost = completion_cost(
-        completion_response=_ocr_response(UNMAPPED_MODEL, pages_processed=3),
-        model=UNMAPPED_MODEL,
-        custom_llm_provider="azure_ai",
-        call_type="ocr",
-        custom_pricing=True,
-        litellm_logging_obj=logging_obj,
-    )
-    assert cost == pytest.approx(CUSTOM_COST_PER_PAGE * 3)

From 9a78bf638aa4688b790094241b2d3484b587d2f0 Mon Sep 17 00:00:00 2001
From: mateo-berri <277851410+mateo-berri@users.noreply.github.com>
Date: Tue, 8 Sep 2026 18:55:13 -0700
Subject: [PATCH 05/12] test(cost): type the OCR pricing test helpers

---
 tests/test_litellm/test_cost_calculator.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/tests/test_litellm/test_cost_calculator.py b/tests/test_litellm/test_cost_calculator.py
index 824108ab0ec..a602e6ee819 100644
--- a/tests/test_litellm/test_cost_calculator.py
+++ b/tests/test_litellm/test_cost_calculator.py
@@ -17,6 +17,8 @@ from litellm.cost_calculator import (
     handle_realtime_stream_cost_calculation,
     response_cost_calculator,
 )
+from litellm.litellm_core_utils.litellm_logging import Logging
+from litellm.llms.base_llm.ocr.transformation import OCRPage, OCRResponse, OCRUsageInfo
 from litellm.types.llms.openai import OpenAIRealtimeStreamList
 from litellm.types.utils import (
     CacheCreationTokenDetails,
@@ -4651,9 +4653,7 @@ UNMAPPED_OCR_MODEL: Final = "azure_ai/some-unmapped-ocr-model-for-testing"
 MAPPED_OCR_MODEL: Final = "mistral/mistral-ocr-4-0"
 
 
-def _ocr_response(model: str, pages_processed: int, credits: float | None = None):
-    from litellm.llms.base_llm.ocr.transformation import OCRPage, OCRResponse, OCRUsageInfo
-
+def _ocr_response(model: str, pages_processed: int, credits: float | None = None) -> OCRResponse:
     return OCRResponse(
         pages=[OCRPage(index=index, markdown=f"page {index}") for index in range(pages_processed)],
         model=model,
@@ -4661,9 +4661,7 @@ def _ocr_response(model: str, pages_processed: int, credits: float | None = None
     )
 
 
-def _ocr_logging_obj(litellm_params: dict):
-    from litellm.litellm_core_utils.litellm_logging import Logging
-
+def _ocr_logging_obj(litellm_params: dict[str, dict[str, ModelInfo]]) -> Logging:
     logging_obj = Logging(
         model=UNMAPPED_OCR_MODEL,
         messages=[],

From a29103cbbffdaaa0044e084b5a1c264bcf67361b Mon Sep 17 00:00:00 2001
From: mateo-berri <277851410+mateo-berri@users.noreply.github.com>
Date: Tue, 8 Sep 2026 19:43:31 -0700
Subject: [PATCH 06/12] fix(cost): read OCR pricing registered under the router
 deployment id

---
 litellm/cost_calculator.py                 | 18 +++++++++++++++---
 tests/test_litellm/test_cost_calculator.py | 19 +++++++++++++++++++
 2 files changed, 34 insertions(+), 3 deletions(-)

diff --git a/litellm/cost_calculator.py b/litellm/cost_calculator.py
index 9aed82f37e3..afafc12623a 100644
--- a/litellm/cost_calculator.py
+++ b/litellm/cost_calculator.py
@@ -1429,7 +1429,9 @@ def completion_cost(
                     )
                 elif call_type in _VIDEO_CALL_TYPES:
                     ### VIDEO GENERATION COST CALCULATION ###
-                    _video_model_info: ModelInfo | None = _deployment_model_info(litellm_logging_obj, custom_pricing)
+                    _video_model_info: ModelInfo | None = _deployment_model_info(
+                        litellm_logging_obj, custom_pricing, router_model_id
+                    )
 
                     usage_obj = getattr(completion_response, "usage", None)
                     duration_seconds: float | None = None
@@ -1650,7 +1652,7 @@ def completion_cost(
                     vertex_location=vertex_location,
                     response=completion_response,
                     request_model=request_model_for_cost,
-                    custom_model_info=_deployment_model_info(litellm_logging_obj, custom_pricing),
+                    custom_model_info=_deployment_model_info(litellm_logging_obj, custom_pricing, router_model_id),
                 )
 
                 # Get additional costs from provider (e.g., routing fees, infrastructure costs)
@@ -1883,8 +1885,18 @@ def response_cost_calculator(
 def _deployment_model_info(
     litellm_logging_obj: LitellmLoggingObject | None,
     custom_pricing: bool | None,
+    router_model_id: str | None,
 ) -> ModelInfo | None:
-    if not custom_pricing or litellm_logging_obj is None:
+    if not custom_pricing:
+        return None
+    registered_deployment_info: Final = (
+        _cost_map_model_info(router_model_id, None)
+        if router_model_id is not None and router_model_id in litellm.model_cost
+        else None
+    )
+    if registered_deployment_info is not None:
+        return registered_deployment_info
+    if litellm_logging_obj is None:
         return None
     litellm_params: Final = getattr(litellm_logging_obj, "litellm_params", None)
     if litellm_params is None:
diff --git a/tests/test_litellm/test_cost_calculator.py b/tests/test_litellm/test_cost_calculator.py
index a602e6ee819..04a547c222c 100644
--- a/tests/test_litellm/test_cost_calculator.py
+++ b/tests/test_litellm/test_cost_calculator.py
@@ -4761,6 +4761,25 @@ def test_completion_cost_ocr_reads_deployment_pricing_from_logging_metadata(meta
     assert cost == pytest.approx(0.004 * 3)
 
 
+def test_completion_cost_ocr_prefers_pricing_registered_under_router_model_id(monkeypatch: pytest.MonkeyPatch):
+    deployment_id: Final = "ocr-deployment-priced-through-litellm-params"
+    monkeypatch.setitem(
+        litellm.model_cost, deployment_id, {"mode": "ocr", "litellm_provider": "azure_ai", "ocr_cost_per_page": 0.05}
+    )
+    logging_obj = _ocr_logging_obj({"metadata": {"model_info": {"mode": "ocr"}}})
+
+    cost = completion_cost(
+        completion_response=_ocr_response(UNMAPPED_OCR_MODEL, pages_processed=3),
+        model=UNMAPPED_OCR_MODEL,
+        custom_llm_provider="azure_ai",
+        call_type="ocr",
+        custom_pricing=True,
+        router_model_id=deployment_id,
+        litellm_logging_obj=logging_obj,
+    )
+    assert cost == pytest.approx(0.05 * 3)
+
+
 def test_completion_cost_ocr_ignores_deployment_pricing_without_custom_pricing_flag():
     logging_obj = _ocr_logging_obj({"metadata": {"model_info": {"ocr_cost_per_page": 0.004}}})
 

From 2c7751219d1a0e260d3088dc83cbb0df1934ec5c Mon Sep 17 00:00:00 2001
From: mateo-berri <277851410+mateo-berri@users.noreply.github.com>
Date: Tue, 8 Sep 2026 20:04:23 -0700
Subject: [PATCH 07/12] fix(ocr): bill request-level OCR pricing and fall back
 to the map without credits

---
 litellm/cost_calculator.py                 |  5 ++-
 litellm/ocr/main.py                        |  2 +
 tests/test_litellm/ocr/test_main.py        | 49 ++++++++++++++++++++++
 tests/test_litellm/test_cost_calculator.py | 16 +++++++
 4 files changed, 70 insertions(+), 2 deletions(-)
 create mode 100644 tests/test_litellm/ocr/test_main.py

diff --git a/litellm/cost_calculator.py b/litellm/cost_calculator.py
index afafc12623a..68f52e4a10e 100644
--- a/litellm/cost_calculator.py
+++ b/litellm/cost_calculator.py
@@ -1948,12 +1948,13 @@ def ocr_cost(
     if response.usage_info is None:
         raise ValueError("OCR response usage_info is None")
 
+    credits: Final = getattr(response.usage_info, "credits", None)
     has_custom_ocr_pricing: Final = model_info is not None and (
-        model_info.get("ocr_cost_per_page") is not None or model_info.get("ocr_cost_per_credit") is not None
+        model_info.get("ocr_cost_per_page") is not None
+        or (credits is not None and model_info.get("ocr_cost_per_credit") is not None)
     )
     pricing: Final = model_info if has_custom_ocr_pricing else _cost_map_model_info(model, custom_llm_provider)
 
-    credits: Final = getattr(response.usage_info, "credits", None)
     cost_per_credit: Final = pricing.get("ocr_cost_per_credit") if pricing is not None else None
     if credits is not None and cost_per_credit is not None:
         return cost_per_credit * credits, 0.0
diff --git a/litellm/ocr/main.py b/litellm/ocr/main.py
index df3f9d2096b..8b0e6950801 100644
--- a/litellm/ocr/main.py
+++ b/litellm/ocr/main.py
@@ -32,6 +32,7 @@ from litellm.rust_bridge import ocr as rust_ocr_bridge
 from litellm.rust_bridge.bindings import native_exception_types
 from litellm.rust_bridge.configuration import rust_enabled
 from litellm.types.router import GenericLiteLLMParams
+from litellm.types.utils import CustomPricingLiteLLMParams
 from litellm.utils import ProviderConfigManager, client
 
 ####### ENVIRONMENT VARIABLES ###################
@@ -171,6 +172,7 @@ def _prepare_ocr_request(
         litellm_params={
             "litellm_call_id": litellm_call_id,
             "api_base": api_base,
+            **litellm_params.model_dump(include=frozenset(CustomPricingLiteLLMParams.model_fields), exclude_none=True),
         },
         custom_llm_provider=custom_llm_provider,
     )
diff --git a/tests/test_litellm/ocr/test_main.py b/tests/test_litellm/ocr/test_main.py
new file mode 100644
index 00000000000..0007d98dcb0
--- /dev/null
+++ b/tests/test_litellm/ocr/test_main.py
@@ -0,0 +1,49 @@
+from typing import Final
+
+from litellm.litellm_core_utils.litellm_logging import Logging, use_custom_pricing_for_model
+from litellm.ocr.main import _prepare_ocr_request
+
+OCR_MODEL: Final = "mistral/mistral-ocr-4-1"
+DOCUMENT: Final = {"type": "document_url", "document_url": "https://example.com/doc.pdf"}
+
+
+def _logging_obj() -> Logging:
+    return Logging(
+        model=OCR_MODEL,
+        messages=[],
+        stream=False,
+        call_type="ocr",
+        start_time=None,
+        litellm_call_id="test-ocr-request-pricing",
+        function_id="1234",
+    )
+
+
+def _prepare(kwargs: dict[str, object]) -> Logging:
+    logging_obj: Final = _logging_obj()
+    _prepare_ocr_request(
+        model=OCR_MODEL,
+        document=dict(DOCUMENT),
+        api_key="test-key",
+        api_base=None,
+        timeout=None,
+        custom_llm_provider=None,
+        extra_headers=None,
+        kwargs={"litellm_logging_obj": logging_obj, **kwargs},
+    )
+    return logging_obj
+
+
+def test_prepare_ocr_request_forwards_custom_pricing_to_logging_params() -> None:
+    logging_obj: Final = _prepare({"ocr_cost_per_page": 0.05, "ocr_cost_per_credit": 0.5})
+
+    assert logging_obj.litellm_params["ocr_cost_per_page"] == 0.05
+    assert logging_obj.litellm_params["ocr_cost_per_credit"] == 0.5
+    assert use_custom_pricing_for_model(logging_obj.litellm_params) is True
+
+
+def test_prepare_ocr_request_without_custom_pricing_leaves_logging_params_unpriced() -> None:
+    logging_obj: Final = _prepare({})
+
+    assert "ocr_cost_per_page" not in logging_obj.litellm_params
+    assert use_custom_pricing_for_model(logging_obj.litellm_params) is False
diff --git a/tests/test_litellm/test_cost_calculator.py b/tests/test_litellm/test_cost_calculator.py
index 04a547c222c..cb9217b2f41 100644
--- a/tests/test_litellm/test_cost_calculator.py
+++ b/tests/test_litellm/test_cost_calculator.py
@@ -4746,6 +4746,22 @@ def test_ocr_cost_falls_through_to_cost_map_when_deployment_has_no_ocr_pricing()
     assert cost == pytest.approx(map_price * 2)
 
 
+@pytest.mark.usefixtures("_local_model_cost_map")
+def test_ocr_cost_ignores_deployment_credit_pricing_when_response_reports_no_credits():
+    from litellm.cost_calculator import ocr_cost
+
+    map_price: Final = litellm.get_model_info(MAPPED_OCR_MODEL)["ocr_cost_per_page"]
+    assert map_price is not None
+
+    cost, _ = ocr_cost(
+        model=MAPPED_OCR_MODEL,
+        custom_llm_provider="mistral",
+        response=_ocr_response(MAPPED_OCR_MODEL, pages_processed=2),
+        model_info={"ocr_cost_per_credit": 0.5},
+    )
+    assert cost == pytest.approx(map_price * 2)
+
+
 @pytest.mark.parametrize("metadata_key", ["metadata", "litellm_metadata"])
 def test_completion_cost_ocr_reads_deployment_pricing_from_logging_metadata(metadata_key: str):
     logging_obj = _ocr_logging_obj({metadata_key: {"model_info": {"ocr_cost_per_page": 0.004}}})

From 45fad445ebad1af76b4923f4722abbd080db3f04 Mon Sep 17 00:00:00 2001
From: mateo-berri <277851410+mateo-berri@users.noreply.github.com>
Date: Wed, 9 Sep 2026 19:07:16 -0700
Subject: [PATCH 08/12] fix(cost): bill request-level OCR pricing on direct SDK
 calls

---
 litellm/cost_calculator.py                 | 47 ++++++++++++++++++++--
 tests/test_litellm/ocr/test_main.py        | 18 ++++++++-
 tests/test_litellm/test_cost_calculator.py | 34 ++++++++++++++--
 3 files changed, 91 insertions(+), 8 deletions(-)

diff --git a/litellm/cost_calculator.py b/litellm/cost_calculator.py
index 68f52e4a10e..6d35a9e89aa 100644
--- a/litellm/cost_calculator.py
+++ b/litellm/cost_calculator.py
@@ -9,6 +9,7 @@ from typing import TYPE_CHECKING, Any, Final, Literal, cast
 
 from httpx import Response
 from pydantic import BaseModel
+from typing_extensions import ReadOnly, TypedDict
 
 import litellm
 import litellm._logging
@@ -306,6 +307,15 @@ def _transcription_usage_has_token_details(
     return (prompt_tokens_val > 0) or (completion_tokens_val > 0)
 
 
+OCRPricingField = Literal["ocr_cost_per_page", "ocr_cost_per_credit", "annotation_cost_per_page"]
+
+
+class OCRPricing(TypedDict, total=False):
+    ocr_cost_per_page: ReadOnly[float | None]
+    ocr_cost_per_credit: ReadOnly[float | None]
+    annotation_cost_per_page: ReadOnly[float | None]
+
+
 def cost_per_token(
     model: str = "",
     prompt_tokens: int = 0,
@@ -341,7 +351,7 @@ def cost_per_token(
     ### REQUEST MODEL ###
     request_model: str | None = None,  # original request model for router detection
     ### DEPLOYMENT-SPECIFIC PRICING ###
-    custom_model_info: ModelInfo | None = None,
+    custom_model_info: OCRPricing | None = None,
 ) -> tuple[float, float]:
     """
     Calculates the cost per token for a given model, prompt tokens, and completion tokens.
@@ -1652,7 +1662,7 @@ def completion_cost(
                     vertex_location=vertex_location,
                     response=completion_response,
                     request_model=request_model_for_cost,
-                    custom_model_info=_deployment_model_info(litellm_logging_obj, custom_pricing, router_model_id),
+                    custom_model_info=_ocr_model_info(litellm_logging_obj, custom_pricing, router_model_id),
                 )
 
                 # Get additional costs from provider (e.g., routing fees, infrastructure costs)
@@ -1911,6 +1921,35 @@ def _deployment_model_info(
     )
 
 
+def _ocr_model_info(
+    litellm_logging_obj: LitellmLoggingObject | None,
+    custom_pricing: bool | None,
+    router_model_id: str | None,
+) -> OCRPricing | None:
+    deployment_info: Final = _deployment_model_info(litellm_logging_obj, custom_pricing, router_model_id)
+    litellm_params: Final = getattr(litellm_logging_obj, "litellm_params", None) if custom_pricing else None
+    if litellm_params is None:
+        return deployment_info
+    return OCRPricing(
+        ocr_cost_per_page=_request_or_deployment_price("ocr_cost_per_page", litellm_params, deployment_info),
+        ocr_cost_per_credit=_request_or_deployment_price("ocr_cost_per_credit", litellm_params, deployment_info),
+        annotation_cost_per_page=_request_or_deployment_price(
+            "annotation_cost_per_page", litellm_params, deployment_info
+        ),
+    )
+
+
+def _request_or_deployment_price(
+    field: OCRPricingField,
+    litellm_params: Mapping[str, object],
+    deployment_info: ModelInfo | None,
+) -> float | None:
+    request_price: Final = litellm_params.get(field)
+    if isinstance(request_price, int | float):
+        return request_price
+    return deployment_info.get(field) if deployment_info is not None else None
+
+
 def _cost_map_model_info(model: str, custom_llm_provider: str | None) -> ModelInfo | None:
     try:
         return litellm.get_model_info(model=model, custom_llm_provider=custom_llm_provider)
@@ -1922,14 +1961,14 @@ def ocr_cost(
     model: str,
     custom_llm_provider: str | None,
     response: object | None = None,
-    model_info: ModelInfo | None = None,
+    model_info: OCRPricing | None = None,
 ) -> tuple[float, float]:
     """
     Args:
         model: str - model name
         custom_llm_provider: Optional[str] - custom LLM provider
         response: Optional[Any] - response object
-        model_info: Optional[ModelInfo] - deployment-specific model info; its OCR pricing
+        model_info: Optional[OCRPricing] - deployment-specific model info; its OCR pricing
             takes precedence over the model cost map
 
     Returns:
diff --git a/tests/test_litellm/ocr/test_main.py b/tests/test_litellm/ocr/test_main.py
index 0007d98dcb0..de4b28dafdd 100644
--- a/tests/test_litellm/ocr/test_main.py
+++ b/tests/test_litellm/ocr/test_main.py
@@ -1,9 +1,13 @@
 from typing import Final
 
+import pytest
+
+import litellm
 from litellm.litellm_core_utils.litellm_logging import Logging, use_custom_pricing_for_model
+from litellm.llms.base_llm.ocr.transformation import OCRPage, OCRResponse, OCRUsageInfo
 from litellm.ocr.main import _prepare_ocr_request
 
-OCR_MODEL: Final = "mistral/mistral-ocr-4-1"
+OCR_MODEL: Final = "mistral/some-unmapped-ocr-model-for-testing"
 DOCUMENT: Final = {"type": "document_url", "document_url": "https://example.com/doc.pdf"}
 
 
@@ -47,3 +51,15 @@ def test_prepare_ocr_request_without_custom_pricing_leaves_logging_params_unpric
 
     assert "ocr_cost_per_page" not in logging_obj.litellm_params
     assert use_custom_pricing_for_model(logging_obj.litellm_params) is False
+
+
+def test_direct_ocr_call_bills_request_level_per_page_pricing() -> None:
+    assert OCR_MODEL not in litellm.model_cost
+    logging_obj: Final = _prepare({"ocr_cost_per_page": 0.05})
+    response: Final = OCRResponse(
+        pages=[OCRPage(index=index, markdown=f"page {index}") for index in range(3)],
+        model=OCR_MODEL,
+        usage_info=OCRUsageInfo(pages_processed=3),
+    )
+
+    assert logging_obj._response_cost_calculator(result=response) == pytest.approx(0.05 * 3)
diff --git a/tests/test_litellm/test_cost_calculator.py b/tests/test_litellm/test_cost_calculator.py
index cb9217b2f41..6db91d7a775 100644
--- a/tests/test_litellm/test_cost_calculator.py
+++ b/tests/test_litellm/test_cost_calculator.py
@@ -4661,8 +4661,8 @@ def _ocr_response(model: str, pages_processed: int, credits: float | None = None
     )
 
 
-def _ocr_logging_obj(litellm_params: dict[str, dict[str, ModelInfo]]) -> Logging:
-    logging_obj = Logging(
+def _ocr_logging_obj(litellm_params: dict[str, object]) -> Logging:
+    logging_obj: Final = Logging(
         model=UNMAPPED_OCR_MODEL,
         messages=[],
         stream=False,
@@ -4671,7 +4671,7 @@ def _ocr_logging_obj(litellm_params: dict[str, dict[str, ModelInfo]]) -> Logging
         litellm_call_id="test-ocr-custom-pricing",
         function_id="1234",
     )
-    logging_obj.litellm_params = litellm_params
+    logging_obj.update_environment_variables(litellm_params=litellm_params, optional_params={})
     return logging_obj
 
 
@@ -4796,6 +4796,34 @@ def test_completion_cost_ocr_prefers_pricing_registered_under_router_model_id(mo
     assert cost == pytest.approx(0.05 * 3)
 
 
+def test_completion_cost_ocr_bills_request_level_pricing_for_direct_sdk_call():
+    logging_obj = _ocr_logging_obj({"ocr_cost_per_page": 0.05})
+
+    cost = completion_cost(
+        completion_response=_ocr_response(UNMAPPED_OCR_MODEL, pages_processed=3),
+        model=UNMAPPED_OCR_MODEL,
+        custom_llm_provider="azure_ai",
+        call_type="ocr",
+        custom_pricing=True,
+        litellm_logging_obj=logging_obj,
+    )
+    assert cost == pytest.approx(0.05 * 3)
+
+
+def test_completion_cost_ocr_request_level_pricing_fills_in_deployment_model_info_without_ocr_pricing():
+    logging_obj = _ocr_logging_obj({"ocr_cost_per_page": 0.05, "metadata": {"model_info": {"mode": "ocr"}}})
+
+    cost = completion_cost(
+        completion_response=_ocr_response(UNMAPPED_OCR_MODEL, pages_processed=3),
+        model=UNMAPPED_OCR_MODEL,
+        custom_llm_provider="azure_ai",
+        call_type="ocr",
+        custom_pricing=True,
+        litellm_logging_obj=logging_obj,
+    )
+    assert cost == pytest.approx(0.05 * 3)
+
+
 def test_completion_cost_ocr_ignores_deployment_pricing_without_custom_pricing_flag():
     logging_obj = _ocr_logging_obj({"metadata": {"model_info": {"ocr_cost_per_page": 0.004}}})
 

From 763270e875f92b4c7eca2d636d56f7e6089ed63d Mon Sep 17 00:00:00 2001
From: mateo-berri <277851410+mateo-berri@users.noreply.github.com>
Date: Wed, 9 Sep 2026 19:24:55 -0700
Subject: [PATCH 09/12] fix(cost): treat annotation-only deployment pricing as
 custom OCR pricing

---
 litellm/cost_calculator.py                 |  1 +
 tests/test_litellm/test_cost_calculator.py | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+)

diff --git a/litellm/cost_calculator.py b/litellm/cost_calculator.py
index 422e340abf5..09700ad6b72 100644
--- a/litellm/cost_calculator.py
+++ b/litellm/cost_calculator.py
@@ -1999,6 +1999,7 @@ def ocr_cost(
     credits: Final = getattr(response.usage_info, "credits", None)
     has_custom_ocr_pricing: Final = model_info is not None and (
         model_info.get("ocr_cost_per_page") is not None
+        or model_info.get("annotation_cost_per_page") is not None
         or (credits is not None and model_info.get("ocr_cost_per_credit") is not None)
     )
     pricing: Final = model_info if has_custom_ocr_pricing else _cost_map_model_info(model, custom_llm_provider)
diff --git a/tests/test_litellm/test_cost_calculator.py b/tests/test_litellm/test_cost_calculator.py
index a0ae9511aff..a05fadce42d 100644
--- a/tests/test_litellm/test_cost_calculator.py
+++ b/tests/test_litellm/test_cost_calculator.py
@@ -4795,6 +4795,24 @@ def test_ocr_cost_uses_deployment_per_page_pricing_for_unmapped_model(pages_proc
     assert cost == pytest.approx(0.004 * pages_processed)
 
 
+def test_ocr_cost_uses_deployment_annotation_only_pricing_for_unmapped_model():
+    from litellm.cost_calculator import ocr_cost
+
+    assert UNMAPPED_OCR_MODEL not in litellm.model_cost
+    response: Final = OCRResponse(
+        pages=[OCRPage(index=index, markdown=f"page {index}") for index in range(3)],
+        model=UNMAPPED_OCR_MODEL,
+        usage_info=OCRUsageInfo(pages_processed=3, pages_processed_annotation=2),
+    )
+    cost, _ = ocr_cost(
+        model=UNMAPPED_OCR_MODEL,
+        custom_llm_provider="azure_ai",
+        response=response,
+        model_info={"annotation_cost_per_page": 0.01},
+    )
+    assert cost == pytest.approx(0.01 * 2)
+
+
 def test_ocr_cost_uses_deployment_per_credit_pricing_for_unmapped_model():
     from litellm.cost_calculator import ocr_cost
 

From d71f4aeff9587ae189446598de23b35e6d8d8142 Mon Sep 17 00:00:00 2001
From: mateo-berri <277851410+mateo-berri@users.noreply.github.com>
Date: Wed, 9 Sep 2026 19:47:00 -0700
Subject: [PATCH 10/12] fix(cost): layer deployment OCR rates over the cost map
 field by field

---
 litellm/cost_calculator.py                 | 45 +++++++++-------------
 tests/test_litellm/test_cost_calculator.py | 18 +++++++++
 2 files changed, 37 insertions(+), 26 deletions(-)

diff --git a/litellm/cost_calculator.py b/litellm/cost_calculator.py
index 09700ad6b72..93d9609df9e 100644
--- a/litellm/cost_calculator.py
+++ b/litellm/cost_calculator.py
@@ -1939,24 +1939,22 @@ def _ocr_model_info(
     litellm_params: Final = getattr(litellm_logging_obj, "litellm_params", None) if custom_pricing else None
     if litellm_params is None:
         return deployment_info
-    return OCRPricing(
-        ocr_cost_per_page=_request_or_deployment_price("ocr_cost_per_page", litellm_params, deployment_info),
-        ocr_cost_per_credit=_request_or_deployment_price("ocr_cost_per_credit", litellm_params, deployment_info),
-        annotation_cost_per_page=_request_or_deployment_price(
-            "annotation_cost_per_page", litellm_params, deployment_info
-        ),
+    return _layered_ocr_pricing(litellm_params, deployment_info)
+
+
+def _first_ocr_price(field: OCRPricingField, *sources: Mapping[str, object] | None) -> float | None:
+    return next(
+        (price for source in sources if source is not None and isinstance(price := source.get(field), int | float)),
+        None,
     )
 
 
-def _request_or_deployment_price(
-    field: OCRPricingField,
-    litellm_params: Mapping[str, object],
-    deployment_info: ModelInfo | None,
-) -> float | None:
-    request_price: Final = litellm_params.get(field)
-    if isinstance(request_price, int | float):
-        return request_price
-    return deployment_info.get(field) if deployment_info is not None else None
+def _layered_ocr_pricing(*sources: Mapping[str, object] | None) -> OCRPricing:
+    return OCRPricing(
+        ocr_cost_per_page=_first_ocr_price("ocr_cost_per_page", *sources),
+        ocr_cost_per_credit=_first_ocr_price("ocr_cost_per_credit", *sources),
+        annotation_cost_per_page=_first_ocr_price("annotation_cost_per_page", *sources),
+    )
 
 
 def _cost_map_model_info(model: str, custom_llm_provider: str | None) -> ModelInfo | None:
@@ -1977,8 +1975,8 @@ def ocr_cost(
         model: str - model name
         custom_llm_provider: Optional[str] - custom LLM provider
         response: Optional[Any] - response object
-        model_info: Optional[OCRPricing] - deployment-specific model info; its OCR pricing
-            takes precedence over the model cost map
+        model_info: Optional[OCRPricing] - deployment-specific OCR pricing; each rate it sets
+            overrides the model cost map's, the rest fall back to the map
 
     Returns:
         Tuple[float, float]: cost of OCR processing
@@ -1997,19 +1995,14 @@ def ocr_cost(
         raise ValueError("OCR response usage_info is None")
 
     credits: Final = getattr(response.usage_info, "credits", None)
-    has_custom_ocr_pricing: Final = model_info is not None and (
-        model_info.get("ocr_cost_per_page") is not None
-        or model_info.get("annotation_cost_per_page") is not None
-        or (credits is not None and model_info.get("ocr_cost_per_credit") is not None)
-    )
-    pricing: Final = model_info if has_custom_ocr_pricing else _cost_map_model_info(model, custom_llm_provider)
+    pricing: Final = _layered_ocr_pricing(model_info, _cost_map_model_info(model, custom_llm_provider))
 
-    cost_per_credit: Final = pricing.get("ocr_cost_per_credit") if pricing is not None else None
+    cost_per_credit: Final = pricing.get("ocr_cost_per_credit")
     if credits is not None and cost_per_credit is not None:
         return cost_per_credit * credits, 0.0
 
-    ocr_cost_per_page: Final = pricing.get("ocr_cost_per_page") if pricing is not None else None
-    annotation_cost_per_page: Final = pricing.get("annotation_cost_per_page") if pricing is not None else None
+    ocr_cost_per_page: Final = pricing.get("ocr_cost_per_page")
+    annotation_cost_per_page: Final = pricing.get("annotation_cost_per_page")
     annotation_rate: Final = annotation_cost_per_page if annotation_cost_per_page is not None else ocr_cost_per_page
 
     pages_processed: Final = response.usage_info.pages_processed
diff --git a/tests/test_litellm/test_cost_calculator.py b/tests/test_litellm/test_cost_calculator.py
index a05fadce42d..d07ff231429 100644
--- a/tests/test_litellm/test_cost_calculator.py
+++ b/tests/test_litellm/test_cost_calculator.py
@@ -4813,6 +4813,24 @@ def test_ocr_cost_uses_deployment_annotation_only_pricing_for_unmapped_model():
     assert cost == pytest.approx(0.01 * 2)
 
 
+def test_ocr_cost_annotation_only_override_keeps_mapped_per_page_rate():
+    from litellm.cost_calculator import ocr_cost
+
+    map_price: Final = litellm.model_cost[MAPPED_OCR_MODEL]["ocr_cost_per_page"]
+    response: Final = OCRResponse(
+        pages=[OCRPage(index=index, markdown=f"page {index}") for index in range(3)],
+        model=MAPPED_OCR_MODEL,
+        usage_info=OCRUsageInfo(pages_processed=3, pages_processed_annotation=2),
+    )
+    cost, _ = ocr_cost(
+        model=MAPPED_OCR_MODEL,
+        custom_llm_provider="mistral",
+        response=response,
+        model_info={"annotation_cost_per_page": 0.01},
+    )
+    assert cost == pytest.approx(map_price * 3 + 0.01 * 2)
+
+
 def test_ocr_cost_uses_deployment_per_credit_pricing_for_unmapped_model():
     from litellm.cost_calculator import ocr_cost
 

From 251bc07e97dee08c6a61e3bf1b1e5d497e3d0c4e Mon Sep 17 00:00:00 2001
From: mateo-berri <277851410+mateo-berri@users.noreply.github.com>
Date: Thu, 10 Sep 2026 18:10:34 -0700
Subject: [PATCH 11/12] chore(cost): drop the section header comment above
 custom_model_info

---
 .git-check.out             | 58 ++++++++++++++++++++++++++++++++++++++
 litellm/cost_calculator.py |  1 -
 2 files changed, 58 insertions(+), 1 deletion(-)
 create mode 100644 .git-check.out

diff --git a/.git-check.out b/.git-check.out
new file mode 100644
index 00000000000..73092f18281
--- /dev/null
+++ b/.git-check.out
@@ -0,0 +1,58 @@
+uv sync --inexact --frozen --extra proxy --group proxy-dev --group e2e-dev
+Audited 232 packages in 79ms
+uv run --no-sync python scripts/prisma_generate_if_needed.py
+Environment variables loaded from .env
+Prisma schema loaded from litellm/proxy/schema.prisma
+Warning: The binaryTargets option is not officially supported by Prisma Client Python.
+
+✔ Generated Prisma Client Python (v0.11.0) to ./.venv/lib/python3.12/site-packages/prisma in 287ms
+
+cd ui/litellm-dashboard && ../../scripts/with_dashboard_node.sh npm install --no-audit --no-fund
+
+changed 1 package in 550ms
+bootstrap: .env left untouched
+bootstrap: done
+./scripts/pre_commit_lint.sh
+check: logging full output to /Users/mateo/Development/litellm/.git/worktrees/wt40516/pre_commit_lint.log
+check: nothing staged; scoping to the working tree's diff against the merge base with origin/litellm_internal_staging:
+    .git-check.out
+    litellm/cost_calculator.py
+    litellm/ocr/main.py
+    tests/test_litellm/ocr/test_main.py
+    tests/test_litellm/test_cost_calculator.py
+check: linting Python (make lint)
+uv sync --inexact --frozen --group proxy-dev --group e2e-dev
+Audited 205 packages in 51ms
+uv run --no-sync python scripts/prisma_generate_if_needed.py
+Prisma client already generated for litellm/proxy/schema.prisma (prisma 0.11.0); skipping prisma generate
+cd litellm && uv run --no-sync ruff check . && cd ..
+uv run --no-sync python scripts/ruff_strict_gate.py --base "origin/litellm_internal_staging"
+uv run --no-sync python scripts/type_discipline_gate.py --base "origin/litellm_internal_staging"
+uv run --no-sync python scripts/test_quality_gate.py --base "origin/litellm_internal_staging"
+uv run --no-sync python scripts/type_check_gate.py --base "origin/litellm_internal_staging"
+uv run --no-sync basedpyright tests/e2e
+cd litellm && uv run --no-sync python ../tests/documentation_tests/test_circular_imports.py && cd ..
+No LiteLLM type hints found.
+provisioning .venv-typecheck (first run installs packages and generates the Prisma client; re-runs are near-instant no-ops)
+2 files already formatted
+All checks passed!
+uv run --no-sync ruff check --config ruff-tests.toml tests
+warning: Invalid `# noqa` directive on tests/test_litellm/proxy/common_utils/test_user_api_key_cache.py:44: expected a comma-separated list of codes (e.g., `# noqa: F401, F841`).
+All checks passed!
+[from litellm import *] OK! no issues!
+OK: every strict rule is within its codebase ceiling (base origin/litellm_internal_staging)
+0 errors, 0 warnings, 0 notes
+OK: every TQ rule is within its test-suite ceiling (base origin/litellm_internal_staging)
+OK: every LIT rule is within its codebase ceiling (base origin/litellm_internal_staging)
+base counts fetched from CI artifact basedpyright-counts-64ab15e608f7cb59
+OK: every rule is within its basedpyright limit or no higher than base (138494 errors total)
+check: ruff format --check (scoped litellm files)
+2 files already formatted
+check: summary
+    ran:     Python lint (make lint)
+    skipped: tests/e2e checks (basedpyright + raw HTTP client ban) (no tests/e2e Python files in scope)
+    ran:     test-tree lint (ruff-tests.toml + test-quality budget)
+    skipped: dashboard lint (prettier + eslint + lint budgets) (no dashboard files in scope)
+    skipped: dashboard API-type sync (npm run gen:api) (no litellm/proxy, litellm/types, or generator files in scope)
+check: PASS
+check: full log: /Users/mateo/Development/litellm/.git/worktrees/wt40516/pre_commit_lint.log
diff --git a/litellm/cost_calculator.py b/litellm/cost_calculator.py
index 93d9609df9e..22bdb016dc1 100644
--- a/litellm/cost_calculator.py
+++ b/litellm/cost_calculator.py
@@ -354,7 +354,6 @@ def cost_per_token(
     response: Any | None = None,
     ### REQUEST MODEL ###
     request_model: str | None = None,  # original request model for router detection
-    ### DEPLOYMENT-SPECIFIC PRICING ###
     custom_model_info: OCRPricing | None = None,
 ) -> tuple[float, float]:
     """

From e4095077ec05984dc1f042caea3b661e257af4e1 Mon Sep 17 00:00:00 2001
From: mateo-berri <277851410+mateo-berri@users.noreply.github.com>
Date: Thu, 10 Sep 2026 18:23:57 -0700
Subject: [PATCH 12/12] chore: remove a stray local check log

---
 .git-check.out | 58 --------------------------------------------------
 1 file changed, 58 deletions(-)
 delete mode 100644 .git-check.out

diff --git a/.git-check.out b/.git-check.out
deleted file mode 100644
index 73092f18281..00000000000
--- a/.git-check.out
+++ /dev/null
@@ -1,58 +0,0 @@
-uv sync --inexact --frozen --extra proxy --group proxy-dev --group e2e-dev
-Audited 232 packages in 79ms
-uv run --no-sync python scripts/prisma_generate_if_needed.py
-Environment variables loaded from .env
-Prisma schema loaded from litellm/proxy/schema.prisma
-Warning: The binaryTargets option is not officially supported by Prisma Client Python.
-
-✔ Generated Prisma Client Python (v0.11.0) to ./.venv/lib/python3.12/site-packages/prisma in 287ms
-
-cd ui/litellm-dashboard && ../../scripts/with_dashboard_node.sh npm install --no-audit --no-fund
-
-changed 1 package in 550ms
-bootstrap: .env left untouched
-bootstrap: done
-./scripts/pre_commit_lint.sh
-check: logging full output to /Users/mateo/Development/litellm/.git/worktrees/wt40516/pre_commit_lint.log
-check: nothing staged; scoping to the working tree's diff against the merge base with origin/litellm_internal_staging:
-    .git-check.out
-    litellm/cost_calculator.py
-    litellm/ocr/main.py
-    tests/test_litellm/ocr/test_main.py
-    tests/test_litellm/test_cost_calculator.py
-check: linting Python (make lint)
-uv sync --inexact --frozen --group proxy-dev --group e2e-dev
-Audited 205 packages in 51ms
-uv run --no-sync python scripts/prisma_generate_if_needed.py
-Prisma client already generated for litellm/proxy/schema.prisma (prisma 0.11.0); skipping prisma generate
-cd litellm && uv run --no-sync ruff check . && cd ..
-uv run --no-sync python scripts/ruff_strict_gate.py --base "origin/litellm_internal_staging"
-uv run --no-sync python scripts/type_discipline_gate.py --base "origin/litellm_internal_staging"
-uv run --no-sync python scripts/test_quality_gate.py --base "origin/litellm_internal_staging"
-uv run --no-sync python scripts/type_check_gate.py --base "origin/litellm_internal_staging"
-uv run --no-sync basedpyright tests/e2e
-cd litellm && uv run --no-sync python ../tests/documentation_tests/test_circular_imports.py && cd ..
-No LiteLLM type hints found.
-provisioning .venv-typecheck (first run installs packages and generates the Prisma client; re-runs are near-instant no-ops)
-2 files already formatted
-All checks passed!
-uv run --no-sync ruff check --config ruff-tests.toml tests
-warning: Invalid `# noqa` directive on tests/test_litellm/proxy/common_utils/test_user_api_key_cache.py:44: expected a comma-separated list of codes (e.g., `# noqa: F401, F841`).
-All checks passed!
-[from litellm import *] OK! no issues!
-OK: every strict rule is within its codebase ceiling (base origin/litellm_internal_staging)
-0 errors, 0 warnings, 0 notes
-OK: every TQ rule is within its test-suite ceiling (base origin/litellm_internal_staging)
-OK: every LIT rule is within its codebase ceiling (base origin/litellm_internal_staging)
-base counts fetched from CI artifact basedpyright-counts-64ab15e608f7cb59
-OK: every rule is within its basedpyright limit or no higher than base (138494 errors total)
-check: ruff format --check (scoped litellm files)
-2 files already formatted
-check: summary
-    ran:     Python lint (make lint)
-    skipped: tests/e2e checks (basedpyright + raw HTTP client ban) (no tests/e2e Python files in scope)
-    ran:     test-tree lint (ruff-tests.toml + test-quality budget)
-    skipped: dashboard lint (prettier + eslint + lint budgets) (no dashboard files in scope)
-    skipped: dashboard API-type sync (npm run gen:api) (no litellm/proxy, litellm/types, or generator files in scope)
-check: PASS
-check: full log: /Users/mateo/Development/litellm/.git/worktrees/wt40516/pre_commit_lint.log