diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index f6c06f7d83f..158110cbbab 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -2,3 +2,4 @@
 /litellm/model_prices_and_context_window_backup.json @mateo-berri @ryan-crabbe-berri @kerry-berri @joshua-berri
 /helm/ @yassin-berriai
 /terraform/ @yassin-berriai
+/.github/workflows/zizmor.yml @yuneng-berri
diff --git a/.github/workflows/cost-map-guard.yml b/.github/workflows/cost-map-guard.yml
index f9172b9551a..05b22017cbb 100644
--- a/.github/workflows/cost-map-guard.yml
+++ b/.github/workflows/cost-map-guard.yml
@@ -1,7 +1,7 @@
 name: Cost map guard
 
-on: # zizmor: ignore[dangerous-triggers] runs the base branch's code only; the PR's cost map files are read as data and never executed
-  pull_request_target:
+on:
+  pull_request:
     branches:
       - main
       - "litellm_**"
@@ -19,6 +19,7 @@ jobs:
     steps:
       - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
         with:
+          ref: ${{ github.event.pull_request.base.sha }}
           persist-credentials: false
       - name: Fetch the pull request head and its merge base
         id: revisions
diff --git a/.github/workflows/spend-logs-guard.yml b/.github/workflows/spend-logs-guard.yml
index 29e9f236202..cc3bda9b880 100644
--- a/.github/workflows/spend-logs-guard.yml
+++ b/.github/workflows/spend-logs-guard.yml
@@ -1,7 +1,7 @@
 name: Spend logs guard
 
-on: # zizmor: ignore[dangerous-triggers] runs the base branch's code only; the PR's diff is read as data and never executed
-  pull_request_target:
+on:
+  pull_request:
     branches:
       - main
 
@@ -19,7 +19,7 @@ jobs:
     steps:
       - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
         with:
-          ref: ${{ github.event.pull_request.base.ref }}
+          ref: ${{ github.event.pull_request.base.sha }}
           persist-credentials: false
       - name: Fetch the pull request head, its merge base and its reviews
         id: revisions
diff --git a/.github/workflows/test-linting.yml b/.github/workflows/test-linting.yml
index b9f8d7e7dfb..89ca60ad9d1 100644
--- a/.github/workflows/test-linting.yml
+++ b/.github/workflows/test-linting.yml
@@ -561,6 +561,9 @@ jobs:
       - name: router_code_coverage
         run: uv run --no-sync python ./tests/code_coverage_tests/router_code_coverage.py
 
+      - name: router_surface_check
+        run: uv run --no-sync python ./tests/code_coverage_tests/router_surface_check.py
+
       - name: test_chat_completion_imports
         run: uv run --no-sync python ./tests/code_coverage_tests/test_chat_completion_imports.py
 
diff --git a/.github/workflows/test-rust.yml b/.github/workflows/test-rust.yml
index 636a5031e5f..04af770b24f 100644
--- a/.github/workflows/test-rust.yml
+++ b/.github/workflows/test-rust.yml
@@ -4,6 +4,7 @@ on:
   push:
     paths:
       - "litellm-rust/**"
+      - "model_prices_and_context_window.json"
       - "litellm/rust_bridge/**"
       - "scripts/generate_trace_types.py"
       - "scripts/trace_codegen/**"
@@ -38,6 +39,7 @@ on:
       - "litellm_**"
     paths:
       - "litellm-rust/**"
+      - "model_prices_and_context_window.json"
       - "litellm/rust_bridge/**"
       - "scripts/generate_trace_types.py"
       - "scripts/trace_codegen/**"
diff --git a/.github/workflows/test-unit.yml b/.github/workflows/test-unit.yml
index 2ddf21bca17..4768eeb633e 100644
--- a/.github/workflows/test-unit.yml
+++ b/.github/workflows/test-unit.yml
@@ -42,7 +42,7 @@ jobs:
         id: rust-bridge-key
         if: steps.changes.outputs.decision != 'skip'
         env:
-          RUST_BRIDGE_CACHE_KEY: ${{ runner.os }}-rust-bridge-editable-${{ hashFiles('litellm-rust/Cargo.lock', 'litellm-rust/Cargo.toml', 'litellm-rust/crates/**', 'pyproject.toml') }}
+          RUST_BRIDGE_CACHE_KEY: ${{ runner.os }}-rust-bridge-editable-${{ hashFiles('litellm-rust/Cargo.lock', 'litellm-rust/Cargo.toml', 'litellm-rust/crates/**', 'model_prices_and_context_window.json', 'pyproject.toml') }}
         run: echo "key=$RUST_BRIDGE_CACHE_KEY" >> "$GITHUB_OUTPUT"
 
       - name: Set up Python
@@ -245,6 +245,7 @@ jobs:
               tests/unit/llms/clarifai
               tests/unit/llms/claude_code
               tests/unit/llms/cloudflare
+              tests/unit/llms/codestral
               tests/unit/llms/codex
               tests/unit/llms/cohere
               tests/unit/llms/cometapi
diff --git a/.github/workflows/zizmor.yml b/.github/workflows/zizmor.yml
index 73f9efb8df9..eba23e795f3 100644
--- a/.github/workflows/zizmor.yml
+++ b/.github/workflows/zizmor.yml
@@ -27,10 +27,15 @@ jobs:
         with:
           persist-credentials: false
 
+      - name: Install zizmor
+        run: |
+          curl -fsSL --retry 3 -o "$RUNNER_TEMP/zizmor.tar.gz" \
+            https://github.com/zizmorcore/zizmor/releases/download/v1.31.1/zizmor-x86_64-unknown-linux-gnu.tar.gz
+          echo "d185f726bdaf92df78273217dfdd24ebcd6b0ef48cf3ce776ff5762b6e138c99  $RUNNER_TEMP/zizmor.tar.gz" | sha256sum -c -
+          tar xzf "$RUNNER_TEMP/zizmor.tar.gz" -C "$RUNNER_TEMP" zizmor
+
       - name: Run zizmor
-        uses: zizmorcore/zizmor-action@5f14fd08f7cf1cb1609c1e344975f152c7ee938d # v0.5.6
-        with:
-          version: "1.24.1"
-          min-severity: medium
-          advanced-security: false
-          annotations: true
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          "$RUNNER_TEMP/zizmor" --no-ignores --no-config --min-severity=medium --format=github .
diff --git a/ci_cd/spend_logs_guard.py b/ci_cd/spend_logs_guard.py
index a4d9a2e0a0d..5e6d38fba57 100644
--- a/ci_cd/spend_logs_guard.py
+++ b/ci_cd/spend_logs_guard.py
@@ -2,11 +2,12 @@
 needs an approving review from the spend-log owner before it can merge.
 
 CODEOWNERS can only match file paths, and every schema change edits the same schema.prisma copies,
-so a path rule would put every migration on the owner. This gate reads the diff instead: when no
-added line in the watched files mentions the table it passes at once, otherwise it passes only once
-the owner's latest review on the pull request is an approval that still covers every spend-log line
-in the head (approvals survive pushes, so a later commit may not add spend-log lines the owner never
-saw). Reviews do not trigger the workflow, so the check is re-run by hand after approving.
+so a path rule would put every migration on the owner. This gate reads the diff instead: a schema.prisma
+hunk counts when it adds or removes a line inside the `model LiteLLM_SpendLogs { ... }` block, a migration
+hunk counts when an added line names the table. Without such a hunk it passes at once, otherwise it passes
+only once the owner's latest review on the pull request is an approval that still covers every spend-log line
+in the head (approvals survive pushes, so a later commit may not add spend-log lines the owner never saw).
+Reviews do not trigger the workflow, so the check is re-run by hand after approving.
 """
 
 from __future__ import annotations
@@ -15,8 +16,10 @@ import argparse
 import re
 import subprocess
 import sys
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
 from pathlib import Path
+from types import MappingProxyType
 from typing import Final
 
 from pydantic import BaseModel, ConfigDict, TypeAdapter
@@ -29,6 +32,8 @@ WATCHED: Final = (
 MIGRATIONS_PREFIX: Final = "litellm-proxy-extras/litellm_proxy_extras/migrations/"
 TABLE: Final = re.compile(r"(?<![A-Za-z0-9])LiteLLM_SpendLogs(?![A-Za-z0-9])", re.IGNORECASE)
 DECIDING_STATES: Final = frozenset({"APPROVED", "CHANGES_REQUESTED", "DISMISSED"})
+MODEL_START: Final = re.compile(r"^model\s+LiteLLM_SpendLogs\s*\{")
+HUNK: Final = re.compile(r"^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@[^\n]*\n", re.MULTILINE)
 
 
 class Reviewer(BaseModel):
@@ -46,26 +51,71 @@ class Review(BaseModel):
 _REVIEWS: Final = TypeAdapter(list[Review])
 
 
+@dataclass(frozen=True, slots=True)
+class Block:
+    """Lines of `model LiteLLM_SpendLogs { ... }` in one schema.prisma copy at the merge base and at the head."""
+
+    base: range
+    head: range
+
+
+@dataclass(frozen=True, slots=True)
+class Hunk:
+    removed: tuple[tuple[int, str], ...]
+    added: tuple[tuple[int, str], ...]
+
+
 def watched(path: str) -> bool:
     return path in WATCHED or (path.startswith(MIGRATIONS_PREFIX) and path.endswith("/migration.sql"))
 
 
-def _added_lines(section: str) -> tuple[str, ...]:
-    body: Final = section.split("\n@@", 1)
-    return tuple(line[1:] for line in body[1].splitlines() if line.startswith("+")) if len(body) == 2 else ()
+def model_block(schema: str) -> range:
+    """1-based line range of `model LiteLLM_SpendLogs { ... }` including both braces, empty when the schema has none."""
+    lines: Final = schema.splitlines()
+    starts: Final = tuple(number for number, line in enumerate(lines, 1) if MODEL_START.match(line))
+    if not starts:
+        return range(0)
+    ends: Final = tuple(number for number, line in enumerate(lines, 1) if number > starts[0] and line.startswith("}"))
+    return range(starts[0], (ends[0] if ends else len(lines)) + 1)
 
 
-def spend_log_hits(diff: str) -> tuple[str, ...]:
-    """`path: added line` for every added line in a watched file that names the table."""
+def _hunks(section: str) -> tuple[Hunk, ...]:
+    headers: Final = tuple(HUNK.finditer(section))
+    ends: Final = tuple(header.start() for header in headers[1:]) + (len(section),)
+    return tuple(_hunk(header, section[header.end() : end]) for header, end in zip(headers, ends))
+
+
+def _hunk(header: re.Match[str], body: str) -> Hunk:
+    lines: Final = body.splitlines()
+    return Hunk(
+        removed=tuple(enumerate((line[1:] for line in lines if line.startswith("-")), int(header.group(1)))),
+        added=tuple(enumerate((line[1:] for line in lines if line.startswith("+")), int(header.group(2)))),
+    )
+
+
+def spend_log_hits(diff: str, blocks: Mapping[str, Block]) -> tuple[str, ...]:
+    """`path: +line` or `path: -line` for every changed line that touches the table.
+
+    A schema.prisma line counts when its number falls inside that copy's `blocks` entry (head for added lines,
+    merge base for removed ones), a migration line when it is added and names the table."""
     sections: Final = re.split(r"^diff --git [^\n]*\n", diff, flags=re.MULTILINE)
-    return tuple(f"{path}: {line.strip()}" for path, line in _watched_added_lines(sections) if TABLE.search(line))
-
-
-def _watched_added_lines(sections: Sequence[str]) -> tuple[tuple[str, str], ...]:
-    pairs: Final = tuple((_path_of(section), section) for section in sections)
+    paths: Final = tuple((_path_of(section), section) for section in sections)
     return tuple(
-        (path, line) for path, section in pairs if watched(path) for line in _added_lines(section)
-    )  # comprehension-ok: path then its lines
+        hit for path, section in paths if watched(path) for hit in _section_hits(path, _hunks(section), blocks)
+    )  # comprehension-ok: path then its hits
+
+
+def _section_hits(path: str, hunks: Sequence[Hunk], blocks: Mapping[str, Block]) -> tuple[str, ...]:
+    if path not in blocks:
+        return tuple(f"{path}: +{line.strip()}" for hunk in hunks for _, line in hunk.added if TABLE.search(line))
+    block: Final = blocks[path]
+    removed: Final = tuple(
+        f"{path}: -{line.strip()}" for hunk in hunks for number, line in hunk.removed if number in block.base
+    )  # comprehension-ok: hunk then its lines
+    added: Final = tuple(
+        f"{path}: +{line.strip()}" for hunk in hunks for number, line in hunk.added if number in block.head
+    )  # comprehension-ok: hunk then its lines
+    return removed + added
 
 
 def _path_of(section: str) -> str:
@@ -111,13 +161,25 @@ def added_diff(base: str, head: str) -> str:
     return result.stdout
 
 
+def file_at(revision: str, path: str) -> str:
+    """Contents of `path` at `revision`, empty when the file does not exist there."""
+    result: Final = subprocess.run(("git", "show", f"{revision}:{path}"), check=False, capture_output=True, text=True)
+    return result.stdout if result.returncode == 0 else ""
+
+
+def schema_blocks(base: str, head: str) -> Mapping[str, Block]:
+    return MappingProxyType(
+        {path: Block(base=model_block(file_at(base, path)), head=model_block(file_at(head, path))) for path in WATCHED}
+    )
+
+
 def fetched(commit: str) -> bool:
     result: Final = subprocess.run(("git", "fetch", "--no-tags", "--depth=1", "origin", commit), check=False)
     return result.returncode == 0
 
 
 def reviewed_hits(base: str, commit: str) -> tuple[str, ...] | None:
-    return spend_log_hits(added_diff(base, commit)) if fetched(commit) else None
+    return spend_log_hits(added_diff(base, commit), schema_blocks(base, commit)) if fetched(commit) else None
 
 
 class Arguments(BaseModel):
@@ -135,9 +197,12 @@ def main(argv: Sequence[str]) -> int:
     parser.add_argument("--approver", required=True, help="GitHub login whose approval unlocks the merge")
     parser.add_argument("--reviews", required=True, help="JSON file with the pull request's reviews")
     args: Final = Arguments.model_validate(vars(parser.parse_args(argv)))
-    hits: Final = spend_log_hits(added_diff(args.base, args.head))
+    hits: Final = spend_log_hits(added_diff(args.base, args.head), schema_blocks(args.base, args.head))
     if not hits:
-        sys.stdout.write("No added line in schema.prisma or a migration names LiteLLM_SpendLogs; nothing to review.\n")
+        sys.stdout.write(
+            "No change inside model LiteLLM_SpendLogs in schema.prisma and no added migration line names it; "
+            "nothing to review.\n"
+        )
         return 0
     reviews: Final = _REVIEWS.validate_json(args.reviews.read_bytes())
     approval: Final = latest_approval(reviews, args.approver) if approved_by(reviews, args.approver) else None
diff --git a/litellm-rust/Cargo.lock b/litellm-rust/Cargo.lock
index 9c45c5c4b1c..f7d7e5f4dab 100644
--- a/litellm-rust/Cargo.lock
+++ b/litellm-rust/Cargo.lock
@@ -3150,6 +3150,7 @@ dependencies = [
  "defmt",
  "jiff-core",
  "jiff-static",
+ "jiff-tzdb",
  "log",
  "portable-atomic",
  "portable-atomic-util",
@@ -3178,6 +3179,12 @@ dependencies = [
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "jiff-tzdb"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa8377070c6bae868759445e5a77f66d84f0b72f3a054bfb00e6d038b8282da7"
+
 [[package]]
 name = "jni"
 version = "0.22.4"
@@ -3729,9 +3736,12 @@ dependencies = [
 name = "litellm-cost"
 version = "0.1.0"
 dependencies = [
- "criterion",
- "proptest",
+ "jiff",
  "rstest",
+ "schemars 1.2.2",
+ "serde",
+ "serde_json",
+ "strum",
  "thiserror 2.0.19",
 ]
 
@@ -4277,17 +4287,35 @@ name = "litellm-model-catalog"
 version = "0.1.0"
 dependencies = [
  "indexmap 2.14.0",
+ "jiff",
  "jsonschema",
+ "litellm-cost",
  "litellm-error",
- "litellm-llms-types",
+ "macro_rules_attribute",
  "rstest",
  "schemars 1.2.2",
  "serde",
  "serde_json",
+ "serde_with",
+ "strum",
  "thiserror 2.0.19",
  "time",
 ]
 
+[[package]]
+name = "litellm-model-catalog-refresh"
+version = "0.1.0"
+dependencies = [
+ "litellm-error",
+ "litellm-http",
+ "litellm-model-catalog",
+ "reqwest",
+ "rstest",
+ "thiserror 2.0.19",
+ "tokio",
+ "url",
+]
+
 [[package]]
 name = "litellm-python-bridge"
 version = "0.1.0"
@@ -4387,12 +4415,17 @@ name = "litellm-router"
 version = "0.1.0"
 dependencies = [
  "litellm-config",
+ "litellm-core-utils",
  "litellm-inference",
  "litellm-inference-messages",
  "litellm-router-types",
  "rstest",
 ]
 
+[[package]]
+name = "litellm-router-core"
+version = "0.1.0"
+
 [[package]]
 name = "litellm-router-types"
 version = "0.1.0"
diff --git a/litellm-rust/Cargo.toml b/litellm-rust/Cargo.toml
index b7b22cfd32c..49a33e08456 100644
--- a/litellm-rust/Cargo.toml
+++ b/litellm-rust/Cargo.toml
@@ -73,6 +73,9 @@ litellm-python-compat = { path = "crates/python-compat" }
 litellm-circuit-breaker = { path = "crates/circuit-breaker" }
 litellm-redis-client = { path = "crates/redis-client" }
 litellm-redis-testing = { path = "crates/redis-testing" }
+litellm-cost = { path = "crates/cost" }
+litellm-model-catalog = { path = "crates/model-catalog" }
+litellm-model-catalog-refresh = { path = "crates/model-catalog-refresh" }
 
 askama = { version = "0.16.1", default-features = false, features = ["derive", "std"] }
 tracing = "0.1"
@@ -109,6 +112,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0", features = ["float_roundtrip"] }
 serde_with = { version = "=3.21.0", default-features = false, features = ["std", "macros"] }
 sha2 = "0.10"
+sha1 = "0.10"
 syn = { version = "2", default-features = false }
 sqlx = { version = "0.9.0", default-features = false, features = ["json", "macros", "postgres", "runtime-tokio", "chrono", "tls-rustls-ring-native-roots"] }
 chrono = { version = "0.4.45", default-features = false, features = ["std"] }
diff --git a/litellm-rust/crates/core-utils/src/serde_compat.rs b/litellm-rust/crates/core-utils/src/serde_compat.rs
index 3e4d82d3a3e..6f40a4af60a 100644
--- a/litellm-rust/crates/core-utils/src/serde_compat.rs
+++ b/litellm-rust/crates/core-utils/src/serde_compat.rs
@@ -1,13 +1,25 @@
-pub fn parse_str_bool(value: &str) -> Option<bool> {
-    let token = value.trim_matches(|character: char| {
+fn python_strip(value: &str) -> &str {
+    value.trim_matches(|character: char| {
         character.is_whitespace() || matches!(character, '\u{1c}'..='\u{1f}')
-    });
+    })
+}
+
+pub fn parse_str_bool(value: &str) -> Option<bool> {
+    let token = python_strip(value);
     if token.eq_ignore_ascii_case("true") {
         return Some(true);
     }
     token.eq_ignore_ascii_case("false").then_some(false)
 }
 
+pub fn parse_pydantic_bool(value: &str) -> Option<bool> {
+    match python_strip(value).to_ascii_lowercase().as_str() {
+        "1" | "on" | "t" | "true" | "y" | "yes" => Some(true),
+        "0" | "off" | "f" | "false" | "n" | "no" => Some(false),
+        _ => None,
+    }
+}
+
 /// `redis-py` string Booleans: only `1`, `true`, and `yes` (case-insensitive) are true.
 pub fn parse_redis_bool(value: &str) -> bool {
     value == "1" || value.eq_ignore_ascii_case("true") || value.eq_ignore_ascii_case("yes")
@@ -34,4 +46,27 @@ mod tests {
     ) {
         assert_eq!(parse_str_bool(input), expected, "{input:?}");
     }
+
+    #[rstest]
+    #[case::yes(" YES ", Some(true))]
+    #[case::on("On", Some(true))]
+    #[case::one("1", Some(true))]
+    #[case::t("t", Some(true))]
+    #[case::y("y", Some(true))]
+    #[case::control_whitespace_true("\u{1c}TRUE\u{1f}", Some(true))]
+    #[case::no("No", Some(false))]
+    #[case::off("OFF", Some(false))]
+    #[case::zero("0", Some(false))]
+    #[case::f("F", Some(false))]
+    #[case::n("n", Some(false))]
+    #[case::false_word("false", Some(false))]
+    #[case::two("2", None)]
+    #[case::empty("", None)]
+    #[case::unknown("maybe", None)]
+    fn boolean_words_follow_pydantic_lax_bool_parsing(
+        #[case] input: &str,
+        #[case] expected: Option<bool>,
+    ) {
+        assert_eq!(parse_pydantic_bool(input), expected, "{input:?}");
+    }
 }
diff --git a/litellm-rust/crates/cost/Cargo.toml b/litellm-rust/crates/cost/Cargo.toml
index 6921e6151b5..858287c7860 100644
--- a/litellm-rust/crates/cost/Cargo.toml
+++ b/litellm-rust/crates/cost/Cargo.toml
@@ -5,14 +5,17 @@ edition.workspace = true
 license.workspace = true
 repository.workspace = true
 
+[features]
+serde = ["dep:serde"]
+schema = ["serde", "dep:schemars"]
+
 [dependencies]
+jiff = { version = "0.2.37", default-features = false, features = ["std"] }
+schemars = { workspace = true, optional = true }
+serde = { workspace = true, optional = true }
 thiserror.workspace = true
+strum.workspace = true
 
 [dev-dependencies]
-criterion.workspace = true
-proptest.workspace = true
 rstest.workspace = true
-
-[[bench]]
-name = "calculate"
-harness = false
+serde_json.workspace = true
diff --git a/litellm-rust/crates/cost/README.md b/litellm-rust/crates/cost/README.md
index ee4722b6438..f8fc9403917 100644
--- a/litellm-rust/crates/cost/README.md
+++ b/litellm-rust/crates/cost/README.md
@@ -1,13 +1,3 @@
 # litellm-cost
 
-This crate calculates text token charges from rates and usage supplied by its caller. It is standalone and has no Python bridge or proxy integration
-
-Call `compile(&pricing)` once for an immutable plan, then `plan.calculate(&request)` for each supported request. `calculate(&pricing, &request)` compiles on each call. A successful result exposes pre-multiplier component costs, selected rates, the multiplier, and derived `input()`, `output()`, and `total()` values
-
-The caller states whether `prompt_tokens` includes cache tokens. Threshold selection uses total input tokens for either convention and selects one rate for the whole request. Thresholds are sorted when compiled, and duplicate thresholds or tier overrides fail deterministically. `Fast` selects priority rates; unknown tiers use standard rates
-
-`Rate::Missing`, `Rate::Null`, and `Rate::Value(0.0)` remain distinct. Missing cache rates fall back to the selected input rate, and an absent one-hour write rate falls back to the selected write rate. Missing input or output rates return typed errors, including for zero usage. Python's sparse-entry behavior remains outside this native contract
-
-The supported off-peak shape is one non-wrapping UTC daily window. The caller supplies the applicable regional multiplier after provider-specific selection. Negative or non-finite rates, ambiguous rules, inconsistent cache counts, incomplete write splits, invalid windows and overflow return errors. Callers must decline unsupported inputs before native execution if their public contract accepts those shapes
-
-This crate does not select models, read catalogs, fetch provider prices, normalize multimodal usage, process provider-reported costs, or calculate non-token charges. It does not change proxy behavior. The reference fixture was generated by `tests/generate_python_reference.py` against the Python implementation at the commit recorded in `tests/python_reference.tsv`, using synthetic rates and fixed usage
+This crate holds the price data model that `litellm-model-catalog` lowers each catalog entry into, plus the usage, call context and priced outcome types that `calculate` will compute over. There is no `calculate` until the token pricing PR lands. `UnitPrice` is USD per unit and `Usd` is an amount, and only the operations that make sense between them exist, so a price is never added to an amount. `Prices::band` and `Prices::rate` resolve a token rate the way Python's `_get_token_base_cost` does
diff --git a/litellm-rust/crates/cost/benches/calculate.rs b/litellm-rust/crates/cost/benches/calculate.rs
deleted file mode 100644
index 2561b606e6c..00000000000
--- a/litellm-rust/crates/cost/benches/calculate.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-use criterion::{Criterion, criterion_group, criterion_main};
-use litellm_cost::{
-    Pricing, PromptConvention, Rate, Rates, Request, ServiceTier, ThresholdPolicy, ThresholdRates,
-    Usage, calculate, compile,
-};
-use std::hint::black_box;
-
-fn bench(c: &mut Criterion) {
-    let pricing = Pricing {
-        standard: Rates {
-            input: Rate::Value(0.000002),
-            output: Rate::Value(0.000008),
-            cache_read: Rate::Value(0.0000005),
-            cache_write: Rate::Missing,
-            cache_write_1h: Rate::Missing,
-        },
-        tiers: &[],
-        thresholds: &[],
-        off_peak: None,
-    };
-    let request = Request {
-        usage: Usage {
-            prompt_tokens: 1000,
-            completion_tokens: 200,
-            cache_read_tokens: 250,
-            cache_write_tokens: 0,
-            cache_write_5m_tokens: None,
-            cache_write_1h_tokens: None,
-            prompt_convention: PromptConvention::IncludesCache,
-        },
-        service_tier: ServiceTier::Standard,
-        threshold_policy: ThresholdPolicy::Exclusive,
-        region_multiplier: None,
-        billed_at_utc_minute: None,
-    };
-    let plan = compile(&pricing).unwrap();
-    c.bench_function("native_compiled_calculation", |b| {
-        b.iter(|| black_box(plan.calculate(black_box(&request)).unwrap()))
-    });
-    c.bench_function("native_full_wrapper", |b| {
-        b.iter(|| black_box(calculate(black_box(&pricing), black_box(&request)).unwrap()))
-    });
-    c.bench_function("native_rate_compilation", |b| {
-        b.iter(|| black_box(compile(black_box(&pricing)).unwrap()))
-    });
-    let threshold = ThresholdRates {
-        above_prompt_tokens: 1000,
-        standard: Rates {
-            input: Rate::Value(0.000004),
-            output: Rate::Value(0.000016),
-            ..Rates::EMPTY
-        },
-        tiers: &[],
-    };
-    let threshold_pricing = Pricing {
-        thresholds: &[threshold],
-        ..pricing
-    };
-    let threshold_plan = compile(&threshold_pricing).unwrap();
-    c.bench_function("native_threshold_boundary", |b| {
-        b.iter(|| black_box(threshold_plan.calculate(black_box(&request)).unwrap()))
-    });
-}
-
-criterion_group!(benches, bench);
-criterion_main!(benches);
diff --git a/litellm-rust/crates/cost/examples/charge.rs b/litellm-rust/crates/cost/examples/charge.rs
deleted file mode 100644
index a3a83febd74..00000000000
--- a/litellm-rust/crates/cost/examples/charge.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use litellm_cost::{
-    Pricing, PromptConvention, Rate, Rates, Request, ServiceTier, ThresholdPolicy, Usage, compile,
-};
-
-fn main() {
-    let pricing = Pricing {
-        standard: Rates {
-            input: Rate::Value(2.0),
-            output: Rate::Value(4.0),
-            cache_read: Rate::Value(0.5),
-            cache_write: Rate::Value(3.0),
-            cache_write_1h: Rate::Missing,
-        },
-        tiers: &[],
-        thresholds: &[],
-        off_peak: None,
-    };
-    let request = Request {
-        usage: Usage {
-            prompt_tokens: 100,
-            completion_tokens: 20,
-            cache_read_tokens: 25,
-            cache_write_tokens: 10,
-            cache_write_5m_tokens: None,
-            cache_write_1h_tokens: None,
-            prompt_convention: PromptConvention::IncludesCache,
-        },
-        service_tier: ServiceTier::Standard,
-        threshold_policy: ThresholdPolicy::Exclusive,
-        region_multiplier: None,
-        billed_at_utc_minute: None,
-    };
-    let cost = compile(&pricing).unwrap().calculate(&request).unwrap();
-    println!(
-        "input={} output={} total={}",
-        cost.input(),
-        cost.output(),
-        cost.total()
-    );
-}
diff --git a/litellm-rust/crates/cost/src/call.rs b/litellm-rust/crates/cost/src/call.rs
new file mode 100644
index 00000000000..3f44ec03e9b
--- /dev/null
+++ b/litellm-rust/crates/cost/src/call.rs
@@ -0,0 +1,42 @@
+use crate::price::{Channel, Prices, Residency, ServiceTier};
+
+/// Facts about the call, never about the row or the provider
+#[derive(Clone, Debug, PartialEq)]
+pub struct CallContext {
+    /// Requested service tier, `"fast"` maps to `Priority` as on main
+    pub tier: ServiceTier,
+    /// Online, batch or decisions
+    pub channel: Channel,
+    /// OpenAI data residency, picks the residency uplift
+    pub residency: Option<Residency>,
+    /// Vertex call sent to a regional endpoint, picks the regional uplift
+    pub non_global_endpoint: bool,
+    /// Anthropic `speed: fast`, picks the speed uplift
+    pub speed: Option<Speed>,
+    /// Anthropic and Bedrock `inference_geo`, picks the geo uplift
+    pub inference_geo: Option<InferenceGeo>,
+    /// When the call was billed, for off-peak windows
+    pub at: jiff::Timestamp,
+    /// Per-call custom pricing, lowered like a row and applied field by field over it
+    pub overlay: Option<Prices>,
+}
+
+/// Anthropic `speed`
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Speed {
+    Fast,
+}
+
+/// Anthropic and Bedrock `inference_geo`, lowercased as on main
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct InferenceGeo(Box<str>);
+
+impl InferenceGeo {
+    pub fn new(geo: &str) -> Self {
+        Self(geo.to_lowercase().into())
+    }
+
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+}
diff --git a/litellm-rust/crates/cost/src/error.rs b/litellm-rust/crates/cost/src/error.rs
index 1753080617f..7ef5eb87597 100644
--- a/litellm-rust/crates/cost/src/error.rs
+++ b/litellm-rust/crates/cost/src/error.rs
@@ -1,27 +1,24 @@
-#[derive(Clone, Copy, Debug, Eq, PartialEq, thiserror::Error)]
+use thiserror::Error;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Error, strum::VariantArray)]
 pub enum Error {
-    #[error("model has no input rate")]
-    MissingInputRate,
-    #[error("model has no output rate")]
-    MissingOutputRate,
-    #[error("rate must be finite and nonnegative")]
-    InvalidRate,
-    #[error("region multiplier must be finite and positive")]
-    InvalidRegionMultiplier,
-    #[error("off-peak pricing needs a billing minute within the day")]
-    InvalidBillingTime,
-    #[error("off-peak window must start before it ends within the day")]
-    InvalidOffPeakWindow,
-    #[error("cached tokens exceed prompt tokens")]
-    CacheExceedsPrompt,
-    #[error("cache write details do not add up to the cache write tokens")]
-    InvalidCacheWriteDetails,
-    #[error("token count or cost overflows")]
-    TokenCountOverflow,
-    #[error("service tier is repeated or cannot carry its own rates")]
-    DuplicateTier,
-    #[error("prompt token threshold is repeated")]
-    DuplicateThreshold,
-    #[error("service tier is repeated or cannot carry its own rates within a threshold")]
-    DuplicateThresholdTier,
+    #[error("expected a UTC window HH:MM-HH:MM")]
+    InvalidUtcWindow,
+    #[error("expected an ISO weekday number 1-7 or an English day name")]
+    InvalidWeekday,
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+
+    use super::Error;
+    use crate::schedule::{UtcWindow, Weekday};
+
+    #[rstest]
+    #[case::window("not-a-window".parse::<UtcWindow>().unwrap_err(), Error::InvalidUtcWindow)]
+    #[case::weekday("not-a-weekday".parse::<Weekday>().unwrap_err(), Error::InvalidWeekday)]
+    fn schedule_parsers_share_the_crate_error(#[case] error: Error, #[case] expected: Error) {
+        assert_eq!(error, expected);
+    }
 }
diff --git a/litellm-rust/crates/cost/src/lib.rs b/litellm-rust/crates/cost/src/lib.rs
index 24c69afd9d4..192dfa361d6 100644
--- a/litellm-rust/crates/cost/src/lib.rs
+++ b/litellm-rust/crates/cost/src/lib.rs
@@ -1,383 +1,9 @@
+pub mod call;
 mod error;
+pub mod money;
+pub mod price;
+pub mod priced;
+pub mod schedule;
+pub mod usage;
 
-pub use error::Error;
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Rate {
-    Missing,
-    Null,
-    Value(f64),
-}
-
-impl Rate {
-    fn value(self) -> Option<f64> {
-        match self {
-            Self::Value(value) => Some(value),
-            Self::Missing | Self::Null => None,
-        }
-    }
-
-    fn or(self, fallback: Self) -> Self {
-        if self.value().is_some() {
-            self
-        } else {
-            fallback
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Rates {
-    pub input: Rate,
-    pub output: Rate,
-    pub cache_read: Rate,
-    pub cache_write: Rate,
-    pub cache_write_1h: Rate,
-}
-
-impl Rates {
-    pub const EMPTY: Self = Self {
-        input: Rate::Missing,
-        output: Rate::Missing,
-        cache_read: Rate::Missing,
-        cache_write: Rate::Missing,
-        cache_write_1h: Rate::Missing,
-    };
-
-    fn overlay(self, base: Self) -> Self {
-        Self {
-            input: self.input.or(base.input),
-            output: self.output.or(base.output),
-            cache_read: self.cache_read.or(base.cache_read),
-            cache_write: self.cache_write.or(base.cache_write),
-            cache_write_1h: self.cache_write_1h.or(base.cache_write_1h),
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum ServiceTier {
-    Standard,
-    Flex,
-    Priority,
-    Fast,
-    Ultrafast,
-    Unknown,
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum ThresholdPolicy {
-    Exclusive,
-    Inclusive,
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum PromptConvention {
-    IncludesCache,
-    ExcludesCache,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Usage {
-    pub prompt_tokens: u64,
-    pub completion_tokens: u64,
-    pub cache_read_tokens: u64,
-    pub cache_write_tokens: u64,
-    pub cache_write_5m_tokens: Option<u64>,
-    pub cache_write_1h_tokens: Option<u64>,
-    pub prompt_convention: PromptConvention,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct TierRates {
-    pub tier: ServiceTier,
-    pub rates: Rates,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct ThresholdRates<'a> {
-    pub above_prompt_tokens: u64,
-    pub standard: Rates,
-    pub tiers: &'a [TierRates],
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct OffPeakRates {
-    pub start_utc_minute: u16,
-    pub end_utc_minute: u16,
-    pub rates: Rates,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Pricing<'a> {
-    pub standard: Rates,
-    pub tiers: &'a [TierRates],
-    pub thresholds: &'a [ThresholdRates<'a>],
-    pub off_peak: Option<OffPeakRates>,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Request {
-    pub usage: Usage,
-    pub service_tier: ServiceTier,
-    pub threshold_policy: ThresholdPolicy,
-    pub region_multiplier: Option<f64>,
-    pub billed_at_utc_minute: Option<u16>,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Cost {
-    pub uncached_input: f64,
-    pub cache_read: f64,
-    pub cache_write_5m: f64,
-    pub cache_write_1h: f64,
-    pub output: f64,
-    pub multiplier: f64,
-    pub rates: EffectiveRates,
-}
-
-impl Cost {
-    pub fn input(self) -> f64 {
-        (self.uncached_input + self.cache_read + self.cache_write_5m + self.cache_write_1h)
-            * self.multiplier
-    }
-
-    pub fn output(self) -> f64 {
-        self.output * self.multiplier
-    }
-
-    pub fn total(self) -> f64 {
-        self.input() + self.output()
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct EffectiveRates {
-    pub input: f64,
-    pub output: f64,
-    pub cache_read: f64,
-    pub cache_write_5m: f64,
-    pub cache_write_1h: f64,
-}
-
-fn selected_tier(tier: ServiceTier) -> ServiceTier {
-    if tier == ServiceTier::Fast {
-        ServiceTier::Priority
-    } else {
-        tier
-    }
-}
-
-#[derive(Clone, Debug)]
-struct CompiledThreshold {
-    above_prompt_tokens: u64,
-    standard: Rates,
-    tiers: Vec<TierRates>,
-}
-
-#[derive(Clone, Debug)]
-pub struct PricingPlan {
-    standard: Rates,
-    tiers: Vec<TierRates>,
-    thresholds: Vec<CompiledThreshold>,
-    off_peak: Option<OffPeakRates>,
-}
-
-fn valid_rates(rates: Rates) -> bool {
-    [
-        rates.input,
-        rates.output,
-        rates.cache_read,
-        rates.cache_write,
-        rates.cache_write_1h,
-    ]
-    .into_iter()
-    .all(|rate| {
-        rate.value()
-            .is_none_or(|value| value.is_finite() && value >= 0.0)
-    })
-}
-
-fn validate_tiers(tiers: &[TierRates], duplicate: Error) -> Result<(), Error> {
-    if tiers.iter().any(|entry| !valid_rates(entry.rates)) {
-        return Err(Error::InvalidRate);
-    }
-    if tiers.iter().enumerate().any(|(index, entry)| {
-        matches!(
-            entry.tier,
-            ServiceTier::Standard | ServiceTier::Unknown | ServiceTier::Fast
-        ) || tiers[..index]
-            .iter()
-            .any(|previous| previous.tier == entry.tier)
-    }) {
-        return Err(duplicate);
-    }
-    Ok(())
-}
-
-pub fn compile(pricing: &Pricing<'_>) -> Result<PricingPlan, Error> {
-    if !valid_rates(pricing.standard) {
-        return Err(Error::InvalidRate);
-    }
-    validate_tiers(pricing.tiers, Error::DuplicateTier)?;
-    if let Some(window) = pricing.off_peak {
-        if window.start_utc_minute >= 1440
-            || window.end_utc_minute > 1440
-            || window.start_utc_minute >= window.end_utc_minute
-        {
-            return Err(Error::InvalidOffPeakWindow);
-        }
-        if !valid_rates(window.rates) {
-            return Err(Error::InvalidRate);
-        }
-    }
-    let mut thresholds: Vec<_> = pricing
-        .thresholds
-        .iter()
-        .map(|entry| {
-            if !valid_rates(entry.standard) {
-                return Err(Error::InvalidRate);
-            }
-            validate_tiers(entry.tiers, Error::DuplicateThresholdTier)?;
-            Ok(CompiledThreshold {
-                above_prompt_tokens: entry.above_prompt_tokens,
-                standard: entry.standard,
-                tiers: entry.tiers.to_vec(),
-            })
-        })
-        .collect::<Result<_, _>>()?;
-    thresholds.sort_unstable_by_key(|entry| entry.above_prompt_tokens);
-    if thresholds
-        .windows(2)
-        .any(|pair| pair[0].above_prompt_tokens == pair[1].above_prompt_tokens)
-    {
-        return Err(Error::DuplicateThreshold);
-    }
-    Ok(PricingPlan {
-        standard: pricing.standard,
-        tiers: pricing.tiers.to_vec(),
-        thresholds,
-        off_peak: pricing.off_peak,
-    })
-}
-
-impl PricingPlan {
-    fn resolve_rates(&self, request: &Request, threshold_tokens: u64) -> Result<Rates, Error> {
-        let tier = selected_tier(request.service_tier);
-        let base = self
-            .tiers
-            .iter()
-            .find(|entry| tier != ServiceTier::Standard && entry.tier == tier)
-            .map_or(self.standard, |entry| entry.rates.overlay(self.standard));
-        let threshold = self.thresholds.iter().rev().find(|entry| {
-            threshold_tokens > entry.above_prompt_tokens
-                || (request.threshold_policy == ThresholdPolicy::Inclusive
-                    && threshold_tokens == entry.above_prompt_tokens)
-        });
-        let selected = threshold.map_or(base, |entry| {
-            let standard = entry.standard.overlay(base);
-            entry
-                .tiers
-                .iter()
-                .find(|specific| tier != ServiceTier::Standard && specific.tier == tier)
-                .map_or(standard, |specific| specific.rates.overlay(standard))
-        });
-        match self.off_peak {
-            None => Ok(selected),
-            Some(window) => {
-                if window.start_utc_minute >= 1440
-                    || window.end_utc_minute > 1440
-                    || window.start_utc_minute >= window.end_utc_minute
-                {
-                    return Err(Error::InvalidOffPeakWindow);
-                }
-                let minute = request
-                    .billed_at_utc_minute
-                    .ok_or(Error::InvalidBillingTime)?;
-                if minute >= 1440 {
-                    return Err(Error::InvalidBillingTime);
-                }
-                if (window.start_utc_minute..window.end_utc_minute).contains(&minute) {
-                    Ok(window.rates.overlay(selected))
-                } else {
-                    Ok(selected)
-                }
-            }
-        }
-    }
-
-    fn checked_rate(rate: Rate, missing: Error) -> Result<f64, Error> {
-        let value = rate.value().ok_or(missing)?;
-        if !value.is_finite() || value < 0.0 {
-            return Err(Error::InvalidRate);
-        }
-        Ok(value)
-    }
-
-    pub fn calculate(&self, request: &Request) -> Result<Cost, Error> {
-        let usage = request.usage;
-        let cached = usage
-            .cache_read_tokens
-            .checked_add(usage.cache_write_tokens)
-            .ok_or(Error::TokenCountOverflow)?;
-        let (regular, threshold_tokens) = match usage.prompt_convention {
-            PromptConvention::IncludesCache => (
-                usage
-                    .prompt_tokens
-                    .checked_sub(cached)
-                    .ok_or(Error::CacheExceedsPrompt)?,
-                usage.prompt_tokens,
-            ),
-            PromptConvention::ExcludesCache => (
-                usage.prompt_tokens,
-                usage
-                    .prompt_tokens
-                    .checked_add(cached)
-                    .ok_or(Error::TokenCountOverflow)?,
-            ),
-        };
-        let writes = match (usage.cache_write_5m_tokens, usage.cache_write_1h_tokens) {
-            (None, None) => (usage.cache_write_tokens, 0),
-            (Some(five), Some(one)) if five.checked_add(one) == Some(usage.cache_write_tokens) => {
-                (five, one)
-            }
-            _ => return Err(Error::InvalidCacheWriteDetails),
-        };
-        let rates = self.resolve_rates(request, threshold_tokens)?;
-        let input = Self::checked_rate(rates.input, Error::MissingInputRate)?;
-        let output = Self::checked_rate(rates.output, Error::MissingOutputRate)?;
-        let read = Self::checked_rate(rates.cache_read.or(rates.input), Error::MissingInputRate)?;
-        let write = Self::checked_rate(rates.cache_write.or(rates.input), Error::MissingInputRate)?;
-        let write_1h = Self::checked_rate(
-            rates.cache_write_1h.or(rates.cache_write).or(rates.input),
-            Error::MissingInputRate,
-        )?;
-        let multiplier = request.region_multiplier.unwrap_or(1.0);
-        if !multiplier.is_finite() || multiplier <= 0.0 {
-            return Err(Error::InvalidRegionMultiplier);
-        }
-        let cost = Cost {
-            uncached_input: regular as f64 * input,
-            cache_read: usage.cache_read_tokens as f64 * read,
-            cache_write_5m: writes.0 as f64 * write,
-            cache_write_1h: writes.1 as f64 * write_1h,
-            output: usage.completion_tokens as f64 * output,
-            multiplier,
-            rates: EffectiveRates {
-                input,
-                output,
-                cache_read: read,
-                cache_write_5m: write,
-                cache_write_1h: write_1h,
-            },
-        };
-        if !cost.total().is_finite() {
-            return Err(Error::TokenCountOverflow);
-        }
-        Ok(cost)
-    }
-}
-
-pub fn calculate(pricing: &Pricing<'_>, request: &Request) -> Result<Cost, Error> {
-    compile(pricing)?.calculate(request)
-}
+pub use error::*;
diff --git a/litellm-rust/crates/cost/src/money.rs b/litellm-rust/crates/cost/src/money.rs
new file mode 100644
index 00000000000..0140fff52d2
--- /dev/null
+++ b/litellm-rust/crates/cost/src/money.rs
@@ -0,0 +1,257 @@
+use std::iter::Sum;
+use std::ops::{Add, Mul};
+
+use crate::priced::Quantity;
+
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
+pub struct UnitPrice(f64);
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
+pub struct Usd(f64);
+
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
+pub struct Multiplier(f64);
+
+impl UnitPrice {
+    pub fn new(usd_per_unit: f64) -> Option<Self> {
+        (usd_per_unit.is_finite() && usd_per_unit >= 0.0).then_some(Self(usd_per_unit))
+    }
+    pub fn get(self) -> f64 {
+        self.0
+    }
+}
+
+impl Usd {
+    pub const ZERO: Self = Self(0.0);
+
+    pub fn new(amount: f64) -> Option<Self> {
+        (amount.is_finite() && amount >= 0.0).then_some(Self(amount))
+    }
+    pub fn get(self) -> f64 {
+        self.0
+    }
+}
+
+impl Multiplier {
+    pub fn new(factor: f64) -> Option<Self> {
+        (factor.is_finite() && factor >= 1.0).then_some(Self(factor))
+    }
+    pub fn get(self) -> f64 {
+        self.0
+    }
+}
+
+impl Mul<Quantity> for UnitPrice {
+    type Output = Usd;
+
+    fn mul(self, quantity: Quantity) -> Usd {
+        match quantity {
+            Quantity::Count(units) => Usd(self.0 * units as f64),
+            Quantity::Duration(duration) => Usd(self.0 * duration.as_secs_f64()),
+        }
+    }
+}
+
+impl Mul<Multiplier> for UnitPrice {
+    type Output = UnitPrice;
+
+    fn mul(self, factor: Multiplier) -> UnitPrice {
+        UnitPrice(self.0 * factor.0)
+    }
+}
+
+impl Mul<Multiplier> for Usd {
+    type Output = Usd;
+
+    fn mul(self, factor: Multiplier) -> Usd {
+        Usd(self.0 * factor.0)
+    }
+}
+
+impl Add for Usd {
+    type Output = Usd;
+
+    fn add(self, other: Usd) -> Usd {
+        Usd(self.0 + other.0)
+    }
+}
+
+impl Sum for Usd {
+    fn sum<I: Iterator<Item = Usd>>(amounts: I) -> Usd {
+        amounts.fold(Usd::ZERO, Add::add)
+    }
+}
+
+#[cfg(feature = "serde")]
+mod serde_impls {
+    use std::fmt;
+
+    use serde::de::{self, Deserialize, Deserializer, Visitor};
+
+    use super::{Multiplier, UnitPrice};
+
+    #[derive(Clone, Copy)]
+    struct Number(&'static str);
+
+    impl Visitor<'_> for Number {
+        type Value = f64;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+            formatter.write_str(self.0)
+        }
+
+        fn visit_i64<E: de::Error>(self, value: i64) -> Result<f64, E> {
+            Ok(value as f64)
+        }
+
+        fn visit_u64<E: de::Error>(self, value: u64) -> Result<f64, E> {
+            Ok(value as f64)
+        }
+
+        fn visit_f64<E: de::Error>(self, value: f64) -> Result<f64, E> {
+            Ok(value)
+        }
+
+        fn visit_str<E: de::Error>(self, value: &str) -> Result<f64, E> {
+            value
+                .trim()
+                .parse()
+                .map_err(|_| E::invalid_value(de::Unexpected::Str(value), &self))
+        }
+    }
+
+    fn checked<'de, D: Deserializer<'de>, T>(
+        deserializer: D,
+        expected: Number,
+        new: fn(f64) -> Option<T>,
+    ) -> Result<T, D::Error> {
+        let number = deserializer.deserialize_any(expected)?;
+        new(number)
+            .ok_or_else(|| de::Error::invalid_value(de::Unexpected::Float(number), &expected))
+    }
+
+    impl<'de> Deserialize<'de> for UnitPrice {
+        fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+            checked(deserializer, Number("a non-negative USD amount"), Self::new)
+        }
+    }
+
+    impl<'de> Deserialize<'de> for Multiplier {
+        fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+            checked(
+                deserializer,
+                Number("a multiplier of at least 1"),
+                Self::new,
+            )
+        }
+    }
+}
+
+#[cfg(feature = "schema")]
+mod schema {
+    use std::borrow::Cow;
+
+    use schemars::{JsonSchema, Schema, SchemaGenerator, json_schema};
+
+    use super::{Multiplier, UnitPrice};
+
+    impl JsonSchema for UnitPrice {
+        fn inline_schema() -> bool {
+            true
+        }
+        fn schema_name() -> Cow<'static, str> {
+            "UnitPrice".into()
+        }
+        fn json_schema(_: &mut SchemaGenerator) -> Schema {
+            json_schema!({"type": "number", "minimum": 0})
+        }
+    }
+
+    impl JsonSchema for Multiplier {
+        fn inline_schema() -> bool {
+            true
+        }
+        fn schema_name() -> Cow<'static, str> {
+            "Multiplier".into()
+        }
+        fn json_schema(_: &mut SchemaGenerator) -> Schema {
+            json_schema!({"type": "number", "minimum": 1})
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+
+    use super::*;
+
+    #[rstest]
+    #[case::price(0.5)]
+    #[case::free(0.0)]
+    fn unit_price_keeps_finite_non_negative_values(#[case] value: f64) {
+        assert_eq!(UnitPrice::new(value).map(UnitPrice::get), Some(value));
+    }
+
+    #[rstest]
+    #[case::negative(-1e-9)]
+    #[case::nan(f64::NAN)]
+    #[case::infinite(f64::INFINITY)]
+    fn unit_price_rejects_what_no_price_can_be(#[case] value: f64) {
+        assert_eq!(UnitPrice::new(value), None);
+    }
+
+    #[rstest]
+    #[case::uplift(1.1, true)]
+    #[case::neutral(1.0, true)]
+    #[case::discount(0.5, false)]
+    #[case::nan(f64::NAN, false)]
+    fn multiplier_is_never_a_discount(#[case] value: f64, #[case] accepted: bool) {
+        assert_eq!(Multiplier::new(value).is_some(), accepted);
+    }
+
+    #[rstest]
+    fn amounts_follow_units_times_price_then_uplift() {
+        let price = UnitPrice::new(0.25).unwrap();
+        let uplift = Multiplier::new(2.0).unwrap();
+
+        let total: Usd = [
+            price * Quantity::Count(4),
+            (price * uplift) * Quantity::Count(2),
+        ]
+        .into_iter()
+        .sum();
+
+        assert_eq!(total.get(), 2.0);
+        assert_eq!((total * uplift).get(), 4.0);
+    }
+
+    #[rstest]
+    fn a_duration_is_billed_in_fractional_seconds() {
+        let per_second = UnitPrice::new(0.01).unwrap();
+
+        let amount = per_second * Quantity::Duration(std::time::Duration::from_millis(2_500));
+
+        assert!((amount.get() - 0.025).abs() < 1e-12);
+    }
+
+    #[cfg(feature = "serde")]
+    #[rstest]
+    #[case::number(serde_json::json!(1.5e-6), Some(1.5e-6))]
+    #[case::integer(serde_json::json!(2), Some(2.0))]
+    #[case::numeric_string(serde_json::json!(" 0.000002 "), Some(2e-6))]
+    #[case::negative(serde_json::json!(-1), None)]
+    #[case::word(serde_json::json!("free"), None)]
+    #[case::boolean(serde_json::json!(true), None)]
+    fn unit_price_reads_numbers_and_numeric_strings(
+        #[case] written: serde_json::Value,
+        #[case] expected: Option<f64>,
+    ) {
+        use serde::Deserialize;
+
+        assert_eq!(
+            UnitPrice::deserialize(&written).ok().map(UnitPrice::get),
+            expected
+        );
+    }
+}
diff --git a/litellm-rust/crates/cost/src/price.rs b/litellm-rust/crates/cost/src/price.rs
new file mode 100644
index 00000000000..a90bedacb0f
--- /dev/null
+++ b/litellm-rust/crates/cost/src/price.rs
@@ -0,0 +1,505 @@
+mod meter;
+
+use std::collections::BTreeMap;
+use std::num::NonZeroU64;
+
+pub use meter::*;
+
+use crate::call::{InferenceGeo, Speed};
+use crate::money::{Multiplier, UnitPrice};
+use crate::schedule::Schedule;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum ServiceTier {
+    #[default]
+    Standard,
+    Priority,
+    Flex,
+    Ultrafast,
+    Balanced,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Band {
+    #[default]
+    Base,
+    OverPromptTokens(NonZeroU64),
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct When {
+    pub tier: ServiceTier,
+    pub band: Band,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Channel {
+    #[default]
+    Online,
+    Batch,
+    Decisions,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Price {
+    pub meter: Meter,
+    pub channel: Channel,
+    pub when: When,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Prices {
+    rates: BTreeMap<Price, UnitPrice>,
+    off_peak: Option<OffPeak>,
+    billing: Billing,
+}
+
+/// Row attributes pricing reads, lowered by model-catalog from the row and its provider
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct Billing {
+    /// Unit the row bills text in. `Character` only when the row prices characters and not tokens
+    pub text_unit: TextUnit,
+    /// Whether a band's floor is in the band. xAI rows bill the band from the floor itself
+    pub band_edge: BandEdge,
+    /// Rate a cache read borrows when the row has no cache-read price. Fireworks rows borrow half the input rate
+    pub cache_read_fallback: CacheReadFallback,
+    /// Whether a row with no token price is priced by wall clock, from its `mode`
+    pub wall_clock: WallClock,
+    /// From `web_search_billing_unit`, whether web search and Maps grounding bill per query or once per prompt
+    pub web_search: WebSearchUnit,
+    /// Whether `tiered_pricing` bills each meter in its own tier or the whole call at the tier the input picks.
+    /// Dashscope rows bill the whole call (inferred, 10 checks no other row has that shape)
+    pub tier_scope: TierScope,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum TextUnit {
+    #[default]
+    Token,
+    Character,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum BandEdge {
+    #[default]
+    Exclusive,
+    Inclusive,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum CacheReadFallback {
+    #[default]
+    InputRate,
+    HalfInputRate,
+}
+
+/// `ResponseTime` for `chat`, `completion`, `embedding`, `responses` or no mode, `AudioFile` for
+/// `audio_transcription`, which prices the input audio when it has one, `Never` for every other mode
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum WallClock {
+    Never,
+    #[default]
+    ResponseTime,
+    AudioFile,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum WebSearchUnit {
+    PerQuery,
+    #[default]
+    PerPrompt,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum TierScope {
+    #[default]
+    PerMeter,
+    WholeCall,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct OffPeak {
+    schedule: Schedule,
+    rates: OffPeakRates,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct OffPeakRates {
+    pub input: Option<UnitPrice>,
+    pub output: Option<UnitPrice>,
+    pub cache_read: Option<UnitPrice>,
+    pub explicit_cache_read: Option<UnitPrice>,
+    pub cache_write: Option<UnitPrice>,
+    pub reasoning: Option<UnitPrice>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Adjustments(BTreeMap<Uplift, Multiplier>);
+
+/// Which call fact picks which multiplier in `Adjustments`, lowered by model-catalog from the row
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Uplift {
+    /// OpenAI data residency
+    Residency(Residency),
+    /// Vertex non-global endpoint, from `regional_endpoint_uplift_multiplier`
+    NonGlobalEndpoint,
+    /// Anthropic `speed: fast`, from `provider_specific_entry.fast`
+    Speed(Speed),
+    /// Anthropic and Bedrock geo, from `provider_specific_entry.<geo>`, lowercased as on main
+    InferenceGeo(InferenceGeo),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Residency {
+    Eu,
+    Us,
+}
+
+impl Band {
+    pub fn over_prompt_tokens(tokens: u64) -> Self {
+        NonZeroU64::new(tokens).map_or(Self::Base, Self::OverPromptTokens)
+    }
+}
+
+impl Price {
+    pub fn online(meter: Meter, when: When) -> Self {
+        Self {
+            meter,
+            channel: Channel::Online,
+            when,
+        }
+    }
+}
+
+impl Prices {
+    pub fn new(
+        rates: BTreeMap<Price, UnitPrice>,
+        off_peak: Option<OffPeak>,
+        billing: Billing,
+    ) -> Self {
+        Self {
+            rates,
+            off_peak,
+            billing,
+        }
+    }
+
+    pub fn get(&self, price: &Price) -> Option<UnitPrice> {
+        self.rates.get(price).copied()
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (&Price, UnitPrice)> {
+        self.rates.iter().map(|(price, rate)| (price, *rate))
+    }
+
+    pub fn off_peak(&self) -> Option<&OffPeak> {
+        self.off_peak.as_ref()
+    }
+
+    pub fn billing(&self) -> Billing {
+        self.billing
+    }
+
+    /// The online prompt band a request falls in. Every token meter's `_above_` prices count,
+    /// and the highest band the prompt passes wins. `billing.band_edge` says whether the floor is in the band.
+    pub fn band(&self, tier: ServiceTier, prompt_tokens: u64) -> Band {
+        let inclusive = self.billing.band_edge == BandEdge::Inclusive;
+        self.rates
+            .keys()
+            .filter(|price| {
+                price.channel == Channel::Online
+                    && price.meter.sets_prompt_band()
+                    && (price.when.tier == ServiceTier::Standard || price.when.tier == tier)
+            })
+            .filter_map(|price| match price.when.band {
+                Band::OverPromptTokens(floor) => Some(floor.get()),
+                Band::Base => None,
+            })
+            .filter(|floor| prompt_tokens > *floor || (inclusive && prompt_tokens == *floor))
+            .max()
+            .map_or(Band::Base, Band::over_prompt_tokens)
+    }
+
+    /// The online rate for `meter`, tried at `(tier, band)`, `(standard, band)`, `(tier, base)`
+    /// and `(standard, base)` in that order. A missing cache price falls back to the input price
+    /// resolved the same way.
+    pub fn rate(&self, meter: &Meter, tier: ServiceTier, band: Band) -> Option<UnitPrice> {
+        [
+            When { tier, band },
+            When {
+                tier: ServiceTier::Standard,
+                band,
+            },
+            When {
+                tier,
+                band: Band::Base,
+            },
+            When::default(),
+        ]
+        .into_iter()
+        .find_map(|when| self.get(&Price::online(meter.clone(), when)))
+        .or_else(|| self.rate(&meter.fallback()?, tier, band))
+    }
+}
+
+impl OffPeak {
+    pub fn new(schedule: Schedule, rates: OffPeakRates) -> Option<Self> {
+        (rates != OffPeakRates::default()).then_some(Self { schedule, rates })
+    }
+
+    pub fn schedule(&self) -> &Schedule {
+        &self.schedule
+    }
+
+    pub fn rates(&self) -> &OffPeakRates {
+        &self.rates
+    }
+}
+
+impl Adjustments {
+    pub fn new(uplifts: impl IntoIterator<Item = (Uplift, Multiplier)>) -> Self {
+        Self(uplifts.into_iter().collect())
+    }
+
+    pub fn get(&self, uplift: &Uplift) -> Option<Multiplier> {
+        self.0.get(uplift).copied()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::{fixture, rstest};
+
+    use super::*;
+
+    const INPUT: Meter = Meter::TEXT_INPUT;
+    const OUTPUT: Meter = Meter::Output(OutputUnit::Token(TokenKind::Text));
+    const CACHE_READ: Meter = Meter::CacheRead {
+        kind: TokenKind::Text,
+        mode: CacheReadMode::Implicit,
+    };
+    const CACHE_WRITE_HOUR: Meter = Meter::CacheWrite {
+        kind: TokenKind::Text,
+        ttl: CacheTtl::OneHour,
+    };
+
+    fn over(tokens: u64) -> Band {
+        Band::over_prompt_tokens(tokens)
+    }
+
+    fn prices(rates: &[(Meter, Channel, ServiceTier, Band, f64)]) -> Prices {
+        priced_with(rates, Billing::default())
+    }
+
+    fn priced_with(rates: &[(Meter, Channel, ServiceTier, Band, f64)], billing: Billing) -> Prices {
+        Prices::new(
+            rates
+                .iter()
+                .map(|(meter, channel, tier, band, rate)| {
+                    (
+                        Price {
+                            meter: meter.clone(),
+                            channel: *channel,
+                            when: When {
+                                tier: *tier,
+                                band: *band,
+                            },
+                        },
+                        UnitPrice::new(*rate).unwrap(),
+                    )
+                })
+                .collect(),
+            None,
+            billing,
+        )
+    }
+
+    #[fixture]
+    fn priority_with_a_standard_band() -> Prices {
+        use Channel::Online;
+        use ServiceTier::{Priority, Standard};
+        prices(&[
+            (INPUT, Online, Standard, Band::Base, 1.0),
+            (INPUT, Online, Priority, Band::Base, 2.0),
+            (INPUT, Online, Standard, over(200_000), 10.0),
+            (OUTPUT, Online, Standard, Band::Base, 3.0),
+            (OUTPUT, Online, Priority, over(200_000), 30.0),
+        ])
+    }
+
+    #[rstest]
+    #[case::below(1_000, false, Band::Base)]
+    #[case::at_floor_exclusive(200_000, false, Band::Base)]
+    #[case::at_floor_inclusive(200_000, true, over(200_000))]
+    #[case::above(200_001, false, over(200_000))]
+    fn the_band_starts_strictly_above_its_floor_unless_inclusive(
+        #[case] prompt_tokens: u64,
+        #[case] inclusive: bool,
+        #[case] expected: Band,
+    ) {
+        let band_edge = if inclusive {
+            BandEdge::Inclusive
+        } else {
+            BandEdge::Exclusive
+        };
+        let prices = priced_with(
+            &[(
+                INPUT,
+                Channel::Online,
+                ServiceTier::Standard,
+                over(200_000),
+                10.0,
+            )],
+            Billing {
+                band_edge,
+                ..Billing::default()
+            },
+        );
+        assert_eq!(prices.band(ServiceTier::Standard, prompt_tokens), expected);
+    }
+
+    #[rstest]
+    fn a_band_only_another_tier_prices_does_not_apply() {
+        let prices = prices(&[(
+            OUTPUT,
+            Channel::Online,
+            ServiceTier::Flex,
+            over(100_000),
+            1.0,
+        )]);
+        assert_eq!(prices.band(ServiceTier::Standard, 300_000), Band::Base);
+        assert_eq!(prices.band(ServiceTier::Flex, 300_000), over(100_000));
+    }
+
+    #[rstest]
+    fn batch_bands_never_pick_the_online_band() {
+        let prices = prices(&[(
+            INPUT,
+            Channel::Batch,
+            ServiceTier::Standard,
+            over(100_000),
+            1.0,
+        )]);
+        assert_eq!(prices.band(ServiceTier::Standard, 300_000), Band::Base);
+    }
+
+    #[rstest]
+    fn the_highest_band_passed_wins() {
+        let prices = prices(&[
+            (
+                INPUT,
+                Channel::Online,
+                ServiceTier::Standard,
+                over(100_000),
+                1.0,
+            ),
+            (
+                OUTPUT,
+                Channel::Online,
+                ServiceTier::Standard,
+                over(200_000),
+                1.0,
+            ),
+        ]);
+        assert_eq!(prices.band(ServiceTier::Standard, 300_000), over(200_000));
+    }
+
+    #[rstest]
+    #[case::tier_base(INPUT, ServiceTier::Priority, Band::Base, Some(2.0))]
+    #[case::standard_band_beats_tier_base(INPUT, ServiceTier::Priority, over(200_000), Some(10.0))]
+    #[case::tier_band(OUTPUT, ServiceTier::Priority, over(200_000), Some(30.0))]
+    #[case::standard_base_when_nothing_else(OUTPUT, ServiceTier::Flex, over(200_000), Some(3.0))]
+    #[case::cache_read_falls_back_to_the_resolved_input(
+        CACHE_READ,
+        ServiceTier::Priority,
+        over(200_000),
+        Some(10.0)
+    )]
+    #[case::one_hour_write_falls_back_through_write_to_input(
+        CACHE_WRITE_HOUR,
+        ServiceTier::Priority,
+        Band::Base,
+        Some(2.0)
+    )]
+    #[case::twelve_hour_write_falls_back_through_write_to_input(
+        Meter::CacheWrite { kind: TokenKind::Text, ttl: CacheTtl::TwelveHours },
+        ServiceTier::Standard,
+        Band::Base,
+        Some(1.0)
+    )]
+    #[case::no_fallback_for_other_meters(
+        Meter::Input(InputUnit::Token(TokenKind::Audio)),
+        ServiceTier::Standard,
+        Band::Base,
+        None
+    )]
+    fn rate_walks_tier_then_band(
+        priority_with_a_standard_band: Prices,
+        #[case] meter: Meter,
+        #[case] tier: ServiceTier,
+        #[case] band: Band,
+        #[case] expected: Option<f64>,
+    ) {
+        assert_eq!(
+            priority_with_a_standard_band
+                .rate(&meter, tier, band)
+                .map(UnitPrice::get),
+            expected
+        );
+    }
+
+    #[rstest]
+    fn an_explicit_cache_price_wins_over_the_input_fallback() {
+        let prices = prices(&[
+            (
+                INPUT,
+                Channel::Online,
+                ServiceTier::Standard,
+                Band::Base,
+                1.0,
+            ),
+            (
+                CACHE_READ,
+                Channel::Online,
+                ServiceTier::Standard,
+                Band::Base,
+                0.0,
+            ),
+        ]);
+        assert_eq!(
+            prices
+                .rate(&CACHE_READ, ServiceTier::Standard, Band::Base)
+                .map(UnitPrice::get),
+            Some(0.0)
+        );
+    }
+
+    #[rstest]
+    fn off_peak_needs_a_price() {
+        let schedule = Schedule {
+            windows: Vec::new(),
+            weekday_timezone: None,
+        };
+        assert_eq!(
+            OffPeak::new(schedule.clone(), OffPeakRates::default()),
+            None
+        );
+        assert!(
+            OffPeak::new(
+                schedule,
+                OffPeakRates {
+                    output: UnitPrice::new(1.0),
+                    ..OffPeakRates::default()
+                }
+            )
+            .is_some()
+        );
+    }
+
+    #[rstest]
+    #[case::zero(0, Band::Base)]
+    #[case::positive(272_000, Band::OverPromptTokens(NonZeroU64::new(272_000).unwrap()))]
+    fn a_zero_floor_is_the_base_band(#[case] tokens: u64, #[case] expected: Band) {
+        assert_eq!(Band::over_prompt_tokens(tokens), expected);
+    }
+}
diff --git a/litellm-rust/crates/cost/src/price/meter.rs b/litellm-rust/crates/cost/src/price/meter.rs
new file mode 100644
index 00000000000..6e68981d011
--- /dev/null
+++ b/litellm-rust/crates/cost/src/price/meter.rs
@@ -0,0 +1,197 @@
+use std::num::NonZeroU64;
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Meter {
+    Input(InputUnit),
+    Output(OutputUnit),
+    CacheRead {
+        kind: TokenKind,
+        mode: CacheReadMode,
+    },
+    CacheWrite {
+        kind: TokenKind,
+        ttl: CacheTtl,
+    },
+    Feature(Feature),
+    WallClockSecond,
+    WebSearch(SearchContextSize),
+    Guardrail(GuardrailUnit),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum TokenKind {
+    Text,
+    Audio,
+    Image,
+    Video,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum InputUnit {
+    Token(TokenKind),
+    Character,
+    Image,
+    Pixel,
+    Query { over_results: Option<NonZeroU64> },
+    Request,
+    Second,
+    TextMessage,
+    AudioSecond,
+    VideoSecond { over_seconds: Option<NonZeroU64> },
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum OutputUnit {
+    Token(TokenKind),
+    ReasoningToken,
+    Character,
+    Image(Option<ImageSize>),
+    Pixel,
+    Second(Option<Resolution>),
+    VideoSecond,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum CacheReadMode {
+    Implicit,
+    Explicit,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum CacheTtl {
+    Default,
+    OneHour,
+    TwelveHours,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Feature {
+    AnnotationPage,
+    CitationToken,
+    CodeInterpreterSession,
+    GoogleMapsGroundingQuery,
+    OcrCredit,
+    OcrPage,
+    /// `browser_open_cost_per_request`, Groq `browser.open`
+    BrowserOpen,
+    /// `cost_per_additional_result`, Parallel AI results past the ones the query price includes
+    AdditionalResult,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum SearchContextSize {
+    Low,
+    Medium,
+    High,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct GuardrailUnit(Box<str>);
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ImageSize(Box<str>);
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Resolution(Box<str>);
+
+impl Meter {
+    pub(crate) const TEXT_INPUT: Self = Self::Input(InputUnit::Token(TokenKind::Text));
+
+    pub(crate) fn sets_prompt_band(&self) -> bool {
+        matches!(
+            self,
+            Self::Input(InputUnit::Token(TokenKind::Text))
+                | Self::Output(OutputUnit::Token(TokenKind::Text))
+                | Self::CacheRead {
+                    kind: TokenKind::Text,
+                    mode: CacheReadMode::Implicit,
+                }
+                | Self::CacheWrite {
+                    kind: TokenKind::Text,
+                    ..
+                }
+        )
+    }
+
+    pub(crate) fn fallback(&self) -> Option<Self> {
+        match self {
+            Self::CacheRead {
+                kind: TokenKind::Text,
+                mode: CacheReadMode::Implicit,
+            }
+            | Self::CacheWrite {
+                kind: TokenKind::Text,
+                ttl: CacheTtl::Default,
+            } => Some(Self::TEXT_INPUT),
+            Self::CacheWrite {
+                kind: TokenKind::Text,
+                ttl: CacheTtl::OneHour | CacheTtl::TwelveHours,
+            } => Some(Self::CacheWrite {
+                kind: TokenKind::Text,
+                ttl: CacheTtl::Default,
+            }),
+            _ => None,
+        }
+    }
+}
+
+impl GuardrailUnit {
+    pub fn new(counter: &str) -> Self {
+        Self(counter.into())
+    }
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+}
+
+impl ImageSize {
+    pub fn new(label: &str) -> Option<Self> {
+        let number = label.strip_suffix('K').unwrap_or(label);
+        let (whole, fraction) = number.split_once('.').unwrap_or((number, "0"));
+        (is_digits(whole) && is_digits(fraction)).then(|| Self(label.into()))
+    }
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+}
+
+impl Resolution {
+    pub fn new(label: &str) -> Option<Self> {
+        let digits = label.strip_suffix(['p', 'k'])?;
+        is_digits(digits).then(|| Self(label.into()))
+    }
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+}
+
+fn is_digits(value: &str) -> bool {
+    !value.is_empty() && value.bytes().all(|byte| byte.is_ascii_digit())
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+
+    use super::*;
+
+    #[rstest]
+    #[case::kilo("1K", true)]
+    #[case::half_kilo("0.5K", true)]
+    #[case::pixels("1024", true)]
+    #[case::word("big", false)]
+    #[case::bare_suffix("K", false)]
+    #[case::trailing_dot("1.K", false)]
+    fn image_size_labels_are_numbers_with_an_optional_k(#[case] label: &str, #[case] valid: bool) {
+        assert_eq!(ImageSize::new(label).is_some(), valid);
+    }
+
+    #[rstest]
+    #[case::progressive("720p", true)]
+    #[case::kilo("4k", true)]
+    #[case::bare("720", false)]
+    #[case::word("hd", false)]
+    fn resolution_labels_are_numbers_with_p_or_k(#[case] label: &str, #[case] valid: bool) {
+        assert_eq!(Resolution::new(label).is_some(), valid);
+    }
+}
diff --git a/litellm-rust/crates/cost/src/priced.rs b/litellm-rust/crates/cost/src/priced.rs
new file mode 100644
index 00000000000..535560c1b9a
--- /dev/null
+++ b/litellm-rust/crates/cost/src/priced.rs
@@ -0,0 +1,53 @@
+use std::time::Duration;
+
+use crate::money::{UnitPrice, Usd};
+use crate::price::Meter;
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Outcome {
+    Priced(Priced),
+    /// No meter with usage had a price
+    Unpriced {
+        missing: Vec<Meter>,
+    },
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Priced {
+    /// One line per billed meter, fallbacks included
+    pub lines: Vec<Line>,
+    /// Meters with usage and no price and no fallback
+    pub missing: Vec<Meter>,
+    /// Sum of `lines`
+    pub total: Usd,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Line {
+    /// The meter this line bills
+    pub meter: Meter,
+    /// How much of the meter the call used
+    pub quantity: Quantity,
+    /// Rate after off-peak and before uplifts
+    pub unit_price: UnitPrice,
+    /// `unit_price * quantity` times every uplift that applies
+    pub amount: Usd,
+    /// The meter whose rate was borrowed, when this meter had none
+    pub fallback_from: Option<Meter>,
+    /// Which half of main's `(prompt, completion)` pair the line belongs to
+    pub side: Side,
+}
+
+/// A billed amount of one meter
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Quantity {
+    Count(u64),
+    Duration(Duration),
+}
+
+/// Meters main bills as one total (video, Replicate, Amazon Transcribe) take a fixed side, chosen in 09
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Side {
+    Prompt,
+    Completion,
+}
diff --git a/litellm-rust/crates/cost/src/schedule.rs b/litellm-rust/crates/cost/src/schedule.rs
new file mode 100644
index 00000000000..adebc044cca
--- /dev/null
+++ b/litellm-rust/crates/cost/src/schedule.rs
@@ -0,0 +1,241 @@
+use std::str::FromStr;
+
+use crate::Error;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Schedule {
+    pub windows: Vec<Window>,
+    pub weekday_timezone: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Window {
+    pub hours: Vec<UtcWindow>,
+    pub weekdays: Option<Vec<Weekday>>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct UtcWindow {
+    pub start_minute: u16,
+    pub end_minute: u16,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Weekday {
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+    Sunday,
+}
+
+impl FromStr for UtcWindow {
+    type Err = Error;
+
+    fn from_str(window: &str) -> Result<Self, Self::Err> {
+        let (start, end) = window.split_once('-').ok_or(Error::InvalidUtcWindow)?;
+        Ok(Self {
+            start_minute: minute_of_day(start).ok_or(Error::InvalidUtcWindow)?,
+            end_minute: minute_of_day(end).ok_or(Error::InvalidUtcWindow)?,
+        })
+    }
+}
+
+fn minute_of_day(clock: &str) -> Option<u16> {
+    let (hour, minute) = clock.split_once(':')?;
+    if hour.len() != 2 || minute.len() != 2 {
+        return None;
+    }
+    let hour: u16 = hour.parse().ok().filter(|hour| *hour < 24)?;
+    let minute: u16 = minute.parse().ok().filter(|minute| *minute < 60)?;
+    Some(hour * 60 + minute)
+}
+
+impl Weekday {
+    pub fn from_iso(number: u8) -> Option<Self> {
+        match number {
+            1 => Some(Self::Monday),
+            2 => Some(Self::Tuesday),
+            3 => Some(Self::Wednesday),
+            4 => Some(Self::Thursday),
+            5 => Some(Self::Friday),
+            6 => Some(Self::Saturday),
+            7 => Some(Self::Sunday),
+            _ => None,
+        }
+    }
+}
+
+impl FromStr for Weekday {
+    type Err = Error;
+
+    fn from_str(name: &str) -> Result<Self, Self::Err> {
+        match name.trim().to_ascii_lowercase().as_str() {
+            "mon" | "monday" => Ok(Self::Monday),
+            "tue" | "tues" | "tuesday" => Ok(Self::Tuesday),
+            "wed" | "wednesday" => Ok(Self::Wednesday),
+            "thu" | "thur" | "thurs" | "thursday" => Ok(Self::Thursday),
+            "fri" | "friday" => Ok(Self::Friday),
+            "sat" | "saturday" => Ok(Self::Saturday),
+            "sun" | "sunday" => Ok(Self::Sunday),
+            _ => Err(Error::InvalidWeekday),
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+mod serde_impls {
+    use std::fmt;
+
+    use serde::de::{self, Deserialize, Deserializer, Visitor};
+
+    use super::{UtcWindow, Weekday};
+
+    impl<'de> Deserialize<'de> for UtcWindow {
+        fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+            let window = String::deserialize(deserializer)?;
+            window.parse().map_err(de::Error::custom)
+        }
+    }
+
+    struct WrittenWeekday;
+
+    impl Visitor<'_> for WrittenWeekday {
+        type Value = Weekday;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+            formatter.write_str("an ISO weekday number 1-7 or an English day name")
+        }
+
+        fn visit_u64<E: de::Error>(self, number: u64) -> Result<Weekday, E> {
+            u8::try_from(number)
+                .ok()
+                .and_then(Weekday::from_iso)
+                .ok_or_else(|| E::invalid_value(de::Unexpected::Unsigned(number), &self))
+        }
+
+        fn visit_i64<E: de::Error>(self, number: i64) -> Result<Weekday, E> {
+            u64::try_from(number)
+                .map_err(|_| E::invalid_value(de::Unexpected::Signed(number), &self))
+                .and_then(|number| self.visit_u64(number))
+        }
+
+        fn visit_str<E: de::Error>(self, name: &str) -> Result<Weekday, E> {
+            name.parse()
+                .map_err(|_| E::invalid_value(de::Unexpected::Str(name), &self))
+        }
+    }
+
+    impl<'de> Deserialize<'de> for Weekday {
+        fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+            deserializer.deserialize_any(WrittenWeekday)
+        }
+    }
+}
+
+#[cfg(feature = "schema")]
+mod schema {
+    use std::borrow::Cow;
+
+    use schemars::{JsonSchema, Schema, SchemaGenerator, json_schema};
+
+    use super::{UtcWindow, Weekday};
+
+    impl JsonSchema for UtcWindow {
+        fn inline_schema() -> bool {
+            true
+        }
+        fn schema_name() -> Cow<'static, str> {
+            "UtcWindow".into()
+        }
+        fn json_schema(_: &mut SchemaGenerator) -> Schema {
+            json_schema!({
+                "type": "string",
+                "pattern": r"^([01]\d|2[0-3]):[0-5]\d-([01]\d|2[0-3]):[0-5]\d$"
+            })
+        }
+    }
+
+    impl JsonSchema for Weekday {
+        fn inline_schema() -> bool {
+            true
+        }
+        fn schema_name() -> Cow<'static, str> {
+            "Weekday".into()
+        }
+        fn json_schema(_: &mut SchemaGenerator) -> Schema {
+            json_schema!({
+                "anyOf": [
+                    {"type": "integer", "minimum": 1, "maximum": 7},
+                    {
+                        "type": "string",
+                        "pattern": r"(?i)^\s*(mon|monday|tue|tues|tuesday|wed|wednesday|thu|thur|thurs|thursday|fri|friday|sat|saturday|sun|sunday)\s*$"
+                    }
+                ]
+            })
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+
+    use super::*;
+
+    #[rstest]
+    #[case::same_day("10:00-18:30", Some((600, 1110)))]
+    #[case::wraps_midnight("22:00-02:00", Some((1320, 120)))]
+    #[case::whole_day("00:00-00:00", Some((0, 0)))]
+    #[case::hour_out_of_range("25:00-01:00", None)]
+    #[case::minute_out_of_range("10:60-11:00", None)]
+    #[case::one_digit_hour("9:00-10:00", None)]
+    #[case::no_separator("10:00", None)]
+    fn utc_window_reads_hh_mm_ranges(#[case] text: &str, #[case] expected: Option<(u16, u16)>) {
+        assert_eq!(
+            text.parse::<UtcWindow>()
+                .ok()
+                .map(|window| (window.start_minute, window.end_minute)),
+            expected
+        );
+    }
+
+    #[rstest]
+    #[case::short("thurs", Some(Weekday::Thursday))]
+    #[case::upper("SATURDAY", Some(Weekday::Saturday))]
+    #[case::padded(" mon ", Some(Weekday::Monday))]
+    #[case::unknown("someday", None)]
+    #[case::empty("", None)]
+    fn weekday_names_match_python_after_trimming(
+        #[case] name: &str,
+        #[case] expected: Option<Weekday>,
+    ) {
+        assert_eq!(name.parse().ok(), expected);
+    }
+
+    #[rstest]
+    #[case::monday(1, Some(Weekday::Monday))]
+    #[case::sunday(7, Some(Weekday::Sunday))]
+    #[case::zero(0, None)]
+    #[case::eight(8, None)]
+    fn weekday_numbers_are_iso(#[case] number: u8, #[case] expected: Option<Weekday>) {
+        assert_eq!(Weekday::from_iso(number), expected);
+    }
+
+    #[cfg(feature = "serde")]
+    #[rstest]
+    #[case::number(serde_json::json!(6), Some(Weekday::Saturday))]
+    #[case::name(serde_json::json!("Sun"), Some(Weekday::Sunday))]
+    #[case::negative(serde_json::json!(-1), None)]
+    #[case::boolean(serde_json::json!(true), None)]
+    fn weekday_reads_numbers_and_names(
+        #[case] written: serde_json::Value,
+        #[case] expected: Option<Weekday>,
+    ) {
+        use serde::Deserialize;
+
+        assert_eq!(Weekday::deserialize(&written).ok(), expected);
+    }
+}
diff --git a/litellm-rust/crates/cost/src/usage.rs b/litellm-rust/crates/cost/src/usage.rs
new file mode 100644
index 00000000000..8eed83ac87b
--- /dev/null
+++ b/litellm-rust/crates/cost/src/usage.rs
@@ -0,0 +1,104 @@
+use std::collections::BTreeMap;
+use std::time::Duration;
+
+use crate::price::{CacheReadMode, CacheTtl, ImageSize, Resolution, SearchContextSize, TokenKind};
+
+/// What one call consumed. Python fills it from the provider response, `calculate` never reads the catalog for it
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Usage {
+    /// Prompt size as the provider reported it. Only picks `_above_Nk_tokens` bands, never billed.
+    /// Filled even when the call bills characters, `0` when the provider reports none
+    pub prompt_tokens: u64,
+    /// Billed token quantities by meter
+    pub tokens: Tokens,
+    /// Billed character quantities. Used only when the row's `billing.text_unit` is `Character`
+    pub characters: Characters,
+    /// Billed time per second meter, never a bare number of seconds or milliseconds
+    pub durations: BTreeMap<DurationMeter, Duration>,
+    /// Images sent and returned
+    pub images: Images,
+    /// Search queries, web searches and grounding requests
+    pub search: Search,
+    /// Realtime text messages, xAI bills them per message
+    pub text_messages: u64,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Tokens {
+    /// Uncached prompt tokens by modality
+    pub input: BTreeMap<TokenKind, u64>,
+    /// Prompt tokens served from cache, by modality and implicit or explicit cache
+    pub cache_read: BTreeMap<(TokenKind, CacheReadMode), u64>,
+    /// Prompt tokens written to cache, by modality and cache lifetime
+    pub cache_write: BTreeMap<(TokenKind, CacheTtl), u64>,
+    /// Completion tokens by modality, reasoning excluded
+    pub output: BTreeMap<TokenKind, u64>,
+    /// Reasoning tokens, billed at the reasoning rate or the text output rate
+    pub reasoning: u64,
+    /// Perplexity citation tokens, prompt side
+    pub citation: u64,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct Characters {
+    /// Characters of the formatted prompt
+    pub prompt: u64,
+    /// Characters of the response text
+    pub completion: u64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum DurationMeter {
+    /// Response time of the call, for rows priced by wall clock
+    WallClock,
+    /// Length of the input audio, a transcription file or a realtime transcription
+    InputAudio,
+    /// Realtime voice session time
+    LiveVoice,
+    /// Length of generated video, already multiplied by the video count. `resolution` picks `output_cost_per_second_<resolution>`
+    OutputVideo { resolution: Option<Resolution> },
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Images {
+    /// Images sent in the request
+    pub input: u64,
+    /// Pixels sent in the request, for rows priced per input pixel
+    pub input_pixels: u64,
+    /// One entry per returned image, since price can depend on each image's size
+    pub output: Vec<ImageOut>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct ImageOut {
+    /// Size the request asked for, picks a size keyed price like fal's `output_cost_per_image_<size>`
+    pub size: Option<ImageSize>,
+    /// Pixel width the response reported, for per-pixel and nearest-size pricing
+    pub width: Option<u32>,
+    /// Pixel height the response reported, for per-pixel and nearest-size pricing
+    pub height: Option<u32>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Search {
+    /// Search API queries, for `input_cost_per_query` rows
+    pub queries: u64,
+    /// Results the query asked for, picks the `max_results_range` tier
+    pub max_results: Option<u64>,
+    /// Web searches a model ran as a tool
+    pub web_search: Option<WebSearch>,
+    /// Google Maps grounding requests
+    pub maps_grounding: u64,
+    /// Groq `browser.open` calls
+    pub browser_opens: u64,
+    /// Results past the ones the query price includes. Python counts them, since the included 10 is a request default
+    pub additional_results: u64,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct WebSearch {
+    /// Web search requests the model made
+    pub requests: u64,
+    /// Context size the request asked for, picks `search_context_size_<size>`
+    pub context: SearchContextSize,
+}
diff --git a/litellm-rust/crates/cost/tests/calculation.rs b/litellm-rust/crates/cost/tests/calculation.rs
deleted file mode 100644
index af1a73d8c61..00000000000
--- a/litellm-rust/crates/cost/tests/calculation.rs
+++ /dev/null
@@ -1,535 +0,0 @@
-use litellm_cost::{
-    Error, OffPeakRates, Pricing, PromptConvention, Rate, Rates, Request, ServiceTier,
-    ThresholdPolicy, ThresholdRates, TierRates, Usage, calculate, compile,
-};
-use rstest::rstest;
-
-fn rates(input: Rate, output: Rate) -> Rates {
-    Rates {
-        input,
-        output,
-        ..Rates::EMPTY
-    }
-}
-
-fn request() -> Request {
-    Request {
-        usage: Usage {
-            prompt_tokens: 100,
-            completion_tokens: 20,
-            cache_read_tokens: 25,
-            cache_write_tokens: 10,
-            cache_write_5m_tokens: None,
-            cache_write_1h_tokens: None,
-            prompt_convention: PromptConvention::IncludesCache,
-        },
-        service_tier: ServiceTier::Standard,
-        threshold_policy: ThresholdPolicy::Exclusive,
-        region_multiplier: None,
-        billed_at_utc_minute: None,
-    }
-}
-
-fn pricing(standard: Rates) -> Pricing<'static> {
-    Pricing {
-        standard,
-        tiers: &[],
-        thresholds: &[],
-        off_peak: None,
-    }
-}
-
-#[test]
-fn breakdown_and_total_agree() {
-    let standard = Rates {
-        cache_read: Rate::Value(0.5),
-        cache_write: Rate::Value(3.0),
-        ..rates(Rate::Value(2.0), Rate::Value(4.0))
-    };
-    let result = calculate(&pricing(standard), &request()).unwrap();
-    assert_eq!(result.uncached_input, 65.0 * 2.0);
-    assert_eq!(result.cache_read, 25.0 * 0.5);
-    assert_eq!(result.cache_write_5m, 10.0 * 3.0);
-    assert_eq!(result.output(), 20.0 * 4.0);
-    assert_eq!(result.total(), result.input() + result.output());
-    assert_eq!(result.rates.cache_read, 0.5);
-}
-
-#[rstest]
-#[case::missing(Rate::Missing, Rate::Missing, 200.0)]
-#[case::null(Rate::Null, Rate::Missing, 200.0)]
-#[case::zero(Rate::Value(0.0), Rate::Value(0.0), 130.0)]
-fn absent_null_and_zero_cache_rates_are_distinct(
-    #[case] cache_read: Rate,
-    #[case] cache_write: Rate,
-    #[case] expected_input: f64,
-) {
-    let base = rates(Rate::Value(2.0), Rate::Value(4.0));
-    let standard = Rates {
-        cache_read,
-        cache_write,
-        ..base
-    };
-    assert_eq!(
-        calculate(&pricing(standard), &request()).unwrap().input(),
-        expected_input
-    );
-}
-
-#[test]
-fn equivalent_prompt_conventions_select_the_same_threshold() {
-    let threshold = ThresholdRates {
-        above_prompt_tokens: 90,
-        standard: rates(Rate::Value(5.0), Rate::Value(8.0)),
-        tiers: &[],
-    };
-    let specification = Pricing {
-        standard: rates(Rate::Value(2.0), Rate::Value(4.0)),
-        tiers: &[],
-        thresholds: &[threshold],
-        off_peak: None,
-    };
-    let included = request();
-    let excluded = Request {
-        usage: Usage {
-            prompt_tokens: 65,
-            prompt_convention: PromptConvention::ExcludesCache,
-            ..included.usage
-        },
-        ..included
-    };
-    let plan = compile(&specification).unwrap();
-    assert_eq!(plan.calculate(&included), plan.calculate(&excluded));
-    assert_eq!(plan.calculate(&included).unwrap().rates.input, 5.0);
-}
-
-#[test]
-fn split_writes_and_invalid_accounting() {
-    let standard = Rates {
-        cache_read: Rate::Value(0.5),
-        cache_write: Rate::Value(3.0),
-        cache_write_1h: Rate::Value(5.0),
-        ..rates(Rate::Value(2.0), Rate::Value(4.0))
-    };
-    let base = request();
-    let split = Request {
-        usage: Usage {
-            cache_write_5m_tokens: Some(4),
-            cache_write_1h_tokens: Some(6),
-            ..base.usage
-        },
-        ..base
-    };
-    let result = calculate(&pricing(standard), &split).unwrap();
-    assert_eq!(result.cache_write_5m, 12.0);
-    assert_eq!(result.cache_write_1h, 30.0);
-    let overlapping = Request {
-        usage: Usage {
-            prompt_tokens: 30,
-            ..split.usage
-        },
-        ..split
-    };
-    assert_eq!(
-        calculate(&pricing(standard), &overlapping),
-        Err(Error::CacheExceedsPrompt)
-    );
-    let incomplete = Request {
-        usage: Usage {
-            cache_write_1h_tokens: None,
-            ..split.usage
-        },
-        ..split
-    };
-    assert_eq!(
-        calculate(&pricing(standard), &incomplete),
-        Err(Error::InvalidCacheWriteDetails)
-    );
-}
-
-#[test]
-fn threshold_tiers_and_boundaries() {
-    let priority = TierRates {
-        tier: ServiceTier::Priority,
-        rates: rates(Rate::Value(3.0), Rate::Missing),
-    };
-    let threshold = ThresholdRates {
-        above_prompt_tokens: 100,
-        standard: rates(Rate::Value(5.0), Rate::Value(8.0)),
-        tiers: &[
-            TierRates {
-                tier: ServiceTier::Priority,
-                rates: rates(Rate::Value(7.0), Rate::Missing),
-            },
-            TierRates {
-                tier: ServiceTier::Flex,
-                rates: rates(Rate::Value(6.0), Rate::Missing),
-            },
-        ],
-    };
-    let specification = Pricing {
-        standard: rates(Rate::Value(2.0), Rate::Value(4.0)),
-        tiers: &[priority],
-        thresholds: &[threshold],
-        off_peak: None,
-    };
-    let base = request();
-    let no_cache = Request {
-        usage: Usage {
-            cache_read_tokens: 0,
-            cache_write_tokens: 0,
-            ..base.usage
-        },
-        ..base
-    };
-    let fast = Request {
-        service_tier: ServiceTier::Fast,
-        ..no_cache
-    };
-    let inclusive = Request {
-        threshold_policy: ThresholdPolicy::Inclusive,
-        ..fast
-    };
-    let flex = Request {
-        service_tier: ServiceTier::Flex,
-        ..inclusive
-    };
-    assert_eq!(calculate(&specification, &no_cache).unwrap().input(), 200.0);
-    assert_eq!(calculate(&specification, &fast).unwrap().input(), 300.0);
-    assert_eq!(
-        calculate(&specification, &inclusive).unwrap().input(),
-        700.0
-    );
-    assert_eq!(calculate(&specification, &flex).unwrap().input(), 600.0);
-}
-
-#[rstest]
-#[case::ultrafast_above_threshold(ServiceTier::Ultrafast, 300_000, 9_301_000.0, 37_000.0)]
-#[case::ultrafast_at_threshold(ServiceTier::Ultrafast, 272_000, 544_500.0, 5_000.0)]
-#[case::standard_above_threshold(ServiceTier::Standard, 300_000, 3_300_600.0, 13_000.0)]
-#[case::priority_above_threshold(ServiceTier::Priority, 300_000, 5_701_000.0, 23_000.0)]
-fn tiered_long_context_rates_are_selected_by_service_tier(
-    #[case] service_tier: ServiceTier,
-    #[case] prompt_tokens: u64,
-    #[case] expected_input: f64,
-    #[case] expected_output: f64,
-) {
-    let standard = Rates {
-        cache_read: Rate::Value(3.0),
-        ..rates(Rate::Value(1.0), Rate::Value(2.0))
-    };
-    let tiers = [
-        TierRates {
-            tier: ServiceTier::Priority,
-            rates: Rates {
-                cache_read: Rate::Value(5.0),
-                ..rates(Rate::Value(3.0), Rate::Value(4.0))
-            },
-        },
-        TierRates {
-            tier: ServiceTier::Ultrafast,
-            rates: Rates {
-                cache_read: Rate::Value(7.0),
-                ..rates(Rate::Value(2.0), Rate::Value(5.0))
-            },
-        },
-    ];
-    let threshold_tiers = [
-        TierRates {
-            tier: ServiceTier::Priority,
-            rates: Rates {
-                cache_read: Rate::Value(29.0),
-                ..rates(Rate::Value(19.0), Rate::Value(23.0))
-            },
-        },
-        TierRates {
-            tier: ServiceTier::Ultrafast,
-            rates: Rates {
-                cache_read: Rate::Value(41.0),
-                ..rates(Rate::Value(31.0), Rate::Value(37.0))
-            },
-        },
-    ];
-    let thresholds = [ThresholdRates {
-        above_prompt_tokens: 272_000,
-        standard: Rates {
-            cache_read: Rate::Value(17.0),
-            ..rates(Rate::Value(11.0), Rate::Value(13.0))
-        },
-        tiers: &threshold_tiers,
-    }];
-    let pricing = Pricing {
-        standard,
-        tiers: &tiers,
-        thresholds: &thresholds,
-        off_peak: None,
-    };
-    let base = request();
-    let long_context_request = Request {
-        usage: Usage {
-            prompt_tokens,
-            completion_tokens: 1_000,
-            cache_read_tokens: 100,
-            cache_write_tokens: 0,
-            ..base.usage
-        },
-        service_tier,
-        ..base
-    };
-    let cost = calculate(&pricing, &long_context_request).unwrap();
-
-    assert_eq!(cost.input(), expected_input);
-    assert_eq!(cost.output(), expected_output);
-}
-
-#[test]
-fn compile_rejects_ambiguous_rates() {
-    let duplicate = ThresholdRates {
-        above_prompt_tokens: 100,
-        standard: Rates::EMPTY,
-        tiers: &[],
-    };
-    let specification = Pricing {
-        standard: rates(Rate::Value(1.0), Rate::Value(1.0)),
-        tiers: &[],
-        thresholds: &[duplicate, duplicate],
-        off_peak: None,
-    };
-    assert_eq!(
-        compile(&specification).err(),
-        Some(Error::DuplicateThreshold)
-    );
-    let invalid = pricing(rates(Rate::Value(f64::NAN), Rate::Value(1.0)));
-    assert_eq!(compile(&invalid).err(), Some(Error::InvalidRate));
-}
-
-#[test]
-fn off_peak_is_one_non_wrapping_utc_window() {
-    let specification = Pricing {
-        standard: rates(Rate::Value(2.0), Rate::Value(4.0)),
-        tiers: &[],
-        thresholds: &[],
-        off_peak: Some(OffPeakRates {
-            start_utc_minute: 60,
-            end_utc_minute: 120,
-            rates: rates(Rate::Value(1.0), Rate::Value(2.0)),
-        }),
-    };
-    let base = request();
-    let start = Request {
-        billed_at_utc_minute: Some(60),
-        ..base
-    };
-    let end = Request {
-        billed_at_utc_minute: Some(120),
-        ..base
-    };
-    assert_eq!(
-        calculate(&specification, &base),
-        Err(Error::InvalidBillingTime)
-    );
-    assert_eq!(calculate(&specification, &start).unwrap().input(), 100.0);
-    assert_eq!(calculate(&specification, &end).unwrap().input(), 200.0);
-}
-
-#[test]
-fn missing_rates_and_free_rates_remain_distinct() {
-    let base = request();
-    let empty = Request {
-        usage: Usage {
-            prompt_tokens: 0,
-            completion_tokens: 0,
-            cache_read_tokens: 0,
-            cache_write_tokens: 0,
-            ..base.usage
-        },
-        ..base
-    };
-    assert_eq!(
-        calculate(&pricing(Rates::EMPTY), &empty),
-        Err(Error::MissingInputRate)
-    );
-    assert_eq!(
-        calculate(&pricing(rates(Rate::Value(0.0), Rate::Missing)), &empty),
-        Err(Error::MissingOutputRate)
-    );
-    assert_eq!(
-        calculate(&pricing(rates(Rate::Value(0.0), Rate::Value(0.0))), &empty)
-            .unwrap()
-            .total(),
-        0.0
-    );
-}
-
-#[test]
-fn matches_executed_python_reference_cases() {
-    for row in include_str!("python_reference.tsv")
-        .lines()
-        .filter(|line| !line.starts_with('#'))
-    {
-        let fields: Vec<_> = row.split('\t').collect();
-        let count = |index: usize| fields[index].parse::<u64>().unwrap();
-        let number = |index: usize| fields[index].parse::<f64>().unwrap();
-        let optional_rate = |index: usize| {
-            if fields[index].is_empty() {
-                Rate::Missing
-            } else {
-                Rate::Value(number(index))
-            }
-        };
-        let threshold = ThresholdRates {
-            above_prompt_tokens: if fields[9].is_empty() { 0 } else { count(9) },
-            standard: rates(optional_rate(10), optional_rate(11)),
-            tiers: &[],
-        };
-        let thresholds = if fields[9].is_empty() {
-            &[][..]
-        } else {
-            std::slice::from_ref(&threshold)
-        };
-        let specification = Pricing {
-            standard: Rates {
-                cache_read: optional_rate(7),
-                cache_write: optional_rate(8),
-                ..rates(Rate::Value(number(5)), Rate::Value(number(6)))
-            },
-            tiers: &[],
-            thresholds,
-            off_peak: None,
-        };
-        let base = request();
-        let input = Request {
-            usage: Usage {
-                prompt_tokens: count(1),
-                completion_tokens: count(2),
-                cache_read_tokens: count(3),
-                cache_write_tokens: count(4),
-                ..base.usage
-            },
-            ..base
-        };
-        let actual = calculate(&specification, &input).unwrap();
-        assert_eq!(actual.input(), number(12), "{}", fields[0]);
-        assert_eq!(actual.output(), number(13), "{}", fields[0]);
-    }
-}
-
-proptest::proptest! {
-    #[test]
-    fn equivalent_usage_conventions_and_breakdown_agree(
-        regular in 0_u64..1000,
-        read in 0_u64..1000,
-        write in 0_u64..1000,
-        output in 0_u64..1000,
-    ) {
-        let threshold = ThresholdRates {
-            above_prompt_tokens: 1000,
-            standard: rates(Rate::Value(5.0), Rate::Value(8.0)),
-            tiers: &[],
-        };
-        let specification = Pricing {
-            standard: rates(Rate::Value(2.0), Rate::Value(4.0)),
-            tiers: &[],
-            thresholds: &[threshold],
-            off_peak: None,
-        };
-        let base = request();
-        let included = Request {
-            usage: Usage {
-                prompt_tokens: regular + read + write,
-                completion_tokens: output,
-                cache_read_tokens: read,
-                cache_write_tokens: write,
-                ..base.usage
-            },
-            ..base
-        };
-        let excluded = Request {
-            usage: Usage {
-                prompt_tokens: regular,
-                prompt_convention: PromptConvention::ExcludesCache,
-                ..included.usage
-            },
-            ..included
-        };
-        let plan = compile(&specification).unwrap();
-        let left = plan.calculate(&included).unwrap();
-        let right = plan.calculate(&excluded).unwrap();
-        proptest::prop_assert_eq!(left, right);
-        proptest::prop_assert_eq!(left.total(), left.input() + left.output());
-    }
-}
-
-#[test]
-fn regional_multiplier_applies_after_input_components_are_summed() {
-    let standard = Rates {
-        cache_read: Rate::Value(0.5),
-        cache_write: Rate::Value(3.0),
-        ..rates(Rate::Value(2.0), Rate::Value(4.0))
-    };
-    let base = request();
-    let regional = Request {
-        region_multiplier: Some(1.1),
-        ..base
-    };
-    let result = calculate(&pricing(standard), &regional).unwrap();
-    assert_eq!(result.input(), (65.0 * 2.0 + 25.0 * 0.5 + 10.0 * 3.0) * 1.1);
-    assert_eq!(result.output(), 20.0 * 4.0 * 1.1);
-    let invalid = Request {
-        region_multiplier: Some(f64::NAN),
-        ..base
-    };
-    assert_eq!(
-        calculate(&pricing(standard), &invalid),
-        Err(Error::InvalidRegionMultiplier)
-    );
-}
-
-#[test]
-fn compilation_sorts_thresholds_and_rejects_duplicate_tiers() {
-    let high = ThresholdRates {
-        above_prompt_tokens: 200,
-        standard: rates(Rate::Value(7.0), Rate::Missing),
-        tiers: &[],
-    };
-    let low = ThresholdRates {
-        above_prompt_tokens: 100,
-        standard: rates(Rate::Value(5.0), Rate::Missing),
-        tiers: &[],
-    };
-    let specification = Pricing {
-        standard: rates(Rate::Value(2.0), Rate::Value(4.0)),
-        tiers: &[],
-        thresholds: &[high, low],
-        off_peak: None,
-    };
-    let base = request();
-    let above_both = Request {
-        usage: Usage {
-            prompt_tokens: 201,
-            cache_read_tokens: 0,
-            cache_write_tokens: 0,
-            ..base.usage
-        },
-        ..base
-    };
-    assert_eq!(
-        compile(&specification)
-            .unwrap()
-            .calculate(&above_both)
-            .unwrap()
-            .rates
-            .input,
-        7.0
-    );
-    let duplicate = TierRates {
-        tier: ServiceTier::Flex,
-        rates: Rates::EMPTY,
-    };
-    let invalid = Pricing {
-        tiers: &[duplicate, duplicate],
-        thresholds: &[],
-        ..specification
-    };
-    assert_eq!(compile(&invalid).err(), Some(Error::DuplicateTier));
-}
diff --git a/litellm-rust/crates/cost/tests/generate_python_reference.py b/litellm-rust/crates/cost/tests/generate_python_reference.py
deleted file mode 100644
index 4a179555650..00000000000
--- a/litellm-rust/crates/cost/tests/generate_python_reference.py
+++ /dev/null
@@ -1,96 +0,0 @@
-import subprocess
-from dataclasses import dataclass
-from pathlib import Path
-
-from litellm.litellm_core_utils.llm_cost_calc.utils import generic_cost_per_token
-from litellm.types.utils import Usage
-
-
-@dataclass(frozen=True, slots=True)
-class Case:
-    name: str
-    prompt: int
-    completion: int
-    cache_read: int
-    cache_write: int
-    input_rate: float
-    output_rate: float
-    cache_read_rate: float | None = None
-    cache_write_rate: float | None = None
-    threshold: int | None = None
-    threshold_input_rate: float | None = None
-    threshold_output_rate: float | None = None
-
-
-CASES = (
-    Case("ordinary", 100, 20, 0, 0, 2.0, 4.0),
-    Case("cache_fallback", 100, 20, 25, 10, 2.0, 4.0),
-    Case("cache_specific", 100, 20, 25, 10, 2.0, 4.0, 0.5, 3.0),
-    Case("free_cache", 100, 20, 25, 10, 2.0, 4.0, 0.0, 0.0),
-    Case("threshold_below", 99, 20, 0, 0, 2.0, 4.0, threshold=100, threshold_input_rate=5.0, threshold_output_rate=8.0),
-    Case("threshold_at", 100, 20, 0, 0, 2.0, 4.0, threshold=100, threshold_input_rate=5.0, threshold_output_rate=8.0),
-    Case(
-        "threshold_above", 101, 20, 0, 0, 2.0, 4.0, threshold=100, threshold_input_rate=5.0, threshold_output_rate=8.0
-    ),
-    Case(
-        "cache_threshold_above",
-        101,
-        20,
-        25,
-        10,
-        2.0,
-        4.0,
-        threshold=100,
-        threshold_input_rate=5.0,
-        threshold_output_rate=8.0,
-    ),
-)
-
-
-def reference(case: Case) -> tuple[float, float]:
-    info = {"input_cost_per_token": case.input_rate, "output_cost_per_token": case.output_rate}
-    if case.cache_read_rate is not None:
-        info["cache_read_input_token_cost"] = case.cache_read_rate
-    if case.cache_write_rate is not None:
-        info["cache_creation_input_token_cost"] = case.cache_write_rate
-    if case.threshold is not None:
-        info[f"input_cost_per_token_above_{case.threshold}_tokens"] = case.threshold_input_rate
-        info[f"output_cost_per_token_above_{case.threshold}_tokens"] = case.threshold_output_rate
-    details = {"cached_tokens": case.cache_read, "cache_write_tokens": case.cache_write}
-    usage = Usage(prompt_tokens=case.prompt, completion_tokens=case.completion, prompt_tokens_details=details)
-    return generic_cost_per_token(
-        model="synthetic",
-        usage=usage,
-        custom_llm_provider="openai",
-        model_info=info,
-    )
-
-
-def main() -> None:
-    revision = subprocess.check_output(("git", "rev-parse", "HEAD"), text=True).strip()
-    rows = ("# Python reference commit: " + revision,) + tuple(
-        "\t".join(
-            str(value) if value is not None else ""
-            for value in (
-                case.name,
-                case.prompt,
-                case.completion,
-                case.cache_read,
-                case.cache_write,
-                case.input_rate,
-                case.output_rate,
-                case.cache_read_rate,
-                case.cache_write_rate,
-                case.threshold,
-                case.threshold_input_rate,
-                case.threshold_output_rate,
-                *reference(case),
-            )
-        )
-        for case in CASES
-    )
-    Path(__file__).with_name("python_reference.tsv").write_text("\n".join(rows) + "\n")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/litellm-rust/crates/cost/tests/python_reference.tsv b/litellm-rust/crates/cost/tests/python_reference.tsv
deleted file mode 100644
index 5abb1329a61..00000000000
--- a/litellm-rust/crates/cost/tests/python_reference.tsv
+++ /dev/null
@@ -1,9 +0,0 @@
-# Python reference commit: dc4be2fd987c993aefcf16444e34f960c12c8627
-ordinary	100	20	0	0	2.0	4.0						200.0	80.0
-cache_fallback	100	20	25	10	2.0	4.0						200.0	80.0
-cache_specific	100	20	25	10	2.0	4.0	0.5	3.0				172.5	80.0
-free_cache	100	20	25	10	2.0	4.0	0.0	0.0				130.0	80.0
-threshold_below	99	20	0	0	2.0	4.0			100	5.0	8.0	198.0	80.0
-threshold_at	100	20	0	0	2.0	4.0			100	5.0	8.0	200.0	80.0
-threshold_above	101	20	0	0	2.0	4.0			100	5.0	8.0	505.0	160.0
-cache_threshold_above	101	20	25	10	2.0	4.0			100	5.0	8.0	505.0	160.0
diff --git a/litellm-rust/crates/gateway/src/lib.rs b/litellm-rust/crates/gateway/src/lib.rs
index b8ff8e46033..12a9bf9110a 100644
--- a/litellm-rust/crates/gateway/src/lib.rs
+++ b/litellm-rust/crates/gateway/src/lib.rs
@@ -37,6 +37,7 @@ pub fn build_inference(config: &Config) -> Result<Arc<Gateway>, Error> {
             .map(|value| value.expose().to_owned())
             .or_else(|| std::env::var(name).ok())
     };
+    let router = ModelRouter::from_config(config, &lookup);
     let settings = &config.litellm_settings;
     let http_settings = HttpSettings::from_layers([
         HttpSettingsLayer::from_environment(&lookup),
@@ -64,12 +65,7 @@ pub fn build_inference(config: &Config) -> Result<Arc<Gateway>, Error> {
         Arc::new(EnvironmentSecrets::python_compatible(client)),
     ));
     let resources = CoreResources::new(pool);
-    Ok(Arc::new(Gateway::new(
-        resources,
-        http,
-        secrets,
-        ModelRouter::from_model_list(&config.model_list),
-    )?))
+    Ok(Arc::new(Gateway::new(resources, http, secrets, router)?))
 }
 
 pub async fn build_redis(config: &Config) -> Result<RedisClients, Error> {
diff --git a/litellm-rust/crates/inference-messages/src/handler.rs b/litellm-rust/crates/inference-messages/src/handler.rs
index fa802d20587..9d0bf09197e 100644
--- a/litellm-rust/crates/inference-messages/src/handler.rs
+++ b/litellm-rust/crates/inference-messages/src/handler.rs
@@ -141,9 +141,13 @@ async fn provider_call(
         &env_lookup,
     )?;
 
-    let body = config.transform_anthropic_messages_request(
-        trimmed,
-        &MessagesTransformContext::new(shaping.capabilities, shaping.settings.drop_params),
+    let body = config.request_body(
+        config.transform_anthropic_messages_request(
+            trimmed,
+            &MessagesTransformContext::new(shaping.capabilities, shaping.settings.drop_params),
+        )?,
+        &validated.headers,
+        shaping.settings.drop_params,
     )?;
     let environment = ValidatedEnvironment {
         headers: config.request_headers(
@@ -514,6 +518,84 @@ mod tests {
         );
     }
 
+    fn vertex_call_requesting(
+        shaping: MessagesShaping,
+        requested: &str,
+        drop_params: bool,
+    ) -> MessagesCall {
+        MessagesCall {
+            body: body(
+                json!({"model": "claude-sonnet-4-5", "messages": [{"role": "user", "content": "hi"}], "max_tokens": 16}),
+            ),
+            api_key: None,
+            api_base: Some("https://vertex.test".into()),
+            custom_llm_provider: Some("vertex_ai".into()),
+            litellm_params: Default::default(),
+            extra_headers: Some(Map::from_iter([
+                ("authorization".to_string(), json!("Bearer vertex-token")),
+                ("anthropic-version".to_string(), json!(requested)),
+            ])),
+            provider_specific_header: None,
+            timeout: None,
+            shaping: MessagesShaping {
+                settings: MessagesSettings {
+                    drop_params,
+                    ..shaping.settings
+                },
+                ..shaping
+            },
+        }
+    }
+
+    fn vertex_project(name: &str) -> Option<String> {
+        (name == "VERTEXAI_PROJECT").then(|| "version-project".to_string())
+    }
+
+    #[rstest]
+    #[case::sdk_2("2026-10-21", false, "2026-10-21")]
+    #[case::sdk_1("2023-06-01", false, "vertex-2023-10-16")]
+    #[case::unknown_under_drop_params("latest", true, "vertex-2023-10-16")]
+    #[tokio::test]
+    async fn vertex_gets_the_requested_version_in_the_body_alone(
+        shaping: MessagesShaping,
+        #[case] requested: &str,
+        #[case] drop_params: bool,
+        #[case] body_version: &str,
+    ) {
+        let call = provider_call_with_secrets(
+            vertex_call_requesting(shaping, requested, drop_params),
+            &vertex_project,
+        )
+        .await
+        .unwrap();
+        let version_headers: Vec<&str> = call
+            .wire
+            .headers
+            .iter()
+            .filter(|(name, _)| name.eq_ignore_ascii_case("anthropic-version"))
+            .map(|(_, value)| value.as_str())
+            .collect();
+        assert_eq!(
+            (version_headers, &call.wire.body["anthropic_version"]),
+            (Vec::<&str>::new(), &json!(body_version))
+        );
+    }
+
+    #[rstest]
+    #[tokio::test]
+    async fn vertex_refuses_an_unsupported_version_without_drop_params(shaping: MessagesShaping) {
+        assert!(matches!(
+            provider_call_with_secrets(
+                vertex_call_requesting(shaping, "latest", false),
+                &vertex_project
+            )
+            .await,
+            Err(Error::Llm(litellm_llms::Error::InvalidRequest(
+                litellm_llms::ErrorDetail::UnsupportedParameter { .. }
+            )))
+        ));
+    }
+
     #[rstest]
     #[tokio::test]
     async fn missing_credentials_are_reported_before_the_request_is_transformed(
diff --git a/litellm-rust/crates/llms/src/base_llm/messages/transformation.rs b/litellm-rust/crates/llms/src/base_llm/messages/transformation.rs
index 8a88af40d6b..744ce89afdb 100644
--- a/litellm-rust/crates/llms/src/base_llm/messages/transformation.rs
+++ b/litellm-rust/crates/llms/src/base_llm/messages/transformation.rs
@@ -77,6 +77,15 @@ pub trait BaseMessagesConfig: Sync {
         headers
     }
 
+    fn request_body(
+        &self,
+        request: MessagesRequest,
+        _headers: &Headers,
+        _drop_params: bool,
+    ) -> Result<MessagesRequest, Error> {
+        Ok(request)
+    }
+
     /// The JSON that goes on the wire, for a host whose body differs from the typed request:
     /// Python's configs `pop("model")` when the model is addressed by the URL.
     fn wire_body(&self, body: Value) -> Value {
diff --git a/litellm-rust/crates/llms/src/vertex_ai/messages/AGENTS.md b/litellm-rust/crates/llms/src/vertex_ai/messages/AGENTS.md
index b5d637d6bc7..d95da65ac9d 100644
--- a/litellm-rust/crates/llms/src/vertex_ai/messages/AGENTS.md
+++ b/litellm-rust/crates/llms/src/vertex_ai/messages/AGENTS.md
@@ -1,6 +1,7 @@
 # rules
 
-- Claude on Vertex AI: reuses `anthropic/messages` shaping, moves the model into the publisher URL, puts the Vertex `anthropic_version` in the body, and authenticates with a Google access token
+- Claude on Vertex AI: reuses `anthropic/messages` shaping, moves the model into the publisher URL, and authenticates with a Google access token
+- Vertex reads the API version only from the body's `anthropic_version` and answers 400 when an `anthropic-version` header names a different one, so the caller's header never reaches Vertex. A version Vertex accepts in the body is carried there, `2023-06-01`, `2023-01-01`, or no header get `vertex-2023-10-16`, and any other version drops under `drop_params` and is refused without it
 - Applies Vertex's beta policy and strips `output_config.effort` for models that do not accept it
 
 # references
diff --git a/litellm-rust/crates/llms/src/vertex_ai/messages/transformation.rs b/litellm-rust/crates/llms/src/vertex_ai/messages/transformation.rs
index 2e77dbc1ca8..46e5a68dcb8 100644
--- a/litellm-rust/crates/llms/src/vertex_ai/messages/transformation.rs
+++ b/litellm-rust/crates/llms/src/vertex_ai/messages/transformation.rs
@@ -3,10 +3,10 @@ use litellm_auth_gcp::{
     VertexConfig, get_vertex_ai_location, get_vertex_ai_project,
     get_vertex_ai_project_from_credentials, secret_names,
 };
-use litellm_http::request::has_header;
+use litellm_http::request::{has_header, header_value, without_headers};
 use litellm_llms_types::{
     formats::messages::{MessagesOptionalParams, MessagesRequest, MessagesTool, OutputConfig},
-    providers::anthropic::{AnthropicBeta, BetaProvider, BetaSet},
+    providers::anthropic::{AnthropicBeta, BetaProvider, BetaSet, VERSION_HEADER},
     recognized::Recognized,
 };
 use litellm_router_types::LitellmParams;
@@ -36,6 +36,8 @@ use litellm_llms_types::providers::vertex_ai::{
 };
 
 const WEB_SEARCH_TOOL_PREFIX: &str = "web_search";
+const VERSIONS_SERVED_AS_VERTEX_DEFAULT: [&str; 3] = ["", "2023-01-01", "2023-06-01"];
+const VERSIONS_VERTEX_ACCEPTS_IN_BODY: [&str; 2] = [ANTHROPIC_VERSION, "2026-10-21"];
 
 /// Claude on Vertex AI, Python's `VertexAIPartnerModelsAnthropicMessagesConfig`: the Anthropic
 /// payload addressed to a project and location, authenticated with a Google access token.
@@ -90,12 +92,6 @@ impl BaseMessagesConfig for VertexAiPartnerModelsAnthropicMessagesConfig {
                     .params
                     .output_config
                     .and_then(|config| sanitize_output_config(config, accepts_effort)),
-                extra: request
-                    .params
-                    .extra
-                    .into_iter()
-                    .chain([("anthropic_version".to_string(), json!(ANTHROPIC_VERSION))])
-                    .collect(),
                 ..request.params
             },
             ..request
@@ -133,7 +129,35 @@ impl BaseMessagesConfig for VertexAiPartnerModelsAnthropicMessagesConfig {
     }
 
     fn request_headers(&self, headers: Headers, request: &MessagesRequest) -> Headers {
-        merge_beta_headers(headers, vertex_feature_betas(request))
+        merge_beta_headers(
+            without_headers(headers, &[VERSION_HEADER]),
+            vertex_feature_betas(request),
+        )
+    }
+
+    fn request_body(
+        &self,
+        request: MessagesRequest,
+        headers: &Headers,
+        drop_params: bool,
+    ) -> Result<MessagesRequest, Error> {
+        let version = vertex_version(
+            &request.model,
+            header_value(headers, VERSION_HEADER),
+            drop_params,
+        )?;
+        Ok(MessagesRequest {
+            params: MessagesOptionalParams {
+                extra: request
+                    .params
+                    .extra
+                    .into_iter()
+                    .chain([("anthropic_version".to_string(), json!(version))])
+                    .collect(),
+                ..request.params
+            },
+            ..request
+        })
     }
 
     /// Vertex addresses the model in the URL and rejects it in the body.
@@ -225,6 +249,26 @@ fn vertex_feature_betas(request: &MessagesRequest) -> BetaSet {
     )
 }
 
+fn vertex_version<'a>(
+    model: &str,
+    requested: Option<&'a str>,
+    drop_params: bool,
+) -> Result<&'a str, Error> {
+    match requested.map(str::trim).unwrap_or_default() {
+        version if VERSIONS_SERVED_AS_VERTEX_DEFAULT.contains(&version) => Ok(ANTHROPIC_VERSION),
+        version if VERSIONS_VERTEX_ACCEPTS_IN_BODY.contains(&version) => Ok(version),
+        _ if drop_params => Ok(ANTHROPIC_VERSION),
+        version => Err(Error::InvalidRequest(
+            crate::ErrorDetail::UnsupportedParameter {
+                model: model.into(),
+                param: VERSION_HEADER.into(),
+                value: version.into(),
+                hint: String::new(),
+            },
+        )),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
@@ -471,6 +515,28 @@ mod tests {
         );
     }
 
+    #[rstest]
+    #[case::sdk_spelling("anthropic-version")]
+    #[case::any_case("Anthropic-Version")]
+    fn a_forwarded_anthropic_version_never_reaches_vertex(#[case] name: &str) {
+        let request: MessagesRequest = serde_json::from_value(json!({
+            "model": "claude-sonnet-4-5",
+            "max_tokens": 16,
+            "messages": [{"role": "user", "content": "hi"}],
+        }))
+        .unwrap();
+        assert_eq!(
+            VERTEX_ANTHROPIC_MESSAGES_CONFIG.request_headers(
+                vec![
+                    (name.to_string(), "2026-10-21".to_string()),
+                    ("x-request-id".to_string(), "req-1".to_string()),
+                ],
+                &request,
+            ),
+            vec![("x-request-id".to_string(), "req-1".to_string())]
+        );
+    }
+
     fn transformed(value: Value, context: &MessagesTransformContext) -> Value {
         let request: MessagesRequest = serde_json::from_value(value).unwrap();
         serde_json::to_value(
@@ -482,16 +548,87 @@ mod tests {
     }
 
     #[rstest]
-    fn the_body_carries_the_vertex_version_and_the_wire_drops_the_model() {
-        let body = transformed(
-            json!({
-                "model": "claude-sonnet-4-5@20250929",
-                "max_tokens": 16,
-                "messages": [{"role": "user", "content": "hi"}]
-            }),
-            &MessagesTransformContext::default(),
+    #[case::sdk_2(&[("anthropic-version", "2026-10-21")], false, "2026-10-21")]
+    #[case::any_case(&[("Anthropic-Version", "2026-10-21")], false, "2026-10-21")]
+    #[case::vertex_name(&[("anthropic-version", "vertex-2023-10-16")], false, "vertex-2023-10-16")]
+    #[case::sdk_1(&[("anthropic-version", "2023-06-01")], false, "vertex-2023-10-16")]
+    #[case::first_version(&[("anthropic-version", "2023-01-01")], false, "vertex-2023-10-16")]
+    #[case::blank(&[("anthropic-version", " ")], false, "vertex-2023-10-16")]
+    #[case::no_header(&[], false, "vertex-2023-10-16")]
+    #[case::unknown_under_drop_params(&[("anthropic-version", "latest")], true, "vertex-2023-10-16")]
+    fn the_requested_version_goes_in_the_body(
+        #[case] forwarded: &[(&str, &str)],
+        #[case] drop_params: bool,
+        #[case] body_version: &str,
+    ) {
+        let request: MessagesRequest = serde_json::from_value(json!({
+            "model": "claude-sonnet-4-5",
+            "max_tokens": 16,
+            "messages": [{"role": "user", "content": "hi"}],
+        }))
+        .unwrap();
+        let headers: Headers = forwarded
+            .iter()
+            .map(|(name, value)| (name.to_string(), value.to_string()))
+            .collect();
+        let body = serde_json::to_value(
+            VERTEX_ANTHROPIC_MESSAGES_CONFIG
+                .request_body(request, &headers, drop_params)
+                .unwrap(),
+        )
+        .unwrap();
+        assert_eq!(body["anthropic_version"], json!(body_version));
+    }
+
+    #[rstest]
+    #[case::unreleased("2025-01-01")]
+    #[case::alias("latest")]
+    fn an_unsupported_version_is_refused_without_drop_params(#[case] requested: &str) {
+        let request: MessagesRequest = serde_json::from_value(json!({
+            "model": "claude-sonnet-4-5",
+            "max_tokens": 16,
+            "messages": [{"role": "user", "content": "hi"}],
+        }))
+        .unwrap();
+        let headers: Headers = vec![("anthropic-version".to_string(), requested.to_string())];
+        let Error::InvalidRequest(detail) = VERTEX_ANTHROPIC_MESSAGES_CONFIG
+            .request_body(request, &headers, false)
+            .unwrap_err()
+        else {
+            panic!("expected an invalid request");
+        };
+        assert_eq!(
+            detail.to_string(),
+            format!(
+                "claude-sonnet-4-5 does not support anthropic-version={requested}. \
+                 To drop unsupported params, set `litellm.drop_params = True`."
+            )
         );
-        assert_eq!(body["anthropic_version"], json!("vertex-2023-10-16"));
+    }
+
+    #[rstest]
+    fn the_body_carries_the_vertex_version_and_the_wire_drops_the_model() {
+        let request: MessagesRequest = serde_json::from_value(json!({
+            "model": "claude-sonnet-4-5@20250929",
+            "max_tokens": 16,
+            "messages": [{"role": "user", "content": "hi"}]
+        }))
+        .unwrap();
+        let body = serde_json::to_value(
+            VERTEX_ANTHROPIC_MESSAGES_CONFIG
+                .request_body(
+                    VERTEX_ANTHROPIC_MESSAGES_CONFIG
+                        .transform_anthropic_messages_request(
+                            request,
+                            &MessagesTransformContext::default(),
+                        )
+                        .unwrap(),
+                    &Vec::new(),
+                    false,
+                )
+                .unwrap(),
+        )
+        .unwrap();
         assert_eq!(body["model"], json!("claude-sonnet-4-5@20250929"));
         let wire = VERTEX_ANTHROPIC_MESSAGES_CONFIG.wire_body(body);
         assert_eq!(wire.get("model"), None);
diff --git a/litellm-rust/crates/model-catalog-refresh/Cargo.toml b/litellm-rust/crates/model-catalog-refresh/Cargo.toml
new file mode 100644
index 00000000000..27219042c6c
--- /dev/null
+++ b/litellm-rust/crates/model-catalog-refresh/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "litellm-model-catalog-refresh"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[dependencies]
+litellm-http.workspace = true
+litellm-model-catalog.workspace = true
+thiserror.workspace = true
+url.workspace = true
+
+[dev-dependencies]
+litellm-error.workspace = true
+litellm-http = { workspace = true, features = ["test-support"] }
+reqwest.workspace = true
+rstest.workspace = true
+tokio.workspace = true
diff --git a/litellm-rust/crates/model-catalog-refresh/src/error.rs b/litellm-rust/crates/model-catalog-refresh/src/error.rs
new file mode 100644
index 00000000000..656f32370cb
--- /dev/null
+++ b/litellm-rust/crates/model-catalog-refresh/src/error.rs
@@ -0,0 +1,105 @@
+use std::io;
+
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+#[error(transparent)]
+pub struct Error(Box<Repr>);
+
+#[derive(Debug, Error)]
+enum Repr {
+    #[error(transparent)]
+    Http(#[from] litellm_http::Error),
+    #[error("could not read the catalog")]
+    Read(#[source] io::Error),
+    #[error("invalid catalog URL")]
+    InvalidUrl(#[source] url::ParseError),
+    #[error("unsupported catalog URL scheme {scheme}")]
+    UnsupportedScheme { scheme: String },
+}
+
+impl Error {
+    pub fn unsupported_scheme(scheme: String) -> Self {
+        Self(Box::new(Repr::UnsupportedScheme { scheme }))
+    }
+}
+
+impl From<litellm_http::Error> for Error {
+    fn from(cause: litellm_http::Error) -> Self {
+        Self(Box::new(Repr::Http(cause)))
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(cause: io::Error) -> Self {
+        Self(Box::new(Repr::Read(cause)))
+    }
+}
+
+impl From<url::ParseError> for Error {
+    fn from(cause: url::ParseError) -> Self {
+        Self(Box::new(Repr::InvalidUrl(cause)))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use litellm_error::{Report, find};
+    use rstest::rstest;
+
+    use super::*;
+    use crate::{DoneReason, Reply, Step};
+
+    #[rstest]
+    fn exhausted_transport_keeps_its_typed_cause() {
+        let reply = Reply::Transport {
+            error: io::Error::from(io::ErrorKind::ConnectionReset).into(),
+        };
+        let Reply::Transport { error } = reply else {
+            panic!("transport failure")
+        };
+        let step = Step::Done {
+            reason: DoneReason::Exhausted(error),
+        };
+        let Step::Done {
+            reason: DoneReason::Exhausted(error),
+        } = step
+        else {
+            panic!("exhausted attempts")
+        };
+        let cause = find::<io::Error>(&error).expect("typed I/O cause");
+        assert_eq!(cause.kind(), io::ErrorKind::ConnectionReset);
+        assert_eq!(
+            Report::new(&error)
+                .to_string()
+                .matches(&cause.to_string())
+                .count(),
+            1
+        );
+        assert!(!error.to_string().contains(&cause.to_string()));
+    }
+
+    #[rstest]
+    fn invalid_source_keeps_its_typed_cause() {
+        let error = Error::from(url::Url::parse("http://[invalid").unwrap_err());
+        assert!(find::<url::ParseError>(&error).is_some());
+    }
+
+    #[rstest]
+    #[tokio::test]
+    async fn http_failures_keep_the_cause_without_the_url() {
+        let cause = litellm_http::Client::for_test()
+            .get("http://localhost:invalid/private?api_key=secret")
+            .send()
+            .await
+            .unwrap_err();
+        let error = Error::from(litellm_http::Error::from(cause));
+        assert!(find::<reqwest::Error>(&error).is_some());
+        let report = Report::new(&error).to_string();
+        assert!(!report.contains("secret"), "{report}");
+        assert!(!report.contains("private"), "{report}");
+        let debug = format!("{error:?}");
+        assert!(!debug.contains("secret"), "{debug}");
+        assert!(!debug.contains("private"), "{debug}");
+    }
+}
diff --git a/litellm-rust/crates/model-catalog-refresh/src/lib.rs b/litellm-rust/crates/model-catalog-refresh/src/lib.rs
new file mode 100644
index 00000000000..006c4887fad
--- /dev/null
+++ b/litellm-rust/crates/model-catalog-refresh/src/lib.rs
@@ -0,0 +1,9 @@
+mod error;
+mod policy;
+mod source;
+mod step;
+
+pub use error::Error;
+pub use policy::*;
+pub use source::*;
+pub use step::*;
diff --git a/litellm-rust/crates/model-catalog-refresh/src/policy.rs b/litellm-rust/crates/model-catalog-refresh/src/policy.rs
new file mode 100644
index 00000000000..bc32e40408e
--- /dev/null
+++ b/litellm-rust/crates/model-catalog-refresh/src/policy.rs
@@ -0,0 +1,20 @@
+use std::time::Duration;
+
+use litellm_model_catalog::IntegrityLimits;
+
+/// Main's defaults, 3 attempts, 30 s max wait, 5 s timeout, backoff base 2.0, jitter 0.0 to 1.0 s
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct RetryPolicy {
+    pub max_attempts: u32,
+    pub max_wait: Duration,
+    pub timeout: Duration,
+    pub backoff_base_seconds: f64,
+    pub jitter_min_seconds: f64,
+    pub jitter_max_seconds: f64,
+    /// Main's 50 model floor and 0.5 shrink ratio
+    pub limits: IntegrityLimits,
+}
+
+/// Main's default `LITELLM_MODEL_COST_MAP_URL`
+pub const DEFAULT_REGISTRY_URL: &str =
+    "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
diff --git a/litellm-rust/crates/model-catalog-refresh/src/source.rs b/litellm-rust/crates/model-catalog-refresh/src/source.rs
new file mode 100644
index 00000000000..713e0386941
--- /dev/null
+++ b/litellm-rust/crates/model-catalog-refresh/src/source.rs
@@ -0,0 +1,17 @@
+use std::path::PathBuf;
+
+use url::Url;
+
+/// Where a fetched catalog comes from
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Source {
+    Http(Url),
+    File(PathBuf),
+    S3(S3Object),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct S3Object {
+    pub bucket: String,
+    pub key: String,
+}
diff --git a/litellm-rust/crates/model-catalog-refresh/src/step.rs b/litellm-rust/crates/model-catalog-refresh/src/step.rs
new file mode 100644
index 00000000000..822d1807916
--- /dev/null
+++ b/litellm-rust/crates/model-catalog-refresh/src/step.rs
@@ -0,0 +1,66 @@
+use std::time::Duration;
+
+use litellm_model_catalog::Catalog;
+
+use crate::Error;
+use crate::source::Source;
+
+/// One attempt. Where to fetch from is the `Source`, so the request carries no URL
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct FetchRequest {
+    pub if_none_match: Option<String>,
+    pub timeout: Duration,
+}
+
+#[derive(Debug)]
+pub enum Reply {
+    /// An HTTP, S3 or file answer. The body is read only on 200
+    Response {
+        status: u16,
+        etag: Option<String>,
+        retry_after: Option<Duration>,
+        body: Option<Vec<u8>>,
+    },
+    /// No answer reached us
+    Transport { error: Error },
+}
+
+/// What the fetch state machine asks its driver to do next
+#[derive(Debug)]
+pub enum Step {
+    Fetch(FetchRequest),
+    Sleep(Duration),
+    /// A parsed document to install, with its rejected row errors
+    Adopt {
+        catalog: Box<Catalog>,
+        installed: Installed,
+        errors: Vec<litellm_model_catalog::Error>,
+    },
+    /// 304, a final status, or retries exhausted
+    Done {
+        reason: DoneReason,
+    },
+}
+
+#[derive(Debug)]
+pub enum DoneReason {
+    NotModified,
+    Status(u16),
+    Exhausted(Error),
+}
+
+/// What is installed now, the input to the next revalidation
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Installed {
+    pub origin: Origin,
+    pub etag: Option<String>,
+    /// `git_blob_id` of the installed bytes
+    pub revision: String,
+    pub model_count: usize,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Origin {
+    Bundled,
+    Remote { source: Source },
+}
diff --git a/litellm-rust/crates/model-catalog/AGENTS.md b/litellm-rust/crates/model-catalog/AGENTS.md
index 0a380788c19..fc4b28d4ef0 100644
--- a/litellm-rust/crates/model-catalog/AGENTS.md
+++ b/litellm-rust/crates/model-catalog/AGENTS.md
@@ -1,5 +1,27 @@
-## Validation
+## Layout
 
-For `model_prices_and_context_window.json` validation, we should eventually:
+`wire/` reads one entry as written. `EntryWire::read` makes one pass over the entry's keys and puts every non-null key in exactly one place, which is an attribute, a flat price parsed by `FlatKey::parse`, a price block, a `supports_*` capability or `unknown`. A known key with a bad value becomes an `Error` that names the key, and the rest of the entry is still read
 
-- Stop skipping this crate's tests
+`lower.rs` is the only code that knows both the wire types and `litellm-cost`. It lowers an `EntryWire` into `Prices`, `Adjustments` and `Model` and checks the rules that span keys, such as one price per meter and condition, contiguous tiers, no suffix inside a block, and off-peak needing hours and prices. Lowering only goes one way. Nothing turns `Prices` back into JSON, since the raw fields are kept
+
+`catalog.rs` reads the document, indexes aliases and runs the checks across entries. A bad entry keeps its raw fields and its errors are listed in `Loaded.errors`. Deciding what to do with them is the caller's job. `Catalog::written` gives back every top-level key and value as the document wrote them, in document order. `Catalog::served` gives back every model and alias as Python serves it, without `sample_spec` and `fallback_generalizations`
+
+`Billing` on `Prices` holds the row attributes pricing reads (text unit, band edge, cache-read fallback, wall clock, web search unit, tier scope). `lower.rs` derives it from the row and its `litellm_provider`, so `litellm-cost` holds no provider list
+
+`store/` is the catalog's in-memory store and the only place that indexes model names. Its rules are in [src/store/AGENTS.md](src/store/AGENTS.md)
+
+`layers.rs`, `resolve/`, `model_info.rs` and `register.rs` hold types only. The functions over them land with their first caller
+
+Catalog errors use one opaque `Error` with typed causes and JSON Pointer accessors (`path`, `key`, `field`). `Error::rejects` alone decides whether an error fails the document, rejects its row or neither, and `ErrorKind` is the stable name hosts report it by
+
+## Prices
+
+The price vocabulary lives in `litellm-cost`, and only this crate knows JSON key names. Every price is keyed by `Meter`, `Channel` and `When`. A variation only one meter has stays in the meter (cache TTL, image size, resolution, `_above_Ns_interval`, `max_results_range`). Service tier and prompt band make up `When`. Batch and decisions are a `Channel` because Python bills them with their own rules. Off-peak is an overlay on `Prices`, and regional uplifts are `Adjustments`, never prices
+
+A new `N`, image size or resolution in an existing key shape parses with no Rust change. A new unit, token kind, feature or tier needs a variant in `litellm-cost` plus its spelling in `wire/flat_key.rs` and `FLAT_KEY_PATTERN` in `schema.rs`
+
+`Prices::band` and `Prices::rate` are pinned to Python's `_get_token_base_cost` by `tests/price_lookup_reference.json`. After a billing change in Python, regenerate it from the repo root with `PYTHONPATH=. python litellm-rust/crates/model-catalog/tests/generate_price_lookup_reference.py`
+
+## Tests
+
+`BUNDLED_REGISTRY` embeds the root `model_prices_and_context_window.json`, so the tests over it fail a JSON change with a bad value or a key no type reads
diff --git a/litellm-rust/crates/model-catalog/Cargo.toml b/litellm-rust/crates/model-catalog/Cargo.toml
index 2c2866d7090..45d16515dcd 100644
--- a/litellm-rust/crates/model-catalog/Cargo.toml
+++ b/litellm-rust/crates/model-catalog/Cargo.toml
@@ -6,15 +6,19 @@ license.workspace = true
 repository.workspace = true
 
 [features]
-schema = ["dep:schemars", "litellm-llms-types/schema"]
+schema = ["dep:schemars", "litellm-cost/schema"]
 
 [dependencies]
-litellm-llms-types.workspace = true
+litellm-cost = { workspace = true, features = ["serde"] }
 
 indexmap = { version = "2.14.0", features = ["serde"] }
+jiff = { version = "0.2.37", default-features = false, features = ["std", "tzdb-bundle-always"] }
+macro_rules_attribute.workspace = true
 schemars = { workspace = true, optional = true }
 serde.workspace = true
-serde_json.workspace = true
+serde_json = { workspace = true, features = ["preserve_order"] }
+serde_with.workspace = true
+strum.workspace = true
 thiserror.workspace = true
 time.workspace = true
 
diff --git a/litellm-rust/crates/model-catalog/src/bundled.rs b/litellm-rust/crates/model-catalog/src/bundled.rs
new file mode 100644
index 00000000000..d71a2d57ebb
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/bundled.rs
@@ -0,0 +1,3 @@
+/// The registry document this build serves when no other one is loaded.
+pub const BUNDLED_REGISTRY: &[u8] =
+    include_bytes!("../../../../model_prices_and_context_window.json");
diff --git a/litellm-rust/crates/model-catalog/src/capabilities.rs b/litellm-rust/crates/model-catalog/src/capabilities.rs
deleted file mode 100644
index 30724766aeb..00000000000
--- a/litellm-rust/crates/model-catalog/src/capabilities.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-/// Primary API surface / task type of the model.
-#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[serde(rename_all = "snake_case")]
-pub enum Mode {
-    AudioSpeech,
-    AudioTranscription,
-    Chat,
-    Completion,
-    Decisions,
-    Embedding,
-    Evaluation,
-    Guardrail,
-    ImageEdit,
-    ImageGeneration,
-    Moderation,
-    Ocr,
-    Realtime,
-    Rerank,
-    Responses,
-    Search,
-    VectorStore,
-    VideoGeneration,
-}
-
-/// Gemini audio generation API the model is served through.
-#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[serde(rename_all = "snake_case")]
-pub enum VertexAiAudioApi {
-    LyriaPredict,
-    LyriaInteractions,
-}
-
-/// Audio container format the model can return.
-#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[serde(rename_all = "snake_case")]
-pub enum AudioFormat {
-    Mp3,
-    Wav,
-}
-
-/// Input modality the model accepts.
-#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[serde(rename_all = "snake_case")]
-pub enum InputModality {
-    Text,
-    Image,
-    Audio,
-    Video,
-}
-
-/// Output modality the model can produce.
-#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[serde(rename_all = "snake_case")]
-pub enum OutputModality {
-    Text,
-    Image,
-    Audio,
-    Video,
-    Code,
-}
diff --git a/litellm-rust/crates/model-catalog/src/catalog.rs b/litellm-rust/crates/model-catalog/src/catalog.rs
index 37412ef1e14..ac5f4ffcf25 100644
--- a/litellm-rust/crates/model-catalog/src/catalog.rs
+++ b/litellm-rust/crates/model-catalog/src/catalog.rs
@@ -1,54 +1,29 @@
-use crate::error::Error;
-use crate::fallback::{FallbackGeneralizations, FallbackRule};
-use crate::model_info::ModelInfo;
+use std::borrow::Cow;
+use std::collections::HashSet;
+
 use indexmap::IndexMap;
 use serde::Deserialize;
-use serde_json::{Map, Value};
-use std::collections::HashMap;
+use serde_json::Value;
 
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct Provenance {
-    pub source: Option<String>,
-    pub revision: Option<String>,
-    pub etag: Option<String>,
-}
+use crate::error::{Error, Loaded, Rejects, Repr};
+use crate::fallback::{FallbackGeneralizations, FallbackRule};
+use crate::model::Model;
+use crate::store::{Rows, Store};
+use crate::wire::{EntryWire, Fields};
+
+const SAMPLE_SPEC: &str = "sample_spec";
+const FALLBACK_GENERALIZATIONS: &str = "fallback_generalizations";
 
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct IntegrityLimits {
-    pub reference_model_count: usize,
-    pub min_model_count: usize,
-    pub min_reference_ratio: f64,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
-pub enum AliasIssue {
-    #[error("model {model:?} has aliases that are not an array")]
-    InvalidList { model: String },
-    #[error("model {model:?} has an alias that is not a string")]
-    InvalidName { model: String },
-    #[error("alias {alias:?} of model {model:?} is already a model name")]
-    CanonicalCollision { model: String, alias: String },
-    #[error("alias {alias:?} of model {model:?} is already an alias of another model")]
-    AliasCollision { model: String, alias: String },
+    min_model_count: usize,
+    min_reference_ratio: f64,
 }
 
 #[derive(Clone, Debug)]
 pub struct ModelEntry {
-    fields: Map<String, Value>,
-    info: ModelInfo,
-}
-
-impl ModelEntry {
-    pub fn field(&self, name: &str) -> Option<&Value> {
-        self.fields.get(name)
-    }
-    pub fn fields(&self) -> &Map<String, Value> {
-        &self.fields
-    }
-    /// The entry deserialized into the typed mirror of the catalog schema.
-    pub fn info(&self) -> &ModelInfo {
-        &self.info
-    }
+    fields: Fields,
+    model: Option<Model>,
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -58,142 +33,312 @@ pub struct ModelMatch<'a> {
     pub entry: &'a ModelEntry,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
+struct Section {
+    index: usize,
+    key: String,
+    value: Value,
+}
+
+/// One fetched key kept off the served map because its row failed validation
+#[derive(Clone, Debug)]
+pub struct Rejection<'a> {
+    pub key: String,
+    pub errors: Vec<&'a Error>,
+    /// The bundled row for the key is served instead. `false` means the key is left out
+    pub replaced_by_bundled: bool,
+}
+
+#[derive(Clone, Copy, Debug, serde::Serialize)]
+#[serde(untagged)]
+pub enum Written<'a> {
+    Entry(&'a Fields),
+    Section(&'a Value),
+}
+
+#[derive(Clone, Debug)]
 pub struct Catalog {
+    store: Store<CatalogRows>,
+    sections: Vec<Section>,
+    fallback_generalizations: Option<FallbackGeneralizations>,
+}
+
+/// Models and aliases, an alias served as its owner's row
+#[derive(Clone, Debug)]
+struct CatalogRows {
     entries: IndexMap<String, ModelEntry>,
     aliases: IndexMap<String, String>,
-    lowercase_keys: HashMap<String, String>,
-    sample_spec: Option<Value>,
-    fallback_generalizations: Option<FallbackGeneralizations>,
-    provenance: Provenance,
-    alias_issues: Vec<AliasIssue>,
+}
+
+impl CatalogRows {
+    fn owner<'a>(&'a self, key: &'a str) -> &'a str {
+        self.aliases.get(key).map_or(key, String::as_str)
+    }
+
+    fn fields(&self, key: &str) -> Option<&Fields> {
+        Some(self.entries.get(self.owner(key))?.fields())
+    }
+}
+
+/// Model names match ignoring case, and keys are grouped by their raw `litellm_provider`
+impl Rows for CatalogRows {
+    type Row = Fields;
+    type Stamp = ();
+
+    fn fold(name: &str) -> String {
+        name.to_lowercase()
+    }
+
+    fn stamp(&self) -> Self::Stamp {}
+
+    fn contains(&self, key: &str) -> bool {
+        self.entries.contains_key(key) || self.aliases.contains_key(key)
+    }
+
+    fn row(&self, key: &str) -> Option<Cow<'_, Fields>> {
+        self.fields(key).map(Cow::Borrowed)
+    }
+
+    fn scan(&self, visit: &mut dyn FnMut(&str, Option<&str>)) {
+        let keys = self.entries.keys().chain(self.aliases.keys());
+        for key in keys {
+            let provider = self
+                .fields(key)
+                .and_then(|fields| fields.get("litellm_provider")?.as_str());
+            visit(key, provider);
+        }
+    }
+}
+
+impl IntegrityLimits {
+    pub fn new(min_model_count: usize, min_reference_ratio: f64) -> Option<Self> {
+        (0.0..=1.0).contains(&min_reference_ratio).then_some(Self {
+            min_model_count,
+            min_reference_ratio,
+        })
+    }
+}
+
+impl ModelEntry {
+    pub fn field(&self, name: &str) -> Option<&Value> {
+        self.fields.get(name)
+    }
+
+    pub fn fields(&self) -> &Fields {
+        &self.fields
+    }
+
+    pub fn model(&self) -> Option<&Model> {
+        self.model.as_ref()
+    }
 }
 
 impl Catalog {
-    pub fn parse(body: &[u8], provenance: Provenance) -> Result<Self, Error> {
-        let root: IndexMap<String, Value> = serde_json::from_slice(body)?;
-        if root.is_empty() {
-            return Err(Error::Empty);
-        }
+    pub fn parse(body: &[u8]) -> Result<Loaded<Self>, Error> {
+        let document = serde_json::from_slice::<Fields>(body)
+            .map_err(|error| Error::new("", Repr::Json(error)))?;
 
-        let mut entries = IndexMap::with_capacity(root.len());
+        let mut problems = Vec::new();
+        let mut sections = Vec::new();
+        let mut entries = IndexMap::with_capacity(document.len());
         let mut alias_lists = Vec::new();
-        let mut alias_issues = Vec::new();
-        let mut sample_spec = None;
-        let mut fallback_generalizations = None;
-        for (name, value) in root {
-            match name.as_str() {
-                "sample_spec" => {
-                    sample_spec = Some(value);
+        for (index, (name, value)) in document.into_iter().enumerate() {
+            let fields = match value {
+                Value::Object(fields) if !is_section(&name) => fields,
+                value => {
+                    if !is_section(&name) {
+                        problems.push(Error::from_key(&name, Repr::NotAnObject));
+                    }
+                    sections.push(Section {
+                        index,
+                        key: name,
+                        value,
+                    });
                     continue;
                 }
-                "fallback_generalizations" => {
-                    fallback_generalizations =
-                        Some(serde_json::from_value::<FallbackGeneralizations>(value)?);
-                    continue;
-                }
-                _ => {}
-            }
-            let Value::Object(mut fields) = value else {
-                return Err(Error::EntryNotObject { model: name });
             };
-            let info = ModelInfo::deserialize(&fields)?;
-            if let Some(aliases) = fields.remove("aliases") {
-                match aliases {
-                    Value::Array(names) => alias_lists.push((name.clone(), names)),
-                    _ => alias_issues.push(AliasIssue::InvalidList {
-                        model: name.clone(),
-                    }),
-                }
+            let (model, aliases, row_problems) = read_row(&fields);
+            problems.extend(
+                row_problems
+                    .into_iter()
+                    .map(|problem| problem.prepend(&name)),
+            );
+            if let Some(aliases) = aliases {
+                alias_lists.push((name.clone(), aliases));
             }
-            entries.insert(name, ModelEntry { fields, info });
+            entries.insert(name, ModelEntry { fields, model });
+        }
+        if entries.is_empty() {
+            return Err(Error::new("", Repr::Empty));
         }
 
-        let mut aliases = IndexMap::new();
+        let mut aliases: IndexMap<String, String> = IndexMap::new();
         for (model, names) in alias_lists {
-            for name in names {
-                let Value::String(alias) = name else {
-                    alias_issues.push(AliasIssue::InvalidName {
-                        model: model.clone(),
-                    });
-                    continue;
-                };
+            for alias in names {
                 if entries.contains_key(&alias) {
-                    alias_issues.push(AliasIssue::CanonicalCollision {
-                        model: model.clone(),
-                        alias,
-                    });
-                } else if aliases.contains_key(&alias) {
-                    alias_issues.push(AliasIssue::AliasCollision {
-                        model: model.clone(),
-                        alias,
-                    });
+                    problems.push(Error::from_key(&model, Repr::AliasShadowsModel { alias }));
+                } else if let Some(taken_by) = aliases.get(&alias) {
+                    problems.push(Error::from_key(
+                        &model,
+                        Repr::AliasTaken {
+                            alias,
+                            taken_by: taken_by.clone(),
+                        },
+                    ));
                 } else {
                     aliases.insert(alias, model.clone());
                 }
             }
         }
 
-        let lowercase_keys = entries
-            .keys()
-            .chain(aliases.keys())
-            .map(|key| (key.to_lowercase(), key.clone()))
-            .collect();
-        Ok(Self {
-            entries,
-            aliases,
-            lowercase_keys,
-            sample_spec,
-            fallback_generalizations,
-            provenance,
-            alias_issues,
+        let fallback_generalizations = sections
+            .iter()
+            .find(|section| section.key == FALLBACK_GENERALIZATIONS)
+            .and_then(|section| {
+                FallbackGeneralizations::deserialize(&section.value)
+                    .map_err(|error| {
+                        problems.push(Error::from_key(&section.key, Repr::Invalid(error)))
+                    })
+                    .ok()
+            });
+        Ok(Loaded {
+            value: Self {
+                store: Store::new(CatalogRows { entries, aliases }),
+                sections,
+                fallback_generalizations,
+            },
+            errors: problems,
         })
     }
 
-    pub fn validate(&self, limits: IntegrityLimits) -> Result<(), Error> {
-        if !limits.min_reference_ratio.is_finite()
-            || !(0.0..=1.0).contains(&limits.min_reference_ratio)
+    pub fn row_errors(model: &str, fields: &Fields) -> Vec<Error> {
+        let (_, _, errors) = read_row(fields);
+        errors
+            .into_iter()
+            .map(|error| error.prepend(model))
+            .collect()
+    }
+
+    pub fn written(&self) -> impl Iterator<Item = (&str, Written<'_>)> {
+        let mut sections = self.sections.iter().peekable();
+        let mut entries = self.rows().entries.iter();
+        (0..self.rows().entries.len() + self.sections.len()).map_while(move |index| match sections
+            .next_if(|section| section.index == index)
         {
-            return Err(Error::InvalidRatio);
-        }
-        let actual = self.entries.len();
+            Some(section) => Some((section.key.as_str(), Written::Section(&section.value))),
+            None => entries
+                .next()
+                .map(|(name, entry)| (name.as_str(), Written::Entry(&entry.fields))),
+        })
+    }
+
+    pub fn served(&self) -> impl Iterator<Item = (&str, &Fields)> {
+        let rows = self.rows();
+        rows.entries
+            .iter()
+            .map(|(name, entry)| (name.as_str(), entry.fields()))
+            .chain(
+                rows.aliases
+                    .iter()
+                    .map(|(alias, owner)| (alias.as_str(), rows.entries[owner].fields())),
+            )
+    }
+
+    pub fn check_size(&self, reference: usize, limits: IntegrityLimits) -> Result<(), Error> {
+        let actual = self.model_count();
         if actual < limits.min_model_count {
-            return Err(Error::BelowMinimum {
-                actual,
-                minimum: limits.min_model_count,
-            });
+            return Err(Error::new(
+                "",
+                Repr::BelowMinimum {
+                    actual,
+                    minimum: limits.min_model_count,
+                },
+            ));
         }
-        if limits.reference_model_count > 0
-            && (actual as f64) < (limits.reference_model_count as f64) * limits.min_reference_ratio
-        {
-            return Err(Error::Shrunk {
-                actual,
-                reference: limits.reference_model_count,
-                ratio: limits.min_reference_ratio,
-            });
+        if (actual as f64) < (reference as f64) * limits.min_reference_ratio {
+            return Err(Error::new(
+                "",
+                Repr::Shrunk {
+                    actual,
+                    reference,
+                    ratio: limits.min_reference_ratio,
+                },
+            ));
         }
         Ok(())
     }
 
-    pub fn lookup(&self, key: &str) -> Option<ModelMatch<'_>> {
-        let matched_key = if self.entries.contains_key(key) || self.aliases.contains_key(key) {
-            key
-        } else {
-            self.lowercase_keys.get(&key.to_lowercase())?.as_str()
-        };
-        let canonical_key = self
-            .aliases
-            .get(matched_key)
-            .map(String::as_str)
-            .unwrap_or(matched_key);
-        let (canonical_key, entry) = self.entries.get_key_value(canonical_key)?;
-        let matched_key = self
+    pub fn without_rejected(self, errors: &[Error]) -> (Self, Vec<&Error>) {
+        let row_names: HashSet<String> = self
+            .rows()
             .entries
-            .get_key_value(matched_key)
+            .keys()
+            .cloned()
+            .chain(
+                self.sections
+                    .iter()
+                    .filter(|section| !is_section(&section.key))
+                    .map(|section| section.key.clone()),
+            )
+            .collect();
+        let rejected: HashSet<String> = errors
+            .iter()
+            .filter(|error| error.rejects() == Rejects::Row)
+            .filter_map(|error| crate::error::pointer_root(error.path()))
+            .filter(|root| row_names.contains(root))
+            .collect();
+        let removed_errors = errors
+            .iter()
+            .filter(|error| {
+                crate::error::pointer_root(error.path())
+                    .is_some_and(|root| rejected.contains(&root))
+            })
+            .collect();
+        let removed_positions: HashSet<usize> = self
+            .written()
+            .enumerate()
+            .filter(|(_, (key, _))| rejected.contains(*key))
+            .map(|(index, _)| index)
+            .collect();
+        let mut catalog = self;
+        catalog.store.edit(|rows| {
+            rows.entries.retain(|name, _| !rejected.contains(name));
+            rows.aliases.retain(|_, owner| !rejected.contains(owner));
+        });
+        catalog
+            .sections
+            .retain(|section| is_section(&section.key) || !rejected.contains(&section.key));
+        for section in &mut catalog.sections {
+            let removed_before = removed_positions
+                .iter()
+                .filter(|index| **index < section.index)
+                .count();
+            section.index -= removed_before;
+        }
+        (catalog, removed_errors)
+    }
+
+    pub fn unrecognized(&self) -> impl Iterator<Item = (&str, &str)> {
+        self.rows().entries.iter().flat_map(|(name, entry)| {
+            entry
+                .model
+                .iter()
+                .flat_map(|model| &model.unrecognized)
+                .map(move |key| (name.as_str(), key.as_str()))
+        })
+    }
+
+    pub fn lookup(&self, key: &str) -> Option<ModelMatch<'_>> {
+        let rows = self.rows();
+        let found = self.store.find_key(key)?;
+        let (canonical_key, entry) = rows.entries.get_key_value(rows.owner(&found))?;
+        let matched_key = rows
+            .entries
+            .get_key_value(found.as_str())
             .map(|(key, _)| key.as_str())
             .or_else(|| {
-                self.aliases
-                    .get_key_value(matched_key)
+                rows.aliases
+                    .get_key_value(found.as_str())
                     .map(|(key, _)| key.as_str())
             })?;
         Some(ModelMatch {
@@ -204,30 +349,58 @@ impl Catalog {
     }
 
     pub fn model_count(&self) -> usize {
-        self.entries.len()
+        self.rows().entries.len()
     }
+
     pub fn model_names(&self) -> impl Iterator<Item = &str> {
-        self.entries.keys().map(String::as_str)
-    }
-    pub fn alias_count(&self) -> usize {
-        self.aliases.len()
+        self.rows().entries.keys().map(String::as_str)
     }
+
     pub fn aliases(&self) -> &IndexMap<String, String> {
-        &self.aliases
+        &self.rows().aliases
     }
-    pub fn alias_issues(&self) -> &[AliasIssue] {
-        &self.alias_issues
+
+    fn rows(&self) -> &CatalogRows {
+        self.store.rows()
     }
+
     pub fn sample_spec(&self) -> Option<&Value> {
-        self.sample_spec.as_ref()
-    }
-    pub fn fallback_generalizations(&self) -> Option<&FallbackGeneralizations> {
-        self.fallback_generalizations.as_ref()
+        self.sections
+            .iter()
+            .find(|section| section.key == SAMPLE_SPEC)
+            .map(|section| &section.value)
     }
+
     pub fn fallback_rules(&self) -> Option<&[FallbackRule]> {
         Some(self.fallback_generalizations.as_ref()?.rules.as_slice())
     }
-    pub fn provenance(&self) -> &Provenance {
-        &self.provenance
+}
+
+fn read_row(fields: &Fields) -> (Option<Model>, Option<Vec<String>>, Vec<Error>) {
+    let wire = EntryWire::read(fields);
+    let aliases = wire.attributes.aliases.clone();
+    let timezone_error = unknown_timezone(&wire);
+    match Model::try_from(wire) {
+        Ok(model) => (Some(model), aliases, timezone_error.into_iter().collect()),
+        Err(mut errors) => {
+            errors.extend(timezone_error);
+            (None, aliases, errors)
+        }
     }
 }
+
+fn is_section(key: &str) -> bool {
+    key == SAMPLE_SPEC || key == FALLBACK_GENERALIZATIONS
+}
+
+fn unknown_timezone(wire: &EntryWire) -> Option<Error> {
+    let zone = wire.off_peak.as_ref()?.weekday_timezone.as_deref()?.trim();
+    (!zone.is_empty() && jiff::tz::TimeZone::get(zone).is_err()).then(|| {
+        Error::from_path(
+            "off_peak_pricing.weekday_timezone",
+            Repr::UnknownTimezone {
+                zone: zone.to_owned(),
+            },
+        )
+    })
+}
diff --git a/litellm-rust/crates/model-catalog/src/error.rs b/litellm-rust/crates/model-catalog/src/error.rs
index 00902858be4..425ae47687f 100644
--- a/litellm-rust/crates/model-catalog/src/error.rs
+++ b/litellm-rust/crates/model-catalog/src/error.rs
@@ -1,21 +1,392 @@
+use std::num::ParseIntError;
+
+use strum::{EnumDiscriminants, IntoStaticStr, VariantArray};
 use thiserror::Error;
 
 #[derive(Debug, Error)]
-pub enum Error {
-    #[error("invalid catalog JSON")]
-    Json(#[from] serde_json::Error),
-    #[error("catalog is empty")]
+#[error(transparent)]
+pub struct Error(Box<Context>);
+
+#[derive(Debug, Error)]
+enum Context {
+    #[error(transparent)]
+    Bare(Repr),
+    #[error("{}", display_path(path))]
+    At {
+        path: String,
+        #[source]
+        cause: Repr,
+    },
+}
+
+#[derive(Debug, Error)]
+pub(crate) enum DateCause {
+    #[error("invalid date component")]
+    Number(#[from] ParseIntError),
+    #[error("calendar component out of range")]
+    Range(#[from] time::error::ComponentRange),
+}
+
+#[derive(Debug, Error, EnumDiscriminants)]
+#[strum_discriminants(name(ErrorKind), derive(IntoStaticStr, VariantArray), vis(pub))]
+pub(crate) enum Repr {
+    #[error("invalid JSON")]
+    #[strum_discriminants(strum(serialize = "json"))]
+    Json(#[source] serde_json::Error),
+    #[error("has no models")]
+    #[strum_discriminants(strum(serialize = "empty"))]
     Empty,
-    #[error("model {model:?} must be an object")]
-    EntryNotObject { model: String },
-    #[error("catalog has {actual} models, below minimum {minimum}")]
+    #[error("has {actual} models, below minimum {minimum}")]
+    #[strum_discriminants(strum(serialize = "below_minimum"))]
     BelowMinimum { actual: usize, minimum: usize },
-    #[error("catalog has {actual} models, below {ratio} of reference count {reference}")]
+    #[error("has {actual} models, below {ratio} of reference count {reference}")]
+    #[strum_discriminants(strum(serialize = "shrunk"))]
     Shrunk {
         actual: usize,
         reference: usize,
         ratio: f64,
     },
-    #[error("minimum reference ratio must be finite and between zero and one")]
-    InvalidRatio,
+    #[error("must be a JSON object")]
+    #[strum_discriminants(strum(serialize = "not_an_object"))]
+    NotAnObject,
+    #[error("invalid value")]
+    #[strum_discriminants(strum(serialize = "invalid"))]
+    Invalid(#[source] serde_json::Error),
+    #[error("not a field this block reads")]
+    #[strum_discriminants(strum(serialize = "unknown_block_key"))]
+    UnknownBlockKey,
+    #[error("required")]
+    #[strum_discriminants(strum(serialize = "missing_provider"))]
+    MissingProvider,
+    #[error("{zone:?} is not an IANA time zone")]
+    #[strum_discriminants(strum(serialize = "unknown_timezone"))]
+    UnknownTimezone { zone: String },
+    #[error("alias {alias:?} is already a model name")]
+    #[strum_discriminants(strum(serialize = "alias_shadows_model"))]
+    AliasShadowsModel { alias: String },
+    #[error("alias {alias:?} already belongs to {taken_by}")]
+    #[strum_discriminants(strum(serialize = "alias_taken"))]
+    AliasTaken { alias: String, taken_by: String },
+    #[error("{first} and {second} price the same meter under the same conditions")]
+    #[strum_discriminants(strum(serialize = "duplicate_price"))]
+    DuplicatePrice { first: String, second: String },
+    #[error("a price inside {block} takes no band or tier suffix")]
+    #[strum_discriminants(strum(serialize = "suffix_inside_block"))]
+    SuffixInsideBlock { block: &'static str },
+    #[error("a tier needs exactly one of range and max_results_range")]
+    #[strum_discriminants(strum(serialize = "tier_range"))]
+    TierRange,
+    #[error("the range ends below its start")]
+    #[strum_discriminants(strum(serialize = "tier_reversed"))]
+    TierReversed,
+    #[error("starts at {start}, but the tiers before it end at {expected}")]
+    #[strum_discriminants(strum(serialize = "tier_gap"))]
+    TierGap { start: u64, expected: u64 },
+    #[error("tiered_pricing mixes token ranges and result ranges")]
+    #[strum_discriminants(strum(serialize = "mixed_tier_basis"))]
+    MixedTierBasis,
+    #[error("a tier by result count only prices input_cost_per_query")]
+    #[strum_discriminants(strum(serialize = "not_priced_by_results"))]
+    NotPricedByResults,
+    #[error("tiered_pricing and prompt token bands are set in two places")]
+    #[strum_discriminants(strum(serialize = "bands_from_two_sources"))]
+    BandsFromTwoSources,
+    #[error("has no off-peak rate")]
+    #[strum_discriminants(strum(serialize = "not_an_off_peak_rate"))]
+    NotAnOffPeakRate,
+    #[error("off_peak_pricing has no prices")]
+    #[strum_discriminants(strum(serialize = "no_off_peak_prices"))]
+    NoOffPeakPrices,
+    #[error("off_peak_pricing needs hours_utc or windows")]
+    #[strum_discriminants(strum(serialize = "no_off_peak_hours"))]
+    NoOffPeakHours,
+    #[error("must list at least one entry")]
+    #[strum_discriminants(strum(serialize = "empty_list"))]
+    EmptyList,
+    #[error("expected a calendar date YYYY-MM-DD")]
+    #[strum_discriminants(strum(serialize = "invalid_date"))]
+    InvalidDate {
+        #[source]
+        cause: Option<DateCause>,
+    },
+}
+
+/// What a problem takes out of the served map
+#[derive(Clone, Copy, Debug, PartialEq, Eq, VariantArray)]
+pub enum Rejects {
+    Document,
+    Row,
+    Nothing,
+}
+
+impl Error {
+    pub fn kind(&self) -> ErrorKind {
+        ErrorKind::from(self.repr())
+    }
+
+    pub fn rejects(&self) -> Rejects {
+        match self.repr() {
+            Repr::Json(_) | Repr::Empty | Repr::BelowMinimum { .. } | Repr::Shrunk { .. } => {
+                Rejects::Document
+            }
+            Repr::NotAnObject
+            | Repr::Invalid(_)
+            | Repr::UnknownBlockKey
+            | Repr::UnknownTimezone { .. }
+            | Repr::AliasShadowsModel { .. }
+            | Repr::AliasTaken { .. }
+            | Repr::DuplicatePrice { .. }
+            | Repr::SuffixInsideBlock { .. }
+            | Repr::TierRange
+            | Repr::TierReversed
+            | Repr::TierGap { .. }
+            | Repr::MixedTierBasis
+            | Repr::NotPricedByResults
+            | Repr::BandsFromTwoSources
+            | Repr::NotAnOffPeakRate
+            | Repr::NoOffPeakPrices
+            | Repr::NoOffPeakHours
+            | Repr::EmptyList
+            | Repr::InvalidDate { .. } => Rejects::Row,
+            Repr::MissingProvider => Rejects::Nothing,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Loaded<T> {
+    pub value: T,
+    pub errors: Vec<Error>,
+}
+
+impl From<Repr> for Error {
+    fn from(cause: Repr) -> Self {
+        Self(Box::new(Context::Bare(cause)))
+    }
+}
+
+impl From<DateCause> for Error {
+    fn from(cause: DateCause) -> Self {
+        Repr::InvalidDate { cause: Some(cause) }.into()
+    }
+}
+
+impl Error {
+    fn repr(&self) -> &Repr {
+        match &*self.0 {
+            Context::Bare(cause) | Context::At { cause, .. } => cause,
+        }
+    }
+
+    pub(crate) fn new(path: impl Into<String>, cause: Repr) -> Self {
+        Self(Box::new(Context::At {
+            path: path.into(),
+            cause,
+        }))
+    }
+
+    pub(crate) fn from_key(key: &str, cause: Repr) -> Self {
+        Self::new(pointer_for_key(key), cause)
+    }
+
+    pub(crate) fn from_path(path: &str, cause: Repr) -> Self {
+        Self::new(path_to_pointer(path), cause)
+    }
+
+    pub fn path(&self) -> &str {
+        match &*self.0 {
+            Context::Bare(_) => "",
+            Context::At { path, .. } => path,
+        }
+    }
+
+    pub fn key(&self) -> Option<String> {
+        pointer_root(self.path())
+    }
+
+    pub fn field(&self) -> Option<String> {
+        let segments: Vec<_> = self
+            .path()
+            .split('/')
+            .skip(2)
+            .map(unescape_pointer_segment)
+            .collect();
+        (!segments.is_empty()).then(|| segments.join("/"))
+    }
+
+    pub(crate) fn prepend(self, key: &str) -> Self {
+        let (path, cause) = match *self.0 {
+            Context::Bare(cause) => (String::new(), cause),
+            Context::At { path, cause } => (path, cause),
+        };
+        Self::new(format!("/{}{path}", escape_pointer_segment(key)), cause)
+    }
+}
+
+pub(crate) fn pointer_root(path: &str) -> Option<String> {
+    path.strip_prefix('/')
+        .and_then(|path| path.split('/').next())
+        .map(unescape_pointer_segment)
+}
+
+fn escape_pointer_segment(segment: &str) -> String {
+    segment.replace('~', "~0").replace('/', "~1")
+}
+
+pub(crate) fn pointer_for_key(key: &str) -> String {
+    format!("/{}", escape_pointer_segment(key))
+}
+
+pub(crate) fn pointer_child(parent: &str, key: &str) -> String {
+    format!("{parent}/{}", escape_pointer_segment(key))
+}
+
+fn unescape_pointer_segment(segment: &str) -> String {
+    segment.replace("~1", "/").replace("~0", "~")
+}
+
+fn path_to_pointer(key: &str) -> String {
+    let mut pointer = String::new();
+    let mut segment = String::new();
+    let mut chars = key.chars();
+    let mut push_segment = |segment: &mut String| {
+        if !segment.is_empty() {
+            pointer.push('/');
+            pointer.push_str(&escape_pointer_segment(segment));
+            segment.clear();
+        }
+    };
+    while let Some(character) = chars.next() {
+        match character {
+            '.' => push_segment(&mut segment),
+            '[' => {
+                push_segment(&mut segment);
+                let mut index = String::new();
+                for character in chars.by_ref() {
+                    if character == ']' {
+                        break;
+                    }
+                    index.push(character);
+                }
+                push_segment(&mut index);
+            }
+            character => segment.push(character),
+        }
+    }
+    push_segment(&mut segment);
+    pointer
+}
+
+fn display_path(path: &str) -> String {
+    if path.is_empty() {
+        return "catalog".to_owned();
+    }
+    path.split('/')
+        .skip(1)
+        .map(unescape_pointer_segment)
+        .enumerate()
+        .fold(String::new(), |mut display, (index, segment)| {
+            if index == 0 {
+                display.push_str(&segment);
+            } else if segment.bytes().all(|byte| byte.is_ascii_digit()) {
+                display.push('[');
+                display.push_str(&segment);
+                display.push(']');
+            } else {
+                display.push('.');
+                display.push_str(&segment);
+            }
+            display
+        })
+}
+
+#[cfg(test)]
+mod tests {
+    use litellm_error::{Report, find};
+    use rstest::rstest;
+    use serde_json::Value;
+
+    use super::*;
+    use crate::{Catalog, wire::IsoDate};
+
+    #[rstest]
+    #[case::json(Repr::Json(serde_json::from_str::<Value>("{").unwrap_err()), Rejects::Document)]
+    #[case::empty(Repr::Empty, Rejects::Document)]
+    #[case::below_minimum(Repr::BelowMinimum { actual: 1, minimum: 2 }, Rejects::Document)]
+    #[case::shrunk(Repr::Shrunk { actual: 1, reference: 3, ratio: 0.5 }, Rejects::Document)]
+    #[case::not_an_object(Repr::NotAnObject, Rejects::Row)]
+    #[case::invalid(Repr::Invalid(serde_json::from_str::<Value>("x").unwrap_err()), Rejects::Row)]
+    #[case::unknown_block_key(Repr::UnknownBlockKey, Rejects::Row)]
+    #[case::missing_provider(Repr::MissingProvider, Rejects::Nothing)]
+    #[case::unknown_timezone(Repr::UnknownTimezone { zone: "invalid".into() }, Rejects::Row)]
+    #[case::alias_shadows_model(Repr::AliasShadowsModel { alias: "model".into() }, Rejects::Row)]
+    #[case::alias_taken(Repr::AliasTaken { alias: "alias".into(), taken_by: "owner".into() }, Rejects::Row)]
+    #[case::duplicate_price(Repr::DuplicatePrice { first: "a".into(), second: "b".into() }, Rejects::Row)]
+    #[case::suffix_inside_block(Repr::SuffixInsideBlock { block: "tiered_pricing" }, Rejects::Row)]
+    #[case::tier_range(Repr::TierRange, Rejects::Row)]
+    #[case::tier_reversed(Repr::TierReversed, Rejects::Row)]
+    #[case::tier_gap(Repr::TierGap { start: 1, expected: 0 }, Rejects::Row)]
+    #[case::mixed_tier_basis(Repr::MixedTierBasis, Rejects::Row)]
+    #[case::not_priced_by_results(Repr::NotPricedByResults, Rejects::Row)]
+    #[case::bands_from_two_sources(Repr::BandsFromTwoSources, Rejects::Row)]
+    #[case::not_an_off_peak_rate(Repr::NotAnOffPeakRate, Rejects::Row)]
+    #[case::no_off_peak_prices(Repr::NoOffPeakPrices, Rejects::Row)]
+    #[case::no_off_peak_hours(Repr::NoOffPeakHours, Rejects::Row)]
+    #[case::empty_list(Repr::EmptyList, Rejects::Row)]
+    #[case::invalid_date(Repr::InvalidDate { cause: None }, Rejects::Row)]
+    fn policy_classifies_each_error(#[case] error: Repr, #[case] expected: Rejects) {
+        assert_eq!(Error::from(error).rejects(), expected);
+    }
+
+    #[rstest]
+    #[case::root("", "x", "/x")]
+    #[case::empty_model("/", "x", "//x")]
+    #[case::empty_parent_segment("/m/", "x", "/m//x")]
+    #[case::escaped("/m~1n", "a~/b", "/m~1n/a~0~1b")]
+    fn pointers_preserve_segments(#[case] parent: &str, #[case] key: &str, #[case] expected: &str) {
+        assert_eq!(pointer_child(parent, key), expected);
+    }
+
+    #[rstest]
+    #[case::malformed(br#"{"#)]
+    #[case::bad_price(br#"{"m":{"litellm_provider":"test","input_cost_per_token":"free"}}"#)]
+    fn json_causes_are_typed_and_rendered_once(#[case] body: &[u8]) {
+        let error = match Catalog::parse(body) {
+            Ok(loaded) => loaded.errors.into_iter().next().expect("invalid price"),
+            Err(error) => error,
+        };
+        let cause = find::<serde_json::Error>(&error)
+            .expect("typed JSON cause")
+            .to_string();
+        let report = Report::new(&error).to_string();
+        assert_eq!(report.matches(&cause).count(), 1, "{report}");
+        assert!(!error.to_string().contains(&cause));
+    }
+
+    #[rstest]
+    #[case::year("xxxx-01-01")]
+    #[case::month("2026-xx-01")]
+    #[case::day("2026-01-xx")]
+    fn date_number_errors_keep_the_cause(#[case] value: &str) {
+        let error = value.parse::<IsoDate>().unwrap_err();
+        let cause = find::<ParseIntError>(&error)
+            .expect("typed integer cause")
+            .to_string();
+        assert_eq!(error.rejects(), Rejects::Row);
+        assert_eq!(Report::new(&error).to_string().matches(&cause).count(), 1);
+        assert!(!error.to_string().contains(&cause));
+    }
+
+    #[rstest]
+    #[case::month("2026-13-01")]
+    #[case::day("2026-02-30")]
+    fn date_range_errors_keep_the_cause(#[case] value: &str) {
+        let error = value.parse::<IsoDate>().unwrap_err();
+        let cause = find::<time::error::ComponentRange>(&error)
+            .expect("typed calendar cause")
+            .to_string();
+        assert_eq!(error.rejects(), Rejects::Row);
+        assert_eq!(Report::new(&error).to_string().matches(&cause).count(), 1);
+        assert!(!error.to_string().contains(&cause));
+    }
 }
diff --git a/litellm-rust/crates/model-catalog/src/fallback.rs b/litellm-rust/crates/model-catalog/src/fallback.rs
index 62291a84929..f5a0cadb6b9 100644
--- a/litellm-rust/crates/model-catalog/src/fallback.rs
+++ b/litellm-rust/crates/model-catalog/src/fallback.rs
@@ -1,10 +1,9 @@
-use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::collections::BTreeMap;
 
 /// One regex rule generalizing unknown model ids to known families.
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[macro_rules_attribute::apply(crate::wire_type)]
+#[derive(Eq, Hash)]
 pub struct FallbackRule {
     pub name: String,
     pub pattern: String,
@@ -15,8 +14,8 @@ pub struct FallbackRule {
 }
 
 /// Regex rules that generalize unknown model ids to known families; not a model entry.
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[macro_rules_attribute::apply(crate::wire_type)]
+#[derive(Eq, Hash)]
 #[serde(deny_unknown_fields)]
 pub struct FallbackGeneralizations {
     pub rules: Vec<FallbackRule>,
diff --git a/litellm-rust/crates/model-catalog/src/layers.rs b/litellm-rust/crates/model-catalog/src/layers.rs
new file mode 100644
index 00000000000..881f0f6af9b
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/layers.rs
@@ -0,0 +1,32 @@
+use std::sync::Arc;
+
+use indexmap::IndexMap;
+use serde_json::Value;
+
+use crate::catalog::Catalog;
+use crate::register::Registrations;
+use crate::wire::Fields;
+
+/// One field of a fetched row over the layer below, RFC 7386. An absent field inherits, JSON `null` is `Remove`
+#[derive(Clone, Debug, PartialEq)]
+pub enum Patch {
+    Set(Value),
+    Remove,
+}
+
+/// The four layers served rows are composed from, lowest first
+#[derive(Clone, Debug)]
+#[expect(
+    dead_code,
+    reason = "02 and 07 add the functions that read these layers"
+)]
+pub struct Layers {
+    /// 0, the wheel's embedded map
+    bundled: Arc<Catalog>,
+    /// 1, the last installed fetch, rejected rows left out
+    fetched: Option<Arc<Catalog>>,
+    /// 2, `register(persist=False)`, cleared by every install and refilled by the router replay
+    transient: IndexMap<String, Fields>,
+    /// 3, `register(persist=True)`, applied over every install
+    persisted: Registrations,
+}
diff --git a/litellm-rust/crates/model-catalog/src/lib.rs b/litellm-rust/crates/model-catalog/src/lib.rs
index 066c2c83c6b..fe419dde054 100644
--- a/litellm-rust/crates/model-catalog/src/lib.rs
+++ b/litellm-rust/crates/model-catalog/src/lib.rs
@@ -1,18 +1,65 @@
-mod capabilities;
+//! The model catalog: per-model pricing, context limits and capabilities.
+//!
+//! This is the Rust form of `model_prices_and_context_window.json`, the map Python reads as
+//! `litellm.model_cost` and through `litellm.get_model_info`. It answers "what does this model
+//! cost and what can it do"; it knows nothing about configured deployments. The router's view of
+//! deployments (groups, aliases, wildcard patterns, team mappings) is the router registry, defined
+//! in `litellm-router-core`, which reads this catalog through its dynamic config.
+//!
+//! # Structure
+//! - `Catalog`: the parsed map. `Catalog::parse` takes the JSON body and returns `Loaded<Catalog>`,
+//!   keeping every entry in file order with its raw fields and collecting row and alias errors.
+//! - `ModelEntry`: one model. `ModelEntry::fields` is the raw JSON object, so unknown fields are
+//!   never lost; `ModelEntry::model` is the optional typed `Model` with attributes, prices,
+//!   adjustments and capabilities. Invalid rows retain their raw fields without a typed model.
+//! - Aliases: an entry may list `aliases`; each alias resolves to its canonical key. Problems
+//!   found while indexing them (bad lists, collisions) are kept in `Loaded::errors` instead of
+//!   failing the document.
+//! - `FallbackGeneralizations` / `FallbackRule`: regex rules that map unknown model ids onto known
+//!   families. They are data in the file, not entries.
+//! - Validation: `Catalog::check_size` checks a catalog against `IntegrityLimits` (a remote copy
+//!   that lost most of its models is refused), and `Catalog::row_errors` validates one row.
+//!
+//! # Lookups
+//! `Catalog::lookup` resolves a key exactly first (entry or alias), then case-insensitively, and
+//! returns a `ModelMatch` with both the key that matched and the canonical key of the entry. Provider
+//! prefixes are not stripped here; callers decide which keys to try.
+//!
+//! # Readers
+//! Cost tracking, the router (through `RouterDynamicConfig`) and the gateway. Nothing in this crate
+//! performs I/O; loading and refreshing the file is the caller's job.
+
+macro_rules_attribute::attribute_alias! {
+    #[apply(wire_type)] =
+        #[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+        #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))];
+}
+
+mod bundled;
 mod catalog;
 mod error;
 mod fallback;
+mod layers;
+mod lower;
+mod model;
 mod model_info;
-mod pricing;
-mod validation;
+mod register;
+mod resolve;
+mod store;
+mod vocabulary;
+pub mod wire;
 
-pub use capabilities::*;
+pub use bundled::*;
 pub use catalog::*;
 pub use error::*;
 pub use fallback::*;
+pub use layers::*;
+pub use model::*;
 pub use model_info::*;
-pub use pricing::*;
-pub use validation::*;
+pub use register::*;
+pub use resolve::*;
+pub use store::*;
+pub use vocabulary::*;
 
 #[cfg(feature = "schema")]
 mod schema;
diff --git a/litellm-rust/crates/model-catalog/src/lower.rs b/litellm-rust/crates/model-catalog/src/lower.rs
new file mode 100644
index 00000000000..4c3fc38a01a
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/lower.rs
@@ -0,0 +1,855 @@
+use std::collections::BTreeMap;
+use std::collections::btree_map::Entry;
+use std::num::NonZeroU64;
+
+use litellm_cost::money::UnitPrice;
+use litellm_cost::price::{
+    Adjustments, Band, BandEdge, Billing, CacheReadFallback, CacheReadMode, CacheTtl,
+    GuardrailUnit, InputUnit, Meter, OffPeak, OffPeakRates, OutputUnit, Price, Prices, Residency,
+    SearchContextSize, TextUnit, TierScope, TokenKind, Uplift, WallClock, WebSearchUnit, When,
+};
+use litellm_cost::schedule::{Schedule, Window};
+
+use crate::error::{Error, Repr, pointer_child, pointer_for_key};
+use crate::model::Model;
+use crate::vocabulary::Mode;
+use crate::wire::{EntryWire, FlatPrice, OffPeakBlock, TierRow, WebSearchBillingUnit};
+
+impl TryFrom<&EntryWire> for Prices {
+    type Error = Vec<Error>;
+
+    fn try_from(wire: &EntryWire) -> Result<Self, Self::Error> {
+        let mut problems = Vec::new();
+        let sourced = flat_prices(&wire.prices)
+            .chain(tier_prices(wire, &mut problems))
+            .chain(search_context_prices(wire))
+            .chain(guardrail_prices(wire));
+        let rates = dedupe(sourced, &mut problems);
+        let off_peak = wire
+            .off_peak
+            .as_ref()
+            .and_then(|block| off_peak(block, &mut problems));
+        if problems.is_empty() {
+            let billing = billing(wire, &rates);
+            Ok(Prices::new(rates, off_peak, billing))
+        } else {
+            Err(problems)
+        }
+    }
+}
+
+fn billing(wire: &EntryWire, rates: &BTreeMap<Price, UnitPrice>) -> Billing {
+    let provider = wire.attributes.litellm_provider.as_deref();
+    let prices_meter = |priced: fn(&Meter) -> bool| rates.keys().any(|price| priced(&price.meter));
+    let prices_tokens = prices_meter(|meter| {
+        matches!(
+            meter,
+            Meter::Input(InputUnit::Token(_)) | Meter::Output(OutputUnit::Token(_))
+        )
+    });
+    let prices_characters = prices_meter(|meter| {
+        matches!(
+            meter,
+            Meter::Input(InputUnit::Character) | Meter::Output(OutputUnit::Character)
+        )
+    });
+    let prices_cache_read = prices_meter(|meter| {
+        matches!(
+            meter,
+            Meter::CacheRead {
+                kind: TokenKind::Text,
+                ..
+            }
+        )
+    });
+    Billing {
+        text_unit: if prices_characters && !prices_tokens {
+            TextUnit::Character
+        } else {
+            TextUnit::Token
+        },
+        band_edge: if provider == Some("xai") {
+            BandEdge::Inclusive
+        } else {
+            BandEdge::Exclusive
+        },
+        cache_read_fallback: if provider == Some("fireworks_ai") && !prices_cache_read {
+            CacheReadFallback::HalfInputRate
+        } else {
+            CacheReadFallback::InputRate
+        },
+        wall_clock: match wire.attributes.mode {
+            None | Some(Mode::Chat | Mode::Completion | Mode::Embedding | Mode::Responses) => {
+                WallClock::ResponseTime
+            }
+            Some(Mode::AudioTranscription) => WallClock::AudioFile,
+            Some(_) => WallClock::Never,
+        },
+        web_search: match wire.attributes.web_search_billing_unit {
+            Some(WebSearchBillingUnit::PerQuery) => WebSearchUnit::PerQuery,
+            Some(WebSearchBillingUnit::PerPrompt) | None => WebSearchUnit::PerPrompt,
+        },
+        tier_scope: if provider == Some("dashscope") && wire.tier_rows.is_some() {
+            TierScope::WholeCall
+        } else {
+            TierScope::PerMeter
+        },
+    }
+}
+
+impl From<&EntryWire> for Adjustments {
+    fn from(wire: &EntryWire) -> Self {
+        Adjustments::new(
+            [
+                (Uplift::NonGlobalEndpoint, wire.regional_endpoint_uplift),
+                (Uplift::Residency(Residency::Eu), wire.residency_uplift_eu),
+                (Uplift::Residency(Residency::Us), wire.residency_uplift_us),
+            ]
+            .into_iter()
+            .filter_map(|(uplift, factor)| Some((uplift, factor?))),
+        )
+    }
+}
+
+impl TryFrom<EntryWire> for Model {
+    type Error = Vec<Error>;
+
+    fn try_from(wire: EntryWire) -> Result<Self, Self::Error> {
+        let prices = Prices::try_from(&wire);
+        let adjustments = Adjustments::from(&wire);
+        let EntryWire {
+            attributes,
+            capabilities,
+            unknown,
+            problems,
+            ..
+        } = wire;
+        let missing_provider = attributes.litellm_provider.is_none().then_some(Error::new(
+            pointer_for_key("litellm_provider"),
+            Repr::MissingProvider,
+        ));
+        match prices {
+            Ok(prices) if problems.is_empty() && missing_provider.is_none() => Ok(Model {
+                attributes,
+                prices,
+                adjustments,
+                capabilities,
+                unrecognized: unknown.into_iter().map(|(key, _)| key).collect(),
+            }),
+            prices => Err(problems
+                .into_iter()
+                .chain(missing_provider)
+                .chain(prices.err().into_iter().flatten())
+                .collect()),
+        }
+    }
+}
+
+struct Sourced {
+    price: Price,
+    rate: UnitPrice,
+    source: String,
+    path: String,
+}
+
+fn flat_prices(prices: &[FlatPrice]) -> impl Iterator<Item = Sourced> + '_ {
+    prices.iter().map(|flat| {
+        let (channel, when) = flat.flat.channel_and_when();
+        Sourced {
+            price: Price {
+                meter: flat.flat.meter.clone(),
+                channel,
+                when,
+            },
+            rate: flat.price,
+            source: flat.key.clone(),
+            path: flat.path.clone(),
+        }
+    })
+}
+
+fn dedupe(
+    sourced: impl Iterator<Item = Sourced>,
+    problems: &mut Vec<Error>,
+) -> BTreeMap<Price, UnitPrice> {
+    let mut seen: BTreeMap<Price, (UnitPrice, String, String)> = BTreeMap::new();
+    for Sourced {
+        price,
+        rate,
+        source,
+        path,
+    } in sourced
+    {
+        match seen.entry(price) {
+            Entry::Occupied(first) if first.get().0 == rate => {}
+            Entry::Occupied(first) => problems.push(Error::new(
+                path,
+                Repr::DuplicatePrice {
+                    first: first.get().1.clone(),
+                    second: source.clone(),
+                },
+            )),
+            Entry::Vacant(slot) => {
+                slot.insert((rate, source, path));
+            }
+        }
+    }
+    seen.into_iter()
+        .map(|(price, (rate, _, _))| (price, rate))
+        .collect()
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum TierBasis {
+    PromptTokens,
+    Results,
+}
+
+fn tier_basis(row: &TierRow) -> Result<(TierBasis, [u64; 2]), Error> {
+    match (row.range, row.max_results_range) {
+        (Some(range), None) => Ok((TierBasis::PromptTokens, range)),
+        (None, Some(range)) => Ok((TierBasis::Results, range)),
+        _ => Err(Error::new(row.path.clone(), Repr::TierRange)),
+    }
+}
+
+fn tier_prices(wire: &EntryWire, problems: &mut Vec<Error>) -> Vec<Sourced> {
+    let Some(rows) = wire.tier_rows.as_deref().filter(|rows| !rows.is_empty()) else {
+        return Vec::new();
+    };
+    let based: Vec<_> = rows
+        .iter()
+        .filter_map(|row| match tier_basis(row) {
+            Ok((basis, range)) => Some((basis, range, row)),
+            Err(problem) => {
+                problems.push(problem);
+                None
+            }
+        })
+        .collect();
+    let Some(&(basis, ..)) = based.first() else {
+        return Vec::new();
+    };
+    if based.iter().any(|(other, ..)| *other != basis) {
+        problems.push(Error::from_key("tiered_pricing", Repr::MixedTierBasis));
+        return Vec::new();
+    }
+    if basis == TierBasis::PromptTokens {
+        problems.extend(
+            wire.prices
+                .iter()
+                .filter(|flat| flat.flat.band != Band::Base)
+                .map(|flat| Error::new(flat.path.clone(), Repr::BandsFromTwoSources)),
+        );
+    }
+    let mut ordered = based;
+    ordered.sort_by_key(|(_, [start, _], _)| *start);
+    problems.extend(ladder_problems(basis, &ordered));
+    ordered
+        .iter()
+        .flat_map(|(basis, [start, _], row)| {
+            row.prices.iter().map(move |flat| (*basis, *start, flat))
+        })
+        .filter_map(
+            |(basis, start, flat)| match tier_price(basis, start, flat) {
+                Ok(sourced) => Some(sourced),
+                Err(problem) => {
+                    problems.push(problem);
+                    None
+                }
+            },
+        )
+        .collect()
+}
+
+fn ladder_problems(basis: TierBasis, ordered: &[(TierBasis, [u64; 2], &TierRow)]) -> Vec<Error> {
+    let step = match basis {
+        TierBasis::PromptTokens => 0,
+        TierBasis::Results => 1,
+    };
+    let reversed = ordered
+        .iter()
+        .filter(|(_, [start, end], _)| end < start)
+        .map(|(.., row)| Error::new(row.path.clone(), Repr::TierReversed));
+    let first = ordered
+        .first()
+        .filter(|(_, [start, _], _)| *start > step)
+        .map(|(_, [start, _], row)| {
+            Error::new(
+                row.path.clone(),
+                Repr::TierGap {
+                    start: *start,
+                    expected: 0,
+                },
+            )
+        });
+    let gaps = ordered.windows(2).filter_map(|pair| {
+        let (_, [_, end], _) = pair[0];
+        let (_, [start, _], row) = pair[1];
+        (end.checked_add(step) != Some(start)).then(|| {
+            Error::new(
+                row.path.clone(),
+                Repr::TierGap {
+                    start,
+                    expected: end,
+                },
+            )
+        })
+    });
+    reversed.chain(first).chain(gaps).collect()
+}
+
+fn tier_price(basis: TierBasis, start: u64, flat: &FlatPrice) -> Result<Sourced, Error> {
+    if flat.flat.has_suffix() {
+        return Err(Error::new(
+            flat.path.clone(),
+            Repr::SuffixInsideBlock {
+                block: "tiered_pricing",
+            },
+        ));
+    }
+    let (meter, band) = match (basis, &flat.flat.meter) {
+        (TierBasis::PromptTokens, meter) => (meter.clone(), Band::over_prompt_tokens(start)),
+        (TierBasis::Results, Meter::Input(InputUnit::Query { over_results: None })) => (
+            Meter::Input(InputUnit::Query {
+                over_results: NonZeroU64::new(start.saturating_sub(1)),
+            }),
+            Band::Base,
+        ),
+        (TierBasis::Results, _) => {
+            return Err(Error::new(flat.path.clone(), Repr::NotPricedByResults));
+        }
+    };
+    Ok(Sourced {
+        price: Price::online(
+            meter,
+            When {
+                band,
+                ..When::default()
+            },
+        ),
+        rate: flat.price,
+        source: flat.key.clone(),
+        path: flat.path.clone(),
+    })
+}
+
+fn search_context_prices(wire: &EntryWire) -> impl Iterator<Item = Sourced> + '_ {
+    wire.search_context.iter().flat_map(|costs| {
+        [
+            (SearchContextSize::Low, "low", costs.search_context_size_low),
+            (
+                SearchContextSize::Medium,
+                "medium",
+                costs.search_context_size_medium,
+            ),
+            (
+                SearchContextSize::High,
+                "high",
+                costs.search_context_size_high,
+            ),
+        ]
+        .into_iter()
+        .filter_map(|(size, name, rate)| {
+            Some(Sourced {
+                price: Price::online(Meter::WebSearch(size), When::default()),
+                rate: rate?,
+                source: format!("search_context_cost_per_query.search_context_size_{name}"),
+                path: pointer_child(
+                    &pointer_for_key("search_context_cost_per_query"),
+                    &format!("search_context_size_{name}"),
+                ),
+            })
+        })
+    })
+}
+
+fn guardrail_prices(wire: &EntryWire) -> impl Iterator<Item = Sourced> + '_ {
+    wire.guardrail.iter().flatten().map(|(unit, rate)| Sourced {
+        price: Price::online(Meter::Guardrail(GuardrailUnit::new(unit)), When::default()),
+        rate: *rate,
+        source: format!("guardrail_cost_per_unit.{unit}"),
+        path: pointer_child(&pointer_for_key("guardrail_cost_per_unit"), unit),
+    })
+}
+
+fn off_peak(block: &OffPeakBlock, problems: &mut Vec<Error>) -> Option<OffPeak> {
+    let rates = off_peak_rates(&block.prices, problems);
+    let schedule = schedule(block, problems)?;
+    let off_peak = OffPeak::new(schedule, rates);
+    if off_peak.is_none() {
+        problems.push(Error::from_key("off_peak_pricing", Repr::NoOffPeakPrices));
+    }
+    off_peak
+}
+
+fn off_peak_rates(prices: &[FlatPrice], problems: &mut Vec<Error>) -> OffPeakRates {
+    let mut rates = OffPeakRates::default();
+    for flat in prices {
+        if flat.flat.has_suffix() {
+            problems.push(Error::new(
+                flat.path.clone(),
+                Repr::SuffixInsideBlock {
+                    block: "off_peak_pricing",
+                },
+            ));
+            continue;
+        }
+        let slot = match flat.flat.meter {
+            Meter::Input(InputUnit::Token(TokenKind::Text)) => &mut rates.input,
+            Meter::Output(OutputUnit::Token(TokenKind::Text)) => &mut rates.output,
+            Meter::Output(OutputUnit::ReasoningToken) => &mut rates.reasoning,
+            Meter::CacheRead {
+                kind: TokenKind::Text,
+                mode: CacheReadMode::Implicit,
+            } => &mut rates.cache_read,
+            Meter::CacheRead {
+                kind: TokenKind::Text,
+                mode: CacheReadMode::Explicit,
+            } => &mut rates.explicit_cache_read,
+            Meter::CacheWrite {
+                kind: TokenKind::Text,
+                ttl: CacheTtl::Default,
+            } => &mut rates.cache_write,
+            _ => {
+                problems.push(Error::new(flat.path.clone(), Repr::NotAnOffPeakRate));
+                continue;
+            }
+        };
+        *slot = Some(flat.price);
+    }
+    rates
+}
+
+fn schedule(block: &OffPeakBlock, problems: &mut Vec<Error>) -> Option<Schedule> {
+    let empty = |key: String| Error::from_path(&key, Repr::EmptyList);
+    let every_day = block
+        .hours_utc
+        .iter()
+        .map(|hours| ("off_peak_pricing.hours_utc".to_owned(), hours, None));
+    let windows = block
+        .windows
+        .iter()
+        .flatten()
+        .enumerate()
+        .map(|(index, window)| {
+            (
+                format!("off_peak_pricing.windows[{index}].hours_utc"),
+                &window.hours_utc,
+                Some((index, window.weekdays.as_ref())),
+            )
+        });
+    let windows: Vec<Window> = every_day
+        .chain(windows)
+        .map(|(key, hours, weekdays)| {
+            if hours.windows().is_empty() {
+                problems.push(empty(key));
+            }
+            if let Some((index, Some(days))) = weekdays
+                && days.is_empty()
+            {
+                problems.push(empty(format!("off_peak_pricing.windows[{index}].weekdays")));
+            }
+            Window {
+                hours: hours.windows().to_vec(),
+                weekdays: weekdays.and_then(|(_, days)| days.cloned()),
+            }
+        })
+        .collect();
+    if block.windows.as_ref().is_some_and(Vec::is_empty) {
+        problems.push(empty("off_peak_pricing.windows".to_owned()));
+    }
+    if block.hours_utc.is_none() && block.windows.is_none() {
+        problems.push(Error::from_key("off_peak_pricing", Repr::NoOffPeakHours));
+        return None;
+    }
+    Some(Schedule {
+        windows,
+        weekday_timezone: block.weekday_timezone.clone(),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use litellm_cost::money::Multiplier;
+    use litellm_cost::price::{Channel, ServiceTier};
+    use litellm_cost::schedule::{UtcWindow, Weekday};
+    use rstest::rstest;
+    use serde_json::{Value, json};
+
+    use super::*;
+
+    const TEXT_INPUT: Meter = Meter::Input(InputUnit::Token(TokenKind::Text));
+
+    fn wire(entry: Value) -> EntryWire {
+        let Value::Object(fields) = entry else {
+            panic!("entry must be an object")
+        };
+        let wire = EntryWire::read(&fields);
+        assert!(wire.problems.is_empty(), "{:?}", wire.problems);
+        wire
+    }
+
+    fn prices(entry: Value) -> Result<Prices, Vec<Error>> {
+        Prices::try_from(&wire(entry))
+    }
+
+    fn online(meter: Meter, tier: ServiceTier, band: Band) -> Price {
+        Price::online(meter, When { tier, band })
+    }
+
+    #[rstest]
+    #[case::flat_key(json!({"input_cost_per_token": 1e-6}), online(TEXT_INPUT, ServiceTier::Standard, Band::Base))]
+    #[case::band_and_tier(
+        json!({"input_cost_per_token_above_272k_tokens_priority": 1e-6}),
+        online(TEXT_INPUT, ServiceTier::Priority, Band::over_prompt_tokens(272_000))
+    )]
+    #[case::batch(
+        json!({"input_cost_per_token_batches": 1e-6}),
+        Price { meter: TEXT_INPUT, channel: Channel::Batch, when: When::default() }
+    )]
+    #[case::first_token_tier_is_the_base_band(
+        json!({"tiered_pricing": [{"range": [0.0, 256000.0], "input_cost_per_token": 1e-6}]}),
+        online(TEXT_INPUT, ServiceTier::Standard, Band::Base)
+    )]
+    #[case::result_tier_stays_in_its_meter(
+        json!({"tiered_pricing": [
+            {"max_results_range": [0, 25], "input_cost_per_query": 2e-6},
+            {"max_results_range": [26, 100], "input_cost_per_query": 1e-6}
+        ]}),
+        online(
+            Meter::Input(InputUnit::Query { over_results: NonZeroU64::new(25) }),
+            ServiceTier::Standard,
+            Band::Base
+        )
+    )]
+    #[case::search_context(
+        json!({"search_context_cost_per_query": {"search_context_size_low": 1e-6}}),
+        online(Meter::WebSearch(SearchContextSize::Low), ServiceTier::Standard, Band::Base)
+    )]
+    #[case::character_band_is_a_prompt_token_band(
+        json!({"input_cost_per_character_above_128k_tokens": 1e-6}),
+        online(Meter::Input(InputUnit::Character), ServiceTier::Standard, Band::over_prompt_tokens(128_000))
+    )]
+    #[case::guardrail(
+        json!({"guardrail_cost_per_unit": {"contentPolicyUnits": 1e-6}}),
+        online(Meter::Guardrail(GuardrailUnit::new("contentPolicyUnits")), ServiceTier::Standard, Band::Base)
+    )]
+    fn every_spelling_lowers_to_one_price(#[case] entry: Value, #[case] expected: Price) {
+        assert_eq!(prices(entry).unwrap().get(&expected), UnitPrice::new(1e-6));
+    }
+
+    #[rstest]
+    fn two_spellings_that_agree_are_one_price() {
+        let prices = prices(json!({
+            "input_cost_per_token": 1e-6,
+            "tiered_pricing": [
+                {"range": [0, 10], "input_cost_per_token": 1e-6},
+                {"range": [10, 20], "input_cost_per_token": 2e-6}
+            ]
+        }))
+        .unwrap();
+        assert_eq!(
+            prices.get(&Price::online(TEXT_INPUT, When::default())),
+            UnitPrice::new(1e-6)
+        );
+    }
+
+    #[rstest]
+    fn token_tiers_lower_to_prompt_bands_at_each_start() {
+        let prices = prices(json!({"tiered_pricing": [
+            {"range": [0, 256000], "input_cost_per_token": 1e-6},
+            {"range": [256000, 1000000], "input_cost_per_token": 2e-6}
+        ]}))
+        .unwrap();
+        assert_eq!(
+            prices.band(ServiceTier::Standard, 256_001),
+            Band::over_prompt_tokens(256_000)
+        );
+        assert_eq!(
+            prices
+                .rate(
+                    &TEXT_INPUT,
+                    ServiceTier::Standard,
+                    Band::over_prompt_tokens(256_000)
+                )
+                .map(UnitPrice::get),
+            Some(2e-6)
+        );
+    }
+
+    #[rstest]
+    #[case::two_spellings_of_one_price(
+        json!({
+            "input_cost_per_token": 1e-6,
+            "tiered_pricing": [{"range": [0, 10], "input_cost_per_token": 2e-6}]
+        }),
+        "/tiered_pricing/0/input_cost_per_token",
+        "duplicate_price"
+    )]
+    #[case::zero_band_is_the_base_price(
+        json!({"input_cost_per_token": 1e-6, "input_cost_per_token_above_0k_tokens": 2e-6}),
+        "/input_cost_per_token_above_0k_tokens",
+        "duplicate_price"
+    )]
+    #[case::tier_without_range(
+        json!({"tiered_pricing": [{"input_cost_per_token": 1e-6}]}),
+        "/tiered_pricing/0",
+        "tier_range"
+    )]
+    #[case::tier_with_suffix(
+        json!({"tiered_pricing": [{"range": [0, 10], "input_cost_per_token_priority": 1e-6}]}),
+        "/tiered_pricing/0/input_cost_per_token_priority",
+        "suffix_inside_block"
+    )]
+    #[case::reversed_range(
+        json!({"tiered_pricing": [{"range": [0, 10], "input_cost_per_token": 1e-6}, {"range": [10, 5], "input_cost_per_token": 1e-6}]}),
+        "/tiered_pricing/1",
+        "tier_reversed"
+    )]
+    #[case::gap_between_tiers(
+        json!({"tiered_pricing": [
+            {"range": [0, 10], "input_cost_per_token": 1e-6},
+            {"range": [20, 30], "input_cost_per_token": 2e-6}
+        ]}),
+        "/tiered_pricing/1",
+        "tier_gap"
+    )]
+    #[case::ladder_not_from_zero(
+        json!({"tiered_pricing": [{"range": [5, 10], "input_cost_per_token": 1e-6}]}),
+        "/tiered_pricing/0",
+        "tier_gap"
+    )]
+    #[case::result_ladder_overlaps(
+        json!({"tiered_pricing": [
+            {"max_results_range": [1, 10], "input_cost_per_query": 1e-6},
+            {"max_results_range": [10, 20], "input_cost_per_query": 2e-6}
+        ]}),
+        "/tiered_pricing/1",
+        "tier_gap"
+    )]
+    #[case::mixed_basis(
+        json!({"tiered_pricing": [
+            {"range": [0, 10], "input_cost_per_token": 1e-6},
+            {"max_results_range": [11, 20], "input_cost_per_query": 2e-6}
+        ]}),
+        "/tiered_pricing",
+        "mixed_tier_basis"
+    )]
+    #[case::result_tier_prices_a_token(
+        json!({"tiered_pricing": [{"max_results_range": [0, 10], "input_cost_per_token": 1e-6}]}),
+        "/tiered_pricing/0/input_cost_per_token",
+        "not_priced_by_results"
+    )]
+    #[case::two_band_sources(
+        json!({
+            "output_cost_per_token_above_200k_tokens": 1e-6,
+            "tiered_pricing": [{"range": [0, 10], "input_cost_per_token": 1e-6}]
+        }),
+        "/output_cost_per_token_above_200k_tokens",
+        "bands_from_two_sources"
+    )]
+    #[case::off_peak_without_hours(
+        json!({"off_peak_pricing": {"input_cost_per_token": 1e-6}}),
+        "/off_peak_pricing",
+        "no_off_peak_hours"
+    )]
+    #[case::off_peak_without_prices(
+        json!({"off_peak_pricing": {"hours_utc": "00:00-01:00"}}),
+        "/off_peak_pricing",
+        "no_off_peak_prices"
+    )]
+    #[case::off_peak_empty_windows(
+        json!({"off_peak_pricing": {"windows": [], "input_cost_per_token": 1e-6}}),
+        "/off_peak_pricing/windows",
+        "empty_list"
+    )]
+    #[case::off_peak_empty_hours(
+        json!({"off_peak_pricing": {"hours_utc": [], "input_cost_per_token": 1e-6}}),
+        "/off_peak_pricing/hours_utc",
+        "empty_list"
+    )]
+    #[case::off_peak_empty_weekdays(
+        json!({"off_peak_pricing": {
+            "windows": [{"hours_utc": "00:00-01:00", "weekdays": []}],
+            "input_cost_per_token": 1e-6
+        }}),
+        "/off_peak_pricing/windows/0/weekdays",
+        "empty_list"
+    )]
+    #[case::off_peak_image_price(
+        json!({"off_peak_pricing": {"hours_utc": "00:00-01:00", "output_cost_per_image": 1}}),
+        "/off_peak_pricing/output_cost_per_image",
+        "not_an_off_peak_rate"
+    )]
+    #[case::off_peak_band(
+        json!({"off_peak_pricing": {"hours_utc": "00:00-01:00", "input_cost_per_token_above_200k_tokens": 1}}),
+        "/off_peak_pricing/input_cost_per_token_above_200k_tokens",
+        "suffix_inside_block"
+    )]
+    fn rules_across_keys_name_where_each_price_came_from(
+        #[case] entry: Value,
+        #[case] expected_path: &str,
+        #[case] expected_variant: &str,
+    ) {
+        let problems = prices(entry).unwrap_err();
+        assert!(
+            problems
+                .iter()
+                .any(|problem| problem.path() == expected_path
+                    && <&str>::from(problem.kind()) == expected_variant),
+            "{problems:?}"
+        );
+    }
+
+    #[rstest]
+    fn off_peak_hours_and_windows_form_one_schedule_with_its_rates() {
+        let prices = prices(json!({"off_peak_pricing": {
+            "hours_utc": ["00:00-01:00"],
+            "windows": [{"hours_utc": "10:00-12:00", "weekdays": [6, " sun "]}],
+            "weekday_timezone": "Asia/Shanghai",
+            "output_cost_per_token": 1e-6,
+            "explicit_cache_read_input_token_cost": 2e-6
+        }}))
+        .unwrap();
+        let off_peak = prices.off_peak().unwrap();
+        let window = |text: &str| text.parse::<UtcWindow>().unwrap();
+
+        assert_eq!(
+            off_peak.schedule(),
+            &Schedule {
+                windows: vec![
+                    Window {
+                        hours: vec![window("00:00-01:00")],
+                        weekdays: None,
+                    },
+                    Window {
+                        hours: vec![window("10:00-12:00")],
+                        weekdays: Some(vec![Weekday::Saturday, Weekday::Sunday]),
+                    },
+                ],
+                weekday_timezone: Some("Asia/Shanghai".into()),
+            }
+        );
+        assert_eq!(
+            off_peak.rates(),
+            &OffPeakRates {
+                output: UnitPrice::new(1e-6),
+                explicit_cache_read: UnitPrice::new(2e-6),
+                ..OffPeakRates::default()
+            }
+        );
+        assert_eq!(prices.iter().count(), 0);
+    }
+
+    #[rstest]
+    fn uplifts_are_adjustments_not_prices() {
+        let wire = wire(json!({
+            "regional_endpoint_uplift_multiplier": 1.1,
+            "regional_processing_uplift_multiplier_eu": "1.2"
+        }));
+        let adjustments = Adjustments::from(&wire);
+
+        assert_eq!(Prices::try_from(&wire).unwrap().iter().count(), 0);
+        assert_eq!(
+            adjustments
+                .get(&Uplift::NonGlobalEndpoint)
+                .map(Multiplier::get),
+            Some(1.1)
+        );
+        assert_eq!(
+            adjustments
+                .get(&Uplift::Residency(Residency::Eu))
+                .map(Multiplier::get),
+            Some(1.2)
+        );
+        assert_eq!(adjustments.get(&Uplift::Residency(Residency::Us)), None);
+    }
+
+    #[rstest]
+    fn a_model_reports_field_provider_and_price_problems_together() {
+        let Value::Object(fields) = json!({
+            "mode": "chatt",
+            "tiered_pricing": [{"input_cost_per_token": 1e-6}]
+        }) else {
+            unreachable!()
+        };
+        let problems: Vec<String> = Model::from_fields(&fields)
+            .unwrap_err()
+            .iter()
+            .map(|problem| litellm_error::Report::new(problem).to_string())
+            .collect();
+
+        assert_eq!(problems.len(), 3, "{problems:?}");
+        assert!(problems[0].starts_with("mode: invalid value: unknown variant `chatt`"));
+        assert_eq!(problems[1], "litellm_provider: required");
+        assert_eq!(
+            problems[2],
+            "tiered_pricing[0]: a tier needs exactly one of range and max_results_range"
+        );
+    }
+
+    #[rstest]
+    fn a_null_value_is_absent() {
+        let Value::Object(fields) = json!({
+            "litellm_provider": "openai",
+            "input_cost_per_token": null,
+            "mode": null
+        }) else {
+            unreachable!()
+        };
+        let model = Model::from_fields(&fields).unwrap();
+
+        assert_eq!(model.prices.iter().count(), 0);
+        assert_eq!(model.attributes.mode, None);
+        assert!(model.unrecognized.is_empty());
+    }
+
+    #[rstest]
+    #[case::tokens_win_over_characters(
+        json!({"litellm_provider": "vertex_ai-language-models", "input_cost_per_character": 1e-6, "input_cost_per_token": 1e-6}),
+        Billing::default()
+    )]
+    #[case::characters_only(
+        json!({"litellm_provider": "vertex_ai-language-models", "input_cost_per_character": 1e-6}),
+        Billing { text_unit: TextUnit::Character, ..Billing::default() }
+    )]
+    #[case::xai_band_is_inclusive(
+        json!({"litellm_provider": "xai", "input_cost_per_token": 1e-6}),
+        Billing { band_edge: BandEdge::Inclusive, ..Billing::default() }
+    )]
+    #[case::fireworks_without_cache_read_borrows_half(
+        json!({"litellm_provider": "fireworks_ai", "input_cost_per_token": 1e-6}),
+        Billing { cache_read_fallback: CacheReadFallback::HalfInputRate, ..Billing::default() }
+    )]
+    #[case::fireworks_with_cache_read_keeps_it(
+        json!({"litellm_provider": "fireworks_ai", "input_cost_per_token": 1e-6, "cache_read_input_token_cost": 1e-7}),
+        Billing::default()
+    )]
+    #[case::transcription_prices_the_audio_file(
+        json!({"litellm_provider": "openai", "mode": "audio_transcription", "input_cost_per_second": 1e-4}),
+        Billing { wall_clock: WallClock::AudioFile, ..Billing::default() }
+    )]
+    #[case::provisioned_chat_prices_response_time(
+        json!({"litellm_provider": "bedrock", "mode": "chat", "cost_per_second": 1e-2}),
+        Billing::default()
+    )]
+    #[case::image_generation_is_never_wall_clock(
+        json!({"litellm_provider": "openai", "mode": "image_generation"}),
+        Billing { wall_clock: WallClock::Never, ..Billing::default() }
+    )]
+    #[case::gemini_per_query_search(
+        json!({"litellm_provider": "gemini", "web_search_billing_unit": "per_query"}),
+        Billing { web_search: WebSearchUnit::PerQuery, ..Billing::default() }
+    )]
+    #[case::dashscope_tiers_bill_the_whole_call(
+        json!({"litellm_provider": "dashscope", "tiered_pricing": [{"range": [0, 32000], "input_cost_per_token": 1e-6}]}),
+        Billing { tier_scope: TierScope::WholeCall, ..Billing::default() }
+    )]
+    fn billing_is_lowered_from_the_row_and_its_provider(
+        #[case] entry: Value,
+        #[case] expected: Billing,
+    ) {
+        assert_eq!(prices(entry).unwrap().billing(), expected);
+    }
+}
diff --git a/litellm-rust/crates/model-catalog/src/model.rs b/litellm-rust/crates/model-catalog/src/model.rs
new file mode 100644
index 00000000000..c1acd1c14cb
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/model.rs
@@ -0,0 +1,22 @@
+use std::collections::BTreeMap;
+
+use litellm_cost::price::{Adjustments, Prices};
+
+use crate::error::Error;
+use crate::wire::{Attributes, EntryWire, Fields};
+
+/// One catalog entry read into types.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Model {
+    pub attributes: Attributes,
+    pub prices: Prices,
+    pub adjustments: Adjustments,
+    pub capabilities: BTreeMap<String, bool>,
+    pub unrecognized: Vec<String>,
+}
+
+impl Model {
+    pub fn from_fields(fields: &Fields) -> Result<Self, Vec<Error>> {
+        Self::try_from(EntryWire::read(fields))
+    }
+}
diff --git a/litellm-rust/crates/model-catalog/src/model_info.rs b/litellm-rust/crates/model-catalog/src/model_info.rs
index ebee2c64140..8f7549c1c6d 100644
--- a/litellm-rust/crates/model-catalog/src/model_info.rs
+++ b/litellm-rust/crates/model-catalog/src/model_info.rs
@@ -1,582 +1,194 @@
-use crate::capabilities::{AudioFormat, InputModality, Mode, OutputModality, VertexAiAudioApi};
-use crate::pricing::{OffPeakPricing, SearchContextCostPerQuery, TieredRate, WebSearchBillingUnit};
-use litellm_llms_types::formats::chat_completions::ReasoningEffort;
-use serde::{Deserialize, Serialize};
+use indexmap::IndexMap;
 use serde_json::Value;
-use std::collections::BTreeMap;
 
-/// Typed mirror of one catalog model entry.
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-pub struct ModelInfo {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub annotation_cost_per_page: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub annotation_cost_per_page_batches: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub audio_transcription_config: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub bedrock_converse_supports_strict_tools: Option<bool>,
-    /// Highest reasoning effort the Bedrock output_config accepts for this model.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub bedrock_output_config_effort_ceiling: Option<ReasoningEffort>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_audio_token_cost: Option<f64>,
-    /// USD per token written to the provider's prompt cache.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_above_32k_tokens: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_above_100k_tokens: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_above_100k_tokens_batches: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_above_128k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_above_1hr: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_above_1hr_above_100k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_above_1hr_above_200k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_above_200k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_above_200k_tokens_batches: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_above_256k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_above_272k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_above_272k_tokens_batches: Option<f64>,
-    /// Flex service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_above_272k_tokens_flex: Option<f64>,
-    /// Priority service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_above_272k_tokens_priority: Option<f64>,
-    /// Ultrafast service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_above_272k_tokens_ultrafast: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_batches: Option<f64>,
-    /// Flex service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_flex: Option<f64>,
-    /// Priority service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_priority: Option<f64>,
-    /// Ultrafast service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost_ultrafast: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_audio_token_cost: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_image_token_cost: Option<f64>,
-    /// USD per prompt token served from the provider's prompt cache.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_above_32k_tokens: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_above_100k_tokens: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_above_100k_tokens_batches: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_above_128k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_above_200k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_above_200k_tokens_batches: Option<f64>,
-    /// Priority service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_above_200k_tokens_priority: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_above_256k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_above_272k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_above_272k_tokens_batches: Option<f64>,
-    /// Flex service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_above_272k_tokens_flex: Option<f64>,
-    /// Priority service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_above_272k_tokens_priority: Option<f64>,
-    /// Ultrafast service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_above_272k_tokens_ultrafast: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_above_512k_tokens: Option<f64>,
-    /// Balanced service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_balanced: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_batches: Option<f64>,
-    /// Flex service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_flex: Option<f64>,
-    /// Priority service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_priority: Option<f64>,
-    /// Ultrafast service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost_ultrafast: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub citation_cost_per_token: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub code_interpreter_cost_per_session: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub comment: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub computer_use_input_cost_per_1k_tokens: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub computer_use_output_cost_per_1k_tokens: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cost_per_second: Option<f64>,
-    /// Reasoning effort the provider applies when the request omits reasoning_effort. Gates whether a non-default temperature or the top_p/logprobs sampling params are accepted, which hold only when the effort resolves to 'none'.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub default_reasoning_effort: Option<ReasoningEffort>,
-    /// Date the provider deprecates the model, YYYY-MM-DD.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub deprecation_date: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub file_search_cost_per_1k_calls: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub file_search_cost_per_gb_per_day: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub gemini_audio_only_live: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub gemini_native_audio: Option<bool>,
-    /// USD per Grounding with Google Maps request; billed per query or per prompt per web_search_billing_unit.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub google_maps_grounding_cost_per_query: Option<f64>,
-    /// USD cost per billable guardrail unit, keyed by the provider's usage counter name (e.g. Bedrock's contentPolicyUnits).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub guardrail_cost_per_unit: Option<BTreeMap<String, f64>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_audio_per_second: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_audio_per_second_above_128k_tokens: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_audio_token: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_audio_token_batches: Option<f64>,
-    /// Priority service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_audio_token_priority: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_character: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_character_above_128k_tokens: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_image: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_image_above_128k_tokens: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_image_token: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_image_token_batches: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_pixel: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_query: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_request: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_second: Option<f64>,
-    /// USD per prompt token.
-    #[serde(skip_serializing_if = "Option::is_none")]
+/// The fields main's `ModelInfoBase(...)` copies (`litellm/utils.py` at c7c895db45), one typed field each,
+/// read from the raw row without lowering it, so building one never fails
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct ModelInfoFields {
+    pub key: String,
+    pub max_tokens: Option<i64>,
+    pub max_input_tokens: Option<i64>,
+    pub max_output_tokens: Option<i64>,
     pub input_cost_per_token: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_above_32k_tokens: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_above_100k_tokens: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_above_100k_tokens_batches: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_above_128k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_above_200k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_above_200k_tokens_batches: Option<f64>,
-    /// Priority service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_above_200k_tokens_priority: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_above_256k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_above_272k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_above_272k_tokens_batches: Option<f64>,
-    /// Flex service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_above_272k_tokens_flex: Option<f64>,
-    /// Priority service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_above_272k_tokens_priority: Option<f64>,
-    /// Ultrafast service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_above_272k_tokens_ultrafast: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_above_512k_tokens: Option<f64>,
-    /// Balanced service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_balanced: Option<f64>,
-    /// USD per prompt token via the provider's batch API.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_batches: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token_cache_hit: Option<f64>,
-    /// Flex service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub input_cost_per_token_flex: Option<f64>,
-    /// Priority service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub input_cost_per_token_priority: Option<f64>,
-    /// Ultrafast service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
+    pub input_cost_per_token_balanced: Option<f64>,
     pub input_cost_per_token_ultrafast: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_video_per_second: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_video_per_second_above_128k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_video_per_second_above_15s_interval: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_video_per_second_above_8s_interval: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cache_creation_input_token_cost: Option<f64>,
+    pub cache_creation_input_token_cost_above_200k_tokens: Option<f64>,
+    pub cache_creation_input_token_cost_above_272k_tokens: Option<f64>,
+    pub cache_creation_input_token_cost_above_272k_tokens_priority: Option<f64>,
+    pub cache_creation_input_token_cost_above_272k_tokens_flex: Option<f64>,
+    pub cache_creation_input_token_cost_above_272k_tokens_ultrafast: Option<f64>,
+    pub cache_creation_input_token_cost_flex: Option<f64>,
+    pub cache_creation_input_token_cost_priority: Option<f64>,
+    pub cache_creation_input_token_cost_ultrafast: Option<f64>,
+    pub cache_read_input_token_cost: Option<f64>,
+    pub cache_read_input_audio_token_cost: Option<f64>,
+    pub cache_read_input_audio_token_cost_flex: Option<f64>,
+    pub cache_read_input_audio_token_cost_priority: Option<f64>,
+    pub cache_read_input_audio_token_cost_batches: Option<f64>,
+    pub explicit_cache_read_input_token_cost: Option<f64>,
+    pub prompt_cache_min_tokens: Option<i64>,
+    pub cache_read_input_token_cost_above_200k_tokens: Option<f64>,
+    pub cache_read_input_token_cost_above_200k_tokens_priority: Option<f64>,
+    pub cache_read_input_token_cost_above_272k_tokens: Option<f64>,
+    pub cache_read_input_token_cost_above_272k_tokens_priority: Option<f64>,
+    pub cache_read_input_token_cost_above_272k_tokens_flex: Option<f64>,
+    pub cache_read_input_token_cost_above_272k_tokens_ultrafast: Option<f64>,
+    pub cache_read_input_token_cost_above_512k_tokens: Option<f64>,
+    pub cache_read_input_token_cost_flex: Option<f64>,
+    pub cache_read_input_token_cost_priority: Option<f64>,
+    pub cache_read_input_token_cost_balanced: Option<f64>,
+    pub cache_read_input_token_cost_ultrafast: Option<f64>,
+    pub cache_read_input_token_cost_batches: Option<f64>,
+    pub cache_read_input_token_cost_above_200k_tokens_batches: Option<f64>,
+    pub cache_read_input_token_cost_above_272k_tokens_batches: Option<f64>,
+    pub cache_creation_input_token_cost_batches: Option<f64>,
+    pub cache_creation_input_token_cost_above_200k_tokens_batches: Option<f64>,
+    pub cache_creation_input_token_cost_above_272k_tokens_batches: Option<f64>,
+    pub cache_creation_input_token_cost_above_1hr: Option<f64>,
+    pub cache_creation_input_token_cost_above_12hr: Option<f64>,
+    pub cache_creation_input_token_cost_above_12hr_flex: Option<f64>,
+    pub cache_creation_input_token_cost_above_12hr_priority: Option<f64>,
+    pub cache_creation_input_token_cost_above_12hr_above_272k_tokens: Option<f64>,
+    pub cache_creation_input_token_cost_above_12hr_above_272k_tokens_flex: Option<f64>,
+    pub cache_creation_input_token_cost_above_12hr_above_272k_tokens_priority: Option<f64>,
+    pub cache_creation_input_token_cost_above_12hr_batches: Option<f64>,
+    pub cache_creation_input_token_cost_above_12hr_ultrafast: Option<f64>,
+    pub cache_creation_input_token_cost_above_12hr_above_272k_tokens_batches: Option<f64>,
+    pub cache_creation_input_token_cost_above_12hr_above_272k_tokens_ultrafast: Option<f64>,
+    pub off_peak_pricing: Option<Value>,
+    pub input_cost_per_character: Option<f64>,
+    pub input_cost_per_token_above_128k_tokens: Option<f64>,
+    pub input_cost_per_token_above_200k_tokens: Option<f64>,
+    pub input_cost_per_token_above_200k_tokens_priority: Option<f64>,
+    pub input_cost_per_token_above_272k_tokens: Option<f64>,
+    pub input_cost_per_token_above_272k_tokens_priority: Option<f64>,
+    pub input_cost_per_token_above_272k_tokens_flex: Option<f64>,
+    pub input_cost_per_token_above_272k_tokens_ultrafast: Option<f64>,
+    pub input_cost_per_token_above_512k_tokens: Option<f64>,
+    pub input_cost_per_query: Option<f64>,
+    pub cost_per_second: Option<f64>,
+    pub input_cost_per_second: Option<f64>,
+    pub input_cost_per_text_message: Option<f64>,
+    pub input_cost_per_audio_token: Option<f64>,
+    pub input_cost_per_audio_token_flex: Option<f64>,
+    pub input_cost_per_audio_token_priority: Option<f64>,
+    pub input_cost_per_image_token: Option<f64>,
     pub input_cost_per_video_token: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    pub input_cost_per_audio_token_batches: Option<f64>,
+    pub input_cost_per_image_token_batches: Option<f64>,
+    pub input_cost_per_image: Option<f64>,
+    pub input_cost_per_audio_per_second: Option<f64>,
+    pub input_cost_per_video_per_second: Option<f64>,
+    pub input_cost_per_token_batches: Option<f64>,
     pub input_cost_per_video_token_batches: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_dbu_cost_per_token: Option<f64>,
-    /// LiteLLM provider slug; one of https://docs.litellm.ai/docs/providers.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub litellm_provider: Option<String>,
-    /// Maximum prompt/context tokens the model accepts.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_input_tokens: Option<u64>,
-    /// Maximum tokens the model can generate in one response.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_output_tokens: Option<u64>,
-    /// Legacy field: max output tokens if the provider specifies it, else max input tokens.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_tokens: Option<u64>,
-    /// Free-form notes about the entry (e.g. pricing derivation).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub metadata: Option<BTreeMap<String, Value>>,
-    /// Primary API surface / task type of the model.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub mode: Option<Mode>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ocr_cost_per_credit: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ocr_cost_per_page: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ocr_cost_per_page_batches: Option<f64>,
-    /// Rates that replace the same-named base fields while the request falls inside the stated UTC windows.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub off_peak_pricing: Option<OffPeakPricing>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_audio_token: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_character: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_character_above_128k_tokens: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_image: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_image_1024: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_image_1536: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_image_512: Option<f64>,
-    #[serde(
-        rename = "output_cost_per_image_0.5K",
-        skip_serializing_if = "Option::is_none"
-    )]
-    pub output_cost_per_image_0_5k: Option<f64>,
-    #[serde(
-        rename = "output_cost_per_image_1K",
-        skip_serializing_if = "Option::is_none"
-    )]
-    pub output_cost_per_image_1k: Option<f64>,
-    #[serde(
-        rename = "output_cost_per_image_2K",
-        skip_serializing_if = "Option::is_none"
-    )]
-    pub output_cost_per_image_2k: Option<f64>,
-    #[serde(
-        rename = "output_cost_per_image_4K",
-        skip_serializing_if = "Option::is_none"
-    )]
-    pub output_cost_per_image_4k: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_image_token: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_pixel: Option<f64>,
-    /// USD per reasoning/thinking token, when billed separately.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_reasoning_token: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_second: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_second_1080p: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_second_2k: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_second_480p: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_second_4k: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_second_720p: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_second_768p: Option<f64>,
-    /// USD per generated token.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token_above_32k_tokens: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token_above_100k_tokens: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token_above_100k_tokens_batches: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token_above_128k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token_above_200k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token_above_200k_tokens_batches: Option<f64>,
-    /// Priority service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token_above_200k_tokens_priority: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token_above_256k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token_above_272k_tokens: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token_above_272k_tokens_batches: Option<f64>,
-    /// Flex service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token_above_272k_tokens_flex: Option<f64>,
-    /// Priority service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token_above_272k_tokens_priority: Option<f64>,
-    /// Ultrafast service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token_above_272k_tokens_ultrafast: Option<f64>,
-    /// Rate applied once the prompt exceeds the token threshold in the field name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token_above_512k_tokens: Option<f64>,
-    /// Balanced service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token_balanced: Option<f64>,
-    /// USD per generated token via the provider's batch API.
-    #[serde(skip_serializing_if = "Option::is_none")]
+    pub input_cost_per_token_above_200k_tokens_batches: Option<f64>,
+    pub input_cost_per_token_above_272k_tokens_batches: Option<f64>,
     pub output_cost_per_token_batches: Option<f64>,
-    /// Flex service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
+    pub output_cost_per_token_above_200k_tokens_batches: Option<f64>,
+    pub output_cost_per_token_above_272k_tokens_batches: Option<f64>,
+    pub output_cost_per_token: Option<f64>,
     pub output_cost_per_token_flex: Option<f64>,
-    /// Priority service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub output_cost_per_token_priority: Option<f64>,
-    /// Ultrafast service-tier rate for the same-named base field.
-    #[serde(skip_serializing_if = "Option::is_none")]
+    pub output_cost_per_token_balanced: Option<f64>,
     pub output_cost_per_token_ultrafast: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_video_per_second: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_video_token: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_dbu_cost_per_token: Option<f64>,
-    /// Embedding dimension for embedding models.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_vector_size: Option<u64>,
-    /// Smallest prefix the provider will actually cache; absent means the provider default applies.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub prompt_cache_min_tokens: Option<u64>,
-    /// Provider-internal routing hints (e.g. bedrock_invocation_schema).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub provider_specific_entry: Option<BTreeMap<String, Value>>,
-    /// Exact reasoning_effort levels this deployment accepts; wins over supports_* flags.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub reasoning_effort_levels: Option<Vec<ReasoningEffort>>,
-    /// Multiplier applied to all token costs when served from a non-global Vertex AI endpoint (e.g. 1.10 = +10%).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub regional_endpoint_uplift_multiplier: Option<f64>,
-    /// Multiplier applied to all token costs for EU data residency (e.g. 1.10 = +10%).
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub regional_processing_uplift_multiplier_eu: Option<f64>,
-    /// Multiplier applied to all token costs for US data residency (e.g. 1.10 = +10%).
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub regional_processing_uplift_multiplier_us: Option<f64>,
-    /// Provider default requests-per-minute limit.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub rpm: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub rules: Option<Vec<Value>>,
-    /// USD cost per web search query, keyed by search context size.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub search_context_cost_per_query: Option<SearchContextCostPerQuery>,
-    /// URL of the provider pricing/model page this entry was taken from.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub source: Option<String>,
-    /// Audio container formats the model can return.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supported_audio_formats: Option<Vec<AudioFormat>>,
-    /// OpenAI-style API routes this model can be called through, e.g. /v1/chat/completions.
-    #[serde(skip_serializing_if = "Option::is_none")]
+    pub regional_endpoint_uplift_multiplier: Option<f64>,
+    pub output_cost_per_audio_token: Option<f64>,
+    pub output_cost_per_character: Option<f64>,
+    pub output_cost_per_reasoning_token: Option<f64>,
+    pub output_cost_per_reasoning_token_flex: Option<f64>,
+    pub output_cost_per_reasoning_token_priority: Option<f64>,
+    pub output_cost_per_token_above_128k_tokens: Option<f64>,
+    pub output_cost_per_character_above_128k_tokens: Option<f64>,
+    pub output_cost_per_token_above_200k_tokens: Option<f64>,
+    pub output_cost_per_token_above_200k_tokens_priority: Option<f64>,
+    pub output_cost_per_token_above_272k_tokens: Option<f64>,
+    pub output_cost_per_token_above_272k_tokens_priority: Option<f64>,
+    pub output_cost_per_token_above_272k_tokens_flex: Option<f64>,
+    pub output_cost_per_token_above_272k_tokens_ultrafast: Option<f64>,
+    pub output_cost_per_token_above_512k_tokens: Option<f64>,
+    pub output_cost_per_second: Option<f64>,
+    pub output_cost_per_second_1080p: Option<f64>,
+    pub output_cost_per_second_480p: Option<f64>,
+    pub output_cost_per_second_720p: Option<f64>,
+    pub output_cost_per_second_768p: Option<f64>,
+    pub output_cost_per_second_2k: Option<f64>,
+    pub output_cost_per_second_4k: Option<f64>,
+    pub output_cost_per_video_per_second: Option<f64>,
+    pub output_cost_per_image: Option<f64>,
+    pub output_cost_per_pixel: Option<f64>,
+    pub output_cost_per_image_token: Option<f64>,
+    pub output_cost_per_image_token_batches: Option<f64>,
+    pub output_cost_per_video_token: Option<f64>,
+    pub output_vector_size: Option<i64>,
+    pub citation_cost_per_token: Option<f64>,
+    pub tiered_pricing: Option<Value>,
+    pub litellm_provider: Option<String>,
+    pub mode: Option<Value>,
     pub supported_endpoints: Option<Vec<String>>,
-    /// Input modalities the model accepts.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supported_modalities: Option<Vec<InputModality>>,
-    /// Output modalities the model can produce.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supported_output_modalities: Option<Vec<OutputModality>>,
-    /// Cloud regions the model is available in ('global' or region ids).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supported_regions: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_adaptive_thinking: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_anthropic_compaction: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_anthropic_thinking_payload: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_assistant_prefill: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_audio_input: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_audio_output: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_bedrock_runtime_chat_completions_response_format: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_bedrock_runtime_chat_completions_tools_with_reasoning: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_computer_use: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_embedding_image_input: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_fast_mode: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_forced_tool_use: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_function_calling: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_image_input: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_image_size: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_legacy_thinking: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_low_reasoning_effort: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_max_reasoning_effort: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_mid_conversation_system: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_minimal_reasoning_effort: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_multimodal: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_native_streaming: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_native_structured_output: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_none_reasoning_effort: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_nova_canvas_image_edit: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_output_config: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_parallel_function_calling: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_parallel_tool_use_config: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_pdf_input: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_prompt_cache_breakpoint: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_prompt_caching: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_reasoning: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_response_schema: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_sampling_params: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_speed: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub supports_system_messages: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_thinking_cache_preservation: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_tool_choice: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_tool_search: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_url_context: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_video_input: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    pub supports_response_schema: Option<bool>,
     pub supports_vision: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    pub supports_function_calling: Option<bool>,
+    pub supports_parallel_function_calling: Option<bool>,
+    pub supports_tool_choice: Option<bool>,
+    pub supports_assistant_prefill: Option<bool>,
+    pub supports_prompt_caching: Option<bool>,
+    pub supports_prompt_cache_breakpoint: Option<bool>,
+    pub supports_thinking_cache_preservation: Option<bool>,
+    pub supports_audio_input: Option<bool>,
+    pub supports_video_input: Option<bool>,
+    pub supports_box_questions: Option<bool>,
+    pub supports_audio_output: Option<bool>,
+    pub supports_pdf_input: Option<bool>,
+    pub supports_embedding_image_input: Option<bool>,
+    pub supports_native_streaming: Option<bool>,
+    pub supports_native_structured_output: Option<bool>,
+    pub supports_bedrock_native_structured_output: Option<bool>,
     pub supports_web_search: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub supports_xhigh_reasoning_effort: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    pub supports_url_context: Option<bool>,
+    pub supports_reasoning: Option<bool>,
+    pub supports_adaptive_thinking: Option<bool>,
+    pub supports_legacy_thinking: Option<bool>,
     pub thinking_always_on: Option<bool>,
-    /// Context-length or result-count tiered rates; each tier's costs apply within its range.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tiered_pricing: Option<Vec<TieredRate>>,
-    /// Provider default tokens-per-minute limit.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tpm: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub use_openai_responses_path: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    pub supports_tool_search: Option<bool>,
+    pub supports_mid_conversation_system: Option<bool>,
+    pub supports_anthropic_thinking_payload: Option<bool>,
+    pub supports_anthropic_compaction: Option<bool>,
+    pub supports_none_reasoning_effort: Option<bool>,
+    pub supports_minimal_reasoning_effort: Option<bool>,
+    pub supports_low_reasoning_effort: Option<bool>,
+    pub supports_xhigh_reasoning_effort: Option<bool>,
+    pub supports_max_reasoning_effort: Option<bool>,
+    pub reasoning_effort_levels: Option<Value>,
+    pub default_reasoning_effort: Option<Value>,
+    pub bedrock_output_config_effort_ceiling: Option<Value>,
+    pub bedrock_converse_supports_strict_tools: Option<bool>,
+    pub supports_regex_lookaround: Option<bool>,
+    pub supports_computer_use: Option<bool>,
+    pub search_context_cost_per_query: Option<Value>,
+    pub web_search_billing_unit: Option<Value>,
+    pub search_free_requests: Option<Value>,
+    pub google_maps_grounding_cost_per_query: Option<f64>,
+    pub tpm: Option<i64>,
+    pub rpm: Option<i64>,
+    pub ocr_cost_per_page: Option<f64>,
+    pub ocr_cost_per_page_batches: Option<f64>,
+    pub ocr_cost_per_credit: Option<f64>,
+    pub annotation_cost_per_page: Option<f64>,
+    pub annotation_cost_per_page_batches: Option<f64>,
+    pub provider_specific_entry: Option<Value>,
     pub uses_embed_content: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub vector_store_cost_per_gb_per_day: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub vertex_ai_audio_api: Option<VertexAiAudioApi>,
-    /// Whether web search is billed per query or per prompt.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub web_search_billing_unit: Option<WebSearchBillingUnit>,
+    pub supports_image_size: Option<bool>,
+    pub supported_audio_formats: Option<Value>,
+    pub token_count_framing: Option<i64>,
+    pub token_count_model: Option<Value>,
+    pub token_count_tokenizer: Option<Value>,
+    pub vertex_ai_audio_api: Option<Value>,
+    /// Every key matching `ABOVE_THRESHOLD_COST_KEY_PATTERN`, copied as written
+    pub above_threshold_costs: IndexMap<String, Value>,
 }
diff --git a/litellm-rust/crates/model-catalog/src/pricing.rs b/litellm-rust/crates/model-catalog/src/pricing.rs
deleted file mode 100644
index b8ed652451c..00000000000
--- a/litellm-rust/crates/model-catalog/src/pricing.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-/// Whether web search is billed per query or per prompt.
-#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[serde(rename_all = "snake_case")]
-pub enum WebSearchBillingUnit {
-    PerQuery,
-    PerPrompt,
-}
-
-/// UTC "HH:MM-HH:MM" window, or a list of them; a window may wrap past midnight.
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[serde(untagged)]
-pub enum UtcHours {
-    Single(String),
-    Multiple(Vec<String>),
-}
-
-/// ISO-8601 weekday number (1 = Monday .. 7 = Sunday) or English day name.
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[serde(untagged)]
-pub enum Weekday {
-    Number(u8),
-    Name(String),
-}
-
-/// One off-peak window entry inside `windows`.
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[serde(deny_unknown_fields)]
-pub struct OffPeakWindow {
-    pub hours_utc: UtcHours,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub weekdays: Option<Vec<Weekday>>,
-}
-
-/// Rates that replace the same-named base fields inside the stated UTC windows.
-#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[serde(deny_unknown_fields)]
-pub struct OffPeakPricing {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub hours_utc: Option<UtcHours>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub windows: Option<Vec<OffPeakWindow>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub weekday_timezone: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_reasoning_token: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost: Option<f64>,
-}
-
-/// USD cost per web search query, keyed by search context size.
-#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[serde(deny_unknown_fields)]
-pub struct SearchContextCostPerQuery {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub search_context_size_low: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub search_context_size_medium: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub search_context_size_high: Option<f64>,
-}
-
-/// One tier of a context-length or result-count tiered rate.
-#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[serde(deny_unknown_fields)]
-pub struct TieredRate {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub range: Option<[f64; 2]>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_results_range: Option<[f64; 2]>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_token: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_token: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_cost_per_reasoning_token: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_read_input_token_cost: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cache_creation_input_token_cost: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_cost_per_query: Option<f64>,
-}
diff --git a/litellm-rust/crates/model-catalog/src/register.rs b/litellm-rust/crates/model-catalog/src/register.rs
new file mode 100644
index 00000000000..ed34082ae57
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/register.rs
@@ -0,0 +1,26 @@
+use std::collections::{BTreeSet, HashMap};
+
+use indexmap::IndexMap;
+
+use crate::wire::Fields;
+
+/// Where one `register` call writes and which row it inherits from
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RegistrationTarget {
+    /// Always the caller's key, never a case variant of it
+    pub write: String,
+    /// The first candidate that is an exact key whose row passes `provider_matches`
+    pub inherit_from: Option<String>,
+}
+
+/// Python's inheritance candidates in main's order, `get_model_info`'s then `_resolve_builtin_model_cost_entry`'s
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RegistrationCandidates(pub Vec<String>);
+
+/// Layer 3, and the fields `register` last wrote, which litellm owns again
+#[derive(Clone, Debug, Default)]
+#[expect(dead_code, reason = "07 adds the functions that read registrations")]
+pub struct Registrations {
+    persisted: IndexMap<String, Fields>,
+    registered_fields: HashMap<String, BTreeSet<String>>,
+}
diff --git a/litellm-rust/crates/model-catalog/src/resolve/image.rs b/litellm-rust/crates/model-catalog/src/resolve/image.rs
new file mode 100644
index 00000000000..d24e170b32c
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/resolve/image.rs
@@ -0,0 +1,18 @@
+/// What an image call asks for. `resolve_image` builds main's eight key spellings from it
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ImageCandidates {
+    pub model: String,
+    pub provider: Option<String>,
+    /// Width and height, `1024 x 1024` when the request names none, as on main
+    pub size: Option<(u32, u32)>,
+    pub quality: Option<String>,
+}
+
+/// A size and quality keyed row, `{quality}/{W}-x-{H}/{model}`, parsed once per index build for fal's nearest match
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ImageKey {
+    pub quality: Option<String>,
+    pub width: u32,
+    pub height: u32,
+    pub model: String,
+}
diff --git a/litellm-rust/crates/model-catalog/src/resolve/mod.rs b/litellm-rust/crates/model-catalog/src/resolve/mod.rs
new file mode 100644
index 00000000000..fbaead622aa
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/resolve/mod.rs
@@ -0,0 +1,46 @@
+mod image;
+
+pub use image::*;
+
+/// The seven names main's `get_model_info` tries, built by Python, walked in this order by Rust
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Candidates {
+    pub combined_model_name: Option<String>,
+    pub model: String,
+    pub region_free_combined_model_name: Option<String>,
+    pub split_model: Option<String>,
+    pub combined_stripped_model_name: Option<String>,
+    pub stripped_model_name: Option<String>,
+    pub provider_prefixed_model_name: Option<String>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum CandidateSlot {
+    CombinedModelName,
+    Model,
+    RegionFreeCombinedModelName,
+    SplitModel,
+    CombinedStrippedModelName,
+    StrippedModelName,
+    ProviderPrefixedModelName,
+}
+
+/// Which step matched, so a test can name the step that changed
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Via {
+    pub slot: CandidateSlot,
+    /// Matched through the case-insensitive index rather than an exact key
+    pub case_insensitive: bool,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Resolution {
+    Found {
+        key: String,
+        via: Via,
+    },
+    /// Every candidate tried, in order
+    Missing {
+        tried: Vec<String>,
+    },
+}
diff --git a/litellm-rust/crates/model-catalog/src/schema.rs b/litellm-rust/crates/model-catalog/src/schema.rs
index 7de988b3ff3..66f9933a3e3 100644
--- a/litellm-rust/crates/model-catalog/src/schema.rs
+++ b/litellm-rust/crates/model-catalog/src/schema.rs
@@ -1,9 +1,80 @@
-use schemars::Schema;
+use std::collections::BTreeMap;
+
+use litellm_cost::money::{Multiplier, UnitPrice};
+use schemars::{JsonSchema, Schema};
 use serde_json::{Map, Value, json};
 
+use crate::fallback::FallbackGeneralizations;
+use crate::wire::{Attributes, OffPeakWindow, SearchContextCostPerQuery, UtcHours};
+
+#[derive(JsonSchema)]
+#[schemars(rename = "ModelEntry")]
+struct ModelEntry {
+    #[serde(flatten)]
+    _attributes: Attributes,
+    #[serde(flatten)]
+    _blocks: PriceBlocks,
+}
+
+#[derive(JsonSchema)]
+#[allow(dead_code)]
+struct PriceBlocks {
+    /// USD cost per billable guardrail unit, keyed by the provider's usage counter name (e.g. Bedrock's contentPolicyUnits).
+    guardrail_cost_per_unit: Option<BTreeMap<String, UnitPrice>>,
+    /// Rates that replace the same-named base fields while the request falls inside the stated UTC windows.
+    off_peak_pricing: Option<OffPeakPricing>,
+    /// Multiplier applied to all token costs when served from a non-global Vertex AI endpoint (e.g. 1.10 = +10%).
+    regional_endpoint_uplift_multiplier: Option<Multiplier>,
+    /// Multiplier applied to all token costs for EU data residency (e.g. 1.10 = +10%).
+    regional_processing_uplift_multiplier_eu: Option<Multiplier>,
+    /// Multiplier applied to all token costs for US data residency (e.g. 1.10 = +10%).
+    regional_processing_uplift_multiplier_us: Option<Multiplier>,
+    /// USD cost per web search query, keyed by search context size.
+    search_context_cost_per_query: Option<SearchContextCostPerQuery>,
+    /// Context-length or result-count tiered rates; each tier's costs apply within its range.
+    tiered_pricing: Option<Vec<TieredRate>>,
+}
+
+/// Rates that replace the same-named base fields inside the stated UTC windows.
+#[derive(JsonSchema)]
+#[allow(dead_code)]
+struct OffPeakPricing {
+    hours_utc: Option<UtcHours>,
+    windows: Option<Vec<OffPeakWindow>>,
+    weekday_timezone: Option<String>,
+}
+
+/// One tier of a context-length or result-count tiered rate.
+#[derive(JsonSchema)]
+#[allow(dead_code)]
+struct TieredRate {
+    range: Option<[u64; 2]>,
+    max_results_range: Option<[u64; 2]>,
+}
+
+#[derive(JsonSchema)]
+#[allow(dead_code)]
+struct RegistryDocument {
+    sample_spec: Option<Map<String, Value>>,
+    fallback_generalizations: Option<FallbackGeneralizations>,
+}
+
+pub(crate) const FLAT_KEY_PATTERN: &str = concat!(
+    r"^(",
+    r"input_cost_per_((audio_|image_|video_)?token|character|image|pixel|query|request|second|text_message|audio_per_second|video_per_second(_above_\d+s_interval)?)",
+    r"|output_cost_per_((audio_|image_|video_|reasoning_)?token|character|image(_\d+(\.\d+)?K?)?|pixel|second(_\d+[pk])?|video_per_second)",
+    r"|cache_read_input_(audio_|image_|video_)?token_cost",
+    r"|explicit_cache_read_input_token_cost",
+    r"|cache_creation_input_(audio_|image_|video_)?token_cost(_above_1hr|_above_12hr)?",
+    r"|annotation_cost_per_page|citation_cost_per_token|code_interpreter_cost_per_session",
+    r"|google_maps_grounding_cost_per_query|ocr_cost_per_credit|ocr_cost_per_page|cost_per_second",
+    r"|browser_open_cost_per_request|cost_per_additional_result",
+    r")(_above_\d+k?_tokens)?(_(priority|flex|ultrafast|balanced|batches|decisions))?$",
+);
+
 /// JSON Schema for one model entry, including registry validation constraints.
 pub fn model_entry_json_schema() -> Schema {
-    let mut schema = serde_json::to_value(schemars::schema_for!(crate::ModelInfo))
+    let mut schema = serde_json::to_value(schemars::schema_for!(ModelEntry))
         .expect("derived model schema serializes");
     remove_nullable_optional_fields(&mut schema);
     decorate_model_entry(&mut schema);
@@ -22,24 +93,21 @@ pub fn registry_json_schema() -> Schema {
     entry.as_object_mut().unwrap().remove("$schema");
     definitions.insert("modelEntry".into(), entry);
 
-    let mut fallback = serde_json::to_value(schemars::schema_for!(crate::FallbackGeneralizations))
-        .expect("derived fallback schema serializes");
-    remove_nullable_optional_fields(&mut fallback);
-    definitions.extend(take_definitions(&mut fallback));
-    fallback.as_object_mut().unwrap().remove("$schema");
-
-    let root = json!({
-        "$schema": "https://json-schema.org/draft/2020-12/schema",
-        "title": "LiteLLM model prices and context window registry",
-        "type": "object",
-        "properties": {
-            "sample_spec": {"type": "object"},
-            "fallback_generalizations": fallback
-        },
-        "additionalProperties": {"$ref": "#/$defs/modelEntry"},
-        "$defs": definitions
-    });
-    Schema::from(root.as_object().unwrap().clone())
+    let mut registry = serde_json::to_value(schemars::schema_for!(RegistryDocument))
+        .expect("derived registry schema serializes");
+    remove_nullable_optional_fields(&mut registry);
+    definitions.extend(take_definitions(&mut registry));
+    let root = registry.as_object_mut().unwrap();
+    root.insert(
+        "title".into(),
+        "LiteLLM model prices and context window registry".into(),
+    );
+    root.insert(
+        "additionalProperties".into(),
+        json!({"$ref": "#/$defs/modelEntry"}),
+    );
+    root.insert("$defs".into(), Value::Object(definitions));
+    Schema::from(root.clone())
 }
 
 fn take_definitions(schema: &mut Value) -> Map<String, Value> {
@@ -80,42 +148,21 @@ fn remove_nullable_optional_fields(value: &mut Value) {
 }
 
 fn decorate_model_entry(schema: &mut Value) {
+    let rates = json!({FLAT_KEY_PATTERN: {"type": "number", "minimum": 0}});
     let object = schema.as_object_mut().unwrap();
     object.insert("required".into(), json!(["litellm_provider"]));
     object.insert("additionalProperties".into(), Value::Bool(true));
-    let properties = object
-        .get_mut("properties")
-        .unwrap()
-        .as_object_mut()
-        .unwrap();
-    properties.insert(
-        "aliases".into(),
-        json!({"type": "array", "items": {"type": "string"}}),
+    object.insert(
+        "patternProperties".into(),
+        json!({
+            FLAT_KEY_PATTERN: {"type": "number", "minimum": 0},
+            "^supports_": {"type": "boolean"},
+        }),
     );
-    properties.get_mut("deprecation_date").unwrap()["format"] = json!("date");
-    properties.get_mut("deprecation_date").unwrap()["pattern"] =
-        json!(r"^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$");
-
-    properties.iter_mut().for_each(|(name, property)| {
-        if name.contains("cost") {
-            property["minimum"] = json!(0);
-        } else if name.contains("uplift_multiplier") {
-            property["minimum"] = json!(1);
-        }
-    });
-    properties.get_mut("guardrail_cost_per_unit").unwrap()["additionalProperties"]["minimum"] =
-        json!(0);
-
     let definitions = object.get_mut("$defs").unwrap().as_object_mut().unwrap();
-    for definition in ["OffPeakPricing", "TieredRate", "SearchContextCostPerQuery"] {
-        let properties = definitions[definition]["properties"]
-            .as_object_mut()
-            .unwrap();
-        properties.iter_mut().for_each(|(name, property)| {
-            if name.contains("cost") || definition == "SearchContextCostPerQuery" {
-                property["minimum"] = json!(0);
-            }
-        });
+    for definition in ["OffPeakPricing", "TieredRate"] {
+        definitions[definition]["patternProperties"] = rates.clone();
+        definitions[definition]["additionalProperties"] = Value::Bool(false);
     }
     definitions["OffPeakPricing"]["anyOf"] = json!([
         {"required": ["hours_utc"]},
@@ -123,15 +170,43 @@ fn decorate_model_entry(schema: &mut Value) {
     ]);
     definitions["OffPeakPricing"]["properties"]["windows"]["minItems"] = json!(1);
     definitions["OffPeakWindow"]["properties"]["weekdays"]["minItems"] = json!(1);
-    definitions["TieredRate"]["properties"]["range"]["items"]["minimum"] = json!(0);
-    definitions["TieredRate"]["properties"]["max_results_range"]["items"]["minimum"] = json!(0);
-    definitions["Weekday"]["anyOf"][0]["minimum"] = json!(1);
-    definitions["Weekday"]["anyOf"][0]["maximum"] = json!(7);
-    definitions["Weekday"]["anyOf"][1]["pattern"] = json!(
-        r"(?i)^(mon|monday|tue|tues|tuesday|wed|wednesday|thu|thur|thurs|thursday|fri|friday|sat|saturday|sun|sunday)$"
-    );
-    let window_pattern = json!(r"^([01]\d|2[0-3]):[0-5]\d-([01]\d|2[0-3]):[0-5]\d$");
-    definitions["UtcHours"]["anyOf"][0]["pattern"] = window_pattern.clone();
-    definitions["UtcHours"]["anyOf"][1]["items"]["pattern"] = window_pattern;
     definitions["UtcHours"]["anyOf"][1]["minItems"] = json!(1);
 }
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+
+    use super::FLAT_KEY_PATTERN;
+    use crate::wire::FlatKey;
+
+    #[rstest]
+    #[case::input_token("input_cost_per_token")]
+    #[case::cache_write_one_hour_band(
+        "cache_creation_input_token_cost_above_1hr_above_200k_tokens"
+    )]
+    #[case::image_label("output_cost_per_image_0.5K")]
+    #[case::resolution_tier("output_cost_per_second_4k_flex")]
+    #[case::feature_batch("annotation_cost_per_page_batches")]
+    #[case::video_interval("input_cost_per_video_per_second_above_8s_interval")]
+    #[case::explicit_cache_read("explicit_cache_read_input_token_cost")]
+    #[case::wall_clock("cost_per_second")]
+    #[case::unused_meter("cost_per_token")]
+    #[case::other_currency("input_dbu_cost_per_token")]
+    #[case::typo("input_cost_per_tokne")]
+    #[case::read_has_no_ttl("cache_read_input_token_cost_above_1hr")]
+    #[case::interval_on_a_token_meter("input_cost_per_token_above_8s_interval")]
+    fn flat_key_pattern_agrees_with_the_parser(#[case] key: &str) {
+        let schema = serde_json::json!({
+            "type": "object",
+            "patternProperties": {FLAT_KEY_PATTERN: {}},
+            "additionalProperties": false,
+        });
+        let validator = jsonschema::validator_for(&schema).unwrap();
+
+        assert_eq!(
+            validator.is_valid(&serde_json::json!({key: 1})),
+            FlatKey::parse(key).is_some()
+        );
+    }
+}
diff --git a/litellm-rust/crates/model-catalog/src/store/AGENTS.md b/litellm-rust/crates/model-catalog/src/store/AGENTS.md
new file mode 100644
index 00000000000..f1dacd2e217
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/store/AGENTS.md
@@ -0,0 +1,35 @@
+# Store
+
+`Store<R: Rows>` is an in-memory store, a small database built for exactly three queries. It knows nothing about the catalog. A source picks its own `Rows::Row` type, how names fold for matching, and the group each key is listed under. The catalog's sources fold to lowercase and group by raw `litellm_provider`
+
+| Query | Method | Real caller |
+|---|---|---|
+| row by exact key | `Store::get` | reading `litellm.model_cost["gpt-4o"]` |
+| actual key for a name that folds to the same form | `Store::find_key` | `get_model_info("GPT-4o")` finding `gpt-4o` |
+| keys in a group | `Store::keys_in` | the provider sets, `litellm.open_ai_chat_completion_models` |
+
+## Rules
+
+- nothing in `store/` imports from the rest of the crate. Wire types, case rules and field names such as `litellm_provider` belong to the source that implements `Rows`
+- the index in `name_index.rs` is private to the store. Never build a folded-name map or a provider grouping anywhere else in the workspace. A new lookup pattern is a new `Store` method backed by `NameIndex`
+- the index holds keys, never rows. Rows are always read from `Rows`, so a price edit is seen on the next read and never rebuilds the index
+- `find_key` and `keys_in` never return a key the rows lack. A hit on a removed key rebuilds the index once and asks again
+- `keys_in` matches the group exactly as the source wrote it. Provider aliases such as `vertex_ai` over `vertex_ai-language-models` are Python's job
+- when two keys fold to the same name the later key in row order wins, like main's `_model_cost_lowercase_map`
+
+## Stamps
+
+`Rows::stamp` is how the store learns that the index may be stale. The store keeps the stamp it built the index at and rebuilds when the source returns a different one. A source must change its stamp whenever a key or a key's group changes, since those are the two things the index holds
+
+| Source | Stamp | Blind spot |
+|---|---|---|
+| `Catalog`'s `CatalogRows` | `()`, every change goes through `Store::edit`, which drops the index | none |
+| python-bridge's bound `litellm.model_cost` | the dict object and its `len` | a delete plus an add between two reads, or a `litellm_provider` rewrite on an existing key |
+
+A source with a blind spot calls `Store::invalidate` when it knows keys changed. Until then a key added in the blind spot is not found, and a key moved to another provider stays listed under the old one. Removed keys are still never returned
+
+## Tests
+
+Tests live in `mod.rs`'s `tests` module and drive the store through `ModelCost`, a fake `litellm.model_cost` with real bundled keys whose row is just its `litellm_provider`. Each Python write is a method (`set`, `del`, `rebind`) and its stamp is what python-bridge can see. Add a scenario as a named test that reads like the Python user code it stands for
+
+The two property tests compare every answer with a linear scan of the same dict. With a stamp that sees every key change, answers must match exactly. With the dict stamp, every answer must be sound (present, same folded name), and `invalidate` must make them match again. A store change that fails either is a bug in the store, not in the test
diff --git a/litellm-rust/crates/model-catalog/src/store/mod.rs b/litellm-rust/crates/model-catalog/src/store/mod.rs
new file mode 100644
index 00000000000..2220526f8b6
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/store/mod.rs
@@ -0,0 +1,460 @@
+mod name_index;
+
+use std::borrow::Cow;
+use std::fmt;
+use std::sync::{PoisonError, RwLock};
+
+use name_index::NameIndex;
+
+/// Where a `Store`'s rows live. The store rebuilds its index whenever `stamp` changes, so a source must change its
+/// stamp whenever a key or a key's group changes, or call `Store::invalidate` when it cannot
+pub trait Rows {
+    type Row: ToOwned + ?Sized;
+    type Stamp: PartialEq;
+
+    /// The name two spellings of one key share, which `Store::find_key` matches on
+    fn fold(name: &str) -> String;
+    fn stamp(&self) -> Self::Stamp;
+    fn contains(&self, key: &str) -> bool;
+    fn row(&self, key: &str) -> Option<Cow<'_, Self::Row>>;
+    /// Every key in row order with the group it is listed under
+    fn scan(&self, visit: &mut dyn FnMut(&str, Option<&str>));
+}
+
+/// An in-memory store for three queries (row by exact key, actual key for a name by its folded form, keys in a group)
+/// that owns the only index behind them
+pub struct Store<R: Rows> {
+    rows: R,
+    index: RwLock<Option<Built<R::Stamp>>>,
+}
+
+struct Built<S> {
+    stamp: S,
+    names: NameIndex,
+}
+
+impl<R: Rows> Store<R> {
+    pub fn new(rows: R) -> Self {
+        Self {
+            rows,
+            index: RwLock::new(None),
+        }
+    }
+
+    pub fn rows(&self) -> &R {
+        &self.rows
+    }
+
+    /// Changes the rows in place. The index is rebuilt on the next query
+    pub fn edit<T>(&mut self, edit: impl FnOnce(&mut R) -> T) -> T {
+        let edited = edit(&mut self.rows);
+        *self.index.get_mut().unwrap_or_else(PoisonError::into_inner) = None;
+        edited
+    }
+
+    pub fn get(&self, key: &str) -> Option<Cow<'_, R::Row>> {
+        self.rows.row(key)
+    }
+
+    /// The key itself when present, otherwise the actual key that folds to the same name. Never a key the rows lack
+    pub fn find_key(&self, name: &str) -> Option<String> {
+        if self.rows.contains(name) {
+            return Some(name.to_owned());
+        }
+        let folded = R::fold(name);
+        let hit = self.query(|names| names.key_for(&folded).map(str::to_owned))?;
+        if self.rows.contains(&hit) {
+            return Some(hit);
+        }
+        self.invalidate();
+        self.query(|names| names.key_for(&folded).map(str::to_owned))
+            .filter(|key| self.rows.contains(key))
+    }
+
+    /// Keys whose group is exactly `group`, in row order. Never a key the rows lack
+    pub fn keys_in(&self, group: &str) -> Vec<String> {
+        self.query(|names| names.keys_in(group).to_vec())
+            .into_iter()
+            .filter(|key| self.rows.contains(key))
+            .collect()
+    }
+
+    /// Drops the index, for a source whose stamp cannot see every key change
+    pub fn invalidate(&self) {
+        *self.index.write().unwrap_or_else(PoisonError::into_inner) = None;
+    }
+
+    fn query<T>(&self, read: impl Fn(&NameIndex) -> T) -> T {
+        let stamp = self.rows.stamp();
+        if let Some(built) = self
+            .index
+            .read()
+            .unwrap_or_else(PoisonError::into_inner)
+            .as_ref()
+            .filter(|built| built.stamp == stamp)
+        {
+            return read(&built.names);
+        }
+        let names = NameIndex::scan(&self.rows);
+        let answer = read(&names);
+        *self.index.write().unwrap_or_else(PoisonError::into_inner) = Some(Built { stamp, names });
+        answer
+    }
+}
+
+impl<R: Rows + Clone> Clone for Store<R> {
+    fn clone(&self) -> Self {
+        Self::new(self.rows.clone())
+    }
+}
+
+impl<R: Rows + fmt::Debug> fmt::Debug for Store<R> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Store")
+            .field("rows", &self.rows)
+            .finish_non_exhaustive()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::cell::{Cell, RefCell};
+
+    use indexmap::IndexMap;
+    use rstest::{fixture, rstest};
+
+    use super::*;
+
+    const BUNDLED: &[(&str, Option<&str>)] = &[
+        ("gpt-4o", Some("openai")),
+        ("o3-pro", Some("openai")),
+        ("azure/gpt-4o", Some("azure")),
+        ("claude-sonnet-4-5", Some("anthropic")),
+        ("gemini-2.5-pro", Some("vertex_ai-language-models")),
+        (
+            "fireworks_ai/accounts/fireworks/models/llama-v3p1-8b-instruct",
+            Some("fireworks_ai"),
+        ),
+        (
+            "anyscale/meta-llama/Meta-Llama-3-8B-Instruct",
+            Some("anyscale"),
+        ),
+        ("sample_free_row", None),
+    ];
+
+    /// `litellm.model_cost` as Python sees it. The stamp is what python-bridge can observe for free, the dict's
+    /// identity and its length, so a write that keeps both hides a key change from the store
+    struct ModelCost {
+        dict: RefCell<IndexMap<String, Option<String>>>,
+        identity: Cell<u64>,
+        index_changes: Cell<u64>,
+        honest_stamp: bool,
+        scans: Cell<usize>,
+    }
+
+    impl ModelCost {
+        fn new(rows: &[(&str, Option<&str>)], honest_stamp: bool) -> Self {
+            Self {
+                dict: RefCell::new(
+                    rows.iter()
+                        .map(|(key, provider)| ((*key).to_owned(), provider.map(str::to_owned)))
+                        .collect(),
+                ),
+                identity: Cell::new(0),
+                index_changes: Cell::new(0),
+                honest_stamp,
+                scans: Cell::new(0),
+            }
+        }
+
+        /// `model_cost[key] = {"litellm_provider": provider, ...}`
+        fn set(&self, key: &str, provider: Option<&str>) {
+            let previous = self
+                .dict
+                .borrow_mut()
+                .insert(key.to_owned(), provider.map(str::to_owned));
+            if previous.as_ref().map(Option::as_deref) != Some(provider) {
+                self.index_changes.set(self.index_changes.get() + 1);
+            }
+        }
+
+        /// `del model_cost[key]`
+        fn del(&self, key: &str) {
+            if self.dict.borrow_mut().shift_remove(key).is_some() {
+                self.index_changes.set(self.index_changes.get() + 1);
+            }
+        }
+
+        /// `litellm.model_cost = {...}`, a new dict object
+        fn rebind(&self, rows: &[(&str, Option<&str>)]) {
+            *self.dict.borrow_mut() = rows
+                .iter()
+                .map(|(key, provider)| ((*key).to_owned(), provider.map(str::to_owned)))
+                .collect();
+            self.identity.set(self.identity.get() + 1);
+            self.index_changes.set(self.index_changes.get() + 1);
+        }
+    }
+
+    /// A row is its `litellm_provider`, which is also the group the store lists its key under
+    impl Rows for &ModelCost {
+        type Row = Option<String>;
+        type Stamp = (u64, u64);
+
+        fn fold(name: &str) -> String {
+            name.to_lowercase()
+        }
+
+        fn stamp(&self) -> Self::Stamp {
+            if self.honest_stamp {
+                (self.identity.get(), self.index_changes.get())
+            } else {
+                (self.identity.get(), self.dict.borrow().len() as u64)
+            }
+        }
+
+        fn contains(&self, key: &str) -> bool {
+            self.dict.borrow().contains_key(key)
+        }
+
+        fn row(&self, key: &str) -> Option<Cow<'_, Option<String>>> {
+            Some(Cow::Owned(self.dict.borrow().get(key)?.clone()))
+        }
+
+        fn scan(&self, visit: &mut dyn FnMut(&str, Option<&str>)) {
+            self.scans.set(self.scans.get() + 1);
+            for (key, provider) in self.dict.borrow().iter() {
+                visit(key, provider.as_deref());
+            }
+        }
+    }
+
+    #[fixture]
+    fn model_cost() -> ModelCost {
+        ModelCost::new(BUNDLED, false)
+    }
+
+    /// Rows only `Store::edit` can change, so the stamp never moves
+    #[derive(Debug)]
+    struct Owned(IndexMap<String, Option<String>>);
+
+    impl Rows for Owned {
+        type Row = Option<String>;
+        type Stamp = ();
+
+        fn fold(name: &str) -> String {
+            name.to_lowercase()
+        }
+
+        fn stamp(&self) -> Self::Stamp {}
+
+        fn contains(&self, key: &str) -> bool {
+            self.0.contains_key(key)
+        }
+
+        fn row(&self, key: &str) -> Option<Cow<'_, Option<String>>> {
+            self.0.get(key).map(Cow::Borrowed)
+        }
+
+        fn scan(&self, visit: &mut dyn FnMut(&str, Option<&str>)) {
+            for (key, provider) in &self.0 {
+                visit(key, provider.as_deref());
+            }
+        }
+    }
+
+    fn owned(rows: &[(&str, Option<&str>)]) -> Store<Owned> {
+        Store::new(Owned(
+            rows.iter()
+                .map(|(key, provider)| ((*key).to_owned(), provider.map(str::to_owned)))
+                .collect(),
+        ))
+    }
+
+    #[rstest]
+    #[case::bundled_key_as_written("gpt-4o", Some("gpt-4o"))]
+    #[case::user_typed_upper_case("GPT-4o", Some("gpt-4o"))]
+    #[case::provider_prefixed("Azure/GPT-4o", Some("azure/gpt-4o"))]
+    #[case::fireworks_path_in_another_case(
+        "fireworks_ai/accounts/fireworks/models/Llama-v3p1-8B-Instruct",
+        Some("fireworks_ai/accounts/fireworks/models/llama-v3p1-8b-instruct")
+    )]
+    #[case::mixed_case_bundled_key(
+        "anyscale/meta-llama/meta-llama-3-8b-instruct",
+        Some("anyscale/meta-llama/Meta-Llama-3-8B-Instruct")
+    )]
+    #[case::unmapped_model("my-finetune", None)]
+    #[case::prefix_is_not_a_match("gpt-4", None)]
+    fn find_key_maps_a_requested_model_to_its_key(
+        model_cost: ModelCost,
+        #[case] model: &str,
+        #[case] expected: Option<&str>,
+    ) {
+        assert_eq!(Store::new(&model_cost).find_key(model).as_deref(), expected);
+    }
+
+    #[rstest]
+    #[case::the_bundled_spelling("gpt-4o", "gpt-4o")]
+    #[case::the_registered_spelling("GPT-4o", "GPT-4o")]
+    #[case::another_spelling_takes_the_later_key("Gpt-4O", "GPT-4o")]
+    fn a_registered_case_variant_is_its_own_row(
+        model_cost: ModelCost,
+        #[case] model: &str,
+        #[case] expected: &str,
+    ) {
+        model_cost.set("GPT-4o", Some("openai"));
+        assert_eq!(
+            Store::new(&model_cost).find_key(model).as_deref(),
+            Some(expected)
+        );
+    }
+
+    #[rstest]
+    #[case::openai_in_map_order("openai", &["gpt-4o", "o3-pro"])]
+    #[case::azure("azure", &["azure/gpt-4o"])]
+    #[case::raw_vertex_family("vertex_ai-language-models", &["gemini-2.5-pro"])]
+    #[case::provider_alias_is_python_s_job("vertex_ai", &[])]
+    #[case::matched_as_written("OpenAI", &[])]
+    #[case::unknown_provider("acme", &[])]
+    fn keys_in_lists_the_keys_a_raw_provider_names(
+        model_cost: ModelCost,
+        #[case] provider: &str,
+        #[case] expected: &[&str],
+    ) {
+        assert_eq!(Store::new(&model_cost).keys_in(provider), expected);
+    }
+
+    #[rstest]
+    fn a_model_written_straight_into_the_dict_is_found_in_any_case(model_cost: ModelCost) {
+        let store = Store::new(&model_cost);
+        assert_eq!(store.find_key("mycorp/custom-model"), None);
+
+        model_cost.set("MyCorp/Custom-Model", Some("openai"));
+
+        assert_eq!(
+            store.find_key("mycorp/custom-model").as_deref(),
+            Some("MyCorp/Custom-Model")
+        );
+        assert_eq!(
+            store.keys_in("openai"),
+            ["gpt-4o", "o3-pro", "MyCorp/Custom-Model"]
+        );
+    }
+
+    #[rstest]
+    fn a_price_edit_reuses_the_index(model_cost: ModelCost) {
+        let store = Store::new(&model_cost);
+        assert_eq!(store.find_key("GPT-4o").as_deref(), Some("gpt-4o"));
+
+        model_cost.set("gpt-4o", Some("openai"));
+        model_cost.set("o3-pro", Some("openai"));
+        model_cost.set("gpt-4o", Some("openai"));
+
+        assert_eq!(store.find_key("O3-PRO").as_deref(), Some("o3-pro"));
+        assert_eq!(store.keys_in("openai"), ["gpt-4o", "o3-pro"]);
+        assert_eq!(model_cost.scans.get(), 1);
+    }
+
+    #[rstest]
+    fn a_reload_that_rebinds_the_dict_is_seen_even_at_the_same_length(model_cost: ModelCost) {
+        let store = Store::new(&model_cost);
+        assert_eq!(store.find_key("GPT-4o").as_deref(), Some("gpt-4o"));
+
+        let mut reloaded = BUNDLED.to_vec();
+        reloaded[0] = ("gpt-4o-2024-11-20", Some("openai"));
+        model_cost.rebind(&reloaded);
+
+        assert_eq!(store.find_key("GPT-4o"), None);
+        assert_eq!(
+            store.find_key("GPT-4o-2024-11-20").as_deref(),
+            Some("gpt-4o-2024-11-20")
+        );
+    }
+
+    #[rstest]
+    fn a_deleted_model_is_never_returned(model_cost: ModelCost) {
+        let store = Store::new(&model_cost);
+        assert_eq!(store.find_key("O3-PRO").as_deref(), Some("o3-pro"));
+
+        model_cost.del("o3-pro");
+
+        assert_eq!(store.find_key("O3-PRO"), None);
+        assert_eq!(store.keys_in("openai"), ["gpt-4o"]);
+    }
+
+    #[rstest]
+    fn a_respelled_key_at_the_same_length_is_found_after_one_rebuild(model_cost: ModelCost) {
+        let store = Store::new(&model_cost);
+        assert_eq!(store.find_key("o3-PRO").as_deref(), Some("o3-pro"));
+
+        model_cost.del("o3-pro");
+        model_cost.set("O3-Pro", Some("openai"));
+
+        assert_eq!(store.find_key("o3-PRO").as_deref(), Some("O3-Pro"));
+        assert_eq!(model_cost.scans.get(), 2);
+    }
+
+    #[rstest]
+    fn a_swap_at_the_same_length_hides_the_new_key_until_invalidate(model_cost: ModelCost) {
+        let store = Store::new(&model_cost);
+        assert_eq!(store.find_key("O3-PRO").as_deref(), Some("o3-pro"));
+
+        model_cost.del("o3-pro");
+        model_cost.set("MyCorp/Custom-Model", Some("openai"));
+
+        assert_eq!(store.find_key("mycorp/custom-model"), None);
+        assert_eq!(store.keys_in("openai"), ["gpt-4o"]);
+
+        store.invalidate();
+
+        assert_eq!(
+            store.find_key("mycorp/custom-model").as_deref(),
+            Some("MyCorp/Custom-Model")
+        );
+        assert_eq!(store.keys_in("openai"), ["gpt-4o", "MyCorp/Custom-Model"]);
+    }
+
+    #[rstest]
+    fn a_provider_rewrite_on_an_existing_key_needs_invalidate(model_cost: ModelCost) {
+        let store = Store::new(&model_cost);
+        assert_eq!(store.keys_in("openai"), ["gpt-4o", "o3-pro"]);
+
+        model_cost.set("o3-pro", Some("azure"));
+
+        assert_eq!(store.keys_in("openai"), ["gpt-4o", "o3-pro"]);
+
+        store.invalidate();
+
+        assert_eq!(store.keys_in("openai"), ["gpt-4o"]);
+        assert_eq!(store.keys_in("azure"), ["o3-pro", "azure/gpt-4o"]);
+    }
+
+    #[rstest]
+    fn an_edit_on_owned_rows_is_seen_by_the_next_query() {
+        let mut store = owned(BUNDLED);
+        assert_eq!(store.find_key("GPT-4o").as_deref(), Some("gpt-4o"));
+
+        store.edit(|rows| {
+            rows.0.shift_remove("gpt-4o");
+            rows.0
+                .insert("MyCorp/Custom-Model".to_owned(), Some("openai".to_owned()));
+        });
+
+        assert_eq!(store.find_key("GPT-4o"), None);
+        assert_eq!(
+            store.find_key("mycorp/custom-model").as_deref(),
+            Some("MyCorp/Custom-Model")
+        );
+        assert_eq!(store.keys_in("openai"), ["o3-pro", "MyCorp/Custom-Model"]);
+    }
+
+    #[rstest]
+    fn get_reads_the_row_by_exact_key_only() {
+        let store = owned(BUNDLED);
+        assert_eq!(
+            store.get("azure/gpt-4o").as_deref(),
+            Some(&Some("azure".to_owned()))
+        );
+        assert_eq!(store.get("Azure/GPT-4o"), None);
+    }
+}
diff --git a/litellm-rust/crates/model-catalog/src/store/name_index.rs b/litellm-rust/crates/model-catalog/src/store/name_index.rs
new file mode 100644
index 00000000000..86f05cb31af
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/store/name_index.rs
@@ -0,0 +1,35 @@
+use std::collections::HashMap;
+
+use super::Rows;
+
+/// Keys only, never rows, so a value write never makes it stale. A later key wins when two keys fold to one name
+#[derive(Debug, Default)]
+pub(super) struct NameIndex {
+    by_folded: HashMap<String, String>,
+    by_group: HashMap<String, Vec<String>>,
+}
+
+impl NameIndex {
+    pub(super) fn scan<R: Rows>(rows: &R) -> Self {
+        let mut index = Self::default();
+        rows.scan(&mut |key, group| {
+            index.by_folded.insert(R::fold(key), key.to_owned());
+            if let Some(group) = group {
+                index
+                    .by_group
+                    .entry(group.to_owned())
+                    .or_default()
+                    .push(key.to_owned());
+            }
+        });
+        index
+    }
+
+    pub(super) fn key_for(&self, folded: &str) -> Option<&str> {
+        self.by_folded.get(folded).map(String::as_str)
+    }
+
+    pub(super) fn keys_in(&self, group: &str) -> &[String] {
+        self.by_group.get(group).map_or(&[], Vec::as_slice)
+    }
+}
diff --git a/litellm-rust/crates/model-catalog/src/validation.rs b/litellm-rust/crates/model-catalog/src/validation.rs
deleted file mode 100644
index 6dd4174148c..00000000000
--- a/litellm-rust/crates/model-catalog/src/validation.rs
+++ /dev/null
@@ -1,252 +0,0 @@
-use std::collections::BTreeSet;
-
-use serde_json::{Map, Value};
-use thiserror::Error;
-
-use crate::{AliasIssue, Catalog, ModelInfo, UtcHours, Weekday};
-
-#[derive(Debug, Error)]
-pub enum RegistryValidationError {
-    #[error("invalid registry entry {model:?}")]
-    Entry {
-        model: String,
-        #[source]
-        reason: EntryViolation,
-    },
-    #[error(transparent)]
-    Alias(AliasIssue),
-}
-
-#[derive(Debug, Error)]
-pub enum EntryViolation {
-    #[error("entry must be an object")]
-    NotObject,
-    #[error("aliases must be an array")]
-    AliasesNotArray,
-    #[error("aliases must contain strings")]
-    AliasNotString,
-    #[error("entry does not match the model schema")]
-    Schema(#[source] serde_json::Error),
-    #[error("litellm_provider is required")]
-    MissingProvider,
-    #[error("invalid deprecation_date")]
-    DeprecationDate(#[source] time::error::Parse),
-    #[error("off_peak_pricing needs hours or windows")]
-    OffPeakWithoutHours,
-    #[error("off_peak_pricing.hours_utc is invalid")]
-    InvalidHours,
-    #[error("off_peak_pricing.windows is empty")]
-    EmptyWindows,
-    #[error("off_peak_pricing.weekdays is invalid")]
-    InvalidWeekdays,
-    #[error("typed entry could not be serialized")]
-    Serialize(#[source] serde_json::Error),
-    #[error("entry has an unknown field, null, or changed value: {}", fields.join(", "))]
-    ChangedFields { fields: Vec<String> },
-    #[error("{field} must be nonnegative")]
-    Negative { field: String },
-    #[error("{field} must be at least one")]
-    UpliftBelowOne { field: String },
-}
-
-pub fn validate_model_entry(model: &str, value: &Value) -> Result<(), RegistryValidationError> {
-    validate_entry_inner(value).map_err(|reason| RegistryValidationError::Entry {
-        model: model.to_owned(),
-        reason,
-    })
-}
-
-pub fn validate_registry(catalog: &Catalog) -> Result<(), RegistryValidationError> {
-    if let Some(issue) = catalog.alias_issues().first() {
-        return Err(RegistryValidationError::Alias(issue.clone()));
-    }
-    catalog.model_names().try_for_each(|name| {
-        let entry = catalog.lookup(name).expect("catalog name must resolve");
-        validate_model_entry(name, &Value::Object(entry.entry.fields().clone()))
-    })
-}
-
-fn json_eq(left: &Value, right: &Value) -> bool {
-    match (left, right) {
-        (Value::Number(left), Value::Number(right)) => left.as_f64() == right.as_f64(),
-        (Value::Array(left), Value::Array(right)) => {
-            left.len() == right.len() && left.iter().zip(right).all(|(a, b)| json_eq(a, b))
-        }
-        (Value::Object(left), Value::Object(right)) => {
-            left.len() == right.len()
-                && left
-                    .iter()
-                    .all(|(key, value)| right.get(key).is_some_and(|other| json_eq(value, other)))
-        }
-        _ => left == right,
-    }
-}
-
-fn keys(value: &Map<String, Value>) -> BTreeSet<String> {
-    value.keys().cloned().collect()
-}
-
-fn symmetric_difference(left: &BTreeSet<String>, right: &BTreeSet<String>) -> Vec<String> {
-    left.symmetric_difference(right).cloned().collect()
-}
-
-fn validate_entry_inner(value: &Value) -> Result<(), EntryViolation> {
-    let object = value.as_object().ok_or(EntryViolation::NotObject)?;
-    if let Some(aliases) = object.get("aliases") {
-        let names = aliases.as_array().ok_or(EntryViolation::AliasesNotArray)?;
-        if names.iter().any(|name| !name.is_string()) {
-            return Err(EntryViolation::AliasNotString);
-        }
-    }
-    let info: ModelInfo = serde_json::from_value(value.clone()).map_err(EntryViolation::Schema)?;
-    if info.litellm_provider.is_none() {
-        return Err(EntryViolation::MissingProvider);
-    }
-    validate_dates_and_windows(&info)?;
-    let serialized = serde_json::to_value(info).map_err(EntryViolation::Serialize)?;
-    let mut expected = object.clone();
-    expected.remove("aliases");
-    if !json_eq(&Value::Object(expected.clone()), &serialized) {
-        let actual = serialized
-            .as_object()
-            .expect("ModelInfo serializes as an object");
-        return Err(EntryViolation::ChangedFields {
-            fields: symmetric_difference(&keys(&expected), &keys(actual)),
-        });
-    }
-    check_prices("", value)
-}
-
-fn validate_dates_and_windows(info: &ModelInfo) -> Result<(), EntryViolation> {
-    if let Some(date) = &info.deprecation_date {
-        let format = time::format_description::parse_borrowed::<2>("[year]-[month]-[day]").unwrap();
-        time::Date::parse(date, &format).map_err(EntryViolation::DeprecationDate)?;
-    }
-    let Some(pricing) = &info.off_peak_pricing else {
-        return Ok(());
-    };
-    if pricing.hours_utc.is_none() && pricing.windows.is_none() {
-        return Err(EntryViolation::OffPeakWithoutHours);
-    }
-    if let Some(hours) = &pricing.hours_utc {
-        validate_hours(hours)?;
-    }
-    if let Some(windows) = &pricing.windows {
-        if windows.is_empty() {
-            return Err(EntryViolation::EmptyWindows);
-        }
-        windows.iter().try_for_each(|window| {
-            validate_hours(&window.hours_utc)?;
-            if let Some(days) = &window.weekdays
-                && (days.is_empty() || days.iter().any(|day| !valid_weekday(day)))
-            {
-                return Err(EntryViolation::InvalidWeekdays);
-            }
-            Ok(())
-        })?;
-    }
-    Ok(())
-}
-
-fn validate_hours(hours: &UtcHours) -> Result<(), EntryViolation> {
-    let values = match hours {
-        UtcHours::Single(value) => std::slice::from_ref(value),
-        UtcHours::Multiple(values) => values.as_slice(),
-    };
-    if values.is_empty() || values.iter().any(|value| !valid_utc_window(value)) {
-        return Err(EntryViolation::InvalidHours);
-    }
-    Ok(())
-}
-
-fn valid_utc_window(value: &str) -> bool {
-    let Some((start, end)) = value.split_once('-') else {
-        return false;
-    };
-    [start, end].into_iter().all(|clock| {
-        let Some((hour, minute)) = clock.split_once(':') else {
-            return false;
-        };
-        hour.len() == 2
-            && minute.len() == 2
-            && hour.parse::<u8>().is_ok_and(|hour| hour < 24)
-            && minute.parse::<u8>().is_ok_and(|minute| minute < 60)
-    })
-}
-
-fn valid_weekday(day: &Weekday) -> bool {
-    match day {
-        Weekday::Number(number) => (1..=7).contains(number),
-        Weekday::Name(name) => matches!(
-            name.to_ascii_lowercase().as_str(),
-            "mon"
-                | "monday"
-                | "tue"
-                | "tues"
-                | "tuesday"
-                | "wed"
-                | "wednesday"
-                | "thu"
-                | "thur"
-                | "thurs"
-                | "thursday"
-                | "fri"
-                | "friday"
-                | "sat"
-                | "saturday"
-                | "sun"
-                | "sunday"
-        ),
-    }
-}
-
-fn check_prices(path: &str, value: &Value) -> Result<(), EntryViolation> {
-    let Some(object) = value.as_object() else {
-        return Ok(());
-    };
-    object.iter().try_for_each(|(key, field)| {
-        let field_path = format!("{path}.{key}");
-        if (key.contains("cost")
-            || path.ends_with(".guardrail_cost_per_unit")
-            || path.ends_with(".search_context_cost_per_query"))
-            && let Some(number) = field.as_f64()
-            && number < 0.0
-        {
-            return Err(EntryViolation::Negative {
-                field: relative(&field_path),
-            });
-        }
-        if key.contains("uplift_multiplier")
-            && let Some(number) = field.as_f64()
-            && number < 1.0
-        {
-            return Err(EntryViolation::UpliftBelowOne {
-                field: relative(&field_path),
-            });
-        }
-        if matches!(key.as_str(), "range" | "max_results_range")
-            && field.as_array().is_some_and(|values| {
-                values
-                    .iter()
-                    .any(|value| value.as_f64().is_some_and(|n| n < 0.0))
-            })
-        {
-            return Err(EntryViolation::Negative {
-                field: relative(&field_path),
-            });
-        }
-        if matches!(key.as_str(), "metadata" | "provider_specific_entry") {
-            return Ok(());
-        }
-        match field.as_array() {
-            Some(items) => items.iter().enumerate().try_for_each(|(index, item)| {
-                check_prices(&format!("{field_path}[{index}]"), item)
-            }),
-            None => check_prices(&field_path, field),
-        }
-    })
-}
-
-fn relative(field_path: &str) -> String {
-    field_path.trim_start_matches('.').to_owned()
-}
diff --git a/litellm-rust/crates/model-catalog/src/vocabulary.rs b/litellm-rust/crates/model-catalog/src/vocabulary.rs
new file mode 100644
index 00000000000..2b7ac8bd1ab
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/vocabulary.rs
@@ -0,0 +1,126 @@
+/// Primary API surface / task type of the model.
+#[macro_rules_attribute::apply(crate::wire_type)]
+#[derive(Copy, Eq, Hash)]
+#[serde(rename_all = "snake_case")]
+pub enum Mode {
+    AudioSpeech,
+    AudioTranscription,
+    Chat,
+    Completion,
+    Decisions,
+    Embedding,
+    Evaluation,
+    Extraction,
+    Guardrail,
+    ImageEdit,
+    ImageGeneration,
+    Moderation,
+    Ocr,
+    Realtime,
+    Rerank,
+    Responses,
+    Search,
+    VectorStore,
+    VideoGeneration,
+}
+
+/// Gemini audio generation API the model is served through.
+#[macro_rules_attribute::apply(crate::wire_type)]
+#[derive(Copy, Eq, Hash)]
+#[serde(rename_all = "snake_case")]
+pub enum VertexAiAudioApi {
+    LyriaPredict,
+    LyriaInteractions,
+}
+
+/// Audio container format the model can return.
+#[macro_rules_attribute::apply(crate::wire_type)]
+#[derive(Copy, Eq, Hash)]
+#[serde(rename_all = "snake_case")]
+pub enum AudioFormat {
+    Mp3,
+    Wav,
+}
+
+/// Input modality the model accepts.
+#[macro_rules_attribute::apply(crate::wire_type)]
+#[derive(Copy, Eq, Hash)]
+#[serde(rename_all = "snake_case")]
+pub enum InputModality {
+    Text,
+    Image,
+    Audio,
+    Video,
+}
+
+/// Output modality the model can produce.
+#[macro_rules_attribute::apply(crate::wire_type)]
+#[derive(Copy, Eq, Hash)]
+#[serde(rename_all = "snake_case")]
+pub enum OutputModality {
+    Text,
+    Image,
+    Audio,
+    Video,
+    Code,
+}
+
+/// API route a model can be called through.
+#[macro_rules_attribute::apply(crate::wire_type)]
+#[derive(Copy, Eq, Hash)]
+pub enum Endpoint {
+    #[serde(rename = "/v1/chat/completions")]
+    ChatCompletions,
+    #[serde(rename = "/v1/completions")]
+    Completions,
+    #[serde(rename = "/v1/responses")]
+    Responses,
+    #[serde(rename = "/v1/messages")]
+    Messages,
+    #[serde(rename = "/v1/batch")]
+    Batch,
+    #[serde(rename = "/v1/embeddings")]
+    Embeddings,
+    #[serde(rename = "/v1/images/generations")]
+    ImageGenerations,
+    #[serde(rename = "/v1/images/edits")]
+    ImageEdits,
+    #[serde(rename = "/v1/audio/speech")]
+    AudioSpeech,
+    #[serde(rename = "/v1/audio/transcriptions")]
+    AudioTranscriptions,
+    #[serde(rename = "/v1/realtime")]
+    Realtime,
+    #[serde(rename = "/v1/realtime/transcription_sessions")]
+    RealtimeTranscriptionSessions,
+    #[serde(rename = "/v1/videos")]
+    Videos,
+    #[serde(rename = "/v1/ocr")]
+    Ocr,
+    #[serde(rename = "/v1/listen")]
+    Listen,
+    #[serde(rename = "/v1/systemone")]
+    SystemOne,
+    #[serde(rename = "/v1/decisions")]
+    Decisions,
+    #[serde(rename = "/v1beta/interactions")]
+    Interactions,
+    #[serde(rename = "/v1beta/models")]
+    Models,
+    #[serde(rename = "/vertex_ai/live")]
+    VertexAiLive,
+}
+
+/// Reasoning effort level a model accepts or applies.
+#[macro_rules_attribute::apply(crate::wire_type)]
+#[derive(Copy, Eq, Hash)]
+#[serde(rename_all = "snake_case")]
+pub enum EffortLevel {
+    None,
+    Minimal,
+    Low,
+    Medium,
+    High,
+    Xhigh,
+    Max,
+}
diff --git a/litellm-rust/crates/model-catalog/src/wire/attributes.rs b/litellm-rust/crates/model-catalog/src/wire/attributes.rs
new file mode 100644
index 00000000000..93c10a81524
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/wire/attributes.rs
@@ -0,0 +1,344 @@
+use std::collections::BTreeMap;
+use std::fmt;
+use std::str::FromStr;
+
+use litellm_cost::money::UnitPrice;
+use serde::de::{self, Deserializer};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use crate::error::{DateCause, Error, Repr};
+use crate::vocabulary::{
+    AudioFormat, EffortLevel, Endpoint, InputModality, Mode, OutputModality, VertexAiAudioApi,
+};
+use crate::wire::lax::Count;
+
+macro_rules! attributes {
+    ($($(#[$doc:meta])* $name:ident: $ty:ty $(as $via:ty)?),* $(,)?) => {
+        /// The named, non-price fields of a catalog entry.
+        #[derive(Clone, Debug, Default, PartialEq)]
+        #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+        pub struct Attributes {
+            $($(#[$doc])* pub $name: Option<$ty>,)*
+        }
+
+        impl Attributes {
+            pub(crate) fn read(
+                &mut self,
+                key: &str,
+                value: &Value,
+            ) -> Option<Result<(), serde_json::Error>> {
+                match key {
+                    $(stringify!($name) => Some(
+                        attributes!(@read value, $ty $(, $via)?).map(|read| self.$name = Some(read)),
+                    ),)*
+                    _ => None,
+                }
+            }
+        }
+    };
+    (@read $value:ident, $ty:ty) => {
+        <$ty as Deserialize>::deserialize($value)
+    };
+    (@read $value:ident, $ty:ty, $via:ty) => {
+        serde_with::de::DeserializeAsWrap::<$ty, $via>::deserialize($value)
+            .map(serde_with::de::DeserializeAsWrap::into_inner)
+    };
+}
+
+attributes! {
+    /// Other names this entry is served under.
+    aliases: Vec<String>,
+    audio_transcription_config: String,
+    bedrock_converse_supports_strict_tools: bool,
+    /// Highest reasoning effort the Bedrock output_config accepts for this model.
+    bedrock_output_config_effort_ceiling: EffortLevel,
+    comment: String,
+    /// Reasoning effort the provider applies when the request omits reasoning_effort. Gates whether a non-default temperature or the top_p/logprobs sampling params are accepted, which hold only when the effort resolves to 'none'.
+    default_reasoning_effort: EffortLevel,
+    /// Date the provider deprecates the model, YYYY-MM-DD.
+    deprecation_date: IsoDate,
+    gemini_audio_only_live: bool,
+    gemini_native_audio: bool,
+    input_cost_per_token_cache_hit: UnitPrice,
+    /// Databricks units, not USD.
+    input_dbu_cost_per_token: Dbu,
+    /// LiteLLM provider slug; one of https://docs.litellm.ai/docs/providers.
+    litellm_provider: String,
+    /// Maximum prompt/context tokens the model accepts.
+    max_input_tokens: u64 as Count,
+    /// Maximum tokens the model can generate in one response.
+    max_output_tokens: u64 as Count,
+    /// Legacy field: max output tokens if the provider specifies it, else max input tokens.
+    max_tokens: u64 as Count,
+    /// Free-form notes about the entry (e.g. pricing derivation).
+    metadata: BTreeMap<String, Value>,
+    /// Primary API surface / task type of the model.
+    mode: Mode,
+    /// Databricks units, not USD.
+    output_dbu_cost_per_token: Dbu,
+    /// Embedding dimension for embedding models.
+    output_vector_size: u64 as Count,
+    /// Smallest prefix the provider will actually cache; absent means the provider default applies.
+    prompt_cache_min_tokens: u64 as Count,
+    /// Provider-internal routing hints (e.g. bedrock_invocation_schema).
+    provider_specific_entry: BTreeMap<String, Value>,
+    reasoning_contexts: Vec<String>,
+    /// Exact reasoning_effort levels this deployment accepts; wins over supports_* flags.
+    reasoning_effort_levels: Vec<EffortLevel>,
+    reasoning_modes: Vec<String>,
+    /// Provider default requests-per-minute limit.
+    rpm: u64 as Count,
+    /// Grounded search requests the provider includes for free before search is billed.
+    search_free_requests: SearchFreeRequests,
+    /// URL of the provider pricing/model page this entry was taken from.
+    source: String,
+    /// Audio container formats the model can return.
+    supported_audio_formats: Vec<AudioFormat>,
+    /// OpenAI-style API routes this model can be called through, e.g. /v1/chat/completions.
+    supported_endpoints: Vec<Endpoint>,
+    /// Input modalities the model accepts.
+    supported_modalities: Vec<InputModality>,
+    /// Output modalities the model can produce.
+    supported_output_modalities: Vec<OutputModality>,
+    /// Cloud regions the model is available in ('global' or region ids).
+    supported_regions: Vec<String>,
+    thinking_always_on: bool,
+    token_count_framing: u64 as Count,
+    token_count_model: TokenCountModel,
+    token_count_tokenizer: TokenCountTokenizer,
+    /// Provider default tokens-per-minute limit.
+    tpm: u64 as Count,
+    use_openai_responses_path: bool,
+    uses_embed_content: bool,
+    vertex_ai_audio_api: VertexAiAudioApi,
+    /// Whether web search is billed per query or per prompt.
+    web_search_billing_unit: WebSearchBillingUnit,
+}
+
+/// The model whose provider token counter counts tokens for this entry.
+#[macro_rules_attribute::apply(crate::wire_type)]
+#[derive(Eq, Hash)]
+#[serde(deny_unknown_fields)]
+pub struct TokenCountModel {
+    pub model: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub litellm_provider: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub region: Option<String>,
+}
+
+/// Free grounded search requests per period, shared across the models of one group.
+#[macro_rules_attribute::apply(crate::wire_type)]
+#[derive(Eq, Hash)]
+#[serde(deny_unknown_fields)]
+pub struct SearchFreeRequests {
+    pub count: u64,
+    pub period: FreeRequestPeriod,
+    pub shared_group: String,
+}
+
+#[macro_rules_attribute::apply(crate::wire_type)]
+#[derive(Copy, Eq, Hash)]
+#[serde(rename_all = "snake_case")]
+pub enum FreeRequestPeriod {
+    Day,
+    Month,
+}
+
+/// Local tokenizer that counts tokens for this entry.
+#[macro_rules_attribute::apply(crate::wire_type)]
+#[derive(Copy, Eq, Hash)]
+#[serde(rename_all = "snake_case")]
+pub enum TokenCountTokenizer {
+    KimiK3,
+}
+
+/// Whether web search is billed per query or per prompt.
+#[macro_rules_attribute::apply(crate::wire_type)]
+#[derive(Copy, Eq, Hash)]
+#[serde(rename_all = "snake_case")]
+pub enum WebSearchBillingUnit {
+    PerQuery,
+    PerPrompt,
+}
+
+/// A non-negative amount of Databricks units.
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Serialize)]
+#[serde(transparent)]
+pub struct Dbu(f64);
+
+impl Dbu {
+    pub fn new(units: f64) -> Option<Self> {
+        (units.is_finite() && units >= 0.0).then_some(Self(units))
+    }
+    pub fn get(self) -> f64 {
+        self.0
+    }
+}
+
+impl<'de> Deserialize<'de> for Dbu {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        let units = f64::deserialize(deserializer)?;
+        Self::new(units).ok_or_else(|| {
+            de::Error::invalid_value(
+                de::Unexpected::Float(units),
+                &"a non-negative number of Databricks units",
+            )
+        })
+    }
+}
+
+/// A calendar date written YYYY-MM-DD.
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    serde_with::DeserializeFromStr,
+    serde_with::SerializeDisplay,
+)]
+pub struct IsoDate(pub time::Date);
+
+impl FromStr for IsoDate {
+    type Err = Error;
+
+    fn from_str(date: &str) -> Result<Self, Self::Err> {
+        let mut parts = date.split('-');
+        let (Some(year), Some(month), Some(day), None) =
+            (parts.next(), parts.next(), parts.next(), parts.next())
+        else {
+            return Err(Repr::InvalidDate { cause: None }.into());
+        };
+        if year.len() != 4 || month.len() != 2 || day.len() != 2 {
+            return Err(Repr::InvalidDate { cause: None }.into());
+        }
+        let number = |part: &str| part.parse::<u8>().map_err(DateCause::from);
+        let month = time::Month::try_from(number(month)?).map_err(DateCause::from)?;
+        time::Date::from_calendar_date(year.parse().map_err(DateCause::from)?, month, number(day)?)
+            .map(Self)
+            .map_err(DateCause::from)
+            .map_err(Error::from)
+    }
+}
+
+impl fmt::Display for IsoDate {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{:04}-{:02}-{:02}",
+            self.0.year(),
+            u8::from(self.0.month()),
+            self.0.day()
+        )
+    }
+}
+
+#[cfg(feature = "schema")]
+mod schema {
+    use std::borrow::Cow;
+
+    use schemars::{JsonSchema, Schema, SchemaGenerator, json_schema};
+
+    use super::{Dbu, IsoDate};
+
+    impl JsonSchema for IsoDate {
+        fn inline_schema() -> bool {
+            true
+        }
+        fn schema_name() -> Cow<'static, str> {
+            "IsoDate".into()
+        }
+        fn json_schema(_: &mut SchemaGenerator) -> Schema {
+            json_schema!({
+                "type": "string",
+                "format": "date",
+                "pattern": r"^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$"
+            })
+        }
+    }
+
+    impl JsonSchema for Dbu {
+        fn inline_schema() -> bool {
+            true
+        }
+        fn schema_name() -> Cow<'static, str> {
+            "Dbu".into()
+        }
+        fn json_schema(_: &mut SchemaGenerator) -> Schema {
+            json_schema!({"type": "number", "minimum": 0})
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+    use serde_json::json;
+
+    use super::*;
+
+    #[rstest]
+    #[case::leap_day("2028-02-29", true)]
+    #[case::not_a_leap_year("2026-02-29", false)]
+    #[case::impossible_day("2026-02-31", false)]
+    #[case::one_digit_month("2026-2-01", false)]
+    #[case::extra_part("2026-02-01-01", false)]
+    fn iso_dates_are_real_calendar_dates(#[case] text: &str, #[case] valid: bool) {
+        assert_eq!(text.parse::<IsoDate>().is_ok(), valid);
+    }
+
+    #[rstest]
+    #[case::count_written_as_text("max_tokens", json!("8192"), true)]
+    #[case::negative_count("max_tokens", json!(-1), false)]
+    #[case::known_mode("mode", json!("chat"), true)]
+    #[case::unknown_mode("mode", json!("chatt"), false)]
+    #[case::negative_dbu("input_dbu_cost_per_token", json!(-1), false)]
+    #[case::reasoning_contexts("reasoning_contexts", json!(["reasoning", "non_reasoning"]), true)]
+    #[case::reasoning_modes("reasoning_modes", json!(["none", "adaptive"]), true)]
+    #[case::reasoning_context_not_a_list("reasoning_contexts", json!("reasoning"), false)]
+    #[case::reasoning_mode_not_a_string("reasoning_modes", json!([1]), false)]
+    fn each_attribute_reads_its_own_type(
+        #[case] key: &str,
+        #[case] value: Value,
+        #[case] valid: bool,
+    ) {
+        assert_eq!(
+            Attributes::default()
+                .read(key, &value)
+                .map(|read| read.is_ok()),
+            Some(valid)
+        );
+    }
+
+    #[rstest]
+    fn keys_that_are_not_attributes_are_left_to_the_caller() {
+        assert!(
+            Attributes::default()
+                .read("input_cost_per_token", &json!(1))
+                .is_none()
+        );
+    }
+
+    #[rstest]
+    fn reasoning_metadata_is_retained() {
+        let mut attributes = Attributes::default();
+        attributes
+            .read("reasoning_contexts", &json!(["reasoning", "non_reasoning"]))
+            .unwrap()
+            .unwrap();
+        attributes
+            .read("reasoning_modes", &json!(["none", "adaptive"]))
+            .unwrap()
+            .unwrap();
+        assert_eq!(
+            attributes.reasoning_contexts.unwrap(),
+            ["reasoning", "non_reasoning"]
+        );
+        assert_eq!(attributes.reasoning_modes.unwrap(), ["none", "adaptive"]);
+    }
+}
diff --git a/litellm-rust/crates/model-catalog/src/wire/blocks.rs b/litellm-rust/crates/model-catalog/src/wire/blocks.rs
new file mode 100644
index 00000000000..3a355686b7c
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/wire/blocks.rs
@@ -0,0 +1,182 @@
+use litellm_cost::money::UnitPrice;
+use litellm_cost::schedule::{UtcWindow, Weekday};
+use serde::Deserialize;
+use serde::de::DeserializeOwned;
+use serde_json::{Map, Value};
+use serde_with::de::DeserializeAsWrap;
+
+use crate::error::{Error, Repr, pointer_child, pointer_for_key};
+use crate::wire::flat_key::FlatKey;
+use crate::wire::lax::Count;
+
+/// A flat price key with its spelling, kept so problems can name it.
+#[derive(Clone, Debug, PartialEq)]
+pub struct FlatPrice {
+    pub key: String,
+    pub path: String,
+    pub flat: FlatKey,
+    pub price: UnitPrice,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct TierRow {
+    pub path: String,
+    pub range: Option<[u64; 2]>,
+    pub max_results_range: Option<[u64; 2]>,
+    pub prices: Vec<FlatPrice>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct OffPeakBlock {
+    pub hours_utc: Option<UtcHours>,
+    pub windows: Option<Vec<OffPeakWindow>>,
+    pub weekday_timezone: Option<String>,
+    pub prices: Vec<FlatPrice>,
+}
+
+/// One UTC window or a list of them.
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[serde(untagged)]
+pub enum UtcHours {
+    Single(UtcWindow),
+    Multiple(Vec<UtcWindow>),
+}
+
+/// One off-peak window entry inside `windows`.
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[serde(deny_unknown_fields)]
+pub struct OffPeakWindow {
+    pub hours_utc: UtcHours,
+    pub weekdays: Option<Vec<Weekday>>,
+}
+
+/// USD cost per web search query, keyed by search context size.
+#[derive(Clone, Debug, Default, PartialEq, Deserialize)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[serde(deny_unknown_fields)]
+pub struct SearchContextCostPerQuery {
+    pub search_context_size_low: Option<UnitPrice>,
+    pub search_context_size_medium: Option<UnitPrice>,
+    pub search_context_size_high: Option<UnitPrice>,
+}
+
+impl UtcHours {
+    pub fn windows(&self) -> &[UtcWindow] {
+        match self {
+            Self::Single(window) => std::slice::from_ref(window),
+            Self::Multiple(windows) => windows,
+        }
+    }
+}
+
+pub(crate) struct Reader<'a> {
+    pub(crate) problems: &'a mut Vec<Error>,
+}
+
+impl Reader<'_> {
+    pub(crate) fn value<T: DeserializeOwned>(&mut self, path: String, value: &Value) -> Option<T> {
+        T::deserialize(value)
+            .map_err(|error| self.problems.push(Error::new(path, Repr::Invalid(error))))
+            .ok()
+    }
+
+    pub(crate) fn price(
+        &mut self,
+        key: String,
+        path: String,
+        flat: FlatKey,
+        value: &Value,
+    ) -> Option<FlatPrice> {
+        let price = self.value(path.clone(), value)?;
+        Some(FlatPrice {
+            key,
+            path,
+            flat,
+            price,
+        })
+    }
+
+    fn object<'v>(&mut self, path: &str, value: &'v Value) -> Option<&'v Map<String, Value>> {
+        match value {
+            Value::Object(fields) => Some(fields),
+            other => self
+                .value::<Map<String, Value>>(path.to_owned(), other)
+                .and(None),
+        }
+    }
+
+    fn block_price(
+        &mut self,
+        name: &str,
+        key: String,
+        path: String,
+        value: &Value,
+    ) -> Option<FlatPrice> {
+        let Some(flat) = FlatKey::parse(name) else {
+            self.problems.push(Error::new(path, Repr::UnknownBlockKey));
+            return None;
+        };
+        self.price(key, path, flat, value)
+    }
+
+    pub(crate) fn tier_rows(&mut self, value: &Value) -> Option<Vec<TierRow>> {
+        let path = pointer_for_key("tiered_pricing");
+        let rows: Vec<Value> = self.value(path.clone(), value)?;
+        Some(
+            rows.iter()
+                .enumerate()
+                .filter_map(|(index, row)| self.tier_row(path.clone(), index, row))
+                .collect(),
+        )
+    }
+
+    fn tier_row(&mut self, parent: String, index: usize, value: &Value) -> Option<TierRow> {
+        let path = format!("{parent}/{index}");
+        let display_path = format!("tiered_pricing[{index}]");
+        let fields = self.object(&path, value)?;
+        let mut row = TierRow {
+            path: path.clone(),
+            ..TierRow::default()
+        };
+        for (name, value) in fields.iter().filter(|(_, value)| !value.is_null()) {
+            let key = format!("{display_path}.{name}");
+            let child_path = pointer_child(&path, name);
+            match name.as_str() {
+                "range" => row.range = self.bounds(child_path, value),
+                "max_results_range" => row.max_results_range = self.bounds(child_path, value),
+                _ => row
+                    .prices
+                    .extend(self.block_price(name, key, child_path, value)),
+            }
+        }
+        Some(row)
+    }
+
+    fn bounds(&mut self, path: String, value: &Value) -> Option<[u64; 2]> {
+        DeserializeAsWrap::<[u64; 2], [Count; 2]>::deserialize(value)
+            .map(DeserializeAsWrap::into_inner)
+            .map_err(|error| self.problems.push(Error::new(path, Repr::Invalid(error))))
+            .ok()
+    }
+
+    pub(crate) fn off_peak(&mut self, value: &Value) -> Option<OffPeakBlock> {
+        let path = pointer_for_key("off_peak_pricing");
+        let fields = self.object(&path, value)?;
+        let mut block = OffPeakBlock::default();
+        for (name, value) in fields.iter().filter(|(_, value)| !value.is_null()) {
+            let key = format!("off_peak_pricing.{name}");
+            let child_path = pointer_child(&path, name);
+            match name.as_str() {
+                "hours_utc" => block.hours_utc = self.value(child_path, value),
+                "windows" => block.windows = self.value(child_path, value),
+                "weekday_timezone" => block.weekday_timezone = self.value(child_path, value),
+                _ => block
+                    .prices
+                    .extend(self.block_price(name, key, child_path, value)),
+            }
+        }
+        Some(block)
+    }
+}
diff --git a/litellm-rust/crates/model-catalog/src/wire/entry.rs b/litellm-rust/crates/model-catalog/src/wire/entry.rs
new file mode 100644
index 00000000000..9c155c6496a
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/wire/entry.rs
@@ -0,0 +1,193 @@
+use std::collections::BTreeMap;
+
+use litellm_cost::money::{Multiplier, UnitPrice};
+use serde_json::{Map, Value};
+
+use crate::error::{Error, Repr, pointer_for_key};
+use crate::wire::attributes::Attributes;
+use crate::wire::blocks::{FlatPrice, OffPeakBlock, Reader, SearchContextCostPerQuery, TierRow};
+use crate::wire::flat_key::FlatKey;
+
+pub type Fields = Map<String, Value>;
+
+/// One catalog entry as written. Every non-null key lands in exactly one field, and a known key
+/// with a bad value is kept out and listed in `problems`.
+#[derive(Debug, Default)]
+pub struct EntryWire {
+    pub attributes: Attributes,
+    pub prices: Vec<FlatPrice>,
+    pub capabilities: BTreeMap<String, bool>,
+    pub tier_rows: Option<Vec<TierRow>>,
+    pub off_peak: Option<OffPeakBlock>,
+    pub search_context: Option<SearchContextCostPerQuery>,
+    pub guardrail: Option<BTreeMap<String, UnitPrice>>,
+    pub regional_endpoint_uplift: Option<Multiplier>,
+    pub residency_uplift_eu: Option<Multiplier>,
+    pub residency_uplift_us: Option<Multiplier>,
+    pub unknown: Fields,
+    pub problems: Vec<Error>,
+}
+
+impl EntryWire {
+    pub fn read(fields: &Fields) -> Self {
+        let mut problems = Vec::new();
+        let mut wire = Self::default();
+        let mut reader = Reader {
+            problems: &mut problems,
+        };
+        for (key, value) in fields.iter().filter(|(_, value)| !value.is_null()) {
+            wire.read_key(&mut reader, key, value);
+        }
+        Self { problems, ..wire }
+    }
+
+    fn read_key(&mut self, reader: &mut Reader<'_>, key: &str, value: &Value) {
+        let path = || pointer_for_key(key);
+        match key {
+            "tiered_pricing" => self.tier_rows = reader.tier_rows(value),
+            "off_peak_pricing" => self.off_peak = reader.off_peak(value),
+            "search_context_cost_per_query" => self.search_context = reader.value(path(), value),
+            "guardrail_cost_per_unit" => self.guardrail = reader.value(path(), value),
+            "regional_endpoint_uplift_multiplier" => {
+                self.regional_endpoint_uplift = reader.value(path(), value)
+            }
+            "regional_processing_uplift_multiplier_eu" => {
+                self.residency_uplift_eu = reader.value(path(), value)
+            }
+            "regional_processing_uplift_multiplier_us" => {
+                self.residency_uplift_us = reader.value(path(), value)
+            }
+            _ => self.read_open_key(reader, key, value),
+        }
+    }
+
+    fn read_open_key(&mut self, reader: &mut Reader<'_>, key: &str, value: &Value) {
+        if let Some(read) = self.attributes.read(key, value) {
+            if let Err(error) = read {
+                reader
+                    .problems
+                    .push(Error::from_key(key, Repr::Invalid(error)));
+            }
+            return;
+        }
+        if let Some(flat) = FlatKey::parse(key) {
+            self.prices
+                .extend(reader.price(key.to_owned(), pointer_for_key(key), flat, value));
+            return;
+        }
+        if key.starts_with("supports_") {
+            if let Some(flag) = reader.value(pointer_for_key(key), value) {
+                self.capabilities.insert(key.to_owned(), flag);
+            }
+            return;
+        }
+        self.unknown.insert(key.to_owned(), value.clone());
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+    use serde_json::json;
+
+    use super::*;
+
+    fn read(entry: Value) -> EntryWire {
+        let Value::Object(fields) = entry else {
+            panic!("entry must be an object")
+        };
+        EntryWire::read(&fields)
+    }
+
+    fn problem_keys(wire: &EntryWire) -> Vec<String> {
+        wire.problems
+            .iter()
+            .map(|problem| problem.path().to_owned())
+            .collect()
+    }
+
+    #[rstest]
+    fn every_key_lands_in_exactly_one_place() {
+        let wire = read(json!({
+            "litellm_provider": "openai",
+            "max_tokens": "8192",
+            "input_cost_per_token": "0.000001",
+            "tiered_pricing": [{"range": [0, 10], "output_cost_per_token": 2e-6}],
+            "supports_vision": true,
+            "id": "deployment-1",
+            "mode": null
+        }));
+
+        assert_eq!(wire.attributes.litellm_provider.as_deref(), Some("openai"));
+        assert_eq!(wire.attributes.max_tokens, Some(8192));
+        assert_eq!(wire.attributes.mode, None);
+        assert_eq!(
+            wire.prices
+                .iter()
+                .map(|price| price.key.as_str())
+                .collect::<Vec<_>>(),
+            ["input_cost_per_token"]
+        );
+        assert_eq!(wire.tier_rows.unwrap()[0].prices.len(), 1);
+        assert_eq!(
+            wire.capabilities,
+            BTreeMap::from([("supports_vision".to_owned(), true)])
+        );
+        assert_eq!(wire.unknown.keys().collect::<Vec<_>>(), ["id"]);
+        assert!(wire.problems.is_empty());
+    }
+
+    #[rstest]
+    fn every_bad_value_is_reported_by_its_key_at_once() {
+        let wire = read(json!({
+            "mode": "chatt",
+            "max_tokens": -1,
+            "input_cost_per_token": "x",
+            "output_cost_per_image_0.5K": "x",
+            "supports_vision": "yes",
+            "regional_endpoint_uplift_multiplier": 0.5,
+            "tiered_pricing": [
+                {"range": [0, 10], "input_cost_per_token": 1e-6},
+                {"range": [10.5, 20], "typo_cost": 1, "output_cost_per_token": -1}
+            ],
+            "off_peak_pricing": {"hours_utc": "25:00-01:00", "input_cost_per_token": 1e-6}
+        }));
+
+        assert_eq!(
+            problem_keys(&wire)
+                .into_iter()
+                .collect::<std::collections::BTreeSet<_>>(),
+            [
+                "/input_cost_per_token",
+                "/max_tokens",
+                "/mode",
+                "/off_peak_pricing/hours_utc",
+                "/output_cost_per_image_0.5K",
+                "/regional_endpoint_uplift_multiplier",
+                "/supports_vision",
+                "/tiered_pricing/1/output_cost_per_token",
+                "/tiered_pricing/1/range",
+                "/tiered_pricing/1/typo_cost",
+            ]
+            .map(str::to_owned)
+            .into_iter()
+            .collect()
+        );
+    }
+
+    #[rstest]
+    #[case::tiers_not_a_list(json!({"tiered_pricing": {"range": [0, 1]}}), "/tiered_pricing")]
+    #[case::row_not_an_object(json!({"tiered_pricing": [3]}), "/tiered_pricing/0")]
+    #[case::off_peak_not_an_object(json!({"off_peak_pricing": true}), "/off_peak_pricing")]
+    #[case::unknown_search_size(
+        json!({"search_context_cost_per_query": {"search_context_size_huge": 1}}),
+        "/search_context_cost_per_query"
+    )]
+    #[case::negative_guardrail(
+        json!({"guardrail_cost_per_unit": {"contentPolicyUnits": -1}}),
+        "/guardrail_cost_per_unit"
+    )]
+    fn a_bad_block_is_reported_at_the_block(#[case] entry: Value, #[case] expected: &str) {
+        assert_eq!(problem_keys(&read(entry)), [expected]);
+    }
+}
diff --git a/litellm-rust/crates/model-catalog/src/wire/flat_key.rs b/litellm-rust/crates/model-catalog/src/wire/flat_key.rs
new file mode 100644
index 00000000000..906d917b487
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/wire/flat_key.rs
@@ -0,0 +1,359 @@
+use std::num::NonZeroU64;
+
+use litellm_cost::price::{
+    Band, CacheReadMode, CacheTtl, Channel, Feature, ImageSize, InputUnit, Meter, OutputUnit,
+    Resolution, ServiceTier, TokenKind, When,
+};
+
+/// A flat price key as the grammar reads it: `{meter}[_above_{N}k_tokens][_{tier}]`.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct FlatKey {
+    pub meter: Meter,
+    pub band: Band,
+    pub tier: Option<TierSuffix>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TierSuffix {
+    Service(ServiceTier),
+    Batches,
+    Decisions,
+}
+
+impl FlatKey {
+    pub fn parse(key: &str) -> Option<Self> {
+        let (rest, tier) = split_tier(key);
+        let (base, suffix) = split_above(rest)?;
+        let (meter, band) = match suffix {
+            Above::None => (meter(base)?, Band::Base),
+            Above::PromptTokens(tokens) => (meter(base)?, Band::over_prompt_tokens(tokens)),
+            Above::Seconds(seconds) => match meter(base)? {
+                Meter::Input(InputUnit::VideoSecond { over_seconds: None }) => (
+                    Meter::Input(InputUnit::VideoSecond {
+                        over_seconds: NonZeroU64::new(seconds),
+                    }),
+                    Band::Base,
+                ),
+                _ => return None,
+            },
+        };
+        Some(Self { meter, band, tier })
+    }
+
+    pub fn has_suffix(&self) -> bool {
+        self.band != Band::Base || self.tier.is_some()
+    }
+
+    pub fn channel_and_when(&self) -> (Channel, When) {
+        let (channel, tier) = match self.tier {
+            None => (Channel::Online, ServiceTier::Standard),
+            Some(TierSuffix::Service(tier)) => (Channel::Online, tier),
+            Some(TierSuffix::Batches) => (Channel::Batch, ServiceTier::Standard),
+            Some(TierSuffix::Decisions) => (Channel::Decisions, ServiceTier::Standard),
+        };
+        (
+            channel,
+            When {
+                tier,
+                band: self.band,
+            },
+        )
+    }
+}
+
+enum Above {
+    None,
+    PromptTokens(u64),
+    Seconds(u64),
+}
+
+fn split_tier(key: &str) -> (&str, Option<TierSuffix>) {
+    let Some((head, tail)) = key.rsplit_once('_') else {
+        return (key, None);
+    };
+    let tier = match tail {
+        "priority" => TierSuffix::Service(ServiceTier::Priority),
+        "flex" => TierSuffix::Service(ServiceTier::Flex),
+        "ultrafast" => TierSuffix::Service(ServiceTier::Ultrafast),
+        "balanced" => TierSuffix::Service(ServiceTier::Balanced),
+        "batches" => TierSuffix::Batches,
+        "decisions" => TierSuffix::Decisions,
+        _ => return (key, None),
+    };
+    (head, Some(tier))
+}
+
+fn split_above(key: &str) -> Option<(&str, Above)> {
+    let Some((head, tail)) = key.rsplit_once("_above_") else {
+        return Some((key, Above::None));
+    };
+    if tail == "1hr" || tail == "12hr" {
+        return Some((key, Above::None));
+    }
+    if let Some(thousands) = tail.strip_suffix("k_tokens") {
+        return Some((
+            head,
+            Above::PromptTokens(number(thousands)?.checked_mul(1000)?),
+        ));
+    }
+    if let Some(tokens) = tail.strip_suffix("_tokens") {
+        return Some((head, Above::PromptTokens(number(tokens)?)));
+    }
+    let seconds = tail.strip_suffix("s_interval")?;
+    Some((head, Above::Seconds(number(seconds)?)))
+}
+
+fn number(digits: &str) -> Option<u64> {
+    (!digits.is_empty() && digits.bytes().all(|byte| byte.is_ascii_digit()))
+        .then(|| digits.parse().ok())
+        .flatten()
+}
+
+fn meter(base: &str) -> Option<Meter> {
+    let fixed = match base {
+        "cost_per_second" => Some(Meter::WallClockSecond),
+        "explicit_cache_read_input_token_cost" => Some(Meter::CacheRead {
+            kind: TokenKind::Text,
+            mode: CacheReadMode::Explicit,
+        }),
+        "annotation_cost_per_page" => Some(Meter::Feature(Feature::AnnotationPage)),
+        "citation_cost_per_token" => Some(Meter::Feature(Feature::CitationToken)),
+        "code_interpreter_cost_per_session" => {
+            Some(Meter::Feature(Feature::CodeInterpreterSession))
+        }
+        "google_maps_grounding_cost_per_query" => {
+            Some(Meter::Feature(Feature::GoogleMapsGroundingQuery))
+        }
+        "ocr_cost_per_credit" => Some(Meter::Feature(Feature::OcrCredit)),
+        "ocr_cost_per_page" => Some(Meter::Feature(Feature::OcrPage)),
+        "browser_open_cost_per_request" => Some(Meter::Feature(Feature::BrowserOpen)),
+        "cost_per_additional_result" => Some(Meter::Feature(Feature::AdditionalResult)),
+        _ => None,
+    };
+    if fixed.is_some() {
+        return fixed;
+    }
+    if let Some(unit) = base.strip_prefix("input_cost_per_") {
+        return input_unit(unit).map(Meter::Input);
+    }
+    if let Some(unit) = base.strip_prefix("output_cost_per_") {
+        return output_unit(unit).map(Meter::Output);
+    }
+    if let Some(kind) = base
+        .strip_prefix("cache_read_input_")
+        .and_then(|rest| rest.strip_suffix("_cost"))
+    {
+        return Some(Meter::CacheRead {
+            kind: token_kind(kind)?,
+            mode: CacheReadMode::Implicit,
+        });
+    }
+    let rest = base.strip_prefix("cache_creation_input_")?;
+    let (kind, ttl) = if let Some(kind) = rest.strip_suffix("_cost_above_1hr") {
+        (kind, CacheTtl::OneHour)
+    } else if let Some(kind) = rest.strip_suffix("_cost_above_12hr") {
+        (kind, CacheTtl::TwelveHours)
+    } else {
+        (rest.strip_suffix("_cost")?, CacheTtl::Default)
+    };
+    Some(Meter::CacheWrite {
+        kind: token_kind(kind)?,
+        ttl,
+    })
+}
+
+fn token_kind(unit: &str) -> Option<TokenKind> {
+    match unit {
+        "token" => Some(TokenKind::Text),
+        "audio_token" => Some(TokenKind::Audio),
+        "image_token" => Some(TokenKind::Image),
+        "video_token" => Some(TokenKind::Video),
+        _ => None,
+    }
+}
+
+fn input_unit(unit: &str) -> Option<InputUnit> {
+    if let Some(kind) = token_kind(unit) {
+        return Some(InputUnit::Token(kind));
+    }
+    match unit {
+        "character" => Some(InputUnit::Character),
+        "image" => Some(InputUnit::Image),
+        "pixel" => Some(InputUnit::Pixel),
+        "query" => Some(InputUnit::Query { over_results: None }),
+        "request" => Some(InputUnit::Request),
+        "second" => Some(InputUnit::Second),
+        "text_message" => Some(InputUnit::TextMessage),
+        "audio_per_second" => Some(InputUnit::AudioSecond),
+        "video_per_second" => Some(InputUnit::VideoSecond { over_seconds: None }),
+        _ => None,
+    }
+}
+
+fn output_unit(unit: &str) -> Option<OutputUnit> {
+    if let Some(kind) = token_kind(unit) {
+        return Some(OutputUnit::Token(kind));
+    }
+    match unit.split_once('_') {
+        Some(("image", label)) => {
+            return ImageSize::new(label).map(|size| OutputUnit::Image(Some(size)));
+        }
+        Some(("second", label)) => {
+            return Resolution::new(label).map(|resolution| OutputUnit::Second(Some(resolution)));
+        }
+        _ => {}
+    }
+    match unit {
+        "reasoning_token" => Some(OutputUnit::ReasoningToken),
+        "character" => Some(OutputUnit::Character),
+        "image" => Some(OutputUnit::Image(None)),
+        "pixel" => Some(OutputUnit::Pixel),
+        "second" => Some(OutputUnit::Second(None)),
+        "video_per_second" => Some(OutputUnit::VideoSecond),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+
+    use super::*;
+
+    const TEXT_INPUT: Meter = Meter::Input(InputUnit::Token(TokenKind::Text));
+    const TEXT_OUTPUT: Meter = Meter::Output(OutputUnit::Token(TokenKind::Text));
+
+    fn key(meter: Meter, band: Band, tier: Option<TierSuffix>) -> FlatKey {
+        FlatKey { meter, band, tier }
+    }
+
+    #[rstest]
+    #[case::input_token("input_cost_per_token", key(TEXT_INPUT, Band::Base, None))]
+    #[case::band_and_tier(
+        "output_cost_per_token_above_272k_tokens_priority",
+        key(
+            TEXT_OUTPUT,
+            Band::over_prompt_tokens(272_000),
+            Some(TierSuffix::Service(ServiceTier::Priority))
+        )
+    )]
+    #[case::band_without_k(
+        "input_cost_per_token_above_128_tokens",
+        key(TEXT_INPUT, Band::over_prompt_tokens(128), None)
+    )]
+    #[case::zero_band_is_base(
+        "input_cost_per_token_above_0k_tokens",
+        key(TEXT_INPUT, Band::Base, None)
+    )]
+    #[case::batch(
+        "input_cost_per_token_batches",
+        key(TEXT_INPUT, Band::Base, Some(TierSuffix::Batches))
+    )]
+    #[case::reasoning(
+        "output_cost_per_reasoning_token",
+        key(Meter::Output(OutputUnit::ReasoningToken), Band::Base, None)
+    )]
+    #[case::cache_read_audio(
+        "cache_read_input_audio_token_cost",
+        key(Meter::CacheRead { kind: TokenKind::Audio, mode: CacheReadMode::Implicit }, Band::Base, None)
+    )]
+    #[case::explicit_cache_read(
+        "explicit_cache_read_input_token_cost",
+        key(Meter::CacheRead { kind: TokenKind::Text, mode: CacheReadMode::Explicit }, Band::Base, None)
+    )]
+    #[case::cache_write_one_hour_band(
+        "cache_creation_input_token_cost_above_1hr_above_200k_tokens",
+        key(
+            Meter::CacheWrite { kind: TokenKind::Text, ttl: CacheTtl::OneHour },
+            Band::over_prompt_tokens(200_000),
+            None
+        )
+    )]
+    #[case::cache_write_twelve_hours_priority(
+        "cache_creation_input_token_cost_above_12hr_above_272k_tokens_priority",
+        key(
+            Meter::CacheWrite { kind: TokenKind::Text, ttl: CacheTtl::TwelveHours },
+            Band::over_prompt_tokens(272_000),
+            Some(TierSuffix::Service(ServiceTier::Priority))
+        )
+    )]
+    #[case::image_label(
+        "output_cost_per_image_0.5K",
+        key(
+            Meter::Output(OutputUnit::Image(ImageSize::new("0.5K"))),
+            Band::Base,
+            None
+        )
+    )]
+    #[case::image_token_is_a_token(
+        "output_cost_per_image_token",
+        key(Meter::Output(OutputUnit::Token(TokenKind::Image)), Band::Base, None)
+    )]
+    #[case::resolution(
+        "output_cost_per_second_720p",
+        key(
+            Meter::Output(OutputUnit::Second(Resolution::new("720p"))),
+            Band::Base,
+            None
+        )
+    )]
+    #[case::video_interval(
+        "input_cost_per_video_per_second_above_8s_interval",
+        key(Meter::Input(InputUnit::VideoSecond { over_seconds: NonZeroU64::new(8) }), Band::Base, None)
+    )]
+    #[case::feature_batch(
+        "ocr_cost_per_page_batches",
+        key(
+            Meter::Feature(Feature::OcrPage),
+            Band::Base,
+            Some(TierSuffix::Batches)
+        )
+    )]
+    #[case::wall_clock("cost_per_second", key(Meter::WallClockSecond, Band::Base, None))]
+    #[case::browser_open(
+        "browser_open_cost_per_request",
+        key(Meter::Feature(Feature::BrowserOpen), Band::Base, None)
+    )]
+    #[case::additional_result(
+        "cost_per_additional_result",
+        key(Meter::Feature(Feature::AdditionalResult), Band::Base, None)
+    )]
+    fn parses_every_key_shape(#[case] text: &str, #[case] expected: FlatKey) {
+        assert_eq!(FlatKey::parse(text), Some(expected));
+    }
+
+    #[rstest]
+    #[case::typo("input_cost_per_tokne")]
+    #[case::unused_meter("cost_per_token")]
+    #[case::other_currency("input_dbu_cost_per_token")]
+    #[case::cache_hit_alias("input_cost_per_token_cache_hit")]
+    #[case::non_numeric_band("input_cost_per_token_above_xk_tokens")]
+    #[case::interval_on_a_token_meter("input_cost_per_token_above_8s_interval")]
+    #[case::read_has_no_ttl("cache_read_input_token_cost_above_1hr")]
+    #[case::cache_unit_must_be_token("cache_read_input_character_cost")]
+    #[case::bad_image_size("output_cost_per_image_big")]
+    #[case::bad_resolution("output_cost_per_second_hd")]
+    #[case::unknown_feature("telepathy_cost_per_page")]
+    #[case::empty("")]
+    fn rejects_keys_outside_the_grammar(#[case] text: &str) {
+        assert_eq!(FlatKey::parse(text), None);
+    }
+
+    #[rstest]
+    #[case::plain("input_cost_per_token", (Channel::Online, When::default()))]
+    #[case::service_tier(
+        "input_cost_per_token_flex",
+        (Channel::Online, When { tier: ServiceTier::Flex, band: Band::Base })
+    )]
+    #[case::batch(
+        "input_cost_per_token_above_200k_tokens_batches",
+        (Channel::Batch, When { tier: ServiceTier::Standard, band: Band::over_prompt_tokens(200_000) })
+    )]
+    #[case::decisions("input_cost_per_token_decisions", (Channel::Decisions, When::default()))]
+    fn batch_and_decisions_pick_a_channel_not_a_tier(
+        #[case] text: &str,
+        #[case] expected: (Channel, When),
+    ) {
+        assert_eq!(FlatKey::parse(text).unwrap().channel_and_when(), expected);
+    }
+}
diff --git a/litellm-rust/crates/model-catalog/src/wire/lax.rs b/litellm-rust/crates/model-catalog/src/wire/lax.rs
new file mode 100644
index 00000000000..d514a6a82c1
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/wire/lax.rs
@@ -0,0 +1,128 @@
+use std::fmt;
+
+use serde::Deserializer;
+use serde::de::{self, Visitor};
+use serde_with::DeserializeAs;
+
+pub(crate) struct LaxI64;
+
+pub(crate) struct Count;
+
+impl<'de> DeserializeAs<'de, i64> for LaxI64 {
+    fn deserialize_as<D: Deserializer<'de>>(deserializer: D) -> Result<i64, D::Error> {
+        deserializer.deserialize_any(Self)
+    }
+}
+
+impl Visitor<'_> for LaxI64 {
+    type Value = i64;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("an integer in the i64 range")
+    }
+
+    fn visit_i64<E: de::Error>(self, value: i64) -> Result<i64, E> {
+        Ok(value)
+    }
+
+    fn visit_u64<E: de::Error>(self, value: u64) -> Result<i64, E> {
+        i64::try_from(value).map_err(E::custom)
+    }
+
+    fn visit_f64<E: de::Error>(self, value: f64) -> Result<i64, E> {
+        integral_float(value).ok_or_else(|| E::custom("expected an integer in the i64 range"))
+    }
+
+    fn visit_str<E: de::Error>(self, value: &str) -> Result<i64, E> {
+        integer_string(value.trim())
+            .ok_or_else(|| E::custom("expected an integer in the i64 range"))
+    }
+
+    fn visit_bool<E: de::Error>(self, value: bool) -> Result<i64, E> {
+        Ok(i64::from(value))
+    }
+}
+
+impl<'de> DeserializeAs<'de, u64> for Count {
+    fn deserialize_as<D: Deserializer<'de>>(deserializer: D) -> Result<u64, D::Error> {
+        let count = LaxI64::deserialize_as(deserializer)?;
+        u64::try_from(count).map_err(|_| {
+            de::Error::invalid_value(de::Unexpected::Signed(count), &"a count of zero or more")
+        })
+    }
+}
+
+fn integer_string(value: &str) -> Option<i64> {
+    let integer = match value.split_once('.') {
+        Some((integer, fraction)) => {
+            if fraction.is_empty() || !fraction.bytes().all(|byte| byte == b'0') {
+                return None;
+            }
+            integer
+        }
+        None => value,
+    };
+    if integer.starts_with('_') || integer.ends_with('_') || integer.contains("__") {
+        return None;
+    }
+    let digits = integer.strip_prefix(['+', '-']).unwrap_or(integer);
+    if digits.is_empty()
+        || digits.starts_with('_')
+        || !digits
+            .bytes()
+            .all(|byte| byte.is_ascii_digit() || byte == b'_')
+    {
+        return None;
+    }
+    integer.replace('_', "").parse().ok()
+}
+
+fn integral_float(value: f64) -> Option<i64> {
+    (value.is_finite()
+        && value.fract() == 0.0
+        && value >= i64::MIN as f64
+        && value < -(i64::MIN as f64))
+        .then_some(value as i64)
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+    use serde_json::{Value, json};
+    use serde_with::de::DeserializeAsWrap;
+
+    use super::*;
+
+    fn count(value: Value) -> Option<u64> {
+        DeserializeAsWrap::<u64, Count>::deserialize(value)
+            .ok()
+            .map(DeserializeAsWrap::into_inner)
+    }
+
+    use serde::Deserialize;
+
+    #[rstest]
+    #[case::integer(json!(128000), Some(128_000))]
+    #[case::whole_float(json!(128000.0), Some(128_000))]
+    #[case::string(json!(" 8192 "), Some(8192))]
+    #[case::separated(json!("1_000"), Some(1000))]
+    #[case::trailing_zeros(json!("2.000"), Some(2))]
+    #[case::boolean(json!(true), Some(1))]
+    #[case::maximum(json!(i64::MAX.to_string()), Some(i64::MAX as u64))]
+    #[case::negative(json!(-5), None)]
+    #[case::fraction(json!(2.5), None)]
+    #[case::precise_fraction(json!("1.0000000000000001"), None)]
+    #[case::exponent(json!("1e3"), None)]
+    #[case::missing_fraction(json!("2."), None)]
+    #[case::repeated_separator(json!("2__0"), None)]
+    #[case::above_i64(json!(u64::MAX), None)]
+    #[case::float_above_i64(json!(9_223_372_036_854_775_808.0), None)]
+    #[case::word(json!("8k"), None)]
+    #[case::object(json!({}), None)]
+    fn counts_accept_whole_numbers_however_they_are_written(
+        #[case] written: Value,
+        #[case] expected: Option<u64>,
+    ) {
+        assert_eq!(count(written), expected);
+    }
+}
diff --git a/litellm-rust/crates/model-catalog/src/wire/mod.rs b/litellm-rust/crates/model-catalog/src/wire/mod.rs
new file mode 100644
index 00000000000..e8f23b7bd0d
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/src/wire/mod.rs
@@ -0,0 +1,10 @@
+mod attributes;
+mod blocks;
+mod entry;
+mod flat_key;
+mod lax;
+
+pub use attributes::*;
+pub use blocks::*;
+pub use entry::*;
+pub use flat_key::*;
diff --git a/litellm-rust/crates/model-catalog/tests/catalog.rs b/litellm-rust/crates/model-catalog/tests/catalog.rs
index d384dfea9a8..30c070cfb52 100644
--- a/litellm-rust/crates/model-catalog/tests/catalog.rs
+++ b/litellm-rust/crates/model-catalog/tests/catalog.rs
@@ -1,303 +1,405 @@
-use std::path::{Path, PathBuf};
+use std::collections::BTreeSet;
 
-use litellm_model_catalog::{AliasIssue, Catalog, Error, IntegrityLimits, Mode, Provenance};
+use litellm_model_catalog::{
+    BUNDLED_REGISTRY, Catalog, Error, ErrorKind, IntegrityLimits, Mode, Rejects, Written,
+};
 use rstest::{fixture, rstest};
-use serde_json::json;
+use serde_json::{Map, Value, json};
 
 const ALPHA_FIXTURE: &[u8] = br#"{
-    "sample_spec":{"explanation":"example"},
+    "sample_spec":{"explanation":"example","input_cost_per_token":"not checked"},
     "fallback_generalizations":{"rules":[{"name":"family","pattern":"^new-","model_info":{"mode":"chat"}}]},
     "Alpha":{"litellm_provider":"test","aliases":["short"],"price":0,"enabled":false,
              "optional":null,"unknown":{"nested":[1,{"x":true}]}}
 }"#;
 
-#[fixture]
-fn repo_root() -> PathBuf {
-    Path::new(env!("CARGO_MANIFEST_DIR")).join("../../..")
-}
-
-#[fixture]
-fn current_catalog(repo_root: PathBuf) -> Catalog {
-    let body = std::fs::read(repo_root.join("model_prices_and_context_window.json")).unwrap();
-    Catalog::parse(&body, Provenance::default()).unwrap()
-}
-
-#[fixture]
-fn backup_catalog(repo_root: PathBuf) -> Catalog {
-    let body = std::fs::read(repo_root.join("litellm/model_prices_and_context_window_backup.json"))
-        .unwrap();
-    Catalog::parse(&body, Provenance::default()).unwrap()
-}
-
 #[fixture]
 fn fixture_catalog() -> Catalog {
-    Catalog::parse(
-        ALPHA_FIXTURE,
-        Provenance {
-            source: Some("fixture".into()),
-            revision: Some("rev".into()),
-            etag: None,
-        },
-    )
-    .unwrap()
+    Catalog::parse(ALPHA_FIXTURE).unwrap().value
+}
+
+fn loaded(document: Value) -> litellm_model_catalog::Loaded<Catalog> {
+    Catalog::parse(document.to_string().as_bytes()).unwrap()
+}
+
+fn catalog(document: Value) -> Catalog {
+    loaded(document).value
+}
+
+fn written(catalog: &Catalog) -> String {
+    let document: Map<String, Value> = catalog
+        .written()
+        .map(|(key, value)| {
+            let value = match value {
+                Written::Entry(fields) => serde_json::to_value(fields).unwrap(),
+                Written::Section(value) => value.clone(),
+            };
+            (key.to_owned(), value)
+        })
+        .collect();
+    serde_json::to_string(&document).unwrap()
+}
+
+fn report(error: &Error) -> String {
+    litellm_error::Report::new(error).to_string()
+}
+
+fn error_text(document: Value) -> Vec<String> {
+    loaded(document).errors.iter().map(report).collect()
 }
 
 #[rstest]
 #[case::decisions("decisions", Mode::Decisions)]
 #[case::legacy_evaluation("evaluation", Mode::Evaluation)]
 fn parses_decision_modes(#[case] mode: &str, #[case] expected: Mode) {
-    let source = json!({"Test":{"litellm_provider":"test","mode":mode}}).to_string();
-    let catalog = Catalog::parse(source.as_bytes(), Provenance::default()).unwrap();
-
+    let catalog = catalog(json!({"Test": {"litellm_provider": "test", "mode": mode}}));
     assert_eq!(
-        catalog.lookup("Test").unwrap().entry.info().mode,
+        catalog
+            .lookup("Test")
+            .unwrap()
+            .entry
+            .model()
+            .unwrap()
+            .attributes
+            .mode,
         Some(expected)
     );
-    assert_eq!(serde_json::to_value(expected).unwrap(), json!(mode));
 }
 
 #[rstest]
-#[ignore]
-fn preserves_fields_and_metadata(fixture_catalog: Catalog) {
-    let catalog = fixture_catalog;
-    let entry = catalog.lookup("SHORT").unwrap();
-    assert_eq!(entry.canonical_key, "Alpha");
-    assert_eq!(entry.matched_key, "short");
-    assert_eq!(entry.entry.field("price"), Some(&json!(0)));
-    assert_eq!(entry.entry.field("enabled"), Some(&json!(false)));
-    assert_eq!(entry.entry.field("optional"), Some(&json!(null)));
-    assert_eq!(entry.entry.field("missing"), None);
+fn unknown_keys_are_kept_raw_and_listed_as_unrecognized(fixture_catalog: Catalog) {
+    let entry = fixture_catalog.lookup("Alpha").unwrap().entry;
     assert_eq!(
-        entry.entry.field("unknown"),
+        entry.field("unknown"),
         Some(&json!({"nested":[1,{"x":true}]}))
     );
-    assert_eq!(entry.entry.field("aliases"), None);
-    assert_eq!(entry.entry.info().litellm_provider.as_deref(), Some("test"));
     assert_eq!(
-        catalog.sample_spec(),
-        Some(&json!({"explanation":"example"}))
-    );
-    assert_eq!(catalog.fallback_rules().unwrap().len(), 1);
-    assert_eq!(catalog.provenance().revision.as_deref(), Some("rev"));
-    assert_eq!(catalog.model_count(), 1);
-}
-
-#[rstest]
-#[ignore]
-fn snapshot_does_not_borrow_source() {
-    let mut source = ALPHA_FIXTURE.to_vec();
-    let catalog = Catalog::parse(&source, Provenance::default()).unwrap();
-    source.fill(b' ');
-
-    let entry = catalog.lookup("short").unwrap();
-    assert_eq!(entry.canonical_key, "Alpha");
-    assert_eq!(entry.entry.field("price"), Some(&json!(0)));
-}
-
-#[rstest]
-#[case("Shared", "First")]
-#[case("Second", "Second")]
-#[case("shared", "Second")]
-#[case("FIRST", "First")]
-#[case("sHaReD", "Second")]
-#[ignore]
-fn alias_collisions_and_case_fallback_follow_entry_order(
-    #[case] lookup: &str,
-    #[case] expected: &str,
-) {
-    let catalog = Catalog::parse(
-        br#"{
-            "First":{"aliases":["Shared","Second","first"],"value":1},
-            "Second":{"aliases":["Shared","sHaReD"],"value":2},
-            "SHARED":{"value":3}
-        }"#,
-        Provenance::default(),
-    )
-    .unwrap();
-    assert_eq!(catalog.lookup(lookup).unwrap().canonical_key, expected);
-    assert_eq!(catalog.alias_count(), 3);
-    assert!(
-        catalog
-            .alias_issues()
-            .contains(&AliasIssue::CanonicalCollision {
-                model: "First".into(),
-                alias: "Second".into(),
-            })
-    );
-    assert!(
-        catalog
-            .alias_issues()
-            .contains(&AliasIssue::AliasCollision {
-                model: "Second".into(),
-                alias: "Shared".into(),
-            })
+        fixture_catalog.unrecognized().collect::<BTreeSet<_>>(),
+        BTreeSet::from([
+            ("Alpha", "enabled"),
+            ("Alpha", "price"),
+            ("Alpha", "unknown")
+        ])
     );
 }
 
-#[test]
-#[ignore]
-fn json_entry_order_controls_alias_ownership_and_case_fallback() {
-    let forward = Catalog::parse(
-        br#"{
-            "Alpha":{"aliases":["shared"]},
-            "Beta":{"aliases":["shared"]},
-            "Foo":{},
-            "fOO":{}
-        }"#,
-        Provenance::default(),
-    )
-    .unwrap();
-    let reversed = Catalog::parse(
-        br#"{
-            "fOO":{},
-            "Foo":{},
-            "Beta":{"aliases":["shared"]},
-            "Alpha":{"aliases":["shared"]}
-        }"#,
-        Provenance::default(),
-    )
-    .unwrap();
-
-    assert_eq!(forward.lookup("shared").unwrap().canonical_key, "Alpha");
-    assert_eq!(reversed.lookup("shared").unwrap().canonical_key, "Beta");
-    assert_eq!(forward.lookup("foo").unwrap().canonical_key, "fOO");
-    assert_eq!(reversed.lookup("foo").unwrap().canonical_key, "Foo");
-}
-
-#[derive(Debug)]
-enum ValidationOutcome {
-    Ok,
-    Shrunk,
-    BelowMinimum,
-    InvalidRatio,
-}
-
 #[rstest]
-#[case(
-    IntegrityLimits {
-        reference_model_count: 2,
-        min_model_count: 1,
-        min_reference_ratio: 0.5,
-    },
-    ValidationOutcome::Ok
-)]
-#[case(
-    IntegrityLimits {
-        reference_model_count: 3,
-        min_model_count: 1,
-        min_reference_ratio: 0.5,
-    },
-    ValidationOutcome::Shrunk
-)]
-#[case(
-    IntegrityLimits {
-        reference_model_count: 0,
-        min_model_count: 2,
-        min_reference_ratio: 0.5,
-    },
-    ValidationOutcome::BelowMinimum
-)]
-#[case(
-    IntegrityLimits {
-        reference_model_count: 0,
-        min_model_count: 0,
-        min_reference_ratio: f64::NAN,
-    },
-    ValidationOutcome::InvalidRatio
-)]
-#[ignore]
-fn integrity_uses_canonical_count_and_strict_shrink_boundary(
-    #[case] limits: IntegrityLimits,
-    #[case] expected: ValidationOutcome,
-) {
-    let catalog = Catalog::parse(
-        br#"{"sample_spec":{},"fallback_generalizations":{"rules":[]},"a":{"aliases":["b","c"]}}"#,
-        Provenance::default(),
-    )
-    .unwrap();
-    let actual = catalog.validate(limits);
-    match expected {
-        ValidationOutcome::Ok => assert!(actual.is_ok()),
-        ValidationOutcome::Shrunk => {
-            assert!(matches!(actual, Err(Error::Shrunk { actual: 1, .. })))
-        }
-        ValidationOutcome::BelowMinimum => {
-            assert!(matches!(actual, Err(Error::BelowMinimum { actual: 1, .. })))
-        }
-        ValidationOutcome::InvalidRatio => assert!(matches!(actual, Err(Error::InvalidRatio))),
-    }
-}
-
-#[derive(Debug)]
-enum MalformedOutcome {
-    Empty,
-    Json,
-    EntryNotObject,
-}
-
-#[rstest]
-#[case::empty(b"{}", MalformedOutcome::Empty)]
-#[case::invalid_json(b"{", MalformedOutcome::Json)]
-#[case::entry_not_object(br#"{"a":1}"#, MalformedOutcome::EntryNotObject)]
-#[case::fallback_rules_missing(
-    br#"{"fallback_generalizations":{},"a":{}}"#,
-    MalformedOutcome::Json
-)]
-#[ignore]
-fn malformed_input_and_aliases_have_typed_outcomes(
-    #[case] body: &[u8],
-    #[case] expected: MalformedOutcome,
-) {
-    let actual = Catalog::parse(body, Provenance::default());
-    match expected {
-        MalformedOutcome::Empty => assert!(matches!(actual, Err(Error::Empty))),
-        MalformedOutcome::Json => assert!(matches!(actual, Err(Error::Json(_)))),
-        MalformedOutcome::EntryNotObject => {
-            assert!(matches!(actual, Err(Error::EntryNotObject { .. })))
-        }
-    }
-}
-
-#[rstest]
-#[ignore]
-fn invalid_aliases_are_reported_not_fatal() {
-    let catalog = Catalog::parse(
-        br#"{"a":{"aliases":"bad"},"b":{"aliases":[9,"ok"]}}"#,
-        Provenance::default(),
-    )
-    .unwrap();
+fn sections_aliases_and_raw_fields_are_read_in_their_document_views(fixture_catalog: Catalog) {
+    let found = fixture_catalog.lookup("SHORT").unwrap();
+    assert_eq!(found.canonical_key, "Alpha");
+    assert_eq!(found.matched_key, "short");
+    assert_eq!(found.entry.field("optional"), Some(&json!(null)));
+    assert_eq!(found.entry.field("aliases"), Some(&json!(["short"])));
     assert_eq!(
-        catalog.alias_issues(),
-        &[
-            AliasIssue::InvalidList { model: "a".into() },
-            AliasIssue::InvalidName { model: "b".into() },
-        ]
+        fixture_catalog.sample_spec(),
+        Some(&json!({"explanation":"example","input_cost_per_token":"not checked"}))
+    );
+    assert_eq!(fixture_catalog.fallback_rules().unwrap()[0].name, "family");
+    assert_eq!(fixture_catalog.model_count(), 1);
+    assert_eq!(
+        fixture_catalog
+            .served()
+            .map(|(key, _)| key)
+            .collect::<Vec<_>>(),
+        ["Alpha", "short"]
     );
-    assert_eq!(catalog.lookup("ok").unwrap().canonical_key, "b");
-    assert!(catalog.lookup("missing").is_none());
 }
 
 #[rstest]
-#[ignore]
-fn parses_current_and_packaged_catalogs_against_independent_baseline(
-    current_catalog: Catalog,
-    backup_catalog: Catalog,
-) {
-    assert!(current_catalog.model_count() > 0);
-    assert!(backup_catalog.model_count() > 0);
-    assert!(current_catalog.sample_spec().is_some());
-    assert!(backup_catalog.sample_spec().is_some());
-    // Snapshot from 2026-09-23; the backup file mirrors the current file and cannot detect shrinkage.
-    const REFERENCE_MODEL_COUNT: usize = 4303;
-    current_catalog
-        .validate(IntegrityLimits {
-            reference_model_count: REFERENCE_MODEL_COUNT,
-            min_model_count: 50,
-            min_reference_ratio: 0.9,
-        })
-        .unwrap();
-    assert!(current_catalog.model_names().all(|name| {
-        let entry = current_catalog.lookup(name).unwrap().entry;
-        entry.info().litellm_provider.is_some() == entry.field("litellm_provider").is_some()
+fn a_bad_entry_is_reported_by_model_and_key_and_kept_raw() {
+    let parsed = loaded(json!({
+        "Good": {"litellm_provider": "test"},
+        "Bad": {"litellm_provider": "test", "mode": "chatt", "input_cost_per_token": "free"},
+        "Worse": {"mode": "chat"}
     }));
+    let catalog = parsed.value;
+    let problems: Vec<String> = parsed.errors.iter().map(report).collect();
+    assert_eq!(problems.len(), 3, "{problems:?}");
+    assert!(problems[0].starts_with("Bad.mode: invalid value: unknown variant `chatt`"));
+    assert!(problems[1].starts_with("Bad.input_cost_per_token: invalid value"));
+    assert_eq!(problems[2], "Worse.litellm_provider: required");
+    assert!(catalog.lookup("Good").unwrap().entry.model().is_some());
+    assert!(catalog.lookup("Bad").unwrap().entry.model().is_none());
+    assert_eq!(catalog.model_count(), 3);
+    assert!(
+        parsed
+            .errors
+            .iter()
+            .find(|error| error.rejects() == Rejects::Document)
+            .is_none()
+    );
+}
+
+#[rstest]
+#[case::alias_names_a_model(
+    json!({"First": {"litellm_provider": "t", "aliases": ["Second"]}, "Second": {"litellm_provider": "t"}}),
+    r#"First: alias "Second" is already a model name"#
+)]
+#[case::alias_claimed_twice(
+    json!({"First": {"litellm_provider": "t", "aliases": ["shared"]}, "Second": {"litellm_provider": "t", "aliases": ["shared"]}}),
+    r#"Second: alias "shared" already belongs to First"#
+)]
+#[case::aliases_not_a_list(
+    json!({"a": {"litellm_provider": "t", "aliases": "bad"}}),
+    "a.aliases: invalid value: invalid type: string \"bad\", expected a sequence"
+)]
+#[case::entry_not_object(
+    json!({"a": 1, "valid": {"litellm_provider": "test"}}),
+    "a: must be a JSON object"
+)]
+#[case::fallback_rules_missing(
+    json!({"fallback_generalizations": {}, "a": {"litellm_provider": "t"}}),
+    "fallback_generalizations: invalid value: missing field `rules`"
+)]
+#[case::unknown_timezone(
+    json!({"a": {"litellm_provider": "t", "off_peak_pricing": {
+        "windows": [{"hours_utc": "00:00-01:00"}],
+        "weekday_timezone": "Not/AZone",
+        "input_cost_per_token": 1e-6
+    }}}),
+    r#"a.off_peak_pricing.weekday_timezone: "Not/AZone" is not an IANA time zone"#
+)]
+fn document_level_problems_are_reported(#[case] document: Value, #[case] expected: &str) {
+    assert_eq!(error_text(document), [expected]);
+}
+
+#[rstest]
+fn escaped_row_paths_and_row_validation_share_the_parse_rules() {
+    let document = json!({
+        "open/router~v1": {"litellm_provider": "test", "input_cost_per_token": -1}
+    });
+    let parsed = loaded(document);
+    let fields = parsed
+        .value
+        .lookup("open/router~v1")
+        .unwrap()
+        .entry
+        .fields();
+    let row_errors = Catalog::row_errors("open/router~v1", fields);
+    assert_eq!(
+        row_errors
+            .iter()
+            .map(|error| (error.path(), report(error)))
+            .collect::<Vec<_>>(),
+        parsed
+            .errors
+            .iter()
+            .map(|error| (error.path(), report(error)))
+            .collect::<Vec<_>>()
+    );
+    assert_eq!(
+        row_errors[0].path(),
+        "/open~1router~0v1/input_cost_per_token"
+    );
+    assert!(row_errors[0].kind() == ErrorKind::Invalid);
+}
+
+#[rstest]
+fn malformed_fallback_is_collected_while_models_are_read() {
+    let parsed = loaded(json!({
+        "fallback_generalizations": {"rules": "bad"},
+        "a": {"litellm_provider": "test"}
+    }));
+    assert_eq!(parsed.value.model_count(), 1);
+    assert_eq!(parsed.errors.len(), 1);
+    assert_eq!(parsed.errors[0].path(), "/fallback_generalizations");
+}
+
+#[rstest]
+fn rejected_rows_and_their_aliases_are_removed_without_disturbing_written_order() {
+    let body = r#"{"before":{"litellm_provider":"test","aliases":["before-alias"]},"bad":{"litellm_provider":"test","aliases":["bad-alias"],"mode":"chatt"},"not-object":4,"sample_spec":{"keep":true},"after":{"litellm_provider":"test"}}"#;
+    let parsed = Catalog::parse(body.as_bytes()).unwrap();
+    let (catalog, removed) = parsed.value.without_rejected(&parsed.errors);
+
+    assert_eq!(removed.len(), 2);
+    assert_eq!(
+        catalog.lookup("before-alias").unwrap().canonical_key,
+        "before"
+    );
+    assert_eq!(
+        catalog.lookup("BEFORE-ALIAS").unwrap().matched_key,
+        "before-alias"
+    );
+    assert!(catalog.lookup("bad").is_none());
+    assert!(catalog.lookup("BAD").is_none());
+    assert!(catalog.lookup("Bad-Alias").is_none());
+    assert_eq!(catalog.model_count(), 2);
+    assert_eq!(
+        written(&catalog),
+        r#"{"before":{"litellm_provider":"test","aliases":["before-alias"]},"sample_spec":{"keep":true},"after":{"litellm_provider":"test"}}"#
+    );
+}
+
+#[rstest]
+fn invalid_empty_key_rows_are_removed() {
+    let parsed = loaded(json!({
+        "": {"litellm_provider": "test", "mode": "chatt"},
+        "good": {"litellm_provider": "test"}
+    }));
+    assert_eq!(parsed.errors[0].path(), "//mode");
+
+    let (catalog, removed) = parsed.value.without_rejected(&parsed.errors);
+    assert_eq!(catalog.model_count(), 1);
+    assert!(catalog.lookup("").is_none());
+    assert!(catalog.lookup("good").is_some());
+    assert_eq!(removed.len(), 1);
+}
+
+#[rstest]
+fn timezone_errors_reject_providerless_rows_without_rejecting_other_providerless_rows() {
+    let parsed = loaded(json!({
+        "good": {"mode": "chat"},
+        "bad": {"off_peak_pricing": {
+            "windows": [{"hours_utc": "00:00-01:00"}],
+            "weekday_timezone": "Not/AZone",
+            "input_cost_per_token": 1e-6
+        }}
+    }));
+    assert_eq!(parsed.errors.len(), 3);
+    assert!(
+        parsed
+            .errors
+            .iter()
+            .any(|error| error.kind() == ErrorKind::UnknownTimezone)
+    );
+
+    let (catalog, removed) = parsed.value.without_rejected(&parsed.errors);
+    assert_eq!(catalog.model_count(), 1);
+    assert!(catalog.lookup("good").is_some());
+    assert!(catalog.lookup("bad").is_none());
+    assert_eq!(removed.len(), 2);
+}
+
+#[rstest]
+fn bundled_per_row_errors_match_document_errors() {
+    let parsed = Catalog::parse(BUNDLED_REGISTRY).unwrap();
+    let row_errors: Vec<_> = parsed
+        .value
+        .written()
+        .flat_map(|(key, written)| match written {
+            Written::Entry(fields) => Catalog::row_errors(key, fields),
+            Written::Section(_) => Vec::new(),
+        })
+        .map(|error| (error.path().to_owned(), report(&error)))
+        .collect();
+    let document_errors: Vec<_> = parsed
+        .errors
+        .iter()
+        .map(|error| (error.path().to_owned(), report(error)))
+        .collect();
+
+    assert_eq!(row_errors, document_errors);
+}
+
+#[rstest]
+fn three_hundred_rows_filter_one_row_with_two_invalid_prices() {
+    let valid_rows: Map<String, Value> = (0..299)
+        .map(|index| {
+            (
+                format!("valid-{index:03}"),
+                json!({"litellm_provider": "test"}),
+            )
+        })
+        .collect();
+    let mut document = valid_rows;
+    document.insert(
+        "bad".to_owned(),
+        json!({
+            "litellm_provider": "test",
+            "input_cost_per_token": -1,
+            "output_cost_per_token": -1
+        }),
+    );
+    let parsed = Catalog::parse(serde_json::to_vec(&document).unwrap().as_slice()).unwrap();
+    assert_eq!(parsed.value.model_count(), 300);
+    assert_eq!(parsed.errors.len(), 2);
+
+    let (catalog, removed) = parsed.value.without_rejected(&parsed.errors);
+    assert_eq!(catalog.model_count(), 299);
+    assert_eq!(removed.len(), 2);
+}
+
+#[rstest]
+fn integrity_limits_count_canonical_models_not_aliases() {
+    let fetched = catalog(json!({"a": {"litellm_provider": "t", "aliases": ["b", "c"]}}));
+    assert!(
+        fetched
+            .check_size(2, IntegrityLimits::new(1, 0.5).unwrap())
+            .is_ok()
+    );
+    assert_eq!(
+        fetched
+            .check_size(3, IntegrityLimits::new(1, 0.5).unwrap())
+            .unwrap_err()
+            .kind(),
+        ErrorKind::Shrunk
+    );
+    assert_eq!(
+        fetched
+            .check_size(2, IntegrityLimits::new(2, 0.5).unwrap())
+            .unwrap_err()
+            .kind(),
+        ErrorKind::BelowMinimum
+    );
+}
+
+#[rstest]
+#[case::empty(b"{}", "empty")]
+#[case::only_sections(br#"{"sample_spec":{}}"#, "empty")]
+#[case::invalid_json(b"{", "json")]
+#[case::array_root_is_json_error(b"[]", "json")]
+fn malformed_documents_are_rejected_whole(#[case] body: &[u8], #[case] kind: &str) {
+    let error = Catalog::parse(body).unwrap_err();
+    assert_eq!(error.rejects(), Rejects::Document);
+    assert_eq!(<&str>::from(error.kind()), kind);
+}
+
+#[rstest]
+fn written_is_the_document_in_order_including_sections_and_bad_entries() {
+    let body = concat!(
+        r#"{"b":{"litellm_provider":"t","z":1,"a":null},"sample_spec":{"x":"y"},"n":4,"#,
+        r#""fallback_generalizations":{"rules":"bad"},"a":{"mode":"chatt","price":1.0}}"#
+    );
+    let catalog = Catalog::parse(body.as_bytes()).unwrap().value;
+    assert_eq!(written(&catalog), body);
+    assert_eq!(catalog.model_count(), 2);
+}
+
+#[rstest]
+fn the_bundled_registry_parses_with_no_problems_and_every_key_understood() {
+    let loaded = Catalog::parse(BUNDLED_REGISTRY).unwrap();
+    let catalog = loaded.value;
+    assert!(loaded.errors.is_empty(), "{:#?}", loaded.errors);
+    let unrecognized: Vec<_> = catalog.unrecognized().collect();
+    assert!(unrecognized.is_empty(), "{unrecognized:#?}");
+    assert!(
+        catalog
+            .fallback_rules()
+            .is_some_and(|rules| !rules.is_empty())
+    );
+    const REFERENCE_MODEL_COUNT: usize = 4303;
+    assert!(catalog.model_count() as f64 >= REFERENCE_MODEL_COUNT as f64 * 0.9);
+}
+
+#[rstest]
+fn the_bundled_registry_is_written_back_as_it_was_read() {
+    let document: Value = serde_json::from_slice(BUNDLED_REGISTRY).unwrap();
+    assert_eq!(
+        written(&Catalog::parse(BUNDLED_REGISTRY).unwrap().value),
+        serde_json::to_string(&document).unwrap()
+    );
+}
+
+#[rstest]
+fn a_bad_value_keeps_its_json_error_as_the_source_and_names_its_key_and_field() {
+    let parsed =
+        loaded(json!({"open/router": {"litellm_provider": "t", "input_cost_per_token": "free"}}));
+    let error = &parsed.errors[0];
+    let cause = litellm_error::find::<serde_json::Error>(error)
+        .expect("the JSON error is in the chain")
+        .to_string();
+    assert_eq!(report(error).matches(&cause).count(), 1);
+    assert!(!error.to_string().contains(&cause));
+    assert_eq!(error.key().as_deref(), Some("open/router"));
+    assert_eq!(error.field().as_deref(), Some("input_cost_per_token"));
 }
diff --git a/litellm-rust/crates/model-catalog/tests/generate_price_lookup_reference.py b/litellm-rust/crates/model-catalog/tests/generate_price_lookup_reference.py
new file mode 100644
index 00000000000..e49b635ff4a
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/tests/generate_price_lookup_reference.py
@@ -0,0 +1,91 @@
+import itertools
+import json
+import re
+import subprocess
+from pathlib import Path
+from typing import Final
+
+from litellm.litellm_core_utils.llm_cost_calc.utils import _get_token_base_cost
+from litellm.types.utils import Usage
+
+REPO_ROOT: Final = Path(__file__).resolve().parents[4]
+TOKEN_RATE_KEY: Final = re.compile(
+    r"^(input_cost_per_token|output_cost_per_token|cache_read_input_token_cost"
+    r"|cache_creation_input_token_cost(_above_1hr)?)"
+    r"(_above_(\d+)(k?)_tokens)?(_(priority|flex|ultrafast|balanced|batches|decisions))?$"
+)
+SERVICE_TIERS: Final = ("priority", "flex", "ultrafast", "balanced")
+LARGEST_PROMPT: Final = 10_000_000
+INCLUSIVE_PROVIDERS: Final = frozenset({"xai"})
+
+
+def token_rates(entry: dict[str, object]) -> dict[str, object]:
+    return {
+        key: value
+        for key, value in entry.items()
+        if value is not None and (key == "tiered_pricing" or TOKEN_RATE_KEY.match(key))
+    }
+
+
+def band_floors(info: dict[str, object]) -> frozenset[int]:
+    matches: Final = (TOKEN_RATE_KEY.match(key) for key in info)
+    flat: Final = frozenset(
+        int(match.group(4)) * (1000 if match.group(5) else 1)
+        for match in matches
+        if match is not None and match.group(4) is not None
+    )
+    rows: Final = info.get("tiered_pricing")
+    tiers: Final = (
+        frozenset(int(row["range"][0]) for row in rows if isinstance(row, dict) and "range" in row)
+        if isinstance(rows, list)
+        else frozenset()
+    )
+    return flat | tiers
+
+
+def tiers_in(info: dict[str, object]) -> tuple[str | None, ...]:
+    return (None, *(tier for tier in SERVICE_TIERS if any(key.endswith(f"_{tier}") for key in info)))
+
+
+def prompts(info: dict[str, object]) -> tuple[int, ...]:
+    floors: Final = band_floors(info)
+    return tuple(sorted(({1, LARGEST_PROMPT} | floors | {floor + 1 for floor in floors}) - {0}))
+
+
+def check(info: dict[str, object], tier: str | None, prompt: int, inclusive: bool) -> list[object]:
+    usage: Final = Usage(prompt_tokens=prompt, completion_tokens=1, total_tokens=prompt + 1)
+    rates: Final = _get_token_base_cost(info, usage, service_tier=tier, threshold_is_inclusive=inclusive)
+    one_hour: Final = rates.cache_creation_rates_by_ttl.get("1hr", rates.cache_creation_rate)
+    return [tier, prompt, [rates.input_rate, rates.output_rate, rates.cache_creation_rate, one_hour, rates.cache_read_rate]]
+
+
+def shape(info: dict[str, object], inclusive: bool) -> str:
+    rows: Final = info.get("tiered_pricing")
+    row_keys: Final = [sorted(row) for row in rows if isinstance(row, dict)] if isinstance(rows, list) else []
+    return json.dumps([sorted(info), row_keys, inclusive])
+
+
+def checks(info: dict[str, object], inclusive: bool) -> list[list[object]]:
+    return [check(info, tier, prompt, inclusive) for tier, prompt in itertools.product(tiers_in(info), prompts(info))]
+
+
+def main() -> None:
+    registry: Final = json.loads((REPO_ROOT / "model_prices_and_context_window.json").read_text())
+    entries: Final = tuple(
+        (token_rates(entry), entry.get("litellm_provider") in INCLUSIVE_PROVIDERS)
+        for name, entry in registry.items()
+        if name not in ("sample_spec", "fallback_generalizations") and isinstance(entry, dict)
+    )
+    by_shape: Final = {shape(info, inclusive): (info, inclusive) for info, inclusive in reversed(entries) if info}
+    models: Final = tuple(
+        json.dumps({"info": info, "inclusive": inclusive, "checks": checks(info, inclusive)})
+        for info, inclusive in by_shape.values()
+    )
+    revision: Final = subprocess.check_output(("git", "rev-parse", "HEAD"), text=True, cwd=REPO_ROOT).strip()
+    Path(__file__).with_name("price_lookup_reference.json").write_text(
+        f'{{"python_reference_commit": "{revision}", "models": [\n' + ",\n".join(models) + "\n]}\n"
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/litellm-rust/crates/model-catalog/tests/price_lookup.rs b/litellm-rust/crates/model-catalog/tests/price_lookup.rs
new file mode 100644
index 00000000000..cc16e9f23e9
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/tests/price_lookup.rs
@@ -0,0 +1,89 @@
+use litellm_cost::money::UnitPrice;
+use litellm_cost::price::{
+    CacheReadMode, CacheTtl, InputUnit, Meter, OutputUnit, Prices, ServiceTier, TokenKind,
+};
+use litellm_model_catalog::wire::{EntryWire, Fields};
+use rstest::rstest;
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+struct Reference {
+    models: Vec<ReferenceModel>,
+}
+
+#[derive(Deserialize)]
+struct ReferenceModel {
+    info: Fields,
+    inclusive: bool,
+    checks: Vec<(Option<String>, u64, [f64; 5])>,
+}
+
+const METERS: [Meter; 5] = [
+    Meter::Input(InputUnit::Token(TokenKind::Text)),
+    Meter::Output(OutputUnit::Token(TokenKind::Text)),
+    Meter::CacheWrite {
+        kind: TokenKind::Text,
+        ttl: CacheTtl::Default,
+    },
+    Meter::CacheWrite {
+        kind: TokenKind::Text,
+        ttl: CacheTtl::OneHour,
+    },
+    Meter::CacheRead {
+        kind: TokenKind::Text,
+        mode: CacheReadMode::Implicit,
+    },
+];
+
+fn service_tier(name: Option<&str>) -> ServiceTier {
+    match name {
+        None => ServiceTier::Standard,
+        Some("priority") => ServiceTier::Priority,
+        Some("flex") => ServiceTier::Flex,
+        Some("ultrafast") => ServiceTier::Ultrafast,
+        Some("balanced") => ServiceTier::Balanced,
+        Some(other) => panic!("the reference uses an unknown service tier {other}"),
+    }
+}
+
+fn mismatch(
+    prices: &Prices,
+    (tier_name, prompt, python): &(Option<String>, u64, [f64; 5]),
+) -> Option<String> {
+    let tier = service_tier(tier_name.as_deref());
+    let band = prices.band(tier, *prompt);
+    let rust = METERS
+        .each_ref()
+        .map(|meter| prices.rate(meter, tier, band).map_or(0.0, UnitPrice::get));
+    (rust != *python)
+        .then(|| format!("tier={tier_name:?} prompt={prompt}: rust {rust:?}, python {python:?}"))
+}
+
+#[rstest]
+fn band_and_rate_match_python_token_base_cost() {
+    let reference: Reference =
+        serde_json::from_str(include_str!("price_lookup_reference.json")).unwrap();
+
+    let mismatches: Vec<String> = reference
+        .models
+        .iter()
+        .flat_map(|model| {
+            let provider = if model.inclusive { "xai" } else { "openai" };
+            let fields: Fields = model
+                .info
+                .clone()
+                .into_iter()
+                .chain([("litellm_provider".to_owned(), provider.into())])
+                .collect();
+            let prices = Prices::try_from(&EntryWire::read(&fields)).unwrap();
+            model
+                .checks
+                .iter()
+                .filter_map(move |check| mismatch(&prices, check))
+                .map(move |found| format!("{:?} {found}", model.info))
+        })
+        .collect();
+
+    assert!(reference.models.len() > 50);
+    assert!(mismatches.is_empty(), "{mismatches:#?}");
+}
diff --git a/litellm-rust/crates/model-catalog/tests/price_lookup_reference.json b/litellm-rust/crates/model-catalog/tests/price_lookup_reference.json
new file mode 100644
index 00000000000..4b87b696723
--- /dev/null
+++ b/litellm-rust/crates/model-catalog/tests/price_lookup_reference.json
@@ -0,0 +1,89 @@
+{"python_reference_commit": "c7c895db456eda349a7be9661b4b21f578f9b589", "models": [
+{"info": {"cache_creation_input_token_cost": 1.25e-05, "cache_creation_input_token_cost_above_272k_tokens": 2.5e-05, "cache_read_input_token_cost": 1e-06, "cache_read_input_token_cost_above_272k_tokens": 2e-06, "input_cost_per_token": 1e-05, "input_cost_per_token_above_272k_tokens": 2e-05, "output_cost_per_token": 5e-05, "output_cost_per_token_above_272k_tokens": 7.5e-05}, "inclusive": false, "checks": [[null, 1, [1e-05, 5e-05, 1.25e-05, 1.25e-05, 1e-06]], [null, 272000, [1e-05, 5e-05, 1.25e-05, 1.25e-05, 1e-06]], [null, 272001, [2e-05, 7.5e-05, 2.5e-05, 2.5e-05, 2e-06]], [null, 10000000, [2e-05, 7.5e-05, 2.5e-05, 2.5e-05, 2e-06]]]},
+{"info": {"cache_read_input_token_cost": 1e-07, "input_cost_per_token": 1e-06, "output_cost_per_token": 3e-06}, "inclusive": false, "checks": [[null, 1, [1e-06, 3e-06, 1e-06, 1e-06, 1e-07]], [null, 10000000, [1e-06, 3e-06, 1e-06, 1e-06, 1e-07]]]},
+{"info": {"input_cost_per_token": 1.25e-05, "output_cost_per_token": 1.25e-05}, "inclusive": false, "checks": [[null, 1, [1.25e-05, 1.25e-05, 1.25e-05, 1.25e-05, 1.25e-05]], [null, 10000000, [1.25e-05, 1.25e-05, 1.25e-05, 1.25e-05, 1.25e-05]]]},
+{"info": {"cache_creation_input_token_cost": 2.5e-06, "cache_creation_input_token_cost_above_272k_tokens": 5e-06, "cache_creation_input_token_cost_above_272k_tokens_flex": 2.5e-06, "cache_creation_input_token_cost_above_272k_tokens_priority": 1e-05, "cache_creation_input_token_cost_flex": 1.25e-06, "cache_creation_input_token_cost_priority": 5e-06, "cache_read_input_token_cost": 2e-07, "cache_read_input_token_cost_above_272k_tokens": 4e-07, "cache_read_input_token_cost_above_272k_tokens_flex": 2e-07, "cache_read_input_token_cost_above_272k_tokens_priority": 8e-07, "cache_read_input_token_cost_batches": 1e-07, "cache_read_input_token_cost_above_272k_tokens_batches": 2e-07, "cache_creation_input_token_cost_batches": 1.25e-06, "cache_creation_input_token_cost_above_272k_tokens_batches": 2.5e-06, "cache_read_input_token_cost_flex": 1e-07, "cache_read_input_token_cost_priority": 4e-07, "input_cost_per_token": 2e-06, "input_cost_per_token_above_272k_tokens": 4e-06, "input_cost_per_token_above_272k_tokens_flex": 2e-06, "input_cost_per_token_above_272k_tokens_priority": 8e-06, "input_cost_per_token_batches": 1e-06, "input_cost_per_token_above_272k_tokens_batches": 2e-06, "input_cost_per_token_flex": 1e-06, "input_cost_per_token_priority": 4e-06, "output_cost_per_token": 1e-05, "output_cost_per_token_above_272k_tokens": 1.5e-05, "output_cost_per_token_above_272k_tokens_flex": 7.5e-06, "output_cost_per_token_above_272k_tokens_priority": 3e-05, "output_cost_per_token_batches": 5e-06, "output_cost_per_token_above_272k_tokens_batches": 7.5e-06, "output_cost_per_token_flex": 5e-06, "output_cost_per_token_priority": 2e-05}, "inclusive": false, "checks": [[null, 1, [2e-06, 1e-05, 2.5e-06, 2.5e-06, 2e-07]], [null, 272000, [2e-06, 1e-05, 2.5e-06, 2.5e-06, 2e-07]], [null, 272001, [4e-06, 1.5e-05, 5e-06, 5e-06, 4e-07]], [null, 10000000, [4e-06, 1.5e-05, 5e-06, 5e-06, 4e-07]], ["priority", 1, [4e-06, 2e-05, 5e-06, 5e-06, 4e-07]], ["priority", 272000, [4e-06, 2e-05, 5e-06, 5e-06, 4e-07]], ["priority", 272001, [8e-06, 3e-05, 1e-05, 1e-05, 8e-07]], ["priority", 10000000, [8e-06, 3e-05, 1e-05, 1e-05, 8e-07]], ["flex", 1, [1e-06, 5e-06, 1.25e-06, 1.25e-06, 1e-07]], ["flex", 272000, [1e-06, 5e-06, 1.25e-06, 1.25e-06, 1e-07]], ["flex", 272001, [2e-06, 7.5e-06, 2.5e-06, 2.5e-06, 2e-07]], ["flex", 10000000, [2e-06, 7.5e-06, 2.5e-06, 2.5e-06, 2e-07]]]},
+{"info": {"cache_creation_input_token_cost": 1.25e-06, "cache_creation_input_token_cost_above_1hr": 2e-06, "cache_creation_input_token_cost_batches": 6.25e-07, "cache_read_input_token_cost": 1e-07, "cache_read_input_token_cost_batches": 5e-08, "input_cost_per_token": 1e-06, "input_cost_per_token_batches": 5e-07, "output_cost_per_token": 5e-06, "output_cost_per_token_batches": 2.5e-06}, "inclusive": false, "checks": [[null, 1, [1e-06, 5e-06, 1.25e-06, 2e-06, 1e-07]], [null, 10000000, [1e-06, 5e-06, 1.25e-06, 2e-06, 1e-07]]]},
+{"info": {"input_cost_per_token_above_100k_tokens_batches": 2.5e-07, "output_cost_per_token_above_100k_tokens_batches": 1.25e-06, "cache_creation_input_token_cost_above_100k_tokens_batches": 3.125e-07, "cache_read_input_token_cost_above_100k_tokens_batches": 2.5e-08, "cache_creation_input_token_cost": 1.25e-07, "cache_creation_input_token_cost_above_1hr": 2e-07, "cache_creation_input_token_cost_batches": 6.25e-08, "cache_read_input_token_cost": 1e-08, "cache_read_input_token_cost_batches": 5e-09, "input_cost_per_token": 1e-07, "input_cost_per_token_batches": 5e-08, "output_cost_per_token": 5e-07, "output_cost_per_token_batches": 2.5e-07, "input_cost_per_token_above_100k_tokens": 5e-07, "output_cost_per_token_above_100k_tokens": 2.5e-06, "cache_creation_input_token_cost_above_100k_tokens": 6.25e-07, "cache_creation_input_token_cost_above_1hr_above_100k_tokens": 1e-06, "cache_read_input_token_cost_above_100k_tokens": 5e-08}, "inclusive": false, "checks": [[null, 1, [1e-07, 5e-07, 1.25e-07, 2e-07, 1e-08]], [null, 100000, [1e-07, 5e-07, 1.25e-07, 2e-07, 1e-08]], [null, 100001, [5e-07, 2.5e-06, 6.25e-07, 1e-06, 5e-08]], [null, 10000000, [5e-07, 2.5e-06, 6.25e-07, 1e-06, 5e-08]]]},
+{"info": {"input_cost_per_token": 1.0000000000000001e-07, "output_cost_per_token": 5e-07, "cache_read_input_token_cost": 1e-08, "cache_creation_input_token_cost": 1.25e-07, "tiered_pricing": [{"range": [0, 272000], "input_cost_per_token": 1.0000000000000001e-07, "output_cost_per_token": 5e-07, "cache_read_input_token_cost": 1e-08, "cache_creation_input_token_cost": 1.25e-07}, {"range": [272000, 1050000], "input_cost_per_token": 2.0000000000000002e-07, "output_cost_per_token": 7.5e-07, "cache_read_input_token_cost": 2e-08, "cache_creation_input_token_cost": 2.5e-07}]}, "inclusive": false, "checks": [[null, 1, [1.0000000000000001e-07, 5e-07, 1.25e-07, 1.25e-07, 1e-08]], [null, 272000, [1.0000000000000001e-07, 5e-07, 1.25e-07, 1.25e-07, 1e-08]], [null, 272001, [2.0000000000000002e-07, 7.5e-07, 2.5e-07, 2.5e-07, 2e-08]], [null, 10000000, [2.0000000000000002e-07, 7.5e-07, 2.5e-07, 2.5e-07, 2e-08]]]},
+{"info": {"cache_creation_input_token_cost": 1e-06, "cache_read_input_token_cost": 8e-08, "input_cost_per_token": 8e-07, "output_cost_per_token": 4e-06}, "inclusive": false, "checks": [[null, 1, [8e-07, 4e-06, 1e-06, 1e-06, 8e-08]], [null, 10000000, [8e-07, 4e-06, 1e-06, 1e-06, 8e-08]]]},
+{"info": {"input_cost_per_token": 2e-06, "output_cost_per_token": 6e-06, "cache_read_input_token_cost": 5e-07, "tiered_pricing": [{"range": [0, 200000], "input_cost_per_token": 2e-06, "output_cost_per_token": 6e-06, "cache_read_input_token_cost": 5e-07}, {"range": [200000, 500000], "input_cost_per_token": 4e-06, "output_cost_per_token": 1.2e-05, "cache_read_input_token_cost": 1e-06}]}, "inclusive": false, "checks": [[null, 1, [2e-06, 6e-06, 2e-06, 2e-06, 5e-07]], [null, 200000, [2e-06, 6e-06, 2e-06, 2e-06, 5e-07]], [null, 200001, [4e-06, 1.2e-05, 4e-06, 4e-06, 1e-06]], [null, 10000000, [4e-06, 1.2e-05, 4e-06, 4e-06, 1e-06]]]},
+{"info": {"cache_read_input_token_cost": 7.5e-08, "cache_read_input_token_cost_priority": 1.5e-07, "input_cost_per_token": 7.5e-07, "input_cost_per_token_priority": 1.5e-06, "output_cost_per_token": 4.5e-06, "output_cost_per_token_priority": 9e-06}, "inclusive": false, "checks": [[null, 1, [7.5e-07, 4.5e-06, 7.5e-07, 7.5e-07, 7.5e-08]], [null, 10000000, [7.5e-07, 4.5e-06, 7.5e-07, 7.5e-07, 7.5e-08]], ["priority", 1, [1.5e-06, 9e-06, 1.5e-06, 1.5e-06, 1.5e-07]], ["priority", 10000000, [1.5e-06, 9e-06, 1.5e-06, 1.5e-06, 1.5e-07]]]},
+{"info": {"cache_read_input_token_cost": 2e-07, "cache_read_input_token_cost_above_200k_tokens": 4e-07, "input_cost_per_token": 1.25e-06, "input_cost_per_token_above_200k_tokens": 2.5e-06, "output_cost_per_token": 2.5e-06, "output_cost_per_token_above_200k_tokens": 5e-06}, "inclusive": false, "checks": [[null, 1, [1.25e-06, 2.5e-06, 1.25e-06, 1.25e-06, 2e-07]], [null, 200000, [1.25e-06, 2.5e-06, 1.25e-06, 1.25e-06, 2e-07]], [null, 200001, [2.5e-06, 5e-06, 2.5e-06, 2.5e-06, 4e-07]], [null, 10000000, [2.5e-06, 5e-06, 2.5e-06, 2.5e-06, 4e-07]]]},
+{"info": {"cache_creation_input_token_cost": 1.25e-06, "cache_creation_input_token_cost_above_1hr": 2e-06, "cache_read_input_token_cost": 1e-07, "input_cost_per_token": 1e-06, "output_cost_per_token": 5e-06}, "inclusive": false, "checks": [[null, 1, [1e-06, 5e-06, 1.25e-06, 2e-06, 1e-07]], [null, 10000000, [1e-06, 5e-06, 1.25e-06, 2e-06, 1e-07]]]},
+{"info": {"cache_read_input_token_cost": 8.25e-08, "cache_read_input_token_cost_flex": 4.125e-08, "cache_read_input_token_cost_priority": 1.44375e-07, "input_cost_per_token": 3.3e-07, "input_cost_per_token_batches": 1.65e-07, "input_cost_per_token_flex": 1.65e-07, "input_cost_per_token_priority": 5.775e-07, "output_cost_per_token": 2.75e-06, "output_cost_per_token_batches": 1.375e-06, "output_cost_per_token_flex": 1.375e-06, "output_cost_per_token_priority": 4.8125e-06}, "inclusive": false, "checks": [[null, 1, [3.3e-07, 2.75e-06, 3.3e-07, 3.3e-07, 8.25e-08]], [null, 10000000, [3.3e-07, 2.75e-06, 3.3e-07, 3.3e-07, 8.25e-08]], ["priority", 1, [5.775e-07, 4.8125e-06, 5.775e-07, 5.775e-07, 1.44375e-07]], ["priority", 10000000, [5.775e-07, 4.8125e-06, 5.775e-07, 5.775e-07, 1.44375e-07]], ["flex", 1, [1.65e-07, 1.375e-06, 1.65e-07, 1.65e-07, 4.125e-08]], ["flex", 10000000, [1.65e-07, 1.375e-06, 1.65e-07, 1.65e-07, 4.125e-08]]]},
+{"info": {"cache_read_input_token_cost": 7.5e-08, "cache_read_input_token_cost_batches": 3.75e-08, "cache_read_input_token_cost_flex": 3.75e-08, "cache_read_input_token_cost_priority": 1.5e-07, "input_cost_per_token": 7.5e-07, "output_cost_per_token": 4.5e-06, "input_cost_per_token_batches": 3.75e-07, "input_cost_per_token_flex": 3.75e-07, "input_cost_per_token_priority": 1.5e-06, "output_cost_per_token_batches": 2.25e-06, "output_cost_per_token_flex": 2.25e-06, "output_cost_per_token_priority": 9e-06}, "inclusive": false, "checks": [[null, 1, [7.5e-07, 4.5e-06, 7.5e-07, 7.5e-07, 7.5e-08]], [null, 10000000, [7.5e-07, 4.5e-06, 7.5e-07, 7.5e-07, 7.5e-08]], ["priority", 1, [1.5e-06, 9e-06, 1.5e-06, 1.5e-06, 1.5e-07]], ["priority", 10000000, [1.5e-06, 9e-06, 1.5e-06, 1.5e-06, 1.5e-07]], ["flex", 1, [3.75e-07, 2.25e-06, 3.75e-07, 3.75e-07, 3.75e-08]], ["flex", 10000000, [3.75e-07, 2.25e-06, 3.75e-07, 3.75e-07, 3.75e-08]]]},
+{"info": {"cache_read_input_token_cost": 5.5e-09, "input_cost_per_token": 5.5e-08, "input_cost_per_token_batches": 2.75e-08, "output_cost_per_token": 4.4e-07, "output_cost_per_token_batches": 2.2e-07, "cache_read_input_token_cost_batches": 2.75e-09}, "inclusive": false, "checks": [[null, 1, [5.5e-08, 4.4e-07, 5.5e-08, 5.5e-08, 5.5e-09]], [null, 10000000, [5.5e-08, 4.4e-07, 5.5e-08, 5.5e-08, 5.5e-09]]]},
+{"info": {"output_cost_per_token": 0.0}, "inclusive": false, "checks": [[null, 1, [0.0, 0.0, 0.0, 0.0, 0.0]], [null, 10000000, [0.0, 0.0, 0.0, 0.0, 0.0]]]},
+{"info": {"input_cost_per_token_above_100k_tokens": 5e-07, "output_cost_per_token_above_100k_tokens": 2.5e-06, "cache_creation_input_token_cost_above_100k_tokens": 6.25e-07, "cache_creation_input_token_cost_above_1hr_above_100k_tokens": 1e-06, "cache_read_input_token_cost_above_100k_tokens": 5e-08, "cache_creation_input_token_cost": 1.25e-07, "cache_creation_input_token_cost_above_1hr": 2e-07, "cache_creation_input_token_cost_batches": 6.25e-08, "cache_read_input_token_cost": 1e-08, "cache_read_input_token_cost_batches": 5e-09, "input_cost_per_token": 1e-07, "input_cost_per_token_batches": 5e-08, "output_cost_per_token": 5e-07, "output_cost_per_token_batches": 2.5e-07}, "inclusive": false, "checks": [[null, 1, [1e-07, 5e-07, 1.25e-07, 2e-07, 1e-08]], [null, 100000, [1e-07, 5e-07, 1.25e-07, 2e-07, 1e-08]], [null, 100001, [5e-07, 2.5e-06, 6.25e-07, 1e-06, 5e-08]], [null, 10000000, [5e-07, 2.5e-06, 6.25e-07, 1e-06, 5e-08]]]},
+{"info": {"input_cost_per_token_above_100k_tokens": 5.5e-07, "output_cost_per_token_above_100k_tokens": 2.75e-06, "cache_creation_input_token_cost_above_100k_tokens": 6.875e-07, "cache_creation_input_token_cost_above_1hr_above_100k_tokens": 1.1e-06, "cache_read_input_token_cost_above_100k_tokens": 5.5e-08, "cache_creation_input_token_cost": 1.375e-07, "cache_creation_input_token_cost_above_1hr": 2.2e-07, "cache_read_input_token_cost": 1.1e-08, "input_cost_per_token": 1.1e-07, "output_cost_per_token": 5.5e-07}, "inclusive": false, "checks": [[null, 1, [1.1e-07, 5.5e-07, 1.375e-07, 2.2e-07, 1.1e-08]], [null, 100000, [1.1e-07, 5.5e-07, 1.375e-07, 2.2e-07, 1.1e-08]], [null, 100001, [5.5e-07, 2.75e-06, 6.875e-07, 1.1e-06, 5.5e-08]], [null, 10000000, [5.5e-07, 2.75e-06, 6.875e-07, 1.1e-06, 5.5e-08]]]},
+{"info": {"cache_creation_input_token_cost": 4.125e-06, "cache_creation_input_token_cost_flex": 2.0625e-06, "cache_creation_input_token_cost_priority": 7.21875e-06, "cache_read_input_token_cost": 3.3e-07, "cache_read_input_token_cost_flex": 1.65e-07, "cache_read_input_token_cost_priority": 5.775e-07, "input_cost_per_token": 3.3e-06, "input_cost_per_token_flex": 1.65e-06, "input_cost_per_token_priority": 5.775e-06, "output_cost_per_token": 1.65e-05, "output_cost_per_token_flex": 8.25e-06, "output_cost_per_token_priority": 2.8875e-05}, "inclusive": false, "checks": [[null, 1, [3.3e-06, 1.65e-05, 4.125e-06, 4.125e-06, 3.3e-07]], [null, 10000000, [3.3e-06, 1.65e-05, 4.125e-06, 4.125e-06, 3.3e-07]], ["priority", 1, [5.775e-06, 2.8875e-05, 7.21875e-06, 7.21875e-06, 5.775e-07]], ["priority", 10000000, [5.775e-06, 2.8875e-05, 7.21875e-06, 7.21875e-06, 5.775e-07]], ["flex", 1, [1.65e-06, 8.25e-06, 2.0625e-06, 2.0625e-06, 1.65e-07]], ["flex", 10000000, [1.65e-06, 8.25e-06, 2.0625e-06, 2.0625e-06, 1.65e-07]]]},
+{"info": {"cache_read_input_token_cost": 1.375e-07, "cache_read_input_token_cost_priority": 2.75e-07, "input_cost_per_token": 1.375e-06, "input_cost_per_token_batches": 6.875e-07, "input_cost_per_token_priority": 2.75e-06, "output_cost_per_token": 1.1e-05, "output_cost_per_token_batches": 5.5e-06, "output_cost_per_token_priority": 2.2e-05, "cache_read_input_token_cost_batches": 6.875e-08}, "inclusive": false, "checks": [[null, 1, [1.375e-06, 1.1e-05, 1.375e-06, 1.375e-06, 1.375e-07]], [null, 10000000, [1.375e-06, 1.1e-05, 1.375e-06, 1.375e-06, 1.375e-07]], ["priority", 1, [2.75e-06, 2.2e-05, 2.75e-06, 2.75e-06, 2.75e-07]], ["priority", 10000000, [2.75e-06, 2.2e-05, 2.75e-06, 2.75e-06, 2.75e-07]]]},
+{"info": {"input_cost_per_token": 5e-06, "input_cost_per_token_batches": 2.5e-06, "output_cost_per_token": 1.5e-05, "output_cost_per_token_batches": 7.5e-06}, "inclusive": false, "checks": [[null, 1, [5e-06, 1.5e-05, 5e-06, 5e-06, 5e-06]], [null, 10000000, [5e-06, 1.5e-05, 5e-06, 5e-06, 5e-06]]]},
+{"info": {"cache_creation_input_token_cost": 2.1e-06, "cache_creation_input_token_cost_batches": 1.05e-06, "cache_creation_input_token_cost_flex": 1.05e-06, "cache_creation_input_token_cost_priority": 3.675e-06, "cache_read_input_token_cost": 3.12e-07, "cache_read_input_token_cost_batches": 1.56e-07, "cache_read_input_token_cost_flex": 1.56e-07, "cache_read_input_token_cost_priority": 5.46e-07, "input_cost_per_token": 1.68e-06, "input_cost_per_token_batches": 8.4e-07, "input_cost_per_token_flex": 8.4e-07, "input_cost_per_token_priority": 2.94e-06, "output_cost_per_token": 5.28e-06, "output_cost_per_token_batches": 2.64e-06, "output_cost_per_token_flex": 2.64e-06, "output_cost_per_token_priority": 9.24e-06}, "inclusive": false, "checks": [[null, 1, [1.68e-06, 5.28e-06, 2.1e-06, 2.1e-06, 3.12e-07]], [null, 10000000, [1.68e-06, 5.28e-06, 2.1e-06, 2.1e-06, 3.12e-07]], ["priority", 1, [2.94e-06, 9.24e-06, 3.675e-06, 3.675e-06, 5.46e-07]], ["priority", 10000000, [2.94e-06, 9.24e-06, 3.675e-06, 3.675e-06, 5.46e-07]], ["flex", 1, [8.4e-07, 2.64e-06, 1.05e-06, 1.05e-06, 1.56e-07]], ["flex", 10000000, [8.4e-07, 2.64e-06, 1.05e-06, 1.05e-06, 1.56e-07]]]},
+{"info": {"input_cost_per_token": 1.1e-05, "input_cost_per_token_above_272k_tokens": 2.2e-05, "cache_creation_input_token_cost": 1.375e-05, "cache_creation_input_token_cost_above_272k_tokens": 2.75e-05, "cache_creation_input_token_cost_above_272k_tokens_ultrafast": 0.000165, "cache_creation_input_token_cost_ultrafast": 8.25e-05, "cache_read_input_token_cost": 1.1e-06, "cache_read_input_token_cost_above_272k_tokens": 2.2e-06, "cache_read_input_token_cost_above_272k_tokens_ultrafast": 1.32e-05, "cache_read_input_token_cost_ultrafast": 6.6e-06, "input_cost_per_token_above_272k_tokens_ultrafast": 0.000132, "input_cost_per_token_ultrafast": 6.6e-05, "output_cost_per_token": 5.5e-05, "output_cost_per_token_above_272k_tokens": 8.25e-05, "output_cost_per_token_above_272k_tokens_ultrafast": 0.000495, "output_cost_per_token_ultrafast": 0.00033}, "inclusive": false, "checks": [[null, 1, [1.1e-05, 5.5e-05, 1.375e-05, 1.375e-05, 1.1e-06]], [null, 272000, [1.1e-05, 5.5e-05, 1.375e-05, 1.375e-05, 1.1e-06]], [null, 272001, [2.2e-05, 8.25e-05, 2.75e-05, 2.75e-05, 2.2e-06]], [null, 10000000, [2.2e-05, 8.25e-05, 2.75e-05, 2.75e-05, 2.2e-06]], ["ultrafast", 1, [6.6e-05, 0.00033, 8.25e-05, 8.25e-05, 6.6e-06]], ["ultrafast", 272000, [6.6e-05, 0.00033, 8.25e-05, 8.25e-05, 6.6e-06]], ["ultrafast", 272001, [0.000132, 0.000495, 0.000165, 0.000165, 1.32e-05]], ["ultrafast", 10000000, [0.000132, 0.000495, 0.000165, 0.000165, 1.32e-05]]]},
+{"info": {"cache_creation_input_token_cost": 1.25e-05, "cache_creation_input_token_cost_above_272k_tokens": 2.5e-05, "cache_creation_input_token_cost_above_272k_tokens_flex": 1.25e-05, "cache_creation_input_token_cost_above_272k_tokens_priority": 5e-05, "cache_creation_input_token_cost_flex": 6.25e-06, "cache_creation_input_token_cost_priority": 2.5e-05, "cache_read_input_token_cost": 1e-06, "cache_read_input_token_cost_above_272k_tokens": 2e-06, "cache_read_input_token_cost_above_272k_tokens_flex": 1e-06, "cache_read_input_token_cost_above_272k_tokens_priority": 4e-06, "cache_read_input_token_cost_batches": 5e-07, "cache_read_input_token_cost_above_272k_tokens_batches": 1e-06, "cache_creation_input_token_cost_batches": 6.25e-06, "cache_creation_input_token_cost_above_272k_tokens_batches": 1.25e-05, "cache_creation_input_token_cost_above_272k_tokens_ultrafast": 0.00015, "cache_creation_input_token_cost_ultrafast": 7.5e-05, "cache_read_input_token_cost_above_272k_tokens_ultrafast": 1.2e-05, "cache_read_input_token_cost_flex": 5e-07, "cache_read_input_token_cost_priority": 2e-06, "cache_read_input_token_cost_ultrafast": 6e-06, "input_cost_per_token": 1e-05, "input_cost_per_token_above_272k_tokens": 2e-05, "input_cost_per_token_above_272k_tokens_flex": 1e-05, "input_cost_per_token_above_272k_tokens_priority": 4e-05, "input_cost_per_token_batches": 5e-06, "input_cost_per_token_above_272k_tokens_batches": 1e-05, "input_cost_per_token_above_272k_tokens_ultrafast": 0.00012, "input_cost_per_token_flex": 5e-06, "input_cost_per_token_priority": 2e-05, "input_cost_per_token_ultrafast": 6e-05, "output_cost_per_token": 5e-05, "output_cost_per_token_above_272k_tokens": 7.5e-05, "output_cost_per_token_above_272k_tokens_flex": 3.75e-05, "output_cost_per_token_above_272k_tokens_priority": 0.00015, "output_cost_per_token_batches": 2.5e-05, "output_cost_per_token_above_272k_tokens_batches": 3.75e-05, "output_cost_per_token_above_272k_tokens_ultrafast": 0.00045, "output_cost_per_token_flex": 2.5e-05, "output_cost_per_token_priority": 0.0001, "output_cost_per_token_ultrafast": 0.0003}, "inclusive": false, "checks": [[null, 1, [1e-05, 5e-05, 1.25e-05, 1.25e-05, 1e-06]], [null, 272000, [1e-05, 5e-05, 1.25e-05, 1.25e-05, 1e-06]], [null, 272001, [2e-05, 7.5e-05, 2.5e-05, 2.5e-05, 2e-06]], [null, 10000000, [2e-05, 7.5e-05, 2.5e-05, 2.5e-05, 2e-06]], ["priority", 1, [2e-05, 0.0001, 2.5e-05, 2.5e-05, 2e-06]], ["priority", 272000, [2e-05, 0.0001, 2.5e-05, 2.5e-05, 2e-06]], ["priority", 272001, [4e-05, 0.00015, 5e-05, 5e-05, 4e-06]], ["priority", 10000000, [4e-05, 0.00015, 5e-05, 5e-05, 4e-06]], ["flex", 1, [5e-06, 2.5e-05, 6.25e-06, 6.25e-06, 5e-07]], ["flex", 272000, [5e-06, 2.5e-05, 6.25e-06, 6.25e-06, 5e-07]], ["flex", 272001, [1e-05, 3.75e-05, 1.25e-05, 1.25e-05, 1e-06]], ["flex", 10000000, [1e-05, 3.75e-05, 1.25e-05, 1.25e-05, 1e-06]], ["ultrafast", 1, [6e-05, 0.0003, 7.5e-05, 7.5e-05, 6e-06]], ["ultrafast", 272000, [6e-05, 0.0003, 7.5e-05, 7.5e-05, 6e-06]], ["ultrafast", 272001, [0.00012, 0.00045, 0.00015, 0.00015, 1.2e-05]], ["ultrafast", 10000000, [0.00012, 0.00045, 0.00015, 0.00015, 1.2e-05]]]},
+{"info": {"input_cost_per_token": 2.2e-06, "output_cost_per_token": 6.6e-06, "cache_read_input_token_cost": 5.5e-07, "cache_read_input_token_cost_flex": 2.75e-07, "cache_read_input_token_cost_priority": 9.625e-07, "input_cost_per_token_flex": 1.1e-06, "input_cost_per_token_priority": 3.85e-06, "output_cost_per_token_flex": 3.3e-06, "output_cost_per_token_priority": 1.155e-05}, "inclusive": false, "checks": [[null, 1, [2.2e-06, 6.6e-06, 2.2e-06, 2.2e-06, 5.5e-07]], [null, 10000000, [2.2e-06, 6.6e-06, 2.2e-06, 2.2e-06, 5.5e-07]], ["priority", 1, [3.85e-06, 1.155e-05, 3.85e-06, 3.85e-06, 9.625e-07]], ["priority", 10000000, [3.85e-06, 1.155e-05, 3.85e-06, 3.85e-06, 9.625e-07]], ["flex", 1, [1.1e-06, 3.3e-06, 1.1e-06, 1.1e-06, 2.75e-07]], ["flex", 10000000, [1.1e-06, 3.3e-06, 1.1e-06, 1.1e-06, 2.75e-07]]]},
+{"info": {"cache_read_input_token_cost": 3e-06, "cache_read_input_token_cost_above_272k_tokens": 6e-06, "input_cost_per_token": 3e-05, "input_cost_per_token_above_272k_tokens": 6e-05, "output_cost_per_token": 0.00018, "output_cost_per_token_above_272k_tokens": 0.00027}, "inclusive": false, "checks": [[null, 1, [3e-05, 0.00018, 3e-05, 3e-05, 3e-06]], [null, 272000, [3e-05, 0.00018, 3e-05, 3e-05, 3e-06]], [null, 272001, [6e-05, 0.00027, 6e-05, 6e-05, 6e-06]], [null, 10000000, [6e-05, 0.00027, 6e-05, 6e-05, 6e-06]]]},
+{"info": {"input_cost_per_token": 1.5e-07, "input_cost_per_token_batches": 1.2e-07, "output_cost_per_token": 0}, "inclusive": false, "checks": [[null, 1, [1.5e-07, 0.0, 1.5e-07, 1.5e-07, 1.5e-07]], [null, 10000000, [1.5e-07, 0.0, 1.5e-07, 1.5e-07, 1.5e-07]]]},
+{"info": {"cache_read_input_token_cost_priority": 6e-07, "input_cost_per_token_priority": 1.2e-06, "output_cost_per_token_priority": 1.2e-06}, "inclusive": false, "checks": [[null, 1, [0.0, 0.0, 0.0, 0.0, 0.0]], [null, 10000000, [0.0, 0.0, 0.0, 0.0, 0.0]], ["priority", 1, [1.2e-06, 1.2e-06, 1.2e-06, 1.2e-06, 6e-07]], ["priority", 10000000, [1.2e-06, 1.2e-06, 1.2e-06, 1.2e-06, 6e-07]]]},
+{"info": {"cache_read_input_token_cost": 2e-07, "input_cost_per_token": 1.25e-06, "output_cost_per_token": 2.5e-06, "input_cost_per_token_above_200k_tokens": 2.5e-06, "output_cost_per_token_above_200k_tokens": 5e-06, "cache_read_input_token_cost_above_200k_tokens": 4e-07}, "inclusive": true, "checks": [[null, 1, [1.25e-06, 2.5e-06, 1.25e-06, 1.25e-06, 2e-07]], [null, 200000, [2.5e-06, 5e-06, 2.5e-06, 2.5e-06, 4e-07]], [null, 200001, [2.5e-06, 5e-06, 2.5e-06, 2.5e-06, 4e-07]], [null, 10000000, [2.5e-06, 5e-06, 2.5e-06, 2.5e-06, 4e-07]]]},
+{"info": {"cache_read_input_token_cost": 2e-07, "cache_read_input_token_cost_batches": 1.6e-07, "input_cost_per_token": 1.25e-06, "input_cost_per_token_batches": 1e-06, "output_cost_per_token": 2.5e-06, "output_cost_per_token_batches": 2e-06, "input_cost_per_token_above_200k_tokens": 2.5e-06, "input_cost_per_token_above_200k_tokens_batches": 2e-06, "output_cost_per_token_above_200k_tokens": 5e-06, "output_cost_per_token_above_200k_tokens_batches": 4e-06, "cache_read_input_token_cost_above_200k_tokens": 4e-07, "cache_read_input_token_cost_above_200k_tokens_batches": 3.2e-07}, "inclusive": true, "checks": [[null, 1, [1.25e-06, 2.5e-06, 1.25e-06, 1.25e-06, 2e-07]], [null, 200000, [2.5e-06, 5e-06, 2.5e-06, 2.5e-06, 4e-07]], [null, 200001, [2.5e-06, 5e-06, 2.5e-06, 2.5e-06, 4e-07]], [null, 10000000, [2.5e-06, 5e-06, 2.5e-06, 2.5e-06, 4e-07]]]},
+{"info": {"input_cost_per_token": 5e-06}, "inclusive": false, "checks": [[null, 1, [5e-06, 0.0, 5e-06, 5e-06, 5e-06]], [null, 10000000, [5e-06, 0.0, 5e-06, 5e-06, 5e-06]]]},
+{"info": {"cache_read_input_token_cost": 1.5e-08, "input_cost_per_token": 6e-08, "input_cost_per_token_batches": 3e-08, "output_cost_per_token": 2.4e-07, "output_cost_per_token_batches": 1.2e-07}, "inclusive": false, "checks": [[null, 1, [6e-08, 2.4e-07, 6e-08, 6e-08, 1.5e-08]], [null, 10000000, [6e-08, 2.4e-07, 6e-08, 6e-08, 1.5e-08]]]},
+{"info": {"input_cost_per_token": 3.3e-05, "input_cost_per_token_above_272k_tokens": 6.6e-05, "input_cost_per_token_above_272k_tokens_batches": 3.3e-05, "input_cost_per_token_batches": 1.65e-05, "output_cost_per_token": 0.000198, "output_cost_per_token_above_272k_tokens": 0.000297, "output_cost_per_token_above_272k_tokens_batches": 0.0001485, "output_cost_per_token_batches": 9.9e-05}, "inclusive": false, "checks": [[null, 1, [3.3e-05, 0.000198, 3.3e-05, 3.3e-05, 3.3e-05]], [null, 272000, [3.3e-05, 0.000198, 3.3e-05, 3.3e-05, 3.3e-05]], [null, 272001, [6.6e-05, 0.000297, 6.6e-05, 6.6e-05, 6.6e-05]], [null, 10000000, [6.6e-05, 0.000297, 6.6e-05, 6.6e-05, 6.6e-05]]]},
+{"info": {"cache_read_input_token_cost": 7.5e-08, "cache_read_input_token_cost_priority": 1.3125e-07, "input_cost_per_token": 3e-07, "input_cost_per_token_batches": 1.5e-07, "input_cost_per_token_priority": 5.25e-07, "output_cost_per_token": 2.5e-06, "output_cost_per_token_batches": 1.25e-06, "output_cost_per_token_priority": 4.375e-06}, "inclusive": false, "checks": [[null, 1, [3e-07, 2.5e-06, 3e-07, 3e-07, 7.5e-08]], [null, 10000000, [3e-07, 2.5e-06, 3e-07, 3e-07, 7.5e-08]], ["priority", 1, [5.25e-07, 4.375e-06, 5.25e-07, 5.25e-07, 1.3125e-07]], ["priority", 10000000, [5.25e-07, 4.375e-06, 5.25e-07, 5.25e-07, 1.3125e-07]]]},
+{"info": {"input_cost_per_token": 1.25e-06, "output_cost_per_token": 2.5e-06, "cache_read_input_token_cost": 2e-07, "input_cost_per_token_above_200k_tokens": 2.5e-06, "output_cost_per_token_above_200k_tokens": 5e-06}, "inclusive": false, "checks": [[null, 1, [1.25e-06, 2.5e-06, 1.25e-06, 1.25e-06, 2e-07]], [null, 200000, [1.25e-06, 2.5e-06, 1.25e-06, 1.25e-06, 2e-07]], [null, 200001, [2.5e-06, 5e-06, 2.5e-06, 2.5e-06, 2e-07]], [null, 10000000, [2.5e-06, 5e-06, 2.5e-06, 2.5e-06, 2e-07]]]},
+{"info": {"input_cost_per_token": 5e-06, "output_cost_per_token": 3e-05, "cache_read_input_token_cost": 5e-07, "input_cost_per_token_above_272k_tokens": 1e-05, "output_cost_per_token_above_272k_tokens": 4.5e-05}, "inclusive": false, "checks": [[null, 1, [5e-06, 3e-05, 5e-06, 5e-06, 5e-07]], [null, 272000, [5e-06, 3e-05, 5e-06, 5e-06, 5e-07]], [null, 272001, [1e-05, 4.5e-05, 1e-05, 1e-05, 5e-07]], [null, 10000000, [1e-05, 4.5e-05, 1e-05, 1e-05, 5e-07]]]},
+{"info": {"input_cost_per_token": 1.5e-07, "input_cost_per_token_batches": 7.5e-08, "input_cost_per_token_flex": 7.5e-08, "input_cost_per_token_priority": 2.625e-07, "output_cost_per_token": 6e-07, "output_cost_per_token_batches": 3e-07, "output_cost_per_token_flex": 3e-07, "output_cost_per_token_priority": 1.05e-06}, "inclusive": false, "checks": [[null, 1, [1.5e-07, 6e-07, 1.5e-07, 1.5e-07, 1.5e-07]], [null, 10000000, [1.5e-07, 6e-07, 1.5e-07, 1.5e-07, 1.5e-07]], ["priority", 1, [2.625e-07, 1.05e-06, 2.625e-07, 2.625e-07, 2.625e-07]], ["priority", 10000000, [2.625e-07, 1.05e-06, 2.625e-07, 2.625e-07, 2.625e-07]], ["flex", 1, [7.5e-08, 3e-07, 7.5e-08, 7.5e-08, 7.5e-08]], ["flex", 10000000, [7.5e-08, 3e-07, 7.5e-08, 7.5e-08, 7.5e-08]]]},
+{"info": {"tiered_pricing": [{"input_cost_per_token": 1.2e-06, "output_cost_per_token": 6e-06, "range": [0, 32000.0]}, {"input_cost_per_token": 2.4e-06, "output_cost_per_token": 1.2e-05, "range": [32000.0, 128000.0]}, {"input_cost_per_token": 3e-06, "output_cost_per_token": 1.5e-05, "range": [128000.0, 252000.0]}]}, "inclusive": false, "checks": [[null, 1, [1.2e-06, 6e-06, 1.2e-06, 1.2e-06, 1.2e-06]], [null, 32000, [1.2e-06, 6e-06, 1.2e-06, 1.2e-06, 1.2e-06]], [null, 32001, [2.4e-06, 1.2e-05, 2.4e-06, 2.4e-06, 2.4e-06]], [null, 128000, [2.4e-06, 1.2e-05, 2.4e-06, 2.4e-06, 2.4e-06]], [null, 128001, [3e-06, 1.5e-05, 3e-06, 3e-06, 3e-06]], [null, 10000000, [3e-06, 1.5e-05, 3e-06, 3e-06, 3e-06]]]},
+{"info": {"cache_creation_input_token_cost": 1.25e-06, "cache_creation_input_token_cost_above_1hr": 2e-06, "cache_read_input_token_cost": 1e-07, "input_cost_per_token": 1e-06, "output_cost_per_token": 5e-06, "input_cost_per_token_batches": 5e-07, "output_cost_per_token_batches": 2.5e-06}, "inclusive": false, "checks": [[null, 1, [1e-06, 5e-06, 1.25e-06, 2e-06, 1e-07]], [null, 10000000, [1e-06, 5e-06, 1.25e-06, 2e-06, 1e-07]]]},
+{"info": {"cache_read_input_token_cost": 2e-07, "cache_read_input_token_cost_above_200k_tokens": 4e-07, "input_cost_per_token": 2e-06, "input_cost_per_token_above_200k_tokens": 4e-06, "output_cost_per_token": 1.2e-05, "output_cost_per_token_above_200k_tokens": 1.8e-05, "cache_read_input_token_cost_above_200k_tokens_priority": 7.2e-07, "cache_read_input_token_cost_priority": 3.6e-07, "input_cost_per_token_above_200k_tokens_priority": 7.2e-06, "input_cost_per_token_batches": 1e-06, "input_cost_per_token_priority": 3.6e-06, "output_cost_per_token_above_200k_tokens_priority": 3.24e-05, "output_cost_per_token_batches": 6e-06, "output_cost_per_token_priority": 2.16e-05, "cache_read_input_token_cost_flex": 2e-07, "input_cost_per_token_flex": 1e-06, "output_cost_per_token_flex": 6e-06}, "inclusive": false, "checks": [[null, 1, [2e-06, 1.2e-05, 2e-06, 2e-06, 2e-07]], [null, 200000, [2e-06, 1.2e-05, 2e-06, 2e-06, 2e-07]], [null, 200001, [4e-06, 1.8e-05, 4e-06, 4e-06, 4e-07]], [null, 10000000, [4e-06, 1.8e-05, 4e-06, 4e-06, 4e-07]], ["priority", 1, [3.6e-06, 2.16e-05, 3.6e-06, 3.6e-06, 3.6e-07]], ["priority", 200000, [3.6e-06, 2.16e-05, 3.6e-06, 3.6e-06, 3.6e-07]], ["priority", 200001, [7.2e-06, 3.24e-05, 7.2e-06, 7.2e-06, 7.2e-07]], ["priority", 10000000, [7.2e-06, 3.24e-05, 7.2e-06, 7.2e-06, 7.2e-07]], ["flex", 1, [1e-06, 6e-06, 1e-06, 1e-06, 2e-07]], ["flex", 200000, [1e-06, 6e-06, 1e-06, 1e-06, 2e-07]], ["flex", 200001, [4e-06, 1.8e-05, 4e-06, 4e-06, 4e-07]], ["flex", 10000000, [4e-06, 1.8e-05, 4e-06, 4e-06, 4e-07]]]},
+{"info": {"input_cost_per_token": 5e-06, "input_cost_per_token_batches": 2.5e-06, "input_cost_per_token_priority": 8.75e-06, "output_cost_per_token": 1.5e-05, "output_cost_per_token_batches": 7.5e-06, "output_cost_per_token_priority": 2.625e-05}, "inclusive": false, "checks": [[null, 1, [5e-06, 1.5e-05, 5e-06, 5e-06, 5e-06]], [null, 10000000, [5e-06, 1.5e-05, 5e-06, 5e-06, 5e-06]], ["priority", 1, [8.75e-06, 2.625e-05, 8.75e-06, 8.75e-06, 8.75e-06]], ["priority", 10000000, [8.75e-06, 2.625e-05, 8.75e-06, 8.75e-06, 8.75e-06]]]},
+{"info": {"cache_read_input_token_cost": 2e-07, "cache_read_input_token_cost_priority": 3.6e-07, "cache_read_input_token_cost_above_200k_tokens": 4e-07, "cache_read_input_token_cost_above_200k_tokens_priority": 7.2e-07, "cache_read_input_token_cost_batches": 1e-07, "input_cost_per_token": 2e-06, "input_cost_per_token_priority": 3.6e-06, "input_cost_per_token_above_200k_tokens": 4e-06, "input_cost_per_token_above_200k_tokens_priority": 7.2e-06, "input_cost_per_token_batches": 1e-06, "output_cost_per_token": 1.2e-05, "output_cost_per_token_priority": 2.16e-05, "output_cost_per_token_above_200k_tokens": 1.8e-05, "output_cost_per_token_above_200k_tokens_priority": 3.24e-05, "output_cost_per_token_batches": 6e-06}, "inclusive": false, "checks": [[null, 1, [2e-06, 1.2e-05, 2e-06, 2e-06, 2e-07]], [null, 200000, [2e-06, 1.2e-05, 2e-06, 2e-06, 2e-07]], [null, 200001, [4e-06, 1.8e-05, 4e-06, 4e-06, 4e-07]], [null, 10000000, [4e-06, 1.8e-05, 4e-06, 4e-06, 4e-07]], ["priority", 1, [3.6e-06, 2.16e-05, 3.6e-06, 3.6e-06, 3.6e-07]], ["priority", 200000, [3.6e-06, 2.16e-05, 3.6e-06, 3.6e-06, 3.6e-07]], ["priority", 200001, [7.2e-06, 3.24e-05, 7.2e-06, 7.2e-06, 7.2e-07]], ["priority", 10000000, [7.2e-06, 3.24e-05, 7.2e-06, 7.2e-06, 7.2e-07]]]},
+{"info": {"cache_read_input_token_cost": 2e-07, "cache_read_input_token_cost_above_200k_tokens": 4e-07, "cache_read_input_token_cost_above_200k_tokens_priority": 7.2e-07, "cache_read_input_token_cost_batches": 1e-07, "cache_read_input_token_cost_flex": 1e-07, "cache_read_input_token_cost_priority": 3.6e-07, "input_cost_per_token": 2e-06, "input_cost_per_token_above_200k_tokens": 4e-06, "input_cost_per_token_above_200k_tokens_priority": 7.2e-06, "input_cost_per_token_batches": 1e-06, "input_cost_per_token_flex": 1e-06, "input_cost_per_token_priority": 3.6e-06, "output_cost_per_token": 1.2e-05, "output_cost_per_token_above_200k_tokens": 1.8e-05, "output_cost_per_token_above_200k_tokens_priority": 3.24e-05, "output_cost_per_token_batches": 6e-06, "output_cost_per_token_flex": 6e-06, "output_cost_per_token_priority": 2.16e-05}, "inclusive": false, "checks": [[null, 1, [2e-06, 1.2e-05, 2e-06, 2e-06, 2e-07]], [null, 200000, [2e-06, 1.2e-05, 2e-06, 2e-06, 2e-07]], [null, 200001, [4e-06, 1.8e-05, 4e-06, 4e-06, 4e-07]], [null, 10000000, [4e-06, 1.8e-05, 4e-06, 4e-06, 4e-07]], ["priority", 1, [3.6e-06, 2.16e-05, 3.6e-06, 3.6e-06, 3.6e-07]], ["priority", 200000, [3.6e-06, 2.16e-05, 3.6e-06, 3.6e-06, 3.6e-07]], ["priority", 200001, [7.2e-06, 3.24e-05, 7.2e-06, 7.2e-06, 7.2e-07]], ["priority", 10000000, [7.2e-06, 3.24e-05, 7.2e-06, 7.2e-06, 7.2e-07]], ["flex", 1, [1e-06, 6e-06, 1e-06, 1e-06, 1e-07]], ["flex", 200000, [1e-06, 6e-06, 1e-06, 1e-06, 1e-07]], ["flex", 200001, [4e-06, 1.8e-05, 4e-06, 4e-06, 4e-07]], ["flex", 10000000, [4e-06, 1.8e-05, 4e-06, 4e-06, 4e-07]]]},
+{"info": {"input_cost_per_token": 3e-07, "input_cost_per_token_batches": 1.5e-07, "input_cost_per_token_flex": 1.5e-07, "output_cost_per_token": 2.5e-06, "output_cost_per_token_batches": 1.25e-06, "output_cost_per_token_flex": 1.25e-06}, "inclusive": false, "checks": [[null, 1, [3e-07, 2.5e-06, 3e-07, 3e-07, 3e-07]], [null, 10000000, [3e-07, 2.5e-06, 3e-07, 3e-07, 3e-07]], ["flex", 1, [1.5e-07, 1.25e-06, 1.5e-07, 1.5e-07, 1.5e-07]], ["flex", 10000000, [1.5e-07, 1.25e-06, 1.5e-07, 1.5e-07, 1.5e-07]]]},
+{"info": {"cache_creation_input_token_cost": 3.75e-06, "cache_creation_input_token_cost_above_1hr": 6e-06, "cache_creation_input_token_cost_above_1hr_above_200k_tokens": 1.2e-05, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, "input_cost_per_token_above_200k_tokens": 6e-06, "output_cost_per_token_above_200k_tokens": 2.25e-05, "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, "cache_read_input_token_cost_above_200k_tokens": 6e-07, "cache_read_input_token_cost_batches": 1.5e-07, "input_cost_per_token_batches": 1.5e-06, "output_cost_per_token": 1.5e-05, "output_cost_per_token_batches": 7.5e-06, "cache_creation_input_token_cost_batches": 1.88e-06}, "inclusive": false, "checks": [[null, 1, [3e-06, 1.5e-05, 3.75e-06, 6e-06, 3e-07]], [null, 200000, [3e-06, 1.5e-05, 3.75e-06, 6e-06, 3e-07]], [null, 200001, [6e-06, 2.25e-05, 7.5e-06, 1.2e-05, 6e-07]], [null, 10000000, [6e-06, 2.25e-05, 7.5e-06, 1.2e-05, 6e-07]]]},
+{"info": {"input_cost_per_token": 7.4e-07, "input_cost_per_token_flex": 3.7e-07, "output_cost_per_token": 2.22e-06, "output_cost_per_token_flex": 1.11e-06}, "inclusive": false, "checks": [[null, 1, [7.4e-07, 2.22e-06, 7.4e-07, 7.4e-07, 7.4e-07]], [null, 10000000, [7.4e-07, 2.22e-06, 7.4e-07, 7.4e-07, 7.4e-07]], ["flex", 1, [3.7e-07, 1.11e-06, 3.7e-07, 3.7e-07, 3.7e-07]], ["flex", 10000000, [3.7e-07, 1.11e-06, 3.7e-07, 3.7e-07, 3.7e-07]]]},
+{"info": {"cache_creation_input_token_cost": 3.75e-06, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, "input_cost_per_token_above_200k_tokens": 6e-06, "output_cost_per_token_above_200k_tokens": 2.25e-05, "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, "cache_read_input_token_cost_above_200k_tokens": 6e-07, "output_cost_per_token": 1.5e-05}, "inclusive": false, "checks": [[null, 1, [3e-06, 1.5e-05, 3.75e-06, 3.75e-06, 3e-07]], [null, 200000, [3e-06, 1.5e-05, 3.75e-06, 3.75e-06, 3e-07]], [null, 200001, [6e-06, 2.25e-05, 7.5e-06, 7.5e-06, 6e-07]], [null, 10000000, [6e-06, 2.25e-05, 7.5e-06, 7.5e-06, 6e-07]]]},
+{"info": {"cache_creation_input_token_cost": 4.5e-06, "cache_creation_input_token_cost_above_1hr": 7.2e-06, "cache_read_input_token_cost": 3.6e-07, "input_cost_per_token": 3.6e-06, "input_cost_per_token_above_200k_tokens": 7.2e-06, "output_cost_per_token_above_200k_tokens": 2.7e-05, "cache_creation_input_token_cost_above_200k_tokens": 9e-06, "cache_creation_input_token_cost_above_1hr_above_200k_tokens": 1.44e-05, "cache_read_input_token_cost_above_200k_tokens": 7.2e-07, "output_cost_per_token": 1.8e-05}, "inclusive": false, "checks": [[null, 1, [3.6e-06, 1.8e-05, 4.5e-06, 7.2e-06, 3.6e-07]], [null, 200000, [3.6e-06, 1.8e-05, 4.5e-06, 7.2e-06, 3.6e-07]], [null, 200001, [7.2e-06, 2.7e-05, 9e-06, 1.44e-05, 7.2e-07]], [null, 10000000, [7.2e-06, 2.7e-05, 9e-06, 1.44e-05, 7.2e-07]]]},
+{"info": {"cache_creation_input_token_cost": 3.75e-06, "cache_creation_input_token_cost_above_1hr": 6e-06, "cache_creation_input_token_cost_above_1hr_above_200k_tokens": 1.2e-05, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, "input_cost_per_token_above_200k_tokens": 6e-06, "output_cost_per_token_above_200k_tokens": 2.25e-05, "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, "cache_read_input_token_cost_above_200k_tokens": 6e-07, "output_cost_per_token": 1.5e-05, "input_cost_per_token_batches": 1.5e-06, "output_cost_per_token_batches": 7.5e-06}, "inclusive": false, "checks": [[null, 1, [3e-06, 1.5e-05, 3.75e-06, 6e-06, 3e-07]], [null, 200000, [3e-06, 1.5e-05, 3.75e-06, 6e-06, 3e-07]], [null, 200001, [6e-06, 2.25e-05, 7.5e-06, 1.2e-05, 6e-07]], [null, 10000000, [6e-06, 2.25e-05, 7.5e-06, 1.2e-05, 6e-07]]]},
+{"info": {"input_cost_per_token": 1.25e-06, "input_cost_per_token_above_200k_tokens": 2.5e-06, "output_cost_per_token": 1e-05, "output_cost_per_token_above_200k_tokens": 1.5e-05}, "inclusive": false, "checks": [[null, 1, [1.25e-06, 1e-05, 1.25e-06, 1.25e-06, 1.25e-06]], [null, 200000, [1.25e-06, 1e-05, 1.25e-06, 1.25e-06, 1.25e-06]], [null, 200001, [2.5e-06, 1.5e-05, 2.5e-06, 2.5e-06, 2.5e-06]], [null, 10000000, [2.5e-06, 1.5e-05, 2.5e-06, 2.5e-06, 2.5e-06]]]},
+{"info": {"cache_read_input_token_cost": 1.25e-06, "input_cost_per_token": 5e-06}, "inclusive": false, "checks": [[null, 1, [5e-06, 0.0, 5e-06, 5e-06, 1.25e-06]], [null, 10000000, [5e-06, 0.0, 5e-06, 5e-06, 1.25e-06]]]},
+{"info": {"input_cost_per_token": 3e-07, "input_cost_per_token_above_512k_tokens": 6e-07, "output_cost_per_token": 1.2e-06, "output_cost_per_token_above_512k_tokens": 2.4e-06, "cache_read_input_token_cost": 6e-08, "cache_read_input_token_cost_above_512k_tokens": 1.2e-07}, "inclusive": false, "checks": [[null, 1, [3e-07, 1.2e-06, 3e-07, 3e-07, 6e-08]], [null, 512000, [3e-07, 1.2e-06, 3e-07, 3e-07, 6e-08]], [null, 512001, [6e-07, 2.4e-06, 6e-07, 6e-07, 1.2e-07]], [null, 10000000, [6e-07, 2.4e-06, 6e-07, 6e-07, 1.2e-07]]]},
+{"info": {"cache_read_input_token_cost": 1.25e-06, "cache_read_input_token_cost_batches": 6.25e-07, "input_cost_per_token": 5e-06, "input_cost_per_token_batches": 2.5e-06}, "inclusive": false, "checks": [[null, 1, [5e-06, 0.0, 5e-06, 5e-06, 1.25e-06]], [null, 10000000, [5e-06, 0.0, 5e-06, 5e-06, 1.25e-06]]]},
+{"info": {"cache_read_input_token_cost": 5e-09, "cache_read_input_token_cost_batches": 2.5e-09, "cache_read_input_token_cost_flex": 2.5e-09, "input_cost_per_token": 5e-08, "input_cost_per_token_batches": 2.5e-08, "input_cost_per_token_flex": 2.5e-08, "input_cost_per_token_priority": 2.5e-06, "output_cost_per_token": 4e-07, "output_cost_per_token_batches": 2e-07, "output_cost_per_token_flex": 2e-07}, "inclusive": false, "checks": [[null, 1, [5e-08, 4e-07, 5e-08, 5e-08, 5e-09]], [null, 10000000, [5e-08, 4e-07, 5e-08, 5e-08, 5e-09]], ["priority", 1, [2.5e-06, 4e-07, 2.5e-06, 2.5e-06, 5e-09]], ["priority", 10000000, [2.5e-06, 4e-07, 2.5e-06, 2.5e-06, 5e-09]], ["flex", 1, [2.5e-08, 2e-07, 2.5e-08, 2.5e-08, 2.5e-09]], ["flex", 10000000, [2.5e-08, 2e-07, 2.5e-08, 2.5e-08, 2.5e-09]]]},
+{"info": {"cache_read_input_token_cost": 2e-08, "cache_read_input_token_cost_batches": 1e-08, "cache_read_input_token_cost_flex": 1e-08, "input_cost_per_token": 2e-07, "output_cost_per_token": 1.25e-06, "input_cost_per_token_batches": 1e-07, "input_cost_per_token_flex": 1e-07, "output_cost_per_token_batches": 6.25e-07, "output_cost_per_token_flex": 6.25e-07}, "inclusive": false, "checks": [[null, 1, [2e-07, 1.25e-06, 2e-07, 2e-07, 2e-08]], [null, 10000000, [2e-07, 1.25e-06, 2e-07, 2e-07, 2e-08]], ["flex", 1, [1e-07, 6.25e-07, 1e-07, 1e-07, 1e-08]], ["flex", 10000000, [1e-07, 6.25e-07, 1e-07, 1e-07, 1e-08]]]},
+{"info": {"input_cost_per_token": 3e-05, "input_cost_per_token_above_272k_tokens": 6e-05, "input_cost_per_token_flex": 1.5e-05, "input_cost_per_token_batches": 1.5e-05, "input_cost_per_token_above_272k_tokens_batches": 3e-05, "output_cost_per_token": 0.00018, "output_cost_per_token_above_272k_tokens": 0.00027, "output_cost_per_token_flex": 9e-05, "output_cost_per_token_batches": 9e-05, "output_cost_per_token_above_272k_tokens_batches": 0.000135, "input_cost_per_token_above_272k_tokens_flex": 3e-05, "output_cost_per_token_above_272k_tokens_flex": 0.000135}, "inclusive": false, "checks": [[null, 1, [3e-05, 0.00018, 3e-05, 3e-05, 3e-05]], [null, 272000, [3e-05, 0.00018, 3e-05, 3e-05, 3e-05]], [null, 272001, [6e-05, 0.00027, 6e-05, 6e-05, 6e-05]], [null, 10000000, [6e-05, 0.00027, 6e-05, 6e-05, 6e-05]], ["flex", 1, [1.5e-05, 9e-05, 1.5e-05, 1.5e-05, 1.5e-05]], ["flex", 272000, [1.5e-05, 9e-05, 1.5e-05, 1.5e-05, 1.5e-05]], ["flex", 272001, [3e-05, 0.000135, 3e-05, 3e-05, 3e-05]], ["flex", 10000000, [3e-05, 0.000135, 3e-05, 3e-05, 3e-05]]]},
+{"info": {"cache_read_input_token_cost": 5e-07, "cache_read_input_token_cost_above_272k_tokens": 1e-06, "cache_read_input_token_cost_batches": 2.5e-07, "cache_read_input_token_cost_above_272k_tokens_batches": 5e-07, "cache_read_input_token_cost_flex": 2.5e-07, "cache_read_input_token_cost_priority": 1.25e-06, "input_cost_per_token": 5e-06, "input_cost_per_token_above_272k_tokens": 1e-05, "input_cost_per_token_flex": 2.5e-06, "input_cost_per_token_batches": 2.5e-06, "input_cost_per_token_above_272k_tokens_batches": 5e-06, "input_cost_per_token_priority": 1.25e-05, "output_cost_per_token": 3e-05, "output_cost_per_token_above_272k_tokens": 4.5e-05, "output_cost_per_token_flex": 1.5e-05, "output_cost_per_token_batches": 1.5e-05, "output_cost_per_token_above_272k_tokens_batches": 2.25e-05, "output_cost_per_token_priority": 7.5e-05, "input_cost_per_token_above_272k_tokens_flex": 5e-06, "output_cost_per_token_above_272k_tokens_flex": 2.25e-05, "cache_read_input_token_cost_above_272k_tokens_flex": 5e-07}, "inclusive": false, "checks": [[null, 1, [5e-06, 3e-05, 5e-06, 5e-06, 5e-07]], [null, 272000, [5e-06, 3e-05, 5e-06, 5e-06, 5e-07]], [null, 272001, [1e-05, 4.5e-05, 1e-05, 1e-05, 1e-06]], [null, 10000000, [1e-05, 4.5e-05, 1e-05, 1e-05, 1e-06]], ["priority", 1, [1.25e-05, 7.5e-05, 1.25e-05, 1.25e-05, 1.25e-06]], ["priority", 272000, [1.25e-05, 7.5e-05, 1.25e-05, 1.25e-05, 1.25e-06]], ["priority", 272001, [1e-05, 4.5e-05, 1e-05, 1e-05, 1e-06]], ["priority", 10000000, [1e-05, 4.5e-05, 1e-05, 1e-05, 1e-06]], ["flex", 1, [2.5e-06, 1.5e-05, 2.5e-06, 2.5e-06, 2.5e-07]], ["flex", 272000, [2.5e-06, 1.5e-05, 2.5e-06, 2.5e-06, 2.5e-07]], ["flex", 272001, [5e-06, 2.25e-05, 5e-06, 5e-06, 5e-07]], ["flex", 10000000, [5e-06, 2.25e-05, 5e-06, 5e-06, 5e-07]]]},
+{"info": {"input_cost_per_token": 3e-05, "input_cost_per_token_above_272k_tokens": 6e-05, "input_cost_per_token_flex": 1.5e-05, "input_cost_per_token_batches": 1.5e-05, "input_cost_per_token_above_272k_tokens_batches": 3e-05, "output_cost_per_token": 0.00018, "output_cost_per_token_above_272k_tokens": 0.00027, "output_cost_per_token_flex": 9e-05, "output_cost_per_token_batches": 9e-05, "output_cost_per_token_above_272k_tokens_batches": 0.000135}, "inclusive": false, "checks": [[null, 1, [3e-05, 0.00018, 3e-05, 3e-05, 3e-05]], [null, 272000, [3e-05, 0.00018, 3e-05, 3e-05, 3e-05]], [null, 272001, [6e-05, 0.00027, 6e-05, 6e-05, 6e-05]], [null, 10000000, [6e-05, 0.00027, 6e-05, 6e-05, 6e-05]], ["flex", 1, [1.5e-05, 9e-05, 1.5e-05, 1.5e-05, 1.5e-05]], ["flex", 272000, [1.5e-05, 9e-05, 1.5e-05, 1.5e-05, 1.5e-05]], ["flex", 272001, [6e-05, 0.00027, 6e-05, 6e-05, 6e-05]], ["flex", 10000000, [6e-05, 0.00027, 6e-05, 6e-05, 6e-05]]]},
+{"info": {"cache_creation_input_token_cost": 1.25e-07, "cache_creation_input_token_cost_decisions": 1.25e-07, "cache_creation_input_token_cost_above_272k_tokens": 2.5e-07, "cache_creation_input_token_cost_above_272k_tokens_decisions": 2.5e-07, "cache_creation_input_token_cost_above_272k_tokens_flex": 1.25e-07, "cache_creation_input_token_cost_above_272k_tokens_priority": 5e-07, "cache_creation_input_token_cost_flex": 6.25e-08, "cache_creation_input_token_cost_priority": 2.5e-07, "cache_read_input_token_cost": 1e-08, "cache_read_input_token_cost_decisions": 1e-08, "cache_read_input_token_cost_above_272k_tokens": 2e-08, "cache_read_input_token_cost_above_272k_tokens_decisions": 2e-08, "cache_read_input_token_cost_above_272k_tokens_flex": 1e-08, "cache_read_input_token_cost_above_272k_tokens_priority": 4e-08, "cache_read_input_token_cost_batches": 5e-09, "cache_read_input_token_cost_above_272k_tokens_batches": 1e-08, "cache_creation_input_token_cost_batches": 6.25e-08, "cache_creation_input_token_cost_above_272k_tokens_batches": 1.25e-07, "cache_read_input_token_cost_flex": 5e-09, "cache_read_input_token_cost_priority": 2e-08, "input_cost_per_token": 1e-07, "input_cost_per_token_decisions": 1e-07, "input_cost_per_token_above_272k_tokens": 2e-07, "input_cost_per_token_above_272k_tokens_decisions": 2e-07, "input_cost_per_token_above_272k_tokens_flex": 1e-07, "input_cost_per_token_above_272k_tokens_priority": 4e-07, "input_cost_per_token_batches": 5e-08, "input_cost_per_token_above_272k_tokens_batches": 1e-07, "input_cost_per_token_flex": 5e-08, "input_cost_per_token_priority": 2e-07, "output_cost_per_token": 5e-07, "output_cost_per_token_decisions": 0.0, "output_cost_per_token_above_272k_tokens": 7.5e-07, "output_cost_per_token_above_272k_tokens_decisions": 0.0, "output_cost_per_token_above_272k_tokens_flex": 3.75e-07, "output_cost_per_token_above_272k_tokens_priority": 1.5e-06, "output_cost_per_token_batches": 2.5e-07, "output_cost_per_token_above_272k_tokens_batches": 3.75e-07, "output_cost_per_token_flex": 2.5e-07, "output_cost_per_token_priority": 1e-06}, "inclusive": false, "checks": [[null, 1, [1e-07, 5e-07, 1.25e-07, 1.25e-07, 1e-08]], [null, 272000, [1e-07, 5e-07, 1.25e-07, 1.25e-07, 1e-08]], [null, 272001, [2e-07, 7.5e-07, 2.5e-07, 2.5e-07, 2e-08]], [null, 10000000, [2e-07, 7.5e-07, 2.5e-07, 2.5e-07, 2e-08]], ["priority", 1, [2e-07, 1e-06, 2.5e-07, 2.5e-07, 2e-08]], ["priority", 272000, [2e-07, 1e-06, 2.5e-07, 2.5e-07, 2e-08]], ["priority", 272001, [4e-07, 1.5e-06, 5e-07, 5e-07, 4e-08]], ["priority", 10000000, [4e-07, 1.5e-06, 5e-07, 5e-07, 4e-08]], ["flex", 1, [5e-08, 2.5e-07, 6.25e-08, 6.25e-08, 5e-09]], ["flex", 272000, [5e-08, 2.5e-07, 6.25e-08, 6.25e-08, 5e-09]], ["flex", 272001, [1e-07, 3.75e-07, 1.25e-07, 1.25e-07, 1e-08]], ["flex", 10000000, [1e-07, 3.75e-07, 1.25e-07, 1.25e-07, 1e-08]]]},
+{"info": {"cache_creation_input_token_cost": 1.25e-07, "cache_creation_input_token_cost_above_100k_tokens": 6.25e-07, "cache_read_input_token_cost": 1e-08, "cache_read_input_token_cost_above_100k_tokens": 5e-08, "input_cost_per_token": 1e-07, "input_cost_per_token_above_100k_tokens": 5e-07, "output_cost_per_token": 5e-07, "output_cost_per_token_above_100k_tokens": 2.5e-06}, "inclusive": false, "checks": [[null, 1, [1e-07, 5e-07, 1.25e-07, 1.25e-07, 1e-08]], [null, 100000, [1e-07, 5e-07, 1.25e-07, 1.25e-07, 1e-08]], [null, 100001, [5e-07, 2.5e-06, 6.25e-07, 6.25e-07, 5e-08]], [null, 10000000, [5e-07, 2.5e-06, 6.25e-07, 6.25e-07, 5e-08]]]},
+{"info": {"input_cost_per_token": 0, "input_cost_per_token_above_128k_tokens": 0, "output_cost_per_token": 0, "output_cost_per_token_above_128k_tokens": 0}, "inclusive": false, "checks": [[null, 1, [0.0, 0.0, 0.0, 0.0, 0.0]], [null, 128000, [0.0, 0.0, 0.0, 0.0, 0.0]], [null, 128001, [0.0, 0.0, 0.0, 0.0, 0.0]], [null, 10000000, [0.0, 0.0, 0.0, 0.0, 0.0]]]},
+{"info": {"cache_read_input_token_cost": 5e-08, "cache_read_input_token_cost_priority": 9e-08, "input_cost_per_token": 5e-07, "input_cost_per_token_batches": 2.5e-07, "input_cost_per_token_flex": 2.5e-07, "input_cost_per_token_priority": 9e-07, "output_cost_per_token": 3e-06, "output_cost_per_token_batches": 1.5e-06, "output_cost_per_token_flex": 1.5e-06, "output_cost_per_token_priority": 5.4e-06}, "inclusive": false, "checks": [[null, 1, [5e-07, 3e-06, 5e-07, 5e-07, 5e-08]], [null, 10000000, [5e-07, 3e-06, 5e-07, 5e-07, 5e-08]], ["priority", 1, [9e-07, 5.4e-06, 9e-07, 9e-07, 9e-08]], ["priority", 10000000, [9e-07, 5.4e-06, 9e-07, 9e-07, 9e-08]], ["flex", 1, [2.5e-07, 1.5e-06, 2.5e-07, 2.5e-07, 5e-08]], ["flex", 10000000, [2.5e-07, 1.5e-06, 2.5e-07, 2.5e-07, 5e-08]]]},
+{"info": {"cache_read_input_token_cost": 3e-08, "input_cost_per_token": 3e-07, "input_cost_per_token_batches": 1.5e-07, "input_cost_per_token_flex": 1.5e-07, "input_cost_per_token_priority": 5.4e-07, "output_cost_per_token": 2.5e-06}, "inclusive": false, "checks": [[null, 1, [3e-07, 2.5e-06, 3e-07, 3e-07, 3e-08]], [null, 10000000, [3e-07, 2.5e-06, 3e-07, 3e-07, 3e-08]], ["priority", 1, [5.4e-07, 2.5e-06, 5.4e-07, 5.4e-07, 3e-08]], ["priority", 10000000, [5.4e-07, 2.5e-06, 5.4e-07, 5.4e-07, 3e-08]], ["flex", 1, [1.5e-07, 2.5e-06, 1.5e-07, 1.5e-07, 3e-08]], ["flex", 10000000, [1.5e-07, 2.5e-06, 1.5e-07, 1.5e-07, 3e-08]]]},
+{"info": {"cache_read_input_token_cost": 8.3e-08, "input_cost_per_token": 1.65e-07, "input_cost_per_token_batches": 8.3e-08, "output_cost_per_token": 6.6e-07}, "inclusive": false, "checks": [[null, 1, [1.65e-07, 6.6e-07, 1.65e-07, 1.65e-07, 8.3e-08]], [null, 10000000, [1.65e-07, 6.6e-07, 1.65e-07, 1.65e-07, 8.3e-08]]]},
+{"info": {"cache_read_input_token_cost": 2e-07, "cache_read_input_token_cost_above_200k_tokens": 4e-07, "cache_creation_input_token_cost_above_200k_tokens": 2.5e-07, "input_cost_per_token": 2e-06, "input_cost_per_token_above_200k_tokens": 4e-06, "input_cost_per_token_batches": 1e-06, "output_cost_per_token": 1.2e-05, "output_cost_per_token_above_200k_tokens": 1.8e-05, "output_cost_per_token_batches": 6e-06, "input_cost_per_token_priority": 3.6e-06, "input_cost_per_token_above_200k_tokens_priority": 7.2e-06, "output_cost_per_token_priority": 2.16e-05, "output_cost_per_token_above_200k_tokens_priority": 3.24e-05, "cache_read_input_token_cost_priority": 3.6e-07, "cache_read_input_token_cost_above_200k_tokens_priority": 7.2e-07}, "inclusive": false, "checks": [[null, 1, [2e-06, 1.2e-05, 2e-06, 2e-06, 2e-07]], [null, 200000, [2e-06, 1.2e-05, 2e-06, 2e-06, 2e-07]], [null, 200001, [4e-06, 1.8e-05, 2.5e-07, 2.5e-07, 4e-07]], [null, 10000000, [4e-06, 1.8e-05, 2.5e-07, 2.5e-07, 4e-07]], ["priority", 1, [3.6e-06, 2.16e-05, 3.6e-06, 3.6e-06, 3.6e-07]], ["priority", 200000, [3.6e-06, 2.16e-05, 3.6e-06, 3.6e-06, 3.6e-07]], ["priority", 200001, [7.2e-06, 3.24e-05, 2.5e-07, 2.5e-07, 7.2e-07]], ["priority", 10000000, [7.2e-06, 3.24e-05, 2.5e-07, 2.5e-07, 7.2e-07]]]},
+{"info": {"cache_creation_input_token_cost_above_200k_tokens": 2.5e-07, "cache_read_input_token_cost": 2e-07, "cache_read_input_token_cost_above_200k_tokens": 4e-07, "cache_read_input_token_cost_above_200k_tokens_priority": 7.2e-07, "cache_read_input_token_cost_priority": 3.6e-07, "input_cost_per_token": 2e-06, "input_cost_per_token_above_200k_tokens": 4e-06, "input_cost_per_token_above_200k_tokens_priority": 7.2e-06, "input_cost_per_token_batches": 1e-06, "input_cost_per_token_flex": 1e-06, "input_cost_per_token_priority": 3.6e-06, "output_cost_per_token": 1.2e-05, "output_cost_per_token_above_200k_tokens": 1.8e-05, "output_cost_per_token_above_200k_tokens_priority": 3.24e-05, "output_cost_per_token_batches": 6e-06, "output_cost_per_token_flex": 6e-06, "output_cost_per_token_priority": 2.16e-05}, "inclusive": false, "checks": [[null, 1, [2e-06, 1.2e-05, 2e-06, 2e-06, 2e-07]], [null, 200000, [2e-06, 1.2e-05, 2e-06, 2e-06, 2e-07]], [null, 200001, [4e-06, 1.8e-05, 2.5e-07, 2.5e-07, 4e-07]], [null, 10000000, [4e-06, 1.8e-05, 2.5e-07, 2.5e-07, 4e-07]], ["priority", 1, [3.6e-06, 2.16e-05, 3.6e-06, 3.6e-06, 3.6e-07]], ["priority", 200000, [3.6e-06, 2.16e-05, 3.6e-06, 3.6e-06, 3.6e-07]], ["priority", 200001, [7.2e-06, 3.24e-05, 2.5e-07, 2.5e-07, 7.2e-07]], ["priority", 10000000, [7.2e-06, 3.24e-05, 2.5e-07, 2.5e-07, 7.2e-07]], ["flex", 1, [1e-06, 6e-06, 1e-06, 1e-06, 2e-07]], ["flex", 200000, [1e-06, 6e-06, 1e-06, 1e-06, 2e-07]], ["flex", 200001, [4e-06, 1.8e-05, 2.5e-07, 2.5e-07, 4e-07]], ["flex", 10000000, [4e-06, 1.8e-05, 2.5e-07, 2.5e-07, 4e-07]]]},
+{"info": {"cache_read_input_token_cost": 2e-07, "cache_read_input_token_cost_above_200k_tokens": 4e-07, "cache_creation_input_token_cost_above_200k_tokens": 2.5e-07, "input_cost_per_token": 2e-06, "input_cost_per_token_above_200k_tokens": 4e-06, "input_cost_per_token_batches": 1e-06, "output_cost_per_token": 1.2e-05, "output_cost_per_token_above_200k_tokens": 1.8e-05, "output_cost_per_token_batches": 6e-06}, "inclusive": false, "checks": [[null, 1, [2e-06, 1.2e-05, 2e-06, 2e-06, 2e-07]], [null, 200000, [2e-06, 1.2e-05, 2e-06, 2e-06, 2e-07]], [null, 200001, [4e-06, 1.8e-05, 2.5e-07, 2.5e-07, 4e-07]], [null, 10000000, [4e-06, 1.8e-05, 2.5e-07, 2.5e-07, 4e-07]]]},
+{"info": {"cache_read_input_token_cost": 1.25e-07, "cache_read_input_token_cost_above_200k_tokens": 2.5e-07, "cache_creation_input_token_cost_above_200k_tokens": 2.5e-07, "cache_read_input_token_cost_above_200k_tokens_priority": 4.5e-07, "cache_read_input_token_cost_flex": 1.25e-07, "cache_read_input_token_cost_priority": 2.25e-07, "input_cost_per_token": 1.25e-06, "input_cost_per_token_above_200k_tokens": 2.5e-06, "output_cost_per_token": 1e-05, "output_cost_per_token_above_200k_tokens": 1.5e-05, "input_cost_per_token_above_200k_tokens_priority": 4.5e-06, "input_cost_per_token_batches": 6.25e-07, "input_cost_per_token_flex": 6.25e-07, "input_cost_per_token_priority": 2.25e-06, "output_cost_per_token_above_200k_tokens_priority": 2.7e-05, "output_cost_per_token_batches": 5e-06, "output_cost_per_token_flex": 5e-06, "output_cost_per_token_priority": 1.8e-05}, "inclusive": false, "checks": [[null, 1, [1.25e-06, 1e-05, 1.25e-06, 1.25e-06, 1.25e-07]], [null, 200000, [1.25e-06, 1e-05, 1.25e-06, 1.25e-06, 1.25e-07]], [null, 200001, [2.5e-06, 1.5e-05, 2.5e-07, 2.5e-07, 2.5e-07]], [null, 10000000, [2.5e-06, 1.5e-05, 2.5e-07, 2.5e-07, 2.5e-07]], ["priority", 1, [2.25e-06, 1.8e-05, 2.25e-06, 2.25e-06, 2.25e-07]], ["priority", 200000, [2.25e-06, 1.8e-05, 2.25e-06, 2.25e-06, 2.25e-07]], ["priority", 200001, [4.5e-06, 2.7e-05, 2.5e-07, 2.5e-07, 4.5e-07]], ["priority", 10000000, [4.5e-06, 2.7e-05, 2.5e-07, 2.5e-07, 4.5e-07]], ["flex", 1, [6.25e-07, 5e-06, 6.25e-07, 6.25e-07, 1.25e-07]], ["flex", 200000, [6.25e-07, 5e-06, 6.25e-07, 6.25e-07, 1.25e-07]], ["flex", 200001, [2.5e-06, 1.5e-05, 2.5e-07, 2.5e-07, 2.5e-07]], ["flex", 10000000, [2.5e-06, 1.5e-05, 2.5e-07, 2.5e-07, 2.5e-07]]]},
+{"info": {"cache_creation_input_token_cost": 1.875e-06, "input_cost_per_token": 3.75e-06, "output_cost_per_token": 1.5e-05}, "inclusive": false, "checks": [[null, 1, [3.75e-06, 1.5e-05, 1.875e-06, 1.875e-06, 3.75e-06]], [null, 10000000, [3.75e-06, 1.5e-05, 1.875e-06, 1.875e-06, 3.75e-06]]]},
+{"info": {"cache_read_input_token_cost": 2.1e-07, "cache_read_input_token_cost_flex": 1.05e-07, "input_cost_per_token": 8.4e-07, "input_cost_per_token_flex": 4.2e-07, "output_cost_per_token": 3.36e-06, "output_cost_per_token_flex": 1.68e-06}, "inclusive": false, "checks": [[null, 1, [8.4e-07, 3.36e-06, 8.4e-07, 8.4e-07, 2.1e-07]], [null, 10000000, [8.4e-07, 3.36e-06, 8.4e-07, 8.4e-07, 2.1e-07]], ["flex", 1, [4.2e-07, 1.68e-06, 4.2e-07, 4.2e-07, 1.05e-07]], ["flex", 10000000, [4.2e-07, 1.68e-06, 4.2e-07, 4.2e-07, 1.05e-07]]]},
+{"info": {"input_cost_per_token": 2.5e-06, "output_cost_per_token": 1.25e-05, "cache_read_input_token_cost": 2.5e-07, "input_cost_per_token_balanced": 2e-06, "output_cost_per_token_balanced": 1e-05, "cache_read_input_token_cost_balanced": 2e-07, "input_cost_per_token_flex": 1.25e-06, "output_cost_per_token_flex": 6.25e-06, "cache_read_input_token_cost_flex": 1.5e-07}, "inclusive": false, "checks": [[null, 1, [2.5e-06, 1.25e-05, 2.5e-06, 2.5e-06, 2.5e-07]], [null, 10000000, [2.5e-06, 1.25e-05, 2.5e-06, 2.5e-06, 2.5e-07]], ["flex", 1, [1.25e-06, 6.25e-06, 1.25e-06, 1.25e-06, 1.5e-07]], ["flex", 10000000, [1.25e-06, 6.25e-06, 1.25e-06, 1.25e-06, 1.5e-07]], ["balanced", 1, [2e-06, 1e-05, 2e-06, 2e-06, 2e-07]], ["balanced", 10000000, [2e-06, 1e-05, 2e-06, 2e-06, 2e-07]]]},
+{"info": {"tiered_pricing": [{"input_cost_per_query": 0.00166, "max_results_range": [1, 10]}, {"input_cost_per_query": 0.00332, "max_results_range": [11, 20]}, {"input_cost_per_query": 0.00498, "max_results_range": [21, 30]}, {"input_cost_per_query": 0.00664, "max_results_range": [31, 40]}, {"input_cost_per_query": 0.0083, "max_results_range": [41, 50]}, {"input_cost_per_query": 0.00996, "max_results_range": [51, 60]}, {"input_cost_per_query": 0.01162, "max_results_range": [61, 70]}, {"input_cost_per_query": 0.01328, "max_results_range": [71, 80]}, {"input_cost_per_query": 0.01494, "max_results_range": [81, 90]}, {"input_cost_per_query": 0.0166, "max_results_range": [91, 100]}]}, "inclusive": false, "checks": [[null, 1, [0.0, 0.0, 0.0, 0.0, 0.0]], [null, 10000000, [0.0, 0.0, 0.0, 0.0, 0.0]]]},
+{"info": {"tiered_pricing": [{"input_cost_per_query": 0.005, "max_results_range": [0, 25]}, {"input_cost_per_query": 0.025, "max_results_range": [26, 100]}]}, "inclusive": false, "checks": [[null, 1, [0.0, 0.0, 0.0, 0.0, 0.0]], [null, 10000000, [0.0, 0.0, 0.0, 0.0, 0.0]]]},
+{"info": {"tiered_pricing": [{"cache_read_input_token_cost": 8e-08, "input_cost_per_token": 4e-07, "output_cost_per_token": 1.6e-06, "range": [0, 256000.0]}, {"cache_read_input_token_cost": 2.4e-07, "input_cost_per_token": 1.2e-06, "output_cost_per_token": 4.8e-06, "range": [256000.0, 1000000.0]}]}, "inclusive": false, "checks": [[null, 1, [4e-07, 1.6e-06, 4e-07, 4e-07, 8e-08]], [null, 256000, [4e-07, 1.6e-06, 4e-07, 4e-07, 8e-08]], [null, 256001, [1.2e-06, 4.8e-06, 1.2e-06, 1.2e-06, 2.4e-07]], [null, 10000000, [1.2e-06, 4.8e-06, 1.2e-06, 1.2e-06, 2.4e-07]]]},
+{"info": {"tiered_pricing": [{"input_cost_per_token": 5e-08, "output_cost_per_token": 4e-07, "range": [0, 256000.0]}, {"input_cost_per_token": 2.5e-07, "output_cost_per_token": 2e-06, "range": [256000.0, 1000000.0]}]}, "inclusive": false, "checks": [[null, 1, [5e-08, 4e-07, 5e-08, 5e-08, 5e-08]], [null, 256000, [5e-08, 4e-07, 5e-08, 5e-08, 5e-08]], [null, 256001, [2.5e-07, 2e-06, 2.5e-07, 2.5e-07, 2.5e-07]], [null, 10000000, [2.5e-07, 2e-06, 2.5e-07, 2.5e-07, 2.5e-07]]]},
+{"info": {"tiered_pricing": [{"input_cost_per_token": 3e-07, "output_cost_per_token": 1.5e-06, "range": [0, 32000.0]}, {"input_cost_per_token": 5e-07, "output_cost_per_token": 2.5e-06, "range": [32000.0, 128000.0]}, {"input_cost_per_token": 8e-07, "output_cost_per_token": 4e-06, "range": [128000.0, 256000.0]}, {"input_cost_per_token": 1.6e-06, "output_cost_per_token": 9.6e-06, "range": [256000.0, 1000000.0]}]}, "inclusive": false, "checks": [[null, 1, [3e-07, 1.5e-06, 3e-07, 3e-07, 3e-07]], [null, 32000, [3e-07, 1.5e-06, 3e-07, 3e-07, 3e-07]], [null, 32001, [5e-07, 2.5e-06, 5e-07, 5e-07, 5e-07]], [null, 128000, [5e-07, 2.5e-06, 5e-07, 5e-07, 5e-07]], [null, 128001, [8e-07, 4e-06, 8e-07, 8e-07, 8e-07]], [null, 256000, [8e-07, 4e-06, 8e-07, 8e-07, 8e-07]], [null, 256001, [1.6e-06, 9.6e-06, 1.6e-06, 1.6e-06, 1.6e-06]], [null, 10000000, [1.6e-06, 9.6e-06, 1.6e-06, 1.6e-06, 1.6e-06]]]},
+{"info": {"tiered_pricing": [{"cache_read_input_token_cost": 8e-08, "input_cost_per_token": 3e-07, "output_cost_per_token": 1.5e-06, "range": [0, 32000.0]}, {"cache_read_input_token_cost": 1.2e-07, "input_cost_per_token": 5e-07, "output_cost_per_token": 2.5e-06, "range": [32000.0, 128000.0]}, {"cache_read_input_token_cost": 2e-07, "input_cost_per_token": 8e-07, "output_cost_per_token": 4e-06, "range": [128000.0, 256000.0]}, {"cache_read_input_token_cost": 4e-07, "input_cost_per_token": 1.6e-06, "output_cost_per_token": 9.6e-06, "range": [256000.0, 1000000.0]}]}, "inclusive": false, "checks": [[null, 1, [3e-07, 1.5e-06, 3e-07, 3e-07, 8e-08]], [null, 32000, [3e-07, 1.5e-06, 3e-07, 3e-07, 8e-08]], [null, 32001, [5e-07, 2.5e-06, 5e-07, 5e-07, 1.2e-07]], [null, 128000, [5e-07, 2.5e-06, 5e-07, 5e-07, 1.2e-07]], [null, 128001, [8e-07, 4e-06, 8e-07, 8e-07, 2e-07]], [null, 256000, [8e-07, 4e-06, 8e-07, 8e-07, 2e-07]], [null, 256001, [1.6e-06, 9.6e-06, 1.6e-06, 1.6e-06, 4e-07]], [null, 10000000, [1.6e-06, 9.6e-06, 1.6e-06, 1.6e-06, 4e-07]]]},
+{"info": {"tiered_pricing": [{"input_cost_per_token": 4e-07, "output_cost_per_reasoning_token": 4e-06, "output_cost_per_token": 1.2e-06, "range": [0, 256000.0]}, {"input_cost_per_token": 1.2e-06, "output_cost_per_reasoning_token": 1.2e-05, "output_cost_per_token": 3.6e-06, "range": [256000.0, 1000000.0]}]}, "inclusive": false, "checks": [[null, 1, [4e-07, 1.2e-06, 4e-07, 4e-07, 4e-07]], [null, 256000, [4e-07, 1.2e-06, 4e-07, 4e-07, 4e-07]], [null, 256001, [1.2e-06, 3.6e-06, 1.2e-06, 1.2e-06, 1.2e-06]], [null, 10000000, [1.2e-06, 3.6e-06, 1.2e-06, 1.2e-06, 1.2e-06]]]},
+{"info": {"cache_creation_input_token_cost": 1.375e-06, "cache_read_input_token_cost": 1.1e-07, "input_cost_per_token": 1.1e-06, "output_cost_per_token": 5.5e-06, "input_cost_per_token_batches": 5.5e-07, "output_cost_per_token_batches": 2.75e-06}, "inclusive": false, "checks": [[null, 1, [1.1e-06, 5.5e-06, 1.375e-06, 1.375e-06, 1.1e-07]], [null, 10000000, [1.1e-06, 5.5e-06, 1.375e-06, 1.375e-06, 1.1e-07]]]},
+{"info": {"cache_read_input_token_cost": 2.75e-07, "cache_read_input_token_cost_above_272k_tokens": 5.5e-07, "cache_read_input_token_cost_above_272k_tokens_batches": 2.75e-07, "cache_read_input_token_cost_batches": 1.43e-07, "cache_read_input_token_cost_priority": 5.5e-07, "input_cost_per_token": 2.75e-06, "input_cost_per_token_priority": 5.5e-06, "output_cost_per_token": 1.65e-05, "output_cost_per_token_priority": 3.3e-05, "input_cost_per_token_above_272k_tokens": 5.5e-06, "input_cost_per_token_above_272k_tokens_batches": 2.75e-06, "input_cost_per_token_batches": 1.375e-06, "output_cost_per_token_above_272k_tokens": 2.475e-05, "output_cost_per_token_above_272k_tokens_batches": 1.2375e-05, "output_cost_per_token_batches": 8.25e-06}, "inclusive": false, "checks": [[null, 1, [2.75e-06, 1.65e-05, 2.75e-06, 2.75e-06, 2.75e-07]], [null, 272000, [2.75e-06, 1.65e-05, 2.75e-06, 2.75e-06, 2.75e-07]], [null, 272001, [5.5e-06, 2.475e-05, 5.5e-06, 5.5e-06, 5.5e-07]], [null, 10000000, [5.5e-06, 2.475e-05, 5.5e-06, 5.5e-06, 5.5e-07]], ["priority", 1, [5.5e-06, 3.3e-05, 5.5e-06, 5.5e-06, 5.5e-07]], ["priority", 272000, [5.5e-06, 3.3e-05, 5.5e-06, 5.5e-06, 5.5e-07]], ["priority", 272001, [5.5e-06, 2.475e-05, 5.5e-06, 5.5e-06, 5.5e-07]], ["priority", 10000000, [5.5e-06, 2.475e-05, 5.5e-06, 5.5e-06, 5.5e-07]]]},
+{"info": {"cache_read_input_token_cost": 5e-07, "cache_read_input_token_cost_above_272k_tokens": 1e-06, "cache_read_input_token_cost_above_272k_tokens_batches": 5e-07, "cache_read_input_token_cost_priority": 1.25e-06, "cache_read_input_token_cost_above_272k_tokens_priority": 2e-06, "cache_read_input_token_cost_batches": 2.5e-07, "cache_read_input_token_cost_flex": 2.5e-07, "input_cost_per_token": 5e-06, "input_cost_per_token_above_272k_tokens": 1e-05, "input_cost_per_token_above_272k_tokens_batches": 5e-06, "input_cost_per_token_above_272k_tokens_flex": 5e-06, "input_cost_per_token_priority": 1.25e-05, "input_cost_per_token_above_272k_tokens_priority": 2e-05, "input_cost_per_token_batches": 2.5e-06, "input_cost_per_token_flex": 2.5e-06, "output_cost_per_token": 3e-05, "output_cost_per_token_above_272k_tokens": 4.5e-05, "output_cost_per_token_above_272k_tokens_batches": 2.25e-05, "output_cost_per_token_priority": 7.5e-05, "output_cost_per_token_above_272k_tokens_priority": 9e-05, "output_cost_per_token_batches": 1.5e-05}, "inclusive": false, "checks": [[null, 1, [5e-06, 3e-05, 5e-06, 5e-06, 5e-07]], [null, 272000, [5e-06, 3e-05, 5e-06, 5e-06, 5e-07]], [null, 272001, [1e-05, 4.5e-05, 1e-05, 1e-05, 1e-06]], [null, 10000000, [1e-05, 4.5e-05, 1e-05, 1e-05, 1e-06]], ["priority", 1, [1.25e-05, 7.5e-05, 1.25e-05, 1.25e-05, 1.25e-06]], ["priority", 272000, [1.25e-05, 7.5e-05, 1.25e-05, 1.25e-05, 1.25e-06]], ["priority", 272001, [2e-05, 9e-05, 2e-05, 2e-05, 2e-06]], ["priority", 10000000, [2e-05, 9e-05, 2e-05, 2e-05, 2e-06]], ["flex", 1, [2.5e-06, 3e-05, 2.5e-06, 2.5e-06, 2.5e-07]], ["flex", 272000, [2.5e-06, 3e-05, 2.5e-06, 2.5e-06, 2.5e-07]], ["flex", 272001, [5e-06, 4.5e-05, 5e-06, 5e-06, 1e-06]], ["flex", 10000000, [5e-06, 4.5e-05, 5e-06, 5e-06, 1e-06]]]},
+{"info": {"cache_creation_input_token_cost": 5e-06, "cache_creation_input_token_cost_above_272k_tokens": 1e-05, "cache_creation_input_token_cost_priority": 1e-05, "cache_creation_input_token_cost_above_272k_tokens_priority": 2e-05, "cache_read_input_token_cost": 4e-07, "cache_read_input_token_cost_above_272k_tokens": 8e-07, "cache_read_input_token_cost_priority": 8e-07, "cache_read_input_token_cost_above_272k_tokens_priority": 1.6e-06, "input_cost_per_token": 4e-06, "input_cost_per_token_above_272k_tokens": 8e-06, "input_cost_per_token_priority": 8e-06, "input_cost_per_token_above_272k_tokens_priority": 1.6e-05, "output_cost_per_token": 2e-05, "output_cost_per_token_above_272k_tokens": 3e-05, "output_cost_per_token_priority": 4e-05, "output_cost_per_token_above_272k_tokens_priority": 6e-05}, "inclusive": false, "checks": [[null, 1, [4e-06, 2e-05, 5e-06, 5e-06, 4e-07]], [null, 272000, [4e-06, 2e-05, 5e-06, 5e-06, 4e-07]], [null, 272001, [8e-06, 3e-05, 1e-05, 1e-05, 8e-07]], [null, 10000000, [8e-06, 3e-05, 1e-05, 1e-05, 8e-07]], ["priority", 1, [8e-06, 4e-05, 1e-05, 1e-05, 8e-07]], ["priority", 272000, [8e-06, 4e-05, 1e-05, 1e-05, 8e-07]], ["priority", 272001, [1.6e-05, 6e-05, 2e-05, 2e-05, 1.6e-06]], ["priority", 10000000, [1.6e-05, 6e-05, 2e-05, 2e-05, 1.6e-06]]]},
+{"info": {"cache_creation_input_token_cost": 5e-06, "cache_creation_input_token_cost_above_272k_tokens": 1e-05, "cache_creation_input_token_cost_above_272k_tokens_flex": 5e-06, "cache_creation_input_token_cost_priority": 1e-05, "cache_creation_input_token_cost_above_272k_tokens_priority": 2e-05, "cache_creation_input_token_cost_flex": 2.5e-06, "cache_read_input_token_cost": 4e-07, "cache_read_input_token_cost_above_272k_tokens": 8e-07, "cache_read_input_token_cost_above_272k_tokens_flex": 4e-07, "cache_read_input_token_cost_priority": 8e-07, "cache_read_input_token_cost_above_272k_tokens_priority": 1.6e-06, "cache_read_input_token_cost_flex": 2e-07, "input_cost_per_token": 4e-06, "input_cost_per_token_above_272k_tokens": 8e-06, "input_cost_per_token_above_272k_tokens_flex": 4e-06, "input_cost_per_token_priority": 8e-06, "input_cost_per_token_above_272k_tokens_priority": 1.6e-05, "input_cost_per_token_flex": 2e-06, "output_cost_per_token": 2e-05, "output_cost_per_token_above_272k_tokens": 3e-05, "output_cost_per_token_above_272k_tokens_flex": 1.5e-05, "output_cost_per_token_priority": 4e-05, "output_cost_per_token_above_272k_tokens_priority": 6e-05, "output_cost_per_token_flex": 1e-05}, "inclusive": false, "checks": [[null, 1, [4e-06, 2e-05, 5e-06, 5e-06, 4e-07]], [null, 272000, [4e-06, 2e-05, 5e-06, 5e-06, 4e-07]], [null, 272001, [8e-06, 3e-05, 1e-05, 1e-05, 8e-07]], [null, 10000000, [8e-06, 3e-05, 1e-05, 1e-05, 8e-07]], ["priority", 1, [8e-06, 4e-05, 1e-05, 1e-05, 8e-07]], ["priority", 272000, [8e-06, 4e-05, 1e-05, 1e-05, 8e-07]], ["priority", 272001, [1.6e-05, 6e-05, 2e-05, 2e-05, 1.6e-06]], ["priority", 10000000, [1.6e-05, 6e-05, 2e-05, 2e-05, 1.6e-06]], ["flex", 1, [2e-06, 1e-05, 2.5e-06, 2.5e-06, 2e-07]], ["flex", 272000, [2e-06, 1e-05, 2.5e-06, 2.5e-06, 2e-07]], ["flex", 272001, [4e-06, 1.5e-05, 5e-06, 5e-06, 4e-07]], ["flex", 10000000, [4e-06, 1.5e-05, 5e-06, 5e-06, 4e-07]]]},
+{"info": {"cache_read_input_token_cost": 3e-06, "cache_read_input_token_cost_above_272k_tokens": 6e-06, "input_cost_per_token": 3e-05, "input_cost_per_token_above_272k_tokens": 6e-05, "input_cost_per_token_above_272k_tokens_batches": 3e-05, "input_cost_per_token_above_272k_tokens_flex": 3e-05, "input_cost_per_token_batches": 1.5e-05, "input_cost_per_token_flex": 1.5e-05, "output_cost_per_token": 0.00018, "output_cost_per_token_above_272k_tokens": 0.00027, "output_cost_per_token_above_272k_tokens_batches": 0.000135, "output_cost_per_token_above_272k_tokens_flex": 0.000135, "output_cost_per_token_batches": 9e-05, "output_cost_per_token_flex": 9e-05}, "inclusive": false, "checks": [[null, 1, [3e-05, 0.00018, 3e-05, 3e-05, 3e-06]], [null, 272000, [3e-05, 0.00018, 3e-05, 3e-05, 3e-06]], [null, 272001, [6e-05, 0.00027, 6e-05, 6e-05, 6e-06]], [null, 10000000, [6e-05, 0.00027, 6e-05, 6e-05, 6e-06]], ["flex", 1, [1.5e-05, 9e-05, 1.5e-05, 1.5e-05, 3e-06]], ["flex", 272000, [1.5e-05, 9e-05, 1.5e-05, 1.5e-05, 3e-06]], ["flex", 272001, [3e-05, 0.000135, 3e-05, 3e-05, 6e-06]], ["flex", 10000000, [3e-05, 0.000135, 3e-05, 3e-05, 6e-06]]]},
+{"info": {"cache_read_input_token_cost": 2.5e-07, "cache_read_input_token_cost_above_272k_tokens": 5e-07, "cache_read_input_token_cost_above_272k_tokens_batches": 2.5e-07, "cache_read_input_token_cost_above_272k_tokens_flex": 2.5e-07, "cache_read_input_token_cost_priority": 5e-07, "cache_read_input_token_cost_above_272k_tokens_priority": 1e-06, "cache_read_input_token_cost_batches": 1.3e-07, "input_cost_per_token": 2.5e-06, "input_cost_per_token_above_272k_tokens": 5e-06, "input_cost_per_token_priority": 5e-06, "input_cost_per_token_above_272k_tokens_priority": 1e-05, "output_cost_per_token": 1.5e-05, "output_cost_per_token_above_272k_tokens": 2.25e-05, "output_cost_per_token_priority": 3e-05, "output_cost_per_token_above_272k_tokens_priority": 4.5e-05, "input_cost_per_token_above_272k_tokens_batches": 2.5e-06, "input_cost_per_token_above_272k_tokens_flex": 2.5e-06, "input_cost_per_token_batches": 1.25e-06, "input_cost_per_token_flex": 1.25e-06, "output_cost_per_token_above_272k_tokens_batches": 1.125e-05, "output_cost_per_token_above_272k_tokens_flex": 1.125e-05, "output_cost_per_token_batches": 7.5e-06, "output_cost_per_token_flex": 7.5e-06}, "inclusive": false, "checks": [[null, 1, [2.5e-06, 1.5e-05, 2.5e-06, 2.5e-06, 2.5e-07]], [null, 272000, [2.5e-06, 1.5e-05, 2.5e-06, 2.5e-06, 2.5e-07]], [null, 272001, [5e-06, 2.25e-05, 5e-06, 5e-06, 5e-07]], [null, 10000000, [5e-06, 2.25e-05, 5e-06, 5e-06, 5e-07]], ["priority", 1, [5e-06, 3e-05, 5e-06, 5e-06, 5e-07]], ["priority", 272000, [5e-06, 3e-05, 5e-06, 5e-06, 5e-07]], ["priority", 272001, [1e-05, 4.5e-05, 1e-05, 1e-05, 1e-06]], ["priority", 10000000, [1e-05, 4.5e-05, 1e-05, 1e-05, 1e-06]], ["flex", 1, [1.25e-06, 7.5e-06, 1.25e-06, 1.25e-06, 2.5e-07]], ["flex", 272000, [1.25e-06, 7.5e-06, 1.25e-06, 1.25e-06, 2.5e-07]], ["flex", 272001, [2.5e-06, 1.125e-05, 2.5e-06, 2.5e-06, 2.5e-07]], ["flex", 10000000, [2.5e-06, 1.125e-05, 2.5e-06, 2.5e-06, 2.5e-07]]]},
+{"info": {"cache_read_input_token_cost": 5e-07, "cache_read_input_token_cost_above_272k_tokens": 1e-06, "cache_read_input_token_cost_priority": 1e-06, "cache_read_input_token_cost_above_272k_tokens_priority": 2e-06, "input_cost_per_token": 5e-06, "input_cost_per_token_above_272k_tokens": 1e-05, "input_cost_per_token_priority": 1e-05, "input_cost_per_token_above_272k_tokens_priority": 2e-05, "output_cost_per_token": 3e-05, "output_cost_per_token_above_272k_tokens": 4.5e-05, "output_cost_per_token_priority": 6e-05, "output_cost_per_token_above_272k_tokens_priority": 9e-05}, "inclusive": false, "checks": [[null, 1, [5e-06, 3e-05, 5e-06, 5e-06, 5e-07]], [null, 272000, [5e-06, 3e-05, 5e-06, 5e-06, 5e-07]], [null, 272001, [1e-05, 4.5e-05, 1e-05, 1e-05, 1e-06]], [null, 10000000, [1e-05, 4.5e-05, 1e-05, 1e-05, 1e-06]], ["priority", 1, [1e-05, 6e-05, 1e-05, 1e-05, 1e-06]], ["priority", 272000, [1e-05, 6e-05, 1e-05, 1e-05, 1e-06]], ["priority", 272001, [2e-05, 9e-05, 2e-05, 2e-05, 2e-06]], ["priority", 10000000, [2e-05, 9e-05, 2e-05, 2e-05, 2e-06]]]},
+{"info": {"cache_read_input_token_cost": 3.125e-07, "input_cost_per_token": 1.25e-06, "input_cost_per_token_batches": 6.25e-07, "input_cost_per_token_priority": 2.1875e-06, "output_cost_per_token": 1e-05, "output_cost_per_token_batches": 5e-06, "output_cost_per_token_priority": 1.75e-05}, "inclusive": false, "checks": [[null, 1, [1.25e-06, 1e-05, 1.25e-06, 1.25e-06, 3.125e-07]], [null, 10000000, [1.25e-06, 1e-05, 1.25e-06, 1.25e-06, 3.125e-07]], ["priority", 1, [2.1875e-06, 1.75e-05, 2.1875e-06, 2.1875e-06, 3.125e-07]], ["priority", 10000000, [2.1875e-06, 1.75e-05, 2.1875e-06, 2.1875e-06, 3.125e-07]]]}
+]}
diff --git a/litellm-rust/crates/model-catalog/tests/registry_validation.rs b/litellm-rust/crates/model-catalog/tests/registry_validation.rs
deleted file mode 100644
index 3b65ef13d78..00000000000
--- a/litellm-rust/crates/model-catalog/tests/registry_validation.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use litellm_model_catalog::{
-    Catalog, FallbackGeneralizations, Provenance, validate_model_entry, validate_registry,
-};
-use rstest::{fixture, rstest};
-use serde_json::{Map, Value};
-
-#[fixture]
-fn repo_root() -> PathBuf {
-    Path::new(env!("CARGO_MANIFEST_DIR")).join("../../..")
-}
-
-#[rstest]
-#[case("model_prices_and_context_window.json")]
-#[case("litellm/model_prices_and_context_window_backup.json")]
-#[ignore]
-fn checked_in_registry_passes_strict_validation(repo_root: PathBuf, #[case] filename: &str) {
-    let body = std::fs::read(repo_root.join(filename)).unwrap();
-    let catalog = Catalog::parse(&body, Provenance::default()).unwrap();
-    validate_registry(&catalog).unwrap();
-}
-
-#[rstest]
-#[ignore]
-fn fallback_generalizations_are_typed(repo_root: PathBuf) {
-    let body = std::fs::read(repo_root.join("model_prices_and_context_window.json")).unwrap();
-    let document: Map<String, Value> = serde_json::from_slice(&body).unwrap();
-    let Some(raw_rules) = document.get("fallback_generalizations") else {
-        return;
-    };
-    let _: FallbackGeneralizations = serde_json::from_value(raw_rules.clone()).unwrap();
-    let catalog = Catalog::parse(&body, Provenance::default()).unwrap();
-    assert!(
-        catalog
-            .fallback_rules()
-            .is_some_and(|rules| !rules.is_empty())
-    );
-}
-
-#[rstest]
-#[case::missing_provider(serde_json::json!({"mode": "chat"}), "litellm_provider")]
-#[case::unknown_field(serde_json::json!({"litellm_provider": "test", "typo": true}), "unknown field")]
-#[case::negative_price(serde_json::json!({"litellm_provider": "test", "input_cost_per_token": -1}), "nonnegative")]
-#[case::negative_nested_price(serde_json::json!({"litellm_provider": "test", "guardrail_cost_per_unit": {"unit": -1}}), "nonnegative")]
-#[case::invalid_mode(serde_json::json!({"litellm_provider": "test", "mode": "invalid"}), "unknown variant")]
-#[case::invalid_date(serde_json::json!({"litellm_provider": "test", "deprecation_date": "2026-02-31"}), "deprecation_date")]
-#[case::invalid_hours(serde_json::json!({"litellm_provider": "test", "off_peak_pricing": {"hours_utc": "25:00-01:00"}}), "hours_utc")]
-#[case::empty_windows(serde_json::json!({"litellm_provider": "test", "off_peak_pricing": {"windows": []}}), "windows is empty")]
-#[case::invalid_weekday(serde_json::json!({"litellm_provider": "test", "off_peak_pricing": {"windows": [{"hours_utc": "00:00-01:00", "weekdays": [0]}]}}), "weekdays is invalid")]
-#[case::invalid_aliases(serde_json::json!({"litellm_provider": "test", "aliases": ["good", 7]}), "aliases must contain strings")]
-#[case::null_aliases(serde_json::json!({"litellm_provider": "test", "aliases": null}), "aliases must be an array")]
-#[ignore]
-fn registry_validation_rejects_malformed_entries(#[case] entry: Value, #[case] expected: &str) {
-    let error = validate_model_entry("test", &entry).unwrap_err();
-    assert!(
-        litellm_error::Report::new(&error)
-            .to_string()
-            .contains(expected)
-    );
-}
-
-#[test]
-#[ignore]
-fn checked_in_catalog_and_backup_match() {
-    let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../..");
-    let current = std::fs::read(root.join("model_prices_and_context_window.json")).unwrap();
-    let backup =
-        std::fs::read(root.join("litellm/model_prices_and_context_window_backup.json")).unwrap();
-    assert_eq!(current, backup);
-    let catalog = Catalog::parse(&current, Provenance::default()).unwrap();
-    assert!(
-        catalog.alias_issues().is_empty(),
-        "invalid registry aliases"
-    );
-}
-
-#[rstest]
-#[case::input("input_cost_per_token_above_100k_tokens")]
-#[case::input_batches("input_cost_per_token_above_100k_tokens_batches")]
-#[case::output("output_cost_per_token_above_100k_tokens")]
-#[case::output_batches("output_cost_per_token_above_100k_tokens_batches")]
-#[case::cache_creation("cache_creation_input_token_cost_above_100k_tokens")]
-#[case::cache_creation_batches("cache_creation_input_token_cost_above_100k_tokens_batches")]
-#[case::cache_creation_1hr("cache_creation_input_token_cost_above_1hr_above_100k_tokens")]
-#[case::cache_read("cache_read_input_token_cost_above_100k_tokens")]
-#[case::cache_read_batches("cache_read_input_token_cost_above_100k_tokens_batches")]
-fn registry_validation_keeps_above_100k_tier_rates(#[case] field: &str) {
-    let mut entry = Map::new();
-    entry.insert("litellm_provider".into(), "anthropic".into());
-    entry.insert(field.into(), 5e-7.into());
-    validate_model_entry("test", &Value::Object(entry)).unwrap();
-}
diff --git a/litellm-rust/crates/model-catalog/tests/schema.rs b/litellm-rust/crates/model-catalog/tests/schema.rs
index f9a028a78ab..464cf069cac 100644
--- a/litellm-rust/crates/model-catalog/tests/schema.rs
+++ b/litellm-rust/crates/model-catalog/tests/schema.rs
@@ -1,16 +1,17 @@
 #![cfg(feature = "schema")]
 
-use std::collections::BTreeSet;
-use std::path::Path;
-
-use litellm_model_catalog::{model_entry_json_schema, registry_json_schema};
+use litellm_model_catalog::{BUNDLED_REGISTRY, model_entry_json_schema, registry_json_schema};
 use rstest::rstest;
-use serde_json::{Value, json};
+use serde_json::{Map, Value, json};
 
 fn schema() -> Value {
     serde_json::to_value(model_entry_json_schema()).expect("generated schema serializes")
 }
 
+fn checked_in_catalog() -> Value {
+    serde_json::from_slice(BUNDLED_REGISTRY).unwrap()
+}
+
 fn registry_validator() -> jsonschema::Validator {
     let schema = serde_json::to_value(registry_json_schema()).unwrap();
     jsonschema::options()
@@ -19,26 +20,21 @@ fn registry_validator() -> jsonschema::Validator {
         .expect("generated registry schema is valid")
 }
 
-#[rstest]
-#[case("model_prices_and_context_window.json")]
-#[case("litellm/model_prices_and_context_window_backup.json")]
-#[ignore]
-fn generated_registry_schema_validates_checked_in_catalog(#[case] path: &str) {
-    let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../..");
-    let catalog: Value = serde_json::from_slice(&std::fs::read(root.join(path)).unwrap()).unwrap();
+#[test]
+fn generated_registry_schema_validates_checked_in_catalog() {
+    let catalog = checked_in_catalog();
     let validator = registry_validator();
     let errors: Vec<_> = validator
         .iter_errors(&catalog)
         .map(|error| error.to_string())
         .collect();
-    assert!(errors.is_empty(), "{path}: {errors:?}");
+    assert!(errors.is_empty(), "{errors:?}");
 }
 
 #[rstest]
 #[case(json!({"example": {"litellm_provider": "test"}}))]
 #[case(json!({"example": {"litellm_provider": "test", "future_field": true}}))]
 #[case(json!({"sample_spec": {"litellm_provider": "placeholder"}}))]
-#[ignore]
 fn generated_registry_schema_keeps_reader_compatibility(#[case] document: Value) {
     assert!(registry_validator().is_valid(&document));
 }
@@ -59,47 +55,55 @@ fn generated_registry_schema_keeps_reader_compatibility(#[case] document: Value)
 #[case::invalid_weekday(json!({"litellm_provider": "test", "off_peak_pricing": {"windows": [{"hours_utc": "00:00-01:00", "weekdays": [0]}]}}))]
 #[case::invalid_aliases(json!({"litellm_provider": "test", "aliases": "wrong"}))]
 #[case::non_object_model(json!(4))]
-#[ignore]
 fn generated_registry_schema_rejects_invalid_entries(#[case] entry: Value) {
     assert!(!registry_validator().is_valid(&json!({"example": entry})));
 }
 
-#[rstest]
-#[case("model_prices_and_context_window.json")]
-#[case("litellm/model_prices_and_context_window_backup.json")]
-#[ignore]
-fn generated_schema_covers_catalog_fields(#[case] path: &str) {
-    let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../..");
-    let catalog: Value = serde_json::from_slice(&std::fs::read(root.join(path)).unwrap()).unwrap();
+#[test]
+fn generated_schema_covers_catalog_fields() {
+    let catalog = checked_in_catalog();
     let schema = schema();
-    let properties = schema["properties"]
+    let any_value = |keys: &Value| -> Map<String, Value> {
+        keys.as_object()
+            .expect("schema keys are an object")
+            .keys()
+            .map(|key| (key.clone(), json!({})))
+            .collect()
+    };
+    let keys_only = json!({
+        "type": "object",
+        "properties": any_value(&schema["properties"]),
+        "patternProperties": any_value(&schema["patternProperties"]),
+        "additionalProperties": false,
+    });
+    let registry = serde_json::to_value(registry_json_schema()).unwrap();
+    let sections = registry["properties"]
         .as_object()
-        .expect("ModelInfo schema has properties");
-    let fields: BTreeSet<&str> = catalog
+        .expect("registry has sections");
+    let fields: Map<String, Value> = catalog
         .as_object()
         .expect("catalog is an object")
         .iter()
-        .filter(|(name, _)| *name != "sample_spec" && *name != "fallback_generalizations")
+        .filter(|(name, _)| !sections.contains_key(*name))
         .flat_map(|(_, entry)| entry.as_object().expect("model entry is an object").keys())
-        .map(String::as_str)
-        .filter(|name| *name != "aliases")
+        .map(|name| (name.clone(), Value::Null))
         .collect();
-    let missing: Vec<_> = fields
-        .into_iter()
-        .filter(|name| !properties.contains_key(*name))
+    let missing: Vec<_> = jsonschema::validator_for(&keys_only)
+        .unwrap()
+        .iter_errors(&Value::Object(fields))
+        .map(|error| error.to_string())
         .collect();
 
     assert!(
         missing.is_empty(),
-        "{path}: fields missing from schema: {missing:?}"
+        "fields missing from schema: {missing:?}"
     );
 }
 
 #[rstest]
 #[case("Mode", "chat")]
-#[case("ReasoningEffort", "high")]
+#[case("EffortLevel", "high")]
 #[case("InputModality", "image")]
-#[ignore]
 fn generated_schema_includes_enum_values(#[case] definition: &str, #[case] value: &str) {
     let schema = schema();
     let variants = schema["$defs"][definition]["enum"]
@@ -110,7 +114,6 @@ fn generated_schema_includes_enum_values(#[case] definition: &str, #[case] value
 }
 
 #[test]
-#[ignore]
 fn generated_schema_includes_nested_pricing_types() {
     let schema = schema();
     let definitions = schema["$defs"].as_object().expect("schema has definitions");
diff --git a/litellm-rust/crates/router-core/Cargo.toml b/litellm-rust/crates/router-core/Cargo.toml
new file mode 100644
index 00000000000..af97bd52c57
--- /dev/null
+++ b/litellm-rust/crates/router-core/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "litellm-router-core"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+description = "The router core behind litellm.Router: registry, settings, health, selection and the call loop"
+
+[dependencies]
diff --git a/litellm-rust/crates/router-core/src/lib.rs b/litellm-rust/crates/router-core/src/lib.rs
new file mode 100644
index 00000000000..05d95d02c84
--- /dev/null
+++ b/litellm-rust/crates/router-core/src/lib.rs
@@ -0,0 +1,63 @@
+//! Routing for LiteLLM: decide which deployment serves a request, and drive retries, fallbacks
+//! and cooldowns around the attempts.
+//!
+//! This crate defines the boundary `litellm.Router` is moving behind. Today the Python router in
+//! `litellm/router.py` implements all of it; this crate is where the Rust core will implement the
+//! same interface. Until then it holds this overview and nothing else, so the interface is written
+//! down in code before either side changes.
+//!
+//! # The public surface
+//! Code outside the router uses `litellm.Router` through two kinds of members and nothing else:
+//! - The endpoint methods (`acompletion`, `aembedding`, `aresponses`, `aanthropic_messages`, the
+//!   files, batches, assistants and vector store wrappers, 37 in all). Each is a thin wrapper over
+//!   `call(op, request)`.
+//! - Eight entry points: `registry()`, `settings()`, `health()`, `select()`, `apply()`,
+//!   `observe()`, `register_plugin()` and `retire()`.
+//!
+//! Every other member that outside code uses today has a named replacement among those. The old
+//! names stay available for about a month through a `DeprecatedRouterMembers` mixin, which
+//! implements them over the entry points and warns on use. A CI check
+//! (`tests/code_coverage_tests/router_surface_check.py`) keeps an allowlist of the members outside
+//! code touches; the list may only shrink.
+//!
+//! # Structure
+//! - `Registry`: the configured deployments, indexed by id, model group, alias, wildcard pattern
+//!   and team. Immutable and versioned. Seven queries: `deployment(id)`, `deployments(filter)`,
+//!   `names(filter)`, `resolve(name, scope)`, `group(name)`, `access_groups()` and
+//!   `credentials(id)`. "Registry" is the router's view of what is configured; per-model pricing
+//!   and capabilities are the model catalog (`litellm-model-catalog`), which the router reads
+//!   through its dynamic config.
+//! - `RouterConfig` / `RouterDynamicConfig`: everything the router needs to know, passed in. The
+//!   router never reads process globals. Static config (model list, strategy, retry, timeout and
+//!   cooldown policy, Redis settings, plugins) is fixed for the router's life. Dynamic config
+//!   (pricing, model aliases, fallbacks, retry counts, callbacks) is a versioned snapshot read
+//!   once per call.
+//! - `Settings`: one typed, frozen view of the configuration a caller may read.
+//! - `Health`: cooldowns, blocked deployments and usage, kept in shared cache keys so Python and
+//!   Rust workers see the same state. `report(id, outcome)` records outcomes the router did not
+//!   see itself (a health check, an interceptor that marks a deployment failed).
+//! - `select(model, request)`: resolve a name, filter eligible deployments, pick one with the
+//!   configured strategy, without calling it.
+//! - `apply(changes)`: one `ChangeSet` (upserts, deletes, settings), applied atomically, producing
+//!   a new registry version.
+//! - `call(op, request)`: select, run the attempt, and retry or fall back until it succeeds or the
+//!   policy is exhausted.
+//!
+//! # Execution
+//! Each attempt resolves an `Executor` after a deployment is picked. A Rust-native operation runs
+//! its `inference-*` route machine in-process; anything else goes through `Host::invoke`. A
+//! started attempt is never replayed on a different executor.
+//!
+//! # Hosts
+//! `Host` is what the embedding process provides: `invoke` for non-native operations, `select`
+//! for strategies and sub-routers not yet ported, `allow_fallback` for access and budget checks,
+//! `sleep`, `observe` for routing events, and `cache`, a DualCache-style store that holds all
+//! routing state under the same keys, encodings and TTLs the Python router uses. `PythonHost`
+//! serves them from the existing Python code when the router runs inside Python; `NativeHost`
+//! serves them in the Rust server, where an operation without a Rust implementation makes the
+//! config fail at build time, never partway through a request.
+//!
+//! # Plugins
+//! Routing strategies, pre-call checks and sub-routers (auto, complexity, quality, adaptive)
+//! register through `register_plugin` and see a `RoutingContext` (registry, settings, health and
+//! the current request), never the router itself.
diff --git a/litellm-rust/crates/router/Cargo.toml b/litellm-rust/crates/router/Cargo.toml
index a356bedcf16..988d1b68805 100644
--- a/litellm-rust/crates/router/Cargo.toml
+++ b/litellm-rust/crates/router/Cargo.toml
@@ -7,6 +7,7 @@ repository.workspace = true
 
 [dependencies]
 litellm-config.workspace = true
+litellm-core-utils.workspace = true
 litellm-inference.workspace = true
 litellm-inference-messages.workspace = true
 litellm-router-types.workspace = true
diff --git a/litellm-rust/crates/router/README.md b/litellm-rust/crates/router/README.md
index 972d37d14be..a734e634104 100644
--- a/litellm-rust/crates/router/README.md
+++ b/litellm-rust/crates/router/README.md
@@ -1,4 +1,4 @@
-`litellm-router` scaffolds the model-list setup and deployment lookup portion of Python's `litellm.Router`. `Router::from_model_list(&config.model_list)` maps configured public names to provider deployments. Programmatic callers can collect `(String, Deployment)` entries into a `Router`
+`litellm-router` scaffolds the model-list setup and deployment lookup portion of Python's `litellm.Router`. `Router::from_config(&config, &env)` maps configured public names to provider deployments and reads `drop_params` from `litellm_settings` and each deployment, resolving an `os.environ/NAME` value through `env`. Programmatic callers can collect `(String, Deployment)` entries into a `Router`
 
 Lookup is exact and returns `None` for an unknown name. This extraction preserves the gateway's existing behavior: the last entry wins when public names repeat. Multiple deployments per model group, routing strategies, retries, cooldowns, and fallbacks are not implemented yet
 
diff --git a/litellm-rust/crates/router/src/lib.rs b/litellm-rust/crates/router/src/lib.rs
index fb48213e8a7..b75c1a14446 100644
--- a/litellm-rust/crates/router/src/lib.rs
+++ b/litellm-rust/crates/router/src/lib.rs
@@ -2,16 +2,33 @@ mod deployment;
 
 use std::collections::HashMap;
 
-use litellm_config::Model;
+use litellm_config::{Config, Spelled};
+use litellm_core_utils::{serde_compat::parse_pydantic_bool, settings::Lookup};
+use litellm_inference_messages::{MessagesSettings, MessagesShaping};
 
 pub use deployment::Deployment;
 
 #[derive(Clone, Debug, Default)]
 pub struct Router(HashMap<String, Deployment>);
 
+fn is_on(flag: Option<&Spelled<bool>>, env: &impl Lookup) -> bool {
+    match flag {
+        Some(Spelled::Value(on)) => *on,
+        Some(Spelled::Text(text)) => match text.strip_prefix("os.environ/") {
+            Some(name) => env
+                .get(name)
+                .is_some_and(|value| parse_pydantic_bool(&value) == Some(true)),
+            None => parse_pydantic_bool(text) == Some(true),
+        },
+        None => false,
+    }
+}
+
 impl Router {
-    pub fn from_model_list(model_list: &[Model]) -> Self {
-        model_list
+    pub fn from_config(config: &Config, env: &impl Lookup) -> Self {
+        let drops_params_globally = is_on(config.litellm_settings.drop_params.as_ref(), env);
+        config
+            .model_list
             .iter()
             .map(|model| {
                 (
@@ -26,6 +43,14 @@ impl Router {
                         api_base: model.litellm_params.api_base.clone(),
                         custom_llm_provider: model.litellm_params.custom_llm_provider.clone(),
                         litellm_params: model.litellm_params.clone(),
+                        shaping: MessagesShaping {
+                            settings: MessagesSettings {
+                                drop_params: drops_params_globally
+                                    || is_on(model.litellm_params.drop_params.as_ref(), env),
+                                ..MessagesSettings::default()
+                            },
+                            ..MessagesShaping::default()
+                        },
                         ..Deployment::default()
                     },
                 )
@@ -43,3 +68,60 @@ impl FromIterator<(String, Deployment)> for Router {
         Self(entries.into_iter().collect())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use litellm_config::Config;
+    use rstest::rstest;
+
+    use super::Router;
+
+    #[rstest]
+    #[case::unset("", "", false)]
+    #[case::deployment_flag("", "\n      drop_params: true", true)]
+    #[case::deployment_word("", "\n      drop_params: \" True \"", true)]
+    #[case::deployment_off("", "\n      drop_params: false", false)]
+    #[case::deployment_unknown_word("", "\n      drop_params: maybe", false)]
+    #[case::deployment_yes("", "\n      drop_params: yes", true)]
+    #[case::deployment_no("", "\n      drop_params: \"no\"", false)]
+    #[case::deployment_env_reference("", "\n      drop_params: os.environ/DROP_PARAMS_FLAG", true)]
+    #[case::deployment_unset_env_reference(
+        "",
+        "\n      drop_params: os.environ/MISSING_FLAG",
+        false
+    )]
+    #[case::global_env_reference(
+        "litellm_settings:\n  drop_params: os.environ/DROP_PARAMS_FLAG\n",
+        "",
+        true
+    )]
+    #[case::global_flag("litellm_settings:\n  drop_params: true\n", "", true)]
+    #[case::global_word("litellm_settings:\n  drop_params: \"true\"\n", "", true)]
+    #[case::global_off("litellm_settings:\n  drop_params: false\n", "", false)]
+    #[case::global_over_deployment_off(
+        "litellm_settings:\n  drop_params: true\n",
+        "\n      drop_params: false",
+        true
+    )]
+    fn configured_drop_params_reach_the_deployment(
+        #[case] settings: &str,
+        #[case] deployment: &str,
+        #[case] expected: bool,
+    ) {
+        let config = Config::from_yaml(&format!(
+            "{settings}model_list:\n  - model_name: public-model\n    litellm_params:\n      model: provider/model{deployment}"
+        ))
+        .unwrap();
+
+        assert_eq!(
+            Router::from_config(&config, &|name: &str| (name == "DROP_PARAMS_FLAG")
+                .then(|| " Yes ".to_owned()))
+            .get("public-model")
+            .unwrap()
+            .shaping
+            .settings
+            .drop_params,
+            expected
+        );
+    }
+}
diff --git a/litellm-rust/crates/router/tests/router.rs b/litellm-rust/crates/router/tests/router.rs
index bbaeb806b96..03e78ab9d11 100644
--- a/litellm-rust/crates/router/tests/router.rs
+++ b/litellm-rust/crates/router/tests/router.rs
@@ -16,7 +16,7 @@ fn configuration_preserves_deployment_parameters(#[case] parameters: &str) {
         "model_list:\n  - model_name: public-model\n    litellm_params:\n      model: provider/model\n      {parameters}"
     ))
     .unwrap();
-    let router = Router::from_model_list(&config.model_list);
+    let router = Router::from_config(&config, &|_: &str| None);
     let deployment = router.get(&config.model_list[0].model_name).unwrap();
     let params = &config.model_list[0].litellm_params;
 
@@ -44,7 +44,7 @@ fn configuration_types_the_provider_params_of_a_deployment() {
       azure_ad_token: ignored-by-every-group",
     )
     .unwrap();
-    let router = Router::from_model_list(&config.model_list);
+    let router = Router::from_config(&config, &|_: &str| None);
     let params = &router.get("public-model").unwrap().litellm_params;
 
     assert_eq!(
@@ -74,7 +74,7 @@ fn lookup_uses_public_names(#[case] name: &str, #[case] expected: Option<&str>)
       model: provider/b",
     )
     .unwrap();
-    let router = Router::from_model_list(&config.model_list);
+    let router = Router::from_config(&config, &|_: &str| None);
 
     assert_eq!(router.get(name).map(|entry| entry.model.as_str()), expected);
 }
@@ -84,7 +84,7 @@ fn empty_configuration_has_no_deployment() {
     let config = Config::from_yaml("model_list: []").unwrap();
 
     assert!(
-        Router::from_model_list(&config.model_list)
+        Router::from_config(&config, &|_: &str| None)
             .get("")
             .is_none()
     );
diff --git a/litellm/__init__.py b/litellm/__init__.py
index 8dfe5adca1c..c649a48211a 100644
--- a/litellm/__init__.py
+++ b/litellm/__init__.py
@@ -1336,7 +1336,6 @@ all_embedding_models = (
 )
 
 ####### IMAGE GENERATION MODELS ###################
-openai_image_generation_models = ["dall-e-2", "dall-e-3"]
 
 ####### VIDEO GENERATION MODELS ###################
 openai_video_generation_models = ["sora-2"]
diff --git a/litellm/a2a_protocol/providers/bedrock_agentcore/transformation.py b/litellm/a2a_protocol/providers/bedrock_agentcore/transformation.py
index 1cea0194715..d4400fbb4cc 100644
--- a/litellm/a2a_protocol/providers/bedrock_agentcore/transformation.py
+++ b/litellm/a2a_protocol/providers/bedrock_agentcore/transformation.py
@@ -19,6 +19,7 @@ from litellm.a2a_protocol.utils import (
 )
 from litellm.exceptions import BadRequestError
 from litellm.llms.bedrock.chat.agentcore.transformation import AmazonAgentCoreConfig
+from litellm.llms.custom_httpx.sse_lines import aiter_sse_lines
 
 RUNTIME_SESSION_ID_MIN_LENGTH: Final = 33
 RUNTIME_SESSION_ID_MAX_LENGTH: Final = 256
@@ -50,7 +51,7 @@ _RESERVED_PREFIX_HEADERS: Final[tuple[str, ...]] = (
 class _SSELineSource(Protocol):
     """Minimal streaming-response surface used to read SSE lines."""
 
-    def aiter_lines(self) -> AsyncIterator[str]: ...
+    def aiter_text(self) -> AsyncIterator[str]: ...
 
 
 def _filter_reserved_headers(
@@ -244,7 +245,7 @@ class BedrockAgentCoreA2ATransformation:
         Yields:
             Parsed JSON dicts from SSE data lines
         """
-        async for line in response.aiter_lines():
+        async for line in aiter_sse_lines(response.aiter_text()):
             line = line.strip()
             if not line:
                 continue
diff --git a/litellm/a2a_protocol/providers/watsonx_orchestrate/handler.py b/litellm/a2a_protocol/providers/watsonx_orchestrate/handler.py
index 0a2871d25cc..3937c47ea3c 100644
--- a/litellm/a2a_protocol/providers/watsonx_orchestrate/handler.py
+++ b/litellm/a2a_protocol/providers/watsonx_orchestrate/handler.py
@@ -20,6 +20,7 @@ from litellm.llms.custom_httpx.http_handler import (
     AsyncHTTPHandler,
     get_async_httpx_client,
 )
+from litellm.llms.custom_httpx.sse_lines import aiter_sse_lines
 from litellm.types.llms.custom_http import httpxSpecialProvider
 
 _IBM_CLOUD_IAM_URL: Final = "https://iam.cloud.ibm.com/identity/token"
@@ -74,7 +75,7 @@ class _WXORun(TypedDict, total=False):
 
 
 class _SSELineSource(Protocol):
-    def aiter_lines(self) -> AsyncIterator[str]: ...
+    def aiter_text(self) -> AsyncIterator[str]: ...
 
 
 class _WXOView(TypedDict, total=False):
@@ -231,7 +232,7 @@ class WatsonxOrchestrateHandler:
     async def _accumulate_wxo_sse_text(response: _SSELineSource) -> str:
         source: Final[_WXOView] = {"sse_source": response}
         accumulated_text = ""
-        async for line in source["sse_source"].aiter_lines():
+        async for line in aiter_sse_lines(source["sse_source"].aiter_text()):
             if not line.startswith("data:"):
                 continue
             data_str = line[5:].strip()
diff --git a/litellm/caching/in_memory_cache.py b/litellm/caching/in_memory_cache.py
index 1cc3e106aa0..6b40c48c4ef 100644
--- a/litellm/caching/in_memory_cache.py
+++ b/litellm/caching/in_memory_cache.py
@@ -274,7 +274,9 @@ class InMemoryCache(BaseCache):
     ) -> list[float] | None:
         results: Final = []
         for increment in increment_list:
-            result = await self.async_increment(increment["key"], increment["increment_value"], **kwargs)
+            result = await self.async_increment(
+                increment["key"], increment["increment_value"], ttl=increment["ttl"], **kwargs
+            )
             results.append(result)
         return results
 
diff --git a/litellm/completion_extras/litellm_responses_transformation/transformation.py b/litellm/completion_extras/litellm_responses_transformation/transformation.py
index 47a3a903d82..ee3639ac387 100644
--- a/litellm/completion_extras/litellm_responses_transformation/transformation.py
+++ b/litellm/completion_extras/litellm_responses_transformation/transformation.py
@@ -34,6 +34,7 @@ from litellm.llms.base_llm.base_model_iterator import BaseModelResponseIterator
 from litellm.llms.base_llm.bridges.completion_transformation import (
     CompletionTransformationBridge,
 )
+from litellm.llms.custom_httpx.sse_lines import split_sse_lines
 from litellm.responses.litellm_completion_transformation.tool_search import is_anthropic_tool_search_chat_tool
 from litellm.responses.sse_output_recovery import (
     parse_sse_json_chunk,
@@ -1351,7 +1352,7 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge):
         recovered_output_items: Final[dict[int, dict[str, object]]] = {}
         recovered_text_only_items: Final[dict[int, dict[str, object]]] = {}
 
-        for chunk in raw_sse.splitlines():
+        for chunk in split_sse_lines(raw_sse):
             parsed_chunk = parse_sse_json_chunk(chunk)
             if parsed_chunk is None:
                 continue
diff --git a/litellm/constants.py b/litellm/constants.py
index 1d5c6404bfd..25770d960bb 100644
--- a/litellm/constants.py
+++ b/litellm/constants.py
@@ -764,7 +764,6 @@ ANTHROPIC_WEB_SEARCH_TOOL_MAX_USES: Final = {
 # Used for web search interception across providers
 LITELLM_WEB_SEARCH_TOOL_NAME: Final = "litellm_web_search"
 
-DEFAULT_IMAGE_ENDPOINT_MODEL: Final = "dall-e-2"
 DEFAULT_VIDEO_ENDPOINT_MODEL: Final = "sora-2"
 
 DEFAULT_GOOGLE_VIDEO_DURATION_SECONDS: Final = get_env_int("DEFAULT_GOOGLE_VIDEO_DURATION_SECONDS", 8)
diff --git a/litellm/cost_calculator.py b/litellm/cost_calculator.py
index 86b22069a39..087d5b5b718 100644
--- a/litellm/cost_calculator.py
+++ b/litellm/cost_calculator.py
@@ -1592,14 +1592,6 @@ def completion_cost(
                     for part in ws_tier_parts
                 )
 
-        if (
-            (call_type == "aimage_generation" or call_type == "image_generation")
-            and model is not None
-            and isinstance(model, str)
-            and len(model) == 0
-            and custom_llm_provider == "azure"
-        ):
-            model = "dall-e-2"  # for dall-e-2, azure expects an empty model name
         # Handle Inputs to completion_cost
         prompt_tokens = 0
         prompt_characters: int | None = None
@@ -1674,7 +1666,8 @@ def completion_cost(
             raw_candidates if custom_pricing is True else _priced_candidates_before_unpriced_rules(raw_candidates)
         )
 
-        for idx, (model, candidate_pricing_provider) in enumerate(potential_model_names):
+        for idx, (candidate_model, candidate_pricing_provider) in enumerate(potential_model_names):
+            model = candidate_model
             try:
                 if verbose_logger.isEnabledFor(logging.DEBUG):
                     verbose_logger.debug("selected model name for cost calculation: %s", model)
diff --git a/litellm/google_genai/streaming_iterator.py b/litellm/google_genai/streaming_iterator.py
index a22c47cb1e7..08ac7d4f9dc 100644
--- a/litellm/google_genai/streaming_iterator.py
+++ b/litellm/google_genai/streaming_iterator.py
@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Any, Final
 
 import litellm
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+from litellm.llms.custom_httpx.sse_lines import aiter_sse_lines, iter_sse_lines
 from litellm.proxy.pass_through_endpoints.success_handler import (
     PassThroughEndpointLogging,
 )
@@ -131,9 +132,9 @@ class GoogleGenAIGenerateContentStreamingIterator(BaseGoogleGenAIGenerateContent
         self.model = model
         self.generate_content_provider_config = generate_content_provider_config
         self.litellm_metadata = litellm_metadata
-        # Gemini streamGenerateContent uses SSE line framing; iter_lines keeps
+        # Gemini streamGenerateContent uses SSE line framing; iter_sse_lines keeps
         # large inlineData payloads (e.g. image/jpeg) intact within one event.
-        self.stream_iterator = response.iter_lines()
+        self.stream_iterator = iter_sse_lines(response.iter_text())
 
     def __iter__(self):
         return self
@@ -182,9 +183,9 @@ class AsyncGoogleGenAIGenerateContentStreamingIterator(BaseGoogleGenAIGenerateCo
         self.model = model
         self.generate_content_provider_config = generate_content_provider_config
         self.litellm_metadata = litellm_metadata
-        # Gemini streamGenerateContent uses SSE line framing; aiter_lines keeps
+        # Gemini streamGenerateContent uses SSE line framing; aiter_sse_lines keeps
         # large inlineData payloads (e.g. image/jpeg) intact within one event.
-        self.stream_iterator = response.aiter_lines()
+        self.stream_iterator = aiter_sse_lines(response.aiter_text())
 
     def __aiter__(self):
         return self
diff --git a/litellm/images/main.py b/litellm/images/main.py
index 84156919774..6e77cbb7046 100644
--- a/litellm/images/main.py
+++ b/litellm/images/main.py
@@ -1,9 +1,9 @@
 import asyncio
 import contextvars
 import importlib
-from collections.abc import Coroutine, Mapping
+from collections.abc import Collection, Coroutine, Mapping
 from functools import partial
-from typing import TYPE_CHECKING, Final, Literal, cast, overload
+from typing import TYPE_CHECKING, Final, Literal, cast, get_type_hints, overload
 
 from pydantic import TypeAdapter, ValidationError
 
@@ -16,7 +16,6 @@ import litellm
 
 # client is imported from litellm as it's a decorator
 from litellm import client
-from litellm.constants import DEFAULT_IMAGE_ENDPOINT_MODEL
 from litellm.constants import request_timeout as DEFAULT_REQUEST_TIMEOUT
 from litellm.exceptions import LiteLLMUnknownProvider
 from litellm.litellm_core_utils.get_llm_provider_logic import (
@@ -61,6 +60,7 @@ from litellm.types.utils import (
     ProviderRoutingHints,
 )
 from litellm.utils import (
+    EXTRA_BODY_ROUTING_KEYS,
     ImageResponse,
     ProviderConfigManager,
     get_llm_provider,
@@ -298,17 +298,14 @@ def image_generation(
             if custom_llm_provider == "chatgpt" or (model is not None and model.startswith("chatgpt/"))
             else None
         )
-        dynamic_api_key: str | None = None
-        if model is not None or custom_llm_provider is not None:
-            model, custom_llm_provider, dynamic_api_key, api_base = get_llm_provider(
-                model=model,
-                custom_llm_provider=custom_llm_provider,
-                api_base=api_base,
-                litellm_params=chatgpt_params,
-            )
-        else:
-            model = "dall-e-2"
-            custom_llm_provider = "openai"  # default to dall-e-2 on openai
+        if model is None and custom_llm_provider is None:
+            raise litellm.BadRequestError(message="model is required", model="", llm_provider="")
+        model, custom_llm_provider, dynamic_api_key, api_base = get_llm_provider(
+            model=model,
+            custom_llm_provider=custom_llm_provider,
+            api_base=api_base,
+            litellm_params=chatgpt_params,
+        )
         model_response.hidden_params["model"] = model
         openai_params: Final = [
             "user",
@@ -466,7 +463,7 @@ def image_generation(
             litellm.LlmProviders.QWENCLOUD,
             litellm.LlmProviders.QWEN_AI_PLATFORM,
             litellm.LlmProviders.EDENAI,
-        ):
+        ) or (custom_llm_provider == litellm.LlmProviders.TENCENT and image_generation_config is not None):
             if image_generation_config is None:
                 raise ValueError(f"image generation config is not supported for {custom_llm_provider}")
 
@@ -711,7 +708,7 @@ async def aimage_variation(*args, **kwargs) -> ImageResponse:
 @client
 def image_variation(
     image: FileTypes,
-    model: str = "dall-e-2",  # set to dall-e-2 by default - like OpenAI.
+    model: str | None = None,
     n: int = 1,
     response_format: Literal["url", "b64_json"] = "url",
     size: str | None = None,
@@ -727,7 +724,7 @@ def image_variation(
     litellm_params: Final = get_litellm_params(**kwargs)
     # get the custom llm provider
     model, custom_llm_provider, dynamic_api_key, api_base = get_llm_provider(
-        model=model,
+        model=model or "",
         custom_llm_provider=litellm_params.get("custom_llm_provider", None),
         api_base=litellm_params.get("api_base", None),
         api_key=litellm_params.get("api_key", None),
@@ -746,7 +743,7 @@ def image_variation(
     response: ImageResponse | None = None
 
     provider_config: Final = ProviderConfigManager.get_provider_model_info(
-        model=model or "",  # openai defaults to dall-e-2
+        model=model,
         provider=llm_provider,
     )
 
@@ -771,7 +768,7 @@ def image_variation(
             model_response=model_response,
             api_key=api_key,
             api_base=api_base,
-            model=model,
+            model=model or None,
             image=image,
             timeout=litellm_params.get("timeout", None),
             custom_llm_provider=custom_llm_provider,
@@ -789,7 +786,7 @@ def image_variation(
             model_response=model_response,
             api_key=api_key,
             api_base=api_base,
-            model=model,
+            model=model or None,
             image=image,
             timeout=litellm_params.get("timeout", None) or DEFAULT_REQUEST_TIMEOUT,
             custom_llm_provider=custom_llm_provider,
@@ -807,6 +804,32 @@ def image_variation(
     return response
 
 
+_IMAGE_EDIT_OPENAI_PARAMS: Final = frozenset(get_type_hints(ImageEditOptionalRequestParams))
+_DROP_PARAM_KWARGS: Final = frozenset({"drop_params", "additional_drop_params"})
+_ADDITIONAL_DROP_PARAMS: Final = TypeAdapter[tuple[str, ...]](tuple[str, ...])
+
+
+def _listed_drop_params(additional_drop_params: object) -> tuple[str, ...]:
+    try:
+        return _ADDITIONAL_DROP_PARAMS.validate_python(additional_drop_params)
+    except ValidationError:
+        return ()
+
+
+def _tokenhub_passthrough_edit_params(
+    non_default_params: Mapping[str, object],
+    extra_body: Mapping[str, object] | None,
+    mapped_params: Collection[str],
+    additional_drop_params: Collection[str] | None,
+) -> Mapping[str, object]:
+    dropped: Final = frozenset(additional_drop_params or ())
+    unmapped_excluded: Final = _DROP_PARAM_KWARGS | _IMAGE_EDIT_OPENAI_PARAMS | frozenset(mapped_params) | dropped
+    return {
+        **{key: value for key, value in non_default_params.items() if key not in unmapped_excluded},
+        **{key: value for key, value in (extra_body or {}).items() if key not in dropped | EXTRA_BODY_ROUTING_KEYS},
+    }
+
+
 @client
 def image_edit(
     image: FileTypes | list[FileTypes] | None = None,
@@ -874,7 +897,7 @@ def image_edit(
         # get llm provider logic
         litellm_params: Final = GenericLiteLLMParams(**kwargs)
         model, custom_llm_provider, _, _ = get_llm_provider(
-            model=model or DEFAULT_IMAGE_ENDPOINT_MODEL,
+            model=model or "",
             custom_llm_provider=custom_llm_provider,
         )
 
@@ -935,22 +958,24 @@ def image_edit(
             raise ValueError(f"image edit is not supported for {custom_llm_provider}")
 
         local_vars.update(kwargs)
+        provider_supported_params: Final[frozenset[str]] = frozenset(
+            image_edit_provider_config.get_supported_openai_params(model)
+        )
         # Get ImageEditOptionalRequestParams with only valid parameters
         image_edit_optional_params: Final[ImageEditOptionalRequestParams] = (
             _get_ImageEditRequestUtils().get_requested_image_edit_optional_param(
                 local_vars,
-                provider_supported_params=frozenset(
-                    image_edit_provider_config.get_supported_openai_params(model)
-                ).intersection(non_default_params),
+                provider_supported_params=provider_supported_params.intersection(non_default_params),
             )
         )
         # Get optional parameters for the responses API
+        additional_drop_params: Final = _listed_drop_params(kwargs.get("additional_drop_params"))
         image_edit_request_params: Final[dict] = _get_ImageEditRequestUtils().get_optional_params_image_edit(
             model=model,
             image_edit_provider_config=image_edit_provider_config,
             image_edit_optional_params=image_edit_optional_params,
             drop_params=kwargs.get("drop_params"),
-            additional_drop_params=kwargs.get("additional_drop_params"),
+            additional_drop_params=additional_drop_params,
         )
 
         if image_edit_provider_config.use_multipart_form_data() and (
@@ -1039,7 +1064,19 @@ def image_edit(
             image=images,
             prompt=prompt,
             image_edit_provider_config=image_edit_provider_config,
-            image_edit_optional_request_params=image_edit_request_params,
+            image_edit_optional_request_params={
+                **image_edit_request_params,
+                **(
+                    _tokenhub_passthrough_edit_params(
+                        non_default_params,
+                        extra_body if isinstance(extra_body, dict) else None,
+                        provider_supported_params,
+                        additional_drop_params,
+                    )
+                    if custom_llm_provider == litellm.LlmProviders.TENCENT.value
+                    else {}
+                ),
+            },
             custom_llm_provider=custom_llm_provider,
             litellm_params=litellm_params,
             logging_obj=litellm_logging_obj,
diff --git a/litellm/images/utils.py b/litellm/images/utils.py
index 24454954714..4e0cde24a68 100644
--- a/litellm/images/utils.py
+++ b/litellm/images/utils.py
@@ -1,6 +1,9 @@
+import base64
+import os
 from collections.abc import Collection, Mapping
 from io import BufferedReader, BytesIO
-from typing import Any, Final, cast, get_type_hints
+from pathlib import Path
+from typing import Any, Final, Protocol, cast, get_type_hints, runtime_checkable
 
 import litellm
 from litellm.litellm_core_utils.token_counter import get_image_type
@@ -16,7 +19,7 @@ class ImageEditRequestUtils:
         image_edit_provider_config: BaseImageEditConfig,
         image_edit_optional_params: ImageEditOptionalRequestParams,
         drop_params: bool | None = None,
-        additional_drop_params: list[str] | None = None,
+        additional_drop_params: Collection[str] | None = None,
     ) -> dict:
         """
         Get optional parameters for the image edit API.
@@ -145,3 +148,36 @@ class ImageEditRequestUtils:
         except Exception:
             # If anything goes wrong, default to PNG
             return FILE_MIME_TYPES[FileType.PNG]
+
+
+@runtime_checkable
+class _SeekableBinaryReader(Protocol):
+    def tell(self) -> int: ...
+
+    def seek(self, offset: int) -> int: ...
+
+    def read(self) -> bytes: ...
+
+
+def _read_image_bytes(image: object) -> bytes:
+    if isinstance(image, bytes):
+        return image
+    if isinstance(image, tuple):
+        return _read_image_bytes(image[1])
+    if isinstance(image, os.PathLike):
+        return Path(image).read_bytes()
+    if isinstance(image, _SeekableBinaryReader):
+        position: Final = image.tell()
+        image.seek(0)
+        data: Final = image.read()
+        image.seek(position)
+        return data
+    raise ValueError(f"Unsupported image type for image edit: {type(image).__name__}")
+
+
+def image_to_data_url(image: object) -> str:
+    if isinstance(image, str):
+        return image
+    image_bytes: Final = _read_image_bytes(image)
+    mime_type: Final = ImageEditRequestUtils.get_image_content_type(image_bytes)
+    return f"data:{mime_type};base64,{base64.b64encode(image_bytes).decode('utf-8')}"
diff --git a/litellm/integrations/websearch_interception/handler.py b/litellm/integrations/websearch_interception/handler.py
index a38b8bed595..6e1ba3eea08 100644
--- a/litellm/integrations/websearch_interception/handler.py
+++ b/litellm/integrations/websearch_interception/handler.py
@@ -97,6 +97,8 @@ WEBSEARCH_NATIVE_BLOCKS_METADATA_KEY: Final = "websearch_native_blocks"
 
 _RESPONSE_CONTENT_FIELD: Final = "content"
 
+_CLAUDE_CODE_WEB_SEARCH_PROMPT_PREFIX: Final = "Perform a web search for the query:"
+
 _ResponseT: Final = TypeVar("_ResponseT")
 
 
@@ -363,7 +365,8 @@ class WebSearchInterceptionLogger(CustomLogger):
             get_last_user_message,
         )
 
-        query: Final = get_last_user_message(cast(list[AllMessageValues], messages))
+        last_user_message: Final = get_last_user_message(cast(list[AllMessageValues], messages)) or ""
+        query: Final = last_user_message.removeprefix(_CLAUDE_CODE_WEB_SEARCH_PROMPT_PREFIX).strip()
         if not query:
             return None
 
diff --git a/litellm/interactions/streaming_iterator.py b/litellm/interactions/streaming_iterator.py
index f4ad57bf7b4..c7faa3fc510 100644
--- a/litellm/interactions/streaming_iterator.py
+++ b/litellm/interactions/streaming_iterator.py
@@ -21,6 +21,7 @@ from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLogging
 from litellm.litellm_core_utils.llm_response_utils.get_api_base import get_api_base
 from litellm.litellm_core_utils.thread_pool_executor import executor
 from litellm.llms.base_llm.interactions.transformation import BaseInteractionsAPIConfig
+from litellm.llms.custom_httpx.sse_lines import aiter_sse_lines, iter_sse_lines
 from litellm.types.interactions import (
     InteractionsAPIStreamingResponse,
 )
@@ -145,7 +146,7 @@ class InteractionsAPIStreamingIterator(BaseInteractionsAPIStreamingIterator):
             litellm_metadata=litellm_metadata,
             custom_llm_provider=custom_llm_provider,
         )
-        self.stream_iterator = response.aiter_lines()
+        self.stream_iterator = aiter_sse_lines(response.aiter_text())
 
     def __aiter__(self):
         return self
@@ -212,7 +213,7 @@ class SyncInteractionsAPIStreamingIterator(BaseInteractionsAPIStreamingIterator)
             litellm_metadata=litellm_metadata,
             custom_llm_provider=custom_llm_provider,
         )
-        self.stream_iterator = response.iter_lines()
+        self.stream_iterator = iter_sse_lines(response.iter_text())
 
     def __iter__(self):
         return self
diff --git a/litellm/router_utils/batch_utils.py b/litellm/litellm_core_utils/batch_utils.py
similarity index 100%
rename from litellm/router_utils/batch_utils.py
rename to litellm/litellm_core_utils/batch_utils.py
diff --git a/litellm/litellm_core_utils/get_litellm_params.py b/litellm/litellm_core_utils/get_litellm_params.py
index ba964d200ec..8178b7e98b8 100644
--- a/litellm/litellm_core_utils/get_litellm_params.py
+++ b/litellm/litellm_core_utils/get_litellm_params.py
@@ -75,6 +75,8 @@ OPTIONAL_KWARGS_KEYS: Final = (
             "rpm",
             "itpm",
             "otpm",
+            "tpd",
+            "rpd",
             "use_xai_oauth",
             "chatgpt_auth_file",
             "github_copilot_auth_type",
diff --git a/litellm/litellm_core_utils/get_llm_provider_logic.py b/litellm/litellm_core_utils/get_llm_provider_logic.py
index 19c1d5c414c..d9933087334 100644
--- a/litellm/litellm_core_utils/get_llm_provider_logic.py
+++ b/litellm/litellm_core_utils/get_llm_provider_logic.py
@@ -437,7 +437,6 @@ def get_llm_provider(
             model in litellm.open_ai_chat_completion_models
             or "ft:gpt-3.5-turbo" in model
             or "ft:gpt-4" in model  # catches ft:gpt-4-0613, ft:gpt-4o
-            or model in litellm.openai_image_generation_models
             or model.startswith("gpt-image")
             or model in litellm.openai_video_generation_models
         ):
diff --git a/litellm/litellm_core_utils/litellm_logging.py b/litellm/litellm_core_utils/litellm_logging.py
index 80f1f8f5eca..8b66c27b930 100644
--- a/litellm/litellm_core_utils/litellm_logging.py
+++ b/litellm/litellm_core_utils/litellm_logging.py
@@ -3481,7 +3481,7 @@ class Logging(LiteLLMLoggingBaseClass):
                             start_time=start_time,
                             end_time=end_time,
                             print_verbose=print_verbose,
-                            level=LogfireLevel.INFO.value,
+                            level=LogfireLevel.INFO,
                         )
 
                     if callback == "lunary" and lunaryLogger is not None:
@@ -4442,7 +4442,7 @@ class Logging(LiteLLMLoggingBaseClass):
                             response_obj=result,
                             start_time=start_time,
                             end_time=end_time,
-                            level=LogfireLevel.ERROR.value,
+                            level=LogfireLevel.ERROR,
                             print_verbose=print_verbose,
                         )
 
diff --git a/litellm/litellm_core_utils/llm_cost_calc/utils.py b/litellm/litellm_core_utils/llm_cost_calc/utils.py
index 3b49f239afe..4b0b875af6d 100644
--- a/litellm/litellm_core_utils/llm_cost_calc/utils.py
+++ b/litellm/litellm_core_utils/llm_cost_calc/utils.py
@@ -6,7 +6,7 @@ from collections.abc import Mapping, Sequence
 from dataclasses import dataclass, field, replace
 from datetime import datetime, timezone, tzinfo
 from types import MappingProxyType
-from typing import Final, Literal, TypedDict, cast
+from typing import Final, Literal, Protocol, TypedDict, cast
 from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 from typing_extensions import ReadOnly
@@ -2085,6 +2085,41 @@ def calculate_image_response_web_search_cost(
     )
 
 
+class _ModelPricedImageCostCalculator(Protocol):
+    def __call__(self, model: str, image_response: ImageResponse, model_info: ModelInfo | None = None) -> float: ...
+
+
+def _model_priced_image_cost_calculator(
+    custom_llm_provider: str | None, model: str
+) -> _ModelPricedImageCostCalculator | None:
+    match custom_llm_provider:
+        case litellm.LlmProviders.RECRAFT.value:
+            from litellm.llms.recraft.cost_calculator import cost_calculator as recraft_image_cost_calculator
+
+            return recraft_image_cost_calculator
+        case litellm.LlmProviders.AIML.value:
+            from litellm.llms.aiml.image_generation.cost_calculator import cost_calculator as aiml_image_cost_calculator
+
+            return aiml_image_cost_calculator
+        case litellm.LlmProviders.COMETAPI.value:
+            from litellm.llms.cometapi.image_generation.cost_calculator import (
+                cost_calculator as cometapi_image_cost_calculator,
+            )
+
+            return cometapi_image_cost_calculator
+        case litellm.LlmProviders.RUNWAYML.value:
+            from litellm.llms.runwayml.cost_calculator import cost_calculator as runwayml_image_cost_calculator
+
+            return runwayml_image_cost_calculator
+        case litellm.LlmProviders.TENCENT.value:
+            from litellm.llms.tencent.cost_calculator import image_cost_calculator as tencent_image_cost_calculator
+            from litellm.llms.tencent.image_generation.transformation import is_tokenhub_image_model
+
+            return tencent_image_cost_calculator if is_tokenhub_image_model(model) else None
+        case _:
+            return None
+
+
 class CostCalculatorUtils:
     @staticmethod
     def call_type_has_image_response(call_type: str) -> bool:
@@ -2131,9 +2166,6 @@ class CostCalculatorUtils:
         from litellm.llms.gemini.image_generation.cost_calculator import (
             cost_calculator as gemini_image_cost_calculator,
         )
-        from litellm.llms.recraft.cost_calculator import (
-            cost_calculator as recraft_image_cost_calculator,
-        )
         from litellm.llms.vertex_ai.image_generation.cost_calculator import (
             cost_calculator as vertex_ai_image_cost_calculator,
         )
@@ -2146,7 +2178,10 @@ class CostCalculatorUtils:
         )
         resolved_n: Final = n if n is not None else (len(completion_response.data) if completion_response.data else 0)
         pricing: Final = deployment_pricing(model_info)
+        model_priced_calculator: Final = _model_priced_image_cost_calculator(custom_llm_provider, model)
 
+        if model_priced_calculator is not None:
+            return model_priced_calculator(model=model, image_response=completion_response, model_info=pricing)
         if custom_llm_provider == litellm.LlmProviders.VERTEX_AI.value:
             if isinstance(completion_response, ImageResponse):
                 return vertex_ai_image_cost_calculator(
@@ -2164,36 +2199,6 @@ class CostCalculatorUtils:
                     optional_params=optional_params,
                 )
             raise TypeError("completion_response must be of type ImageResponse for bedrock image cost calculation")
-        elif custom_llm_provider == litellm.LlmProviders.RECRAFT.value:
-            from litellm.llms.recraft.cost_calculator import (
-                cost_calculator as recraft_image_cost_calculator,
-            )
-
-            return recraft_image_cost_calculator(
-                model=model,
-                image_response=completion_response,
-                model_info=pricing,
-            )
-        elif custom_llm_provider == litellm.LlmProviders.AIML.value:
-            from litellm.llms.aiml.image_generation.cost_calculator import (
-                cost_calculator as aiml_image_cost_calculator,
-            )
-
-            return aiml_image_cost_calculator(
-                model=model,
-                image_response=completion_response,
-                model_info=pricing,
-            )
-        elif custom_llm_provider == litellm.LlmProviders.COMETAPI.value:
-            from litellm.llms.cometapi.image_generation.cost_calculator import (
-                cost_calculator as cometapi_image_cost_calculator,
-            )
-
-            return cometapi_image_cost_calculator(
-                model=model,
-                image_response=completion_response,
-                model_info=pricing,
-            )
         elif custom_llm_provider == litellm.LlmProviders.GEMINI.value:
             if call_type in (
                 CallTypes.image_edit.value,
@@ -2237,16 +2242,6 @@ class CostCalculatorUtils:
                 optional_params=optional_params,
                 model_info=pricing,
             )
-        elif custom_llm_provider == litellm.LlmProviders.RUNWAYML.value:
-            from litellm.llms.runwayml.cost_calculator import (
-                cost_calculator as runwayml_image_cost_calculator,
-            )
-
-            return runwayml_image_cost_calculator(
-                model=model,
-                image_response=completion_response,
-                model_info=pricing,
-            )
         elif (
             custom_llm_provider == litellm.LlmProviders.OPENAI.value
             or custom_llm_provider == litellm.LlmProviders.AZURE.value
diff --git a/litellm/litellm_core_utils/prompt_templates/common_utils.py b/litellm/litellm_core_utils/prompt_templates/common_utils.py
index cf6bdc69556..101f069c0f8 100644
--- a/litellm/litellm_core_utils/prompt_templates/common_utils.py
+++ b/litellm/litellm_core_utils/prompt_templates/common_utils.py
@@ -21,8 +21,8 @@ from pydantic import TypeAdapter
 
 import litellm
 from litellm import verbose_logger
+from litellm.litellm_core_utils.batch_utils import InMemoryFile
 from litellm.litellm_core_utils.core_helpers import as_str_mapping
-from litellm.router_utils.batch_utils import InMemoryFile
 from litellm.types.llms.openai import (
     AllMessageValues,
     ChatCompletionAssistantMessage,
diff --git a/litellm/litellm_core_utils/safe_json_dumps.py b/litellm/litellm_core_utils/safe_json_dumps.py
index 63242a580e7..24c401281ef 100644
--- a/litellm/litellm_core_utils/safe_json_dumps.py
+++ b/litellm/litellm_core_utils/safe_json_dumps.py
@@ -34,7 +34,7 @@ def safe_json_structure(
     def _transform(key: str | None, value: str) -> str:
         return value if value_transform is None else value_transform(key, value)
 
-    def _serialize(obj: object, seen: set[int], depth: int, key: str | None = None) -> Any:
+    def _serialize(obj: object, seen: set[int], depth: int, key: str | None = None) -> object:
         # Check for maximum depth.
         if depth > max_depth:
             return "MaxDepthExceeded"
@@ -48,32 +48,32 @@ def safe_json_structure(
         if id(obj) in seen:
             return "CircularReference Detected"
         seen.add(id(obj))
-        result: dict | list | tuple | set | str
         if isinstance(obj, dict):
-            result = {}
-            for k, v in obj.items():
-                if isinstance(k, (str)):
-                    clean_k = k.replace("\x00", "") if "\x00" in k else k
-                    result[clean_k] = _serialize(v, seen, depth + 1, clean_k)
+            mapping_result: Final = {
+                (clean_k := k.replace("\x00", "") if "\x00" in k else k): _serialize(v, seen, depth + 1, clean_k)
+                for k, v in obj.items()
+                if isinstance(k, str)
+            }
             seen.remove(id(obj))
-            return result
+            return mapping_result
         elif isinstance(obj, list):
-            result = [_serialize(item, seen, depth + 1, key) for item in obj]
+            list_result: Final = [_serialize(item, seen, depth + 1, key) for item in obj]
             seen.remove(id(obj))
-            return result
+            return list_result
         elif isinstance(obj, tuple):
-            result = tuple(_serialize(item, seen, depth + 1, key) for item in obj)
+            tuple_result: Final = tuple(_serialize(item, seen, depth + 1, key) for item in obj)
             seen.remove(id(obj))
-            return result
+            return tuple_result
         elif isinstance(obj, set):
-            result = sorted([_serialize(item, seen, depth + 1, key) for item in obj])
+            sortable_values: Final[list[Any]] = [_serialize(item, seen, depth + 1, key) for item in obj]
+            set_result: Final = sorted(sortable_values)
             seen.remove(id(obj))
-            return result
+            return set_result
         elif isinstance(obj, BaseModel):
             dumped: Final = obj.model_dump()
-            result = _serialize(dumped, seen, depth + 1, key)
+            model_result: Final = _serialize(dumped, seen, depth + 1, key)
             seen.remove(id(obj))
-            return result
+            return model_result
         else:
             # Fall back to string conversion for non-serializable objects.
             try:
diff --git a/litellm/litellm_core_utils/streaming_handler.py b/litellm/litellm_core_utils/streaming_handler.py
index 3fb25de43cc..2348d8e57d6 100644
--- a/litellm/litellm_core_utils/streaming_handler.py
+++ b/litellm/litellm_core_utils/streaming_handler.py
@@ -1263,7 +1263,7 @@ class CustomStreamWrapper:
                 )
 
             if _is_delta_empty:
-                model_response.choices[0].delta = Delta(content=None)  # ensure empty delta chunk returned
+                model_response.choices[0].delta = Delta(content=self._close_open_think_block())
                 # get any function call arguments
                 model_response.choices[0].finish_reason = map_finish_reason(
                     finish_reason=self.received_finish_reason
@@ -1292,21 +1292,26 @@ class CustomStreamWrapper:
         if self.merge_reasoning_content_in_choices is not True:
             return
         delta: Final = model_response.choices[0].delta
-        reasoning_content: Final = getattr(delta, "reasoning_content", None)
+        reasoning_content: Final = getattr(delta, "reasoning_content", None) or ""
         content: Final = delta.content or ""
-        if reasoning_content:
-            self._emitted_disqualifying_content = True
-            closes_thinking: Final = bool(content) and not self.sent_last_thinking_block
-            opening: Final = "" if self.sent_first_thinking_block else "<think>"
-            delta.content = opening + reasoning_content + ("</think>" + content if closes_thinking else "")
-            self.sent_first_thinking_block = True
-            self.sent_last_thinking_block = self.sent_last_thinking_block or closes_thinking
-        elif self.sent_first_thinking_block and not self.sent_last_thinking_block and content:
-            delta.content = "</think>" + content
-            self.sent_last_thinking_block = True
-
+        ends_thinking: Final = bool(content or delta.tool_calls or delta.function_call)
+        inside_think_block: Final = self.sent_first_thinking_block and not self.sent_last_thinking_block
+        opening: Final = "<think>" if reasoning_content and not inside_think_block else ""
+        closing: Final = "</think>" if ends_thinking and (reasoning_content or inside_think_block) else ""
         if hasattr(delta, "reasoning_content"):
             del delta.reasoning_content
+        if not reasoning_content and not closing:
+            return
+        delta.content = opening + reasoning_content + closing + content
+        self.sent_first_thinking_block = True
+        self.sent_last_thinking_block = bool(closing)
+        self._emitted_disqualifying_content = self._emitted_disqualifying_content or bool(reasoning_content)
+
+    def _close_open_think_block(self) -> str | None:
+        if not self.sent_first_thinking_block or self.sent_last_thinking_block:
+            return None
+        self.sent_last_thinking_block = True
+        return "</think>"
 
     def _dispatch_provider_chunk(
         self,
@@ -1932,8 +1937,20 @@ class CustomStreamWrapper:
             model_response.choices[0].finish_reason == "stop" and self.tool_call
         ):  # don't overwrite for other - potential error finish reasons
             model_response.choices[0].finish_reason = "tool_calls"
+        close_tag: Final = self._close_open_think_block()
+        if close_tag is not None:
+            model_response.choices[0].delta.content = close_tag
         return model_response
 
+    def _final_chunk_for_logging(self, processed_chunk: "ModelResponseStream") -> "ModelResponseStream | None":
+        if self.received_finish_reason is not None or self.intermittent_finish_reason is not None:
+            return processed_chunk
+        if processed_chunk.choices[0].delta.content is None:
+            return None
+        return processed_chunk.model_copy(
+            update={"choices": [processed_chunk.choices[0].model_copy(update={"finish_reason": None})]}
+        )
+
     def _record_usage_only_chunk(self, model_response: "ModelResponseStream") -> None:
         """
         Keep provider usage-only chunks (e.g. OpenRouter's post-finish chunk, which carries a
@@ -2173,10 +2190,9 @@ class CustomStreamWrapper:
             else:
                 self.sent_last_chunk = True
                 processed_chunk: Final = self.finish_reason_handler()
-                # The logged response is built from self.chunks; keep a finish_reason the provider sent on its
-                # last content chunk (stripped there), but never add the synthetic "stop" used when it sent none.
-                if self.received_finish_reason is not None or self.intermittent_finish_reason is not None:
-                    self.chunks.append(processed_chunk)
+                final_chunk_for_logging: Final = self._final_chunk_for_logging(processed_chunk)
+                if final_chunk_for_logging is not None:
+                    self.chunks.append(final_chunk_for_logging)
                 if self.stream_options is None:
                     self._set_final_chunk_usage(processed_chunk)
                 ## LOGGING
@@ -2406,10 +2422,9 @@ class CustomStreamWrapper:
         else:
             self.sent_last_chunk = True
             processed_chunk: Final = self.finish_reason_handler()
-            # The logged response is built from self.chunks; keep a finish_reason the provider sent on its
-            # last content chunk (stripped there), but never add the synthetic "stop" used when it sent none.
-            if self.received_finish_reason is not None or self.intermittent_finish_reason is not None:
-                self.chunks.append(processed_chunk)
+            final_chunk_for_logging: Final = self._final_chunk_for_logging(processed_chunk)
+            if final_chunk_for_logging is not None:
+                self.chunks.append(final_chunk_for_logging)
             if self.stream_options is None:
                 self._set_final_chunk_usage(processed_chunk)
             # see sync __next__'s sibling branch: deliberately do NOT restore
diff --git a/litellm/llms/anthropic/chat/handler.py b/litellm/llms/anthropic/chat/handler.py
index 13ceea3e31b..8a82ed98991 100644
--- a/litellm/llms/anthropic/chat/handler.py
+++ b/litellm/llms/anthropic/chat/handler.py
@@ -38,6 +38,7 @@ from litellm.llms.custom_httpx.http_handler import (
     get_async_httpx_client,
     get_httpx_client,
 )
+from litellm.llms.custom_httpx.sse_lines import aiter_sse_lines, iter_sse_lines
 from litellm.types.llms.anthropic import (
     ContentBlockDelta,
     ContentBlockStart,
@@ -233,7 +234,7 @@ async def make_call(
         raise AnthropicError(status_code=500, message=str(e))
 
     completion_stream: Final = ModelResponseIterator(
-        streaming_response=response.aiter_lines(),
+        streaming_response=aiter_sse_lines(response.aiter_text()),
         sync_stream=False,
         json_mode=json_mode,
         speed=speed,
@@ -304,7 +305,7 @@ def make_sync_call(
         )
 
     completion_stream: Final = ModelResponseIterator(
-        streaming_response=response.iter_lines(),
+        streaming_response=iter_sse_lines(response.iter_text()),
         sync_stream=True,
         json_mode=json_mode,
         speed=speed,
diff --git a/litellm/llms/anthropic/messages/stream_assembly.py b/litellm/llms/anthropic/messages/stream_assembly.py
index 90bdad8f4bc..c103eb0f975 100644
--- a/litellm/llms/anthropic/messages/stream_assembly.py
+++ b/litellm/llms/anthropic/messages/stream_assembly.py
@@ -13,6 +13,7 @@ from litellm.llms.anthropic.chat.handler import (
 )
 from litellm.llms.anthropic.chat.transformation import AnthropicConfig
 from litellm.llms.anthropic.messages.native.utils import MESSAGE_DELTA_OPTIONAL_KEYS
+from litellm.llms.custom_httpx.sse_lines import split_sse_lines
 from litellm.types.utils import (
     Choices,
     Message,
@@ -269,7 +270,7 @@ def build_complete_streaming_response_legacy(
 
 def extract_sse_data(event_str: str) -> dict | None:
     """Parse the JSON object from the ``data:`` line of an Anthropic SSE event."""
-    for line in event_str.splitlines():
+    for line in split_sse_lines(event_str):
         stripped = line.strip()
         if stripped.startswith("data:"):
             payload = stripped[len("data:") :].strip()
diff --git a/litellm/llms/anthropic/prompt_cache_prediction.py b/litellm/llms/anthropic/prompt_cache_prediction.py
index 7a4c707860d..17c178d169e 100644
--- a/litellm/llms/anthropic/prompt_cache_prediction.py
+++ b/litellm/llms/anthropic/prompt_cache_prediction.py
@@ -29,7 +29,7 @@ from litellm.llms.anthropic.messages.native.transformation import (
     AnthropicMessagesConfig,
 )
 from litellm.llms.anthropic.messages.native.utils import AnthropicMessagesRequestUtils, prepare_native_messages
-from litellm.router_utils.baseline_request import (
+from litellm.router_strategy.auto_router.baseline_request import (
     BASELINE_PARAMETERS,
     capture_baseline_parameters,
 )
diff --git a/litellm/llms/azure/azure.py b/litellm/llms/azure/azure.py
index 02f1ba3472a..5a181faad11 100644
--- a/litellm/llms/azure/azure.py
+++ b/litellm/llms/azure/azure.py
@@ -13,13 +13,12 @@ from openai import (
     BadRequestError,
     OpenAI,
 )
-from pydantic import BaseModel, TypeAdapter
+from pydantic import BaseModel
 
 import litellm
-from litellm.constants import AZURE_OPERATION_POLLING_TIMEOUT, DEFAULT_MAX_RETRIES
+from litellm.constants import DEFAULT_MAX_RETRIES
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
 from litellm.litellm_core_utils.logging_utils import speech_request_body, track_llm_api_timing
-from litellm.litellm_core_utils.url_utils import SSRFError, assert_same_origin
 from litellm.llms.custom_httpx.http_handler import (
     AsyncHTTPHandler,
     HTTPHandler,
@@ -34,7 +33,6 @@ from litellm.types.utils import (
 from litellm.utils import (
     CustomStreamWrapper,
     convert_to_model_response_object,
-    modify_url,
 )
 
 from ...types.llms.openai import HttpxBinaryResponseContent
@@ -59,8 +57,6 @@ from .image_generation import (
 )
 from .image_generation.http_utils import azure_deployment_image_generation_json_body
 
-_DECODED_JSON: Final = TypeAdapter(object)
-
 
 class AzureOpenAIAssistantsAPIConfig:
     """
@@ -860,11 +856,6 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
         headers: dict,
         deployment_name: str | None = None,
     ) -> httpx.Response:
-        """
-        Implemented for azure dall-e-2 image gen calls
-
-        Alternative to needing a custom transport implementation
-        """
         if client is None:
             _params: Final = {}
             if timeout is not None:
@@ -881,95 +872,6 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
         else:
             async_handler = client
 
-        if (
-            "images/generations" in api_base
-            and api_version
-            in [  # dall-e-3 starts from `2023-12-01-preview` so we should be able to avoid conflict
-                "2023-06-01-preview",
-                "2023-07-01-preview",
-                "2023-08-01-preview",
-                "2023-09-01-preview",
-                "2023-10-01-preview",
-            ]
-        ):  # CREATE + POLL for azure dall-e-2 calls
-            api_base = modify_url(original_url=api_base, new_path="/openai/images/generations:submit")
-
-            data.pop(
-                "model", None
-            )  # REMOVE 'model' from dall-e-2 arg https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#request-a-generated-image-dall-e-2-preview
-            response = await async_handler.post(
-                url=api_base,
-                data=json.dumps(data),
-                headers=headers,
-            )
-            if "operation-location" in response.headers:
-                operation_location_url: Final = response.headers["operation-location"]
-            else:
-                raise AzureOpenAIError(status_code=500, message=response.text)
-            # Reject polling URLs that don't share an origin with ``api_base``.
-            # Without this an upstream-controlled or attacker-controlled
-            # value would receive the operator's Azure API key in the
-            # request headers below. VERIA-51.
-            try:
-                assert_same_origin(operation_location_url, api_base)
-            except SSRFError as ssrf_err:
-                raise AzureOpenAIError(
-                    status_code=502,
-                    message=f"Rejected polling URL: {ssrf_err}",
-                )
-            response = await async_handler.get(
-                url=operation_location_url,
-                headers=headers,
-            )
-
-            await response.aread()
-
-            timeout_secs: Final[int] = AZURE_OPERATION_POLLING_TIMEOUT
-            start_time: Final = time.time()
-            if "status" not in response.json():
-                # Don't reflect the raw response body — when the polling
-                # URL points at an internal JSON API (cloud metadata
-                # service etc.) reflecting it here turns Blind SSRF into
-                # Full-Read SSRF. VERIA-51.
-                raise AzureOpenAIError(
-                    status_code=502,
-                    message="Polling response missing 'status' field",
-                )
-            while response.json()["status"] not in ["succeeded", "failed"]:
-                if time.time() - start_time > timeout_secs:
-                    raise AzureOpenAIError(status_code=408, message="Operation polling timed out.")
-
-                await asyncio.sleep(int(response.headers.get("retry-after") or 10))
-                response = await async_handler.get(
-                    url=operation_location_url,
-                    headers=headers,
-                )
-                await response.aread()
-
-            if response.json()["status"] == "failed":
-                error_data: Final = response.json()
-                # Preserve Azure error details (e.g. content_policy_violation,
-                # inner_error, content_filter_results) as structured body so
-                # exception_type() can route them correctly.
-                _error_body: Final = error_data.get("error", error_data)
-                _error_msg: Final = (
-                    _error_body.get("message", "Image generation failed")
-                    if isinstance(_error_body, dict)
-                    else json.dumps(error_data)
-                )
-                raise AzureOpenAIError(
-                    status_code=400,
-                    message=_error_msg,
-                    body=error_data,
-                )
-
-            result: Final = _DECODED_JSON.validate_python(response.json()["result"])
-            return httpx.Response(
-                status_code=200,
-                headers=response.headers,
-                content=json.dumps(result).encode("utf-8"),
-                request=httpx.Request(method="POST", url="https://api.openai.com/v1"),
-            )
         request_json: Final = azure_deployment_image_generation_json_body(api_base, data, deployment_name)
         return await async_handler.post(
             url=api_base,
@@ -988,11 +890,6 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
         headers: dict,
         deployment_name: str | None = None,
     ) -> httpx.Response:
-        """
-        Implemented for azure dall-e-2 image gen calls
-
-        Alternative to needing a custom transport implementation
-        """
         if client is None:
             _params: Final = {}
             if timeout is not None:
@@ -1006,87 +903,6 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
         else:
             sync_handler = client
 
-        if (
-            "images/generations" in api_base
-            and api_version
-            in [  # dall-e-3 starts from `2023-12-01-preview` so we should be able to avoid conflict
-                "2023-06-01-preview",
-                "2023-07-01-preview",
-                "2023-08-01-preview",
-                "2023-09-01-preview",
-                "2023-10-01-preview",
-            ]
-        ):  # CREATE + POLL for azure dall-e-2 calls
-            api_base = modify_url(original_url=api_base, new_path="/openai/images/generations:submit")
-
-            data.pop(
-                "model", None
-            )  # REMOVE 'model' from dall-e-2 arg https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#request-a-generated-image-dall-e-2-preview
-            response = sync_handler.post(
-                url=api_base,
-                data=json.dumps(data),
-                headers=headers,
-            )
-            if "operation-location" in response.headers:
-                operation_location_url: Final = response.headers["operation-location"]
-            else:
-                raise AzureOpenAIError(status_code=500, message=response.text)
-            try:
-                assert_same_origin(operation_location_url, api_base)
-            except SSRFError as ssrf_err:
-                raise AzureOpenAIError(
-                    status_code=502,
-                    message=f"Rejected polling URL: {ssrf_err}",
-                )
-            response = sync_handler.get(
-                url=operation_location_url,
-                headers=headers,
-            )
-
-            response.read()
-
-            timeout_secs: Final[int] = AZURE_OPERATION_POLLING_TIMEOUT
-            start_time: Final = time.time()
-            if "status" not in response.json():
-                raise AzureOpenAIError(
-                    status_code=502,
-                    message="Polling response missing 'status' field",
-                )
-            while response.json()["status"] not in ["succeeded", "failed"]:
-                if time.time() - start_time > timeout_secs:
-                    raise AzureOpenAIError(status_code=408, message="Operation polling timed out.")
-
-                time.sleep(int(response.headers.get("retry-after") or 10))
-                response = sync_handler.get(
-                    url=operation_location_url,
-                    headers=headers,
-                )
-                response.read()
-
-            if response.json()["status"] == "failed":
-                error_data: Final = response.json()
-                # Preserve Azure error details (e.g. content_policy_violation,
-                # inner_error, content_filter_results) as structured body so
-                # exception_type() can route them correctly.
-                _error_body: Final = error_data.get("error", error_data)
-                _error_msg: Final = (
-                    _error_body.get("message", "Image generation failed")
-                    if isinstance(_error_body, dict)
-                    else json.dumps(error_data)
-                )
-                raise AzureOpenAIError(
-                    status_code=400,
-                    message=_error_msg,
-                    body=error_data,
-                )
-
-            result: Final = _DECODED_JSON.validate_python(response.json()["result"])
-            return httpx.Response(
-                status_code=200,
-                headers=response.headers,
-                content=json.dumps(result).encode("utf-8"),
-                request=httpx.Request(method="POST", url="https://api.openai.com/v1"),
-            )
         request_json: Final = azure_deployment_image_generation_json_body(api_base, data, deployment_name)
         return sync_handler.post(
             url=api_base,
@@ -1193,10 +1009,10 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
                 deployment_name=model,
             )
 
-            provider_config: Final = get_azure_image_generation_config(data.get("model", "dall-e-2"))
+            provider_config: Final = get_azure_image_generation_config(data.get("model", ""))
             if provider_config is not None:
                 return provider_config.transform_image_generation_response(
-                    model=data.get("model", "dall-e-2"),
+                    model=data.get("model", ""),
                     raw_response=httpx_response,
                     model_response=model_response or ImageResponse(),
                     logging_obj=logging_obj,
@@ -1329,10 +1145,10 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
                 headers=request_headers,
                 deployment_name=model,
             )
-            provider_config: Final = get_azure_image_generation_config(data.get("model", "dall-e-2"))
+            provider_config: Final = get_azure_image_generation_config(data.get("model", ""))
             if isinstance(provider_config, AzureFoundryMAIImageGenerationConfig):
                 return provider_config.transform_image_generation_response(
-                    model=data.get("model", "dall-e-2"),
+                    model=data.get("model", ""),
                     raw_response=httpx_response,
                     model_response=model_response or ImageResponse(),
                     logging_obj=logging_obj,
diff --git a/litellm/llms/azure/image_generation/__init__.py b/litellm/llms/azure/image_generation/__init__.py
index a2a905f2287..7e9b5f5d99c 100644
--- a/litellm/llms/azure/image_generation/__init__.py
+++ b/litellm/llms/azure/image_generation/__init__.py
@@ -4,14 +4,10 @@ from litellm.llms.base_llm.image_generation.transformation import (
     BaseImageGenerationConfig,
 )
 
-from .dall_e_2_transformation import AzureDallE2ImageGenerationConfig
-from .dall_e_3_transformation import AzureDallE3ImageGenerationConfig
 from .gpt_transformation import AzureGPTImageGenerationConfig
 from .http_utils import azure_deployment_image_generation_json_body
 
 __all__ = [
-    "AzureDallE2ImageGenerationConfig",
-    "AzureDallE3ImageGenerationConfig",
     "AzureGPTImageGenerationConfig",
     "azure_deployment_image_generation_json_body",
 ]
@@ -21,11 +17,7 @@ def get_azure_image_generation_config(model: str) -> BaseImageGenerationConfig:
     model = model.lower()
     model = model.replace("-", "")
     model = model.replace("_", "")
-    if model == "" or "dalle2" in model:  # empty model is dall-e-2
-        return AzureDallE2ImageGenerationConfig()
-    elif "dalle3" in model:
-        return AzureDallE3ImageGenerationConfig()
-    elif AzureFoundryMAIImageGenerationConfig.is_mai_model(model):
+    if AzureFoundryMAIImageGenerationConfig.is_mai_model(model):
         return AzureFoundryMAIImageGenerationConfig()
     else:
         verbose_logger.debug(
diff --git a/litellm/llms/azure/image_generation/dall_e_2_transformation.py b/litellm/llms/azure/image_generation/dall_e_2_transformation.py
deleted file mode 100644
index 788753e4ea9..00000000000
--- a/litellm/llms/azure/image_generation/dall_e_2_transformation.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from litellm.llms.openai.image_generation import DallE2ImageGenerationConfig
-
-
-class AzureDallE2ImageGenerationConfig(DallE2ImageGenerationConfig):
-    """
-    Azure dall-e-2 image generation config
-    """
diff --git a/litellm/llms/azure/image_generation/dall_e_3_transformation.py b/litellm/llms/azure/image_generation/dall_e_3_transformation.py
deleted file mode 100644
index e6974f9317e..00000000000
--- a/litellm/llms/azure/image_generation/dall_e_3_transformation.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from litellm.llms.openai.image_generation import DallE3ImageGenerationConfig
-
-
-class AzureDallE3ImageGenerationConfig(DallE3ImageGenerationConfig):
-    """
-    Azure dall-e-3 image generation config
-    """
diff --git a/litellm/llms/azure_ai/agents/handler.py b/litellm/llms/azure_ai/agents/handler.py
index 94f1399f01b..423a09c5c92 100644
--- a/litellm/llms/azure_ai/agents/handler.py
+++ b/litellm/llms/azure_ai/agents/handler.py
@@ -35,6 +35,7 @@ from litellm.llms.azure_ai.agents.transformation import (
     AzureAIAgentsConfig,
     AzureAIAgentsError,
 )
+from litellm.llms.custom_httpx.sse_lines import aiter_sse_lines
 from litellm.types.llms.openai import (
     ChatCompletionAnnotation,
     ChatCompletionAnnotationURLCitation,
@@ -632,7 +633,7 @@ class AzureAIAgentsHandler:
 
         current_event = None
 
-        async for line in response.aiter_lines():
+        async for line in aiter_sse_lines(response.aiter_text()):
             line = line.strip()
 
             if line.startswith("event:"):
diff --git a/litellm/llms/azure_ai/image_generation/__init__.py b/litellm/llms/azure_ai/image_generation/__init__.py
index 742922ad295..bd3c11d36f9 100644
--- a/litellm/llms/azure_ai/image_generation/__init__.py
+++ b/litellm/llms/azure_ai/image_generation/__init__.py
@@ -3,15 +3,11 @@ from litellm.llms.base_llm.image_generation.transformation import (
     BaseImageGenerationConfig,
 )
 
-from .dall_e_2_transformation import AzureFoundryDallE2ImageGenerationConfig
-from .dall_e_3_transformation import AzureFoundryDallE3ImageGenerationConfig
 from .flux_transformation import AzureFoundryFluxImageGenerationConfig
 from .gpt_transformation import AzureFoundryGPTImageGenerationConfig
 from .mai_transformation import AzureFoundryMAIImageGenerationConfig
 
 __all__ = [
-    "AzureFoundryDallE2ImageGenerationConfig",
-    "AzureFoundryDallE3ImageGenerationConfig",
     "AzureFoundryFluxImageGenerationConfig",
     "AzureFoundryGPTImageGenerationConfig",
     "AzureFoundryMAIImageGenerationConfig",
@@ -22,11 +18,7 @@ def get_azure_ai_image_generation_config(model: str) -> BaseImageGenerationConfi
     model = model.lower()
     model = model.replace("-", "")
     model = model.replace("_", "")
-    if model == "" or "dalle2" in model:  # empty model is dall-e-2
-        return AzureFoundryDallE2ImageGenerationConfig()
-    elif "dalle3" in model:
-        return AzureFoundryDallE3ImageGenerationConfig()
-    elif AzureFoundryMAIImageGenerationConfig.is_mai_model(model):
+    if AzureFoundryMAIImageGenerationConfig.is_mai_model(model):
         return AzureFoundryMAIImageGenerationConfig()
     elif "flux" in model:
         return AzureFoundryFluxImageGenerationConfig()
diff --git a/litellm/llms/azure_ai/image_generation/dall_e_2_transformation.py b/litellm/llms/azure_ai/image_generation/dall_e_2_transformation.py
deleted file mode 100644
index 2c8a5426628..00000000000
--- a/litellm/llms/azure_ai/image_generation/dall_e_2_transformation.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from litellm.llms.openai.image_generation import DallE2ImageGenerationConfig
-
-
-class AzureFoundryDallE2ImageGenerationConfig(DallE2ImageGenerationConfig):
-    """
-    Azure dall-e-2 image generation config
-    """
diff --git a/litellm/llms/azure_ai/image_generation/dall_e_3_transformation.py b/litellm/llms/azure_ai/image_generation/dall_e_3_transformation.py
deleted file mode 100644
index 3ceb9b405da..00000000000
--- a/litellm/llms/azure_ai/image_generation/dall_e_3_transformation.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from litellm.llms.openai.image_generation import DallE3ImageGenerationConfig
-
-
-class AzureFoundryDallE3ImageGenerationConfig(DallE3ImageGenerationConfig):
-    """
-    Azure dall-e-3 image generation config
-    """
diff --git a/litellm/llms/base_llm/base_model_iterator.py b/litellm/llms/base_llm/base_model_iterator.py
index 032951be74a..3afc685b3dd 100644
--- a/litellm/llms/base_llm/base_model_iterator.py
+++ b/litellm/llms/base_llm/base_model_iterator.py
@@ -96,7 +96,7 @@ class BaseModelResponseIterator:
         released (and a backend like vLLM aborts generation) when the stream
         is abandoned before its natural end.
 
-        ``streaming_response`` is usually a bare ``aiter_lines()`` generator
+        ``streaming_response`` is usually a bare ``aiter_sse_lines()`` generator
         that holds no reference to the response, so the handler that owns the
         response attaches it here after construction."""
         if self.http_response is not None:
diff --git a/litellm/llms/base_llm/guardrail_translation/utils.py b/litellm/llms/base_llm/guardrail_translation/utils.py
index 725146fe894..fb886e42780 100644
--- a/litellm/llms/base_llm/guardrail_translation/utils.py
+++ b/litellm/llms/base_llm/guardrail_translation/utils.py
@@ -6,6 +6,7 @@ from typing import Final, TypeVar, cast  # noqa: TID251  # a rebuilt chat row ha
 
 from pydantic import BaseModel, ConfigDict, TypeAdapter, ValidationError
 
+from litellm.llms.custom_httpx.sse_lines import split_sse_lines
 from litellm.types.llms.anthropic_messages.anthropic_response import AnthropicUsage
 from litellm.types.llms.openai import AllMessageValues, ResponseAPIUsage
 
@@ -24,7 +25,7 @@ def _anthropic_stream_chunk_events(item: object) -> list[dict]:
 
     events: Final[list[dict]] = []
     for block in chunk.split("\n\n"):
-        for line in block.splitlines():
+        for line in split_sse_lines(block):
             stripped = line.strip()
             if not stripped.startswith("data:"):
                 continue
diff --git a/litellm/llms/base_llm/sandbox/transformation.py b/litellm/llms/base_llm/sandbox/transformation.py
index fe0e3abb87e..9b9b4e0a947 100644
--- a/litellm/llms/base_llm/sandbox/transformation.py
+++ b/litellm/llms/base_llm/sandbox/transformation.py
@@ -12,6 +12,7 @@ from typing import Final
 import httpx
 from pydantic import Field, PrivateAttr
 
+from litellm.llms.custom_httpx.sse_lines import aiter_sse_lines
 from litellm.types.llms.base import LiteLLMPydanticObjectBase
 
 SANDBOX_MAX_OUTPUT_BYTES: Final = 10 * 1024 * 1024
@@ -99,7 +100,7 @@ class BaseSandboxConfig:
     async def _read_capped_lines(self, response: httpx.Response) -> list[str]:
         lines: Final[list[str]] = []
         total = 0
-        async for line in response.aiter_lines():
+        async for line in aiter_sse_lines(response.aiter_text()):
             total += len(line.encode("utf-8"))
             if total > SANDBOX_MAX_OUTPUT_BYTES:
                 raise ValueError(
diff --git a/litellm/llms/bedrock/chat/invoke_transformations/amazon_twelvelabs_pegasus_transformation.py b/litellm/llms/bedrock/chat/invoke_transformations/amazon_twelvelabs_pegasus_transformation.py
index f7566ac4923..dc14ef005b5 100644
--- a/litellm/llms/bedrock/chat/invoke_transformations/amazon_twelvelabs_pegasus_transformation.py
+++ b/litellm/llms/bedrock/chat/invoke_transformations/amazon_twelvelabs_pegasus_transformation.py
@@ -10,6 +10,8 @@ import time
 from typing import TYPE_CHECKING, Any, Final
 
 import httpx
+from pydantic import ConfigDict, TypeAdapter, with_config
+from typing_extensions import NotRequired, ReadOnly, TypedDict
 
 import litellm
 from litellm._logging import verbose_logger
@@ -34,6 +36,15 @@ else:
     LiteLLMLoggingObj = Any
 
 
+@with_config(ConfigDict(extra="allow", strict=True))
+class _PegasusResponse(TypedDict):
+    message: ReadOnly[NotRequired[str | None]]
+    finishReason: ReadOnly[NotRequired[str | None]]
+
+
+_PEGASUS_RESPONSE: Final = TypeAdapter(_PegasusResponse)
+
+
 class AmazonTwelveLabsPegasusConfig(AmazonInvokeConfig, BaseConfig):
     """
     Handles transforming OpenAI-style requests into Bedrock InvokeModel requests for
@@ -207,7 +218,7 @@ class AmazonTwelveLabsPegasusConfig(AmazonInvokeConfig, BaseConfig):
         ModelResponse with choices[0].message.content and finish_reason
         """
         try:
-            completion_response: Final = raw_response.json()
+            completion_response: Final = _PEGASUS_RESPONSE.validate_python(raw_response.json())
         except Exception as e:
             raise BedrockError(
                 message=f"Error parsing response: {raw_response.text}, error: {e}",
@@ -224,7 +235,7 @@ class AmazonTwelveLabsPegasusConfig(AmazonInvokeConfig, BaseConfig):
         message_content: Final = completion_response.get("message", "")
 
         # Extract finish reason and map to LiteLLM format
-        finish_reason_raw: Final = completion_response.get("finishReason", "stop")
+        finish_reason_raw: Final = completion_response.get("finishReason") or "stop"
         finish_reason: Final = map_finish_reason(finish_reason_raw)
 
         # Set the response content
diff --git a/litellm/llms/bedrock/chat/invoke_transformations/base_invoke_transformation.py b/litellm/llms/bedrock/chat/invoke_transformations/base_invoke_transformation.py
index 51b5a99272e..852179e8caa 100644
--- a/litellm/llms/bedrock/chat/invoke_transformations/base_invoke_transformation.py
+++ b/litellm/llms/bedrock/chat/invoke_transformations/base_invoke_transformation.py
@@ -1,11 +1,12 @@
 import copy
 import json
 import time
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 from typing import TYPE_CHECKING, Any, Final, cast, get_args
 
 import httpx
-from pydantic import TypeAdapter, ValidationError
+from pydantic import ConfigDict, TypeAdapter, ValidationError, with_config
+from typing_extensions import NotRequired, ReadOnly, TypedDict
 
 import litellm
 from litellm._logging import verbose_logger
@@ -48,6 +49,27 @@ from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM
 
 _GUARDRAIL_CONFIG_VALIDATOR: Final["TypeAdapter[GuardrailConfigBlock]"] = TypeAdapter(GuardrailConfigBlock)
 
+
+@with_config(ConfigDict(extra="allow", strict=True))
+class _CohereGeneration(TypedDict):
+    text: ReadOnly[str | None]
+    finish_reason: ReadOnly[str | None]
+
+
+@with_config(ConfigDict(extra="allow", strict=True))
+class _CohereInvokeResponse(TypedDict):
+    text: NotRequired[ReadOnly[str | None]]
+    generations: NotRequired[ReadOnly[Sequence[_CohereGeneration]]]
+
+
+@with_config(ConfigDict(extra="allow", strict=True))
+class _LlamaInvokeResponse(TypedDict):
+    generation: ReadOnly[str | None]
+
+
+_COHERE_INVOKE_RESPONSE: Final = TypeAdapter(_CohereInvokeResponse)
+_LLAMA_INVOKE_RESPONSE: Final = TypeAdapter(_LlamaInvokeResponse)
+
 _GUARDRAIL_CONFIG_EXPECTED_FORMAT: Final = (
     "{'guardrailIdentifier': str, 'guardrailVersion': str, 'trace': 'enabled'|'disabled'|'enabled_full'}"
 )
@@ -310,12 +332,13 @@ class AmazonInvokeConfig(BaseConfig, BaseAWSLLM):
         outputText: str | None = None
         try:
             if provider == "cohere":
-                if "text" in completion_response:
-                    outputText = completion_response["text"]
-                elif "generations" in completion_response:
-                    outputText = completion_response["generations"][0]["text"]
+                cohere_response: Final = _COHERE_INVOKE_RESPONSE.validate_python(completion_response)
+                if "text" in cohere_response:
+                    outputText = cohere_response["text"]
+                elif "generations" in cohere_response:
+                    outputText = cohere_response["generations"][0]["text"]
                     model_response.choices[0].finish_reason = map_finish_reason(
-                        completion_response["generations"][0]["finish_reason"]
+                        cohere_response["generations"][0]["finish_reason"] or "stop"
                     )
             elif provider == "anthropic":
                 return litellm.AmazonAnthropicClaudeConfig().transform_response(
@@ -361,7 +384,7 @@ class AmazonInvokeConfig(BaseConfig, BaseAWSLLM):
             elif provider == "ai21":
                 outputText = completion_response.get("completions")[0].get("data").get("text")
             elif provider == "meta" or provider == "llama" or provider == "deepseek_r1":
-                outputText = completion_response["generation"]
+                outputText = _LLAMA_INVOKE_RESPONSE.validate_python(completion_response)["generation"]
             elif provider == "mistral":
                 outputText = litellm.AmazonMistralConfig.get_outputText(completion_response, model_response)
             else:  # amazon titan
diff --git a/litellm/llms/bedrock/files/transformation.py b/litellm/llms/bedrock/files/transformation.py
index 8c4702bcf99..0624c2c65db 100644
--- a/litellm/llms/bedrock/files/transformation.py
+++ b/litellm/llms/bedrock/files/transformation.py
@@ -49,6 +49,7 @@ from litellm.llms.base_llm.files.transformation import (
     BaseFilesConfig,
     LiteLLMLoggingObj,
 )
+from litellm.llms.custom_httpx.sse_lines import split_sse_lines
 from litellm.types.llms.base import LiteLLMBaseModel
 from litellm.types.llms.bedrock import AwsAuthParams, BedrockBatchRecordKind
 from litellm.types.llms.openai import (
@@ -400,7 +401,7 @@ def _batch_input_line(line_number: int, line: str) -> _BatchInputLine:
 
 
 def _non_blank_lines(file_content: str) -> Iterator[tuple[int, str]]:
-    numbered_lines: Final = enumerate(file_content.splitlines(), start=1)
+    numbered_lines: Final = enumerate(split_sse_lines(file_content), start=1)
     return ((line_number, line) for line_number, line in numbered_lines if line.strip())
 
 
diff --git a/litellm/llms/bedrock/passthrough/guardrail_translation/handler.py b/litellm/llms/bedrock/passthrough/guardrail_translation/handler.py
index 1b01b0ec6d0..3a65a8928bf 100644
--- a/litellm/llms/bedrock/passthrough/guardrail_translation/handler.py
+++ b/litellm/llms/bedrock/passthrough/guardrail_translation/handler.py
@@ -45,6 +45,7 @@ from litellm.llms.bedrock.passthrough.guardrail_translation.structured_edits imp
     structured_edits,
     tool_edits,
 )
+from litellm.llms.custom_httpx.sse_lines import split_sse_lines
 from litellm.proxy.guardrails.auto_router_compression import is_compression_guardrail
 from litellm.types.utils import GenericGuardrailAPIInputs
 
@@ -947,7 +948,7 @@ def _invoke_frames(items: Sequence[object]) -> tuple[InvokeStreamFrame, ...]:
 def _sse_events(sse: bytes) -> tuple[Mapping[str, object], ...]:
     return tuple(
         _JSON_OBJECT.validate_python(json.loads(line[len("data:") :]))
-        for line in sse.decode().splitlines()
+        for line in split_sse_lines(sse.decode())
         if line.startswith("data:")
     )
 
diff --git a/litellm/llms/bedrock/realtime/transformation.py b/litellm/llms/bedrock/realtime/transformation.py
index 9cb38822881..952d8858f78 100644
--- a/litellm/llms/bedrock/realtime/transformation.py
+++ b/litellm/llms/bedrock/realtime/transformation.py
@@ -53,6 +53,7 @@ from litellm.types.realtime import (
     RealtimeResponseTypedDict,
 )
 
+_JSON_OBJECT_MESSAGE: Final = TypeAdapter(dict[str, JsonValue], config=ConfigDict(strict=True))
 _JSON_VALUE: Final = TypeAdapter(object)
 _JSON_OBJECT: Final = TypeAdapter(Mapping[str, object])
 
@@ -856,7 +857,7 @@ class BedrockRealtimeConfig(BaseRealtimeConfig):
             List of Bedrock format messages (JSON strings)
         """
         try:
-            json_message: Final[dict[str, JsonValue]] = json.loads(message)
+            json_message: Final = _JSON_OBJECT_MESSAGE.validate_python(json.loads(message))
         except json.JSONDecodeError:
             verbose_logger.warning("Invalid JSON message: %s", message[:200])
             return []
diff --git a/litellm/llms/bedrock/search/transformation.py b/litellm/llms/bedrock/search/transformation.py
index 565fc12aa1e..6f72cadad67 100644
--- a/litellm/llms/bedrock/search/transformation.py
+++ b/litellm/llms/bedrock/search/transformation.py
@@ -47,6 +47,7 @@ from litellm.llms.base_llm.search.transformation import (
 )
 from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM
 from litellm.llms.bedrock.common_utils import BedrockError
+from litellm.llms.custom_httpx.sse_lines import split_sse_lines
 from litellm.secret_managers.main import get_secret_str
 
 # AgentCore web-search rejects queries longer than 200 characters
@@ -146,7 +147,9 @@ def _iter_sse_events(text: str) -> Iterator[Mapping[str, object]]:
     progress notifications before the JSON-RPC response.
     """
     for chunk in _SSE_EVENT_SEPARATOR.split(text):
-        payload = "\n".join(line[len("data:") :].lstrip() for line in chunk.splitlines() if line.startswith("data:"))
+        payload = "\n".join(
+            line[len("data:") :].lstrip() for line in split_sse_lines(chunk) if line.startswith("data:")
+        )
         if not payload:
             continue
         try:
diff --git a/litellm/llms/chatgpt/responses/transformation.py b/litellm/llms/chatgpt/responses/transformation.py
index 040b7b8c1d8..72b5cde21d1 100644
--- a/litellm/llms/chatgpt/responses/transformation.py
+++ b/litellm/llms/chatgpt/responses/transformation.py
@@ -11,6 +11,7 @@ from litellm.litellm_core_utils.llm_response_utils.convert_dict_to_response impo
     safe_convert_created_field,
 )
 from litellm.litellm_core_utils.url_utils import join_api_base
+from litellm.llms.custom_httpx.sse_lines import split_sse_lines
 from litellm.llms.openai.common_utils import OpenAIError
 from litellm.llms.openai.responses.transformation import OpenAIResponsesAPIConfig
 from litellm.responses.sse_output_recovery import (
@@ -199,7 +200,7 @@ class ChatGPTResponsesAPIConfig(OpenAIResponsesAPIConfig):
         error_message = None
         streamed_output_items: Final[dict[int, dict[str, object]]] = {}
         text_only_output_items: Final[dict[int, dict[str, object]]] = {}
-        for chunk in body_text.splitlines():
+        for chunk in split_sse_lines(body_text):
             parsed_chunk = parse_sse_json_chunk(chunk)
             if parsed_chunk is None:
                 continue
diff --git a/litellm/llms/codestral/completion/handler.py b/litellm/llms/codestral/completion/handler.py
index 6bebfe2d444..6b172e77295 100644
--- a/litellm/llms/codestral/completion/handler.py
+++ b/litellm/llms/codestral/completion/handler.py
@@ -20,6 +20,7 @@ from litellm.llms.custom_httpx.http_handler import (
     AsyncHTTPHandler,
     get_async_httpx_client,
 )
+from litellm.llms.custom_httpx.sse_lines import aiter_sse_lines, iter_sse_lines
 from litellm.types.utils import TextChoices
 from litellm.utils import CustomStreamWrapper, TextCompletionResponse
 
@@ -109,7 +110,7 @@ async def make_call(
     if response.status_code != 200:
         raise TextCompletionCodestralError(status_code=response.status_code, message=response.text)
 
-    completion_stream: Final = response.aiter_lines()
+    completion_stream: Final = aiter_sse_lines(response.aiter_text())
     # LOGGING
     logging_obj.post_call(
         input=messages,
@@ -339,13 +340,13 @@ class CodestralTextCompletion:
             response = litellm.module_level_client.post(
                 completion_url,
                 headers=headers,
-                data=json.dumps(data),
+                data=json.dumps({**data, "stream": True}),
                 stream=stream,
             )
             _response: Final = CustomStreamWrapper(
-                response.iter_lines(),
+                iter_sse_lines(response.iter_text()),
                 model,
-                custom_llm_provider="codestral",
+                custom_llm_provider="text-completion-codestral",
                 logging_obj=logging_obj,
             )
             return _response
diff --git a/litellm/llms/custom_httpx/aiohttp_handler.py b/litellm/llms/custom_httpx/aiohttp_handler.py
index 447d7b685f7..e6544968d24 100644
--- a/litellm/llms/custom_httpx/aiohttp_handler.py
+++ b/litellm/llms/custom_httpx/aiohttp_handler.py
@@ -21,6 +21,7 @@ from litellm.llms.custom_httpx.http_handler import (
     get_httpx_client,
     get_ssl_configuration,
 )
+from litellm.llms.custom_httpx.sse_lines import iter_sse_lines
 from litellm.types.llms.openai import FileTypes
 from litellm.types.utils import HttpHandlerRequestFields, ImageResponse, LlmProviders
 from litellm.utils import CustomStreamWrapper, ModelResponse, ProviderConfigManager
@@ -466,7 +467,7 @@ class BaseLLMAIOHTTPHandler:
             )
         else:
             completion_stream = provider_config.get_model_response_iterator(
-                streaming_response=response.iter_lines(), sync_stream=True
+                streaming_response=iter_sse_lines(response.iter_text()), sync_stream=True
             )
 
         # LOGGING
@@ -560,11 +561,8 @@ class BaseLLMAIOHTTPHandler:
         organization: str | None = None,
         headers: dict | None = None,
     ) -> ImageResponse:
-        if model is None:
-            raise ValueError("model is required for non-openai image variations")
-
         provider_config: Final = ProviderConfigManager.get_provider_image_variation_config(
-            model=model,  # openai defaults to dall-e-2
+            model=model or "",
             provider=LlmProviders(custom_llm_provider),
         )
 
diff --git a/litellm/llms/custom_httpx/llm_http_handler.py b/litellm/llms/custom_httpx/llm_http_handler.py
index afa12b58b29..e7da6586b97 100644
--- a/litellm/llms/custom_httpx/llm_http_handler.py
+++ b/litellm/llms/custom_httpx/llm_http_handler.py
@@ -118,6 +118,7 @@ from litellm.llms.custom_httpx.http_handler import (
     get_httpx_client,
     header_value,
 )
+from litellm.llms.custom_httpx.sse_lines import aiter_sse_lines, iter_sse_lines
 from litellm.responses.streaming_iterator import (
     BaseResponsesAPIStreamingIterator,
     MockResponsesAPIStreamingIterator,
@@ -1086,7 +1087,7 @@ class BaseLLMHTTPHandler:
             completion_stream: object = MockResponseIterator(model_response=model_response, json_mode=json_mode)
         else:
             completion_stream = provider_config.get_model_response_iterator_for_request(
-                streaming_response=response.iter_lines(),
+                streaming_response=iter_sse_lines(response.iter_text()),
                 sync_stream=True,
                 json_mode=json_mode,
                 optional_params=_OPTIONAL_PARAMS.validate_python(optional_params),
@@ -1229,7 +1230,7 @@ class BaseLLMHTTPHandler:
             completion_stream: object = MockResponseIterator(model_response=model_response, json_mode=json_mode)
         else:
             completion_stream = provider_config.get_model_response_iterator_for_request(
-                streaming_response=response.aiter_lines(),
+                streaming_response=aiter_sse_lines(response.aiter_text()),
                 sync_stream=False,
                 json_mode=json_mode,
                 optional_params=_OPTIONAL_PARAMS.validate_python(optional_params),
diff --git a/litellm/llms/custom_httpx/sse_lines.py b/litellm/llms/custom_httpx/sse_lines.py
new file mode 100644
index 00000000000..71ea7d621eb
--- /dev/null
+++ b/litellm/llms/custom_httpx/sse_lines.py
@@ -0,0 +1,74 @@
+"""
+Split a decoded Server-Sent Events body into lines the way the SSE spec does.
+
+httpx's `iter_lines()` / `aiter_lines()` follow `str.splitlines()`, which also breaks on U+0085, U+2028,
+U+2029, \\x0b, \\x0c and \\x1c-\\x1e. JSON leaves U+0085, U+2028 and U+2029 unescaped inside strings, so a
+`data:` line carrying one of them gets cut in half. SSE lines end only at CRLF, LF or CR
+(https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream)
+"""
+
+import io
+import re
+from collections.abc import AsyncIterable, AsyncIterator, Iterable, Iterator, Sequence
+from typing import Final
+
+_SSE_LINE_BREAK: Final = re.compile(r"\r\n|\r|\n")
+_SSE_LINE_WITH_BREAK: Final = re.compile(r"[^\r\n]*(?:\r\n|\r|\n)|[^\r\n]+")
+
+
+def _split_lines(text: str) -> Sequence[str]:
+    if "\r" not in text:
+        return text.split("\n")
+    crlf_folded: Final = text.replace("\r\n", "\n")
+    if "\r" not in crlf_folded:
+        return crlf_folded.split("\n")
+    return _SSE_LINE_BREAK.split(text)
+
+
+class _SSELineSplitter:
+    def __init__(self) -> None:
+        self._partial_line: io.StringIO = io.StringIO()
+        self._after_cr: bool = False
+
+    def feed(self, text: str) -> tuple[str, ...]:
+        if not text:
+            return ()
+        fresh: Final = text[1:] if self._after_cr and text.startswith("\n") else text
+        self._after_cr = fresh.endswith("\r")
+        *ended, tail = _split_lines(fresh)
+        if not ended:
+            _ = self._partial_line.write(tail)
+            return ()
+        first: Final = self._partial_line.getvalue() + ended[0]
+        self._partial_line = io.StringIO()
+        _ = self._partial_line.write(tail)
+        return (first, *ended[1:])
+
+    def flush(self) -> tuple[str, ...]:
+        rest: Final = self._partial_line.getvalue()
+        self._partial_line = io.StringIO()
+        return (rest,) if rest else ()
+
+
+def iter_sse_lines(text_chunks: Iterable[str]) -> Iterator[str]:
+    splitter: Final = _SSELineSplitter()
+    for text in text_chunks:
+        yield from splitter.feed(text)
+    yield from splitter.flush()
+
+
+def split_sse_lines(text: str) -> tuple[str, ...]:
+    return tuple(iter_sse_lines((text,)))
+
+
+def split_sse_lines_keepends(text: str) -> tuple[str, ...]:
+    return tuple(_SSE_LINE_WITH_BREAK.findall(text))
+
+
+async def aiter_sse_lines(text_chunks: AsyncIterable[str]) -> AsyncIterator[str]:
+    splitter: Final = _SSELineSplitter()
+    async for text in text_chunks:
+        for line in splitter.feed(text):
+            yield line
+    for line in splitter.flush():
+        yield line
diff --git a/litellm/llms/dashscope/embed/transformation.py b/litellm/llms/dashscope/embed/transformation.py
index d0c2b4dff0c..35132346261 100644
--- a/litellm/llms/dashscope/embed/transformation.py
+++ b/litellm/llms/dashscope/embed/transformation.py
@@ -14,6 +14,8 @@ Docs - https://help.aliyun.com/zh/model-studio/text-embedding-synchronous-api
 from typing import Final
 
 import httpx
+from pydantic import ConfigDict, TypeAdapter, with_config
+from typing_extensions import NotRequired, ReadOnly, TypedDict
 
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
 from litellm.litellm_core_utils.url_utils import ensure_api_route
@@ -28,6 +30,23 @@ from ..common_utils import DashScopeError
 DEFAULT_API_BASE: Final = "https://dashscope.aliyuncs.com/compatible-mode/v1"
 
 
+@with_config(ConfigDict(extra="allow", strict=True))
+class _DashScopeUsage(TypedDict, total=False):
+    prompt_tokens: NotRequired[ReadOnly[int]]
+    total_tokens: NotRequired[ReadOnly[int]]
+
+
+@with_config(ConfigDict(extra="allow", strict=True))
+class _DashScopeEmbeddingResponse(TypedDict, total=False):
+    data: NotRequired[ReadOnly[list[object]]]
+    model: NotRequired[ReadOnly[str | None]]
+    usage: NotRequired[ReadOnly[_DashScopeUsage | None]]
+    id: NotRequired[ReadOnly[object]]
+
+
+_DASHSCOPE_EMBEDDING_RESPONSE: Final = TypeAdapter(_DashScopeEmbeddingResponse)
+
+
 class DashScopeEmbeddingConfig(BaseEmbeddingConfig):
     """
     Reference: https://help.aliyun.com/zh/model-studio/text-embedding-synchronous-api
@@ -152,11 +171,12 @@ class DashScopeEmbeddingConfig(BaseEmbeddingConfig):
                 message=message,
             )
 
+        parsed_response: Final = _DASHSCOPE_EMBEDDING_RESPONSE.validate_python(response_json)
         model_response.object = "list"
-        model_response.data = response_json.get("data", [])
-        model_response.model = response_json.get("model", model)
+        model_response.data = parsed_response.get("data", [])
+        model_response.model = parsed_response.get("model", model)
 
-        usage: Final = response_json.get("usage") or {}
+        usage: Final = parsed_response.get("usage") or {}
         prompt_tokens: Final = usage.get("prompt_tokens", 0)
         total_tokens: Final = usage.get("total_tokens", prompt_tokens)
         setattr(
@@ -169,8 +189,8 @@ class DashScopeEmbeddingConfig(BaseEmbeddingConfig):
             ),
         )
 
-        if "id" in response_json:
-            setattr(model_response, "id", response_json["id"])
+        if "id" in parsed_response:
+            setattr(model_response, "id", parsed_response["id"])
 
         return model_response
 
diff --git a/litellm/llms/databricks/streaming_utils.py b/litellm/llms/databricks/streaming_utils.py
index eca87f9dd5f..cc85012b803 100644
--- a/litellm/llms/databricks/streaming_utils.py
+++ b/litellm/llms/databricks/streaming_utils.py
@@ -1,6 +1,8 @@
 import json
 from typing import Final
 
+from pydantic import ConfigDict, TypeAdapter
+
 import litellm
 from litellm import verbose_logger
 from litellm.types.llms.openai import (
@@ -23,6 +25,9 @@ def _usage_block(usage: Usage) -> ChatCompletionUsageBlock:
     )
 
 
+_JSON_CHUNK: Final = TypeAdapter(dict[str, object], config=ConfigDict(strict=True))
+
+
 class ModelResponseIterator:
     def __init__(self, streaming_response, sync_stream: bool):
         self.streaming_response = streaming_response
@@ -99,7 +104,7 @@ class ModelResponseIterator:
             self.response_iterator = self.streaming_response
         chunk: Final = self._next_sse_data()
         try:
-            json_chunk: Final = json.loads(chunk)
+            json_chunk: Final = _JSON_CHUNK.validate_python(json.loads(chunk))
             return self.chunk_parser(chunk=json_chunk)
         except ValueError as e:
             verbose_logger.debug(
@@ -126,7 +131,7 @@ class ModelResponseIterator:
         if chunk == "[DONE]":
             raise StopAsyncIteration
         try:
-            json_chunk: Final = json.loads(chunk)
+            json_chunk: Final = _JSON_CHUNK.validate_python(json.loads(chunk))
             return self.chunk_parser(chunk=json_chunk)
         except ValueError as e:
             verbose_logger.debug(
diff --git a/litellm/llms/fal_ai/image_edit/flux_lora_depth_transformation.py b/litellm/llms/fal_ai/image_edit/flux_lora_depth_transformation.py
index 344d9d3c75b..6d0891295bd 100644
--- a/litellm/llms/fal_ai/image_edit/flux_lora_depth_transformation.py
+++ b/litellm/llms/fal_ai/image_edit/flux_lora_depth_transformation.py
@@ -4,13 +4,14 @@ from typing import Final
 
 from httpx._types import RequestFiles
 
+from litellm.images.utils import image_to_data_url
 from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.secret_managers.main import get_secret_str
 from litellm.types.images.main import ImageEditOptionalRequestParams
 from litellm.types.router import GenericLiteLLMParams
 from litellm.types.utils import FileTypes
 
-from .transformation import DEFAULT_BASE_URL, FalAIImageEditConfig, to_data_url
+from .transformation import DEFAULT_BASE_URL, FalAIImageEditConfig
 
 FLUX_LORA_DEPTH_ENDPOINT: Final[str] = "fal-ai/flux-lora-depth"
 SUPPORTED_OPENAI_PARAMS: Final[tuple[str, ...]] = ("n", "size")
@@ -68,7 +69,7 @@ class FalAIFluxLoraDepthEditConfig(FalAIImageEditConfig):
         )
         request_body: Final[dict[str, object]] = {  # mutable-ok: base class contract returns a dict
             "prompt": prompt,
-            "image_url": to_data_url(next(iter(images))),
+            "image_url": image_to_data_url(next(iter(images))),
             **provider_params,
         }
         return request_body, ()
diff --git a/litellm/llms/fal_ai/image_edit/transformation.py b/litellm/llms/fal_ai/image_edit/transformation.py
index ea4e8cac5bf..5cbf635fd47 100644
--- a/litellm/llms/fal_ai/image_edit/transformation.py
+++ b/litellm/llms/fal_ai/image_edit/transformation.py
@@ -1,15 +1,12 @@
-import base64
-import os
 from collections.abc import Mapping
-from pathlib import Path
 from types import MappingProxyType
-from typing import TYPE_CHECKING, Final, Protocol, runtime_checkable
+from typing import TYPE_CHECKING, Final
 
 import httpx
 from httpx._types import RequestFiles
 from pydantic import ConfigDict, TypeAdapter
 
-from litellm.images.utils import ImageEditRequestUtils
+from litellm.images.utils import image_to_data_url
 from litellm.llms.base_llm.image_edit.transformation import BaseImageEditConfig
 from litellm.llms.fal_ai.image_generation.gpt_image_2_transformation import (
     map_gpt_image_quality,
@@ -39,39 +36,6 @@ PARAM_TRANSLATION: Final[Mapping[str, str]] = MappingProxyType(
 )
 
 
-@runtime_checkable
-class _SeekableBinaryReader(Protocol):
-    def tell(self) -> int: ...
-
-    def seek(self, offset: int) -> int: ...
-
-    def read(self) -> bytes: ...
-
-
-def _read_image_bytes(image: object) -> bytes:
-    if isinstance(image, bytes):
-        return image
-    if isinstance(image, tuple):
-        return _read_image_bytes(image[1])
-    if isinstance(image, os.PathLike):
-        return Path(image).read_bytes()
-    if isinstance(image, _SeekableBinaryReader):
-        position: Final = image.tell()
-        image.seek(0)
-        data: Final = image.read()
-        image.seek(position)
-        return data
-    raise ValueError(f"Unsupported image type for Fal AI image edit: {type(image).__name__}")
-
-
-def to_data_url(image: object) -> str:
-    if isinstance(image, str):
-        return image
-    image_bytes: Final = _read_image_bytes(image)
-    mime_type: Final = ImageEditRequestUtils.get_image_content_type(image_bytes)
-    return f"data:{mime_type};base64,{base64.b64encode(image_bytes).decode('utf-8')}"
-
-
 def _first(value: object) -> object:
     return value[0] if isinstance(value, list) and value else value
 
@@ -146,14 +110,14 @@ class FalAIImageEditConfig(BaseImageEditConfig):
             raise ValueError("Fal AI image edit requires at least one input image")
         mask: Final = _first(image_edit_optional_request_params.get("mask"))
         mask_field: Final[Mapping[str, str]] = (
-            MappingProxyType({"mask_url": to_data_url(mask)}) if mask is not None else MappingProxyType({})
+            MappingProxyType({"mask_url": image_to_data_url(mask)}) if mask is not None else MappingProxyType({})
         )
         provider_params: Final[Mapping[str, object]] = MappingProxyType(
             {key: value for key, value in image_edit_optional_request_params.items() if key != "mask"}
         )
         request_body: Final[dict[str, object]] = {  # mutable-ok: base class contract returns a dict
             "prompt": prompt,
-            "image_urls": tuple(to_data_url(img) for img in images),
+            "image_urls": tuple(image_to_data_url(img) for img in images),
             **mask_field,
             **provider_params,
         }
diff --git a/litellm/llms/gemini/google_genai/guardrail_translation/handler.py b/litellm/llms/gemini/google_genai/guardrail_translation/handler.py
index 34007bc8fd4..b6b2aa6c28f 100644
--- a/litellm/llms/gemini/google_genai/guardrail_translation/handler.py
+++ b/litellm/llms/gemini/google_genai/guardrail_translation/handler.py
@@ -23,6 +23,7 @@ from litellm.llms.base_llm.guardrail_translation.base_translation import (
     BaseTranslation,
     StreamTransformSink,
 )
+from litellm.llms.custom_httpx.sse_lines import split_sse_lines
 from litellm.types.utils import GenericGuardrailAPIInputs
 
 if TYPE_CHECKING:
@@ -121,7 +122,7 @@ def _parse_json_dict_or_none(payload: str) -> Mapping[str, object] | None:
 def _sse_payload_texts(sse_text: str) -> tuple[str, ...]:
     return tuple(
         text
-        for line in sse_text.splitlines()
+        for line in split_sse_lines(sse_text)
         if line.startswith("data:")
         for payload in (line[len("data:") :].strip(),)
         if payload and payload != "[DONE]"
diff --git a/litellm/llms/gigachat/authenticator.py b/litellm/llms/gigachat/authenticator.py
index d43e203d7a1..f37c6e88896 100644
--- a/litellm/llms/gigachat/authenticator.py
+++ b/litellm/llms/gigachat/authenticator.py
@@ -12,6 +12,8 @@ from types import MappingProxyType
 from typing import Final
 
 import httpx
+from pydantic import ConfigDict, TypeAdapter, with_config
+from typing_extensions import NotRequired, ReadOnly, TypedDict
 
 from litellm._logging import verbose_logger
 from litellm.caching.caching import InMemoryCache
@@ -37,6 +39,17 @@ _token_cache: Final = InMemoryCache()
 _NO_LITELLM_PARAMS: Final[Mapping[str, object]] = MappingProxyType({})
 
 
+@with_config(ConfigDict(extra="allow", strict=True))
+class _GigaChatTokenResponse(TypedDict):
+    tok: NotRequired[ReadOnly[str | None]]
+    access_token: NotRequired[ReadOnly[str | None]]
+    exp: NotRequired[ReadOnly[int | float | str | None]]
+    expires_at: NotRequired[ReadOnly[int | float | str | None]]
+
+
+_TOKEN_RESPONSE: Final = TypeAdapter(_GigaChatTokenResponse)
+
+
 class GigaChatAuthError(BaseLLMException):
     """GigaChat authentication error."""
 
@@ -230,7 +243,7 @@ async def _request_token_async(
 
 def _parse_token_response(response: httpx.Response) -> tuple[str, int]:
     """Parse OAuth token response."""
-    data: Final = response.json()
+    data: Final = _TOKEN_RESPONSE.validate_python(response.json())
 
     # GigaChat returns either 'tok'/'exp' or 'access_token'/'expires_at'
     access_token: Final = data.get("tok") or data.get("access_token")
diff --git a/litellm/llms/huggingface/embedding/transformation.py b/litellm/llms/huggingface/embedding/transformation.py
index 1b7d6483739..6e6a117227e 100644
--- a/litellm/llms/huggingface/embedding/transformation.py
+++ b/litellm/llms/huggingface/embedding/transformation.py
@@ -17,6 +17,7 @@ from litellm.litellm_core_utils.prompt_templates.factory import (
 )
 from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper
 from litellm.llms.base_llm.chat.transformation import BaseConfig, BaseLLMException
+from litellm.llms.custom_httpx.sse_lines import iter_sse_lines
 from litellm.secret_managers.main import get_secret_str
 from litellm.types.llms.openai import AllMessageValues
 from litellm.types.utils import Choices, Message, ModelResponse, Usage
@@ -357,7 +358,7 @@ class HuggingFaceEmbeddingConfig(BaseConfig):
         api_key: str | None = None,
     ) -> list[dict[str, str]]:
         streamed_response: Final = CustomStreamWrapper(
-            completion_stream=response.iter_lines(),
+            completion_stream=iter_sse_lines(response.iter_text()),
             model=model,
             custom_llm_provider="huggingface",
             logging_obj=logging_obj,
diff --git a/litellm/llms/langgraph/chat/sse_iterator.py b/litellm/llms/langgraph/chat/sse_iterator.py
index 575820bceee..6fe355ad98c 100644
--- a/litellm/llms/langgraph/chat/sse_iterator.py
+++ b/litellm/llms/langgraph/chat/sse_iterator.py
@@ -12,6 +12,7 @@ import httpx
 from pydantic import TypeAdapter
 
 from litellm._logging import verbose_logger
+from litellm.llms.custom_httpx.sse_lines import aiter_sse_lines, iter_sse_lines
 from litellm.types.utils import Delta, ModelResponseStream, StreamingChoices
 
 _DECODED_JSON: Final = TypeAdapter(object)
@@ -36,12 +37,12 @@ class LangGraphSSEStreamIterator:
 
     def __iter__(self):
         """Initialize sync iteration."""
-        self.line_iterator = self.response.iter_lines()
+        self.line_iterator = iter_sse_lines(self.response.iter_text())
         return self
 
     def __aiter__(self):
         """Initialize async iteration."""
-        self.async_line_iterator = self.response.aiter_lines()
+        self.async_line_iterator = aiter_sse_lines(self.response.aiter_text())
         return self
 
     def _parse_sse_line(self, line: str) -> ModelResponseStream | None:
diff --git a/litellm/llms/oobabooga/chat/oobabooga.py b/litellm/llms/oobabooga/chat/oobabooga.py
index 8879c20c5eb..b4dc57ff5ed 100644
--- a/litellm/llms/oobabooga/chat/oobabooga.py
+++ b/litellm/llms/oobabooga/chat/oobabooga.py
@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Final
 import litellm
 from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.custom_httpx.http_handler import get_httpx_client
+from litellm.llms.custom_httpx.sse_lines import iter_sse_lines
 from litellm.utils import EmbeddingResponse, ModelResponse, Usage
 
 from ..common_utils import OobaboogaError
@@ -74,7 +75,7 @@ def completion(
         stream=optional_params["stream"] if "stream" in optional_params else False,
     )
     if "stream" in optional_params and optional_params["stream"] is True:
-        return response.iter_lines()
+        return iter_sse_lines(response.iter_text())
     else:
         return oobabooga_config.transform_response(
             model=model,
diff --git a/litellm/llms/openai/image_edit/__init__.py b/litellm/llms/openai/image_edit/__init__.py
index 63a41b65e8a..261010071c9 100644
--- a/litellm/llms/openai/image_edit/__init__.py
+++ b/litellm/llms/openai/image_edit/__init__.py
@@ -1,31 +1,5 @@
-from typing import Final
-
-from litellm.llms.base_llm.image_edit.transformation import BaseImageEditConfig
-
-from .dalle2_transformation import DallE2ImageEditConfig
 from .transformation import OpenAIImageEditConfig
 
 __all__ = [
-    "DallE2ImageEditConfig",
     "OpenAIImageEditConfig",
-    "get_openai_image_edit_config",
 ]
-
-
-def get_openai_image_edit_config(model: str) -> BaseImageEditConfig:
-    """
-    Get the appropriate OpenAI image edit config based on the model.
-
-    Args:
-        model: The model name (e.g., "dall-e-2", "gpt-image-1")
-
-    Returns:
-        The appropriate config instance for the model
-    """
-    model_normalized: Final = model.lower().replace("-", "").replace("_", "")
-
-    if model_normalized == "dalle2":
-        return DallE2ImageEditConfig()
-    else:
-        # Default to standard OpenAI config for gpt-image-1 and other models
-        return OpenAIImageEditConfig()
diff --git a/litellm/llms/openai/image_edit/dalle2_transformation.py b/litellm/llms/openai/image_edit/dalle2_transformation.py
deleted file mode 100644
index f349959b14f..00000000000
--- a/litellm/llms/openai/image_edit/dalle2_transformation.py
+++ /dev/null
@@ -1,98 +0,0 @@
-from io import BufferedReader
-from typing import TYPE_CHECKING, Any, Final, cast
-
-from httpx._types import RequestFiles
-
-import litellm
-from litellm.images.utils import ImageEditRequestUtils
-from litellm.types.images.main import ImageEditRequestParams
-from litellm.types.llms.openai import FileTypes
-from litellm.types.router import GenericLiteLLMParams
-
-from .transformation import OpenAIImageEditConfig
-
-if TYPE_CHECKING:
-    from litellm.litellm_core_utils.litellm_logging import Logging as _LiteLLMLoggingObj
-
-    LiteLLMLoggingObj = _LiteLLMLoggingObj
-else:
-    LiteLLMLoggingObj = Any
-
-
-class DallE2ImageEditConfig(OpenAIImageEditConfig):
-    """
-    DALL-E-2 specific configuration for image edit API.
-
-    DALL-E-2 only supports editing a single image (not an array).
-    Uses "image" field name instead of "image[]".
-    """
-
-    def transform_image_edit_request(
-        self,
-        model: str,
-        prompt: str | None,
-        image: FileTypes | None,
-        image_edit_optional_request_params: dict,
-        litellm_params: GenericLiteLLMParams,
-        headers: dict,
-    ) -> tuple[dict, RequestFiles]:
-        """
-        Transform image edit request for DALL-E-2.
-
-        DALL-E-2 only accepts a single image with field name "image" (not "image[]").
-        """
-        request_params: Final = {
-            "model": model,
-            **image_edit_optional_request_params,
-        }
-        if image is not None:
-            request_params["image"] = image
-        if prompt is not None:
-            request_params["prompt"] = prompt
-
-        request: Final = ImageEditRequestParams(**request_params)
-        request_dict: Final = cast(dict, request)
-
-        #########################################################
-        # Separate images and masks as `files` and send other parameters as `data`
-        #########################################################
-        _image_list: Final = request_dict.get("image")
-        _mask = request_dict.get("mask")
-        data_without_files: Final = {k: v for k, v in request_dict.items() if k not in ["image", "mask"]}
-        files_list: Final[list[tuple[str, Any]]] = []
-
-        # Handle image parameter - DALL-E-2 only supports single image
-        if _image_list is not None:
-            image_list: Final = [_image_list] if not isinstance(_image_list, list) else _image_list
-
-            # Validate only one image is provided
-            if len(image_list) > 1:
-                raise litellm.BadRequestError(
-                    message="DALL-E-2 only supports editing a single image. Please provide one image.",
-                    model=model,
-                    llm_provider="openai",
-                )
-
-            # Use "image" field name (singular) for DALL-E-2
-            for _image in image_list:
-                if _image is not None:
-                    self._add_image_to_files(
-                        files_list=files_list,
-                        image=_image,
-                        field_name="image",
-                    )
-
-        # Handle mask parameter if provided
-        if _mask is not None:
-            # Handle case where mask can be a list (extract first mask)
-            if isinstance(_mask, list):
-                _mask = _mask[0] if _mask else None
-
-            if _mask is not None:
-                mask_content_type: Final[str] = ImageEditRequestUtils.get_image_content_type(_mask)
-                if isinstance(_mask, BufferedReader):
-                    files_list.append(("mask", (_mask.name, _mask, mask_content_type)))
-                else:
-                    files_list.append(("mask", ("mask.png", _mask, mask_content_type)))
-
-        return data_without_files, files_list
diff --git a/litellm/llms/openai/image_edit/transformation.py b/litellm/llms/openai/image_edit/transformation.py
index 9def833052b..0bba58096ef 100644
--- a/litellm/llms/openai/image_edit/transformation.py
+++ b/litellm/llms/openai/image_edit/transformation.py
@@ -96,7 +96,7 @@ class OpenAIImageEditConfig(BaseImageEditConfig):
         """
         # Build request params, only including non-None values
         request_params: Final = {
-            "model": model,
+            **({"model": model} if model else {}),
             **image_edit_optional_request_params,
         }
         if image is not None:
diff --git a/litellm/llms/openai/image_generation/__init__.py b/litellm/llms/openai/image_generation/__init__.py
index e20c80f20bb..4cffbe81a0e 100644
--- a/litellm/llms/openai/image_generation/__init__.py
+++ b/litellm/llms/openai/image_generation/__init__.py
@@ -1,9 +1,3 @@
-from litellm.llms.base_llm.image_generation.transformation import (
-    BaseImageGenerationConfig,
-)
-
-from .dall_e_2_transformation import DallE2ImageGenerationConfig
-from .dall_e_3_transformation import DallE3ImageGenerationConfig
 from .gpt_transformation import GPTImageGenerationConfig
 from .guardrail_translation import (
     OpenAIImageGenerationHandler,
@@ -11,18 +5,7 @@ from .guardrail_translation import (
 )
 
 __all__ = [
-    "DallE2ImageGenerationConfig",
-    "DallE3ImageGenerationConfig",
     "GPTImageGenerationConfig",
     "OpenAIImageGenerationHandler",
     "guardrail_translation_mappings",
 ]
-
-
-def get_openai_image_generation_config(model: str) -> BaseImageGenerationConfig:
-    if model.startswith("dall-e-2") or model == "":  # empty model is dall-e-2
-        return DallE2ImageGenerationConfig()
-    elif model.startswith("dall-e-3"):
-        return DallE3ImageGenerationConfig()
-    else:
-        return GPTImageGenerationConfig()
diff --git a/litellm/llms/openai/image_generation/dall_e_2_transformation.py b/litellm/llms/openai/image_generation/dall_e_2_transformation.py
deleted file mode 100644
index ffc6f1d5fe9..00000000000
--- a/litellm/llms/openai/image_generation/dall_e_2_transformation.py
+++ /dev/null
@@ -1,81 +0,0 @@
-from typing import TYPE_CHECKING, Final
-
-import httpx
-
-from litellm.llms.base_llm.image_generation.transformation import (
-    BaseImageGenerationConfig,
-)
-from litellm.types.llms.openai import OpenAIImageGenerationOptionalParams
-from litellm.types.utils import ImageResponse
-from litellm.utils import convert_to_model_response_object
-
-if TYPE_CHECKING:
-    from litellm.litellm_core_utils.logging import Logging as LiteLLMLoggingObj
-
-    from litellm.litellm_core_utils.tokenizer import Encoding as Tokenizer
-
-
-class DallE2ImageGenerationConfig(BaseImageGenerationConfig):
-    """
-    OpenAI dall-e-2 image generation config
-    """
-
-    def get_supported_openai_params(self, model: str) -> list[OpenAIImageGenerationOptionalParams]:
-        return ["n", "response_format", "quality", "size", "user"]
-
-    def map_openai_params(
-        self,
-        non_default_params: dict,
-        optional_params: dict,
-        model: str,
-        drop_params: bool,
-    ) -> dict:
-        supported_params: Final = self.get_supported_openai_params(model)
-        for k in non_default_params:
-            if k not in optional_params:
-                if k in supported_params:
-                    optional_params[k] = non_default_params[k]
-                elif drop_params:
-                    pass
-                else:
-                    raise ValueError(
-                        f"Parameter {k} is not supported for model {model}. Supported parameters are {supported_params}. Set drop_params=True to drop unsupported parameters."
-                    )
-
-        return optional_params
-
-    def transform_image_generation_response(
-        self,
-        model: str,
-        raw_response: httpx.Response,
-        model_response: ImageResponse,
-        logging_obj: "LiteLLMLoggingObj",
-        request_data: dict,
-        optional_params: dict,
-        litellm_params: dict,
-        encoding: "Tokenizer | None",
-        api_key: str | None = None,
-        json_mode: bool | None = None,
-    ) -> ImageResponse:
-        response: Final = raw_response.json()
-
-        stringified_response: Final = response
-        ## LOGGING
-        logging_obj.post_call(
-            input=request_data.get("prompt", ""),
-            api_key=api_key,
-            additional_args={"complete_input_dict": request_data},
-            original_response=stringified_response,
-        )
-        image_response: Final[ImageResponse] = convert_to_model_response_object(
-            response_object=stringified_response,
-            model_response_object=model_response,
-            response_type="image_generation",
-        )
-
-        # set optional params
-        image_response.size = optional_params.get("size", "1024x1024")  # default is always 1024x1024
-        image_response.quality = optional_params.get("quality", "standard")  # always standard for dall-e-2
-        image_response.output_format = optional_params.get("output_format", "png")  # always png for dall-e-2
-
-        return image_response
diff --git a/litellm/llms/openai/image_generation/dall_e_3_transformation.py b/litellm/llms/openai/image_generation/dall_e_3_transformation.py
deleted file mode 100644
index 90b7eaedf2f..00000000000
--- a/litellm/llms/openai/image_generation/dall_e_3_transformation.py
+++ /dev/null
@@ -1,81 +0,0 @@
-from typing import TYPE_CHECKING, Final
-
-import httpx
-
-from litellm.llms.base_llm.image_generation.transformation import (
-    BaseImageGenerationConfig,
-)
-from litellm.types.llms.openai import OpenAIImageGenerationOptionalParams
-from litellm.types.utils import ImageResponse
-from litellm.utils import convert_to_model_response_object
-
-if TYPE_CHECKING:
-    from litellm.litellm_core_utils.logging import Logging as LiteLLMLoggingObj
-
-    from litellm.litellm_core_utils.tokenizer import Encoding as Tokenizer
-
-
-class DallE3ImageGenerationConfig(BaseImageGenerationConfig):
-    """
-    OpenAI dall-e-3 image generation config
-    """
-
-    def get_supported_openai_params(self, model: str) -> list[OpenAIImageGenerationOptionalParams]:
-        return ["n", "response_format", "quality", "size", "user", "style"]
-
-    def map_openai_params(
-        self,
-        non_default_params: dict,
-        optional_params: dict,
-        model: str,
-        drop_params: bool,
-    ) -> dict:
-        supported_params: Final = self.get_supported_openai_params(model)
-        for k in non_default_params:
-            if k not in optional_params:
-                if k in supported_params:
-                    optional_params[k] = non_default_params[k]
-                elif drop_params:
-                    pass
-                else:
-                    raise ValueError(
-                        f"Parameter {k} is not supported for model {model}. Supported parameters are {supported_params}. Set drop_params=True to drop unsupported parameters."
-                    )
-
-        return optional_params
-
-    def transform_image_generation_response(
-        self,
-        model: str,
-        raw_response: httpx.Response,
-        model_response: ImageResponse,
-        logging_obj: "LiteLLMLoggingObj",
-        request_data: dict,
-        optional_params: dict,
-        litellm_params: dict,
-        encoding: "Tokenizer | None",
-        api_key: str | None = None,
-        json_mode: bool | None = None,
-    ) -> ImageResponse:
-        response: Final = raw_response.json()
-
-        stringified_response: Final = response
-        ## LOGGING
-        logging_obj.post_call(
-            input=request_data.get("prompt", ""),
-            api_key=api_key,
-            additional_args={"complete_input_dict": request_data},
-            original_response=stringified_response,
-        )
-        image_response: Final[ImageResponse] = convert_to_model_response_object(
-            response_object=stringified_response,
-            model_response_object=model_response,
-            response_type="image_generation",
-        )
-
-        # set optional params
-        image_response.size = optional_params.get("size", "1024x1024")  # default is always 1024x1024
-        image_response.quality = optional_params.get("quality", "hd")  # always hd for dall-e-3
-        image_response.output_format = optional_params.get("output_format", "png")  # always png for dall-e-3
-
-        return image_response
diff --git a/litellm/llms/openai/image_variations/handler.py b/litellm/llms/openai/image_variations/handler.py
index 89dcdc40e02..01f01d3de1d 100644
--- a/litellm/llms/openai/image_variations/handler.py
+++ b/litellm/llms/openai/image_variations/handler.py
@@ -151,7 +151,7 @@ class OpenAIImageVariationsHandler:
     ) -> ImageResponse:
         try:
             provider_config: Final = ProviderConfigManager.get_provider_image_variation_config(
-                model=model or "",  # openai defaults to dall-e-2
+                model=model or "",
                 provider=LlmProviders.OPENAI,
             )
 
diff --git a/litellm/llms/openai/realtime/handler.py b/litellm/llms/openai/realtime/handler.py
index 080fc3d24c9..b7e4cc6868f 100644
--- a/litellm/llms/openai/realtime/handler.py
+++ b/litellm/llms/openai/realtime/handler.py
@@ -5,7 +5,7 @@ This requires websockets, and is currently only supported on LiteLLM Proxy.
 """
 
 import ssl
-from typing import Any, Final, cast
+from typing import TYPE_CHECKING, Final, cast
 
 from litellm._logging import redact_string, verbose_logger
 from litellm.constants import REALTIME_WEBSOCKET_MAX_MESSAGE_SIZE_BYTES
@@ -23,6 +23,9 @@ from ....llms.custom_httpx.http_handler import get_shared_realtime_ssl_context
 from ..common_utils import is_openai_backed_api_base
 from ..openai import OpenAIChatCompletion
 
+if TYPE_CHECKING:
+    from fastapi import WebSocket
+
 
 class OpenAIRealtime(OpenAIChatCompletion):
     """
@@ -131,7 +134,7 @@ class OpenAIRealtime(OpenAIChatCompletion):
     async def async_realtime(
         self,
         model: str,
-        websocket: Any,
+        websocket: "WebSocket",
         logging_obj: LiteLLMLogging,
         api_base: str | None = None,
         api_key: str | None = None,
diff --git a/litellm/llms/openai_like/chat/handler.py b/litellm/llms/openai_like/chat/handler.py
index 2c74ef19e7d..a450947afdf 100644
--- a/litellm/llms/openai_like/chat/handler.py
+++ b/litellm/llms/openai_like/chat/handler.py
@@ -16,6 +16,7 @@ from litellm import LlmProviders
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
 from litellm.llms.base_llm.base_model_iterator import MockResponseIterator
 from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler, HTTPHandler
+from litellm.llms.custom_httpx.sse_lines import aiter_sse_lines, iter_sse_lines
 from litellm.llms.databricks.streaming_utils import ModelResponseIterator
 from litellm.llms.openai.chat.gpt_transformation import OpenAIGPTConfig
 from litellm.llms.openai.openai import OpenAIConfig
@@ -65,7 +66,9 @@ async def make_call(
         model_response: Final = _fake_streamed_model_response(response.json())
         completion_stream = MockResponseIterator(model_response=model_response)
     else:
-        completion_stream = ModelResponseIterator(streaming_response=response.aiter_lines(), sync_stream=False)
+        completion_stream = ModelResponseIterator(
+            streaming_response=aiter_sse_lines(response.aiter_text()), sync_stream=False
+        )
     # LOGGING
     logging_obj.post_call(
         input=messages,
@@ -103,7 +106,9 @@ def make_sync_call(
         model_response: Final = _fake_streamed_model_response(response.json())
         completion_stream = MockResponseIterator(model_response=model_response)
     else:
-        completion_stream = ModelResponseIterator(streaming_response=response.iter_lines(), sync_stream=True)
+        completion_stream = ModelResponseIterator(
+            streaming_response=iter_sse_lines(response.iter_text()), sync_stream=True
+        )
 
     # LOGGING
     logging_obj.post_call(
diff --git a/litellm/llms/perplexity/embedding/transformation.py b/litellm/llms/perplexity/embedding/transformation.py
index 7b4da933976..147d344795d 100644
--- a/litellm/llms/perplexity/embedding/transformation.py
+++ b/litellm/llms/perplexity/embedding/transformation.py
@@ -12,12 +12,14 @@ This module decodes them into float arrays for OpenAI-compatible responses.
 """
 
 import base64
+import builtins
 import struct
-from collections.abc import Mapping
-from typing import Final
+from collections.abc import Mapping, Sequence
+from typing import Final, Literal
 
 import httpx
-from pydantic import ConfigDict, TypeAdapter
+from pydantic import ConfigDict, TypeAdapter, with_config
+from typing_extensions import ReadOnly, TypedDict
 
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
 from litellm.litellm_core_utils.url_utils import join_api_base
@@ -31,6 +33,17 @@ _JSON_OBJECT: Final = TypeAdapter(Mapping[str, object], config=ConfigDict(hide_i
 _INT: Final = TypeAdapter(int)
 
 
+@with_config(ConfigDict(extra="allow", strict=True))
+class _PerplexityEmbeddingResponse(TypedDict, total=False):
+    model: ReadOnly[str | None]
+    object: ReadOnly[Literal["list"]]
+    data: ReadOnly[Sequence[builtins.object] | Mapping[str, builtins.object] | Literal[""]]
+    usage: ReadOnly[builtins.object]
+
+
+_EMBEDDING_RESPONSE_ADAPTER: Final = TypeAdapter(_PerplexityEmbeddingResponse)
+
+
 class PerplexityEmbeddingError(BaseLLMException):
     def __init__(
         self,
@@ -153,14 +166,18 @@ class PerplexityEmbeddingConfig(BaseEmbeddingConfig):
         litellm_params: dict = {},
     ) -> EmbeddingResponse:
         try:
-            raw_response_json: Final = raw_response.json()
+            raw_response_json: Final[object] = raw_response.json()
         except Exception:
             raise PerplexityEmbeddingError(message=raw_response.text, status_code=raw_response.status_code)
 
-        model_response.model = raw_response_json.get("model", model)
-        model_response.object = raw_response_json.get("object", "list")
+        response_data: Final[_PerplexityEmbeddingResponse] = _EMBEDDING_RESPONSE_ADAPTER.validate_python(
+            raw_response_json
+        )
 
-        raw_data: Final = raw_response_json.get("data", [])
+        model_response.model = response_data.get("model", model)
+        model_response.object = response_data.get("object", "list")
+
+        raw_data: Final = response_data.get("data", [])
         decoded_data: Final[list[dict[str, object]]] = []
         for item in raw_data:
             decoded_item = dict(_JSON_OBJECT.validate_python(item))
@@ -168,7 +185,7 @@ class PerplexityEmbeddingConfig(BaseEmbeddingConfig):
             decoded_data.append(decoded_item)
         model_response.data = decoded_data
 
-        usage_data: Final = _JSON_OBJECT.validate_python(raw_response_json.get("usage", {}))
+        usage_data: Final = _JSON_OBJECT.validate_python(response_data.get("usage", {}))
         usage: Final = Usage(
             prompt_tokens=_INT.validate_python(
                 usage_data.get("prompt_tokens", 0) or usage_data.get("total_tokens", 0) or 0
diff --git a/litellm/llms/predibase/chat/handler.py b/litellm/llms/predibase/chat/handler.py
index d0a61ea6e00..2ba4a63e08b 100644
--- a/litellm/llms/predibase/chat/handler.py
+++ b/litellm/llms/predibase/chat/handler.py
@@ -14,6 +14,7 @@ from litellm.llms.custom_httpx.http_handler import (
     AsyncHTTPHandler,
     get_async_httpx_client,
 )
+from litellm.llms.custom_httpx.sse_lines import aiter_sse_lines, iter_sse_lines
 from litellm.utils import CustomStreamWrapper, ModelResponse
 
 from ..common_utils import PredibaseError
@@ -34,7 +35,7 @@ async def make_call(
     if response.status_code != 200:
         raise PredibaseError(status_code=response.status_code, message=response.text)
 
-    completion_stream: Final = response.aiter_lines()
+    completion_stream: Final = aiter_sse_lines(response.aiter_text())
     # LOGGING
     logging_obj.post_call(
         input=messages,
@@ -163,7 +164,7 @@ class PredibaseChatCompletion:
                 timeout=timeout,
             )
             _response: Final = CustomStreamWrapper(
-                response.iter_lines(),
+                iter_sse_lines(response.iter_text()),
                 model,
                 custom_llm_provider="predibase",
                 logging_obj=logging_obj,
diff --git a/litellm/llms/tencent/cost_calculator.py b/litellm/llms/tencent/cost_calculator.py
index d9aebdc3284..5d2abe3acf4 100644
--- a/litellm/llms/tencent/cost_calculator.py
+++ b/litellm/llms/tencent/cost_calculator.py
@@ -1,6 +1,49 @@
-from litellm.litellm_core_utils.llm_cost_calc.utils import generic_cost_per_token
-from litellm.types.utils import Usage
+from typing import Final
+
+from litellm.litellm_core_utils.llm_cost_calc.utils import (
+    calculate_image_response_cost_from_usage,
+    flat_image_cost,
+    generic_cost_per_token,
+    resolve_image_model_info,
+)
+from litellm.types.utils import ImageResponse, ModelInfo, Usage
 
 
 def cost_per_token(model: str, usage: Usage) -> tuple[float, float]:
     return generic_cost_per_token(model=model, usage=usage, custom_llm_provider="tencent")
+
+
+def _deployment_image_token_pricing(model_info: ModelInfo | None) -> ModelInfo | None:
+    if model_info is None or model_info.get("output_cost_per_image_token") is not None:
+        return model_info
+    output_cost_per_token: Final = model_info.get("output_cost_per_token")
+    if output_cost_per_token is None:
+        return model_info
+    priced: Final[ModelInfo] = {**model_info, "output_cost_per_image_token": output_cost_per_token}
+    return priced
+
+
+def _deployment_prices_per_image_only(model_info: ModelInfo | None) -> bool:
+    return (
+        model_info is not None
+        and model_info.get("output_cost_per_image") is not None
+        and model_info.get("output_cost_per_image_token") is None
+        and model_info.get("output_cost_per_token") is None
+    )
+
+
+def image_cost_calculator(model: str, image_response: ImageResponse, model_info: ModelInfo | None = None) -> float:
+    resolved_model_info: Final = resolve_image_model_info(
+        model=model, custom_llm_provider="tencent", model_info=_deployment_image_token_pricing(model_info)
+    )
+    if _deployment_prices_per_image_only(model_info):
+        return flat_image_cost(resolved_model_info, image_response)
+    token_based_cost: Final = calculate_image_response_cost_from_usage(
+        model=model,
+        image_response=image_response,
+        custom_llm_provider="tencent",
+        model_info=resolved_model_info,
+    )
+    if token_based_cost is not None:
+        return token_based_cost
+    return flat_image_cost(resolved_model_info, image_response)
diff --git a/litellm/llms/tencent/image_edit/__init__.py b/litellm/llms/tencent/image_edit/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/litellm/llms/tencent/image_edit/transformation.py b/litellm/llms/tencent/image_edit/transformation.py
new file mode 100644
index 00000000000..3033d161ce7
--- /dev/null
+++ b/litellm/llms/tencent/image_edit/transformation.py
@@ -0,0 +1,147 @@
+from collections.abc import Mapping
+from types import MappingProxyType
+from typing import TYPE_CHECKING, Final, TypeAlias
+
+import httpx
+from httpx._types import RequestFiles
+from pydantic import TypeAdapter
+from typing_extensions import override
+
+from litellm.images.utils import image_to_data_url
+from litellm.llms.base_llm.chat.transformation import BaseLLMException
+from litellm.llms.base_llm.image_edit.transformation import BaseImageEditConfig
+from litellm.llms.tencent.image_generation.transformation import (
+    TOKENHUB_IMAGE_PARAMS,
+    tokenhub_image_headers,
+    tokenhub_image_params,
+    tokenhub_image_response,
+    tokenhub_image_url,
+)
+from litellm.types.images.main import ImageEditOptionalRequestParams
+from litellm.types.router import GenericLiteLLMParams
+from litellm.types.utils import ImageResponse
+
+if TYPE_CHECKING:
+    from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+
+_IMAGES: Final = TypeAdapter(tuple[object, ...])
+_FORM_BOOLEANS: Final = MappingProxyType({"true": True, "false": False})
+_OPENAI_PARAMS: Final = frozenset(TOKENHUB_IMAGE_PARAMS)
+
+_FormEntries: TypeAlias = tuple[tuple[tuple[str, ...], object], ...]
+
+
+def _form_scalar(value: object) -> object:
+    match value:
+        case str() if value.lower() in _FORM_BOOLEANS:
+            return _FORM_BOOLEANS[value.lower()]
+        case str() if value.removeprefix("-").isdigit():
+            return int(value)
+        case _:
+            return value
+
+
+def _form_path(key: str) -> tuple[str, ...]:
+    root, bracket, rest = key.partition("[")
+    if not bracket or not rest.endswith("]"):
+        return (key,)
+    return (root, *rest.removesuffix("]").split("]["))
+
+
+def _nested_form_value(entries: _FormEntries) -> object:
+    match entries:
+        case (((), value),):
+            return _form_scalar(value)
+        case _:
+            return _nested_form_fields(tuple(entry for entry in entries if entry[0]))
+
+
+def _nested_form_fields(entries: _FormEntries) -> Mapping[str, object]:
+    roots: Final = tuple(dict.fromkeys(path[0] for path, _ in entries))
+    return {
+        root: _nested_form_value(tuple((path[1:], value) for path, value in entries if path[0] == root))
+        for root in roots
+    }
+
+
+def _tokenhub_form_params(params: Mapping[str, object]) -> Mapping[str, object]:
+    tokenhub_entries: Final = tuple(
+        (_form_path(key), value) for key, value in params.items() if key not in _OPENAI_PARAMS
+    )
+    return {
+        **{key: value for key, value in params.items() if key in _OPENAI_PARAMS},
+        **_nested_form_fields(tokenhub_entries),
+    }
+
+
+class TencentImageEditConfig(BaseImageEditConfig):
+    @override
+    def get_supported_openai_params(self, model: str) -> list[str]:  # mutable-ok: mirrors override contract
+        return list(TOKENHUB_IMAGE_PARAMS)
+
+    @override
+    def map_openai_params(
+        self,
+        image_edit_optional_params: ImageEditOptionalRequestParams,
+        model: str,
+        drop_params: bool,
+    ) -> dict[str, object]:  # mutable-ok: mirrors override contract
+        return dict(tokenhub_image_params(image_edit_optional_params, model, drop_params))
+
+    @override
+    def validate_environment(
+        self,
+        headers: Mapping[str, str],
+        model: str,
+        api_key: str | None = None,
+        litellm_params: Mapping[str, object] | None = None,
+        api_base: str | None = None,
+    ) -> dict[str, str]:  # mutable-ok: mirrors override contract
+        return dict(tokenhub_image_headers(headers, api_key, model))
+
+    @override
+    def get_complete_url(
+        self,
+        model: str,
+        api_base: str | None,
+        litellm_params: Mapping[str, object],
+    ) -> str:
+        return tokenhub_image_url(api_base)
+
+    @override
+    def use_multipart_form_data(self) -> bool:
+        return False
+
+    @override
+    def transform_image_edit_request(
+        self,
+        model: str,
+        prompt: str | None,
+        image: object,
+        image_edit_optional_request_params: Mapping[str, object],
+        litellm_params: GenericLiteLLMParams,
+        headers: Mapping[str, str],
+    ) -> tuple[dict[str, object], RequestFiles]:  # mutable-ok: mirrors override contract
+        images: Final = _IMAGES.validate_python(image) if isinstance(image, list) else (image,)
+        return {
+            "model": model,
+            "prompt": prompt,
+            "images": tuple(image_to_data_url(img) for img in images if img is not None),
+            **_tokenhub_form_params(image_edit_optional_request_params),
+        }, ()
+
+    @override
+    def transform_image_edit_response(
+        self,
+        model: str,
+        raw_response: httpx.Response,
+        logging_obj: "LiteLLMLoggingObj",
+    ) -> ImageResponse:
+        image_response: Final = tokenhub_image_response(raw_response)
+        if image_response is None:
+            raise BaseLLMException(
+                status_code=raw_response.status_code,
+                message=raw_response.text,
+                headers=raw_response.headers,
+            )
+        return image_response
diff --git a/litellm/llms/tencent/image_generation/__init__.py b/litellm/llms/tencent/image_generation/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/litellm/llms/tencent/image_generation/transformation.py b/litellm/llms/tencent/image_generation/transformation.py
new file mode 100644
index 00000000000..fb4b102e8be
--- /dev/null
+++ b/litellm/llms/tencent/image_generation/transformation.py
@@ -0,0 +1,200 @@
+from collections.abc import Mapping, Sequence
+from typing import TYPE_CHECKING, Final
+
+import httpx
+from pydantic import BaseModel, ConfigDict, TypeAdapter, ValidationError
+from typing_extensions import override
+
+from litellm.exceptions import AuthenticationError, UnsupportedParamsError
+from litellm.litellm_core_utils.url_utils import ensure_api_route, join_api_base
+from litellm.llms.base_llm.chat.transformation import BaseLLMException
+from litellm.llms.base_llm.image_generation.transformation import (
+    BaseImageGenerationConfig,
+)
+from litellm.secret_managers.main import get_secret_str
+from litellm.types.llms.openai import (
+    AllMessageValues,
+    OpenAIImageGenerationOptionalParams,
+)
+from litellm.types.utils import (
+    ImageObject,
+    ImageResponse,
+    ImageUsage,
+    ImageUsageInputTokensDetails,
+    LlmProviders,
+)
+
+if TYPE_CHECKING:
+    from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+
+TOKENHUB_API_BASE: Final = "https://tokenhub-intl.tencentcloudmaas.com/v1"
+TOKENHUB_IMAGE_PATH: Final = "/wand/si-image/generation"
+TOKENHUB_IMAGE_MODEL_PREFIX: Final = "seedream-"
+TOKENHUB_IMAGE_PARAMS: Final[tuple[OpenAIImageGenerationOptionalParams, ...]] = (
+    "n",
+    "size",
+    "response_format",
+    "output_format",
+    "background",
+    "user",
+)
+
+_JSON_OBJECT: Final = TypeAdapter(Mapping[str, object], config=ConfigDict(hide_input_in_errors=True))
+
+
+class _TokenHubImage(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    url: str | None = None
+    b64_json: str | None = None
+    size: str | None = None
+    output_format: str | None = None
+
+
+class _TokenHubUsage(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    total_tokens: int
+
+
+class _TokenHubImageResponse(BaseModel):
+    model_config = ConfigDict(frozen=True, hide_input_in_errors=True)
+
+    created: int
+    data: tuple[_TokenHubImage, ...]
+    tokenhub_usage: _TokenHubUsage | None = None
+
+
+def is_tokenhub_image_model(model: str) -> bool:
+    return model.removeprefix(f"{LlmProviders.TENCENT.value}/").startswith(TOKENHUB_IMAGE_MODEL_PREFIX)
+
+
+def tokenhub_image_url(api_base: str | None) -> str:
+    base: Final = api_base or get_secret_str("TENCENT_API_BASE") or TOKENHUB_API_BASE
+    return join_api_base(ensure_api_route(base, "v1"), TOKENHUB_IMAGE_PATH)
+
+
+def tokenhub_image_headers(headers: Mapping[str, str], api_key: str | None, model: str) -> Mapping[str, str]:
+    resolved_api_key: Final = api_key or get_secret_str("TENCENT_API_KEY")
+    if not resolved_api_key:
+        raise AuthenticationError(
+            message="TENCENT_API_KEY is not set. Set it in the environment or pass api_key.",
+            llm_provider="tencent",
+            model=model,
+        )
+    return {**headers, "Authorization": f"Bearer {resolved_api_key}", "Content-Type": "application/json"}
+
+
+def tokenhub_image_params(params: Mapping[str, object], model: str, drop_params: bool) -> Mapping[str, object]:
+    n: Final = params.get("n")
+    if n is not None and n != 1 and not drop_params:
+        raise UnsupportedParamsError(
+            status_code=400,
+            message=f"Tencent TokenHub returns one image per request, so n={n} is not supported for {model}. "
+            + "To send n=1 instead, set `litellm.drop_params = True`.",
+        )
+    return {
+        key: value
+        for key, value in params.items()
+        if key != "n" and value is not None and not (key == "background" and value == "auto")
+    }
+
+
+def tokenhub_image_response(raw_response: httpx.Response) -> ImageResponse | None:
+    try:
+        parsed: Final = _TokenHubImageResponse.model_validate_json(raw_response.content)
+    except ValidationError:
+        return None
+    total_tokens: Final = parsed.tokenhub_usage.total_tokens if parsed.tokenhub_usage is not None else 0
+    first_image: Final = parsed.data[0] if parsed.data else _TokenHubImage()
+    return ImageResponse(
+        created=parsed.created,
+        data=[ImageObject(url=image.url, b64_json=image.b64_json) for image in parsed.data],
+        size=first_image.size,
+        output_format=first_image.output_format,
+        usage=ImageUsage(
+            input_tokens=0,
+            input_tokens_details=ImageUsageInputTokensDetails(image_tokens=0, text_tokens=0),
+            output_tokens=total_tokens,
+            total_tokens=total_tokens,
+        ),
+    )
+
+
+class TencentImageGenerationConfig(BaseImageGenerationConfig):
+    @override
+    def get_supported_openai_params(
+        self, model: str
+    ) -> list[OpenAIImageGenerationOptionalParams]:  # mutable-ok: mirrors override contract
+        return list(TOKENHUB_IMAGE_PARAMS)
+
+    @override
+    def map_openai_params(
+        self,
+        non_default_params: Mapping[str, object],
+        optional_params: Mapping[str, object],
+        model: str,
+        drop_params: bool,
+    ) -> dict[str, object]:  # mutable-ok: mirrors override contract
+        return {**optional_params, **tokenhub_image_params(non_default_params, model, drop_params)}
+
+    @override
+    def get_complete_url(
+        self,
+        api_base: str | None,
+        api_key: str | None,
+        model: str,
+        optional_params: Mapping[str, object],
+        litellm_params: Mapping[str, object],
+        stream: bool | None = None,
+    ) -> str:
+        return tokenhub_image_url(api_base)
+
+    @override
+    def validate_environment(
+        self,
+        headers: Mapping[str, str],
+        model: str,
+        messages: Sequence[AllMessageValues],
+        optional_params: Mapping[str, object],
+        litellm_params: Mapping[str, object],
+        api_key: str | None = None,
+        api_base: str | None = None,
+    ) -> dict[str, str]:  # mutable-ok: mirrors override contract
+        return dict(tokenhub_image_headers(headers, api_key, model))
+
+    @override
+    def transform_image_generation_request(
+        self,
+        model: str,
+        prompt: str,
+        optional_params: Mapping[str, object],
+        litellm_params: Mapping[str, object],
+        headers: Mapping[str, str],
+    ) -> dict[str, object]:  # mutable-ok: mirrors override contract
+        extra_body: Final = _JSON_OBJECT.validate_python(optional_params.get("extra_body") or {})
+        params: Final = {key: value for key, value in optional_params.items() if key != "extra_body"}
+        return {"model": model, "prompt": prompt, **params, **extra_body}
+
+    @override
+    def transform_image_generation_response(
+        self,
+        model: str,
+        raw_response: httpx.Response,
+        model_response: ImageResponse,
+        logging_obj: "LiteLLMLoggingObj",
+        request_data: Mapping[str, object],
+        optional_params: Mapping[str, object],
+        litellm_params: Mapping[str, object],
+        encoding: object,
+        api_key: str | None = None,
+        json_mode: bool | None = None,
+    ) -> ImageResponse:
+        image_response: Final = tokenhub_image_response(raw_response)
+        if image_response is None:
+            raise BaseLLMException(
+                status_code=raw_response.status_code,
+                message=raw_response.text,
+                headers=raw_response.headers,
+            )
+        return image_response
diff --git a/litellm/llms/vertex_ai/agent_engine/transformation.py b/litellm/llms/vertex_ai/agent_engine/transformation.py
index 9f592398f74..0339533e1f5 100644
--- a/litellm/llms/vertex_ai/agent_engine/transformation.py
+++ b/litellm/llms/vertex_ai/agent_engine/transformation.py
@@ -22,6 +22,7 @@ from litellm.litellm_core_utils.prompt_templates.common_utils import (
     convert_content_list_to_str,
 )
 from litellm.llms.base_llm.chat.transformation import BaseConfig, BaseLLMException
+from litellm.llms.custom_httpx.sse_lines import aiter_sse_lines, iter_sse_lines
 from litellm.llms.vertex_ai.agent_engine.sse_iterator import (
     VertexAgentEngineResponseIterator,
 )
@@ -357,7 +358,7 @@ class VertexAgentEngineConfig(BaseConfig, VertexBase):
     ) -> VertexAgentEngineResponseIterator:
         """Return a streaming iterator for SSE responses."""
         return VertexAgentEngineResponseIterator(
-            streaming_response=raw_response.iter_lines(),
+            streaming_response=iter_sse_lines(raw_response.iter_text()),
             sync_stream=True,
         )
 
@@ -465,7 +466,7 @@ class VertexAgentEngineConfig(BaseConfig, VertexBase):
 
         # Create iterator for SSE stream (async)
         completion_stream: Final = VertexAgentEngineResponseIterator(
-            streaming_response=response.aiter_lines(),
+            streaming_response=aiter_sse_lines(response.aiter_text()),
             sync_stream=False,
         )
 
diff --git a/litellm/llms/vertex_ai/gemini/vertex_and_google_ai_studio_gemini.py b/litellm/llms/vertex_ai/gemini/vertex_and_google_ai_studio_gemini.py
index f27593dc94e..c506192f253 100644
--- a/litellm/llms/vertex_ai/gemini/vertex_and_google_ai_studio_gemini.py
+++ b/litellm/llms/vertex_ai/gemini/vertex_and_google_ai_studio_gemini.py
@@ -41,6 +41,7 @@ from litellm.llms.custom_httpx.http_handler import (
     get_async_httpx_client,
     get_httpx_client,
 )
+from litellm.llms.custom_httpx.sse_lines import aiter_sse_lines, iter_sse_lines
 from litellm.types.llms.anthropic import AnthropicThinkingParam
 from litellm.types.llms.base import CachedTokensDetails
 from litellm.types.llms.gemini import BidiGenerateContentServerMessage
@@ -3241,7 +3242,7 @@ async def make_call(
             raise
 
     completion_stream: Final = ModelResponseIterator(
-        streaming_response=response.aiter_lines(),
+        streaming_response=aiter_sse_lines(response.aiter_text()),
         sync_stream=False,
         logging_obj=logging_obj,
         response_headers=response.headers,
@@ -3312,7 +3313,7 @@ def make_sync_call(
             raise
 
     completion_stream: Final = ModelResponseIterator(
-        streaming_response=response.iter_lines(),
+        streaming_response=iter_sse_lines(response.iter_text()),
         sync_stream=True,
         logging_obj=logging_obj,
         response_headers=response.headers,
@@ -4190,7 +4191,7 @@ class ModelResponseIterator:
             log_failed_hop(e)
             return self._truncated_stream_end(token)
         self._start_hop(hop_response, token)
-        self.streaming_response = hop_response.aiter_lines()
+        self.streaming_response = aiter_sse_lines(hop_response.aiter_text())
         self.async_response_iterator = self.streaming_response
         return None
 
@@ -4204,7 +4205,7 @@ class ModelResponseIterator:
             log_failed_hop(e)
             return self._truncated_stream_end(token)
         self._start_hop(hop_response, token)
-        self.streaming_response = hop_response.iter_lines()
+        self.streaming_response = iter_sse_lines(hop_response.iter_text())
         self.response_iterator = self.streaming_response
         return None
 
diff --git a/litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/messages/transformation.py b/litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/messages/transformation.py
index 6d8eb228786..1f0ee728cd1 100644
--- a/litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/messages/transformation.py
+++ b/litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/messages/transformation.py
@@ -1,6 +1,8 @@
 from collections.abc import Mapping, Sequence
 from typing import Final
 
+from litellm.exceptions import UnsupportedParamsError
+from litellm.litellm_core_utils.core_helpers import drops_unsupported_params
 from litellm.llms.anthropic.common_utils import AnthropicModelInfo
 from litellm.llms.anthropic.messages.native.transformation import (
     AnthropicMessagesConfig,
@@ -17,6 +19,41 @@ from litellm.types.router import GenericLiteLLMParams
 from ....vertex_llm_base import VertexBase
 from ..output_params_utils import sanitize_vertex_anthropic_output_params
 
+_VERSION_HEADER_VERTEX_READS_FROM_BODY: Final = "anthropic-version"
+_VERTEX_DEFAULT_VERSION: Final = "vertex-2023-10-16"
+_VERSIONS_SERVED_AS_VERTEX_DEFAULT: Final = frozenset({"", "2023-01-01", "2023-06-01"})
+_VERSIONS_VERTEX_ACCEPTS_IN_BODY: Final = frozenset({_VERTEX_DEFAULT_VERSION, "2026-10-21"})
+
+
+def _requested_version(headers: Mapping[str, object]) -> str:
+    requested: Final = next(
+        (value for name, value in headers.items() if name.lower() == _VERSION_HEADER_VERTEX_READS_FROM_BODY),
+        "",
+    )
+    return requested.strip() if isinstance(requested, str) else ""
+
+
+def _vertex_version(headers: Mapping[str, object], model: str, drop_params: bool) -> str | UnsupportedParamsError:
+    requested: Final = _requested_version(headers)
+    if requested in _VERSIONS_SERVED_AS_VERTEX_DEFAULT:
+        return _VERTEX_DEFAULT_VERSION
+    if requested in _VERSIONS_VERTEX_ACCEPTS_IN_BODY:
+        return requested
+    if drop_params:
+        return _VERTEX_DEFAULT_VERSION
+    return UnsupportedParamsError(
+        message=(
+            f"{model} does not support {_VERSION_HEADER_VERTEX_READS_FROM_BODY}={requested}. "
+            "To drop unsupported params, set `litellm.drop_params = True`."
+        ),
+        llm_provider="vertex_ai",
+        model=model,
+    )
+
+
+def _without_version_header(headers: Mapping[str, str]) -> dict[str, str]:  # mutable-ok: the caller sends these headers
+    return {name: value for name, value in headers.items() if name.lower() != _VERSION_HEADER_VERTEX_READS_FROM_BODY}
+
 
 class VertexAIPartnerModelsAnthropicMessagesConfig(AnthropicMessagesConfig, VertexBase):
     @property
@@ -198,7 +235,7 @@ class VertexAIPartnerModelsAnthropicMessagesConfig(AnthropicMessagesConfig, Vert
         messages: list[dict],
         anthropic_messages_optional_request_params: dict,
         litellm_params: GenericLiteLLMParams,
-        headers: dict,
+        headers: dict[str, object],  # mutable-ok: mirrors the provider transform contract
     ) -> dict:
         anthropic_messages_request: Final = super().transform_anthropic_messages_request(
             model=model,
@@ -212,10 +249,28 @@ class VertexAIPartnerModelsAnthropicMessagesConfig(AnthropicMessagesConfig, Vert
 
         self._remove_scope_from_cache_control(anthropic_messages_request)
 
-        anthropic_messages_request["anthropic_version"] = "vertex-2023-10-16"
+        version: Final = _vertex_version(
+            headers, model=model, drop_params=drops_unsupported_params(litellm_params.drop_params)
+        )
+        if isinstance(version, UnsupportedParamsError):
+            raise version
+        anthropic_messages_request["anthropic_version"] = version
 
         anthropic_messages_request.pop("model", None)  # do not pass model in request body to vertex ai
 
         sanitize_vertex_anthropic_output_params(anthropic_messages_request, model)
 
         return anthropic_messages_request
+
+    def sign_request(
+        self,
+        headers: Mapping[str, str],
+        optional_params: Mapping[str, object],
+        request_data: Mapping[str, object],
+        api_base: str,
+        api_key: str | None = None,
+        model: str | None = None,
+        stream: bool | None = None,
+        fake_stream: bool | None = None,
+    ) -> tuple[dict[str, str], bytes | None]:  # mutable-ok: the caller sends these headers
+        return _without_version_header(headers), None
diff --git a/litellm/llms/vertex_ai/vertex_gemma_models/transformation.py b/litellm/llms/vertex_ai/vertex_gemma_models/transformation.py
index 9fa86ec30f5..ec2fd16f93e 100644
--- a/litellm/llms/vertex_ai/vertex_gemma_models/transformation.py
+++ b/litellm/llms/vertex_ai/vertex_gemma_models/transformation.py
@@ -9,10 +9,11 @@ The actual message transformation reuses OpenAIGPTConfig since Gemma uses OpenAI
 """
 
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Any, Final, cast
+from typing import TYPE_CHECKING, Final, cast
 
 import httpx
-from pydantic import ValidationError
+from pydantic import ConfigDict, TypeAdapter, ValidationError
+from typing_extensions import NotRequired, ReadOnly, TypeAliasType, TypedDict
 
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.llms.custom_httpx.http_handler import (
@@ -32,6 +33,17 @@ if TYPE_CHECKING:
     from litellm.litellm_core_utils.tokenizer import Encoding as Tokenizer
 
 
+class _PredictionsEnvelope(TypedDict):
+    predictions: NotRequired[ReadOnly[dict[str, object]]]
+
+
+_PredictionsEnvelopeType = TypeAliasType("_PredictionsEnvelopeType", _PredictionsEnvelope)
+_PREDICTIONS_ENVELOPE: Final[TypeAdapter[_PredictionsEnvelope]] = TypeAdapter(
+    _PredictionsEnvelopeType,
+    config=ConfigDict(strict=True, extra="allow"),
+)
+
+
 def parse_vertex_gemma_container_error(predictions: object) -> VertexGemmaContainerError | None:
     try:
         return VertexGemmaContainerError.model_validate(predictions)
@@ -142,7 +154,7 @@ class VertexGemmaConfig(OpenAIGPTConfig):
 
     def _unwrap_predictions_response(
         self,
-        response_json: dict[str, Any],
+        response_json: _PredictionsEnvelope,
     ) -> dict[str, object]:
         """
         Unwrap the Vertex Gemma predictions format to OpenAI format.
@@ -354,7 +366,7 @@ class VertexGemmaConfig(OpenAIGPTConfig):
                 message=f"Request failed: {response.text}",
             )
 
-        response_json: Final = response.json()
+        response_json: Final = _PREDICTIONS_ENVELOPE.validate_python(response.json())
 
         # Unwrap predictions to get OpenAI-compatible response
         openai_response: Final = self._unwrap_predictions_response(response_json)
@@ -449,7 +461,7 @@ class VertexGemmaConfig(OpenAIGPTConfig):
                 message=f"Request failed: {response.text}",
             )
 
-        response_json: Final = response.json()
+        response_json: Final = _PREDICTIONS_ENVELOPE.validate_python(response.json())
 
         # Unwrap predictions to get OpenAI-compatible response
         openai_response: Final = self._unwrap_predictions_response(response_json)
diff --git a/litellm/llms/volcengine/responses/transformation.py b/litellm/llms/volcengine/responses/transformation.py
index 747ea21e4fb..4076ed06fc2 100644
--- a/litellm/llms/volcengine/responses/transformation.py
+++ b/litellm/llms/volcengine/responses/transformation.py
@@ -3,6 +3,7 @@ from types import UnionType
 from typing import TYPE_CHECKING, Any, Final, Literal, Protocol, Union, get_args, get_origin
 
 import httpx
+from pydantic import ConfigDict, TypeAdapter
 from pydantic import fields as pyd_fields
 
 import litellm
@@ -37,6 +38,8 @@ if TYPE_CHECKING:
 else:
     LiteLLMLoggingObj = Any
 
+_RESPONSE_BODY: Final = TypeAdapter(dict[str, object], config=ConfigDict(strict=True))
+
 
 class _EventModelClass(Protocol):
     @property
@@ -420,7 +423,7 @@ class VolcEngineResponsesAPIConfig(OpenAIResponsesAPIConfig):
 
     @staticmethod
     def _parsed_response_body(raw_response: httpx.Response) -> dict[str, object]:
-        return raw_response.json()
+        return _RESPONSE_BODY.validate_python(raw_response.json())
 
     @staticmethod
     def _annotation_origin(annotation: object) -> object:
diff --git a/litellm/model_prices_and_context_window_backup.json b/litellm/model_prices_and_context_window_backup.json
index 1f2bd7d7837..8719565a96f 100644
--- a/litellm/model_prices_and_context_window_backup.json
+++ b/litellm/model_prices_and_context_window_backup.json
@@ -28853,6 +28853,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.039,
         "output_cost_per_image_token": 3e-05,
+        "output_cost_per_image_token_batches": 1.5e-05,
         "output_cost_per_reasoning_token": 2.5e-06,
         "output_cost_per_token": 2.5e-06,
         "output_cost_per_token_batches": 1.25e-06,
@@ -28910,6 +28911,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.134,
         "output_cost_per_image_token": 0.00012,
+        "output_cost_per_image_token_batches": 6e-05,
         "output_cost_per_token": 1.2e-05,
         "output_cost_per_token_above_200k_tokens": 1.8e-05,
         "output_cost_per_token_above_200k_tokens_priority": 3.24e-05,
@@ -28963,12 +28965,13 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.134,
         "output_cost_per_image_token": 0.00012,
+        "output_cost_per_image_token_batches": 6e-05,
         "output_cost_per_token": 1.2e-05,
         "output_cost_per_token_priority": 2.16e-05,
         "output_cost_per_token_above_200k_tokens": 1.8e-05,
         "output_cost_per_token_above_200k_tokens_priority": 3.24e-05,
         "output_cost_per_token_batches": 6e-06,
-        "source": "https://ai.google.dev/gemini-api/docs/pricing",
+        "source": "https://cloud.google.com/gemini-enterprise-agent-platform/generative-ai/pricing",
         "supported_endpoints": [
             "/v1/chat/completions",
             "/v1/images/generations",
@@ -29014,6 +29017,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.0672,
         "output_cost_per_image_token": 6e-05,
+        "output_cost_per_image_token_batches": 3e-05,
         "output_cost_per_token": 3e-06,
         "output_cost_per_token_batches": 1.5e-06,
         "output_cost_per_token_flex": 1.5e-06,
@@ -29059,9 +29063,10 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.0672,
         "output_cost_per_image_token": 6e-05,
+        "output_cost_per_image_token_batches": 3e-05,
         "output_cost_per_token": 3e-06,
         "output_cost_per_token_batches": 1.5e-06,
-        "source": "https://cloud.google.com/vertex-ai/generative-ai/pricing#gemini-models",
+        "source": "https://cloud.google.com/gemini-enterprise-agent-platform/generative-ai/pricing",
         "supported_endpoints": [
             "/v1/chat/completions",
             "/v1/images/generations",
@@ -29106,6 +29111,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.0336,
         "output_cost_per_image_token": 3e-05,
+        "output_cost_per_image_token_batches": 1.5e-05,
         "output_cost_per_token": 1.5e-06,
         "output_cost_per_token_batches": 7.5e-07,
         "output_cost_per_token_flex": 7.5e-07,
@@ -29672,10 +29678,12 @@
         },
         "search_free_requests": {"count": 10000, "period": "day", "shared_group": "gemini-2.5-pro"},
         "google_maps_grounding_cost_per_query": 0.025,
+        "input_cost_per_token_above_200k_tokens_batches": 1.25e-06,
         "input_cost_per_token_above_200k_tokens_priority": 4.5e-06,
         "input_cost_per_token_batches": 6.25e-07,
         "input_cost_per_token_flex": 6.25e-07,
         "input_cost_per_token_priority": 2.25e-06,
+        "output_cost_per_token_above_200k_tokens_batches": 7.5e-06,
         "output_cost_per_token_above_200k_tokens_priority": 2.7e-05,
         "output_cost_per_token_batches": 5e-06,
         "output_cost_per_token_flex": 5e-06,
@@ -29690,6 +29698,7 @@
         "google_maps_grounding_cost_per_query": 0.014,
         "input_cost_per_token": 2e-06,
         "input_cost_per_token_above_200k_tokens": 4e-06,
+        "input_cost_per_token_above_200k_tokens_batches": 2e-06,
         "input_cost_per_token_above_200k_tokens_priority": 7.2e-06,
         "input_cost_per_token_batches": 1e-06,
         "input_cost_per_token_flex": 1e-06,
@@ -29701,6 +29710,7 @@
         "output_cost_per_image": 0.00012,
         "output_cost_per_token": 1.2e-05,
         "output_cost_per_token_above_200k_tokens": 1.8e-05,
+        "output_cost_per_token_above_200k_tokens_batches": 9e-06,
         "output_cost_per_token_above_200k_tokens_priority": 3.24e-05,
         "output_cost_per_token_batches": 6e-06,
         "output_cost_per_token_flex": 6e-06,
@@ -30229,6 +30239,7 @@
         "google_maps_grounding_cost_per_query": 0.014,
         "input_cost_per_token": 2e-06,
         "input_cost_per_token_above_200k_tokens": 4e-06,
+        "input_cost_per_token_above_200k_tokens_batches": 2e-06,
         "input_cost_per_token_above_200k_tokens_priority": 7.2e-06,
         "input_cost_per_token_batches": 1e-06,
         "input_cost_per_token_flex": 1e-06,
@@ -30240,6 +30251,7 @@
         "output_cost_per_image": 0.00012,
         "output_cost_per_token": 1.2e-05,
         "output_cost_per_token_above_200k_tokens": 1.8e-05,
+        "output_cost_per_token_above_200k_tokens_batches": 9e-06,
         "output_cost_per_token_above_200k_tokens_priority": 3.24e-05,
         "output_cost_per_token_batches": 6e-06,
         "output_cost_per_token_flex": 6e-06,
@@ -51910,6 +51922,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.039,
         "output_cost_per_image_token": 3e-05,
+        "output_cost_per_image_token_batches": 1.5e-05,
         "output_cost_per_reasoning_token": 2.5e-06,
         "output_cost_per_token": 2.5e-06,
         "output_cost_per_token_batches": 1.25e-06,
@@ -51968,6 +51981,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.134,
         "output_cost_per_image_token": 0.00012,
+        "output_cost_per_image_token_batches": 6e-05,
         "output_cost_per_token": 1.2e-05,
         "output_cost_per_token_above_200k_tokens": 1.8e-05,
         "output_cost_per_token_above_200k_tokens_priority": 3.24e-05,
@@ -52002,13 +52016,14 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.134,
         "output_cost_per_image_token": 0.00012,
+        "output_cost_per_image_token_batches": 6e-05,
         "output_cost_per_token": 1.2e-05,
         "output_cost_per_token_priority": 2.16e-05,
         "output_cost_per_token_above_200k_tokens": 1.8e-05,
         "output_cost_per_token_above_200k_tokens_priority": 3.24e-05,
         "output_cost_per_token_batches": 6e-06,
         "supports_reasoning": false,
-        "source": "https://docs.cloud.google.com/vertex-ai/generative-ai/docs/models/gemini/3-pro-image",
+        "source": "https://cloud.google.com/gemini-enterprise-agent-platform/generative-ai/pricing",
         "supported_endpoints": [
             "/v1/chat/completions",
             "/v1/images/generations",
@@ -52034,6 +52049,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.0672,
         "output_cost_per_image_token": 6e-05,
+        "output_cost_per_image_token_batches": 3e-05,
         "output_cost_per_token": 3e-06,
         "output_cost_per_token_batches": 1.5e-06,
         "output_cost_per_token_flex": 1.5e-06,
@@ -52061,10 +52077,11 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.0672,
         "output_cost_per_image_token": 6e-05,
+        "output_cost_per_image_token_batches": 3e-05,
         "output_cost_per_token": 3e-06,
         "output_cost_per_token_batches": 1.5e-06,
         "supports_reasoning": false,
-        "source": "https://cloud.google.com/vertex-ai/generative-ai/pricing#gemini-models",
+        "source": "https://cloud.google.com/gemini-enterprise-agent-platform/generative-ai/pricing",
         "supported_endpoints": [
             "/v1/chat/completions",
             "/v1/images/generations",
@@ -52089,6 +52106,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.0336,
         "output_cost_per_image_token": 3e-05,
+        "output_cost_per_image_token_batches": 1.5e-05,
         "output_cost_per_token": 1.5e-06,
         "output_cost_per_token_batches": 7.5e-07,
         "output_cost_per_token_flex": 7.5e-07,
@@ -61986,6 +62004,39 @@
         "supports_reasoning": true,
         "supports_vision": false
     },
+    "tencent/seedream-image-v5.0-flash": {
+        "litellm_provider": "tencent",
+        "mode": "image_generation",
+        "output_cost_per_image": 0.018,
+        "output_cost_per_image_token": 1.6e-06,
+        "source": "https://cloud.tencent.com/document/product/1823/130055",
+        "supported_endpoints": [
+            "/v1/images/generations",
+            "/v1/images/edits"
+        ]
+    },
+    "tencent/seedream-image-v5.0-lite": {
+        "litellm_provider": "tencent",
+        "mode": "image_generation",
+        "output_cost_per_image": 0.035,
+        "output_cost_per_image_token": 1.6e-06,
+        "source": "https://www.tencentcloud.com/document/product/1300/78937",
+        "supported_endpoints": [
+            "/v1/images/generations",
+            "/v1/images/edits"
+        ]
+    },
+    "tencent/seedream-image-v5.0-pro": {
+        "litellm_provider": "tencent",
+        "mode": "image_generation",
+        "output_cost_per_image": 0.09,
+        "output_cost_per_image_token": 1.6e-06,
+        "source": "https://www.tencentcloud.com/document/product/1300/78937",
+        "supported_endpoints": [
+            "/v1/images/generations",
+            "/v1/images/edits"
+        ]
+    },
     "cognition/swe-1.6": {
         "input_cost_per_token": 5e-07,
         "output_cost_per_token": 2.5e-06,
@@ -74367,6 +74418,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.0336,
         "output_cost_per_image_token": 3e-05,
+        "output_cost_per_image_token_batches": 1.5e-05,
         "output_cost_per_token": 7.5e-06,
         "output_cost_per_token_batches": 3.75e-06,
         "output_cost_per_token_priority": 1.35e-05,
@@ -74412,6 +74464,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.0336,
         "output_cost_per_image_token": 3e-05,
+        "output_cost_per_image_token_batches": 1.5e-05,
         "output_cost_per_token": 7.5e-06,
         "output_cost_per_token_batches": 3.75e-06,
         "output_cost_per_token_priority": 1.35e-05,
diff --git a/litellm/provider_endpoints_support_backup.json b/litellm/provider_endpoints_support_backup.json
index d73ac19bae1..0a6c2bcb2a9 100644
--- a/litellm/provider_endpoints_support_backup.json
+++ b/litellm/provider_endpoints_support_backup.json
@@ -3793,8 +3793,8 @@
         "responses": true,
         "text_completion": true,
         "embeddings": false,
-        "image_generations": false,
-        "image_edits": false,
+        "image_generations": true,
+        "image_edits": true,
         "audio_transcriptions": false,
         "audio_speech": false,
         "rerank": false,
diff --git a/litellm/proxy/agent_endpoints/a2a_endpoints.py b/litellm/proxy/agent_endpoints/a2a_endpoints.py
index 4691c7b0bc5..219ce906340 100644
--- a/litellm/proxy/agent_endpoints/a2a_endpoints.py
+++ b/litellm/proxy/agent_endpoints/a2a_endpoints.py
@@ -26,6 +26,7 @@ from litellm._logging import verbose_proxy_logger
 from litellm.litellm_core_utils.core_helpers import as_str_mapping
 from litellm.litellm_core_utils.url_utils import SSRFError, validate_url
 from litellm.llms.a2a.common_utils import resolve_a2a_hop_auth_header
+from litellm.llms.custom_httpx.sse_lines import aiter_sse_lines
 from litellm.proxy._types import UserAPIKeyAuth
 from litellm.proxy.a2a.version_convert import (
     A2AVersion,
@@ -320,7 +321,7 @@ async def _a2a_sse_event_source(
                 "error": {"code": -32603, "message": resp.reason_phrase},
             }
             return
-        async for line in resp.aiter_lines():
+        async for line in aiter_sse_lines(resp.aiter_text()):
             stripped = line.strip()
             if not stripped.startswith("data:"):
                 continue
diff --git a/litellm/proxy/anthropic_endpoints/streaming_model_restamp.py b/litellm/proxy/anthropic_endpoints/streaming_model_restamp.py
index f748a754fe0..32e0f6e8682 100644
--- a/litellm/proxy/anthropic_endpoints/streaming_model_restamp.py
+++ b/litellm/proxy/anthropic_endpoints/streaming_model_restamp.py
@@ -14,6 +14,8 @@ from typing import Final
 
 from pydantic import TypeAdapter, ValidationError
 
+from litellm.llms.custom_httpx.sse_lines import split_sse_lines_keepends
+
 _MESSAGE_START_EVENT: Final = "message_start"
 _MESSAGE_START_MARKER: Final = b"message_start"
 _SSE_DATA_FIELD: Final = "data:"
@@ -52,7 +54,7 @@ def _restamped_data_line(line: str, requested_model: str) -> str | None:
 
 
 def _restamped_frame(frame: str, requested_model: str) -> str | None:
-    lines: Final = frame.splitlines(keepends=True)
+    lines: Final = split_sse_lines_keepends(frame)
     restamped: Final = tuple(_restamped_data_line(line, requested_model) for line in lines)
     if all(line is None for line in restamped):
         return None
diff --git a/litellm/proxy/client/models.py b/litellm/proxy/client/models.py
index 1361a3e6364..859322f061d 100644
--- a/litellm/proxy/client/models.py
+++ b/litellm/proxy/client/models.py
@@ -3,9 +3,12 @@ from collections.abc import Mapping
 from typing import Any, Final
 
 import requests
+from pydantic import ConfigDict, TypeAdapter
 
 from .exceptions import NotFoundError, UnauthorizedError
 
+_JSON_OBJECT: Final = TypeAdapter(dict[str, object], config=ConfigDict(strict=True))
+
 
 class ModelsManagementClient:
     def __init__(self, base_url: str, api_key: str | None = None, timeout: int = 30):
@@ -109,7 +112,7 @@ class ModelsManagementClient:
         try:
             response: Final = session.send(request.prepare(), timeout=self._timeout)
             response.raise_for_status()
-            return response.json()
+            return _JSON_OBJECT.validate_python(response.json())
         except requests.exceptions.HTTPError as e:
             if e.response.status_code == 401:
                 raise UnauthorizedError(e)
@@ -145,7 +148,7 @@ class ModelsManagementClient:
         try:
             response: Final = session.send(request.prepare(), timeout=self._timeout)
             response.raise_for_status()
-            return response.json()
+            return _JSON_OBJECT.validate_python(response.json())
         except requests.exceptions.HTTPError as e:
             if e.response.status_code == 401:
                 raise UnauthorizedError(e)
@@ -287,7 +290,7 @@ class ModelsManagementClient:
         try:
             response: Final = session.send(request.prepare(), timeout=self._timeout)
             response.raise_for_status()
-            return response.json()
+            return _JSON_OBJECT.validate_python(response.json())
         except requests.exceptions.HTTPError as e:
             if e.response.status_code == 401:
                 raise UnauthorizedError(e)
diff --git a/litellm/proxy/common_request_processing.py b/litellm/proxy/common_request_processing.py
index f5d6417fb79..9bb451495c8 100644
--- a/litellm/proxy/common_request_processing.py
+++ b/litellm/proxy/common_request_processing.py
@@ -139,8 +139,8 @@ from litellm.proxy.utils import (  # noqa: F401  # legacy module exports
 )
 from litellm.responses.streaming_iterator import partial_responses_incomplete_event_on_disconnect, spawn_logging_task
 from litellm.router import Router
+from litellm.router_strategy.auto_router.auto_router_model_naming import AUTO_ROUTER_MODEL_PREFIX
 from litellm.router_utils.add_retry_fallback_headers import get_hidden_params_dict
-from litellm.router_utils.auto_router_model_naming import AUTO_ROUTER_MODEL_PREFIX
 from litellm.router_utils.common_utils import resolve_model_group_alias, resolve_served_model
 from litellm.types.extraction import ExtractionResponse
 from litellm.types.guardrails import GuardrailEventHooks
@@ -266,6 +266,8 @@ from litellm.proxy.anthropic_endpoints.streaming_model_restamp import (
     AnthropicStreamModelRestamper,
 )
 from litellm.proxy.litellm_pre_call_utils import (
+    ROUTER_SCHEDULED_ROUTE_TYPES,
+    SCHEDULER_PRIORITY_HEADER,
     LiteLLMProxyRequestSetup,
     add_litellm_data_to_request,
     get_metadata_variable_name,
@@ -2478,14 +2480,20 @@ class ProxyBaseLLMRequestProcessing:
                     self.data["model"] = alias_target
 
         aliased_model: Final = self.data.get("model")
+        if llm_router is not None and route_type in ROUTER_SCHEDULED_ROUTE_TYPES and isinstance(aliased_model, str):
+            self.data.update(
+                llm_router.priority_header_update(
+                    model=aliased_model, kwargs=self.data, header=request.headers.get(SCHEDULER_PRIORITY_HEADER)
+                )
+            )
 
         litellm_call_id: Final = resolve_litellm_call_id(request.headers.get("x-litellm-call-id"))
         self.data["litellm_call_id"] = litellm_call_id
         bind_telemetry_call_id(litellm_call_id)
-        DDSpanTagger.tag_call_id(self.data.get("litellm_call_id"))
+        DDSpanTagger.tag_call_id(litellm_call_id)
         DDSpanTagger.tag_request(
             user_api_key_dict=user_api_key_dict,
-            requested_model=self.data.get("model"),
+            requested_model=aliased_model,
         )
 
         ### AUTO STREAM USAGE TRACKING ###
diff --git a/litellm/proxy/db/accounting_ledger.py b/litellm/proxy/db/accounting_ledger.py
new file mode 100644
index 00000000000..91f8307283e
--- /dev/null
+++ b/litellm/proxy/db/accounting_ledger.py
@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import AsyncGenerator, Callable
+from contextlib import AbstractAsyncContextManager, asynccontextmanager
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING, Final, Literal, TypeAlias
+
+from pydantic import AwareDatetime, ConfigDict, JsonValue, TypeAdapter
+from typing_extensions import assert_never
+
+from litellm.accounting import CostEvent, DeliveryTarget, EventKind, InboundUsageEvent, OutboundUsageEvent
+from litellm.proxy.db.db_span import db_span
+from litellm.proxy.db.routing_prisma_wrapper import writer_wrapper
+
+if TYPE_CHECKING:
+    from prisma import Prisma
+
+    from litellm.proxy.utils import PrismaClient
+
+AccountingEvent: TypeAlias = InboundUsageEvent | OutboundUsageEvent | CostEvent
+_JSON: Final = TypeAdapter(dict[str, JsonValue])
+_INSTANT: Final[TypeAdapter[datetime]] = TypeAdapter(AwareDatetime)
+_STRINGS: Final = TypeAdapter(tuple[dict[str, str], ...])
+_TIMEOUT: Final = timedelta(seconds=10)
+
+
+class AccountingConflictError(ValueError):
+    pass
+
+
+_Transaction: TypeAlias = AbstractAsyncContextManager["Prisma"]
+
+
+@dataclass(frozen=True, slots=True)
+class _AcceptedEvent:
+    event_id: str
+    kind: EventKind
+    source_event_id: str | None
+    occurred_at: datetime
+    payload: str
+    payload_hash: str
+    targets: tuple[str, ...]
+    schema_version: int
+    version: int
+
+
+def _json(value: object) -> str:
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False)
+
+
+def _prepare(
+    event: AccountingEvent,
+    targets: tuple[DeliveryTarget, ...],
+    envelope: str,
+    schema_version: int,
+    version: int,
+) -> _AcceptedEvent:
+    if type(schema_version) is not int or type(version) is not int or min(schema_version, version) < 1:
+        raise ValueError("Accounting versions must be positive integers")
+    validated: Final = type(event).model_validate_json(event.model_dump_json())
+    payload: Final = _JSON.validate_json(envelope)
+    if payload.get("event") != validated.model_dump(mode="json"):
+        raise ValueError("Accounting envelope must contain the matching public event")
+    destinations: Final = tuple(sorted(frozenset(DeliveryTarget(target).value for target in targets)))
+    serialized: Final = _json(payload)
+    identity: Final = _json((schema_version, version, destinations, payload))
+    kind: Final = (
+        EventKind.COST
+        if isinstance(validated, CostEvent)
+        else EventKind.INBOUND_USAGE
+        if isinstance(validated, InboundUsageEvent)
+        else EventKind.OUTBOUND_USAGE
+    )
+    return _AcceptedEvent(
+        event_id=validated.event_id,
+        kind=kind,
+        source_event_id=validated.usage_event_id if isinstance(validated, CostEvent) else None,
+        occurred_at=validated.occurred_at if isinstance(validated, CostEvent) else validated.ended_at,
+        payload=serialized,
+        payload_hash=hashlib.sha256(identity.encode()).hexdigest(),
+        targets=destinations,
+        schema_version=schema_version,
+        version=version,
+    )
+
+
+_INSERT_EVENT: Final = """
+INSERT INTO "LiteLLM_AccountingEvent"
+    (event_id, kind, source_event_id, schema_version, payload_hash, occurred_at, payload)
+VALUES ($1, $2::"AccountingEventKind", $3, $4::int, $5, $6::timestamp, $7::jsonb)
+ON CONFLICT (event_id) DO NOTHING RETURNING event_id
+"""
+_INSERT_DELIVERIES: Final = """
+INSERT INTO "LiteLLM_AccountingDelivery" (event_id, target, version)
+SELECT $1, value::"AccountingDeliveryTarget", $3::int FROM jsonb_array_elements_text($2::jsonb)
+"""
+_LOCK_SOURCE: Final = """
+SELECT event_id FROM "LiteLLM_AccountingEvent"
+WHERE event_id = $1 AND kind = 'outbound_usage' FOR UPDATE
+"""
+_EXISTING_COST: Final = """
+SELECT event_id FROM "LiteLLM_AccountingEvent" WHERE kind = 'cost' AND source_event_id = $1
+"""
+_LOCK_EVENT: Final = """
+SELECT payload_hash FROM "LiteLLM_AccountingEvent" WHERE event_id = $1 FOR UPDATE
+"""
+_COMPLETED_FAMILY: Final = """
+root.source_event_id IS NULL AND root.kind IN ('inbound_usage', 'outbound_usage')
+AND root.recorded_at < $1::timestamp
+AND (root.kind = 'inbound_usage' OR EXISTS (
+    SELECT 1 FROM "LiteLLM_AccountingEvent" AS cost WHERE cost.source_event_id = root.event_id AND cost.kind = 'cost'
+))
+AND NOT EXISTS (
+    SELECT 1 FROM "LiteLLM_AccountingEvent" AS member
+    WHERE (member.event_id = root.event_id OR (member.kind = 'cost' AND member.source_event_id = root.event_id))
+    AND (member.recorded_at >= $1::timestamp
+        OR EXISTS (SELECT 1 FROM "LiteLLM_AccountingDelivery" AS delivery
+            WHERE delivery.event_id = member.event_id AND delivery.state != 'applied'))
+)
+"""
+_RETENTION_CANDIDATES: Final = (
+    'SELECT root.event_id FROM "LiteLLM_AccountingEvent" AS root WHERE '
+    + _COMPLETED_FAMILY
+    + " ORDER BY root.recorded_at, root.event_id LIMIT $2::int FOR UPDATE OF root SKIP LOCKED"
+)
+_ELIGIBLE_GROUP: Final = (
+    'SELECT root.event_id FROM "LiteLLM_AccountingEvent" AS root WHERE root.event_id = $2 AND ' + _COMPLETED_FAMILY
+)
+_DELETE_DELIVERIES: Final = """
+DELETE FROM "LiteLLM_AccountingDelivery" WHERE event_id IN (
+    SELECT event_id FROM "LiteLLM_AccountingEvent" WHERE event_id = $1 OR (kind = 'cost' AND source_event_id = $1)
+)
+"""
+_DELETE_EVENTS: Final = """
+DELETE FROM "LiteLLM_AccountingEvent" WHERE event_id = $1 OR (kind = 'cost' AND source_event_id = $1)
+"""
+
+
+_Conflict: TypeAlias = Literal["missing_source", "competing_cost", "identity_conflict"]
+
+
+async def _accept(db: Prisma, record: _AcceptedEvent) -> Literal["inserted", "duplicate"] | _Conflict:
+    if record.source_event_id is not None:
+        source: Final = _STRINGS.validate_python(await db.query_raw(_LOCK_SOURCE, record.source_event_id))
+        if not source:
+            return "missing_source"
+        costs: Final = _STRINGS.validate_python(tuple(await db.query_raw(_EXISTING_COST, record.source_event_id)))
+        if any(cost["event_id"] != record.event_id for cost in costs):
+            return "competing_cost"
+    inserted: Final = _STRINGS.validate_python(
+        await db.query_raw(
+            _INSERT_EVENT,
+            record.event_id,
+            record.kind.value,
+            record.source_event_id,
+            record.schema_version,
+            record.payload_hash,
+            record.occurred_at.astimezone(timezone.utc).isoformat(),
+            record.payload,
+        )
+    )
+    if not inserted:
+        existing: Final = _STRINGS.validate_python(tuple(await db.query_raw(_LOCK_EVENT, record.event_id)))
+        if not existing or existing[0]["payload_hash"] != record.payload_hash:
+            return "identity_conflict"
+        return "duplicate"
+    await db.execute_raw(_INSERT_DELIVERIES, record.event_id, _json(record.targets), record.version)
+    return "inserted"
+
+
+async def _delete_completed(db: Prisma, event_id: str, cutoff: str) -> int:
+    if not _STRINGS.validate_python(await db.query_raw(_ELIGIBLE_GROUP, cutoff, event_id)):
+        return 0
+    await db.execute_raw(_DELETE_DELIVERIES, event_id)
+    return await db.execute_raw(_DELETE_EVENTS, event_id)
+
+
+class AccountingLedger:
+    def __init__(self, transaction: Callable[[], _Transaction]) -> None:
+        self._transaction: Final = transaction
+
+    @classmethod
+    def for_client(cls, client: PrismaClient) -> AccountingLedger:
+        from prisma.client import TransactionManager
+
+        managers: Final = TypeAdapter(TransactionManager, config=ConfigDict(arbitrary_types_allowed=True))
+
+        @asynccontextmanager
+        async def transaction() -> AsyncGenerator[Prisma]:
+            primary: Final = writer_wrapper(client.db)
+            manager: Final = managers.validate_python(primary.tx(timeout=_TIMEOUT))
+            async with db_span("accounting_ledger", "LiteLLM_AccountingEvent"), manager as db:
+                await db.execute_raw("SET LOCAL statement_timeout = 5000")
+                await db.execute_raw("SET LOCAL lock_timeout = 1000")
+                yield db
+
+        return cls(transaction)
+
+    async def insert_event(
+        self,
+        event: AccountingEvent,
+        targets: tuple[DeliveryTarget, ...],
+        *,
+        envelope: str,
+        schema_version: int = 1,
+        version: int = 1,
+    ) -> Literal["inserted", "duplicate"]:
+        """Accept T5/T6's serialized envelope, containing its public event under `event`.
+
+        The immutable acceptance hash includes the target set and delivery version.
+        Changing either for an accepted event conflicts. T7 must provide a separate
+        add-target or new-version workflow that preserves receipts and prevents
+        duplicate contributions; redelivery cannot silently create or reset work.
+
+        The Prisma adapter opens one interactive transaction per event, including
+        two SET LOCAL statements and a source-row lock for costs. I/O is async,
+        but awaiting this method inline adds commit latency per event, potentially
+        several times per request. T5 owns bounded asynchronous capture and an
+        explicit batching strategy; looping over this method does not batch commits.
+        Success acknowledges commit, independently of HTTP response acknowledgement.
+        """
+        record: Final = _prepare(event, targets, envelope, schema_version, version)
+        async with self._transaction() as db:
+            result: Final = await _accept(db, record)
+        match result:
+            case "inserted" | "duplicate":
+                return result
+            case "missing_source":
+                raise AccountingConflictError("Cost source must be a durably accepted outbound usage event")
+            case "competing_cost":
+                raise AccountingConflictError("Usage event already has an authoritative cost")
+            case "identity_conflict":
+                raise AccountingConflictError("Event identity conflicts with its accepted content or delivery set")
+            case _:
+                assert_never(result)
+
+    async def purge_completed(
+        self,
+        *,
+        redelivery_before: datetime | None = None,
+        recovery_before: datetime | None = None,
+        limit: int = 100,
+    ) -> int:
+        """Delete at most `limit` completed families once both retention owners permit it.
+
+        T8 must supply a coherent recovery watermark including outstanding holds.
+        Omitting either watermark disables deletion. Each usage row and its cost
+        remain together so a retained charge never loses its source or vice versa.
+        Applied receipts are deleted with the family, ending its retained dedup
+        protection. The caller must guarantee events recorded before
+        redelivery_before cannot be redelivered through supported paths.
+        T8's recovery_before must also protect checkpoints,
+        outstanding holds and unfinished settlements; age alone is insufficient.
+        """
+        if type(limit) is not int or not 1 <= limit <= 1000:
+            raise ValueError("Accounting retention batch size must be between 1 and 1000")
+        if redelivery_before is None or recovery_before is None:
+            return 0
+        cutoff: Final = min(
+            _INSTANT.validate_python(redelivery_before).astimezone(timezone.utc),
+            _INSTANT.validate_python(recovery_before).astimezone(timezone.utc),
+        ).isoformat()
+        async with self._transaction() as db:
+            roots: Final = _STRINGS.validate_python(tuple(await db.query_raw(_RETENTION_CANDIDATES, cutoff, limit)))
+            deleted: Final = tuple([await _delete_completed(db, root["event_id"], cutoff) for root in roots])
+        return sum(deleted)
diff --git a/litellm/proxy/guardrails/auto_router_compression.py b/litellm/proxy/guardrails/auto_router_compression.py
index 1267fb15db8..3071bcbb1dc 100644
--- a/litellm/proxy/guardrails/auto_router_compression.py
+++ b/litellm/proxy/guardrails/auto_router_compression.py
@@ -14,7 +14,7 @@ from typing import TYPE_CHECKING, Final
 
 from litellm._logging import verbose_proxy_logger
 from litellm.litellm_core_utils.core_helpers import get_or_create_metadata_bucket
-from litellm.router_utils.auto_router_model_naming import AUTO_ROUTER_MODEL_PREFIX
+from litellm.router_strategy.auto_router.auto_router_model_naming import AUTO_ROUTER_MODEL_PREFIX
 from litellm.types.utils import GenericGuardrailAPIInputs
 
 if TYPE_CHECKING:
diff --git a/litellm/proxy/guardrails/guardrail_hooks/openai/moderations.py b/litellm/proxy/guardrails/guardrail_hooks/openai/moderations.py
index 98be35079c3..16b3c45f6f8 100644
--- a/litellm/proxy/guardrails/guardrail_hooks/openai/moderations.py
+++ b/litellm/proxy/guardrails/guardrail_hooks/openai/moderations.py
@@ -169,7 +169,7 @@ class OpenAIModerationGuardrail(OpenAIGuardrailBase, CustomGuardrail):
 
         from litellm.types.llms.openai import OpenAIModerationResponse
 
-        return OpenAIModerationResponse(**response.json())
+        return OpenAIModerationResponse.model_validate(response.json())
 
     def _check_moderation_result(self, moderation_response: "OpenAIModerationResponse") -> None:
         """
diff --git a/litellm/proxy/health_check.py b/litellm/proxy/health_check.py
index 0d2f8dc9a0c..be32405154c 100644
--- a/litellm/proxy/health_check.py
+++ b/litellm/proxy/health_check.py
@@ -27,7 +27,7 @@ from litellm.constants import (
     HEALTH_CHECK_TIMEOUT_SECONDS,
 )
 from litellm.litellm_core_utils.health_check_helpers import native_health_check_mode
-from litellm.router_utils.auto_router_model_naming import (
+from litellm.router_strategy.auto_router.auto_router_model_naming import (
     StrategyRouterDependency,
     classify_strategy_router_model,
     strategy_router_dependencies,
diff --git a/litellm/proxy/hooks/autorouter_baseline_cache.py b/litellm/proxy/hooks/autorouter_baseline_cache.py
index c4232609124..1147ce7ec12 100644
--- a/litellm/proxy/hooks/autorouter_baseline_cache.py
+++ b/litellm/proxy/hooks/autorouter_baseline_cache.py
@@ -37,8 +37,8 @@ from litellm.proxy.spend_tracking.savings import (
     _effective_model_info,  # pyright: ignore[reportPrivateUsage]  # existing deployment-price owner
     _proxy_llm_router,  # pyright: ignore[reportPrivateUsage]  # existing optional proxy-router owner
 )
+from litellm.router_strategy.auto_router.baseline_request import baseline_request
 from litellm.router_strategy.complexity_router.context_compaction import compaction_applied
-from litellm.router_utils.baseline_request import baseline_request
 from litellm.types.llms.base import LiteLLMBaseModel
 from litellm.types.router import BaselineRouteStamp
 from litellm.types.utils import CallTypes, ModelInfo, Usage
diff --git a/litellm/proxy/hooks/model_max_budget_limiter.py b/litellm/proxy/hooks/model_max_budget_limiter.py
index 11a47b2d424..1c4a61cfad8 100644
--- a/litellm/proxy/hooks/model_max_budget_limiter.py
+++ b/litellm/proxy/hooks/model_max_budget_limiter.py
@@ -19,6 +19,7 @@ from litellm._internal_context import with_service_target
 from litellm._logging import verbose_proxy_logger
 from litellm.caching.caching import DualCache
 from litellm.integrations.custom_logger import Span
+from litellm.litellm_core_utils.batch_utils import batch_charged_once_marker_key, batch_id_to_charge_once
 from litellm.litellm_core_utils.duration_parser import duration_in_seconds
 from litellm.litellm_core_utils.litellm_logging import StandardLoggingPayloadSetup
 from litellm.llms.bedrock.common_utils import get_bedrock_base_model, get_bedrock_cross_region_inference_regions
@@ -30,7 +31,6 @@ from litellm.proxy.hooks.model_budget_shared_windows import (
     SharedWindows,
 )
 from litellm.router_strategy.budget_limiter import RouterBudgetLimiting, budget_window_seconds
-from litellm.router_utils.batch_utils import batch_charged_once_marker_key, batch_id_to_charge_once
 from litellm.types.llms.openai import AllMessageValues
 from litellm.types.utils import BudgetConfig, LlmProviders, StandardLoggingPayload
 
diff --git a/litellm/proxy/litellm_pre_call_utils.py b/litellm/proxy/litellm_pre_call_utils.py
index 24a31723faa..2c05f724374 100644
--- a/litellm/proxy/litellm_pre_call_utils.py
+++ b/litellm/proxy/litellm_pre_call_utils.py
@@ -118,6 +118,9 @@ _SESSION_ID_VALUE_RE: Final = re.compile(r"^[a-zA-Z0-9_\-]{8,}$")
 
 _SHA256_HEX_RE: Final = re.compile(r"^[0-9a-f]{64}$")
 
+SCHEDULER_PRIORITY_HEADER: Final = "x-litellm-priority"
+ROUTER_SCHEDULED_ROUTE_TYPES: Final = frozenset({"acompletion", "atext_completion"})
+
 # W3C Trace Context traceparent header: https://www.w3.org/TR/trace-context/
 # e.g. "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01"
 _TRACEPARENT_RE: Final = re.compile(r"^[0-9a-f]{2}-([0-9a-f]{32})-[0-9a-f]{16}-[0-9a-f]{2}$", re.IGNORECASE)
@@ -688,7 +691,7 @@ def _metadata_string_tags(metadata_objects: Iterable[Mapping[str, object]]) -> t
 
 
 def _strip_untrusted_request_header_controls(
-    headers: Any,
+    headers: object,
     *,
     allow_client_message_redaction_opt_out: bool = False,
 ) -> None:
@@ -1692,7 +1695,7 @@ class LiteLLMProxyRequestSetup:
 
     @staticmethod
     def add_internal_user_from_user_mapping(
-        general_settings: dict | None,
+        general_settings: Mapping[str, object] | None,
         user_api_key_dict: UserAPIKeyAuth,
         headers: dict,
     ) -> UserAPIKeyAuth:
@@ -1711,7 +1714,7 @@ class LiteLLMProxyRequestSetup:
         return user_api_key_dict
 
     @staticmethod
-    def get_user_from_headers(headers: dict, general_settings: dict | None = None) -> str | None:
+    def get_user_from_headers(headers: dict, general_settings: Mapping[str, object] | None = None) -> str | None:
         """
         Get the user from the specified header if `general_settings.user_header_name` is set.
         """
@@ -1732,7 +1735,9 @@ class LiteLLMProxyRequestSetup:
         return user
 
     @staticmethod
-    def get_openai_org_id_from_headers(headers: dict, general_settings: dict | None = None) -> str | None:
+    def get_openai_org_id_from_headers(
+        headers: dict, general_settings: Mapping[str, object] | None = None
+    ) -> str | None:
         """
         Get the OpenAI Org ID from the headers.
         """
@@ -1823,7 +1828,7 @@ class LiteLLMProxyRequestSetup:
         headers: dict,
         request_data: Mapping[str, object],
         user_api_key_dict: UserAPIKeyAuth,
-        general_settings: dict[str, object] | None = None,
+        general_settings: Mapping[str, object] | None = None,
     ) -> LitellmDataForBackendLLMCall:
         """
         - Adds user from headers
@@ -3285,7 +3290,7 @@ def _per_user_credential_names_for_groups(
         GITHUB_COPILOT_AUTH_TYPE_KEY,
         GITHUB_COPILOT_PER_USER_AUTH_TYPE,
     )
-    from litellm.router_utils.auto_router_model_naming import classify_strategy_router_model
+    from litellm.router_strategy.auto_router.auto_router_model_naming import classify_strategy_router_model
 
     names: Final[list[str]] = []  # mutable-ok: accumulates one name per per-user deployment
     for group in model_groups:
diff --git a/litellm/proxy/management_endpoints/auto_router_endpoints.py b/litellm/proxy/management_endpoints/auto_router_endpoints.py
index 7a843aecc0c..3dceab6b7f7 100644
--- a/litellm/proxy/management_endpoints/auto_router_endpoints.py
+++ b/litellm/proxy/management_endpoints/auto_router_endpoints.py
@@ -60,16 +60,16 @@ from litellm.repositories.table_repositories import PrismaTableRepository
 from litellm.repositories.team_repository import TeamRepository
 from litellm.repositories.user_repository import UserRepository
 from litellm.repositories.verification_token_repository import VerificationTokenRepository
+from litellm.router_strategy.auto_router.auto_router_model_naming import (
+    StrategyRouterDependencyRole,
+    classify_strategy_router_model,
+    strategy_router_dependencies,
+)
 from litellm.router_strategy.complexity_router import ComplexityRouter
 from litellm.router_strategy.complexity_router.request_models import (
     AutoRouterRoutingTestRequest,
     RequestComplexityRouterConfig,
 )
-from litellm.router_utils.auto_router_model_naming import (
-    StrategyRouterDependencyRole,
-    classify_strategy_router_model,
-    strategy_router_dependencies,
-)
 from litellm.types.llms.base import LiteLLMBaseModel
 from litellm.types.management_endpoints.auto_router_endpoints import (
     SHADOW_EVAL_TURN_VALVE,
@@ -231,9 +231,12 @@ def _shadow_eval_attempts(prisma_client: "PrismaClient") -> _ShadowEvalAttemptTa
     return _ShadowEvalAttemptRepository(prisma_client).table
 
 
+_RAW_ROWS: Final = TypeAdapter(Sequence[dict[str, object]], config=ConfigDict(strict=True))
+
+
 async def _query_raw(prisma_client: "PrismaClient", query: str, *args: object) -> Sequence[Mapping[str, object]]:
     async with db_span("auto_router_report_query", sql_relation(query)):
-        return await prisma_client.db.query_raw(query, *args)
+        return _RAW_ROWS.validate_python(await prisma_client.db.query_raw(query, *args))
 
 
 async def _execute_raw(prisma_client: "PrismaClient", query: str, *args: object) -> int:
@@ -408,7 +411,7 @@ async def validate_complexity_router_config(
         auto_router_environment_reference_error(data.complexity_router_config, user_api_key_dict)
     )
 
-    from litellm.router_utils.auto_router_model_naming import (
+    from litellm.router_strategy.auto_router.auto_router_model_naming import (
         validate_complexity_router_config_write,
     )
 
diff --git a/litellm/proxy/management_endpoints/model_management_endpoints.py b/litellm/proxy/management_endpoints/model_management_endpoints.py
index 45006b14df6..8cd3559ba86 100644
--- a/litellm/proxy/management_endpoints/model_management_endpoints.py
+++ b/litellm/proxy/management_endpoints/model_management_endpoints.py
@@ -131,6 +131,23 @@ from litellm.repositories.project_repository import ProjectRepository
 from litellm.repositories.table_repositories import ModelTableRepository
 from litellm.repositories.team_repository import TeamRepository
 from litellm.router import Router
+from litellm.router_strategy.auto_router.auto_router_model_naming import (
+    GATED_AUTO_ROUTER_CAPABILITIES,
+    STRATEGY_ROUTER_PARAM_FIELDS,
+    GatedAutoRouterCapability,
+    capability_limit_violation,
+    carries_complexity_router_settings,
+    count_capability_routers,
+    gated_capabilities_of,
+    is_complexity_router_model,
+    validate_complexity_router_config_placement,
+    validate_complexity_router_config_write,
+    validate_strategy_router_model_write,
+)
+from litellm.router_strategy.auto_router.auto_router_tuning_baseline import (
+    is_mutable_tuned_candidate,
+    tuning_quota_violation,
+)
 from litellm.router_strategy.complexity_router import (
     DEFAULT_CLASSIFIER_CONTEXT_WINDOW_SIZE,
     ClassificationRubric,
@@ -144,20 +161,6 @@ from litellm.router_strategy.complexity_router import (
     normalize_classification_prompt,
 )
 from litellm.router_strategy.complexity_router.config import resolve_complexity_router_config_write
-from litellm.router_utils.auto_router_model_naming import (
-    GATED_AUTO_ROUTER_CAPABILITIES,
-    STRATEGY_ROUTER_PARAM_FIELDS,
-    GatedAutoRouterCapability,
-    capability_limit_violation,
-    carries_complexity_router_settings,
-    count_capability_routers,
-    gated_capabilities_of,
-    is_complexity_router_model,
-    validate_complexity_router_config_placement,
-    validate_complexity_router_config_write,
-    validate_strategy_router_model_write,
-)
-from litellm.router_utils.auto_router_tuning_baseline import is_mutable_tuned_candidate, tuning_quota_violation
 from litellm.types.llms.base import LiteLLMBaseModel
 from litellm.types.llms.bedrock import AwsSessionTag
 from litellm.types.proxy.management_endpoints.model_management_endpoints import (
diff --git a/litellm/proxy/management_endpoints/router_settings_endpoints.py b/litellm/proxy/management_endpoints/router_settings_endpoints.py
index 1f4ca442d20..41c4b5cfaf7 100644
--- a/litellm/proxy/management_endpoints/router_settings_endpoints.py
+++ b/litellm/proxy/management_endpoints/router_settings_endpoints.py
@@ -10,7 +10,7 @@ GET /router/fields - Get router settings field definitions without values (for U
 import inspect
 from collections.abc import Mapping
 from types import MappingProxyType
-from typing import Any, Final, get_args
+from typing import Final, get_args
 
 from fastapi import APIRouter, Depends
 from pydantic import Field
@@ -32,7 +32,7 @@ router: Final = APIRouter()
 
 class RouterSettingsResponse(LiteLLMBaseModel):
     fields: list[RouterSettingsField] = Field(description="List of all configurable router settings with metadata")
-    current_values: dict[str, Any] = Field(description="Current values of router settings")
+    current_values: dict[str, object] = Field(description="Current values of router settings")
     routing_strategy_descriptions: dict[str, str] = Field(description="Descriptions for each routing strategy option")
     routing_group_strategies: tuple[str, ...] = Field(
         description="Strategies supported when constructing a routing group"
diff --git a/litellm/proxy/management_helpers/auto_router_availability.py b/litellm/proxy/management_helpers/auto_router_availability.py
index 9b511ce0817..ce7859aff2d 100644
--- a/litellm/proxy/management_helpers/auto_router_availability.py
+++ b/litellm/proxy/management_helpers/auto_router_availability.py
@@ -7,14 +7,14 @@ from typing import Final
 from pydantic import Json, TypeAdapter, ValidationError
 
 from litellm.proxy.common_utils.encrypt_decrypt_utils import decrypt_value_helper
-from litellm.router_utils.auto_router_model_naming import (
+from litellm.router_strategy.auto_router.auto_router_model_naming import (
     GATED_AUTO_ROUTER_CAPABILITIES,
     capability_limit_violation,
     classify_strategy_router_model,
     count_capability_routers,
     gated_capabilities_of,
 )
-from litellm.router_utils.auto_router_tuning_baseline import (
+from litellm.router_strategy.auto_router.auto_router_tuning_baseline import (
     is_mutable_tuned_candidate,
     mutable_tuned_identities,
     tuning_quota_violation,
diff --git a/litellm/proxy/management_helpers/auto_router_permissions.py b/litellm/proxy/management_helpers/auto_router_permissions.py
index 995446db7a6..8597f0d3667 100644
--- a/litellm/proxy/management_helpers/auto_router_permissions.py
+++ b/litellm/proxy/management_helpers/auto_router_permissions.py
@@ -34,13 +34,16 @@ from litellm.repositories.prisma_protocols import DatabaseClient
 from litellm.repositories.project_repository import ProjectRepository
 from litellm.repositories.table_repositories import TeamMembershipRepository
 from litellm.router import Router
+from litellm.router_strategy.auto_router.auto_router_model_naming import (
+    classify_strategy_router_model,
+    strategy_router_dependencies,
+)
 from litellm.router_strategy.complexity_router.config import (
     ComplexityRouterConfigWrite,
     normalize_classifier_config_aliases,
     resolve_complexity_router_config_write,
 )
 from litellm.router_strategy.complexity_router.request_models import RequestComplexityRouterConfig
-from litellm.router_utils.auto_router_model_naming import classify_strategy_router_model, strategy_router_dependencies
 from litellm.types.llms.base import LiteLLMBaseModel
 from litellm.types.router import Deployment, updateDeployment
 
diff --git a/litellm/proxy/management_helpers/team_roster_sync.py b/litellm/proxy/management_helpers/team_roster_sync.py
index dc0ba2e47d4..08be455a55d 100644
--- a/litellm/proxy/management_helpers/team_roster_sync.py
+++ b/litellm/proxy/management_helpers/team_roster_sync.py
@@ -40,6 +40,7 @@ from litellm.proxy.management_helpers.access_group_team_sync import (
 )
 from litellm.proxy.utils import PrismaClient, ProxyLogging
 from litellm.repositories.chunked_in import delete_many_in, find_many_in, update_many_in
+from litellm.repositories.team_repository import TeamRepository
 
 if TYPE_CHECKING:
     from prisma import Prisma
@@ -144,7 +145,7 @@ def _changes_nothing(plan: RosterPlan) -> bool:
 
 
 async def _unchanged_roster(prisma_client: PrismaClient, team_id: str) -> RosterSync | TeamGone:
-    team_row: Final = await prisma_client.writer_db.litellm_teamtable.find_unique(where={"team_id": team_id})
+    team_row: Final = await TeamRepository(prisma_client, use_writer=True).table.find_unique(where={"team_id": team_id})
     if team_row is None:
         return TeamGone(team_id=team_id)
     team: Final = LiteLLM_TeamTable.model_validate(team_row.model_dump())
diff --git a/litellm/proxy/mcp_server/discoverable_endpoints.py b/litellm/proxy/mcp_server/discoverable_endpoints.py
index eb12b15cdae..07a267d6caa 100644
--- a/litellm/proxy/mcp_server/discoverable_endpoints.py
+++ b/litellm/proxy/mcp_server/discoverable_endpoints.py
@@ -300,12 +300,13 @@ def decode_state_hash(encrypted_state: str) -> dict:
     if decrypted_json is None:
         raise ValueError("Failed to decrypt state parameter")
 
-    state_data: Final = json.loads(decrypted_json)
+    state_data: Final = _DECODED_STATE.validate_python(json.loads(decrypted_json))
     return state_data
 
 
 _MANAGED_AUTH_CODE_PREFIX: Final = "llm_scope_"
 _DECODED_JSON: Final = TypeAdapter(object)
+_DECODED_STATE: Final = TypeAdapter(dict[str, object], config=ConfigDict(strict=True))
 
 
 class _ManagedAuthorizationCode(LiteLLMBaseModel):
diff --git a/litellm/proxy/pass_through_endpoints/llm_provider_handlers/anthropic_passthrough_logging_handler.py b/litellm/proxy/pass_through_endpoints/llm_provider_handlers/anthropic_passthrough_logging_handler.py
index 7c7eb51bc5d..5415314f29b 100644
--- a/litellm/proxy/pass_through_endpoints/llm_provider_handlers/anthropic_passthrough_logging_handler.py
+++ b/litellm/proxy/pass_through_endpoints/llm_provider_handlers/anthropic_passthrough_logging_handler.py
@@ -29,6 +29,7 @@ from litellm.llms.anthropic.messages.stream_assembly import (
     split_sse_chunk_into_events,
 )
 from litellm.llms.bedrock.common_utils import BEDROCK_INVOKE_TRACE_FIELD
+from litellm.llms.custom_httpx.sse_lines import split_sse_lines
 from litellm.proxy._types import PassThroughEndpointLoggingTypedDict
 from litellm.proxy.auth.auth_utils import get_end_user_id_from_request_body
 from litellm.proxy.pass_through_endpoints.llm_provider_handlers.batch_attribution import (
@@ -61,7 +62,7 @@ _JSON_OBJECT: Final = TypeAdapter(Mapping[str, object], config=ConfigDict(hide_i
 
 def _event_payload(event: str) -> Mapping[str, object] | None:
     data_lines: Final = tuple(
-        line.strip()[len("data:") :].strip() for line in event.splitlines() if line.strip().startswith("data:")
+        line.strip()[len("data:") :].strip() for line in split_sse_lines(event) if line.strip().startswith("data:")
     )
     if not data_lines or data_lines[0] in ("", "[DONE]"):
         return None
@@ -362,7 +363,7 @@ class AnthropicPassthroughLoggingHandler:
     ) -> str | None:
         for raw in all_chunks:
             text = raw.decode("utf-8") if isinstance(raw, bytes) else raw
-            for line in text.splitlines():
+            for line in split_sse_lines(text):
                 if not line.startswith("data:"):
                     continue
                 try:
@@ -402,7 +403,7 @@ class AnthropicPassthroughLoggingHandler:
         """
         for raw in reversed(all_chunks):
             text = raw.decode("utf-8") if isinstance(raw, bytes) else raw
-            for line in reversed(text.splitlines()):
+            for line in reversed(split_sse_lines(text)):
                 if not line.startswith("data:"):
                     continue
                 try:
diff --git a/litellm/proxy/pass_through_endpoints/llm_provider_handlers/tinyfish_passthrough_logging_handler.py b/litellm/proxy/pass_through_endpoints/llm_provider_handlers/tinyfish_passthrough_logging_handler.py
index 2afc1d17bc2..0c4a3f64852 100644
--- a/litellm/proxy/pass_through_endpoints/llm_provider_handlers/tinyfish_passthrough_logging_handler.py
+++ b/litellm/proxy/pass_through_endpoints/llm_provider_handlers/tinyfish_passthrough_logging_handler.py
@@ -21,6 +21,7 @@ from litellm.llms.custom_httpx.http_handler import (
     AsyncHTTPHandler,
     get_async_httpx_client,
 )
+from litellm.llms.custom_httpx.sse_lines import split_sse_lines
 from litellm.proxy._types import PassThroughEndpointLoggingTypedDict
 from litellm.types.llms.custom_http import httpxSpecialProvider
 from litellm.types.passthrough_endpoints.tinyfish import (
@@ -81,7 +82,7 @@ def sse_poller_spawned(logging_obj: LiteLLMLoggingObj) -> bool:
 
 
 def run_id_from_sse_frames(frames: bytes) -> str | None:
-    return _run_id_from_sse_chunks(frames.decode("utf-8", errors="replace").splitlines())
+    return _run_id_from_sse_chunks(split_sse_lines(frames.decode("utf-8", errors="replace")))
 
 
 def resolve_tinyfish_agent_api_base() -> str:
diff --git a/litellm/proxy/pass_through_endpoints/managed_id_rewriter.py b/litellm/proxy/pass_through_endpoints/managed_id_rewriter.py
index 9790c150ae1..cae8ccc93ee 100644
--- a/litellm/proxy/pass_through_endpoints/managed_id_rewriter.py
+++ b/litellm/proxy/pass_through_endpoints/managed_id_rewriter.py
@@ -51,6 +51,7 @@ from litellm.llms.base_llm.managed_resources.isolation import (
     can_access_resource,
     resolve_resource_owner_id,
 )
+from litellm.llms.custom_httpx.sse_lines import split_sse_lines
 from litellm.proxy._types import UserAPIKeyAuth
 from litellm.proxy.batches_endpoints.common_utils import validate_batch_list_limit
 from litellm.proxy.common_utils.sse_keepalive import split_complete_sse_frames
@@ -830,7 +831,7 @@ _SSE_EVENT_ADAPTER: Final = TypeAdapter(Mapping[str, JsonValue])
 
 
 def _first_streamed_response(frames: bytes) -> tuple[str, Mapping[str, JsonValue]] | None:
-    for line in frames.decode("utf-8", errors="replace").splitlines():
+    for line in split_sse_lines(frames.decode("utf-8", errors="replace")):
         if not line.startswith(_SSE_DATA_PREFIX):
             continue
         try:
diff --git a/litellm/proxy/pass_through_endpoints/pass_through_endpoints.py b/litellm/proxy/pass_through_endpoints/pass_through_endpoints.py
index 650dcae3239..e017eee3d27 100644
--- a/litellm/proxy/pass_through_endpoints/pass_through_endpoints.py
+++ b/litellm/proxy/pass_through_endpoints/pass_through_endpoints.py
@@ -30,6 +30,7 @@ from pydantic import TypeAdapter
 from starlette.datastructures import UploadFile as StarletteUploadFile
 from starlette.routing import BaseRoute, Route
 from starlette.websockets import WebSocketState
+from typing_extensions import ReadOnly
 from websockets.asyncio.client import connect
 from websockets.exceptions import (
     ConnectionClosedError,
@@ -173,8 +174,17 @@ def _is_mergeable_client_metadata(key: str, value: object) -> bool:
     return not key.startswith("user_api_key_") and (key != "model_info" or isinstance(value, Mapping))
 
 
+class _RegisteredPassThroughRoute(TypedDict):
+    endpoint_id: ReadOnly[str]
+    path: ReadOnly[str | None]
+    type: ReadOnly[str]
+    methods: ReadOnly[str | bool | list[str] | tuple[str, ...] | Mapping[str, object]]
+    auth: ReadOnly[bool]
+    passthrough_params: ReadOnly[Mapping[str, object]]
+
+
 # Global registry to track registered pass-through routes and prevent memory leaks
-_registered_pass_through_routes: Final[dict[str, dict[str, str | bool | list[str] | Mapping[str, object]]]] = {}
+_registered_pass_through_routes: Final[dict[str, _RegisteredPassThroughRoute]] = {}
 
 
 def get_response_body(response: httpx.Response) -> dict | None:
@@ -2239,7 +2249,7 @@ def create_pass_through_route(
                     status_code=status.HTTP_405_METHOD_NOT_ALLOWED,
                     detail=f"Method {request.method} is not allowed for pass-through endpoint {path}.",
                 )
-            target_params: Final = {
+            target_params: Final[dict[str, object]] = {
                 "target": target,
                 "custom_headers": custom_headers,
                 "forward_headers": _forward_headers,
@@ -2271,7 +2281,9 @@ def create_pass_through_route(
 
             # Ensure custom_headers is a dict. Botocore returns a HeadersDict
             # for SigV4-prepared requests, which is a Mapping but not a dict.
-            headers_dict: Final = dict(param_custom_headers) if isinstance(param_custom_headers, Mapping) else {}
+            headers_dict: Final[dict[str, object]] = (
+                {**param_custom_headers} if isinstance(param_custom_headers, Mapping) else {}
+            )
 
             # Ensure query_params and custom_body are dicts or None
             final_query_params: Final = query_params_data if isinstance(query_params_data, dict) else {}
@@ -3104,9 +3116,7 @@ class SafeRouteAdder:
                 return f"{path}/{{subpath:path}}"
             return None
 
-        def registered_route_methods(
-            route_info: Mapping[str, str | bool | Sequence[str] | Mapping[str, object]],
-        ) -> tuple[tuple[str, str], ...]:
+        def registered_route_methods(route_info: _RegisteredPassThroughRoute) -> tuple[tuple[str, str], ...]:
             starlette_path: Final = registered_route_path(route_info)
             methods: Final = route_info.get("methods")
             if starlette_path is None or not isinstance(methods, (list, tuple)):
@@ -3462,7 +3472,7 @@ class InitPassThroughEndpointHelpers:
         return (comparison_route, *forwarded)
 
     @staticmethod
-    def get_registered_pass_through_route(route: str, method: str | None = None) -> dict[str, Any] | None:
+    def get_registered_pass_through_route(route: str, method: str | None = None) -> _RegisteredPassThroughRoute | None:
         """Get passthrough params for a given route and optionally filter by HTTP method"""
         comparison_route: Final = InitPassThroughEndpointHelpers._route_for_registry_lookup(route)
         for key in _registered_pass_through_routes:
diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py
index 64fb2791913..b263412ce0f 100644
--- a/litellm/proxy/proxy_server.py
+++ b/litellm/proxy/proxy_server.py
@@ -168,12 +168,7 @@ from litellm.proxy.common_utils.token_count_settings import (
 )
 from litellm.proxy.management_helpers.auto_router_availability import AutoRouterCatalogEntry, build_auto_router_catalog
 from litellm.proxy.management_helpers.model_group_custom_fields import model_group_custom_fields
-from litellm.router_utils.access_windows import access_windows_config_error
-from litellm.router_utils.add_retry_fallback_headers import (
-    get_fallback_errors_from_headers,
-    get_hidden_params_dict,
-)
-from litellm.router_utils.auto_router_model_naming import (
+from litellm.router_strategy.auto_router.auto_router_model_naming import (
     GATED_AUTO_ROUTER_CAPABILITIES,
     STRATEGY_ROUTER_PARAM_FIELDS,
     capability_limit_violation,
@@ -181,12 +176,17 @@ from litellm.router_utils.auto_router_model_naming import (
     count_capability_routers,
     validate_complexity_router_config_placement,
 )
-from litellm.router_utils.auto_router_tuning_baseline import (
+from litellm.router_strategy.auto_router.auto_router_tuning_baseline import (
     TUNING_BASELINE_PARAM_NAME,
     mutable_tuned_identities,
     snapshot_tuning_baselines,
     tuning_limit_violation,
 )
+from litellm.router_utils.access_windows import access_windows_config_error
+from litellm.router_utils.add_retry_fallback_headers import (
+    get_fallback_errors_from_headers,
+    get_hidden_params_dict,
+)
 from litellm.router_utils.common_utils import resolve_model_group_alias
 from litellm.router_utils.routing_groups import parse_routing_groups
 from litellm.types.caching import RedisPipelineIncrementOperation
@@ -666,7 +666,11 @@ from litellm.proxy.list_api.common import (
     problem_response,
     request_validation_problem,
 )
-from litellm.proxy.litellm_pre_call_utils import LiteLLMProxyRequestSetup, add_litellm_data_to_request
+from litellm.proxy.litellm_pre_call_utils import (
+    SCHEDULER_PRIORITY_HEADER,
+    LiteLLMProxyRequestSetup,
+    add_litellm_data_to_request,
+)
 from litellm.proxy.logging_endpoints.callback_logs_endpoints import (
     rust_control_plane_router,
 )
@@ -18481,6 +18485,11 @@ async def async_queue_request(
             raise HTTPException(status_code=500, detail={"error": CommonProxyErrors.no_llm_router.value})
         router: Final = llm_router
 
+        data.update(
+            router.priority_header_update(
+                model=data["model"], kwargs=data, header=request.headers.get(SCHEDULER_PRIORITY_HEADER)
+            )
+        )
         queued_priority, _ = router.split_request_priority(model=data["model"], kwargs=data)
         if "stream" in data and data["stream"] is True:  # use generate_responses to stream responses
 
diff --git a/litellm/proxy/response_polling/background_streaming.py b/litellm/proxy/response_polling/background_streaming.py
index 5f6a7432afb..1eb76f8f558 100644
--- a/litellm/proxy/response_polling/background_streaming.py
+++ b/litellm/proxy/response_polling/background_streaming.py
@@ -18,6 +18,7 @@ from starlette.types import Message
 from typing_extensions import ReadOnly, TypedDict
 
 from litellm._logging import verbose_proxy_logger
+from litellm.llms.custom_httpx.sse_lines import split_sse_lines
 from litellm.proxy.auth.user_api_key_auth import UserAPIKeyAuth
 from litellm.proxy.common_request_processing import ProxyBaseLLMRequestProcessing
 from litellm.proxy.response_polling.polling_handler import ResponsePollingHandler
@@ -81,7 +82,7 @@ class _StreamsBody(Protocol):
 
 
 def _sse_frame_data(frame: str) -> str | None:
-    return next((line[6:].strip() for line in frame.splitlines() if line.startswith("data: ")), None)
+    return next((line[6:].strip() for line in split_sse_lines(frame) if line.startswith("data: ")), None)
 
 
 async def _never_receive() -> Message:
diff --git a/litellm/proxy/spend_tracking/key_metadata_recovery.py b/litellm/proxy/spend_tracking/key_metadata_recovery.py
index 5442c0f3f81..8fd4fbfcb8b 100644
--- a/litellm/proxy/spend_tracking/key_metadata_recovery.py
+++ b/litellm/proxy/spend_tracking/key_metadata_recovery.py
@@ -6,7 +6,7 @@ from datetime import datetime, timedelta
 from types import MappingProxyType
 from typing import Final, Literal, TypeVar
 
-from pydantic import TypeAdapter
+from pydantic import ConfigDict, TypeAdapter
 from typing_extensions import ReadOnly, TypedDict
 
 from litellm._logging import verbose_proxy_logger
@@ -155,6 +155,7 @@ class _DailyUserSpendOwnerRow(LiteLLMBaseModel):
     last_owner: str | None = None
 
 
+_RAW_ROWS: Final = TypeAdapter(Sequence[dict[str, object]], config=ConfigDict(strict=True))
 _TOKEN_DIGEST_ROWS: Final = TypeAdapter(tuple[_TokenDigestRow, ...])
 _SPEND_LOG_DIGEST_ROWS: Final = TypeAdapter(tuple[_SpendLogDigestRow, ...])
 _DAILY_USER_SPEND_OWNER_ROWS: Final = TypeAdapter(tuple[_DailyUserSpendOwnerRow, ...])
@@ -194,7 +195,7 @@ async def _rows_within_the_statement_timeout(
         await transaction.execute_raw(_SPEND_LOG_STATEMENT_TIMEOUT_SQL)
         for setting in planner_settings:
             await transaction.execute_raw(setting)
-        return await transaction.query_raw(sql, *params)
+        return _RAW_ROWS.validate_python(await transaction.query_raw(sql, *params))
 
 
 async def _reverse_hash_key_metadata(
diff --git a/litellm/responses/litellm_completion_transformation/streaming_iterator.py b/litellm/responses/litellm_completion_transformation/streaming_iterator.py
index 219944de521..982158040c4 100644
--- a/litellm/responses/litellm_completion_transformation/streaming_iterator.py
+++ b/litellm/responses/litellm_completion_transformation/streaming_iterator.py
@@ -165,6 +165,7 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
         self._upstream_exhausted: bool = False
         self._response_id_primed: bool = False
         self._pending_tool_events: list[BaseLiteLLMOpenAIResponseObject] = []
+        self._tool_calls_held_behind_text: tuple[object, ...] = ()
         self._tool_output_index_by_call_id: dict[str, int] = {}
         self._tool_args_by_call_id: dict[str, str] = {}
         self._tool_item_id_by_call_id: dict[str, str] = {}  # mutable-ok: filled per call id as tool call events stream
@@ -388,6 +389,15 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
             return ""
         return self._tool_call_id_by_index.get(index, "")
 
+    def _hold_tool_calls_behind_text(self, tool_calls: object) -> None:
+        if isinstance(tool_calls, list):
+            self._tool_calls_held_behind_text = (*self._tool_calls_held_behind_text, *tool_calls)
+
+    def _release_held_tool_calls(self) -> tuple[object, ...]:
+        held: Final = self._tool_calls_held_behind_text
+        self._tool_calls_held_behind_text = ()
+        return held
+
     def _queue_tool_call_delta_events(self, tool_calls: object) -> None:
         """
         Convert chat-completions streaming `tool_calls` deltas into Responses API streaming events.
@@ -1365,6 +1375,7 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
         if delta_content:
             if not self.sent_message_item_added_event:
                 self._queue_message_item_added_events()
+            self._hold_tool_calls_behind_text(getattr(chunk.choices[0].delta, "tool_calls", None))
             self._sequence_number += 1
             text_delta_event: Final = OutputTextDeltaEvent(
                 type=ResponsesAPIStreamEvents.OUTPUT_TEXT_DELTA,
@@ -1379,7 +1390,7 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
         # Priority 3: Handle tool call deltas (if any) -> queue events and emit them
         # For each tool call delta, we emit events one at a time to match OpenAI's streaming behavior
         if chunk.choices and hasattr(chunk.choices[0].delta, "tool_calls") and chunk.choices[0].delta.tool_calls:
-            self._queue_tool_call_delta_events(chunk.choices[0].delta.tool_calls)
+            self._queue_tool_call_delta_events([*self._release_held_tool_calls(), *chunk.choices[0].delta.tool_calls])
             # Return one pending tool event at a time
             if self._pending_tool_events:
                 return self._pending_tool_events.pop(0)
diff --git a/litellm/router.py b/litellm/router.py
index 3e6d82d9b07..fc888495e99 100644
--- a/litellm/router.py
+++ b/litellm/router.py
@@ -7,6 +7,29 @@
 #
 #  Thank you ! We ❤️ you! - Krrish & Ishaan
 
+"""
+litellm.Router: load balancing, retries, fallbacks and cooldowns across deployments.
+
+Public surface. The router is moving behind a narrow interface; code outside
+the router should end up using a Router through two kinds of members only:
+
+- endpoint methods (acompletion, aembedding, aresponses, aanthropic_messages,
+  the files, batches, assistants and vector store wrappers, ...), each a thin
+  wrapper around one call;
+- entry points (being added) that replace direct access to internals: registry() for
+  deployment lookups, settings() for configuration reads, health() for
+  cooldowns, blocks and usage, select() to pick a deployment without calling
+  it, apply() for runtime changes, observe() for routing events,
+  register_plugin() for strategies and sub-routers, and retire() to release
+  the router.
+
+Everything else on the class is internal. The members outside code uses today
+are listed in tests/code_coverage_tests/router_surface_allowlist.json, and a CI
+check (router_surface_check.py next to it) fails on any new outside use, so the
+list only shrinks while callers move to the entry points. The same interface
+is documented for the Rust core in litellm-rust/crates/router-core.
+"""
+
 import asyncio
 import contextlib
 import copy
@@ -85,6 +108,15 @@ from litellm.integrations.custom_logger import CustomLogger
 from litellm.integrations.otel.routing import routing_decision_attributes
 from litellm.integrations.otel.runtime import phase_attributes, phase_event, phase_span
 from litellm.litellm_core_utils.asyncify import run_async_function
+from litellm.litellm_core_utils.batch_utils import (
+    batch_create_routing,
+    deployment_supported_endpoints,
+    get_router_metadata_variable_name,
+    is_batch_retrieve_call_type,
+    replace_model_in_jsonl,
+    should_replace_model_in_jsonl,
+    without_deployments_that_cannot_batch,
+)
 from litellm.litellm_core_utils.completion_timeout import CompletionTimeout
 from litellm.litellm_core_utils.core_helpers import (
     coerce_token_limit,
@@ -148,6 +180,15 @@ from litellm.llms.openai_like.model_info import (
     get_openai_compatible_model_info,
 )
 from litellm.responses.bridge_check import keep_registered_mode
+from litellm.router_strategy.auto_router.auto_router_model_naming import (
+    AUTO_ROUTER_MODEL_PREFIX,
+    STRATEGY_ROUTER_PARAM_FIELDS,
+    GatedAutoRouterCapability,
+    capability_limit_violation,
+    claimed_capabilities,
+    classify_strategy_router_model,
+    count_capability_routers,
+)
 from litellm.router_strategy.base_routing_strategy import BaseRoutingStrategy
 from litellm.router_strategy.budget_limiter import RouterBudgetLimiting
 from litellm.router_strategy.complexity_router.context_compaction import (
@@ -187,24 +228,6 @@ from litellm.router_utils.add_retry_fallback_headers import (
     replace_complexity_router_headers,
     response_total_token_count,
 )
-from litellm.router_utils.auto_router_model_naming import (
-    AUTO_ROUTER_MODEL_PREFIX,
-    STRATEGY_ROUTER_PARAM_FIELDS,
-    GatedAutoRouterCapability,
-    capability_limit_violation,
-    claimed_capabilities,
-    classify_strategy_router_model,
-    count_capability_routers,
-)
-from litellm.router_utils.batch_utils import (
-    batch_create_routing,
-    deployment_supported_endpoints,
-    get_router_metadata_variable_name,
-    is_batch_retrieve_call_type,
-    replace_model_in_jsonl,
-    should_replace_model_in_jsonl,
-    without_deployments_that_cannot_batch,
-)
 from litellm.router_utils.client_initalization_utils import InitalizeCachedClient, MaxParallelRequestsLimit
 from litellm.router_utils.clientside_credential_handler import (
     get_dynamic_litellm_params,
@@ -359,6 +382,7 @@ from litellm.router_utils.request_priority import (
     InvalidPriority,
     parse_default_priority,
     priority_error,
+    priority_header_fields,
     request_drops_params,
     resolve_request_priority,
     unqueueable_priority_message,
@@ -1369,7 +1393,7 @@ class Router:
             },
         ]
 
-        router = Router(model_list=model_list, fallbacks=[{"azure-gpt-3.5-turbo": "openai-gpt-3.5-turbo"}])
+        router = Router(model_list=model_list, fallbacks=[{"azure-gpt-3.5-turbo": ["openai-gpt-3.5-turbo"]}])
         ```
         """
 
@@ -1595,6 +1619,10 @@ class Router:
 
         if default_fallbacks is not None or litellm.default_fallbacks is not None:
             _fallbacks = default_fallbacks or litellm.default_fallbacks
+            if isinstance(_fallbacks, str):
+                raise TypeError(
+                    f"default_fallbacks must be a list of model names, got '{_fallbacks}'. Use ['{_fallbacks}']"
+                )
             if self.fallbacks is not None:
                 self.fallbacks.append({"*": _fallbacks})
             else:
@@ -2838,7 +2866,7 @@ class Router:
         self._initialize_core_endpoints()
         self._initialize_specialized_endpoints()
 
-    def validate_fallbacks(self, fallback_param: list | None):
+    def validate_fallbacks(self, fallback_param: Sequence[Mapping[str, object]] | None):
         """
         Validate the fallbacks parameter.
         """
@@ -2851,6 +2879,13 @@ class Router:
                 raise ValueError(
                     f"Dictionary '{fallback_dict}' must have exactly one key, but has {len(fallback_dict)} keys."
                 )
+            ((model_group, targets),) = fallback_dict.items()
+            if isinstance(targets, list) or check_non_standard_fallback_format(fallbacks=[fallback_dict]):
+                continue
+            raise TypeError(
+                f"Fallbacks for '{model_group}' must be a list of model names, got '{targets}'. "
+                f"Use {{'{model_group}': ['{targets}']}}"
+            )
 
     def _add_encrypted_content_affinity_check(self, enable_global_affinity: bool) -> None:
         def _move_before_deployment_affinity(
@@ -5411,14 +5446,22 @@ class Router:
         request_priority: Final = resolve_request_priority(
             requested=kwargs.get("priority"),
             default_priority=self.default_priority,
-            drops_params=lambda: request_drops_params(
-                kwargs, self.default_litellm_params, self._request_deployment_params(model=model, kwargs=kwargs)
-            ),
+            drops_params=lambda: self._drops_params(model=model, kwargs=kwargs),
         )
         if isinstance(request_priority, InvalidPriority):
             raise priority_error(model=model, message=request_priority.message)
         return request_priority, {key: value for key, value in kwargs.items() if key != "priority"}
 
+    def priority_header_update(
+        self, model: str, kwargs: Mapping[str, object], header: str | None
+    ) -> Mapping[str, int | str]:
+        return priority_header_fields(header, drops_params=lambda: self._drops_params(model=model, kwargs=kwargs))
+
+    def _drops_params(self, model: str, kwargs: Mapping[str, object]) -> bool:
+        return request_drops_params(
+            kwargs, self.default_litellm_params, self._request_deployment_params(model=model, kwargs=kwargs)
+        )
+
     async def _schedule_factory(
         self,
         model: str,
@@ -16251,7 +16294,7 @@ class Router:
         to the deployment that actually served the request. Every attempt therefore
         writes or clears, never just writes.
         """
-        from litellm.router_utils.baseline_request import capture_baseline_parameters
+        from litellm.router_strategy.auto_router.baseline_request import capture_baseline_parameters
         from litellm.types.router import BaselineRouteStamp
 
         phase_attributes(routing_decision_attributes(routing_decision))
diff --git a/litellm/router_utils/auto_router_model_naming.py b/litellm/router_strategy/auto_router/auto_router_model_naming.py
similarity index 100%
rename from litellm/router_utils/auto_router_model_naming.py
rename to litellm/router_strategy/auto_router/auto_router_model_naming.py
diff --git a/litellm/router_utils/auto_router_tuning_baseline.py b/litellm/router_strategy/auto_router/auto_router_tuning_baseline.py
similarity index 100%
rename from litellm/router_utils/auto_router_tuning_baseline.py
rename to litellm/router_strategy/auto_router/auto_router_tuning_baseline.py
diff --git a/litellm/router_utils/baseline_request.py b/litellm/router_strategy/auto_router/baseline_request.py
similarity index 100%
rename from litellm/router_utils/baseline_request.py
rename to litellm/router_strategy/auto_router/baseline_request.py
diff --git a/litellm/router_strategy/budget_limiter.py b/litellm/router_strategy/budget_limiter.py
index eab232eae18..1d502dd8d95 100644
--- a/litellm/router_strategy/budget_limiter.py
+++ b/litellm/router_strategy/budget_limiter.py
@@ -36,12 +36,12 @@ from litellm._logging import verbose_router_logger
 from litellm.caching.caching import DualCache
 from litellm.caching.redis_cache import RedisCache, RedisPipelineIncrementOperation, log_redis_failure
 from litellm.integrations.custom_logger import CustomLogger, Span
+from litellm.litellm_core_utils.batch_utils import batch_charged_once_marker_key, batch_id_to_charge_once
 from litellm.litellm_core_utils.core_helpers import (
     get_metadata_variable_name_from_kwargs,
 )
 from litellm.litellm_core_utils.duration_parser import duration_in_seconds_from
 from litellm.router_strategy.tag_based_routing import get_tags_from_request_kwargs
-from litellm.router_utils.batch_utils import batch_charged_once_marker_key, batch_id_to_charge_once
 from litellm.router_utils.cooldown_callbacks import (
     get_prometheus_logger_from_callbacks,
 )
diff --git a/litellm/router_strategy/least_busy.py b/litellm/router_strategy/least_busy.py
index 6f3e0936641..8e0c3d6a7e7 100644
--- a/litellm/router_strategy/least_busy.py
+++ b/litellm/router_strategy/least_busy.py
@@ -10,7 +10,7 @@ from litellm._logging import verbose_router_logger
 from litellm.caching.caching import DualCache
 from litellm.caching.redis_cache import log_redis_failure
 from litellm.integrations.custom_logger import CustomLogger
-from litellm.router_utils.batch_utils import is_batch_retrieve_call_type
+from litellm.litellm_core_utils.batch_utils import is_batch_retrieve_call_type
 
 IN_FLIGHT_COUNT_TTL_SECONDS: Final = 60 * 60
 
diff --git a/litellm/router_strategy/lowest_cost.py b/litellm/router_strategy/lowest_cost.py
index 5894da9cb4f..17d03fd4ff8 100644
--- a/litellm/router_strategy/lowest_cost.py
+++ b/litellm/router_strategy/lowest_cost.py
@@ -10,7 +10,7 @@ from litellm._internal_context import with_service_target
 from litellm._logging import verbose_router_logger
 from litellm.caching.caching import DualCache
 from litellm.integrations.custom_logger import CustomLogger
-from litellm.router_utils.batch_utils import is_batch_retrieve_call_type
+from litellm.litellm_core_utils.batch_utils import is_batch_retrieve_call_type
 from litellm.router_utils.deployment_pricing import deployment_pricing_models, str_keyed
 
 
diff --git a/litellm/router_strategy/lowest_latency.py b/litellm/router_strategy/lowest_latency.py
index 4e994d3fdc6..c352934db6c 100644
--- a/litellm/router_strategy/lowest_latency.py
+++ b/litellm/router_strategy/lowest_latency.py
@@ -13,9 +13,9 @@ from litellm import ModelResponse, token_counter, verbose_logger
 from litellm._internal_context import with_service_target
 from litellm.caching.caching import DualCache
 from litellm.integrations.custom_logger import CustomLogger
+from litellm.litellm_core_utils.batch_utils import is_batch_retrieve_call_type
 from litellm.litellm_core_utils.core_helpers import get_parent_otel_span_from_kwargs, safe_divide_seconds
 from litellm.responses.utils import ResponseAPILoggingUtils
-from litellm.router_utils.batch_utils import is_batch_retrieve_call_type
 from litellm.types.llms.openai import ResponsesAPIResponse
 from litellm.types.utils import LiteLLMPydanticObjectBase
 
diff --git a/litellm/router_strategy/lowest_tpm_rpm.py b/litellm/router_strategy/lowest_tpm_rpm.py
index 2d373e0c266..9636d7f009d 100644
--- a/litellm/router_strategy/lowest_tpm_rpm.py
+++ b/litellm/router_strategy/lowest_tpm_rpm.py
@@ -9,7 +9,7 @@ from litellm._internal_context import with_service_target
 from litellm._logging import verbose_router_logger
 from litellm.caching.caching import DualCache
 from litellm.integrations.custom_logger import CustomLogger
-from litellm.router_utils.batch_utils import is_batch_retrieve_call_type
+from litellm.litellm_core_utils.batch_utils import is_batch_retrieve_call_type
 from litellm.types.utils import LiteLLMPydanticObjectBase
 from litellm.utils import print_verbose
 
diff --git a/litellm/router_strategy/lowest_tpm_rpm_v2.py b/litellm/router_strategy/lowest_tpm_rpm_v2.py
index 527ea830d55..0719b30d36d 100644
--- a/litellm/router_strategy/lowest_tpm_rpm_v2.py
+++ b/litellm/router_strategy/lowest_tpm_rpm_v2.py
@@ -15,8 +15,8 @@ from litellm._internal_context import with_service_target
 from litellm._logging import verbose_logger, verbose_router_logger
 from litellm.caching.caching import DualCache
 from litellm.integrations.custom_logger import CustomLogger
+from litellm.litellm_core_utils.batch_utils import is_batch_retrieve_call_type
 from litellm.litellm_core_utils.core_helpers import get_parent_otel_span_from_kwargs
-from litellm.router_utils.batch_utils import is_batch_retrieve_call_type
 from litellm.types.router import RouterErrors
 from litellm.types.utils import LiteLLMPydanticObjectBase, StandardLoggingPayload
 from litellm.utils import get_utc_datetime, print_verbose
diff --git a/litellm/router_utils/fallback_event_handlers.py b/litellm/router_utils/fallback_event_handlers.py
index 0a77ad5b9ea..6d1de1f9f6c 100644
--- a/litellm/router_utils/fallback_event_handlers.py
+++ b/litellm/router_utils/fallback_event_handlers.py
@@ -13,6 +13,7 @@ from pydantic import TypeAdapter
 import litellm
 from litellm._logging import verbose_router_logger
 from litellm.integrations.custom_logger import CustomLogger
+from litellm.litellm_core_utils.batch_utils import get_router_metadata_variable_name
 from litellm.litellm_core_utils.core_helpers import get_metadata_variable_name_from_kwargs, safe_deep_copy
 from litellm.litellm_core_utils.credential_accessor import reject_api_key_secret_reference
 from litellm.litellm_core_utils.get_llm_provider_logic import inferred_provider
@@ -22,7 +23,6 @@ from litellm.router_utils.add_retry_fallback_headers import (
     add_fallback_headers_to_response,
     get_fallback_error_info,
 )
-from litellm.router_utils.batch_utils import get_router_metadata_variable_name
 from litellm.router_utils.cooldown_handlers import (
     _first_present,  # pyright: ignore[reportPrivateUsage] - shared internal helper, used across router_utils
     cast_exception_status_to_int,
diff --git a/litellm/router_utils/pre_call_checks/model_rate_limit_check.py b/litellm/router_utils/pre_call_checks/model_rate_limit_check.py
index ea3fdd601dc..9eebcf39515 100644
--- a/litellm/router_utils/pre_call_checks/model_rate_limit_check.py
+++ b/litellm/router_utils/pre_call_checks/model_rate_limit_check.py
@@ -5,15 +5,19 @@ When enabled via router_settings.optional_pre_call_checks: ["enforce_model_rate_
 
 - tpm/rpm: combined TPM + optional RPM (legacy)
 - itpm/otpm: separate input/output tokens per minute
+- tpd/rpd: tokens and requests per UTC calendar day
 
 When a deployment sets both itpm/otpm and tpm/rpm, both are enforced. A warning
 is logged the first time such a deployment is seen.
 """
 
 import contextlib
-from typing import TYPE_CHECKING, Any, Final
+from collections.abc import Callable
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING, Any, Final, Literal
 
 import httpx
+from pydantic import BaseModel, ConfigDict
 
 import litellm
 from litellm._internal_context import with_service_target
@@ -33,6 +37,7 @@ from litellm.router_utils.pre_call_checks.io_token_rate_limit_check import (
     io_token_refund_failure,
 )
 from litellm.router_utils.routing_read_batch import ROUTER_USAGE_TARGET
+from litellm.types.caching import RedisPipelineIncrementOperation
 from litellm.types.router import RouterErrors
 from litellm.types.utils import StandardLoggingPayload
 from litellm.utils import get_utc_datetime
@@ -47,6 +52,62 @@ else:
 
 class RoutingArgs:
     ttl: int = 60  # 1min (RPM/TPM expire key)
+    daily_ttl: int = 86400
+
+
+DAY_FORMAT: Final = "%Y-%m-%d"
+
+
+def seconds_until_utc_midnight(now: datetime) -> int:
+    next_midnight: Final = (now + timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
+    return max(1, int((next_midnight - now).total_seconds()))
+
+
+def _first_set(*values: int | None) -> int | None:
+    return next((value for value in values if value is not None), None)
+
+
+class _DailyLimitFields(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="ignore", from_attributes=True)
+    tpd: int | None = None
+    rpd: int | None = None
+
+
+class _DailyLimitParams(_DailyLimitFields):
+    model: str | None = None
+
+
+class _DailyLimitModelInfo(_DailyLimitFields):
+    id: str | None = None
+
+
+class _DailyLimitDeployment(_DailyLimitFields):
+    model_name: str = ""
+    litellm_params: _DailyLimitParams = _DailyLimitParams()
+    model_info: _DailyLimitModelInfo = _DailyLimitModelInfo()
+
+    def limits(self) -> tuple[int | None, int | None]:
+        return (
+            _first_set(self.tpd, self.litellm_params.tpd, self.model_info.tpd),
+            _first_set(self.rpd, self.litellm_params.rpd, self.model_info.rpd),
+        )
+
+    def cache_keys(self, current_day: str) -> tuple[str, str]:
+        prefix: Final = f"{self.model_info.id}:{self.litellm_params.model}"
+        return f"{prefix}:tpd:{current_day}", f"{prefix}:rpd:{current_day}"
+
+    def limit_error(self, kind: Literal["tpd", "rpd"], limit: int, usage: int, now: datetime) -> litellm.RateLimitError:
+        return litellm.RateLimitError(
+            message=f"Model rate limit exceeded. {kind.upper()} limit={limit}, current usage={usage}",
+            llm_provider="",
+            model=self.litellm_params.model,
+            response=httpx.Response(
+                status_code=429,
+                content=f"{RouterErrors.user_defined_ratelimit_error.value} {kind} limit={limit}. current usage={usage}. id={self.model_info.id}, model_group={self.model_name}",
+                headers={"retry-after": str(seconds_until_utc_midnight(now))},
+                request=httpx.Request(method="model_rate_limit_check", url="https://github.com/BerriAI/litellm"),
+            ),
+        )
 
 
 class ModelRateLimitingCheck(CustomLogger):
@@ -60,12 +121,60 @@ class ModelRateLimitingCheck(CustomLogger):
     this check actively enforces those limits across ALL routing strategies.
     """
 
-    def __init__(self, dual_cache: DualCache):
+    def __init__(self, dual_cache: DualCache, clock: Callable[[], datetime] = get_utc_datetime):
         self.dual_cache = dual_cache
+        self.clock = clock
         # model_ids already warned about itpm/otpm + tpm/rpm on the same deployment,
         # so the warning is logged once per deployment rather than per request.
         self._io_token_conflict_warned_ids: set[str] = set()
 
+    def _increment(self, key: str, value: int, ttl: int) -> int:
+        return self.dual_cache.increment_cache(key=key, value=value, ttl=ttl)
+
+    async def _async_increment(
+        self, key: str, value: int, ttl: int, parent_otel_span: Span | None = None
+    ) -> int | None:
+        count: Final = await self.dual_cache.async_increment_cache(
+            key=key, value=value, ttl=ttl, parent_otel_span=parent_otel_span
+        )
+        return None if count is None else int(count)
+
+    @staticmethod
+    def _request_count_operations(
+        rpm_key: str | None, rpd_key: str | None, increment_value: int
+    ) -> tuple[RedisPipelineIncrementOperation, ...]:
+        return tuple(
+            RedisPipelineIncrementOperation(key=key, increment_value=increment_value, ttl=ttl)
+            for key, ttl in ((rpm_key, RoutingArgs.ttl), (rpd_key, RoutingArgs.daily_ttl))
+            if key is not None
+        )
+
+    async def _async_refund_request_counts(
+        self, rpm_key: str | None, rpd_key: str | None, parent_otel_span: Span | None
+    ) -> None:
+        operations: Final = self._request_count_operations(rpm_key, rpd_key, -1)
+        if operations:
+            await self.dual_cache.async_increment_cache_pipeline(
+                increment_list=list(operations), parent_otel_span=parent_otel_span
+            )
+
+    async def _async_increment_request_counts(
+        self, rpm_key: str | None, rpd_key: str | None, parent_otel_span: Span | None
+    ) -> tuple[int | None, int | None]:
+        operations: Final = self._request_count_operations(rpm_key, rpd_key, 1)
+        if not operations:
+            return None, None
+        counts: Final = await self.dual_cache.async_increment_cache_pipeline(
+            increment_list=list(operations), parent_otel_span=parent_otel_span
+        )
+        if counts is None or len(counts) != len(operations):
+            return None, None
+        count_by_key: Final = {op["key"]: int(count) for op, count in zip(operations, counts)}
+        return (
+            None if rpm_key is None else count_by_key.get(rpm_key),
+            None if rpd_key is None else count_by_key.get(rpd_key),
+        )
+
     def _warn_io_token_and_tpm_rpm_coexist_once(self, deployment: dict) -> None:
         tpm_limit, rpm_limit = self._get_deployment_limits(deployment)
         if tpm_limit is None and rpm_limit is None:
@@ -129,6 +238,21 @@ class ModelRateLimitingCheck(CustomLogger):
 
         return tpm, rpm
 
+    def _check_daily_limits(self, deployment: _DailyLimitDeployment, now: datetime) -> None:
+        tpd_limit, rpd_limit = deployment.limits()
+        if tpd_limit is None and rpd_limit is None:
+            return
+        tpd_key, rpd_key = deployment.cache_keys(now.strftime(DAY_FORMAT))
+        if tpd_limit is not None:
+            current_tpd: Final = self._get_current_tpm(tpd_key, tpd_limit)
+            if current_tpd is not None and current_tpd >= tpd_limit:
+                raise deployment.limit_error("tpd", tpd_limit, current_tpd, now)
+        if rpd_limit is not None:
+            current_rpd: Final = self._increment(rpd_key, 1, RoutingArgs.daily_ttl)
+            if current_rpd > rpd_limit:
+                self._increment(rpd_key, -1, RoutingArgs.daily_ttl)
+                raise deployment.limit_error("rpd", rpd_limit, current_rpd, now)
+
     def _get_cache_keys(self, deployment: dict, current_minute: str) -> tuple[str, str]:
         """Get the cache keys for TPM and RPM tracking."""
         model_id: Final = deployment.get("model_info", {}).get("id")
@@ -178,13 +302,10 @@ class ModelRateLimitingCheck(CustomLogger):
                 )
                 io_reservation_made = True
 
+            dt: Final = self.clock()
+            daily: Final = _DailyLimitDeployment.model_validate(deployment)
             tpm_limit, rpm_limit = self._get_deployment_limits(deployment)
 
-            # If no limits are set, allow the request
-            if tpm_limit is None and rpm_limit is None:
-                return deployment
-
-            dt: Final = get_utc_datetime()
             current_minute: Final = dt.strftime("%H-%M")
             tpm_key, rpm_key = self._get_cache_keys(deployment, current_minute)
 
@@ -213,8 +334,9 @@ class ModelRateLimitingCheck(CustomLogger):
 
             # Check RPM limit (atomic increment-first to avoid race conditions)
             if rpm_limit is not None:
-                current_rpm: Final = self.dual_cache.increment_cache(key=rpm_key, value=1, ttl=RoutingArgs.ttl)
+                current_rpm: Final = self._increment(rpm_key, 1, RoutingArgs.ttl)
                 if current_rpm is not None and current_rpm > rpm_limit:
+                    self._increment(rpm_key, -1, RoutingArgs.ttl)
                     raise litellm.RateLimitError(
                         message=f"Model rate limit exceeded. RPM limit={rpm_limit}, current usage={current_rpm}",
                         llm_provider="",
@@ -230,6 +352,12 @@ class ModelRateLimitingCheck(CustomLogger):
                         ),
                     )
 
+            try:
+                self._check_daily_limits(daily, dt)
+            except litellm.RateLimitError:
+                if rpm_limit is not None:
+                    self._increment(rpm_key, -1, RoutingArgs.ttl)
+                raise
             return deployment
 
         except litellm.RateLimitError:
@@ -259,15 +387,14 @@ class ModelRateLimitingCheck(CustomLogger):
                 )
                 io_reservation_made = True
 
+            dt: Final = self.clock()
+            daily: Final = _DailyLimitDeployment.model_validate(deployment)
+            tpd_limit, rpd_limit = daily.limits()
             tpm_limit, rpm_limit = self._get_deployment_limits(deployment)
 
-            # If no limits are set, allow the request
-            if tpm_limit is None and rpm_limit is None:
-                return deployment
-
-            dt: Final = get_utc_datetime()
             current_minute: Final = dt.strftime("%H-%M")
             tpm_key, rpm_key = self._get_cache_keys(deployment, current_minute)
+            tpd_key, rpd_key = daily.cache_keys(dt.strftime(DAY_FORMAT))
 
             model_id: Final = deployment.get("model_info", {}).get("id")
             model_name: Final = deployment.get("litellm_params", {}).get("model")
@@ -293,30 +420,37 @@ class ModelRateLimitingCheck(CustomLogger):
                         num_retries=0,  # Don't retry - return 429 immediately
                     )
 
-            # Check RPM limit (atomic increment-first to avoid race conditions)
-            if rpm_limit is not None:
-                current_rpm: Final = await self.dual_cache.async_increment_cache(
-                    key=rpm_key,
-                    value=1,
-                    ttl=RoutingArgs.ttl,
-                    parent_otel_span=parent_otel_span,
-                )
-                if current_rpm is not None and current_rpm > rpm_limit:
-                    raise litellm.RateLimitError(
-                        message=f"Model rate limit exceeded. RPM limit={rpm_limit}, current usage={current_rpm}",
-                        llm_provider="",
-                        model=model_name,
-                        response=httpx.Response(
-                            status_code=429,
-                            content=f"{RouterErrors.user_defined_ratelimit_error.value} rpm limit={rpm_limit}. current usage={current_rpm}. id={model_id}, model_group={model_group}",
-                            headers={"retry-after": str(60)},
-                            request=httpx.Request(
-                                method="model_rate_limit_check",
-                                url="https://github.com/BerriAI/litellm",
-                            ),
+            if tpd_limit is not None:
+                current_tpd: Final = await self._async_get_current_tpm(tpd_key, tpd_limit, parent_otel_span)
+                if current_tpd is not None and current_tpd >= tpd_limit:
+                    raise daily.limit_error("tpd", tpd_limit, current_tpd, dt)
+
+            charged_rpm_key: Final = rpm_key if rpm_limit is not None else None
+            charged_rpd_key: Final = rpd_key if rpd_limit is not None else None
+            current_rpm, current_rpd = await self._async_increment_request_counts(
+                charged_rpm_key, charged_rpd_key, parent_otel_span
+            )
+            if rpm_limit is not None and current_rpm is not None and current_rpm > rpm_limit:
+                await self._async_refund_request_counts(charged_rpm_key, charged_rpd_key, parent_otel_span)
+                raise litellm.RateLimitError(
+                    message=f"Model rate limit exceeded. RPM limit={rpm_limit}, current usage={current_rpm}",
+                    llm_provider="",
+                    model=model_name,
+                    response=httpx.Response(
+                        status_code=429,
+                        content=f"{RouterErrors.user_defined_ratelimit_error.value} rpm limit={rpm_limit}. current usage={current_rpm}. id={model_id}, model_group={model_group}",
+                        headers={"retry-after": str(60)},
+                        request=httpx.Request(
+                            method="model_rate_limit_check",
+                            url="https://github.com/BerriAI/litellm",
                         ),
-                        num_retries=0,  # Don't retry - return 429 immediately
-                    )
+                    ),
+                    num_retries=0,  # Don't retry - return 429 immediately
+                )
+
+            if rpd_limit is not None and current_rpd is not None and current_rpd > rpd_limit:
+                await self._async_refund_request_counts(charged_rpm_key, charged_rpd_key, parent_otel_span)
+                raise daily.limit_error("rpd", rpd_limit, current_rpd, dt)
 
             return deployment
 
@@ -373,17 +507,16 @@ class ModelRateLimitingCheck(CustomLogger):
             if not model or not total_tokens:
                 return
 
-            dt: Final = get_utc_datetime()
+            dt: Final = self.clock()
             current_minute: Final = dt.strftime("%H-%M")
             tpm_key: Final = f"{model_id}:{model}:tpm:{current_minute}"
+            tpd_key: Final = f"{model_id}:{model}:tpd:{dt.strftime(DAY_FORMAT)}"
 
             verbose_router_logger.debug("[TPM TRACKING] Incrementing %s by %s", tpm_key, total_tokens)
 
-            await self.dual_cache.async_increment_cache(
-                key=tpm_key,
-                value=total_tokens,
-                ttl=RoutingArgs.ttl,
-            )
+            tokens: Final = int(total_tokens)
+            await self._async_increment(tpm_key, tokens, RoutingArgs.ttl)
+            await self._async_increment(tpd_key, tokens, RoutingArgs.daily_ttl)
 
         except Exception as e:
             verbose_router_logger.debug("Error in ModelRateLimitingCheck.async_log_success_event: %s", e)
@@ -434,15 +567,14 @@ class ModelRateLimitingCheck(CustomLogger):
             if not model or not total_tokens:
                 return
 
-            dt: Final = get_utc_datetime()
+            dt: Final = self.clock()
             current_minute: Final = dt.strftime("%H-%M")
             tpm_key: Final = f"{model_id}:{model}:tpm:{current_minute}"
+            tpd_key: Final = f"{model_id}:{model}:tpd:{dt.strftime(DAY_FORMAT)}"
 
-            self.dual_cache.increment_cache(
-                key=tpm_key,
-                value=total_tokens,
-                ttl=RoutingArgs.ttl,
-            )
+            tokens: Final = int(total_tokens)
+            self._increment(tpm_key, tokens, RoutingArgs.ttl)
+            self._increment(tpd_key, tokens, RoutingArgs.daily_ttl)
 
         except Exception as e:
             verbose_router_logger.debug("Error in ModelRateLimitingCheck.log_success_event: %s", e)
diff --git a/litellm/router_utils/request_priority.py b/litellm/router_utils/request_priority.py
index 14608cc1bcf..61627d4b0cf 100644
--- a/litellm/router_utils/request_priority.py
+++ b/litellm/router_utils/request_priority.py
@@ -47,6 +47,15 @@ def resolve_request_priority(
     return priority
 
 
+def priority_header_fields(header: str | None, drops_params: Callable[[], bool]) -> Mapping[str, int | str]:
+    if not header:
+        return {}
+    priority: Final = _as_priority(header)
+    if isinstance(priority, InvalidPriority):
+        return {} if drops_params() else {"priority": header}
+    return {"priority": priority}
+
+
 def parse_default_priority(value: object) -> int | None | InvalidPriority:
     if value is None:
         return None
diff --git a/litellm/secret_managers/aws_secret_manager_v2.py b/litellm/secret_managers/aws_secret_manager_v2.py
index 98d12e497da..de8566e6fdc 100644
--- a/litellm/secret_managers/aws_secret_manager_v2.py
+++ b/litellm/secret_managers/aws_secret_manager_v2.py
@@ -21,6 +21,8 @@ from types import MappingProxyType
 from typing import TYPE_CHECKING, Final
 
 import httpx
+from pydantic import ConfigDict, TypeAdapter, with_config
+from typing_extensions import ReadOnly, TypedDict
 
 import litellm
 from litellm._logging import verbose_logger
@@ -41,6 +43,15 @@ if TYPE_CHECKING:
     from botocore.awsrequest import HTTPHeaders
 
 
+@with_config(ConfigDict(extra="allow", strict=True))
+class _SecretStringResponse(TypedDict):
+    SecretString: ReadOnly[str]
+
+
+_SECRET_STRING_RESPONSE: Final = TypeAdapter(_SecretStringResponse)
+_AWS_SECRET_MANAGER_RESPONSE: Final = TypeAdapter(dict[str, object], config=ConfigDict(strict=True))
+
+
 class AWSSecretsManagerV2(BaseAWSLLM, BaseSecretManager):
     def __init__(
         self,
@@ -154,7 +165,7 @@ class AWSSecretsManagerV2(BaseAWSLLM, BaseSecretManager):
         try:
             response: Final = await async_client.post(url=endpoint_url, headers=headers, data=body.decode("utf-8"))
             response.raise_for_status()
-            return response.json()["SecretString"]
+            return _SECRET_STRING_RESPONSE.validate_python(response.json())["SecretString"]
         except httpx.TimeoutException:
             raise ValueError("Timeout error occurred")
         except Exception as e:
@@ -204,7 +215,7 @@ class AWSSecretsManagerV2(BaseAWSLLM, BaseSecretManager):
 
         try:
             response: Final = sync_client.post(url=endpoint_url, headers=headers, data=body.decode("utf-8"))
-            return response.json()["SecretString"]
+            return _SECRET_STRING_RESPONSE.validate_python(response.json())["SecretString"]
         except httpx.TimeoutException:
             raise ValueError("Timeout error occurred")
         except httpx.HTTPStatusError as e:
@@ -424,7 +435,7 @@ class AWSSecretsManagerV2(BaseAWSLLM, BaseSecretManager):
         try:
             response: Final = await async_client.post(url=endpoint_url, headers=headers, data=body.decode("utf-8"))
             response.raise_for_status()
-            return response.json()
+            return _AWS_SECRET_MANAGER_RESPONSE.validate_python(response.json())
         except httpx.HTTPStatusError as err:
             raise ValueError(f"HTTP error occurred: {err.response.text}")
         except httpx.TimeoutException:
@@ -481,7 +492,7 @@ class AWSSecretsManagerV2(BaseAWSLLM, BaseSecretManager):
         try:
             response: Final = await async_client.post(url=endpoint_url, headers=headers, data=body.decode("utf-8"))
             response.raise_for_status()
-            return response.json()
+            return _AWS_SECRET_MANAGER_RESPONSE.validate_python(response.json())
         except httpx.HTTPStatusError as err:
             raise ValueError(f"HTTP error occurred: {err.response.text}")
         except httpx.TimeoutException:
@@ -533,7 +544,7 @@ class AWSSecretsManagerV2(BaseAWSLLM, BaseSecretManager):
         try:
             response: Final = await async_client.post(url=endpoint_url, headers=headers, data=body.decode("utf-8"))
             response.raise_for_status()
-            return response.json()
+            return _AWS_SECRET_MANAGER_RESPONSE.validate_python(response.json())
         except httpx.HTTPStatusError as err:
             raise ValueError(f"HTTP error occurred: {err.response.text}")
         except httpx.TimeoutException:
@@ -613,7 +624,7 @@ class AWSSecretsManagerV2(BaseAWSLLM, BaseSecretManager):
         try:
             response: Final = await async_client.post(url=endpoint_url, headers=headers, data=body.decode("utf-8"))
             response.raise_for_status()
-            return response.json()
+            return _AWS_SECRET_MANAGER_RESPONSE.validate_python(response.json())
         except httpx.HTTPStatusError as err:
             raise ValueError(f"HTTP error occurred: {err.response.text}")
         except httpx.TimeoutException:
diff --git a/litellm/types/integrations/rag/bedrock_knowledgebase.py b/litellm/types/integrations/rag/bedrock_knowledgebase.py
index 7156d8101e1..7288eca03b4 100644
--- a/litellm/types/integrations/rag/bedrock_knowledgebase.py
+++ b/litellm/types/integrations/rag/bedrock_knowledgebase.py
@@ -1,4 +1,4 @@
-from typing import Any, Literal
+from typing import Literal
 
 from typing_extensions import ReadOnly, TypedDict
 
@@ -40,7 +40,7 @@ class BedrockKBRetrievalResult(TypedDict, total=False):
     content: BedrockKBContent | None
     location: BedrockKBLocation | None
     score: float | None
-    metadata: dict[str, Any] | None
+    metadata: dict[str, object] | None
 
 
 class BedrockKBResponse(TypedDict, total=False):
@@ -87,21 +87,21 @@ class BedrockKBMetadataConfiguration(TypedDict, total=False):
 class BedrockKBModelConfiguration(TypedDict, total=False):
     """Model configuration for reranking."""
 
-    additionalModelRequestFields: dict[str, Any] | None
+    additionalModelRequestFields: dict[str, object] | None
     modelArn: str | None
 
 
 class BedrockKBRerankingConfiguration(TypedDict, total=False):
     """Configuration for reranking in vector search."""
 
-    bedrockRerankingConfiguration: dict[str, Any] | None  # This could be further typed if needed
+    bedrockRerankingConfiguration: dict[str, object] | None  # This could be further typed if needed
     type: str | None
 
 
 class BedrockKBVectorSearchConfiguration(TypedDict, total=False):
     """Configuration for vector search."""
 
-    filter: dict[str, Any] | None
+    filter: dict[str, object] | None
     implicitFilterConfiguration: BedrockKBImplicitFilterConfiguration | None
     numberOfResults: int | None
     overrideSearchType: str | None
diff --git a/litellm/types/litellm_params.py b/litellm/types/litellm_params.py
index 717b74e5741..9196b7a226f 100644
--- a/litellm/types/litellm_params.py
+++ b/litellm/types/litellm_params.py
@@ -189,6 +189,8 @@ class DeploymentOptions:
     tpm: int | None = None
     itpm: int | None = None
     otpm: int | None = None
+    rpd: int | None = None
+    tpd: int | None = None
     kubernetes_pod_discovery: bool | None = None
     default_api_key_rpm_limit: int | None = None
     default_api_key_tpm_limit: int | None = None
diff --git a/litellm/types/llms/bedrock_invoke_agents.py b/litellm/types/llms/bedrock_invoke_agents.py
index 62f3c18ca7a..b334c986d6b 100644
--- a/litellm/types/llms/bedrock_invoke_agents.py
+++ b/litellm/types/llms/bedrock_invoke_agents.py
@@ -4,7 +4,7 @@ Type definitions for AWS Bedrock Invoke Agent API responses.
 https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html
 """
 
-from typing import Any, Final
+from typing import Final
 
 from typing_extensions import TypedDict
 
@@ -39,7 +39,7 @@ class InvokeAgentModelInvocationInput(TypedDict, total=False):
     """Model invocation input details."""
 
     foundationModel: str | None
-    inferenceConfiguration: dict[str, Any] | None
+    inferenceConfiguration: dict[str, object] | None
     text: str | None
     traceId: str | None
     type: str | None
@@ -49,9 +49,9 @@ class InvokeAgentModelInvocationOutput(TypedDict, total=False):
     """Model invocation output details."""
 
     metadata: InvokeAgentMetadata | None
-    parsedResponse: dict[str, Any] | None
-    rawResponse: dict[str, Any] | None
-    reasoningContent: dict[str, Any] | None
+    parsedResponse: dict[str, object] | None
+    rawResponse: dict[str, object] | None
+    reasoningContent: dict[str, object] | None
     traceId: str | None
 
 
diff --git a/litellm/types/llms/gemini.py b/litellm/types/llms/gemini.py
index c300c26bcd3..2ad81e64e05 100644
--- a/litellm/types/llms/gemini.py
+++ b/litellm/types/llms/gemini.py
@@ -1,5 +1,6 @@
+from collections.abc import Mapping
 from enum import Enum
-from typing import Any, Literal
+from typing import Literal
 
 from typing_extensions import Required, TypedDict
 
@@ -235,7 +236,7 @@ class GeminiVideoGenerationInstance(TypedDict, total=False):
     """Instance data for Gemini video generation request"""
 
     prompt: Required[str]
-    image: dict[str, Any]
+    image: Mapping[str, object]
 
 
 class GeminiVideoGenerationParameters(LiteLLMBaseModel):
@@ -263,7 +264,7 @@ class GeminiVideoGenerationParameters(LiteLLMBaseModel):
     negativePrompt: str | None = None
     """Text describing what not to include in the video."""
 
-    lastFrame: Any | None = None
+    lastFrame: object | None = None
     """
     The final image for interpolation video to transition.
     Should be used with the 'image' parameter.
@@ -275,7 +276,7 @@ class GeminiVideoGenerationParameters(LiteLLMBaseModel):
     Only supported in Veo 3.1 (list of VideoGenerationReferenceImage objects).
     """
 
-    video: Any | None = None
+    video: object | None = None
     """
     Video to be used for video extension (Video object).
     Only supported in Veo 3.1 & Veo 3 Fast.
@@ -354,5 +355,5 @@ class GeminiLongRunningOperationResponse(LiteLLMBaseModel):
     response: GeminiOperationResponse | None = None
     """Response object when operation is complete"""
 
-    error: dict[str, Any] | None = None
+    error: dict[str, object] | None = None
     """Error details if operation failed"""
diff --git a/litellm/types/llms/langgraph.py b/litellm/types/llms/langgraph.py
index 7e34329992d..83f7bb090d1 100644
--- a/litellm/types/llms/langgraph.py
+++ b/litellm/types/llms/langgraph.py
@@ -4,7 +4,8 @@ Type definitions for LangGraph API.
 LangGraph provides a streaming and non-streaming API for running agents.
 """
 
-from typing import Any, Literal
+from collections.abc import Mapping
+from typing import Literal
 
 from typing_extensions import TypedDict
 
@@ -29,8 +30,8 @@ class LangGraphRequest(TypedDict, total=False):
     assistant_id: str
     input: LangGraphInput
     stream_mode: str | None
-    config: dict[str, Any] | None
-    metadata: dict[str, Any] | None
+    config: Mapping[str, object] | None
+    metadata: Mapping[str, object] | None
 
 
 # Response Types - Streaming
@@ -38,7 +39,7 @@ class LangGraphStreamEvent(TypedDict, total=False):
     """Single event in a LangGraph stream response."""
 
     event: str
-    data: Any
+    data: object
 
 
 # Response Types - Non-streaming
@@ -55,7 +56,7 @@ class LangGraphResponse(TypedDict, total=False):
     """Non-streaming response structure from LangGraph."""
 
     messages: list[LangGraphResponseMessage]
-    values: dict[str, Any]
+    values: dict[str, object]
 
 
 # Parsed response for internal use
diff --git a/litellm/types/mcp_server/tool_registry.py b/litellm/types/mcp_server/tool_registry.py
index 738d37c9503..080e27b6ed3 100644
--- a/litellm/types/mcp_server/tool_registry.py
+++ b/litellm/types/mcp_server/tool_registry.py
@@ -1,5 +1,5 @@
 from collections.abc import Callable
-from typing import Any, ClassVar
+from typing import ClassVar
 
 from pydantic import ConfigDict, Field
 
@@ -10,7 +10,7 @@ class MCPTool(LiteLLMBaseModel):
     model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True)
     name: str
     description: str
-    input_schema: dict[str, Any]
+    input_schema: dict[str, object]
     handler: Callable
     server_id: str | None = Field(default=None, frozen=True)
 
@@ -18,18 +18,18 @@ class MCPTool(LiteLLMBaseModel):
 class ToolSchema(LiteLLMBaseModel):
     name: str
     description: str
-    inputSchema: dict[str, Any]
+    inputSchema: dict[str, object]
 
 
 class ListToolsResponse(LiteLLMBaseModel):
     tools: list[ToolSchema]
     nextCursor: str | None = None
-    _meta: dict[str, Any] | None = None
+    _meta: dict[str, object] | None = None
 
 
 class CallToolRequest(LiteLLMBaseModel):
     method: str = "tools/call"
-    params: dict[str, Any]
+    params: dict[str, object]
 
 
 class ContentItem(LiteLLMBaseModel):
diff --git a/litellm/types/proxy/guardrails/guardrail_hooks/enkryptai.py b/litellm/types/proxy/guardrails/guardrail_hooks/enkryptai.py
index d1eba1dd4a9..f936c9d85cf 100644
--- a/litellm/types/proxy/guardrails/guardrail_hooks/enkryptai.py
+++ b/litellm/types/proxy/guardrails/guardrail_hooks/enkryptai.py
@@ -1,5 +1,3 @@
-from typing import Any
-
 from pydantic import Field
 from typing_extensions import TypedDict
 
@@ -20,7 +18,7 @@ class EnkryptAIPolicyViolationDetail(TypedDict, total=False):
 class EnkryptAIPIIDetail(TypedDict, total=False):
     """Details for PII detection."""
 
-    pii: dict[str, Any]
+    pii: dict[str, object]
 
 
 class EnkryptAIToxicityDetail(TypedDict, total=False):
@@ -85,8 +83,8 @@ class EnkryptAIResponseDetails(TypedDict, total=False):
     toxicity: EnkryptAIToxicityDetail | None
     keyword_detected: EnkryptAIKeywordDetail | None
     bias: EnkryptAIBiasDetail | None
-    prompt_injection: dict[str, Any] | None
-    jailbreak: dict[str, Any] | None
+    prompt_injection: dict[str, object] | None
+    jailbreak: dict[str, object] | None
 
 
 class EnkryptAIResponse(TypedDict, total=False):
@@ -107,7 +105,7 @@ class EnkryptAIProcessedResult(TypedDict):
         | EnkryptAIToxicityDetail
         | EnkryptAIKeywordDetail
         | EnkryptAIBiasDetail
-        | dict[str, Any],
+        | dict[str, object],
     ]
 
 
diff --git a/litellm/types/router.py b/litellm/types/router.py
index ba9b82e2a57..f8de2128a80 100644
--- a/litellm/types/router.py
+++ b/litellm/types/router.py
@@ -533,6 +533,8 @@ class GenericLiteLLMParams(CredentialLiteLLMParams, CustomPricingLiteLLMParams):
     rpm: int | None = None
     itpm: int | None = None
     otpm: int | None = None
+    tpd: int | None = None
+    rpd: int | None = None
     timeout: float | str | httpx.Timeout | SDKTimeout | None = None  # if str, pass in as os.environ/
     # read timeout of a live stream, a faked stream takes the longer of this and timeout. If str, pass in as os.environ/
     stream_timeout: float | str | None = None
@@ -738,6 +740,8 @@ class LiteLLMParamsTypedDict(TypedDict, total=False):
     rpm: int | None
     itpm: int | None
     otpm: int | None
+    tpd: ReadOnly[int | None]
+    rpd: ReadOnly[int | None]
     order: int | None
     weight: int | None
     max_parallel_requests: int | None
diff --git a/litellm/utils.py b/litellm/utils.py
index a231644addf..be1e11dd39f 100644
--- a/litellm/utils.py
+++ b/litellm/utils.py
@@ -7664,7 +7664,6 @@ def validate_environment(
             model in litellm.open_ai_chat_completion_models
             or model in litellm.open_ai_text_completion_models
             or model in litellm.open_ai_embedding_models
-            or model in litellm.openai_image_generation_models
             or model.startswith("gpt-image")
         ):
             if "OPENAI_API_KEY" in os.environ:
@@ -10311,11 +10310,9 @@ class ProviderConfigManager:
         provider: LlmProviders,
     ) -> BaseImageGenerationConfig | None:
         if LlmProviders.OPENAI == provider:
-            from litellm.llms.openai.image_generation import (
-                get_openai_image_generation_config,
-            )
+            from litellm.llms.openai.image_generation import GPTImageGenerationConfig
 
-            return get_openai_image_generation_config(model)
+            return GPTImageGenerationConfig()
         elif LlmProviders.AZURE == provider:
             from litellm.llms.azure.image_generation import (
                 get_azure_image_generation_config,
@@ -10418,6 +10415,13 @@ class ProviderConfigManager:
             return get_modelscope_image_generation_config(model)
         elif LlmProviders.EDENAI == provider:
             return litellm.EdenAIImageGenerationConfig()
+        elif LlmProviders.TENCENT == provider:
+            from litellm.llms.tencent.image_generation.transformation import (
+                TencentImageGenerationConfig,
+                is_tokenhub_image_model,
+            )
+
+            return TencentImageGenerationConfig() if is_tokenhub_image_model(model) else None
         return None
 
     @staticmethod
@@ -10539,9 +10543,9 @@ class ProviderConfigManager:
         provider: LlmProviders,
     ) -> BaseImageEditConfig | None:
         if LlmProviders.OPENAI == provider:
-            from litellm.llms.openai.image_edit import get_openai_image_edit_config
+            from litellm.llms.openai.image_edit import OpenAIImageEditConfig
 
-            return get_openai_image_edit_config(model=model)
+            return OpenAIImageEditConfig()
         elif LlmProviders.HOSTED_VLLM == provider:
             from litellm.llms.hosted_vllm.image_edit import get_hosted_vllm_image_edit_config
 
@@ -10606,6 +10610,15 @@ class ProviderConfigManager:
             )
 
             return get_openrouter_image_edit_config(model)
+        elif LlmProviders.TENCENT == provider:
+            from litellm.llms.tencent.image_edit.transformation import (
+                TencentImageEditConfig,
+            )
+            from litellm.llms.tencent.image_generation.transformation import (
+                is_tokenhub_image_model,
+            )
+
+            return TencentImageEditConfig() if is_tokenhub_image_model(model) else None
         return None
 
     @staticmethod
diff --git a/model_prices_and_context_window.json b/model_prices_and_context_window.json
index 1f2bd7d7837..8719565a96f 100644
--- a/model_prices_and_context_window.json
+++ b/model_prices_and_context_window.json
@@ -28853,6 +28853,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.039,
         "output_cost_per_image_token": 3e-05,
+        "output_cost_per_image_token_batches": 1.5e-05,
         "output_cost_per_reasoning_token": 2.5e-06,
         "output_cost_per_token": 2.5e-06,
         "output_cost_per_token_batches": 1.25e-06,
@@ -28910,6 +28911,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.134,
         "output_cost_per_image_token": 0.00012,
+        "output_cost_per_image_token_batches": 6e-05,
         "output_cost_per_token": 1.2e-05,
         "output_cost_per_token_above_200k_tokens": 1.8e-05,
         "output_cost_per_token_above_200k_tokens_priority": 3.24e-05,
@@ -28963,12 +28965,13 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.134,
         "output_cost_per_image_token": 0.00012,
+        "output_cost_per_image_token_batches": 6e-05,
         "output_cost_per_token": 1.2e-05,
         "output_cost_per_token_priority": 2.16e-05,
         "output_cost_per_token_above_200k_tokens": 1.8e-05,
         "output_cost_per_token_above_200k_tokens_priority": 3.24e-05,
         "output_cost_per_token_batches": 6e-06,
-        "source": "https://ai.google.dev/gemini-api/docs/pricing",
+        "source": "https://cloud.google.com/gemini-enterprise-agent-platform/generative-ai/pricing",
         "supported_endpoints": [
             "/v1/chat/completions",
             "/v1/images/generations",
@@ -29014,6 +29017,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.0672,
         "output_cost_per_image_token": 6e-05,
+        "output_cost_per_image_token_batches": 3e-05,
         "output_cost_per_token": 3e-06,
         "output_cost_per_token_batches": 1.5e-06,
         "output_cost_per_token_flex": 1.5e-06,
@@ -29059,9 +29063,10 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.0672,
         "output_cost_per_image_token": 6e-05,
+        "output_cost_per_image_token_batches": 3e-05,
         "output_cost_per_token": 3e-06,
         "output_cost_per_token_batches": 1.5e-06,
-        "source": "https://cloud.google.com/vertex-ai/generative-ai/pricing#gemini-models",
+        "source": "https://cloud.google.com/gemini-enterprise-agent-platform/generative-ai/pricing",
         "supported_endpoints": [
             "/v1/chat/completions",
             "/v1/images/generations",
@@ -29106,6 +29111,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.0336,
         "output_cost_per_image_token": 3e-05,
+        "output_cost_per_image_token_batches": 1.5e-05,
         "output_cost_per_token": 1.5e-06,
         "output_cost_per_token_batches": 7.5e-07,
         "output_cost_per_token_flex": 7.5e-07,
@@ -29672,10 +29678,12 @@
         },
         "search_free_requests": {"count": 10000, "period": "day", "shared_group": "gemini-2.5-pro"},
         "google_maps_grounding_cost_per_query": 0.025,
+        "input_cost_per_token_above_200k_tokens_batches": 1.25e-06,
         "input_cost_per_token_above_200k_tokens_priority": 4.5e-06,
         "input_cost_per_token_batches": 6.25e-07,
         "input_cost_per_token_flex": 6.25e-07,
         "input_cost_per_token_priority": 2.25e-06,
+        "output_cost_per_token_above_200k_tokens_batches": 7.5e-06,
         "output_cost_per_token_above_200k_tokens_priority": 2.7e-05,
         "output_cost_per_token_batches": 5e-06,
         "output_cost_per_token_flex": 5e-06,
@@ -29690,6 +29698,7 @@
         "google_maps_grounding_cost_per_query": 0.014,
         "input_cost_per_token": 2e-06,
         "input_cost_per_token_above_200k_tokens": 4e-06,
+        "input_cost_per_token_above_200k_tokens_batches": 2e-06,
         "input_cost_per_token_above_200k_tokens_priority": 7.2e-06,
         "input_cost_per_token_batches": 1e-06,
         "input_cost_per_token_flex": 1e-06,
@@ -29701,6 +29710,7 @@
         "output_cost_per_image": 0.00012,
         "output_cost_per_token": 1.2e-05,
         "output_cost_per_token_above_200k_tokens": 1.8e-05,
+        "output_cost_per_token_above_200k_tokens_batches": 9e-06,
         "output_cost_per_token_above_200k_tokens_priority": 3.24e-05,
         "output_cost_per_token_batches": 6e-06,
         "output_cost_per_token_flex": 6e-06,
@@ -30229,6 +30239,7 @@
         "google_maps_grounding_cost_per_query": 0.014,
         "input_cost_per_token": 2e-06,
         "input_cost_per_token_above_200k_tokens": 4e-06,
+        "input_cost_per_token_above_200k_tokens_batches": 2e-06,
         "input_cost_per_token_above_200k_tokens_priority": 7.2e-06,
         "input_cost_per_token_batches": 1e-06,
         "input_cost_per_token_flex": 1e-06,
@@ -30240,6 +30251,7 @@
         "output_cost_per_image": 0.00012,
         "output_cost_per_token": 1.2e-05,
         "output_cost_per_token_above_200k_tokens": 1.8e-05,
+        "output_cost_per_token_above_200k_tokens_batches": 9e-06,
         "output_cost_per_token_above_200k_tokens_priority": 3.24e-05,
         "output_cost_per_token_batches": 6e-06,
         "output_cost_per_token_flex": 6e-06,
@@ -51910,6 +51922,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.039,
         "output_cost_per_image_token": 3e-05,
+        "output_cost_per_image_token_batches": 1.5e-05,
         "output_cost_per_reasoning_token": 2.5e-06,
         "output_cost_per_token": 2.5e-06,
         "output_cost_per_token_batches": 1.25e-06,
@@ -51968,6 +51981,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.134,
         "output_cost_per_image_token": 0.00012,
+        "output_cost_per_image_token_batches": 6e-05,
         "output_cost_per_token": 1.2e-05,
         "output_cost_per_token_above_200k_tokens": 1.8e-05,
         "output_cost_per_token_above_200k_tokens_priority": 3.24e-05,
@@ -52002,13 +52016,14 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.134,
         "output_cost_per_image_token": 0.00012,
+        "output_cost_per_image_token_batches": 6e-05,
         "output_cost_per_token": 1.2e-05,
         "output_cost_per_token_priority": 2.16e-05,
         "output_cost_per_token_above_200k_tokens": 1.8e-05,
         "output_cost_per_token_above_200k_tokens_priority": 3.24e-05,
         "output_cost_per_token_batches": 6e-06,
         "supports_reasoning": false,
-        "source": "https://docs.cloud.google.com/vertex-ai/generative-ai/docs/models/gemini/3-pro-image",
+        "source": "https://cloud.google.com/gemini-enterprise-agent-platform/generative-ai/pricing",
         "supported_endpoints": [
             "/v1/chat/completions",
             "/v1/images/generations",
@@ -52034,6 +52049,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.0672,
         "output_cost_per_image_token": 6e-05,
+        "output_cost_per_image_token_batches": 3e-05,
         "output_cost_per_token": 3e-06,
         "output_cost_per_token_batches": 1.5e-06,
         "output_cost_per_token_flex": 1.5e-06,
@@ -52061,10 +52077,11 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.0672,
         "output_cost_per_image_token": 6e-05,
+        "output_cost_per_image_token_batches": 3e-05,
         "output_cost_per_token": 3e-06,
         "output_cost_per_token_batches": 1.5e-06,
         "supports_reasoning": false,
-        "source": "https://cloud.google.com/vertex-ai/generative-ai/pricing#gemini-models",
+        "source": "https://cloud.google.com/gemini-enterprise-agent-platform/generative-ai/pricing",
         "supported_endpoints": [
             "/v1/chat/completions",
             "/v1/images/generations",
@@ -52089,6 +52106,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.0336,
         "output_cost_per_image_token": 3e-05,
+        "output_cost_per_image_token_batches": 1.5e-05,
         "output_cost_per_token": 1.5e-06,
         "output_cost_per_token_batches": 7.5e-07,
         "output_cost_per_token_flex": 7.5e-07,
@@ -61986,6 +62004,39 @@
         "supports_reasoning": true,
         "supports_vision": false
     },
+    "tencent/seedream-image-v5.0-flash": {
+        "litellm_provider": "tencent",
+        "mode": "image_generation",
+        "output_cost_per_image": 0.018,
+        "output_cost_per_image_token": 1.6e-06,
+        "source": "https://cloud.tencent.com/document/product/1823/130055",
+        "supported_endpoints": [
+            "/v1/images/generations",
+            "/v1/images/edits"
+        ]
+    },
+    "tencent/seedream-image-v5.0-lite": {
+        "litellm_provider": "tencent",
+        "mode": "image_generation",
+        "output_cost_per_image": 0.035,
+        "output_cost_per_image_token": 1.6e-06,
+        "source": "https://www.tencentcloud.com/document/product/1300/78937",
+        "supported_endpoints": [
+            "/v1/images/generations",
+            "/v1/images/edits"
+        ]
+    },
+    "tencent/seedream-image-v5.0-pro": {
+        "litellm_provider": "tencent",
+        "mode": "image_generation",
+        "output_cost_per_image": 0.09,
+        "output_cost_per_image_token": 1.6e-06,
+        "source": "https://www.tencentcloud.com/document/product/1300/78937",
+        "supported_endpoints": [
+            "/v1/images/generations",
+            "/v1/images/edits"
+        ]
+    },
     "cognition/swe-1.6": {
         "input_cost_per_token": 5e-07,
         "output_cost_per_token": 2.5e-06,
@@ -74367,6 +74418,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.0336,
         "output_cost_per_image_token": 3e-05,
+        "output_cost_per_image_token_batches": 1.5e-05,
         "output_cost_per_token": 7.5e-06,
         "output_cost_per_token_batches": 3.75e-06,
         "output_cost_per_token_priority": 1.35e-05,
@@ -74412,6 +74464,7 @@
         "mode": "image_generation",
         "output_cost_per_image": 0.0336,
         "output_cost_per_image_token": 3e-05,
+        "output_cost_per_image_token_batches": 1.5e-05,
         "output_cost_per_token": 7.5e-06,
         "output_cost_per_token_batches": 3.75e-06,
         "output_cost_per_token_priority": 1.35e-05,
diff --git a/provider_endpoints_support.json b/provider_endpoints_support.json
index d73ac19bae1..0a6c2bcb2a9 100644
--- a/provider_endpoints_support.json
+++ b/provider_endpoints_support.json
@@ -3793,8 +3793,8 @@
         "responses": true,
         "text_completion": true,
         "embeddings": false,
-        "image_generations": false,
-        "image_edits": false,
+        "image_generations": true,
+        "image_edits": true,
         "audio_transcriptions": false,
         "audio_speech": false,
         "rerank": false,
diff --git a/tests/benchmarks/test_sse_lines_benchmarks.py b/tests/benchmarks/test_sse_lines_benchmarks.py
new file mode 100644
index 00000000000..1320fae49a6
--- /dev/null
+++ b/tests/benchmarks/test_sse_lines_benchmarks.py
@@ -0,0 +1,27 @@
+from collections.abc import Sequence
+from typing import Final
+
+import pytest
+
+from litellm.llms.custom_httpx.sse_lines import iter_sse_lines
+
+EVENT: Final = 'data: {"choices":[{"delta":{"content":"hello world"}}]}'
+
+
+def _chunks(line_break: str) -> Sequence[str]:
+    body: Final = "".join(f"{EVENT}{line_break}{line_break}" for _ in range(2000))
+    return tuple(body[i : i + 512] for i in range(0, len(body), 512))
+
+
+LF_CHUNKS: Final = _chunks("\n")
+CRLF_CHUNKS: Final = _chunks("\r\n")
+
+
+@pytest.mark.benchmark
+def test_iter_sse_lines_lf_stream() -> None:
+    assert sum(1 for _ in iter_sse_lines(LF_CHUNKS)) == 4000
+
+
+@pytest.mark.benchmark
+def test_iter_sse_lines_crlf_stream() -> None:
+    assert sum(1 for _ in iter_sse_lines(CRLF_CHUNKS)) == 4000
diff --git a/tests/code_coverage_tests/router_code_coverage.py b/tests/code_coverage_tests/router_code_coverage.py
index eee02a2f6b6..9fb3633d53c 100644
--- a/tests/code_coverage_tests/router_code_coverage.py
+++ b/tests/code_coverage_tests/router_code_coverage.py
@@ -175,6 +175,8 @@ ignored_function_names = [
     "_responses_continuation",  # Tested through the Responses mid-stream fallback tests in tests/unit/llms/base_llm/responses/test_transformation.py
     "_responses_continuation_ceilings",  # Tested through the Responses mid-stream fallback tests in tests/unit/llms/base_llm/responses/test_transformation.py
     "_team_deployments_named",  # Tested through the team lookups in the concurrent delete tests in test_router.py
+    "priority_header_update",  # Tested through the priority header tests in test_common_request_processing.py
+    "_drops_params",  # Read by split_request_priority and priority_header_update, tested through both
     "_responses_event_announces_background_run",  # Tested through the background Responses stream tests in test_router.py
     "_aresponses_background_stream_can_release",  # Tested through the background Responses stream tests in test_router.py
     "_raise_released_stream_error",  # Tested through the background Responses stream content-policy tests in test_router.py
@@ -185,13 +187,13 @@ ignored_function_names = [
 def main():
     router_file = [
         "./litellm/router.py",
-        "./litellm/router_utils/batch_utils.py",
+        "./litellm/litellm_core_utils/batch_utils.py",
         "./litellm/router_utils/pattern_match_deployments.py",
     ]
     # router_file = [
     #     "../../litellm/router.py",
     #     "../../litellm/router_utils/pattern_match_deployments.py",
-    #     "../../litellm/router_utils/batch_utils.py",
+    #     "../../litellm/litellm_core_utils/batch_utils.py",
     # ]  ## LOCAL TESTING
     tests_dir = "./tests/"  # Update this path if your tests directory is located elsewhere
     # tests_dir = "../../tests/"  # LOCAL TESTING
diff --git a/tests/code_coverage_tests/router_surface_allowlist.json b/tests/code_coverage_tests/router_surface_allowlist.json
new file mode 100644
index 00000000000..428fd9b4011
--- /dev/null
+++ b/tests/code_coverage_tests/router_surface_allowlist.json
@@ -0,0 +1,211 @@
+{
+  "_doc": "Router members and litellm.router_utils modules used outside the router. Shrink-only: see tests/code_coverage_tests/router_surface_check.py.",
+  "members_outside": [
+    "_get_client",
+    "_zero_cost_cache",
+    "a_add_message",
+    "aadapter_completion",
+    "aanthropic_messages",
+    "abatch_completion",
+    "abatch_completion_fastest_response",
+    "acancel_batch",
+    "acancel_fine_tuning_job",
+    "acompletion",
+    "acreate_assistants",
+    "acreate_batch",
+    "acreate_file",
+    "acreate_fine_tuning_job",
+    "acreate_thread",
+    "adaptive_routers",
+    "adecisions",
+    "adelete_assistant",
+    "aembedding",
+    "afile_content",
+    "afile_delete",
+    "aget_assistants",
+    "aget_messages",
+    "aget_responses",
+    "aget_thread",
+    "alist_batches",
+    "alist_fine_tuning_jobs",
+    "allm_passthrough_route",
+    "amoderation",
+    "aocr",
+    "are_all_deployments_blocked",
+    "arefresh_model_info",
+    "aretrieve_batch",
+    "aretrieve_fine_tuning_job",
+    "arm_routing_read_prefetch",
+    "arun_thread",
+    "async_get_available_deployment",
+    "async_get_fully_unhealthy_model_names",
+    "async_get_healthy_deployments",
+    "async_pre_routing_hook",
+    "auto_routers",
+    "avector_store_create",
+    "avector_store_search",
+    "background_health_check_model_groups",
+    "bind_to_request_logging",
+    "cache",
+    "cache_responses",
+    "cached_deployment_model_info",
+    "cached_model_group_info",
+    "completion",
+    "complexity_routers",
+    "config_deployments",
+    "content_policy_fallbacks",
+    "context_window_fallbacks",
+    "cooldown_time",
+    "default_deployment",
+    "default_litellm_params",
+    "delete_deployment",
+    "deployment_latency_map",
+    "deployment_names",
+    "deployment_usable_by_team",
+    "deployments_for_request",
+    "deployments_named",
+    "discard",
+    "embedding",
+    "enable_health_check_routing",
+    "fallbacks",
+    "generate_model_id",
+    "get_all_deployments",
+    "get_available_deployment_for_pass_through",
+    "get_available_guardrail",
+    "get_candidate_model_ids_for_route",
+    "get_configured_display_name",
+    "get_configured_mode",
+    "get_configured_service_tiers",
+    "get_configured_token_limits",
+    "get_credential_deployment",
+    "get_deployment",
+    "get_deployment_by_model_group_name",
+    "get_deployment_credentials",
+    "get_deployment_credentials_with_provider",
+    "get_deployment_model_info",
+    "get_discovered_model_info",
+    "get_fully_blocked_model_names",
+    "get_model_access_groups",
+    "get_model_from_alias",
+    "get_model_group_info",
+    "get_model_group_usage",
+    "get_model_ids",
+    "get_model_info",
+    "get_model_list",
+    "get_model_list_from_model_alias",
+    "get_model_list_from_routing_groups",
+    "get_model_list_of_routed_group",
+    "get_model_listing_info",
+    "get_model_names",
+    "get_remaining_model_group_usage",
+    "get_routable_deployments",
+    "get_routable_upstream_model",
+    "get_router_deployment_budget_limiter",
+    "get_routing_group",
+    "get_settings",
+    "get_valid_args",
+    "guardrail_list",
+    "has_model_id",
+    "health_check_ignore_transient_errors",
+    "health_state_cache",
+    "is_deployment_blocked",
+    "is_model_access_group_for_wildcard_route",
+    "is_recognized_model",
+    "kubernetes_pod_discovery",
+    "map_team_model",
+    "model_group_alias",
+    "model_list",
+    "model_name_to_deployment_indices",
+    "model_names",
+    "pattern_router",
+    "priority_header_update",
+    "prompt_caching_pin_cache",
+    "provider_budget_config",
+    "quality_routers",
+    "resolve_model_name_from_model_id",
+    "resolve_served_model_name",
+    "resolved_litellm_models",
+    "routable_model_group",
+    "router_general_settings",
+    "routing_groups",
+    "routing_plugins",
+    "schedule_acompletion",
+    "search_tools",
+    "serve_through_request_logging",
+    "should_include_deployment",
+    "split_request_priority",
+    "team_model_to_deployment_indices",
+    "team_pattern_routers",
+    "team_ptu_ceiling",
+    "team_public_model_names",
+    "team_public_model_names_of",
+    "update_redis_cache",
+    "update_settings",
+    "upsert_deployment",
+    "wildcard_route_deployments",
+    "wildcard_routed_models"
+  ],
+  "members_router_family": [
+    "_count_pre_call_check_tokens",
+    "_pre_call_checks",
+    "_update_kwargs_before_fallbacks",
+    "acompletion",
+    "adecisions",
+    "aembedding",
+    "allowed_fails",
+    "allowed_fails_policy",
+    "aresponses",
+    "async_function_with_fallbacks",
+    "async_get_healthy_deployments",
+    "cache",
+    "cached_deployment_model_info",
+    "cooldown_cache",
+    "cooldown_time",
+    "default_max_parallel_requests",
+    "deployments_named",
+    "disable_cooldowns",
+    "embedding",
+    "enable_pre_call_checks",
+    "enable_tag_filtering",
+    "explicit_allowed_fails",
+    "fallback_access_check",
+    "fallback_budget_check",
+    "fallbacks",
+    "get_all_deployments",
+    "get_allowed_fails_from_policy",
+    "get_deployment",
+    "get_model_group",
+    "get_model_ids",
+    "get_model_info",
+    "get_model_list",
+    "get_router_model_info",
+    "log_retry",
+    "model_list",
+    "provider_default_deployment_ids",
+    "routing_group_has_alternatives",
+    "routing_strategy",
+    "search_tools",
+    "set_custom_routing_strategy",
+    "slack_alerting_logger",
+    "tag_filtering_match_any",
+    "tag_routing_prefix",
+    "team_model_has_alternatives"
+  ],
+  "router_utils_imports_outside": [
+    "litellm.router_utils.access_windows",
+    "litellm.router_utils.add_retry_fallback_headers",
+    "litellm.router_utils.clientside_credential_handler",
+    "litellm.router_utils.common_utils",
+    "litellm.router_utils.cooldown_handlers",
+    "litellm.router_utils.deployment_pricing",
+    "litellm.router_utils.fallback_event_handlers",
+    "litellm.router_utils.get_retry_from_policy",
+    "litellm.router_utils.health_state_cache",
+    "litellm.router_utils.pattern_match_deployments",
+    "litellm.router_utils.ptu_shares",
+    "litellm.router_utils.reasoning_effort_capability",
+    "litellm.router_utils.router_callbacks.track_deployment_metrics",
+    "litellm.router_utils.routing_groups",
+    "litellm.router_utils.search_api_router"
+  ]
+}
diff --git a/tests/code_coverage_tests/router_surface_check.py b/tests/code_coverage_tests/router_surface_check.py
new file mode 100644
index 00000000000..0b35bac5240
--- /dev/null
+++ b/tests/code_coverage_tests/router_surface_check.py
@@ -0,0 +1,235 @@
+"""
+Fence for the Router's public surface.
+
+Code outside the router may use only the Router members listed in
+router_surface_allowlist.json, and may import only the litellm.router_utils
+modules listed there. The lists hold what is used today and may only shrink:
+
+- a member or module used outside the router that is not listed fails the
+  check (use an existing entry point instead, or discuss widening the surface);
+- a listed member or module that nothing outside the router uses any more
+  also fails, so the entry is removed in the same change.
+
+"Outside" means every non-test file under litellm/ and enterprise/ except
+litellm/router.py and the router's own modules. Uses from the router family
+(litellm/router_utils, litellm/router_strategy) are listed separately, because
+those modules become private parts of the router core in a later step.
+
+Member uses are found the same way the boundary survey found them: attribute
+access on a receiver whose name looks like a router (llm_router,
+litellm_router_instance, router, ...) or on the Router class, plus
+getattr/setattr/hasattr with a constant name on such a receiver. Members
+include the container file endpoints Router.__init__ registers by name.
+
+Run: python tests/code_coverage_tests/router_surface_check.py [--write]
+--write regenerates the allowlist from the current tree (for shrinking it).
+"""
+
+import ast
+import json
+import os
+import re
+import sys
+from typing import Dict, List, Set
+
+ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+ALLOWLIST = os.path.join(os.path.dirname(__file__), "router_surface_allowlist.json")
+
+ROUTER_FILES = {
+    "litellm/router.py",
+}
+ROUTER_CLASS_FILES = ["litellm/router.py"]
+ROUTER_CLASS_NAMES = {"Router"}
+
+SCAN_ROOTS = ["litellm", "enterprise"]
+SKIP_DIRS = {
+    ".git",
+    "node_modules",
+    ".venv",
+    "__pycache__",
+    "litellm-rust",
+    "ui",
+    "docs",
+    "cookbook",
+    "tests",
+    "test",
+}
+
+RECEIVER = re.compile(
+    r"(^|[._])(llm_router|router|litellm_router|litellm_router_instance|router_instance"
+    r"|_router|proxy_router|llm_router_instance|router_obj|mock_router|Router)$"
+)
+# Router.__init__ registers these with setattr(self, name, ...), so they never appear as self.<name>.
+CONTAINER_FILE_ENDPOINTS = "litellm/containers/endpoints.json"
+DYNAMIC_FUNCS = {"getattr", "setattr", "hasattr"}
+
+
+def _area(rel: str) -> str:
+    if rel.startswith(("litellm/router_utils/", "litellm/router_strategy/")):
+        return "router_family"
+    return "outside"
+
+
+def _is_test(rel: str) -> bool:
+    name = os.path.basename(rel)
+    return "/tests/" in rel or name.startswith("test_") or name.endswith("_test.py")
+
+
+def router_members() -> Set[str]:
+    members: Set[str] = set()
+    for rel in ROUTER_CLASS_FILES:
+        with open(os.path.join(ROOT, rel), encoding="utf-8") as f:
+            tree = ast.parse(f.read())
+        for cls in tree.body:
+            if not isinstance(cls, ast.ClassDef) or cls.name not in ROUTER_CLASS_NAMES:
+                continue
+            for node in cls.body:
+                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    members.add(node.name)
+                elif isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
+                    members.add(node.target.id)
+                elif isinstance(node, ast.Assign):
+                    members.update(t.id for t in node.targets if isinstance(t, ast.Name))
+            for node in ast.walk(cls):
+                if (
+                    isinstance(node, ast.Attribute)
+                    and isinstance(node.value, ast.Name)
+                    and node.value.id == "self"
+                    and isinstance(node.ctx, ast.Store)
+                ):
+                    members.add(node.attr)
+    with open(os.path.join(ROOT, CONTAINER_FILE_ENDPOINTS), encoding="utf-8") as f:
+        for endpoint in json.load(f)["endpoints"]:
+            members.update((endpoint["name"], endpoint["async_name"]))
+    return {m for m in members if not (m.startswith("__") and m.endswith("__"))}
+
+
+def _python_files():
+    for top in SCAN_ROOTS:
+        base = os.path.join(ROOT, top)
+        for dirpath, dirnames, filenames in os.walk(base):
+            dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS]
+            for fn in filenames:
+                if fn.endswith(".py"):
+                    path = os.path.join(dirpath, fn)
+                    yield os.path.relpath(path, ROOT).replace(os.sep, "/"), path
+
+
+def scan() -> Dict[str, Dict[str, Set[str]]]:
+    """Return {"members": {area: {member: files}}, "router_utils_imports": {module: files}}."""
+    members = router_members()
+    uses: Dict[str, Dict[str, Set[str]]] = {"outside": {}, "router_family": {}}
+    imports: Dict[str, Set[str]] = {}
+    for rel, path in _python_files():
+        if rel in ROUTER_FILES or _is_test(rel):
+            continue
+        with open(path, encoding="utf-8") as f:
+            src = f.read()
+        has_router = "router" in src.lower()
+        if not has_router:
+            continue
+        try:
+            tree = ast.parse(src)
+        except SyntaxError:
+            continue
+        area = _area(rel)
+        for name in member_uses(tree, members):
+            uses[area].setdefault(name, set()).add(rel)
+        if area == "outside":
+            for node in ast.walk(tree):
+                for mod in _router_utils_modules(node):
+                    imports.setdefault(mod, set()).add(rel)
+    return {"members": uses, "router_utils_imports": imports}
+
+
+def member_uses(tree: ast.AST, members: Set[str]) -> Set[str]:
+    """The Router members a module uses, on an instance or on the Router class itself."""
+    used: Set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Attribute) and node.attr in members:
+            if RECEIVER.search(ast.unparse(node.value)):
+                used.add(node.attr)
+        elif (
+            isinstance(node, ast.Call)
+            and isinstance(node.func, ast.Name)
+            and node.func.id in DYNAMIC_FUNCS
+            and len(node.args) >= 2
+            and isinstance(node.args[1], ast.Constant)
+            and node.args[1].value in members
+            and RECEIVER.search(ast.unparse(node.args[0]))
+        ):
+            used.add(node.args[1].value)
+    return used
+
+
+def _router_utils_modules(node: ast.AST) -> List[str]:
+    if isinstance(node, ast.ImportFrom) and node.module:
+        if node.module == "litellm.router_utils":
+            return ["litellm.router_utils." + a.name for a in node.names]
+        if node.module.startswith("litellm.router_utils."):
+            return [node.module]
+    if isinstance(node, ast.Import):
+        return [a.name for a in node.names if a.name.startswith("litellm.router_utils.")]
+    return []
+
+
+def build_allowlist(found) -> dict:
+    return {
+        "_doc": (
+            "Router members and litellm.router_utils modules used outside the router. "
+            "Shrink-only: see tests/code_coverage_tests/router_surface_check.py."
+        ),
+        "members_outside": sorted(found["members"]["outside"]),
+        "members_router_family": sorted(found["members"]["router_family"]),
+        "router_utils_imports_outside": sorted(found["router_utils_imports"]),
+    }
+
+
+def compare(allow: dict, found) -> List[str]:
+    errors: List[str] = []
+    sections = [
+        ("members_outside", found["members"]["outside"], "Router member"),
+        ("members_router_family", found["members"]["router_family"], "Router member (router family)"),
+        ("router_utils_imports_outside", found["router_utils_imports"], "litellm.router_utils import"),
+    ]
+    for key, used, what in sections:
+        listed = set(allow.get(key, []))
+        for name in sorted(set(used) - listed):
+            files = ", ".join(sorted(used[name]))
+            errors.append(
+                f"new {what} outside the router: {name!r} in {files}. The router surface may only "
+                f"shrink: use an entry point instead."
+            )
+        for name in sorted(listed - set(used)):
+            errors.append(
+                f"{what} {name!r} is listed in {os.path.basename(ALLOWLIST)} [{key}] but nothing uses it "
+                f"any more: remove it from the list."
+            )
+    return errors
+
+
+def main(argv: List[str]) -> int:
+    found = scan()
+    if "--write" in argv:
+        with open(ALLOWLIST, "w", encoding="utf-8") as f:
+            json.dump(build_allowlist(found), f, indent=2)
+            f.write("\n")
+        print(f"wrote {ALLOWLIST}")
+        return 0
+    with open(ALLOWLIST, encoding="utf-8") as f:
+        allow = json.load(f)
+    errors = compare(allow, found)
+    for e in errors:
+        print(e)
+    if errors:
+        return 1
+    print(
+        f"router surface ok: {len(allow['members_outside'])} members outside, "
+        f"{len(allow['members_router_family'])} from the router family, "
+        f"{len(allow['router_utils_imports_outside'])} router_utils modules imported outside"
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))
diff --git a/tests/code_coverage_tests/unbounded_in_baseline.txt b/tests/code_coverage_tests/unbounded_in_baseline.txt
index 1da964681a9..d8c6e2241f4 100644
--- a/tests/code_coverage_tests/unbounded_in_baseline.txt
+++ b/tests/code_coverage_tests/unbounded_in_baseline.txt
@@ -129,4 +129,4 @@ litellm/proxy/utils.py prefetch_config_params prisma param_name.in `param_names`
 litellm/repositories/daily_activity_repository.py DailyActivityRepository.daily_rows prisma [scope.entity_id_field].in `list(scope.entity_ids)` 0
 litellm/repositories/daily_activity_repository.py DailyActivityRepository.daily_rows prisma api_key.in `list(scope.api_keys)` 0
 litellm/repositories/daily_activity_repository.py DailyActivityRepository.daily_rows prisma not.in `list(scope.exclude_entity_ids)` 0
-litellm/router_utils/auto_router_model_naming.py <module> raw-sql classifier_type.IN `IN ({_LLM_CLASSIFIER_TYPES_SQL})` 0
+litellm/router_strategy/auto_router/auto_router_model_naming.py <module> raw-sql classifier_type.IN `IN ({_LLM_CLASSIFIER_TYPES_SQL})` 0
diff --git a/tests/integration/database/test_accounting_ledger.py b/tests/integration/database/test_accounting_ledger.py
index 089ed872dee..0c2ceb62eaf 100644
--- a/tests/integration/database/test_accounting_ledger.py
+++ b/tests/integration/database/test_accounting_ledger.py
@@ -1,16 +1,48 @@
+from __future__ import annotations
+
+import asyncio
+import json
 import os
 import subprocess
 import sys
-from collections.abc import Iterator
+from collections.abc import AsyncGenerator, AsyncIterator, Iterator, Mapping, Sequence
+from contextlib import asynccontextmanager
+from datetime import datetime, timezone
+from decimal import Decimal
+from itertools import chain
 from pathlib import Path
-from typing import Final
+from typing import TYPE_CHECKING, Final, TypeAlias
 
 import psycopg
 import pytest
+import pytest_asyncio
 from psycopg import sql
+from pydantic import JsonValue
 
-from litellm.accounting import DeliveryState, DeliveryTarget, EventKind
+from litellm.accounting import (
+    CostEvent,
+    DeliveryState,
+    DeliveryTarget,
+    EventKind,
+    InboundUsageEvent,
+    Metric,
+    MetricName,
+    OutboundUsageEvent,
+    Outcome,
+    PricingSnapshot,
+)
+from litellm.proxy.db import accounting_ledger
+from litellm.proxy.db.accounting_ledger import AccountingConflictError, AccountingEvent, AccountingLedger
+from litellm.types.utils import CallTypes
 from tests.integration._support.database import scratch_database
+from tests.integration._support.prisma_clients import connected_proxy_prisma
+
+if TYPE_CHECKING:
+    from prisma import Prisma
+
+    from litellm.proxy.utils import PrismaClient
+
+_Writer: TypeAlias = tuple["PrismaClient", AccountingLedger]
 
 _SCHEMA: Final = Path(__file__).resolve().parents[3] / "litellm-proxy-extras/litellm_proxy_extras/schema.prisma"
 _EVENT_INSERT: Final = (
@@ -126,3 +158,377 @@ def test_new_delivery_defaults_to_pending_with_no_attempts(ledger: psycopg.Conne
         (DeliveryTarget.KEY_SPEND.value,),
     ).fetchone()
     assert row == ("pending", 0)
+
+
+_AT: Final = datetime(2026, 1, 1, tzinfo=timezone.utc)
+_CUTOFF: Final = datetime(2026, 2, 1, tzinfo=timezone.utc)
+_TARGETS: Final = (DeliveryTarget.USER_SPEND, DeliveryTarget.TEAM_SPEND)
+
+
+def _usage(event_id: str = "usage", *, inbound: bool = False) -> InboundUsageEvent | OutboundUsageEvent:
+    fields: Final = dict(
+        event_id=event_id,
+        request_id="request",
+        call_type=CallTypes.completion,
+        started_at=_AT,
+        ended_at=_AT,
+        outcome=Outcome.SUCCEEDED,
+        dimensions=(),
+    )
+    if inbound:
+        return InboundUsageEvent(**fields, metrics=(Metric(name=MetricName.REQUESTS, value=Decimal(1)),))
+    return OutboundUsageEvent(**fields, attempt_id=event_id, retry_of_attempt_id=None, metrics=None)
+
+
+def _cost(source: str = "usage", event_id: str = "cost", amount: str = "0.125") -> CostEvent:
+    return CostEvent(
+        event_id=event_id,
+        usage_event_id=source,
+        occurred_at=_AT,
+        dimensions=(),
+        charges=(Metric(name=MetricName.SPEND, value=Decimal(amount), unit="USD"),),
+        snapshot=PricingSnapshot(
+            calculator_version="fixture",
+            model="fixture",
+            provider=None,
+            pricing_source="cost_map",
+            priced_model_key="fixture",
+            total_cost=Decimal(amount),
+        ),
+    )
+
+
+def _envelope(event: AccountingEvent, *, context: Mapping[str, JsonValue] | None = None) -> str:
+    return json.dumps({"event": event.model_dump(mode="json"), "context": context or {}})
+
+
+async def _insert(
+    store: AccountingLedger,
+    event: AccountingEvent,
+    targets: tuple[DeliveryTarget, ...] = _TARGETS,
+    *,
+    context: Mapping[str, JsonValue] | None = None,
+) -> str:
+    return await store.insert_event(event, targets, envelope=_envelope(event, context=context))
+
+
+def _rows(database_url: str, statement: str, parameters: tuple[object, ...] = ()) -> Sequence[tuple[object, ...]]:
+    with psycopg.connect(database_url) as connection:
+        cursor: Final = connection.execute(statement, parameters)
+        return cursor.fetchall() if cursor.description is not None else []
+
+
+def _complete_and_age(database_url: str) -> None:
+    with psycopg.connect(database_url) as connection:
+        connection.execute('UPDATE "LiteLLM_AccountingEvent" SET recorded_at = %s', (_AT,))
+        connection.execute("UPDATE \"LiteLLM_AccountingDelivery\" SET state = 'applied', applied_at = %s", (_AT,))
+
+
+@pytest_asyncio.fixture(loop_scope="function")
+async def writer(ledger_database: str, monkeypatch: pytest.MonkeyPatch) -> AsyncIterator[_Writer]:
+    monkeypatch.setenv("DATABASE_URL", ledger_database)
+    monkeypatch.delenv("DATABASE_URL_READ_REPLICA", raising=False)
+    _rows(ledger_database, 'TRUNCATE "LiteLLM_AccountingDelivery", "LiteLLM_AccountingEvent"')
+    async with connected_proxy_prisma(ledger_database) as client:
+        yield client, AccountingLedger.for_client(client)
+
+
+@pytest.mark.asyncio
+async def test_event_and_complete_delivery_set_commit_together(writer: _Writer, ledger_database: str) -> None:
+    _, store = writer
+    event: Final = _usage()
+    assert await _insert(store, event, context={"requested_region": "eu", "quantity": "1.25"}) == "inserted"
+    rows: Final = _rows(ledger_database, 'SELECT kind::text, source_event_id, payload FROM "LiteLLM_AccountingEvent"')
+    assert rows == [
+        ("outbound_usage", None, json.loads(_envelope(event, context={"requested_region": "eu", "quantity": "1.25"})))
+    ]
+    deliveries: Final = _rows(
+        ledger_database, 'SELECT target::text, state::text, attempts FROM "LiteLLM_AccountingDelivery"'
+    )
+    assert set(deliveries) == {(target.value, "pending", 0) for target in _TARGETS}
+
+
+@pytest.mark.asyncio
+async def test_concurrent_duplicates_preserve_completed_deliveries(writer: _Writer, ledger_database: str) -> None:
+    _, store = writer
+    event: Final = _usage(inbound=True)
+    results: Final = await asyncio.gather(*(_insert(store, event) for _ in range(8)))
+    assert results.count("inserted") == 1 and results.count("duplicate") == 7
+    _complete_and_age(ledger_database)
+    before: Final = _rows(ledger_database, 'SELECT * FROM "LiteLLM_AccountingDelivery" ORDER BY target')
+    reordered: Final = json.dumps(json.loads(_envelope(event)), sort_keys=True, indent=2)
+    assert await store.insert_event(event, tuple(reversed(_TARGETS)) + _TARGETS, envelope=reordered) == "duplicate"
+    assert _rows(ledger_database, 'SELECT * FROM "LiteLLM_AccountingDelivery" ORDER BY target') == before
+    assert _rows(ledger_database, 'SELECT count(*) FROM "LiteLLM_AccountingEvent"') == [(1,)]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("change", ["payload", "context", "targets", "schema_version", "version"])
+async def test_conflicting_acceptance_cannot_overwrite_or_add_work(
+    writer: _Writer, ledger_database: str, change: str
+) -> None:
+    _, store = writer
+    event: Final = _usage()
+    await _insert(store, event)
+    altered: Final = event.model_copy(update={"outcome": Outcome.FAILED}) if change == "payload" else event
+    targets: Final = (DeliveryTarget.KEY_SPEND,) if change == "targets" else _TARGETS
+    context: Final = {"override": "0.5"} if change == "context" else {}
+    options: Final = {change: 2} if change in ("schema_version", "version") else {}
+    with pytest.raises(AccountingConflictError, match="conflicts"):
+        await store.insert_event(altered, targets, envelope=_envelope(altered, context=context), **options)
+    assert _rows(ledger_database, 'SELECT payload FROM "LiteLLM_AccountingEvent"') == [(json.loads(_envelope(event)),)]
+    assert set(_rows(ledger_database, 'SELECT target::text FROM "LiteLLM_AccountingDelivery"')) == {
+        (t.value,) for t in _TARGETS
+    }
+
+
+@pytest.mark.asyncio
+async def test_competing_cost_identities_accept_only_one_authoritative_charge(
+    writer: _Writer, ledger_database: str
+) -> None:
+    _, store = writer
+    await _insert(store, _usage())
+    results: Final = await asyncio.gather(
+        _insert(store, _cost()), _insert(store, _cost(event_id="other-cost")), return_exceptions=True
+    )
+    assert sum(result == "inserted" for result in results) == 1
+    assert sum(isinstance(result, AccountingConflictError) for result in results) == 1
+    accepted: Final = _rows(
+        ledger_database, "SELECT event_id, payload FROM \"LiteLLM_AccountingEvent\" WHERE kind = 'cost'"
+    )
+    assert len(accepted) == 1
+    event: Final = CostEvent.model_validate_json(json.dumps(accepted[0][1]["event"]))
+    assert await _insert(store, event) == "duplicate"
+    assert event.snapshot.total_cost == Decimal("0.125")
+    with pytest.raises(AccountingConflictError):
+        await _insert(store, _cost(event_id=event.event_id, amount="0.5"))
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("source", ["missing", "inbound", "cost"])
+async def test_cost_requires_an_existing_outbound_source(writer: _Writer, ledger_database: str, source: str) -> None:
+    _, store = writer
+    if source == "inbound":
+        await _insert(store, _usage("source", inbound=True))
+    if source == "cost":
+        await _insert(store, _usage())
+        await _insert(store, _cost(event_id="source"))
+    with pytest.raises(AccountingConflictError, match="outbound usage"):
+        await _insert(store, _cost(source="source", event_id="invalid"))
+    assert _rows(ledger_database, "SELECT count(*) FROM \"LiteLLM_AccountingEvent\" WHERE event_id = 'invalid'") == [
+        (0,)
+    ]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("failure", ["before_commit", "after_commit", "cancellation"])
+async def test_interruption_rolls_back_or_retry_recognizes_commit(
+    writer: _Writer, ledger_database: str, failure: str
+) -> None:
+    client, store = writer
+
+    @asynccontextmanager
+    async def interrupted() -> AsyncGenerator[Prisma]:
+        async with client.writer_db.tx() as tx:
+            yield tx
+            if failure == "before_commit":
+                raise RuntimeError("injected pre-commit failure")
+            if failure == "cancellation":
+                raise asyncio.CancelledError
+        raise RuntimeError("injected lost acknowledgement")
+
+    error: Final = asyncio.CancelledError if failure == "cancellation" else RuntimeError
+    with pytest.raises(error):
+        await _insert(AccountingLedger(interrupted), _usage())
+    expected: Final = 1 if failure == "after_commit" else 0
+    assert _rows(ledger_database, 'SELECT count(*) FROM "LiteLLM_AccountingEvent"') == [(expected,)]
+    assert _rows(ledger_database, 'SELECT count(*) FROM "LiteLLM_AccountingDelivery"') == [(expected * len(_TARGETS),)]
+    assert await _insert(store, _usage()) == ("duplicate" if expected else "inserted")
+
+
+@pytest.mark.asyncio
+async def test_delivery_insert_failure_rolls_back_event(writer: _Writer, ledger_database: str) -> None:
+    from prisma.errors import RawQueryError
+
+    _, store = writer
+    with psycopg.connect(ledger_database) as connection:
+        connection.execute(
+            'ALTER TABLE "LiteLLM_AccountingDelivery" ADD CONSTRAINT reject_delivery CHECK (version < 1)'
+        )
+    try:
+        with pytest.raises(RawQueryError, match="reject_delivery"):
+            await _insert(store, _usage())
+        assert _rows(ledger_database, 'SELECT count(*) FROM "LiteLLM_AccountingEvent"') == [(0,)]
+    finally:
+        with psycopg.connect(ledger_database) as connection:
+            connection.execute('ALTER TABLE "LiteLLM_AccountingDelivery" DROP CONSTRAINT reject_delivery')
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("blocked", ["pending", "parked", "unpriced", "recent_cost", "recovery"])
+async def test_retention_preserves_incomplete_or_recovery_needed_families(
+    writer: _Writer, ledger_database: str, blocked: str
+) -> None:
+    _, store = writer
+    await _insert(store, _usage())
+    if blocked != "unpriced":
+        await _insert(store, _cost())
+    _complete_and_age(ledger_database)
+    with psycopg.connect(ledger_database) as connection:
+        if blocked in ("pending", "parked"):
+            connection.execute(
+                "UPDATE \"LiteLLM_AccountingDelivery\" SET state = %s WHERE event_id = 'cost'", (blocked,)
+            )
+        if blocked == "recent_cost":
+            connection.execute(
+                "UPDATE \"LiteLLM_AccountingEvent\" SET recorded_at = %s WHERE event_id = 'cost'", (_CUTOFF,)
+            )
+    before: Final = _rows(ledger_database, 'SELECT event_id FROM "LiteLLM_AccountingEvent" ORDER BY event_id')
+    assert (
+        await store.purge_completed(
+            redelivery_before=_CUTOFF, recovery_before=_AT if blocked == "recovery" else _CUTOFF
+        )
+        == 0
+    )
+    assert _rows(ledger_database, 'SELECT event_id FROM "LiteLLM_AccountingEvent" ORDER BY event_id') == before
+
+
+@pytest.mark.asyncio
+async def test_retention_removes_completed_family_and_receipts_together(writer: _Writer, ledger_database: str) -> None:
+    _, store = writer
+    await _insert(store, _usage())
+    await _insert(store, _cost())
+    _complete_and_age(ledger_database)
+    assert await store.purge_completed(redelivery_before=_CUTOFF, recovery_before=_CUTOFF) == 2
+    assert _rows(ledger_database, 'SELECT count(*) FROM "LiteLLM_AccountingEvent"') == [(0,)]
+    assert _rows(ledger_database, 'SELECT count(*) FROM "LiteLLM_AccountingDelivery"') == [(0,)]
+
+
+@pytest.mark.asyncio
+async def test_retention_respects_batch_bound_and_skips_locked_families(writer: _Writer, ledger_database: str) -> None:
+    client, store = writer
+    for name in ("a", "b", "c"):
+        await _insert(store, _usage(name, inbound=True))
+    _complete_and_age(ledger_database)
+    async with client.writer_db.tx() as tx:
+        await tx.query_raw("SELECT event_id FROM \"LiteLLM_AccountingEvent\" WHERE event_id = 'a' FOR UPDATE")
+        assert await store.purge_completed(redelivery_before=_CUTOFF, recovery_before=_CUTOFF, limit=1) == 1
+        assert _rows(ledger_database, 'SELECT event_id FROM "LiteLLM_AccountingEvent" ORDER BY event_id') == [
+            ("a",),
+            ("c",),
+        ]
+    assert await store.purge_completed(redelivery_before=_CUTOFF, recovery_before=_CUTOFF) == 2
+
+
+@pytest.mark.asyncio
+async def test_retention_makes_progress_past_pending_and_unpriced_events(writer: _Writer, ledger_database: str) -> None:
+    _, store = writer
+    await _insert(store, _usage("a", inbound=True))
+    await _insert(store, _usage("b"))
+    await _insert(store, _usage("c", inbound=True))
+    _complete_and_age(ledger_database)
+    _rows(ledger_database, "UPDATE \"LiteLLM_AccountingDelivery\" SET state = 'pending' WHERE event_id = 'a'")
+    assert await store.purge_completed(redelivery_before=_CUTOFF, recovery_before=_CUTOFF, limit=1) == 1
+    assert _rows(ledger_database, 'SELECT event_id FROM "LiteLLM_AccountingEvent" ORDER BY event_id') == [
+        ("a",),
+        ("b",),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_zero_cost_and_empty_delivery_sets_are_durable(writer: _Writer, ledger_database: str) -> None:
+    _, store = writer
+    await _insert(store, _usage(), targets=())
+    event: Final = _cost(amount="0")
+    assert await _insert(store, event, targets=()) == "inserted"
+    assert await _insert(store, event, targets=()) == "duplicate"
+    assert _rows(ledger_database, 'SELECT count(*) FROM "LiteLLM_AccountingDelivery"') == [(0,)]
+    _complete_and_age(ledger_database)
+    assert await store.purge_completed(redelivery_before=_CUTOFF, recovery_before=_CUTOFF) == 2
+
+
+@pytest.mark.asyncio
+async def test_retention_cannot_delete_source_while_cost_acceptance_is_uncommitted(
+    writer: _Writer, ledger_database: str
+) -> None:
+    client, store = writer
+    await _insert(store, _usage())
+    _complete_and_age(ledger_database)
+    inserted: Final = asyncio.Event()
+    release: Final = asyncio.Event()
+
+    @asynccontextmanager
+    async def paused_commit() -> AsyncGenerator[Prisma]:
+        async with client.writer_db.tx() as tx:
+            yield tx
+            inserted.set()
+            await release.wait()
+
+    task: Final = asyncio.create_task(_insert(AccountingLedger(paused_commit), _cost()))
+    try:
+        await asyncio.wait_for(inserted.wait(), timeout=5)
+        assert await store.purge_completed(redelivery_before=_CUTOFF, recovery_before=_CUTOFF) == 0
+    finally:
+        release.set()
+        await task
+    assert _rows(ledger_database, 'SELECT event_id FROM "LiteLLM_AccountingEvent" ORDER BY event_id') == [
+        ("cost",),
+        ("usage",),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_retention_failure_rolls_back_event_and_receipt_deletion(writer: _Writer, ledger_database: str) -> None:
+    client, store = writer
+    await _insert(store, _usage(inbound=True))
+    _complete_and_age(ledger_database)
+
+    @asynccontextmanager
+    async def interrupted() -> AsyncGenerator[Prisma]:
+        async with client.writer_db.tx() as tx:
+            yield tx
+            raise RuntimeError("injected cleanup failure")
+
+    with pytest.raises(RuntimeError, match="cleanup failure"):
+        await AccountingLedger(interrupted).purge_completed(redelivery_before=_CUTOFF, recovery_before=_CUTOFF)
+    assert _rows(ledger_database, 'SELECT count(*) FROM "LiteLLM_AccountingEvent"') == [(1,)]
+    assert _rows(ledger_database, 'SELECT count(*) FROM "LiteLLM_AccountingDelivery"') == [(len(_TARGETS),)]
+    assert await store.purge_completed(redelivery_before=_CUTOFF, recovery_before=_CUTOFF) == 1
+
+
+@pytest.mark.asyncio
+async def test_ledger_reads_and_writes_use_primary_when_replica_is_configured(
+    writer: _Writer, ledger_database: str, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    with scratch_database("replica") as replica_url:
+        monkeypatch.setenv("DATABASE_URL_READ_REPLICA", replica_url)
+        async with connected_proxy_prisma(ledger_database) as client:
+            store: Final = AccountingLedger.for_client(client)
+            await _insert(store, _usage())
+            assert await _insert(store, _usage()) == "duplicate"
+            assert await _insert(store, _cost()) == "inserted"
+            _complete_and_age(ledger_database)
+            assert await store.purge_completed(redelivery_before=_CUTOFF, recovery_before=_CUTOFF) == 2
+        assert _rows(replica_url, "SELECT to_regclass('public.\"LiteLLM_AccountingEvent\"')") == [(None,)]
+
+
+def _index_conditions(plan: object) -> tuple[tuple[object, object], ...]:
+    if isinstance(plan, dict):
+        own: Final = ((plan.get("Index Name"), plan.get("Index Cond")),) if "Index Name" in plan else ()
+        children: Final = (plan.get("Plan"), *plan.get("Plans", ()))
+        return own + tuple(chain.from_iterable(_index_conditions(child) for child in children if child is not None))
+    return tuple(chain.from_iterable(_index_conditions(item) for item in plan)) if isinstance(plan, list) else ()
+
+
+@pytest.mark.parametrize("statement", [accounting_ledger._DELETE_EVENTS, accounting_ledger._DELETE_DELIVERIES])
+def test_family_cleanup_lookups_use_the_kind_source_index(ledger_database: str, statement: str) -> None:
+    explained: Final = "EXPLAIN (FORMAT JSON) " + statement.replace("$1", "%s")
+    with psycopg.connect(ledger_database) as connection:
+        connection.execute("SET enable_seqscan = off")
+        plan: Final = connection.execute(explained, ("usage",) * statement.count("$1")).fetchone()
+    assert plan is not None
+    conditions: Final = _index_conditions(plan[0])
+    assert any(
+        name == "LiteLLM_AccountingEvent_kind_source_event_id_idx" and "source_event_id" in str(condition)
+        for name, condition in conditions
+    ), conditions
diff --git a/tests/integration/management/test_model_health_check.py b/tests/integration/management/test_model_health_check.py
index 57a05daca94..992c1e8e875 100644
--- a/tests/integration/management/test_model_health_check.py
+++ b/tests/integration/management/test_model_health_check.py
@@ -26,6 +26,20 @@ _DECISIONS_PROBE_REPLY: Final = JsonResponse(
         "usage": {"input_tokens": 10, "output_tokens": 1},
     },
 )
+_EXTRACTION_PROBE_REPLY: Final = JsonResponse(
+    content_type="application/json",
+    body={
+        "result": {
+            "model": "clairic",
+            "answers": {"reachable": {"type": "text", "value": "health", "confidence": 0.9}},
+            "truncated": False,
+            "usage": {"input_tokens": 10, "output_tokens": 0},
+        },
+        "success": True,
+        "errors": [],
+        "messages": [],
+    },
+)
 _CONFIGURED_PROBE_REPLY: Final = JsonResponse(
     content_type="application/json",
     body={
@@ -287,6 +301,29 @@ def test_decisions_mode_health_check_resolves_the_mode_from_the_cost_map_and_sen
         ]
 
 
+def test_extraction_mode_health_check_resolves_the_mode_from_the_cost_map_and_sends_the_extraction_probe(
+    gateway: Gateway,
+) -> None:
+    with gateway.scenario() as scenario:
+        handle: Final = register_scenario(f"health-extraction-{uuid.uuid4().hex[:12]}", _EXTRACTION_PROBE_REPLY)
+        scenario.cleanups.callback(delete_scenario, handle)
+        model: Final = scenario.model(
+            model="cloudflare/@cf/cloudflare/clairic", api_base=handle.api_base(), api_key="synthetic-cloudflare-key"
+        )
+        report: Final = _health_report(gateway, model)
+        assert (report["healthy_count"], report["unhealthy_count"]) == (1, 0), report
+        assert _probes_sent_to(gateway, handle) == [
+            (
+                f"/{handle.scenario_id}/ai/run/@cf/cloudflare/clairic",
+                {
+                    "model": "clairic",
+                    "state": os.environ.get("DEFAULT_HEALTH_CHECK_PROMPT", "test from litellm"),
+                    "fields": {"reachable": {"type": "text", "instructions": "Any word from the text"}},
+                },
+            )
+        ]
+
+
 @pytest.mark.parametrize("mode", ("decisions", "evaluation"), ids=("decisions", "legacy-evaluation"))
 def test_decisions_mode_health_check_sends_the_configured_state_and_questions(gateway: Gateway, mode: str) -> None:
     with gateway.scenario() as scenario:
diff --git a/tests/integration/mcp/test_mcp_llm_endpoints.py b/tests/integration/mcp/test_mcp_llm_endpoints.py
index 394221708bf..f751d1f8f4c 100644
--- a/tests/integration/mcp/test_mcp_llm_endpoints.py
+++ b/tests/integration/mcp/test_mcp_llm_endpoints.py
@@ -6,7 +6,7 @@ from concurrent.futures import ThreadPoolExecutor
 from contextlib import contextmanager
 from dataclasses import dataclass
 from hashlib import sha256
-from itertools import chain
+from itertools import chain, count
 from pathlib import Path
 from typing import Final, Literal, TypeVar
 
@@ -50,6 +50,7 @@ def _llm_gateway(tmp_path_factory: pytest.TempPathFactory) -> Iterator[tuple[Gat
     directory: Final = tmp_path_factory.mktemp("mcp-llm-gateway")
     stock: Final = JSON_OBJECT.validate_python(yaml.safe_load(Path("tests/integration/proxy_config.yaml").read_text()))
     config: Final = directory / "stored-responses.yaml"
+    (directory / f"{STREAM_BLOCK_MODULE}.py").write_text(STREAM_BLOCK_SOURCE)
     config.write_text(
         yaml.safe_dump(
             {
@@ -57,8 +58,17 @@ def _llm_gateway(tmp_path_factory: pytest.TempPathFactory) -> Iterator[tuple[Gat
                 "general_settings": {**object_value(stock["general_settings"]), "store_prompts_in_spend_logs": True},
                 "litellm_settings": {
                     **object_value(stock["litellm_settings"]),
-                    "cost_margin_config": {"hosted_vllm": {"fixed_amount": FIXED_MARGIN}},
+                    "cost_margin_config": {
+                        "hosted_vllm": {"fixed_amount": FIXED_MARGIN},
+                        "deepseek": {"fixed_amount": FIXED_MARGIN},
+                    },
                 },
+                "guardrails": [
+                    {
+                        "guardrail_name": STREAM_BLOCK,
+                        "litellm_params": {"guardrail": f"{STREAM_BLOCK_MODULE}.BlockGuard", "mode": "post_call"},
+                    }
+                ],
             }
         )
     )
@@ -79,7 +89,7 @@ def gateway(_llm_gateway: tuple[Gateway, Mapping[str, str]]) -> Iterator[Gateway
         yield private
 
 
-Surface = Literal["chat", "responses", "messages", "messages_bridge"]
+Surface = Literal["chat", "responses", "messages", "messages_bridge", "responses_bridge"]
 SURFACES: Final[tuple[Surface, ...]] = ("chat", "responses", "messages", "messages_bridge")
 ADD: Final = {"a": 2, "b": 3}
 ANSWER: Final = "the sum is 5"
@@ -88,6 +98,19 @@ AUTO: Final = {**GATEWAY_REF, "require_approval": "never"}
 OUTAGE: Final = "bridge-outage"
 DIRECT: Final = "answer-without-tools"
 FIXED_MARGIN: Final = 0.25
+STREAM_BLOCK: Final = "mcp-stream-block"
+STREAM_BLOCK_MODULE: Final = "mcp_stream_block"
+STREAM_BLOCK_DETAIL: Final = "blocked by output policy"
+STREAM_BLOCK_SOURCE: Final = (
+    "from fastapi import HTTPException\n\n"
+    "from litellm.integrations.custom_guardrail import CustomGuardrail\n\n\n"
+    "class BlockGuard(CustomGuardrail):\n"
+    "    async def async_post_call_streaming_iterator_hook(self, user_api_key_dict, response, request_data):\n"
+    "        async for _ in response:\n"
+    "            pass\n"
+    f'        raise HTTPException(status_code=400, detail="{STREAM_BLOCK_DETAIL}")\n'
+    "        yield\n"
+)
 JSON_OBJECT: Final = TypeAdapter(dict[str, JsonValue])
 JSON_VALUE: Final[TypeAdapter[JsonValue]] = TypeAdapter(JsonValue)
 
@@ -128,6 +151,8 @@ class Billing:
     first: tuple[int, int] = (10, 5)
     follow_up: tuple[int, int] = (10, 5)
     follow_up_fails: bool = False
+    follow_up_breaks: bool = False
+    tool_rounds: int = 1
 
 
 EVEN_ROUNDS: Final = Billing()
@@ -138,6 +163,10 @@ def _fixed_turn(tool: str) -> Callable[[Mapping[str, JsonValue]], Turn]:
     return lambda _: Turn(tool, json.dumps(ADD), ANSWER)
 
 
+def _slow_turn(tool: str, seconds: float) -> Callable[[Mapping[str, JsonValue]], Turn]:
+    return lambda _: Turn(tool, json.dumps({"seconds": seconds}), ANSWER)
+
+
 def _echoing_turn(body: Mapping[str, JsonValue]) -> Turn:
     names: Final = _tool_names(body)
     return Turn(names[0] if names else "", json.dumps({"query": _prompt(body)}), _tool_result_text(body) or "")
@@ -183,6 +212,50 @@ def _item_events(index: int, item: Mapping[str, JsonValue]) -> tuple[dict[str, J
     )
 
 
+def _event_stream(events: Sequence[Mapping[str, JsonValue]]) -> Reply:
+    return Reply(
+        content_type="text/event-stream",
+        chunks=tuple(
+            f"event: {event['type']}\ndata: {json.dumps({**event, 'sequence_number': number})}\n\n".encode()
+            for number, event in enumerate(events)
+        ),
+    )
+
+
+def _broken_follow_up(target: str, identity: str, tokens: tuple[int, int]) -> Reply:
+    outage: Final = {"message": FOLLOW_UP_OUTAGE, "type": "server_error", "code": None}
+    if target.endswith("/chat/completions"):
+        delta: Final = {"role": "assistant", "content": "the sum"}
+        started: Final = {
+            "id": f"chatcmpl-{identity}",
+            "object": "chat.completion.chunk",
+            "created": 1,
+            "model": "gpt-4o-mini",
+            "choices": [{"index": 0, "delta": delta, "finish_reason": None}],
+        }
+        return Reply(
+            content_type="text/event-stream",
+            chunks=tuple(f"data: {json.dumps(frame)}\n\n".encode() for frame in (started, {"error": outage})),
+        )
+    input_tokens, output_tokens = tokens
+    failed: Final[dict[str, JsonValue]] = {
+        "id": f"resp_{identity}",
+        "object": "response",
+        "created_at": 1,
+        "status": "failed",
+        "model": "gpt-4o-mini",
+        "output": [],
+        "error": {"code": "server_error", "message": FOLLOW_UP_OUTAGE},
+        "usage": {"input_tokens": input_tokens, "output_tokens": output_tokens, "total_tokens": sum(tokens)},
+    }
+    return _event_stream(
+        (
+            {"type": "response.created", "response": {**failed, "status": "in_progress", "error": None, "usage": None}},
+            {"type": "response.failed", "response": failed},
+        )
+    )
+
+
 def _responses_stream(response: Mapping[str, JsonValue], items: Sequence[Mapping[str, JsonValue]]) -> Reply:
     item_events: Final = tuple(chain.from_iterable(_item_events(index, item) for index, item in enumerate(items)))
     events: Final = (
@@ -191,13 +264,7 @@ def _responses_stream(response: Mapping[str, JsonValue], items: Sequence[Mapping
         *item_events,
         {"type": "response.completed", "response": response},
     )
-    return Reply(
-        content_type="text/event-stream",
-        chunks=tuple(
-            f"event: {event['type']}\ndata: {json.dumps({**event, 'sequence_number': number})}\n\n".encode()
-            for number, event in enumerate(events)
-        ),
-    )
+    return _event_stream(events)
 
 
 def _block_ids(message: JsonValue, kind: str, field: str) -> frozenset[str]:
@@ -252,6 +319,8 @@ def _anthropic_tool_result_rule(body: Mapping[str, JsonValue]) -> Reply | None:
 def _model_double(
     plan: Callable[[Mapping[str, JsonValue]], Turn], billing: Billing = EVEN_ROUNDS, parallel: int = 1
 ) -> Callable[[Request], Reply]:
+    served: Final = count()
+
     def respond(request: Request) -> Reply:
         if request.method == "GET" and request.target.endswith("/models"):
             return _json({"object": "list", "data": []})
@@ -260,11 +329,12 @@ def _model_double(
             outage: Final = {"error": {"message": "scripted provider outage", "type": "server_error", "code": None}}
             return Reply(status=500, body=json.dumps(outage).encode())
         turn: Final = plan(body)
+        call_number: Final = next(served)
         answered: Final = _has_tool_result(body)
         if answered and billing.follow_up_fails:
             failure: Final = {"error": {"message": FOLLOW_UP_OUTAGE, "type": "server_error", "code": None}}
             return Reply(status=500, body=json.dumps(failure).encode())
-        done: Final = answered or DIRECT in _prompt(body)
+        done: Final = DIRECT in _prompt(body) or (answered and call_number >= billing.tool_rounds)
         calls: Final = range(1, parallel + 1)
         prompt_tokens, completion_tokens = billing.follow_up if answered else billing.first
         identity: Final = uuid.uuid4().hex[:12]
@@ -273,9 +343,15 @@ def _model_double(
             "completion_tokens": completion_tokens,
             "total_tokens": prompt_tokens + completion_tokens,
         }
+        if answered and billing.follow_up_breaks:
+            return _broken_follow_up(request.target, identity, (prompt_tokens, completion_tokens))
         if request.target.endswith("/chat/completions"):
             requested: Final = tuple(
-                {"id": f"call_{call}", "type": "function", "function": {"name": turn.tool, "arguments": turn.arguments}}
+                {
+                    "id": f"call_{identity}_{call}",
+                    "type": "function",
+                    "function": {"name": turn.tool, "arguments": turn.arguments},
+                }
                 for call in calls
             )
             message: Final = (
@@ -460,6 +536,7 @@ def _upstream_model(surface: Surface) -> str:
         "responses": "openai/responses/gpt-4o-mini",
         "messages": "anthropic/claude-sonnet-4-5",
         "messages_bridge": "hosted_vllm/gpt-4o-mini",
+        "responses_bridge": "deepseek/gpt-4o-mini",
     }[surface]
 
 
@@ -475,11 +552,15 @@ def _rig(
     billing: Billing = EVEN_ROUNDS,
     prices: Mapping[str, JsonValue] | None = None,
     parallel: int = 1,
+    slow_tool_seconds: float | None = None,
 ) -> Iterator[Rig]:
     alias: Final = "llm" + uuid.uuid4().hex[:8]
+    plan: Final = (
+        _fixed_turn(f"{alias}-add") if slow_tool_seconds is None else _slow_turn(f"{alias}-slow", slow_tool_seconds)
+    )
     with (
-        mcp_peer() as peer,
-        wire_server(_model_double(_fixed_turn(f"{alias}-add"), billing, parallel)) as wire,
+        mcp_peer(rich=slow_tool_seconds is not None) as peer,
+        wire_server(_model_double(plan, billing, parallel)) as wire,
         gateway.scenario() as scenario,
     ):
         server_id: Final = register_mcp(scenario, peer, alias)
@@ -1048,6 +1129,262 @@ def test_bridged_next_turn_replays_the_mcp_turn_answer(gateway: Gateway) -> None
         assert ANSWER in _assistant_texts(opening), opening
 
 
+StreamedUpstream = Literal["messages_bridge", "responses_bridge"]
+STREAMED_UPSTREAMS: Final[tuple[StreamedUpstream, ...]] = ("messages_bridge", "responses_bridge")
+STREAMED_IDS: Final = ("native", "bridged")
+SLOW_TOOL_SECONDS: Final = 5.0
+
+
+def _events(response: httpx.Response) -> tuple[dict[str, JsonValue], ...]:
+    return tuple(
+        JSON_OBJECT.validate_json(line.removeprefix("data: "))
+        for line in response.text.splitlines()
+        if line.startswith("data: ") and line != "data: [DONE]"
+    )
+
+
+def _completed(response: httpx.Response) -> dict[str, JsonValue]:
+    finished: Final = tuple(
+        object_value(event["response"]) for event in _events(response) if event["type"] == "response.completed"
+    )
+    assert len(finished) == 1, response.text
+    return finished[0]
+
+
+def _model_rows(call_id: str, settled: Callable[[list[dict[str, JsonValue]]], bool]) -> list[dict[str, JsonValue]]:
+    return eventually(
+        lambda: read_rows(
+            "SELECT request_id, status, spend, prompt_tokens, completion_tokens "
+            'FROM "LiteLLM_SpendLogs" WHERE litellm_call_id=%s AND call_type NOT IN (%s, %s)',
+            (call_id, "call_mcp_tool", "list_mcp_tools"),
+        ),
+        settled,
+        seconds=70,
+        return_last_on_timeout=True,
+    )
+
+
+def _billed(rows: Sequence[Mapping[str, JsonValue]]) -> float:
+    return sum(float(str(row["spend"])) for row in rows)
+
+
+def _bills_at_least(expected: float) -> Callable[[list[dict[str, JsonValue]]], bool]:
+    return lambda rows: bool(rows) and _billed(rows) >= expected - 1e-9
+
+
+def _statuses(rows: Sequence[Mapping[str, JsonValue]]) -> list[str]:
+    return sorted(str(row["status"]) for row in rows)
+
+
+def _logs_a_failure_billing(expected: float) -> Callable[[list[dict[str, JsonValue]]], bool]:
+    return lambda rows: "failure" in _statuses(rows) and _billed(rows) >= expected - 1e-9
+
+
+def _limited_key(rig: Rig) -> str:
+    return rig.scenario.key(object_permission={"mcp_servers": [rig.server_id]}, max_parallel_requests=1)
+
+
+def _answers_directly(rig: Rig, key: str) -> int:
+    return rig.send(key, [AUTO], prompt=f"{DIRECT} {rig.alias}").status_code
+
+
+STREAMED_ROUNDS: Final = (
+    pytest.param("messages_bridge", 1, id="native"),
+    pytest.param("responses_bridge", 1, id="bridged"),
+    pytest.param("messages_bridge", 2, id="native-two-tool-rounds"),
+    pytest.param("responses_bridge", 2, id="bridged-two-tool-rounds"),
+    pytest.param("messages_bridge", 0, id="native-no-tool-call"),
+    pytest.param("responses_bridge", 0, id="bridged-no-tool-call"),
+)
+
+
+@pytest.mark.parametrize(("upstream", "tool_rounds"), STREAMED_ROUNDS)
+def test_streaming_responses_auto_execute_bills_every_round_once_on_one_success_row(
+    gateway: Gateway, upstream: StreamedUpstream, tool_rounds: int
+) -> None:
+    rounds: Final = (FIRST_ROUND, *(FOLLOW_UP_ROUND,) * tool_rounds)
+    billing: Final = Billing(FIRST_ROUND, FOLLOW_UP_ROUND, tool_rounds=max(tool_rounds, 1))
+    with _rig(gateway, "responses", upstream=upstream, billing=billing, prices=PRICES) as rig:
+        prompt: Final = None if tool_rounds else f"{DIRECT} {rig.alias}"
+        response: Final = rig.send(_granted_key(rig), [AUTO], prompt=prompt, stream=True)
+        assert response.status_code == 200, response.text
+        completed: Final = _completed(response)
+        assert rig.final_text(completed) == ANSWER, response.text
+        assert len(rig.upstream_tools()) == len(rounds)
+        assert len(_peer_add_calls(rig.peer)) == tool_rounds
+        expected: Final = _price(*rounds) + FIXED_MARGIN
+        rows: Final = _model_rows(response.headers["x-litellm-call-id"], _bills_at_least(expected))
+        assert [row["status"] for row in rows] == ["success"], rows
+        row: Final = rows[0]
+        assert (row["prompt_tokens"], row["completion_tokens"]) == (
+            sum(prompt_tokens for prompt_tokens, _ in rounds),
+            sum(completion_tokens for _, completion_tokens in rounds),
+        ), row
+        usage: Final = object_value(completed["usage"])
+        assert (usage["input_tokens"], usage["output_tokens"]) == (row["prompt_tokens"], row["completion_tokens"])
+        assert float(str(row["spend"])) == pytest.approx(expected), row
+
+
+@pytest.mark.parametrize("upstream", STREAMED_UPSTREAMS, ids=STREAMED_IDS)
+def test_streaming_responses_rejected_follow_up_bills_round_one_once(
+    gateway: Gateway, upstream: StreamedUpstream
+) -> None:
+    billing: Final = Billing(FIRST_ROUND, FOLLOW_UP_ROUND, follow_up_fails=True)
+    with _rig(gateway, "responses", upstream=upstream, billing=billing, prices=PRICES) as rig:
+        response: Final = rig.send(_granted_key(rig), [AUTO], stream=True)
+        assert FOLLOW_UP_OUTAGE in response.text, response.text
+        assert ANSWER not in response.text, response.text
+        assert len(rig.upstream_tools()) == 2
+        expected: Final = _price(FIRST_ROUND) + FIXED_MARGIN
+        rows: Final = _model_rows(response.headers["x-litellm-call-id"], _bills_at_least(expected))
+        assert _billed(rows) == pytest.approx(expected), rows
+
+
+BROKEN_FOLLOW_UPS: Final = (
+    pytest.param("messages_bridge", FOLLOW_UP_ROUND, id="native"),
+    pytest.param("responses_bridge", None, id="bridged"),
+)
+
+
+@pytest.mark.parametrize(("upstream", "reported_usage"), BROKEN_FOLLOW_UPS)
+def test_streaming_responses_follow_up_broken_mid_stream_bills_round_one_once_and_itself_on_a_failure_row(
+    gateway: Gateway, upstream: StreamedUpstream, reported_usage: tuple[int, int] | None
+) -> None:
+    billing: Final = Billing(FIRST_ROUND, FOLLOW_UP_ROUND, follow_up_breaks=True)
+    with _rig(gateway, "responses", upstream=upstream, billing=billing, prices=PRICES) as rig:
+        response: Final = rig.send(_granted_key(rig), [AUTO], stream=True)
+        assert ANSWER not in response.text, response.text
+        assert len(rig.upstream_tools()) == 2
+        round_one: Final = _price(FIRST_ROUND) + FIXED_MARGIN
+        rows: Final = _model_rows(response.headers["x-litellm-call-id"], _logs_a_failure_billing(round_one))
+        assert _statuses(rows) == ["failure", "success"], rows
+        (success,) = (row for row in rows if row["status"] == "success")
+        (failure,) = (row for row in rows if row["status"] == "failure")
+        assert (success["prompt_tokens"], success["completion_tokens"]) == FIRST_ROUND, rows
+        assert float(str(success["spend"])) == pytest.approx(round_one), rows
+        failed_round: Final = (int(str(failure["prompt_tokens"])), int(str(failure["completion_tokens"])))
+        assert min(failed_round) > 0, rows
+        assert reported_usage in (None, failed_round), rows
+        assert float(str(failure["spend"])) == pytest.approx(_price(failed_round)), rows
+
+
+@pytest.mark.parametrize("upstream", STREAMED_UPSTREAMS, ids=STREAMED_IDS)
+def test_streaming_responses_blocked_by_a_post_call_guardrail_bills_every_round_once(
+    gateway: Gateway, upstream: StreamedUpstream
+) -> None:
+    billing: Final = Billing(FIRST_ROUND, FOLLOW_UP_ROUND)
+    with _rig(gateway, "responses", upstream=upstream, billing=billing, prices=PRICES) as rig:
+        key: Final = _granted_key(rig)
+        one_round: Final = rig.send(key, [], prompt=f"{DIRECT} {rig.alias}", stream=True, guardrails=[STREAM_BLOCK])
+        assert STREAM_BLOCK_DETAIL in one_round.text, one_round.text
+        one_round_rows: Final = _model_rows(
+            one_round.headers["x-litellm-call-id"], _logs_a_failure_billing(_price(FIRST_ROUND) + FIXED_MARGIN)
+        )
+        rig.wire.drain()
+        response: Final = rig.send(key, [AUTO], stream=True, guardrails=[STREAM_BLOCK])
+        assert STREAM_BLOCK_DETAIL in response.text, response.text
+        assert len(rig.upstream_tools()) == 2 and len(_peer_add_calls(rig.peer)) == 1
+        expected: Final = _price(FIRST_ROUND, FOLLOW_UP_ROUND) + FIXED_MARGIN
+        rows: Final = _model_rows(response.headers["x-litellm-call-id"], _logs_a_failure_billing(expected))
+        assert _statuses(rows) == _statuses(one_round_rows), (rows, one_round_rows)
+        assert _billed(rows) == pytest.approx(expected), rows
+
+
+@pytest.mark.parametrize(
+    ("surface", "stream"),
+    (("responses", True), ("responses", False), ("chat", False)),
+    ids=("responses-stream", "responses", "chat"),
+)
+def test_auto_executed_tool_call_runs_inside_the_requests_one_parallel_slot(
+    gateway: Gateway, surface: Surface, stream: bool
+) -> None:
+    with _rig(gateway, surface, slow_tool_seconds=SLOW_TOOL_SECONDS) as rig:
+        key: Final = _limited_key(rig)
+        with ThreadPoolExecutor(max_workers=1) as pool:
+            running: Final = pool.submit(rig.send, key, [AUTO], None, stream=stream)
+            eventually(lambda: _peer_add_calls(rig.peer), lambda found: len(found) == 1, seconds=30)
+            during: Final = _answers_directly(rig, key)
+            served: Final = running.result(timeout=90)
+        assert during == 429
+        assert served.status_code == 200 and ANSWER in served.text, served.text
+        eventually(lambda: _answers_directly(rig, key), lambda status: status == 200, seconds=30)
+
+
+@pytest.mark.parametrize("upstream", STREAMED_UPSTREAMS, ids=STREAMED_IDS)
+def test_streaming_responses_hung_up_during_the_tool_call_bills_each_served_round_once_and_frees_the_slot(
+    gateway: Gateway, upstream: StreamedUpstream
+) -> None:
+    billing: Final = Billing(FIRST_ROUND, FOLLOW_UP_ROUND)
+    with _rig(
+        gateway,
+        "responses",
+        upstream=upstream,
+        billing=billing,
+        prices=PRICES,
+        slow_tool_seconds=SLOW_TOOL_SECONDS,
+    ) as rig:
+        key: Final = _limited_key(rig)
+        with rig.gateway.client.stream(
+            "POST",
+            "/v1/responses",
+            headers={"Authorization": f"Bearer {key}"},
+            json={"model": rig.model, "input": f"add {rig.alias}", "tools": [AUTO], "stream": True},
+            timeout=90,
+        ) as hung_up:
+            assert hung_up.status_code == 200
+            call_id: Final = hung_up.headers["x-litellm-call-id"]
+            eventually(lambda: _peer_add_calls(rig.peer), lambda found: len(found) == 1, seconds=30)
+        eventually(lambda: _answers_directly(rig, key), lambda status: status == 200, seconds=60)
+        posted: Final = tuple(
+            JSON_OBJECT.validate_json(request.body) for request in rig.wire.drain() if request.method == "POST"
+        )
+        served: Final = tuple(
+            FOLLOW_UP_ROUND if _has_tool_result(body) else FIRST_ROUND for body in posted if DIRECT not in _prompt(body)
+        )
+        expected: Final = _price(*served) + FIXED_MARGIN
+        rows: Final = _model_rows(call_id, _bills_at_least(expected))
+        assert served and rows, (served, rows)
+        assert _billed(rows) == pytest.approx(expected), (served, rows)
+
+
+@pytest.mark.parametrize("upstream", STREAMED_UPSTREAMS, ids=STREAMED_IDS)
+def test_streaming_responses_repeated_from_the_response_cache_bills_nothing(
+    gateway: Gateway, upstream: StreamedUpstream
+) -> None:
+    billing: Final = Billing(FIRST_ROUND, FOLLOW_UP_ROUND)
+    with _rig(gateway, "responses", upstream=upstream, billing=billing, prices=PRICES) as rig:
+        key: Final = _granted_key(rig)
+        paid: Final = rig.send(key, [AUTO], stream=True)
+        assert paid.status_code == 200 and rig.final_text(_completed(paid)) == ANSWER, paid.text
+        paid_price: Final = _price(FIRST_ROUND, FOLLOW_UP_ROUND) + FIXED_MARGIN
+        _model_rows(paid.headers["x-litellm-call-id"], _bills_at_least(paid_price))
+        assert len(rig.upstream_tools()) == 2
+        cached: Final = rig.send(key, [AUTO], stream=True)
+        assert cached.status_code == 200 and rig.final_text(_completed(cached)) == ANSWER, cached.text
+        assert rig.upstream_tools() == ()
+        rows: Final = _model_rows(
+            cached.headers["x-litellm-call-id"], lambda found: "success" in {row["status"] for row in found}
+        )
+        assert "success" in {row["status"] for row in rows} and _billed(rows) == 0.0, rows
+
+
+def test_bridged_next_turn_after_a_streamed_mcp_turn_replays_its_answer(gateway: Gateway) -> None:
+    billing: Final = Billing(FIRST_ROUND, FOLLOW_UP_ROUND)
+    with _rig(gateway, "responses", upstream="responses_bridge", billing=billing, prices=PRICES) as rig:
+        key: Final = _granted_key(rig)
+        first: Final = rig.send(key, [AUTO], stream=True)
+        assert first.status_code == 200, first.text
+        first_id: Final = string_value(_completed(first)["id"])
+        _model_rows(first.headers["x-litellm-call-id"], _bills_at_least(_price(FIRST_ROUND, FOLLOW_UP_ROUND)))
+        rig.wire.drain()
+        second: Final = rig.send(key, [AUTO], previous_response_id=first_id, cache={"no-cache": True})
+        assert second.status_code == 200, second.text
+        opening: Final = next(
+            JSON_OBJECT.validate_json(request.body) for request in rig.wire.drain() if request.method == "POST"
+        )
+        assert ANSWER in _assistant_texts(opening), opening
+
+
 Bridge = Literal["chat", "responses", "messages"]
 BRIDGES: Final[tuple[Bridge, ...]] = ("chat", "responses")
 Client = Literal["sync", "async"]
diff --git a/tests/integration/providers/test_cloudflare_clairic_extraction_wire.py b/tests/integration/providers/test_cloudflare_clairic_extraction_wire.py
new file mode 100644
index 00000000000..7b2a48c9676
--- /dev/null
+++ b/tests/integration/providers/test_cloudflare_clairic_extraction_wire.py
@@ -0,0 +1,418 @@
+import json
+import math
+import re
+import uuid
+from collections.abc import Iterator, Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Final, Literal
+
+import httpx
+import pytest
+import yaml
+from integration._support.client import JSON_OBJECT, Gateway, eventually, object_value
+from integration._support.database import read_rows
+from integration._support.process import OwnedProxy, WorkerHealthcheck, graceful_stop_seconds, owned_proxy_process
+from integration._support.wire import Reply, Request, Wire, wire_server
+from pydantic import JsonValue, TypeAdapter
+
+Route = Literal["/v1/extraction", "/extraction"]
+
+_API_KEY: Final = "synthetic-cloudflare-key"
+_CLAIRIC: Final = "cloudflare/@cf/cloudflare/clairic"
+_CLAIRIC_PATH: Final = "/ai/run/@cf/cloudflare/clairic"
+_INPUT_TOKENS: Final = 412
+_EMAIL: Final = "billing@acmetools.example"
+_SCENARIO: Final = re.compile(r"scenario-([a-z-]+)")
+_JSON_ROWS: Final = TypeAdapter(list[dict[str, JsonValue]])
+_FIELDS: Final[dict[str, JsonValue]] = {
+    "vendor": {"type": "text", "instructions": "Who sent the invoice?"},
+    "total": {"type": "number", "unit": "USD"},
+}
+_SPEND_QUERY: Final = (
+    'SELECT spend, status, call_type, model_group, prompt_tokens, completion_tokens FROM "LiteLLM_SpendLogs" '
+    "WHERE request_id = %s"
+)
+_OWNED_TIMEOUT: Final = int(2 * graceful_stop_seconds() + 120)
+_REQUEST_GUARDRAIL: Final = "extraction-mask-email-in"
+_RESPONSE_GUARDRAIL: Final = "extraction-mask-email-out"
+_OWNED_MODEL: Final = "invoice-reader"
+
+
+def _state(marker: str, scenario: str = "plain") -> str:
+    return f"Invoice from Acme Tools, total $174. scenario-{scenario} marker-{marker}"
+
+
+def _vendor_span(state: str) -> list[JsonValue]:
+    start: Final = state.index("Acme Tools")
+    return [start, start + len("Acme Tools")]
+
+
+def _email_span(state: str) -> list[JsonValue]:
+    start: Final = state.index(_EMAIL)
+    return [start, start + len(_EMAIL)]
+
+
+def _answers(state: str) -> dict[str, JsonValue]:
+    return {
+        "vendor": {"type": "text", "value": "Acme Tools", "confidence": 0.97, "span": _vendor_span(state)},
+        "total": {"type": "number", "value": 174, "confidence": 0.95},
+    }
+
+
+def _envelope(result: Mapping[str, JsonValue]) -> Reply:
+    return Reply(body=json.dumps({"result": result, "success": True, "errors": [], "messages": []}).encode())
+
+
+def _clairic_reply(request: Request) -> Reply:
+    state: Final = JSON_OBJECT.validate_json(request.body)["state"]
+    assert isinstance(state, str), request.body
+    return _envelope(
+        {
+            "model": "clairic",
+            "answers": _answers(state),
+            "truncated": False,
+            "usage": {"input_tokens": _INPUT_TOKENS, "output_tokens": 0},
+        }
+    )
+
+
+def _expected_response(model: str, state: str) -> dict[str, JsonValue]:
+    return {
+        "model": model,
+        "answers": _answers(state),
+        "truncated": False,
+        "usage": {"input_tokens": _INPUT_TOKENS, "output_tokens": 0},
+    }
+
+
+def _upstream_body(request: Request) -> dict[str, JsonValue]:
+    assert (request.method, request.target) == ("POST", _CLAIRIC_PATH), (request.method, request.target)
+    assert request.headers["authorization"] == f"Bearer {_API_KEY}", request.headers
+    return JSON_OBJECT.validate_json(request.body)
+
+
+def _body(model: str, marker: str, **extra: JsonValue) -> dict[str, JsonValue]:
+    return {"model": model, "state": _state(marker), "fields": _FIELDS, **extra}
+
+
+def _extract(
+    gateway: Gateway,
+    model: str,
+    marker: str,
+    *,
+    route: Route = "/v1/extraction",
+    key: str | None = None,
+    **extra: JsonValue,
+) -> httpx.Response:
+    return gateway.request("POST", route, _body(model, marker, **extra), key=key)
+
+
+def _number(value: JsonValue) -> float:
+    assert isinstance(value, (int, float)) and not isinstance(value, bool), value
+    return float(value)
+
+
+def _expected_spend() -> float:
+    cost_map: Final = JSON_OBJECT.validate_json(Path("model_prices_and_context_window.json").read_bytes())
+    priced: Final = cost_map.get(_CLAIRIC)
+    assert priced is not None, f"{_CLAIRIC} has no cost map entry"
+    return _INPUT_TOKENS * _number(object_value(priced)["input_cost_per_token"])
+
+
+def _spend_row(call_id: str) -> dict[str, JsonValue]:
+    rows: Final = eventually(lambda: read_rows(_SPEND_QUERY, (call_id,)), lambda found: len(found) == 1, seconds=70)
+    return rows[0]
+
+
+def _assert_billed(gateway: Gateway, response: httpx.Response, model: str) -> None:
+    expected: Final = _expected_spend()
+    assert math.isclose(float(response.headers["x-litellm-response-cost"]), expected, rel_tol=1e-9), response.headers
+    call_id: Final = response.headers["x-litellm-call-id"]
+    row: Final = _spend_row(call_id)
+    assert (row["status"], row["call_type"], row["model_group"], row["prompt_tokens"], row["completion_tokens"]) == (
+        "success",
+        "aextraction",
+        model,
+        _INPUT_TOKENS,
+        0,
+    ), row
+    assert math.isclose(_number(row["spend"]), expected, rel_tol=1e-9), row
+    listed: Final = gateway.request("GET", "/spend/logs", params={"request_id": call_id})
+    assert listed.status_code == 200, listed.text
+    (reported,) = _JSON_ROWS.validate_json(listed.content)
+    assert (reported["request_id"], reported["model_group"]) == (call_id, model), reported
+    assert math.isclose(_number(reported["spend"]), expected, rel_tol=1e-9), reported
+
+
+@pytest.mark.parametrize("route", ("/v1/extraction", "/extraction"))
+def test_extraction_reaches_clairic_on_both_routes_and_is_billed(gateway: Gateway, route: Route) -> None:
+    marker: Final = uuid.uuid4().hex
+    with wire_server(_clairic_reply) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model=_CLAIRIC, api_base=wire.url, api_key=_API_KEY)
+        response: Final = _extract(gateway, model, marker, route=route, metadata={"tags": [f"audit-{marker}"]})
+        assert response.status_code == 200, response.text
+        assert response.json() == _expected_response(model, _state(marker))
+        (request,) = wire.drain()
+        assert _upstream_body(request) == {"model": "clairic", "state": _state(marker), "fields": _FIELDS}
+        _assert_billed(gateway, response, model)
+
+
+_INVALID_BODIES: Final[tuple[tuple[str, dict[str, JsonValue]], ...]] = (
+    ("unknown_type", {"fields": {"vendor": {"type": "paragraph"}}}),
+    ("list_without_items", {"fields": {"items": {"type": "list"}}}),
+    ("remote_image", {"images": ["https://images.example/receipt.png"]}),
+)
+
+
+@pytest.mark.parametrize(("label", "change"), _INVALID_BODIES, ids=[label for label, _ in _INVALID_BODIES])
+def test_invalid_extraction_bodies_are_refused_before_any_upstream_call(
+    gateway: Gateway, label: str, change: dict[str, JsonValue]
+) -> None:
+    marker: Final = uuid.uuid4().hex
+    with wire_server(_clairic_reply) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model=_CLAIRIC, api_base=wire.url, api_key=_API_KEY)
+        response: Final = gateway.request("POST", "/v1/extraction", {**_body(model, marker), **change})
+        assert response.status_code == 400, (label, response.text)
+        assert "Invalid Extraction request" in response.text, (label, response.text)
+        assert wire.drain() == (), label
+
+
+@pytest.mark.parametrize(("param", "value"), (("temperature", 0.2), ("stream", True)), ids=("temperature", "stream"))
+def test_unsupported_top_level_params_are_refused_unless_the_deployment_drops_params(
+    gateway: Gateway, param: str, value: JsonValue
+) -> None:
+    marker: Final = uuid.uuid4().hex
+    with wire_server(_clairic_reply) as wire, gateway.scenario() as scenario:
+        strict: Final = scenario.model(model=_CLAIRIC, api_base=wire.url, api_key=_API_KEY)
+        dropping: Final = scenario.model(model=_CLAIRIC, api_base=wire.url, api_key=_API_KEY, drop_params=True)
+        refused: Final = _extract(gateway, strict, marker, **{param: value})
+        assert refused.status_code == 400, refused.text
+        assert param in refused.text, refused.text
+        assert wire.drain() == ()
+        dropped: Final = _extract(gateway, dropping, marker, **{param: value})
+        assert dropped.status_code == 200, dropped.text
+        assert dropped.headers["content-type"].startswith("application/json"), dropped.headers
+        assert dropped.json() == _expected_response(dropping, _state(marker))
+        (request,) = wire.drain()
+        assert _upstream_body(request) == {"model": "clairic", "state": _state(marker), "fields": _FIELDS}
+        _assert_billed(gateway, dropped, dropping)
+
+
+def test_key_checks_on_extraction_match_chat(gateway: Gateway) -> None:
+    marker: Final = uuid.uuid4().hex
+    with wire_server(_clairic_reply) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model=_CLAIRIC, api_base=wire.url, api_key=_API_KEY)
+        anonymous: Final = gateway.client.post("/v1/extraction", json=_body(model, marker))
+        assert anonymous.status_code == 401, anonymous.text
+        restricted: Final = scenario.key(models=[f"other-{uuid.uuid4().hex}"])
+        refused: Final = _extract(gateway, model, marker, key=restricted)
+        chat_refused: Final = gateway.request(
+            "POST",
+            "/v1/chat/completions",
+            {"model": model, "messages": [{"role": "user", "content": marker}]},
+            key=restricted,
+        )
+        assert 400 <= refused.status_code < 500, refused.text
+        assert refused.status_code == chat_refused.status_code, (refused.text, chat_refused.text)
+        assert wire.drain() == ()
+        allowed: Final = scenario.key(models=[model], max_budget=1e-06)
+        first: Final = _extract(gateway, model, marker, key=allowed)
+        assert first.status_code == 200, first.text
+        assert len(wire.drain()) == 1
+        blocked, upstream_calls = eventually(
+            lambda: (_extract(gateway, model, uuid.uuid4().hex, key=allowed), len(wire.drain())),
+            lambda answer: answer[0].status_code != 200,
+            seconds=70,
+        )
+        chat_blocked: Final = gateway.request(
+            "POST",
+            "/v1/chat/completions",
+            {"model": model, "messages": [{"role": "user", "content": marker}]},
+            key=allowed,
+        )
+        assert 400 <= blocked.status_code < 500, blocked.text
+        assert blocked.status_code == chat_blocked.status_code, (blocked.text, chat_blocked.text)
+        assert upstream_calls == 0
+        assert wire.drain() == ()
+
+
+def test_a_small_key_tpm_limit_serves_extraction_and_counts_its_input_tokens(gateway: Gateway) -> None:
+    with wire_server(_clairic_reply) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model=_CLAIRIC, api_base=wire.url, api_key=_API_KEY)
+        key: Final = scenario.key(models=[model], tpm_limit=100)
+        first: Final = _extract(gateway, model, uuid.uuid4().hex, key=key)
+        assert first.status_code == 200, first.text
+        assert len(wire.drain()) == 1
+        limited, upstream_calls = eventually(
+            lambda: (_extract(gateway, model, uuid.uuid4().hex, key=key), len(wire.drain())),
+            lambda answer: answer[0].status_code != 200,
+            seconds=70,
+        )
+        assert limited.status_code == 429, limited.text
+        assert upstream_calls == 0
+
+
+def test_cloudflare_errors_keep_their_status_and_log_an_unbilled_failure(gateway: Gateway) -> None:
+    marker: Final = uuid.uuid4().hex
+    refusal: Final = json.dumps(
+        {
+            "result": None,
+            "success": False,
+            "errors": [{"code": 5006, "message": f"min above max {marker}"}],
+            "messages": [],
+        }
+    ).encode()
+    with wire_server(lambda _: Reply(status=422, body=refusal)) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model=_CLAIRIC, api_base=wire.url, api_key=_API_KEY)
+        response: Final = _extract(gateway, model, marker)
+        assert response.status_code == 422, response.text
+        assert f"min above max {marker}" in response.text, response.text
+        assert len(wire.drain()) >= 1
+        row: Final = _spend_row(response.headers["x-litellm-call-id"])
+        assert (row["status"], row["call_type"], row["model_group"], _number(row["spend"])) == (
+            "failure",
+            "aextraction",
+            model,
+            0.0,
+        ), row
+
+
+def _owned_reply(request: Request) -> Reply:
+    body: Final = JSON_OBJECT.validate_json(request.body)
+    state: Final = body["state"]
+    assert isinstance(state, str), request.body
+    scenario: Final = _SCENARIO.search(state)
+    assert scenario is not None, state
+    if scenario.group(1) != "mask-out":
+        return _clairic_reply(request)
+    return _envelope(
+        {
+            "model": "clairic",
+            "answers": {
+                "vendor": {"type": "text", "value": "Acme Tools", "confidence": 0.97, "span": _vendor_span(state)},
+                "contact_email": {"type": "text", "value": _EMAIL, "confidence": 0.9, "span": _email_span(state)},
+            },
+            "truncated": False,
+            "state_text": state,
+            "usage": {"input_tokens": _INPUT_TOKENS, "output_tokens": 0},
+        }
+    )
+
+
+def _owned_config(upstream_url: str) -> dict[str, JsonValue]:
+    base: Final = JSON_OBJECT.validate_python(yaml.safe_load(Path("tests/integration/proxy_config.yaml").read_text()))
+    email_filter: Final[list[JsonValue]] = [{"pattern_type": "prebuilt", "pattern_name": "email", "action": "MASK"}]
+    return {
+        **base,
+        "guardrails": [
+            {
+                "guardrail_name": _REQUEST_GUARDRAIL,
+                "litellm_params": {"guardrail": "litellm_content_filter", "mode": "pre_call", "patterns": email_filter},
+            },
+            {
+                "guardrail_name": _RESPONSE_GUARDRAIL,
+                "litellm_params": {
+                    "guardrail": "litellm_content_filter",
+                    "mode": "post_call",
+                    "patterns": email_filter,
+                },
+            },
+        ],
+        "model_list": [
+            {
+                "model_name": _OWNED_MODEL,
+                "litellm_params": {"model": _CLAIRIC, "api_base": upstream_url, "api_key": _API_KEY},
+            }
+        ],
+    }
+
+
+@dataclass(frozen=True, slots=True)
+class Rig:
+    proxy: OwnedProxy
+    upstream: Wire
+
+
+@pytest.fixture(scope="module")
+def rig(session_gateway: Gateway, tmp_path_factory: pytest.TempPathFactory) -> Iterator[Rig]:
+    with wire_server(_owned_reply) as upstream:
+        directory: Final = tmp_path_factory.mktemp("clairic-extraction-owned")
+        config_path: Final = directory / "clairic-extraction.yaml"
+        config_path.write_text(yaml.safe_dump(_owned_config(upstream.url)))
+        with owned_proxy_process(
+            session_gateway,
+            directory,
+            {},
+            config=config_path,
+            workers=2,
+            extra_arguments=("--max_tokens", "256", "--temperature", "0.2"),
+            healthcheck=WorkerHealthcheck.LENIENT,
+        ) as proxy:
+            yield Rig(proxy, upstream)
+
+
+def _owned_extract(rig: Rig, state: str, **extra: JsonValue) -> httpx.Response:
+    return rig.proxy.gateway.request(
+        "POST", "/v1/extraction", {"model": _OWNED_MODEL, "state": state, "fields": _FIELDS, **extra}
+    )
+
+
+def _applied_guardrails(response: httpx.Response) -> frozenset[str]:
+    return frozenset(name.strip() for name in response.headers.get("x-litellm-applied-guardrails", "").split(","))
+
+
+@pytest.mark.timeout(_OWNED_TIMEOUT)
+def test_cli_generation_defaults_never_reach_an_extraction_call(rig: Rig) -> None:
+    state: Final = _state(uuid.uuid4().hex)
+    response: Final = _owned_extract(rig, state)
+    assert response.status_code == 200, response.text
+    assert response.json() == _expected_response(_OWNED_MODEL, state)
+    (request,) = rig.upstream.drain()
+    assert _upstream_body(request) == {"model": "clairic", "state": state, "fields": _FIELDS}
+
+
+@pytest.mark.timeout(_OWNED_TIMEOUT)
+def test_a_request_guardrail_masks_the_state_before_clairic_and_drops_spans_into_it(rig: Rig) -> None:
+    state: Final = f"{_state(uuid.uuid4().hex, 'mask-in')} Questions go to {_EMAIL}."
+    response: Final = _owned_extract(rig, state, guardrails=[_REQUEST_GUARDRAIL])
+    assert response.status_code == 200, response.text
+    assert _REQUEST_GUARDRAIL in _applied_guardrails(response), response.headers
+    (request,) = rig.upstream.drain()
+    sent: Final = _upstream_body(request)
+    sent_state: Final = sent["state"]
+    assert isinstance(sent_state, str) and _EMAIL not in sent_state, sent
+    assert sent_state.startswith(state.removesuffix(f"{_EMAIL}.")) and "REDACTED" in sent_state, sent
+    assert sent == {"model": "clairic", "state": sent_state, "fields": _FIELDS}
+    answers: Final = object_value(response.json()["answers"])
+    assert object_value(answers["vendor"]) == {"type": "text", "value": "Acme Tools", "confidence": 0.97}, answers
+
+
+@pytest.mark.timeout(_OWNED_TIMEOUT)
+def test_a_response_guardrail_masks_text_answers_and_state_text(rig: Rig) -> None:
+    state: Final = f"{_state(uuid.uuid4().hex, 'mask-out')} Questions go to {_EMAIL}."
+    fields: Final[dict[str, JsonValue]] = {**_FIELDS, "contact_email": {"type": "text"}}
+    response: Final = rig.proxy.gateway.request(
+        "POST",
+        "/v1/extraction",
+        {
+            "model": _OWNED_MODEL,
+            "state": state,
+            "fields": fields,
+            "guardrails": [_RESPONSE_GUARDRAIL],
+            "options": {"return_state_text": True},
+        },
+    )
+    assert response.status_code == 200, response.text
+    assert _RESPONSE_GUARDRAIL in _applied_guardrails(response), response.headers
+    (request,) = rig.upstream.drain()
+    assert _upstream_body(request)["state"] == state
+    body: Final = response.json()
+    state_text: Final = body["state_text"]
+    assert isinstance(state_text, str) and _EMAIL not in state_text and "REDACTED" in state_text, body
+    answers: Final = object_value(body["answers"])
+    contact: Final = object_value(answers["contact_email"])
+    assert "span" not in contact, answers
+    masked: Final = contact["value"]
+    assert isinstance(masked, str) and _EMAIL not in masked and "REDACTED" in masked, answers
+    assert object_value(answers["vendor"]) == {"type": "text", "value": "Acme Tools", "confidence": 0.97}, answers
diff --git a/tests/integration/providers/test_gemini_grounding_annotations_wire.py b/tests/integration/providers/test_gemini_grounding_annotations_wire.py
new file mode 100644
index 00000000000..11df7c214f3
--- /dev/null
+++ b/tests/integration/providers/test_gemini_grounding_annotations_wire.py
@@ -0,0 +1,65 @@
+import json
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+
+
+def _grounded_reply(request: Request) -> Reply:
+    body: Final = {
+        "candidates": [
+            {
+                "content": {"role": "model", "parts": [{"text": "The passage"}]},
+                "finishReason": "STOP",
+                "groundingMetadata": {
+                    "groundingChunks": [
+                        {"retrievedContext": {"uri": "gs://documents/source"}},
+                        {"web": {"uri": "https://example.com/first", "title": "First"}},
+                        {"web": {"uri": "https://example.com/second", "title": "Second"}},
+                    ],
+                    "groundingSupports": [
+                        {"segment": {"startIndex": 4, "endIndex": 11}, "groundingChunkIndices": [0, 99, 2, 1]}
+                    ],
+                },
+            }
+        ],
+        "usageMetadata": {"promptTokenCount": 5, "candidatesTokenCount": 2, "totalTokenCount": 7},
+    }
+    assert json.loads(request.body)["contents"] == [{"role": "user", "parts": [{"text": "Find sources"}]}]
+    if ":streamGenerateContent" in request.target:
+        return Reply(content_type="text/event-stream", chunks=(f"data: {json.dumps(body)}\n\n".encode(),))
+    return Reply(body=json.dumps(body).encode())
+
+
+@pytest.mark.parametrize("stream", [False, True], ids=["non-streaming", "streaming"])
+def test_chat_grounding_annotations_include_every_web_source(gateway: Gateway, stream: bool) -> None:
+    with wire_server(_grounded_reply) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model="gemini/gemini-3.8-flash", api_base=wire.url, api_key="synthetic-key")
+        response: Final = gateway.request(
+            "POST",
+            "/v1/chat/completions",
+            {"model": model, "messages": [{"role": "user", "content": "Find sources"}], "stream": stream},
+        )
+        assert response.status_code == 200, response.text
+        payloads: Final = (
+            [json.loads(line[6:]) for line in response.text.splitlines() if line.startswith("data: {")]
+            if stream
+            else [response.json()]
+        )
+        messages: Final = tuple(payload["choices"][0]["delta" if stream else "message"] for payload in payloads)
+        annotations: Final = tuple(message["annotations"] for message in messages if message.get("annotations"))
+        assert annotations == (
+            [
+                {
+                    "type": "url_citation",
+                    "url_citation": {
+                        "start_index": 4,
+                        "end_index": 11,
+                        "url": f"https://example.com/{name.lower()}",
+                        "title": name,
+                    },
+                }
+                for name in ("Second", "First")
+            ],
+        ), response.text
diff --git a/tests/integration/routing/test_enforce_model_rate_limits_daily_limits.py b/tests/integration/routing/test_enforce_model_rate_limits_daily_limits.py
new file mode 100644
index 00000000000..c670171a149
--- /dev/null
+++ b/tests/integration/routing/test_enforce_model_rate_limits_daily_limits.py
@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import uuid
+from collections.abc import Iterator
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Final
+
+import httpx
+import pytest
+from integration._support.client import gateway_from_environment
+from integration._support.openai_wire import chat_reply
+from integration._support.process import OwnedProxy, graceful_stop_seconds, owned_proxy_process
+from integration._support.wire import Reply, Request, Wire, wire_server
+from integration.providers._cache_control_marks_support import owned_config
+from integration.routing.test_payment_required_mapping import OPENAI_MODEL, is_model_info_probe, model_list_reply
+from pydantic import JsonValue
+
+pytestmark: Final = pytest.mark.timeout(2 * graceful_stop_seconds() + 120)
+
+GROUP: Final = "daily-limited-group"
+LIMITED_ID: Final = "free-tier-two-a-day"
+UNLIMITED_ID: Final = "paid-tier"
+RPD: Final = 2
+EXTRA_REQUESTS: Final = 2
+
+
+@dataclass(frozen=True, slots=True)
+class Rig:
+    owned: OwnedProxy
+    limited: Wire
+    unlimited: Wire
+
+
+def _reply(request: Request) -> Reply:
+    if is_model_info_probe(request):
+        return model_list_reply()
+    return chat_reply("chatcmpl-daily", OPENAI_MODEL, "served", stream=False)
+
+
+def _deployment(model_id: str, wire: Wire, **params: JsonValue) -> dict[str, JsonValue]:
+    return {
+        "model_name": GROUP,
+        "litellm_params": {
+            "model": OPENAI_MODEL,
+            "api_base": wire.url + "/v1",
+            "api_key": "synthetic-openai-key",
+            **params,
+        },
+        "model_info": {"id": model_id},
+    }
+
+
+def _config(directory: Path, limited: Wire, unlimited: Wire) -> Path:
+    return owned_config(
+        directory,
+        [_deployment(LIMITED_ID, limited, rpd=RPD, order=1), _deployment(UNLIMITED_ID, unlimited, order=2)],
+        litellm_settings={"cache": False},
+        router_settings={"optional_pre_call_checks": ["enforce_model_rate_limits"], "num_retries": 1},
+    )
+
+
+@pytest.fixture(scope="module")
+def rig(tmp_path_factory: pytest.TempPathFactory) -> Iterator[Rig]:
+    directory: Final = tmp_path_factory.mktemp("daily-limits")
+    with (
+        gateway_from_environment() as gateway,
+        wire_server(_reply) as limited,
+        wire_server(_reply) as unlimited,
+        owned_proxy_process(gateway, directory, {}, config=_config(directory, limited, unlimited)) as owned,
+    ):
+        yield Rig(owned, limited, unlimited)
+
+
+def _chat(rig: Rig) -> httpx.Response:
+    return rig.owned.gateway.request(
+        "POST",
+        "/v1/chat/completions",
+        {"model": GROUP, "messages": [{"role": "user", "content": f"daily {uuid.uuid4().hex}"}]},
+    )
+
+
+def _forwarded(wire: Wire) -> int:
+    return sum(1 for request in wire.drain() if not is_model_info_probe(request))
+
+
+def test_requests_past_the_deployment_rpd_are_served_by_the_other_deployment_in_the_group(rig: Rig) -> None:
+    responses: Final = tuple(_chat(rig) for _ in range(RPD + EXTRA_REQUESTS))
+
+    assert [response.status_code for response in responses] == [200] * (RPD + EXTRA_REQUESTS), [
+        response.text for response in responses
+    ]
+    assert [response.headers["x-litellm-model-id"] for response in responses] == [LIMITED_ID] * RPD + [
+        UNLIMITED_ID
+    ] * EXTRA_REQUESTS
+    assert (_forwarded(rig.limited), _forwarded(rig.unlimited)) == (RPD, EXTRA_REQUESTS)
diff --git a/tests/integration/spend/test_background_response_billed_once.py b/tests/integration/spend/test_background_response_billed_once.py
index b207e46204a..5f948fac3ab 100644
--- a/tests/integration/spend/test_background_response_billed_once.py
+++ b/tests/integration/spend/test_background_response_billed_once.py
@@ -1,6 +1,7 @@
 import asyncio
 import base64
 import json
+import math
 import uuid
 from collections.abc import Callable, Mapping
 from concurrent.futures import ThreadPoolExecutor
@@ -10,9 +11,18 @@ from typing import Final
 import httpx
 import openai
 import pytest
-from integration._support.client import Gateway, Scenario, eventually, held, list_value, object_value, string_value
+from integration._support.client import (
+    Gateway,
+    Scenario,
+    delete_key_if_present,
+    eventually,
+    held,
+    list_value,
+    object_value,
+    string_value,
+)
 from integration._support.database import read_rows, write_rows
-from integration._support.otlp_sink import decode_spans
+from integration._support.otlp_sink import Span, decode_spans
 from integration._support.upstream import delete_scenario, register_scenario
 from integration._support.wire import Request, wire_server
 from integration.caching.response_cache_case import entry_key, redis_store
@@ -859,7 +869,7 @@ LANGFUSE_COST: Final = "langfuse.observation.cost_details"
 _LANGFUSE_COST_DETAILS: Final = TypeAdapter(dict[str, float])
 
 
-def _langfuse_callback(host: str) -> dict[str, JsonValue]:
+def _langfuse_callback(host: str, **callback_vars: JsonValue) -> dict[str, JsonValue]:
     return {
         "callback_name": "langfuse",
         "callback_type": "success",
@@ -867,12 +877,17 @@ def _langfuse_callback(host: str) -> dict[str, JsonValue]:
             "langfuse_public_key": LANGFUSE_PUBLIC_KEY,
             "langfuse_secret_key": LANGFUSE_SECRET_KEY,
             "langfuse_host": host,
+            **callback_vars,
         },
     }
 
 
+def _logging_to(langfuse_url: str, **callback_vars: JsonValue) -> dict[str, JsonValue]:
+    return {"logging": [_langfuse_callback(langfuse_url, **callback_vars)]}
+
+
 def _key_with_its_own_logging(scenario: Scenario, langfuse_url: str) -> str:
-    return scenario.key(metadata={"logging": [_langfuse_callback(langfuse_url)]})
+    return scenario.key(metadata=_logging_to(langfuse_url))
 
 
 def _key_in_a_team_with_logging(scenario: Scenario, langfuse_url: str) -> str:
@@ -892,17 +907,33 @@ def _trace_exports(langfuse: Recorder) -> tuple[Request, ...]:
     return tuple(request for request in langfuse.requests() if request.target.startswith(LANGFUSE_TRACES_PATH))
 
 
-def _exported_costs(langfuse: Recorder) -> tuple[float, ...]:
-    spans: Final = tuple(
+def _exported_spans(langfuse: Recorder) -> tuple[Span, ...]:
+    return tuple(
         chain.from_iterable(
             decode_spans(export.body, export.headers.get("content-type", "")) for export in _trace_exports(langfuse)
         )
     )
-    return tuple(
-        _LANGFUSE_COST_DETAILS.validate_json(string_value(span["attributes"][LANGFUSE_COST]))["total"]
-        for span in spans
-        if LANGFUSE_COST in span["attributes"]
-    )
+
+
+def _span_cost(span: Span) -> float | None:
+    cost_details: Final = span["attributes"].get(LANGFUSE_COST)
+    return None if cost_details is None else _LANGFUSE_COST_DETAILS.validate_json(string_value(cost_details))["total"]
+
+
+def _exported_costs(langfuse: Recorder) -> tuple[float, ...]:
+    return tuple(cost for cost in map(_span_cost, _exported_spans(langfuse)) if cost is not None)
+
+
+def _priced_spans(langfuse: Recorder) -> tuple[Span, ...]:
+    return tuple(span for span in _exported_spans(langfuse) if (_span_cost(span) or 0.0) > 0)
+
+
+def _billed_once(langfuse: Recorder, seconds: float) -> Span:
+    priced: Final = eventually(lambda: _priced_spans(langfuse), lambda spans: len(spans) > 0, seconds=seconds)
+    costs: Final = tuple(_span_cost(span) or 0.0 for span in priced)
+    assert len(costs) == 1, costs
+    assert math.isclose(costs[0], PRICE), costs
+    return priced[0]
 
 
 @pytest.mark.timeout(240)
@@ -925,3 +956,133 @@ def test_the_billed_cost_reaches_the_langfuse_project_set_on_the_creating_key_or
         assert [cost for cost in exported if cost > 0] == [pytest.approx(PRICE)]
         credentials: Final = base64.b64encode(f"{LANGFUSE_PUBLIC_KEY}:{LANGFUSE_SECRET_KEY}".encode()).decode()
         assert {export.headers.get("authorization") for export in _trace_exports(langfuse)} == {f"Basic {credentials}"}
+
+
+@pytest.mark.timeout(240)
+def test_the_billed_cost_reaches_the_creating_keys_langfuse_project_and_never_the_readers(gateway: Gateway) -> None:
+    with (
+        wire_server(langfuse_sink) as creator_wire,
+        wire_server(langfuse_sink) as reader_wire,
+        gateway.scenario() as scenario,
+    ):
+        creator_langfuse: Final = Recorder(creator_wire)
+        reader_langfuse: Final = Recorder(reader_wire)
+        team_id: Final = scenario.team()
+        user_id: Final = scenario.member(team_id)
+        creator: Final = scenario.key(team_id=team_id, user_id=user_id, metadata=_logging_to(creator_wire.url))
+        reader: Final = scenario.key(team_id=team_id, user_id=user_id, metadata=_logging_to(reader_wire.url))
+        upstream: Final = scripted_upstream(scenario, background_routes("completed"))
+        response_id: Final = create_background_response(scenario, creator, upstream.model)
+        reads: Final = tuple(read_response(gateway, reader, response_id) for _ in range(READS))
+        assert reads in (settling_reads("completed", READS), free_reads("completed", READS))
+        _billed_once(creator_langfuse, SPEND_LANDING_SECONDS)
+        eventually(lambda: _trace_exports(reader_langfuse), lambda exports: len(exports) > 0)
+        assert _priced_spans(reader_langfuse) == ()
+
+
+MESSAGE_LOGGING: Final[Mapping[str, Mapping[str, JsonValue]]] = {
+    "logged": {},
+    "redacted": {"turn_off_message_logging": "true"},
+}
+
+
+@pytest.mark.timeout(240)
+@pytest.mark.parametrize("message_logging", MESSAGE_LOGGING.keys())
+def test_the_billed_observation_carries_the_response_text_only_when_the_creating_key_keeps_message_logging(
+    gateway: Gateway, message_logging: str
+) -> None:
+    with wire_server(langfuse_sink) as wire, gateway.scenario() as scenario:
+        langfuse: Final = Recorder(wire)
+        key: Final = scenario.key(metadata=_logging_to(wire.url, **MESSAGE_LOGGING[message_logging]))
+        upstream: Final = scripted_upstream(scenario, background_routes("completed"))
+        response_id: Final = create_background_response(scenario, key, upstream.model)
+        reads: Final = tuple(read_response(gateway, key, response_id) for _ in range(READS))
+        assert reads in (settling_reads("completed", READS), free_reads("completed", READS))
+        billed: Final = _billed_once(langfuse, SPEND_LANDING_SECONDS)
+        assert ("pong" in json.dumps(billed["attributes"])) is (message_logging == "logged"), billed["attributes"]
+
+
+def _generated_key(scenario: Scenario, **fields: JsonValue) -> str:
+    key: Final = string_value(scenario.gateway.post("/key/generate", fields)["key"])
+    scenario.cleanups.callback(delete_key_if_present, scenario.gateway, key)
+    return key
+
+
+def _delete_team_if_present(gateway: Gateway, team_id: str) -> None:
+    if gateway.rows('SELECT team_id FROM "LiteLLM_TeamTable" WHERE team_id = %s', (team_id,)):
+        gateway.post("/team/delete", {"team_ids": [team_id]})
+
+
+Retirement = Callable[[Scenario, str, str], tuple[str, Callable[[], object]]]
+
+
+def _rotated_with_grace_then_relogged(
+    scenario: Scenario, billed_url: str, stale_url: str
+) -> tuple[str, Callable[[], object]]:
+    key: Final = _generated_key(scenario, metadata=_logging_to(stale_url))
+
+    def rotate() -> None:
+        rotated: Final = string_value(
+            scenario.gateway.post("/key/regenerate", {"key": key, "grace_period": "1h"})["key"]
+        )
+        scenario.cleanups.callback(delete_key_if_present, scenario.gateway, rotated)
+        scenario.gateway.post("/key/update", {"key": rotated, "metadata": _logging_to(billed_url)})
+
+    return key, rotate
+
+
+def _deleted_key(scenario: Scenario, billed_url: str, _stale_url: str) -> tuple[str, Callable[[], object]]:
+    key: Final = _generated_key(scenario, metadata=_logging_to(billed_url))
+    return key, lambda: scenario.gateway.post("/key/delete", {"keys": [key]})
+
+
+def _deleted_team(scenario: Scenario, billed_url: str, _stale_url: str) -> tuple[str, Callable[[], object]]:
+    team_id: Final = string_value(
+        scenario.gateway.post("/team/new", {"team_alias": f"integration-{uuid.uuid4().hex}"})["team_id"]
+    )
+    scenario.cleanups.callback(_delete_team_if_present, scenario.gateway, team_id)
+    added: Final = scenario.gateway.request("POST", f"/team/{team_id}/callback", _langfuse_callback(billed_url))
+    assert added.status_code == 200, added.text
+    key: Final = _generated_key(scenario, team_id=team_id)
+    return key, lambda: scenario.gateway.post("/team/delete", {"team_ids": [team_id]})
+
+
+RETIREMENTS: Final[Mapping[str, Retirement]] = {
+    "key_rotated_with_grace": _rotated_with_grace_then_relogged,
+    "key_deleted": _deleted_key,
+    "team_deleted": _deleted_team,
+}
+
+
+@pytest.mark.timeout(240)
+@pytest.mark.parametrize("retired", RETIREMENTS.keys())
+def test_a_retired_creators_billed_cost_reaches_its_own_langfuse_project(gateway: Gateway, retired: str) -> None:
+    with (
+        wire_server(langfuse_sink) as billed_wire,
+        wire_server(langfuse_sink) as stale_wire,
+        gateway.scenario() as scenario,
+    ):
+        billed_langfuse: Final = Recorder(billed_wire)
+        stale_langfuse: Final = Recorder(stale_wire)
+        key, retire = RETIREMENTS[retired](scenario, billed_wire.url, stale_wire.url)
+        upstream: Final = scripted_upstream(scenario, background_routes("queued"))
+        response_id: Final = create_background_response(scenario, key, upstream.model)
+        retire()
+        upstream.script(background_routes("completed"))
+        _billed_once(billed_langfuse, ONE_POLL_SECONDS + SPEND_LANDING_SECONDS)
+        assert [row["status"] for row in managed_rows(response_id)] == ["completed"]
+        assert _priced_spans(stale_langfuse) == ()
+
+
+@pytest.mark.timeout(240)
+def test_a_creator_whose_langfuse_keys_resolve_to_nothing_is_still_billed_once(gateway: Gateway) -> None:
+    unset: Final = f"os.environ/INTEGRATION_UNSET_LANGFUSE_{uuid.uuid4().hex.upper()}"
+    with wire_server(langfuse_sink) as wire, gateway.scenario() as scenario:
+        key: Final = scenario.key(metadata=_logging_to(wire.url, langfuse_public_key=unset, langfuse_secret_key=unset))
+        upstream: Final = scripted_upstream(scenario, background_routes("completed"))
+        response_id: Final = create_background_response(scenario, key, upstream.model)
+        reads: Final = tuple(read_response(gateway, key, response_id) for _ in range(READS))
+        assert reads in (settling_reads("completed", READS), free_reads("completed", READS))
+        assert_charged_exactly(lambda: key_spend(key), PRICE)
+        assert math.isclose(number(one_charged_row(upstream.model_id)["spend"]), PRICE)
+        assert [row["status"] for row in managed_rows(response_id)] == ["completed"]
diff --git a/tests/integration/spend/test_global_proxy_spend_counter.py b/tests/integration/spend/test_global_proxy_spend_counter.py
index 0185e48ffbd..e818487cf53 100644
--- a/tests/integration/spend/test_global_proxy_spend_counter.py
+++ b/tests/integration/spend/test_global_proxy_spend_counter.py
@@ -1,16 +1,113 @@
+import json
 import os
 import uuid
+from itertools import product
+from pathlib import Path
 from typing import Final
 
+import httpx
 import pytest
+import yaml
+from integration._support.client import Gateway, eventually, object_value
+from integration._support.process import graceful_stop_seconds, owned_proxy
+from integration._support.redis_process import owned_redis
+from pydantic import JsonValue, TypeAdapter
+from redis import Redis
 
 import litellm
 from litellm.caching.in_memory_cache import InMemoryCache
 from litellm.caching.redis_cache import RedisCache
-from litellm.constants import GLOBAL_PROXY_SPEND_CACHE_KEY
+from litellm.constants import GLOBAL_PROXY_SPEND_CACHE_KEY, LITELLM_PROXY_BUDGET_NAME
 from litellm.proxy.common_utils.user_api_key_cache import UserApiKeyCache
 from litellm.proxy.proxy_server import update_cache
 
+BUDGET_MODEL: Final = "proxy-budget-model"
+CONFIG: Final = TypeAdapter(dict[str, JsonValue])
+SECTION: Final = TypeAdapter(dict[str, JsonValue])
+OWNED_PROXY_SECONDS: Final = 2 * graceful_stop_seconds() + 120
+
+
+def _proxy_budget_config(gateway: Gateway, directory: Path, max_budget: float) -> Path:
+    loaded: Final = CONFIG.validate_python(
+        yaml.safe_load((Path(__file__).resolve().parents[1] / "proxy_config.yaml").read_text())
+    )
+    model: Final[JsonValue] = {
+        "model_name": BUDGET_MODEL,
+        "litellm_params": {
+            "model": "openai/gpt-4o-mini",
+            "api_key": "integration-provider-key",
+            "api_base": f"{gateway.upstream_url}/v1",
+            "input_cost_per_token": 0.001,
+            "output_cost_per_token": 0.002,
+        },
+    }
+    path: Final = directory / "proxy_budget_config.yaml"
+    path.write_text(
+        yaml.safe_dump(
+            {
+                **loaded,
+                "model_list": [model],
+                "general_settings": {
+                    **SECTION.validate_python(loaded["general_settings"]),
+                    "user_api_key_cache_ttl": 600,
+                },
+                "litellm_settings": {
+                    **SECTION.validate_python(loaded["litellm_settings"]),
+                    "max_budget": max_budget,
+                    "budget_duration": "30d",
+                },
+            }
+        )
+    )
+    return path
+
+
+def _chat(proxy: Gateway, key: str, marker: str) -> httpx.Response:
+    return proxy.request(
+        "POST",
+        "/v1/chat/completions",
+        {"model": BUDGET_MODEL, "max_tokens": 20, "messages": [{"role": "user", "content": marker}]},
+        key=key,
+    )
+
+
+def _served_id(proxy: Gateway, key: str) -> str:
+    response: Final = _chat(proxy, key, f"proxy budget {uuid.uuid4().hex}")
+    assert response.status_code == 200, response.text
+    identity: Final = response.json()["id"]
+    assert isinstance(identity, str), response.text
+    return identity
+
+
+def _logged_spend(proxy: Gateway, request_ids: tuple[str, ...]) -> tuple[float, ...]:
+    rows: Final = eventually(
+        lambda: proxy.rows(
+            'SELECT spend FROM "LiteLLM_SpendLogs" WHERE request_id = ANY(%s::text[])',
+            ("{" + ",".join(request_ids) + "}",),
+        ),
+        lambda found: len(found) == len(request_ids),
+        seconds=70,
+    )
+    return tuple(float(str(row["spend"])) for row in rows)
+
+
+def _proxy_budget_spend(proxy: Gateway) -> float | None:
+    rows: Final = proxy.rows('SELECT spend FROM "LiteLLM_UserTable" WHERE user_id = %s', (LITELLM_PROXY_BUDGET_NAME,))
+    return float(str(rows[0]["spend"])) if rows else None
+
+
+def _counter_key(redis: Redis) -> str:
+    found: Final = tuple(str(key, "utf-8") for key in redis.scan_iter(match=f"*{GLOBAL_PROXY_SPEND_CACHE_KEY}"))
+    assert len(found) == 1, found
+    return found[0]
+
+
+def _upstream_saw(proxy: Gateway, marker: str) -> bool:
+    with httpx.Client(base_url=proxy.upstream_url, timeout=5, trust_env=False) as upstream:
+        response: Final = upstream.get("/__observations")
+        response.raise_for_status()
+        return marker in json.dumps(object_value(response.json())["requests"])
+
 
 async def _add_request_cost(cache: UserApiKeyCache, response_cost: float) -> None:
     await update_cache(
@@ -56,3 +153,63 @@ async def test_global_proxy_spend_adds_every_instance_cost_and_stays_cleared_aft
         assert await redis_cache.async_get_cache(key=GLOBAL_PROXY_SPEND_CACHE_KEY) is None
     finally:
         await redis_cache.async_delete_cache(key=GLOBAL_PROXY_SPEND_CACHE_KEY)
+
+
+@pytest.mark.timeout(OWNED_PROXY_SECONDS)
+def test_a_key_with_no_user_spends_toward_the_proxy_max_budget(gateway: Gateway, tmp_path: Path) -> None:
+    with (
+        owned_proxy(gateway, tmp_path, {}, config=_proxy_budget_config(gateway, tmp_path, max_budget=0.01)) as owned,
+        owned.scenario() as scenario,
+    ):
+        key: Final = scenario.key(models=[BUDGET_MODEL])
+        (spent,) = _logged_spend(owned, (_served_id(owned, key),))
+        assert spent > 0.01, spent
+        eventually(
+            lambda: _proxy_budget_spend(owned),
+            lambda recorded: recorded is not None and recorded > 0.01,
+            seconds=70,
+        )
+
+        marker: Final = f"over the proxy budget {uuid.uuid4().hex}"
+        refused: Final = _chat(owned, key, marker)
+
+        assert refused.status_code != 200, refused.text
+        assert object_value(refused.json()["error"])["type"] == "budget_exceeded", refused.text
+        assert not _upstream_saw(owned, marker), refused.text
+
+
+@pytest.mark.timeout(2 * OWNED_PROXY_SECONDS)
+def test_two_proxies_add_every_request_to_one_proxy_spend_counter(gateway: Gateway, tmp_path: Path) -> None:
+    config: Final = _proxy_budget_config(gateway, tmp_path, max_budget=1000.0)
+    with owned_redis(tmp_path / "redis") as cache, Redis(host=cache.host, port=cache.port) as redis:
+        shared_redis: Final = {"REDIS_HOST": cache.host, "REDIS_PORT": str(cache.port)}
+        with owned_proxy(gateway, tmp_path / "first", shared_redis, config=config) as first:
+            assert first.database_url is not None
+            with (
+                owned_proxy(
+                    gateway, tmp_path / "second", {**shared_redis, "DATABASE_URL": first.database_url}, config=config
+                ) as second,
+                first.scenario() as scenario,
+            ):
+                user_key: Final = scenario.key(user_id=scenario.user(), models=[BUDGET_MODEL])
+                userless_key: Final = scenario.key(models=[BUDGET_MODEL])
+                counter: Final = _counter_key(redis)
+                ttl_before: Final = redis.ttl(counter)
+
+                request_ids: Final = tuple(
+                    _served_id(proxy, key) for key, proxy in product((user_key, userless_key), (first, second))
+                )
+                total: Final = sum(_logged_spend(first, request_ids))
+                persisted: Final = eventually(
+                    lambda: _proxy_budget_spend(first),
+                    lambda spend: spend is not None and spend == pytest.approx(total),
+                    seconds=70,
+                )
+
+                assert persisted == pytest.approx(total)
+                eventually(
+                    lambda: redis.get(counter),
+                    lambda shared: shared is not None and float(str(shared, "utf-8")) == pytest.approx(total),
+                    seconds=70,
+                )
+                assert 0 < redis.ttl(counter) <= ttl_before
diff --git a/tests/unit/a2a_protocol/providers/bedrock_agentcore/test_bedrock_agentcore_a2a.py b/tests/unit/a2a_protocol/providers/bedrock_agentcore/test_bedrock_agentcore_a2a.py
index 09f09170241..cd3f7622fa2 100644
--- a/tests/unit/a2a_protocol/providers/bedrock_agentcore/test_bedrock_agentcore_a2a.py
+++ b/tests/unit/a2a_protocol/providers/bedrock_agentcore/test_bedrock_agentcore_a2a.py
@@ -10,6 +10,7 @@ Verifies that:
 """
 
 import json
+from typing import Final
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import httpx
@@ -560,6 +561,37 @@ class TestStreaming:
         assert sent_body["params"]["message"]["messageId"] == "msg-001"
         assert [event["result"]["kind"] for event in events] == ["task", "status-update"]
 
+    @pytest.mark.asyncio
+    @pytest.mark.usefixtures("httpx_transport")
+    async def test_streaming_keeps_unicode_line_separators_inside_an_sse_event(self) -> None:
+        from litellm.a2a_protocol.providers.bedrock_agentcore.config import (
+            BedrockAgentCoreA2AConfig,
+        )
+
+        event: Final = {
+            "jsonrpc": "2.0",
+            "id": "req-001",
+            "result": {"kind": "artifact-update", "artifact": {"parts": [{"kind": "text", "text": "a\u2028b\u2029c"}]}},
+        }
+        with respx.mock(assert_all_called=True) as router:
+            router.post(url__regex=r".*/invocations.*").mock(
+                return_value=httpx.Response(
+                    200,
+                    headers={"content-type": "text/event-stream"},
+                    text=f"data: {json.dumps(event, ensure_ascii=False)}\n\n",
+                )
+            )
+            events: Final = [
+                streamed
+                async for streamed in BedrockAgentCoreA2AConfig().handle_streaming(
+                    request_id="req-001",
+                    params=SAMPLE_PARAMS,
+                    litellm_params=SAMPLE_LITELLM_PARAMS,
+                )
+            ]
+
+        assert events == [event]
+
 
 class TestConfigManager:
     """Test that config manager routes 'bedrock' correctly."""
diff --git a/tests/unit/a2a_protocol/providers/watsonx_orchestrate/test_watsonx_orchestrate_transformation.py b/tests/unit/a2a_protocol/providers/watsonx_orchestrate/test_watsonx_orchestrate_transformation.py
index a300560ae9d..ac3f0390f84 100644
--- a/tests/unit/a2a_protocol/providers/watsonx_orchestrate/test_watsonx_orchestrate_transformation.py
+++ b/tests/unit/a2a_protocol/providers/watsonx_orchestrate/test_watsonx_orchestrate_transformation.py
@@ -1,6 +1,7 @@
 import asyncio
 import json
 import time
+from typing import Final
 
 import httpx
 import pytest
@@ -36,13 +37,8 @@ class _ShortTtlTokenClient:
         return _JsonResponse({"access_token": f"token-{self.calls}", "expires_in": 30})
 
 
-class _SSELines:
-    def __init__(self, lines):
-        self.lines = lines
-
-    async def aiter_lines(self):
-        for line in self.lines:
-            yield line
+def _sse_response(lines: list[str]) -> httpx.Response:
+    return httpx.Response(200, stream=httpx.ByteStream("".join(f"{line}\n" for line in lines).encode()))
 
 
 class _InvalidJsonStreamResponse:
@@ -218,7 +214,7 @@ def test_cp4d_token_ttl_from_absolute_expiration():
 
 @pytest.mark.asyncio
 async def test_accumulate_wxo_sse_text_ignores_non_dict_json_events():
-    response = _SSELines(
+    response = _sse_response(
         [
             "data: null",
             "data: true",
@@ -230,6 +226,14 @@ async def test_accumulate_wxo_sse_text_ignores_non_dict_json_events():
     )
 
 
+@pytest.mark.asyncio
+async def test_accumulate_wxo_sse_text_keeps_unicode_line_separators_inside_an_event() -> None:
+    separated_text: Final = "before\u2028between\u2029after"
+    response: Final = _sse_response([f"data: {json.dumps({'results': separated_text}, ensure_ascii=False)}", ""])
+
+    assert await WatsonxOrchestrateHandler._accumulate_wxo_sse_text(response) == separated_text
+
+
 @pytest.mark.asyncio
 async def test_short_lived_tokens_are_not_served_from_cache():
     client = _ShortTtlTokenClient()
diff --git a/tests/unit/caching/test_in_memory_cache.py b/tests/unit/caching/test_in_memory_cache.py
index 75232476ecd..901832937b5 100644
--- a/tests/unit/caching/test_in_memory_cache.py
+++ b/tests/unit/caching/test_in_memory_cache.py
@@ -235,13 +235,9 @@ def test_in_memory_cache_eviction_order():
 
     # Add items with different TTLs
     now = time.time()
-    in_memory_cache.set_cache(
-        key="early_expire", value="value_1", ttl=100
-    )  # expires in 100 seconds
+    in_memory_cache.set_cache(key="early_expire", value="value_1", ttl=100)  # expires in 100 seconds
     time.sleep(0.01)
-    in_memory_cache.set_cache(
-        key="late_expire", value="value_2", ttl=200
-    )  # expires in 200 seconds
+    in_memory_cache.set_cache(key="late_expire", value="value_2", ttl=200)  # expires in 200 seconds
 
     # Verify TTL order
     early_ttl = in_memory_cache.ttl_dict["early_expire"]
@@ -379,3 +375,20 @@ def test_in_memory_cache_injected_clock_controls_expiry_and_eviction() -> None:
     assert cache.get_cache("second") is None
     assert cache.get_cache("third") == "replacement"
     assert cache.get_cache("fourth") == "new"
+
+
+@pytest.mark.asyncio
+async def test_async_increment_pipeline_keeps_each_key_for_its_own_ttl() -> None:
+    now: Final = {"t": 1_000.0}
+    cache: Final = InMemoryCache(default_ttl=600, clock=lambda: now["t"])
+
+    await cache.async_increment_pipeline(
+        increment_list=[
+            {"key": "minute", "increment_value": 1, "ttl": 60},
+            {"key": "day", "increment_value": 1, "ttl": 86400},
+        ]
+    )
+    now["t"] += 601
+
+    assert cache.get_cache("minute") is None
+    assert cache.get_cache("day") == 1
diff --git a/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py b/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py
index 9aa494c1aab..46f1dbf2e7a 100644
--- a/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py
+++ b/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py
@@ -1102,6 +1102,24 @@ def test_recover_output_items_merges_text_only_items_at_distinct_indices():
     assert recovered[1]["content"][0]["text"] == "From OUTPUT_TEXT_DONE only"
 
 
+def test_recover_output_items_keeps_an_item_whose_text_holds_unicode_line_separators() -> None:
+    from litellm.completion_extras.litellm_responses_transformation.transformation import (
+        LiteLLMResponsesTransformationHandler,
+    )
+
+    item: Final = {
+        "type": "message",
+        "id": "msg_item_0",
+        "role": "assistant",
+        "status": "completed",
+        "content": [{"type": "output_text", "text": "From\u2028OUTPUT_ITEM\u2029DONE", "annotations": []}],
+    }
+    event: Final = {"type": "response.output_item.done", "output_index": 0, "item": item}
+    raw_sse: Final = f"data: {json.dumps(event, ensure_ascii=False)}\ndata: [DONE]\n"
+
+    assert LiteLLMResponsesTransformationHandler._recover_output_items_from_raw_sse(raw_sse) == [item]
+
+
 def test_transform_response_prefers_completed_output_from_raw_sse():
     from litellm.completion_extras.litellm_responses_transformation.transformation import (
         LiteLLMResponsesTransformationHandler,
diff --git a/tests/unit/google_genai/test_google_genai_streaming_iterator.py b/tests/unit/google_genai/test_google_genai_streaming_iterator.py
index 120c99b6e42..cbb9638b3d9 100644
--- a/tests/unit/google_genai/test_google_genai_streaming_iterator.py
+++ b/tests/unit/google_genai/test_google_genai_streaming_iterator.py
@@ -62,7 +62,9 @@ def _logging_obj(
     ],
 )
 def test_streaming_logging_targets_the_provider_that_served_the_request(
-    iterator_cls: type,
+    iterator_cls: (
+        type[AsyncGoogleGenAIGenerateContentStreamingIterator] | type[GoogleGenAIGenerateContentStreamingIterator]
+    ),
     custom_llm_provider: str,
     expected_endpoint_type: EndpointType,
 ):
@@ -99,18 +101,15 @@ def _large_inline_data_event() -> str:
     return f"data: {json.dumps(payload)}"
 
 
+def _sse_response(body: str) -> httpx.Response:
+    return httpx.Response(200, stream=httpx.ByteStream(body.encode()))
+
+
 @pytest.mark.asyncio
 async def test_async_streaming_iterator_yields_complete_sse_events():
     """Large inlineData must not be split across byte-chunk boundaries."""
-    mock_response = MagicMock()
-
-    async def _aiter_lines():
-        yield _large_inline_data_event()
-
-    mock_response.aiter_lines = _aiter_lines
-
     iterator = AsyncGoogleGenAIGenerateContentStreamingIterator(
-        response=mock_response,
+        response=_sse_response(_large_inline_data_event() + "\n\n"),
         model="gemini-3.1-flash-image-preview",
         logging_obj=_logging_obj(),
         generate_content_provider_config=MagicMock(),
@@ -128,11 +127,8 @@ async def test_async_streaming_iterator_yields_complete_sse_events():
 
 
 def test_sync_streaming_iterator_yields_complete_sse_events():
-    mock_response = MagicMock()
-    mock_response.iter_lines.return_value = iter([_large_inline_data_event()])
-
     iterator = GoogleGenAIGenerateContentStreamingIterator(
-        response=mock_response,
+        response=_sse_response(_large_inline_data_event() + "\n\n"),
         model="gemini-3.1-flash-image-preview",
         logging_obj=_logging_obj(),
         generate_content_provider_config=MagicMock(),
@@ -150,17 +146,8 @@ def test_sync_streaming_iterator_yields_complete_sse_events():
 
 @pytest.mark.asyncio
 async def test_async_streaming_iterator_preserves_multi_field_sse_event():
-    mock_response = MagicMock()
-
-    async def _aiter_lines():
-        yield "event: message"
-        yield 'data: {"text":"hi"}'
-        yield ""
-
-    mock_response.aiter_lines = _aiter_lines
-
     iterator = AsyncGoogleGenAIGenerateContentStreamingIterator(
-        response=mock_response,
+        response=_sse_response('event: message\ndata: {"text":"hi"}\n\n'),
         model="gemini-test",
         logging_obj=_logging_obj(),
         generate_content_provider_config=MagicMock(),
@@ -174,16 +161,8 @@ async def test_async_streaming_iterator_preserves_multi_field_sse_event():
 
 @pytest.mark.asyncio
 async def test_async_streaming_iterator_forwards_sse_comment_events():
-    mock_response = MagicMock()
-
-    async def _aiter_lines():
-        yield ": keepalive"
-        yield ""
-
-    mock_response.aiter_lines = _aiter_lines
-
     iterator = AsyncGoogleGenAIGenerateContentStreamingIterator(
-        response=mock_response,
+        response=_sse_response(": keepalive\n\n"),
         model="gemini-test",
         logging_obj=_logging_obj(),
         generate_content_provider_config=MagicMock(),
@@ -195,6 +174,46 @@ async def test_async_streaming_iterator_forwards_sse_comment_events():
     assert chunk == b": keepalive\n\n"
 
 
+_LINE_SEPARATED_TEXT: Final = "before\u2028between\u2029after"
+
+
+async def _first_chunk(
+    iterator: GoogleGenAIGenerateContentStreamingIterator | AsyncGoogleGenAIGenerateContentStreamingIterator,
+) -> bytes:
+    if isinstance(iterator, AsyncGoogleGenAIGenerateContentStreamingIterator):
+        return await iterator.__anext__()
+    return next(iterator)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "iterator_cls",
+    [AsyncGoogleGenAIGenerateContentStreamingIterator, GoogleGenAIGenerateContentStreamingIterator],
+)
+async def test_streaming_iterator_keeps_unicode_line_separators_inside_the_event(
+    iterator_cls: (
+        type[AsyncGoogleGenAIGenerateContentStreamingIterator] | type[GoogleGenAIGenerateContentStreamingIterator]
+    ),
+) -> None:
+    payload: Final = {"candidates": [{"content": {"parts": [{"text": _LINE_SEPARATED_TEXT}]}}]}
+    event: Final = f"data: {json.dumps(payload, ensure_ascii=False)}\n\n"
+    iterator: Final = iterator_cls(
+        response=_sse_response(event),
+        model="gemini-3.8-flash",
+        logging_obj=_logging_obj(),
+        generate_content_provider_config=MagicMock(),
+        litellm_metadata={},
+        custom_llm_provider="gemini",
+    )
+
+    chunk: Final = await _first_chunk(iterator)
+
+    assert chunk == event.encode()
+    assert (
+        json.loads(chunk[len(b"data: ") : -2])["candidates"][0]["content"]["parts"][0]["text"] == _LINE_SEPARATED_TEXT
+    )
+
+
 def _gemini_event(text: str, finish_reason: str | None = None) -> str:
     candidate: Final = {"content": {"role": "model", "parts": [{"text": text}]}, "index": 0}
     payload: Final = {
diff --git a/tests/unit/images/test_image_edit.py b/tests/unit/images/test_image_edit.py
index fb7a2869b2a..4f858050e3e 100644
--- a/tests/unit/images/test_image_edit.py
+++ b/tests/unit/images/test_image_edit.py
@@ -105,6 +105,24 @@ def test_openai_image_edit_sync_accepts_bytesio_images(respx_mock: respx.MockRou
     assert _multipart_image_parts(route.calls[0].request) == (_FIRST_IMAGE,)
 
 
+def test_openai_image_edit_without_a_model_leaves_model_out_of_the_request(
+    respx_mock: respx.MockRouter, httpx_transport: None
+) -> None:
+    route: Final = respx_mock.post("https://api.openai.com/v1/images/edits").mock(
+        return_value=httpx.Response(200, json=_EDIT_RESPONSE)
+    )
+
+    litellm.image_edit(
+        prompt="combine the reference images",
+        image=io.BytesIO(_FIRST_IMAGE),
+        custom_llm_provider="openai",
+        api_key="fake-key",
+    )
+
+    assert route.call_count == 1
+    assert b'name="model"' not in route.calls[0].request.read()
+
+
 @pytest.mark.asyncio
 async def test_openai_image_edit_accepts_bytesio_images(respx_mock: respx.MockRouter, httpx_transport: None) -> None:
     route: Final = respx_mock.post("https://api.openai.com/v1/images/edits").mock(
diff --git a/tests/unit/images/test_main.py b/tests/unit/images/test_main.py
index 88d5ae1fc2e..61b2f28b727 100644
--- a/tests/unit/images/test_main.py
+++ b/tests/unit/images/test_main.py
@@ -300,7 +300,7 @@ async def test_aimage_generation_ignores_a_non_string_base_url_like_the_sync_pat
     )
 
     response: Final = await litellm.aimage_generation(
-        model="dall-e-3",
+        model="gpt-image-2.5-sunburst",
         prompt="a red circle",
         api_base=api_base,
         base_url=httpx.URL(api_base),
@@ -357,6 +357,24 @@ def test_image_edit_prices_a_vertex_deployment_at_its_configured_location(
     assert cost_at("us-central1") == pytest.approx(0.044)
 
 
+def test_image_edit_accepts_a_string_additional_drop_params(respx_mock: respx.MockRouter) -> None:
+    edits_route: Final = respx_mock.post("https://api.openai.com/v1/images/edits").mock(
+        return_value=httpx.Response(status_code=200, json={"created": 1792551838, "data": [{"b64_json": "aW1n"}]})
+    )
+
+    response: Final = litellm.image_edit(
+        model="openai/gpt-image-2.5-sunburst",
+        image=b"\x89PNG\r\n\x1a\nfakepng",
+        prompt="make the circle blue",
+        api_key="sk-test",
+        quality="high",
+        additional_drop_params="quality",
+    )
+
+    assert edits_route.called
+    assert response.data[0].b64_json == "aW1n"
+
+
 class TestCustomLogger(CustomLogger):
     __test__ = False
 
@@ -670,3 +688,24 @@ async def test_chatgpt_images_forward_client_login_and_workspace(
     assert "cookie" not in request.headers
     assert "x-litellm-api-key" not in request.headers
     assert json.loads(request.content) == {"model": "gpt-image-2", "prompt": "A blue circle"}
+
+
+def test_image_generation_without_a_model_or_provider_fails_before_calling_any_provider(
+    respx_mock: respx.MockRouter,
+) -> None:
+    with pytest.raises(litellm.BadRequestError, match="model is required"):
+        litellm.image_generation(prompt="a red circle", api_key="fake_openai_api_key")
+
+    assert not respx_mock.calls
+
+
+def test_topaz_image_variation_works_without_a_model(respx_mock: respx.MockRouter) -> None:
+    route: Final = respx_mock.post("https://api.topazlabs.com/image/v1/enhance").mock(
+        return_value=httpx.Response(200, content=b"enhanced-image", headers={"content-type": "image/png"})
+    )
+
+    response: Final = litellm.image_variation(image=b"source-image", custom_llm_provider="topaz", api_key="fake-key")
+
+    assert route.call_count == 1
+    assert response.data is not None
+    assert response.data[0].b64_json == base64.b64encode(b"enhanced-image").decode()
diff --git a/tests/unit/integrations/websearch_interception/test_websearch_short_circuit.py b/tests/unit/integrations/websearch_interception/test_websearch_short_circuit.py
index fdc3771e903..414bcc11602 100644
--- a/tests/unit/integrations/websearch_interception/test_websearch_short_circuit.py
+++ b/tests/unit/integrations/websearch_interception/test_websearch_short_circuit.py
@@ -6,10 +6,13 @@ and executes the search directly without routing through the backend LLM.
 """
 
 import json
+from typing import Final
 from unittest.mock import AsyncMock, patch
 
 import pytest
+import respx
 
+import litellm
 from litellm.integrations.websearch_interception.handler import (
     WebSearchInterceptionLogger,
 )
@@ -169,6 +172,27 @@ class TestTryShortCircuitSearch:
 
         assert result is None
 
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        "empty_prompt",
+        [
+            "   ",
+            "Perform a web search for the query:   ",
+        ],
+    )
+    async def test_does_not_short_circuit_empty_or_whitespace_user_message(self, empty_prompt: str):
+        """User message that is whitespace or empty query → returns None without executing search."""
+        logger = WebSearchInterceptionLogger(enabled_providers=["github_copilot"])
+
+        result = await logger.try_short_circuit_search(
+            model="github_copilot/claude-sonnet-4",
+            messages=[{"role": "user", "content": empty_prompt}],
+            tools=[{"type": "web_search_20250305", "name": "web_search", "max_uses": 8}],
+            custom_llm_provider="github_copilot",
+        )
+
+        assert result is None
+
     @pytest.mark.asyncio
     async def test_search_failure_returns_error_text(self):
         """Search failure → response with error message, not exception"""
@@ -226,6 +250,46 @@ class TestTryShortCircuitSearch:
 # Query extraction tests
 # ---------------------------------------------------------------------------
 
+PERPLEXITY_SEARCH_URL: Final = "https://api.perplexity.ai/search"
+
+
+@pytest.fixture
+def perplexity_search(monkeypatch: pytest.MonkeyPatch, respx_mock: respx.MockRouter) -> respx.Route:
+    monkeypatch.setenv("PERPLEXITYAI_API_KEY", "test-perplexity-key")
+    monkeypatch.delenv("PERPLEXITY_API_BASE", raising=False)
+    monkeypatch.setattr(litellm, "disable_aiohttp_transport", True)
+    litellm.in_memory_llm_clients_cache.flush_cache()
+    return respx_mock.post(PERPLEXITY_SEARCH_URL).respond(
+        json={"results": [{"title": "Releases", "url": "https://example.com/releases", "snippet": "Release notes"}]}
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("user_message", "searched_query"),
+    [
+        ("Perform a web search for the query: litellm latest release", "litellm latest release"),
+        ('Perform a web search for the query: "litellm proxy"', '"litellm proxy"'),
+    ],
+)
+async def test_short_circuit_searches_the_query_inside_claude_codes_prompt(
+    perplexity_search: respx.Route, user_message: str, searched_query: str
+):
+    logger: Final = WebSearchInterceptionLogger(enabled_providers=["bedrock"])
+
+    result: Final = await logger.try_short_circuit_search(
+        model="bedrock/converse/us.anthropic.claude-sonnet-4-5-20250929-v1:0",
+        messages=[{"role": "user", "content": user_message}],
+        tools=[{"type": "web_search_20250305", "name": "web_search", "max_uses": 8}],
+        custom_llm_provider="bedrock",
+    )
+
+    assert perplexity_search.call_count == 1
+    assert json.loads(perplexity_search.calls.last.request.content)["query"] == searched_query
+    assert result is not None
+    server_tool_use: Final = next(block for block in result["content"] if block["type"] == "server_tool_use")
+    assert server_tool_use["input"]["query"] == searched_query
+
 
 # ---------------------------------------------------------------------------
 # Integration with entry point
diff --git a/tests/unit/interactions/test_interactions_streaming_iterator.py b/tests/unit/interactions/test_interactions_streaming_iterator.py
index afcd0d559d7..fb1fe92d637 100644
--- a/tests/unit/interactions/test_interactions_streaming_iterator.py
+++ b/tests/unit/interactions/test_interactions_streaming_iterator.py
@@ -16,7 +16,10 @@ import pytest
 import litellm
 from litellm.integrations.custom_logger import CustomLogger
 from litellm.interactions import streaming_iterator as interactions_streaming_iterator_module
-from litellm.interactions.streaming_iterator import InteractionsAPIStreamingIterator
+from litellm.interactions.streaming_iterator import (
+    InteractionsAPIStreamingIterator,
+    SyncInteractionsAPIStreamingIterator,
+)
 from litellm.litellm_core_utils import thread_pool_executor as thread_pool_executor_module
 from litellm.litellm_core_utils.litellm_logging import Logging as LitellmLogging
 from litellm.llms.gemini.interactions.transformation import GoogleAIStudioInteractionsConfig
@@ -148,3 +151,43 @@ async def test_stream_logs_its_first_event_time_measured_from_the_call_start():
 
     assert first_event_at is not None
     assert recorder.logged == [(call_start, first_event_at)]
+
+
+_LINE_SEPARATED_TEXT: Final = "before\u2028between\u2029after"
+
+
+async def _first_event(
+    iterator: InteractionsAPIStreamingIterator | SyncInteractionsAPIStreamingIterator,
+) -> InteractionsAPIStreamingResponse:
+    if isinstance(iterator, InteractionsAPIStreamingIterator):
+        return await iterator.__anext__()
+    return next(iterator)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("iterator_cls", [InteractionsAPIStreamingIterator, SyncInteractionsAPIStreamingIterator])
+async def test_stream_keeps_unicode_line_separators_inside_the_delta_text(
+    iterator_cls: type[InteractionsAPIStreamingIterator] | type[SyncInteractionsAPIStreamingIterator],
+) -> None:
+    delta: Final = {"type": "text", "text": _LINE_SEPARATED_TEXT}
+    event: Final = {"event_type": "step.delta", "id": "interaction-1", "delta": delta}
+    iterator: Final = iterator_cls(
+        response=httpx.Response(
+            200, stream=httpx.ByteStream(f"data: {json.dumps(event, ensure_ascii=False)}\n\n".encode())
+        ),
+        model="gemini/gemini-3.1-pro-preview",
+        interactions_api_config=GoogleAIStudioInteractionsConfig(),
+        logging_obj=LitellmLogging(
+            model="gemini/gemini-3.1-pro-preview",
+            messages=[{"role": "user", "content": "hi"}],
+            stream=True,
+            call_type="ainteraction",
+            start_time=datetime(2026, 10, 9, 12, 0, 0),
+            litellm_call_id="interactions-separators",
+            function_id="interactions-separators",
+        ),
+    )
+
+    first: Final = await _first_event(iterator)
+
+    assert first.delta == delta
diff --git a/tests/unit/router_utils/test_batch_utils.py b/tests/unit/litellm_core_utils/test_batch_utils.py
similarity index 97%
rename from tests/unit/router_utils/test_batch_utils.py
rename to tests/unit/litellm_core_utils/test_batch_utils.py
index 79fe86a37c0..cd37d635c43 100644
--- a/tests/unit/router_utils/test_batch_utils.py
+++ b/tests/unit/litellm_core_utils/test_batch_utils.py
@@ -7,7 +7,7 @@ from typing import Dict, Final, List
 import pytest
 
 import litellm
-from litellm.router_utils.batch_utils import (
+from litellm.litellm_core_utils.batch_utils import (
     InMemoryFile,
     get_router_metadata_variable_name,
     parse_jsonl_with_embedded_newlines,
@@ -116,7 +116,7 @@ def test_router_metadata_variable_name():
 
 def test_non_json_input():
     """Test that replace_model_in_jsonl returns original content for non-JSON input"""
-    from litellm.router_utils.batch_utils import replace_model_in_jsonl
+    from litellm.litellm_core_utils.batch_utils import replace_model_in_jsonl
 
     # Test with non-JSON string
     non_json_str = "This is not a JSON string"
@@ -138,7 +138,7 @@ def test_non_json_input():
 
 def test_should_replace_model_in_jsonl():
     """Test that should_replace_model_in_jsonl returns the correct value"""
-    from litellm.router_utils.batch_utils import should_replace_model_in_jsonl
+    from litellm.litellm_core_utils.batch_utils import should_replace_model_in_jsonl
 
     assert should_replace_model_in_jsonl(purpose="batch") is True
     assert should_replace_model_in_jsonl(purpose="batch", passthrough=True) is False
@@ -340,7 +340,7 @@ def test_replace_model_in_jsonl_with_embedded_newlines():
 
 
 def test_is_batch_retrieve_call_type_matches_only_batch_retrieves():
-    from litellm.router_utils.batch_utils import is_batch_retrieve_call_type
+    from litellm.litellm_core_utils.batch_utils import is_batch_retrieve_call_type
     from litellm.types.utils import CallTypes
 
     assert is_batch_retrieve_call_type(CallTypes.aretrieve_batch.value) is True
@@ -389,7 +389,8 @@ def setup_and_teardown():
 )
 def test_batch_charge_identity_requires_a_cost_bearing_retrieval(call_type: str, cost: float, eligible: bool) -> None:
     from openai.types import Batch
-    from litellm.router_utils.batch_utils import batch_id_to_charge_once
+
+    from litellm.litellm_core_utils.batch_utils import batch_id_to_charge_once
 
     batch: Final = Batch(
         id="batch-budget", completion_window="24h", created_at=1, endpoint="/v1/chat/completions",
@@ -401,7 +402,7 @@ def test_batch_charge_identity_requires_a_cost_bearing_retrieval(call_type: str,
 
 def test_batch_charge_markers_keep_counters_and_batches_independent() -> None:
     from litellm.caching.in_memory_cache import InMemoryCache
-    from litellm.router_utils.batch_utils import batch_charged_once_marker_key
+    from litellm.litellm_core_utils.batch_utils import batch_charged_once_marker_key
 
     cache: Final = InMemoryCache()
     cache.set_cache(batch_charged_once_marker_key("provider-spend", "first-batch"), 1)
diff --git a/tests/unit/litellm_core_utils/test_streaming_handler.py b/tests/unit/litellm_core_utils/test_streaming_handler.py
index a1b58521d7e..79978ecfe8e 100644
--- a/tests/unit/litellm_core_utils/test_streaming_handler.py
+++ b/tests/unit/litellm_core_utils/test_streaming_handler.py
@@ -506,6 +506,118 @@ def test_multi_chunk_reasoning_and_content(
     assert initialized_custom_stream_wrapper.sent_last_thinking_block is True
 
 
+def _stream_chunk(delta: dict[str, object], finish_reason: str | None = None) -> ModelResponseStream:
+    return ModelResponseStream(choices=[{"index": 0, "delta": delta, "finish_reason": finish_reason}])
+
+
+def _content_through_first_call(deltas: Sequence[Delta]) -> str:
+    first_call: Final = next(
+        (index for index, delta in enumerate(deltas) if delta.tool_calls or delta.function_call), len(deltas)
+    )
+    return "".join(delta.content or "" for delta in deltas[: first_call + 1])
+
+
+_GET_WEATHER_CALL: Final = {
+    "index": 0,
+    "id": "call_1",
+    "type": "function",
+    "function": {"name": "get_weather", "arguments": '{"city": "Paris"}'},
+}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("is_async", [True, False])
+@pytest.mark.parametrize(
+    "chunks,expected_content,expected_tool_calls",
+    [
+        (
+            (
+                _stream_chunk({"reasoning_content": "Check the weather"}),
+                _stream_chunk({"tool_calls": [_GET_WEATHER_CALL]}),
+                _stream_chunk({}, "tool_calls"),
+            ),
+            "<think>Check the weather</think>",
+            1,
+        ),
+        (
+            (
+                _stream_chunk({"reasoning_content": "Pick a function"}),
+                _stream_chunk({"function_call": {"name": "get_weather", "arguments": "{}"}}),
+                _stream_chunk({}, "function_call"),
+            ),
+            "<think>Pick a function</think>",
+            0,
+        ),
+        (
+            (
+                _stream_chunk({"reasoning_content": "Step one"}),
+                _stream_chunk({"reasoning_content": ", step two"}),
+                _stream_chunk({}, "length"),
+            ),
+            "<think>Step one, step two</think>",
+            0,
+        ),
+        (
+            (
+                _stream_chunk({"reasoning_content": "a"}),
+                _stream_chunk({"content": "b"}),
+                _stream_chunk({"reasoning_content": "c"}),
+                _stream_chunk({"content": "d"}),
+                _stream_chunk({}, "stop"),
+            ),
+            "<think>a</think>b<think>c</think>d",
+            0,
+        ),
+        (
+            (_stream_chunk({"reasoning_content": "Still thinking"}),),
+            "<think>Still thinking</think>",
+            0,
+        ),
+        (
+            (_stream_chunk({"content": "hi"}), _stream_chunk({}, "stop")),
+            "hi",
+            0,
+        ),
+    ],
+    ids=[
+        "reasoning_then_tool_call",
+        "reasoning_then_function_call",
+        "reasoning_cut_by_length",
+        "reasoning_after_answer",
+        "stream_ends_mid_reasoning",
+        "answer_without_reasoning",
+    ],
+)
+async def test_merged_reasoning_stream_keeps_think_tags_balanced(
+    logging_obj: Logging,
+    is_async: bool,
+    chunks: tuple[ModelResponseStream, ...],
+    expected_content: str,
+    expected_tool_calls: int,
+) -> None:
+    response: Final = CustomStreamWrapper(
+        completion_stream=ModelResponseListIterator(model_responses=[chunk.model_copy(deep=True) for chunk in chunks]),
+        model="deepseek-reasoner",
+        logging_obj=logging_obj,
+    )
+    response.merge_reasoning_content_in_choices = True
+
+    deltas: Final = (
+        tuple([chunk.choices[0].delta async for chunk in response])
+        if is_async
+        else tuple(chunk.choices[0].delta for chunk in response)
+    )
+    logged: Final = litellm.stream_chunk_builder(chunks=response.chunks)
+
+    assert "".join(delta.content or "" for delta in deltas) == expected_content
+    assert _content_through_first_call(deltas) == expected_content
+    assert sum(len(delta.tool_calls or ()) for delta in deltas) == expected_tool_calls
+    assert logged.choices[0].message.content == (expected_content or None)
+    assert any(chunk.choices[0].finish_reason for chunk in response.chunks if chunk.choices) == any(
+        chunk.choices[0].finish_reason for chunk in chunks
+    )
+
+
 def test_strip_sse_data_from_chunk():
     """Test the static method that strips 'data: ' prefix from SSE chunks"""
     # Test with string inputs
@@ -7849,7 +7961,7 @@ def gemini_mock_post_streaming(url, **kwargs):
     mock_response = MagicMock()
     mock_response.status_code = 200
     mock_response.headers = {"Content-Type": "text/event-stream"}
-    mock_response.iter_lines = MagicMock(return_value=stream_response())
+    mock_response.iter_text = MagicMock(return_value=stream_response())
 
     return mock_response
 
diff --git a/tests/unit/llms/anthropic/chat/test_anthropic_chat_handler.py b/tests/unit/llms/anthropic/chat/test_anthropic_chat_handler.py
index 1f4a5aaa256..355d407001c 100644
--- a/tests/unit/llms/anthropic/chat/test_anthropic_chat_handler.py
+++ b/tests/unit/llms/anthropic/chat/test_anthropic_chat_handler.py
@@ -15,7 +15,7 @@ import litellm
 from litellm._uuid import uuid
 from litellm.constants import RESPONSE_FORMAT_TOOL_NAME
 from litellm.litellm_core_utils.prompt_templates.factory import anthropic_messages_pt
-from litellm.llms.anthropic.chat.handler import ModelResponseIterator, _envelope_verdict, make_call
+from litellm.llms.anthropic.chat.handler import ModelResponseIterator, _envelope_verdict, make_call, make_sync_call
 from litellm.llms.base_llm.base_utils import response_format_schema, unwrap_response_format_envelope
 from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler, HTTPHandler
 from litellm.types.llms.openai import (
@@ -27,24 +27,34 @@ from litellm.types.utils import ChatCompletionDeltaToolCall, ModelResponseStream
 from tests.unit.llms.anthropic.anthropic_docs_refusal import ANTHROPIC_DOCS_REFUSAL_MESSAGE
 
 
+def _text_delta_stream(text: str) -> bytes:
+    events: Final = (
+        ("content_block_start", {"type": "content_block_start", "index": 0, "content_block": {"type": "text", "text": ""}}),
+        ("content_block_delta", {"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": text}}),
+    )
+    return "".join(
+        f"event: {name}\ndata: {json.dumps(payload, ensure_ascii=False)}\n\n" for name, payload in events
+    ).encode()
+
+
+def _streamed_text(chunks: list[object]) -> str:
+    return "".join(chunk.choices[0].delta.content or "" for chunk in chunks if isinstance(chunk, ModelResponseStream))
+
+
 @pytest.mark.asyncio
 async def test_make_call_passes_logging_obj_to_client_post():
     """make_call must pass logging_obj to client.post so track_llm_api_timing can set llm_api_duration_ms for litellm_overhead_time_ms."""
     mock_client = AsyncMock()
-    mock_response = MagicMock()
-    mock_response.aiter_lines = MagicMock(
-        return_value=iter([b'data: {"type":"message_start"}\n', b'data: {"type":"message_delta"}\n'])
-    )
-    mock_client.post.return_value = mock_response
+    mock_client.post.return_value = httpx.Response(200, stream=httpx.ByteStream(_text_delta_stream("Hi there")))
 
     logging_obj = MagicMock()
 
-    await make_call(
+    completion_stream, _ = await make_call(
         client=mock_client,
         api_base="https://api.anthropic.com/v1/messages",
         headers={},
         data="{}",
-        model="claude-3-5-haiku",
+        model="claude-haiku-5-5",
         messages=[{"role": "user", "content": "Hi"}],
         logging_obj=logging_obj,
         timeout=60.0,
@@ -54,6 +64,39 @@ async def test_make_call_passes_logging_obj_to_client_post():
     mock_client.post.assert_called_once()
     call_kwargs = mock_client.post.call_args[1]
     assert call_kwargs.get("logging_obj") is logging_obj
+    assert _streamed_text([chunk async for chunk in completion_stream]) == "Hi there"
+
+
+_LINE_SEPARATED_TEXT: Final = "before\u2028between\u2029after"
+
+
+async def _streamed_chunks(sync_stream: bool, text: str) -> list[object]:
+    transport: Final = httpx.MockTransport(
+        lambda request: httpx.Response(200, stream=httpx.ByteStream(_text_delta_stream(text)))
+    )
+    call_args: Final = {
+        "api_base": "https://api.anthropic.com/v1/messages",
+        "headers": {},
+        "data": "{}",
+        "model": "claude-haiku-5-5",
+        "messages": [{"role": "user", "content": "Hi"}],
+        "logging_obj": MagicMock(),
+        "timeout": 60.0,
+        "json_mode": False,
+    }
+    if sync_stream:
+        sync_iterator, _ = make_sync_call(client=HTTPHandler(client=httpx.Client(transport=transport)), **call_args)
+        return list(sync_iterator)
+    async_iterator, _ = await make_call(client=AsyncHTTPHandler(transport=transport), **call_args)
+    return [chunk async for chunk in async_iterator]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("sync_stream", [True, False])
+async def test_streamed_text_keeps_unicode_line_separators(sync_stream: bool) -> None:
+    chunks: Final = await _streamed_chunks(sync_stream, _LINE_SEPARATED_TEXT)
+
+    assert _streamed_text(chunks) == _LINE_SEPARATED_TEXT
 
 
 def test_anthropic_completion_does_not_send_deployment_default_limits():
diff --git a/tests/unit/llms/anthropic/messages/test_stream_assembly.py b/tests/unit/llms/anthropic/messages/test_stream_assembly.py
index f7d6b8d4f8c..4993d2fa9bf 100644
--- a/tests/unit/llms/anthropic/messages/test_stream_assembly.py
+++ b/tests/unit/llms/anthropic/messages/test_stream_assembly.py
@@ -144,6 +144,30 @@ def test_anthropic_message_delta_fields_reads_the_fields_the_openai_shape_drops(
     assert dict(anthropic_message_delta_fields(GOOGLE_STREAM)) == {}
 
 
+def test_anthropic_message_delta_fields_reads_a_message_delta_whose_json_holds_unicode_line_separators() -> None:
+    safeguard_results: Final = [
+        {
+            "type": "dangerous_tool_use",
+            "status": {
+                "type": "available",
+                "tool_uses": {
+                    "toolu_01": {"type": "evaluated", "outcome": "flagged", "explanation": "deletes\u2028the\u2029root"}
+                },
+            },
+        }
+    ]
+    message_delta: Final = {
+        "type": "message_delta",
+        "delta": {"stop_reason": "end_turn", "safeguard_results": safeguard_results},
+        "usage": {"output_tokens": 2},
+    }
+    raw_message_delta_frame: Final = f"event: message_delta\ndata: {json.dumps(message_delta, ensure_ascii=False)}\n\n"
+
+    fields: Final = anthropic_message_delta_fields((*ANTHROPIC_STREAM[:5], raw_message_delta_frame.encode()))
+
+    assert dict(fields) == {"safeguard_results": safeguard_results}
+
+
 @pytest.mark.parametrize(
     "chunks",
     [GOOGLE_STREAM, INVALID_UTF8, (ANTHROPIC_ERROR,), ()],
diff --git a/tests/unit/llms/azure/image_generation/test_azure_image_generation_init.py b/tests/unit/llms/azure/image_generation/test_azure_image_generation_init.py
index eabd5c8427d..83e01fce642 100644
--- a/tests/unit/llms/azure/image_generation/test_azure_image_generation_init.py
+++ b/tests/unit/llms/azure/image_generation/test_azure_image_generation_init.py
@@ -20,27 +20,9 @@ from litellm.llms.azure.image_generation.http_utils import (
     azure_deployment_image_generation_json_body,
 )
 from litellm.llms.custom_httpx.http_handler import HTTPHandler
-from litellm.llms.azure.image_generation import (
-    AzureDallE3ImageGenerationConfig,
-    get_azure_image_generation_config,
-)
 from litellm.utils import get_optional_params_image_gen
 
 
-@pytest.mark.parametrize(
-    "received_model, expected_config",
-    [
-        ("dall-e-3", AzureDallE3ImageGenerationConfig),
-        ("dalle-3", AzureDallE3ImageGenerationConfig),
-        ("openai_dall_e_3", AzureDallE3ImageGenerationConfig),
-    ],
-)
-def test_azure_image_generation_config(received_model, expected_config):
-    assert isinstance(
-        get_azure_image_generation_config(received_model), expected_config
-    )
-
-
 def test_azure_deployment_image_generation_json_body():
     """Deployment-scoped Azure image URL must not send ``model`` in JSON."""
     api = (
diff --git a/tests/unit/llms/azure_ai/agents/test_handler.py b/tests/unit/llms/azure_ai/agents/test_handler.py
index 71466bb172c..14b6094747f 100644
--- a/tests/unit/llms/azure_ai/agents/test_handler.py
+++ b/tests/unit/llms/azure_ai/agents/test_handler.py
@@ -173,7 +173,7 @@ async def test_handler_acompletion_with_thread_id_reuses_that_thread() -> None:
 
 
 def _sse(event: str, data: dict[str, object] | str) -> str:
-    return f"event: {event}\ndata: {data if isinstance(data, str) else json.dumps(data)}\n\n"
+    return f"event: {event}\ndata: {data if isinstance(data, str) else json.dumps(data, ensure_ascii=False)}\n\n"
 
 
 def _message_delta(text: str) -> dict[str, object]:
@@ -222,3 +222,24 @@ async def test_acompletion_stream_yields_agent_message_deltas_then_stop(respx_mo
         "thread": {"messages": [{"role": "user", "content": "Hi Agent, what is 10 + 5?"}]},
     }
     assert chunks == [("10 + 5", None), (" = 15", None), (None, "stop")]
+
+
+@pytest.mark.asyncio
+async def test_acompletion_stream_keeps_unicode_line_separators_inside_a_delta(respx_mock: respx.MockRouter) -> None:
+    separated_text: Final = "before\u2028between\u2029after"
+    _ = respx_mock.post(f"{API_BASE}/threads/runs").respond(
+        200,
+        text=_sse("thread.message.delta", _message_delta(separated_text)) + _sse("done", "[DONE]"),
+        headers={"content-type": "text/event-stream"},
+    )
+
+    response: Final = await litellm.acompletion(
+        model=f"azure_ai/agents/{AGENT_ID}",
+        messages=[{"role": "user", "content": "Say it with separators"}],
+        api_base=API_BASE,
+        api_key="azure-ad-token",
+        stream=True,
+    )
+    chunks: Final = [(chunk.choices[0].delta.content, chunk.choices[0].finish_reason) async for chunk in response]
+
+    assert chunks == [(separated_text, None), (None, "stop")]
diff --git a/tests/unit/llms/azure_ai/agents/test_transformation.py b/tests/unit/llms/azure_ai/agents/test_transformation.py
index 10676438858..413908c8313 100644
--- a/tests/unit/llms/azure_ai/agents/test_transformation.py
+++ b/tests/unit/llms/azure_ai/agents/test_transformation.py
@@ -1,7 +1,7 @@
 import json
 from typing import Final
-from unittest.mock import MagicMock
 
+import httpx
 import pytest
 
 from litellm.llms.azure_ai.agents.transformation import AzureAIAgentsConfig
@@ -428,15 +428,10 @@ async def test_azure_ai_agents_streaming_accumulates_annotations_from_multiple_t
         "data: [DONE]",
     ]
 
-    async def mock_aiter_lines():
-        for line in sse_lines:
-            yield line
-
-    mock_response = MagicMock()
-    mock_response.aiter_lines = MagicMock(return_value=mock_aiter_lines())
+    sse_response = httpx.Response(200, stream=httpx.ByteStream("\n".join(sse_lines).encode()))
 
     chunks = []
-    async for chunk in handler._process_sse_stream(mock_response, "azure_ai/agents/asst_123"):
+    async for chunk in handler._process_sse_stream(sse_response, "azure_ai/agents/asst_123"):
         chunks.append(chunk)
 
     final_chunk = chunks[-1]
@@ -498,15 +493,10 @@ async def test_azure_ai_agents_streaming_annotations_from_completed_message():
         "data: [DONE]",
     ]
 
-    async def mock_aiter_lines():
-        for line in sse_lines:
-            yield line
-
-    mock_response = MagicMock()
-    mock_response.aiter_lines = MagicMock(return_value=mock_aiter_lines())
+    sse_response = httpx.Response(200, stream=httpx.ByteStream("\n".join(sse_lines).encode()))
 
     chunks = []
-    async for chunk in handler._process_sse_stream(mock_response, "azure_ai/agents/asst_123"):
+    async for chunk in handler._process_sse_stream(sse_response, "azure_ai/agents/asst_123"):
         chunks.append(chunk)
 
     assert len(chunks) >= 1
diff --git a/tests/unit/llms/base_llm/guardrail_translation/test_utils.py b/tests/unit/llms/base_llm/guardrail_translation/test_utils.py
index 65208a2bd3b..acd50616f90 100644
--- a/tests/unit/llms/base_llm/guardrail_translation/test_utils.py
+++ b/tests/unit/llms/base_llm/guardrail_translation/test_utils.py
@@ -1,9 +1,11 @@
+import json
 from typing import Final
 
 import pytest
 
 import litellm
 from litellm.llms.base_llm.guardrail_translation.utils import (
+    blocked_response_usage,
     effective_skip_system_message_for_guardrail,
     effective_skip_tool_message_for_guardrail,
 )
@@ -32,3 +34,18 @@ def test_a_per_guardrail_skip_flag_wins_over_the_global_setting(
 
     assert effective_skip_system_message_for_guardrail(guardrail) is expected
     assert effective_skip_tool_message_for_guardrail(guardrail) is expected
+
+
+def test_blocked_response_usage_reads_a_message_delta_whose_json_holds_unicode_line_separators() -> None:
+    message_start: Final = {"type": "message_start", "message": {"usage": {"input_tokens": 11, "output_tokens": 1}}}
+    message_delta: Final = {
+        "type": "message_delta",
+        "delta": {"stop_reason": "stop_sequence", "stop_sequence": "END\u2028OF\u2029TURN"},
+        "usage": {"output_tokens": 7},
+    }
+    stream: Final = "".join(
+        f"event: {event['type']}\ndata: {json.dumps(event, ensure_ascii=False)}\n\n"
+        for event in (message_start, message_delta)
+    ).encode()
+
+    assert blocked_response_usage([stream]) == {"input_tokens": 11, "output_tokens": 7}
diff --git a/tests/unit/llms/bedrock/chat/invoke_transformations/test_base_invoke_transformation.py b/tests/unit/llms/bedrock/chat/invoke_transformations/test_base_invoke_transformation.py
index 1890c68b30d..c36644ba536 100644
--- a/tests/unit/llms/bedrock/chat/invoke_transformations/test_base_invoke_transformation.py
+++ b/tests/unit/llms/bedrock/chat/invoke_transformations/test_base_invoke_transformation.py
@@ -242,6 +242,33 @@ def test_transform_response_hands_json_mode_to_nova():
     assert json.loads(result.choices[0].message.content) == {"city": "Paris", "temperature": 21}
 
 
+@pytest.mark.parametrize(("finish_reason", "expected"), [("MAX_TOKENS", "length"), (None, "stop")])
+def test_transform_response_accepts_null_cohere_finish_reason(finish_reason: str | None, expected: str) -> None:
+    from litellm.types.utils import ModelResponse
+
+    raw_response: Final = httpx.Response(
+        200,
+        json={"generations": [{"text": "Hello there", "finish_reason": finish_reason}]},
+        request=httpx.Request("POST", "https://bedrock"),
+    )
+
+    result: Final = AmazonInvokeConfig().transform_response(
+        model="invoke/cohere.command-text-v14",
+        raw_response=raw_response,
+        model_response=ModelResponse(),
+        logging_obj=MagicMock(),
+        request_data={},
+        messages=[{"role": "user", "content": "hi"}],
+        optional_params={},
+        litellm_params={},
+        encoding=None,
+        api_key=None,
+    )
+
+    assert result.choices[0].message.content == "Hello there"
+    assert result.choices[0].finish_reason == expected
+
+
 def _stream_invoke_completion_with_spied_client(**kwargs: object) -> tuple[MagicMock, MagicMock]:
     mock_response = MagicMock()
     mock_response.status_code = 200
diff --git a/tests/unit/llms/bedrock/chat/invoke_transformations/test_twelvelabs_pegasus_transformation.py b/tests/unit/llms/bedrock/chat/invoke_transformations/test_twelvelabs_pegasus_transformation.py
index d90e9933b88..5b3cb2e0c92 100644
--- a/tests/unit/llms/bedrock/chat/invoke_transformations/test_twelvelabs_pegasus_transformation.py
+++ b/tests/unit/llms/bedrock/chat/invoke_transformations/test_twelvelabs_pegasus_transformation.py
@@ -1,6 +1,13 @@
+from typing import Final
+from unittest.mock import Mock
+
+import httpx
+import pytest
+
 from litellm.llms.bedrock.chat.invoke_transformations.amazon_twelvelabs_pegasus_transformation import (
     AmazonTwelveLabsPegasusConfig,
 )
+from litellm.types.utils import ModelResponse
 
 
 def _make_messages() -> list[dict]:
@@ -84,3 +91,24 @@ def test_transform_request_includes_s3_media():
     s3_location = request["mediaSource"]["s3Location"]
     assert s3_location["uri"] == "s3://test-bucket/video.mp4"
     assert s3_location["bucketOwner"] == "123456789012"
+
+
+@pytest.mark.parametrize(
+    ("finish_reason", "expected"),
+    [("length", "length"), (None, "stop")],
+)
+def test_transform_response_accepts_null_finish_reason(finish_reason: str | None, expected: str) -> None:
+    result: Final = AmazonTwelveLabsPegasusConfig().transform_response(
+        model="twelvelabs.pegasus-1-2-v1:0",
+        raw_response=httpx.Response(200, json={"message": "A cat jumps.", "finishReason": finish_reason}),
+        model_response=ModelResponse(),
+        logging_obj=Mock(),
+        request_data={},
+        messages=_make_messages(),
+        optional_params={},
+        litellm_params={},
+        encoding=None,
+    )
+
+    assert result.choices[0].message.content == "A cat jumps."
+    assert result.choices[0].finish_reason == expected
diff --git a/tests/unit/llms/bedrock/files/test_bedrock_files_transformation.py b/tests/unit/llms/bedrock/files/test_bedrock_files_transformation.py
index 7e05ef500f5..9d9e39df944 100644
--- a/tests/unit/llms/bedrock/files/test_bedrock_files_transformation.py
+++ b/tests/unit/llms/bedrock/files/test_bedrock_files_transformation.py
@@ -4458,6 +4458,20 @@ class TestMalformedBatchJsonl:
 _VALID_BATCH_RECORD: Final = json.loads(_VALID_BATCH_LINE)
 
 
+def test_file_content_conversion_keeps_a_line_whose_json_holds_unicode_line_separators() -> None:
+    text: Final = "Hello\u2028from\u2029batch"
+    body: Final = {**_VALID_BATCH_RECORD["body"], "messages": [{"role": "user", "content": text}]}
+    record: Final = {**_VALID_BATCH_RECORD, "body": body}
+    file_content: Final = f"{json.dumps(record, ensure_ascii=False)}\n".encode()
+
+    bedrock_jsonl, _ = BedrockJsonlFilesTransformation().transform_openai_file_content_to_bedrock_file_content(
+        file_content
+    )
+
+    (bedrock_record,) = (json.loads(line) for line in bedrock_jsonl.split("\n"))
+    assert bedrock_record["modelInput"]["messages"] == [{"role": "user", "content": [{"text": text}]}]
+
+
 def _batch_line(body: object) -> str:
     return json.dumps({**_VALID_BATCH_RECORD, "body": body})
 
diff --git a/tests/unit/llms/bedrock/passthrough/guardrail_translation/test_handler.py b/tests/unit/llms/bedrock/passthrough/guardrail_translation/test_handler.py
index 5aaee1f0ee4..aec1672b335 100644
--- a/tests/unit/llms/bedrock/passthrough/guardrail_translation/test_handler.py
+++ b/tests/unit/llms/bedrock/passthrough/guardrail_translation/test_handler.py
@@ -18,7 +18,7 @@ import types
 from collections.abc import Callable, Mapping, Sequence
 from datetime import datetime
 from itertools import chain
-from typing import ClassVar, Literal, TypeAlias
+from typing import ClassVar, Final, Literal, TypeAlias
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import httpx
@@ -60,6 +60,7 @@ from litellm.llms.bedrock.passthrough.guardrail_translation.handler import (
     BedrockPassthroughGuardrailHandler,
     _extract_converse_texts,
     _is_converse_endpoint,
+    _sse_events,
     _write_back_texts,
 )
 
@@ -3840,3 +3841,14 @@ class TestInvokeStreamGuardrailRelay:
 
         assert received_key is not None and received_key.texts == ("In Paris",)
         assert rewritten_key == received_key
+
+
+def test_sse_events_keeps_a_data_line_whose_json_holds_unicode_line_separators() -> None:
+    event: Final = {
+        "type": "content_block_delta",
+        "index": 0,
+        "delta": {"type": "text_delta", "text": "Card\u2028on\u2029file"},
+    }
+    sse: Final = f"event: content_block_delta\ndata: {json.dumps(event, ensure_ascii=False)}\n\n".encode()
+
+    assert _sse_events(sse) == (event,)
diff --git a/tests/unit/llms/bedrock/search/test_agentcore_search_transformation.py b/tests/unit/llms/bedrock/search/test_agentcore_search_transformation.py
index 664dbf87fe9..01cca1fc270 100644
--- a/tests/unit/llms/bedrock/search/test_agentcore_search_transformation.py
+++ b/tests/unit/llms/bedrock/search/test_agentcore_search_transformation.py
@@ -8,6 +8,7 @@ the sharded CI (coverage collection runs against this tree).
 
 import json
 import os
+from typing import Final
 
 import httpx
 import pytest
@@ -682,3 +683,17 @@ def test_transform_search_response_ignores_text_blocks_without_result_objects(bl
     body = {"result": {"content": [{"type": "text", "text": block_text}]}}
 
     assert _transform_text(json.dumps(body)).results == []
+
+
+def test_transform_search_response_keeps_a_result_whose_sse_json_holds_unicode_line_separators() -> None:
+    snippet: Final = "Snippet\u2028for\u2029result"
+    results: Final = [{"title": "Result", "url": "https://example.com/1", "text": snippet}]
+    body: Final = {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "result": {"content": [{"type": "text", "text": json.dumps(results, ensure_ascii=False)}]},
+    }
+
+    response: Final = _transform_text(f"event: message\ndata: {json.dumps(body, ensure_ascii=False)}\n\n")
+
+    assert _as_tuples(response) == [("Result", "https://example.com/1", snippet, None, None)]
diff --git a/tests/unit/llms/chatgpt/responses/test_chatgpt_responses_transformation.py b/tests/unit/llms/chatgpt/responses/test_chatgpt_responses_transformation.py
index a6f7d613f28..635363e77ea 100644
--- a/tests/unit/llms/chatgpt/responses/test_chatgpt_responses_transformation.py
+++ b/tests/unit/llms/chatgpt/responses/test_chatgpt_responses_transformation.py
@@ -587,6 +587,37 @@ class TestChatGPTResponsesMultiAccount:
         assert headers_default["ChatGPT-Account-Id"] == "acct-default"
 
 
+def test_chatgpt_non_stream_sse_keeps_an_output_item_whose_text_holds_unicode_line_separators() -> None:
+    text: Final = "Hello\u2028from\u2029stream"
+    output_item_done: Final = {
+        "type": "response.output_item.done",
+        "output_index": 0,
+        "item": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": text}]},
+    }
+    completed: Final = {
+        "type": "response.completed",
+        "response": {
+            "id": "resp_test",
+            "object": "response",
+            "created_at": 1700000000,
+            "status": "completed",
+            "model": "gpt-6.1-sol",
+            "output": [],
+        },
+    }
+    sse_body: Final = "".join(
+        f"data: {json.dumps(event, ensure_ascii=False)}\n" for event in (output_item_done, completed)
+    )
+
+    parsed: Final = ChatGPTResponsesAPIConfig().transform_response_api_response(
+        model="chatgpt/gpt-6.1-sol",
+        raw_response=httpx.Response(200, headers={"content-type": "text/event-stream"}, text=sse_body),
+        logging_obj=MagicMock(),
+    )
+
+    assert parsed.output_text == text
+
+
 @pytest.mark.parametrize("call", ["responses", "completion"])
 def test_prompt_cache_key_keeps_one_session_header_across_requests(
     call: str, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
diff --git a/tests/unit/llms/cloudflare/test_cloudflare_transformation.py b/tests/unit/llms/cloudflare/test_cloudflare_transformation.py
index 3a45c83556c..ccbfc02f0e6 100644
--- a/tests/unit/llms/cloudflare/test_cloudflare_transformation.py
+++ b/tests/unit/llms/cloudflare/test_cloudflare_transformation.py
@@ -1,6 +1,6 @@
 import asyncio
 import json
-from collections.abc import Callable, Iterator
+from collections.abc import AsyncIterator, Callable, Iterator
 from typing import Final
 from unittest.mock import MagicMock
 
@@ -380,6 +380,35 @@ def test_completion_cloudflare_stream(sync_mode: bool, _cloudflare_httpx_transpo
     assert "language" in content.lower()
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("sync_mode", [True, False], ids=["sync", "async"])
+async def test_cloudflare_stream_keeps_unicode_line_separators_inside_content(
+    sync_mode: bool, _cloudflare_httpx_transport: None
+) -> None:
+    streamed_text: Final = ("alpha\u2028", "beta\u2029", "gamma")
+    base: Final = {"id": "chatcmpl-cf", "object": "chat.completion.chunk", "created": 1, "model": "@cf/glm"}
+    body: Final = "".join(
+        f"data: {json.dumps({**base, 'choices': [{'index': 0, 'delta': {'content': text}}]}, ensure_ascii=False)}\n\n"
+        for text in streamed_text
+    )
+    with respx.mock(assert_all_called=True) as api:
+        api.post(f"{FAKE_API_BASE}/chat/completions").respond(
+            200, headers={"content-type": "text/event-stream"}, content=(body + "data: [DONE]\n\n").encode()
+        )
+        request: Final = {
+            "model": "cloudflare/@cf/glm",
+            "messages": [{"role": "user", "content": "repeat"}],
+            "stream": True,
+            "api_base": FAKE_API_BASE,
+            "api_key": FAKE_API_KEY,
+        }
+        chunks: Final = (
+            tuple(completion(**request)) if sync_mode else tuple([c async for c in await acompletion(**request)])
+        )
+
+    assert "".join(c.choices[0].delta.content or "" for c in chunks) == "".join(streamed_text)
+
+
 def _make_mock_response(json_data: Dict[str, Any]) -> MagicMock:
     mock = MagicMock(spec=httpx.Response)
     mock.status_code = 200
@@ -397,13 +426,13 @@ def test_acompletion_cloudflare_stream(sync_mode, monkeypatch):
 
     if sync_mode:
 
-        def _iter_lines():
+        def _iter_text() -> Iterator[str]:
             for chunk in raw_chunks:
-                yield f"data: {chunk}"
-            yield "data: [DONE]"
+                yield f"data: {chunk}\n\n"
+            yield "data: [DONE]\n\n"
 
         mock_resp = MagicMock()
-        mock_resp.iter_lines.return_value = _iter_lines()
+        mock_resp.iter_text.return_value = _iter_text()
         mock_resp.status_code = 200
         mock_resp.headers = {"content-type": "text/event-stream"}
 
@@ -420,13 +449,13 @@ def test_acompletion_cloudflare_stream(sync_mode, monkeypatch):
             mock_post.assert_called_once()
     else:
 
-        async def _aiter_lines():
+        async def _aiter_text() -> AsyncIterator[str]:
             for chunk in raw_chunks:
-                yield f"data: {chunk}"
-            yield "data: [DONE]"
+                yield f"data: {chunk}\n\n"
+            yield "data: [DONE]\n\n"
 
         mock_resp = MagicMock()
-        mock_resp.aiter_lines.return_value = _aiter_lines()
+        mock_resp.aiter_text.return_value = _aiter_text()
         mock_resp.status_code = 200
         mock_resp.headers = {"content-type": "text/event-stream"}
 
diff --git a/tests/unit/llms/codestral/__init__.py b/tests/unit/llms/codestral/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/unit/llms/codestral/completion/__init__.py b/tests/unit/llms/codestral/completion/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/unit/llms/codestral/completion/test_codestral_completion_handler.py b/tests/unit/llms/codestral/completion/test_codestral_completion_handler.py
new file mode 100644
index 00000000000..9ce50d8ceca
--- /dev/null
+++ b/tests/unit/llms/codestral/completion/test_codestral_completion_handler.py
@@ -0,0 +1,50 @@
+import json
+from typing import Final
+
+import httpx
+import pytest
+import respx
+
+import litellm
+
+_LINE_SEPARATED_TEXT: Final = "before\u2028between\u2029after"
+
+
+def _fim_stream_body(text: str) -> bytes:
+    chunks: Final = (
+        {"id": "c1", "object": "chat.completion.chunk", "created": 1, "model": "codestral-latest",
+         "choices": [{"index": 0, "delta": {"role": "assistant", "content": text}, "finish_reason": None}]},
+        {"id": "c1", "object": "chat.completion.chunk", "created": 1, "model": "codestral-latest",
+         "choices": [{"index": 0, "delta": {"content": ""}, "finish_reason": "stop"}]},
+    )
+    events: Final = "".join(f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n" for chunk in chunks)
+    return f"{events}data: [DONE]\n\n".encode()
+
+
+async def _streamed_texts(sync_stream: bool) -> list[str | None]:
+    request: Final = {
+        "model": "text-completion-codestral/codestral-latest",
+        "prompt": "def f(",
+        "stream": True,
+        "api_key": "codestral-key",
+        "max_retries": 0,
+    }
+    if sync_stream:
+        return [chunk.choices[0].text for chunk in litellm.text_completion(**request)]
+    return [chunk.choices[0].text async for chunk in await litellm.atext_completion(**request)]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("sync_stream", [True, False])
+async def test_fim_stream_keeps_unicode_line_separators_inside_a_delta(
+    sync_stream: bool, respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr(litellm, "disable_aiohttp_transport", True)
+    route: Final = respx_mock.post("https://codestral.mistral.ai/v1/fim/completions").mock(
+        return_value=httpx.Response(200, content=_fim_stream_body(_LINE_SEPARATED_TEXT))
+    )
+
+    texts: Final = await _streamed_texts(sync_stream)
+
+    assert texts == [_LINE_SEPARATED_TEXT, None]
+    assert json.loads(route.calls.last.request.content)["stream"] is True
diff --git a/tests/unit/llms/custom_httpx/test_aiohttp_handler.py b/tests/unit/llms/custom_httpx/test_aiohttp_handler.py
index 83c38b65beb..bb66a70da84 100644
--- a/tests/unit/llms/custom_httpx/test_aiohttp_handler.py
+++ b/tests/unit/llms/custom_httpx/test_aiohttp_handler.py
@@ -1,11 +1,17 @@
+import json
+from typing import Final
 from unittest.mock import AsyncMock, Mock, patch
 
 import aiohttp
+import httpx
 import pytest
 
 import litellm
+from litellm.llms.aiohttp_openai.chat.transformation import AiohttpOpenAIChatConfig
 from litellm.llms.custom_httpx.aiohttp_handler import BaseLLMAIOHTTPHandler
 from litellm.llms.custom_httpx.aiohttp_transport import LiteLLMAiohttpTransport
+from litellm.llms.custom_httpx.http_handler import HTTPHandler
+from litellm.types.utils import ModelResponseStream
 
 
 class TestBaseLLMAIOHTTPHandler:
@@ -445,3 +451,34 @@ class TestBaseLLMAIOHTTPHandler:
         # Should use transport, not connector
         mock_transport.get_valid_client_session.assert_called_once()
         assert result is mock_session_from_transport
+
+
+def test_make_sync_call_stream_keeps_unicode_line_separators_inside_a_delta() -> None:
+    text: Final = "before\u2028between\u2029after"
+    chunk: Final = {
+        "id": "c1",
+        "object": "chat.completion.chunk",
+        "created": 1,
+        "model": "gpt-5.5",
+        "choices": [{"index": 0, "delta": {"content": text}, "finish_reason": None}],
+    }
+    body: Final = f"data: {json.dumps(chunk, ensure_ascii=False)}\n\ndata: [DONE]\n\n".encode()
+    transport: Final = httpx.MockTransport(lambda request: httpx.Response(200, stream=httpx.ByteStream(body)))
+
+    completion_stream, _ = BaseLLMAIOHTTPHandler().make_sync_call(
+        provider_config=AiohttpOpenAIChatConfig(),
+        api_base="https://example.com/v1/chat/completions",
+        headers={},
+        data={"model": "gpt-5.5", "messages": []},
+        model="gpt-5.5",
+        messages=[],
+        logging_obj=Mock(),
+        litellm_params={},
+        timeout=5.0,
+        client=HTTPHandler(client=httpx.Client(transport=transport)),
+    )
+
+    contents: Final = [
+        chunk.choices[0].delta.content for chunk in completion_stream if isinstance(chunk, ModelResponseStream)
+    ]
+    assert contents == [text]
diff --git a/tests/unit/llms/custom_httpx/test_sse_lines.py b/tests/unit/llms/custom_httpx/test_sse_lines.py
new file mode 100644
index 00000000000..9bb03f6da98
--- /dev/null
+++ b/tests/unit/llms/custom_httpx/test_sse_lines.py
@@ -0,0 +1,64 @@
+from collections.abc import AsyncIterator, Sequence
+from typing import Final
+
+import pytest
+
+from litellm.llms.custom_httpx.sse_lines import (
+    aiter_sse_lines,
+    iter_sse_lines,
+    split_sse_lines,
+    split_sse_lines_keepends,
+)
+
+CASES: Final = (
+    pytest.param(("data: a\u2028b\r\n\r\n",), ("data: a\u2028b", ""), id="u2028-stays-inside-the-line"),
+    pytest.param(
+        ("data: \u0085\u2029\x0b\x0c\x1c\x1d\x1e\n",),
+        ("data: \u0085\u2029\x0b\x0c\x1c\x1d\x1e",),
+        id="no-splitlines-only-separator-breaks-a-line",
+    ),
+    pytest.param(("a\r\nb\nc\rd\n",), ("a", "b", "c", "d"), id="crlf-lf-and-cr-each-end-a-line"),
+    pytest.param(("a\r", "\nb\n"), ("a", "b"), id="crlf-split-across-chunks-is-one-break"),
+    pytest.param(("a\r", "\n\r\n"), ("a", ""), id="crlf-split-then-blank-line"),
+    pytest.param(("a\r", "", "\nb\n"), ("a", "b"), id="empty-chunk-between-cr-and-lf"),
+    pytest.param(("a\r", "\r"), ("a", ""), id="cr-then-cr-is-two-breaks"),
+    pytest.param(("a\r\r\nb\n",), ("a", "", "b"), id="cr-then-crlf-in-one-chunk-is-two-breaks"),
+    pytest.param(("a\r\nb\r\n\r\n",), ("a", "b", ""), id="crlf-only-chunk"),
+    pytest.param(("da", "ta: x", "y\n"), ("data: xy",), id="line-spanning-chunks-is-joined"),
+    pytest.param(("data: x",), ("data: x",), id="unterminated-last-line-is-kept"),
+    pytest.param(("",), (), id="empty-body"),
+)
+
+
+async def _async_chunks(chunks: Sequence[str]) -> AsyncIterator[str]:
+    for chunk in chunks:
+        yield chunk
+
+
+@pytest.mark.parametrize(("chunks", "expected"), CASES)
+def test_iter_sse_lines_splits_only_on_cr_lf_and_crlf(chunks: Sequence[str], expected: Sequence[str]) -> None:
+    assert tuple(iter_sse_lines(chunks)) == tuple(expected)
+
+
+@pytest.mark.parametrize(("chunks", "expected"), CASES)
+async def test_aiter_sse_lines_splits_only_on_cr_lf_and_crlf(chunks: Sequence[str], expected: Sequence[str]) -> None:
+    assert tuple([line async for line in aiter_sse_lines(_async_chunks(chunks))]) == tuple(expected)
+
+
+@pytest.mark.parametrize(("chunks", "expected"), CASES)
+def test_split_sse_lines_splits_a_whole_body_only_on_cr_lf_and_crlf(
+    chunks: Sequence[str], expected: Sequence[str]
+) -> None:
+    assert split_sse_lines("".join(chunks)) == tuple(expected)
+
+
+@pytest.mark.parametrize(
+    ("text", "expected"),
+    (
+        pytest.param("a\r\nb\rc\nd", ("a\r\n", "b\r", "c\n", "d"), id="each-break-stays-on-its-line"),
+        pytest.param("data: a\u2028b\u2029c\n\n", ("data: a\u2028b\u2029c\n", "\n"), id="u2028-and-u2029-stay-inside"),
+        pytest.param("", (), id="empty-body"),
+    ),
+)
+def test_split_sse_lines_keepends_splits_only_on_cr_lf_and_crlf(text: str, expected: Sequence[str]) -> None:
+    assert split_sse_lines_keepends(text) == tuple(expected)
diff --git a/tests/unit/llms/databricks/chat/test_databricks_chat_transformation.py b/tests/unit/llms/databricks/chat/test_databricks_chat_transformation.py
index b3a224209e9..eb2e1d8e347 100644
--- a/tests/unit/llms/databricks/chat/test_databricks_chat_transformation.py
+++ b/tests/unit/llms/databricks/chat/test_databricks_chat_transformation.py
@@ -1,6 +1,6 @@
 import copy
 import json
-from collections.abc import Iterator
+from collections.abc import AsyncIterator, Iterator
 from typing import Final
 from unittest.mock import MagicMock, patch
 
@@ -2160,13 +2160,13 @@ def mock_chat_response_nonanthropic_prompt_caching() -> Dict[str, Any]:
 def mock_http_handler_chat_streaming_response() -> MagicMock:
     mock_stream_chunks = mock_chat_streaming_response_chunks()
 
-    def mock_iter_lines():
+    def mock_iter_text() -> Iterator[str]:
         for chunk in mock_stream_chunks:
             for line in chunk.splitlines():
-                yield line
+                yield f"{line}\n"
 
     mock_response = MagicMock()
-    mock_response.iter_lines.side_effect = mock_iter_lines
+    mock_response.iter_text.side_effect = mock_iter_text
     mock_response.status_code = 200
 
     return mock_response
@@ -2175,13 +2175,13 @@ def mock_http_handler_chat_streaming_response() -> MagicMock:
 def mock_http_handler_chat_async_streaming_response() -> MagicMock:
     mock_stream_chunks = mock_chat_streaming_response_chunks()
 
-    async def mock_iter_lines():
+    async def mock_aiter_text() -> AsyncIterator[str]:
         for chunk in mock_stream_chunks:
             for line in chunk.splitlines():
-                yield line
+                yield f"{line}\n"
 
     mock_response = MagicMock()
-    mock_response.aiter_lines.return_value = mock_iter_lines()
+    mock_response.aiter_text.return_value = mock_aiter_text()
     mock_response.status_code = 200
 
     return mock_response
diff --git a/tests/unit/llms/fireworks_ai/chat/test_fireworks_ai_chat_transformation.py b/tests/unit/llms/fireworks_ai/chat/test_fireworks_ai_chat_transformation.py
index 04b791cf289..61e5545b8bf 100644
--- a/tests/unit/llms/fireworks_ai/chat/test_fireworks_ai_chat_transformation.py
+++ b/tests/unit/llms/fireworks_ai/chat/test_fireworks_ai_chat_transformation.py
@@ -1329,7 +1329,7 @@ def test_streaming_surfaces_fireworks_response_fields():
     raw_response = MagicMock()
     raw_response.status_code = 200
     raw_response.headers = {}
-    raw_response.iter_lines = lambda: iter(sse_lines)
+    raw_response.iter_text = lambda: iter(f"{line}\n" for line in sse_lines)
 
     client = HTTPHandler()
     with patch.object(client, "post", return_value=raw_response):
@@ -1788,7 +1788,7 @@ def test_streaming_preserves_selected_model_for_private_accounting():
     raw_response = MagicMock()
     raw_response.status_code = 200
     raw_response.headers = {}
-    raw_response.iter_lines = lambda: iter(sse_lines)
+    raw_response.iter_text = lambda: iter(f"{line}\n" for line in sse_lines)
 
     client = HTTPHandler()
     with patch.object(client, "post", return_value=raw_response):
@@ -2275,7 +2275,7 @@ def test_completion_forwards_litellm_user_id_as_user(call_kwargs: dict[str, obje
 
 def test_completion_forwards_litellm_user_id_when_streaming() -> None:
     client: Final = _fireworks_chat_client()
-    client.post.return_value.iter_lines = lambda: iter(())
+    client.post.return_value.iter_text = lambda: iter(())
     litellm.completion(
         model="fireworks_ai/accounts/fireworks/models/kimi-k3",
         messages=[{"role": "user", "content": "hi"}],
diff --git a/tests/unit/llms/gemini/google_genai/guardrail_translation/test_google_genai_guardrail_handler.py b/tests/unit/llms/gemini/google_genai/guardrail_translation/test_google_genai_guardrail_handler.py
index 4119ce99423..53ddb1135b4 100644
--- a/tests/unit/llms/gemini/google_genai/guardrail_translation/test_google_genai_guardrail_handler.py
+++ b/tests/unit/llms/gemini/google_genai/guardrail_translation/test_google_genai_guardrail_handler.py
@@ -4,6 +4,7 @@ Tests for the Google GenAI generateContent guardrail translation handler.
 
 import json
 from types import SimpleNamespace
+from typing import Final
 from unittest.mock import AsyncMock, MagicMock
 
 import pytest
@@ -190,6 +191,21 @@ async def test_streaming_raw_sse_chunks_accumulate_text_across_split_frames():
     assert guardrail.apply_guardrail.call_args.kwargs["inputs"]["texts"] == ["harmful answer"]
 
 
+@pytest.mark.asyncio
+async def test_streaming_raw_sse_text_holding_unicode_line_separators_reaches_the_guardrail_whole() -> None:
+    guardrail: Final = _mock_guardrail(["clean"])
+    text: Final = "harmful\u2028answer\u2029here"
+    payload: Final = {"candidates": [{"content": {"parts": [{"text": text}]}}]}
+    chunk: Final = f"data: {json.dumps(payload, ensure_ascii=False)}\r\n\r\n"
+
+    await GoogleGenAIGenerateContentHandler().process_output_streaming_response(
+        responses_so_far=[chunk],
+        guardrail_to_apply=guardrail,
+    )
+
+    assert guardrail.apply_guardrail.call_args.kwargs["inputs"]["texts"] == [text]
+
+
 @pytest.mark.asyncio
 async def test_streaming_blocking_guardrail_exception_propagates():
     handler = GoogleGenAIGenerateContentHandler()
diff --git a/tests/unit/llms/langgraph/chat/test_langgraph_sse_iterator.py b/tests/unit/llms/langgraph/chat/test_langgraph_sse_iterator.py
new file mode 100644
index 00000000000..06485362162
--- /dev/null
+++ b/tests/unit/llms/langgraph/chat/test_langgraph_sse_iterator.py
@@ -0,0 +1,32 @@
+import json
+from typing import Final
+
+import httpx
+import pytest
+
+from litellm.llms.langgraph.chat.sse_iterator import LangGraphSSEStreamIterator
+
+_LINE_SEPARATED_TEXT: Final = "before\u2028between\u2029after"
+
+
+def _messages_event_stream(text: str) -> httpx.Response:
+    event: Final = ["messages", [[{"type": "AIMessageChunk", "content": text}, {}]]]
+    return httpx.Response(200, stream=httpx.ByteStream(f"data: {json.dumps(event, ensure_ascii=False)}\n\n".encode()))
+
+
+async def _streamed_contents(iterator: LangGraphSSEStreamIterator, sync_stream: bool) -> list[str | None]:
+    if sync_stream:
+        return [chunk.choices[0].delta.content for chunk in iterator]
+    return [chunk.choices[0].delta.content async for chunk in iterator]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("sync_stream", [True, False])
+async def test_stream_keeps_unicode_line_separators_inside_a_message_chunk(sync_stream: bool) -> None:
+    iterator: Final = LangGraphSSEStreamIterator(
+        response=_messages_event_stream(_LINE_SEPARATED_TEXT), model="langgraph/agent"
+    )
+
+    contents: Final = await _streamed_contents(iterator, sync_stream)
+
+    assert contents == [_LINE_SEPARATED_TEXT, None]
diff --git a/tests/unit/llms/oobabooga/chat/test_oobabooga.py b/tests/unit/llms/oobabooga/chat/test_oobabooga.py
index 395a4fb5715..332b6913890 100644
--- a/tests/unit/llms/oobabooga/chat/test_oobabooga.py
+++ b/tests/unit/llms/oobabooga/chat/test_oobabooga.py
@@ -1,7 +1,12 @@
+import json
+from typing import Final
 from unittest.mock import MagicMock, patch
 
+import httpx
+import respx
 
 import litellm
+from litellm.llms.oobabooga.chat import oobabooga
 
 MOCK_COMPLETION_RESPONSE = {
     "choices": [{"message": {"role": "assistant", "content": "hi there"}}],
@@ -50,3 +55,27 @@ def test_url_valued_model_still_targets_that_url():
     mock_post.assert_called_once()
     called_url = mock_post.call_args[0][0]
     assert called_url == "https://sdk-user.example/v1/chat/completions"
+
+
+def test_stream_keeps_unicode_line_separators_inside_a_data_line(respx_mock: respx.MockRouter) -> None:
+    text: Final = "before\u2028between\u2029after"
+    chunk: Final = {"choices": [{"index": 0, "delta": {"content": text}, "finish_reason": None}]}
+    data_line: Final = f"data: {json.dumps(chunk, ensure_ascii=False)}"
+    respx_mock.post("https://ooba.example/v1/chat/completions").mock(
+        return_value=httpx.Response(200, content=f"{data_line}\n\ndata: [DONE]\n\n".encode())
+    )
+
+    lines: Final = oobabooga.completion(
+        model="my-model",
+        messages=[{"role": "user", "content": "hello"}],
+        api_base="https://ooba.example",
+        model_response=litellm.ModelResponse(),
+        print_verbose=print,
+        encoding=None,
+        api_key=None,
+        logging_obj=MagicMock(),
+        optional_params={"stream": True},
+        litellm_params={},
+    )
+
+    assert [line for line in lines if line] == [data_line, "data: [DONE]"]
diff --git a/tests/unit/llms/openai/image_generation/test_openai_image_generation_extra_headers.py b/tests/unit/llms/openai/image_generation/test_openai_image_generation_extra_headers.py
index 11df07f5fea..e103412e0c3 100644
--- a/tests/unit/llms/openai/image_generation/test_openai_image_generation_extra_headers.py
+++ b/tests/unit/llms/openai/image_generation/test_openai_image_generation_extra_headers.py
@@ -265,7 +265,7 @@ class TestImageGenerationEntryPointHeaders:
         test_headers = {"cf-aig-authorization": "Bearer my-secret"}
 
         await litellm.aimage_generation(
-            model="dall-e-3",
+            model="gpt-image-2.5-sunburst",
             prompt="A white cat",
             extra_headers=test_headers,
             client=mock_openai_client,
diff --git a/tests/unit/llms/openai/test_openai_common_utils.py b/tests/unit/llms/openai/test_openai_common_utils.py
index 831df30c98a..8dc92e23fdf 100644
--- a/tests/unit/llms/openai/test_openai_common_utils.py
+++ b/tests/unit/llms/openai/test_openai_common_utils.py
@@ -46,12 +46,12 @@ API_FUNCTION_PARAMS = [
     (
         "image_generation",
         False,
-        {"model": "dall-e-3", "prompt": "A beautiful sunset over mountains"},
+        {"model": "gpt-image-2.5-sunburst", "prompt": "A beautiful sunset over mountains"},
     ),
     (
         "image_generation",
         True,
-        {"model": "dall-e-3", "prompt": "A beautiful sunset over mountains"},
+        {"model": "gpt-image-2.5-sunburst", "prompt": "A beautiful sunset over mountains"},
     ),
     (
         "speech",
@@ -84,11 +84,7 @@ async def test_openai_client_reuse(function_name, is_async, args):
     """
 
     # Determine which client class to mock based on whether the test is async
-    client_path = (
-        "litellm.llms.openai.openai.AsyncOpenAI"
-        if is_async
-        else "litellm.llms.openai.openai.OpenAI"
-    )
+    client_path = "litellm.llms.openai.openai.AsyncOpenAI" if is_async else "litellm.llms.openai.openai.OpenAI"
 
     # Create the appropriate patches
     with (
@@ -98,9 +94,7 @@ async def test_openai_client_reuse(function_name, is_async, args):
     ):
         # Setup the mock to return None first time (cache miss) then a client for subsequent calls
         mock_client = MagicMock()
-        mock_get_cache.side_effect = [None] + [
-            mock_client
-        ] * 9  # First call returns None, rest return the mock client
+        mock_get_cache.side_effect = [None] + [mock_client] * 9  # First call returns None, rest return the mock client
 
         # Make 10 API calls
         for _ in range(10):
@@ -118,9 +112,9 @@ async def test_openai_client_reuse(function_name, is_async, args):
                 pass
 
         # Verify client was created only once
-        assert (
-            mock_client_class.call_count == 1
-        ), f"{'Async' if is_async else ''}OpenAI client should be created only once"
+        assert mock_client_class.call_count == 1, (
+            f"{'Async' if is_async else ''}OpenAI client should be created only once"
+        )
 
         # Verify the client was cached
         assert mock_set_cache.call_count == 1, "Client should be cached once"
@@ -144,12 +138,8 @@ def test_precomputed_init_params_match_inspect_signature():
         _OPENAI_INIT_PARAMS,
     )
 
-    expected_openai = tuple(
-        p for p in inspect.signature(OpenAI.__init__).parameters if p != "self"
-    )
-    expected_azure = tuple(
-        p for p in inspect.signature(AzureOpenAI.__init__).parameters if p != "self"
-    )
+    expected_openai = tuple(p for p in inspect.signature(OpenAI.__init__).parameters if p != "self")
+    expected_azure = tuple(p for p in inspect.signature(AzureOpenAI.__init__).parameters if p != "self")
 
     assert _OPENAI_INIT_PARAMS == expected_openai
     assert _AZURE_OPENAI_INIT_PARAMS == expected_azure
@@ -500,7 +490,10 @@ async def test_sdk_api_factories_keep_httpx_transport_and_request_timeouts(api:
         moved: Final = mock.get(host="sdk-default.example", path="/v1/moved-models").mock(
             return_value=httpx.Response(
                 200,
-                json={"object": "list", "data": [{"id": "sdk-compat", "object": "model", "created": 0, "owned_by": "t"}]},
+                json={
+                    "object": "list",
+                    "data": [{"id": "sdk-compat", "object": "model", "created": 0, "owned_by": "t"}],
+                },
             )
         )
         sdk_client: Final = _sdk_api_client(api, is_async, timeout)
@@ -542,7 +535,10 @@ async def test_azure_gateway_and_image_variations_use_the_callers_async_session(
         assert azure_client is not None
         assert azure_client._client is session
         response: Final = await aimage_variation(
-            image=BytesIO(b"image-bytes"), api_key="transport-only", api_base="https://sdk-default.example/v1"
+            image=BytesIO(b"image-bytes"),
+            custom_llm_provider="openai",
+            api_key="transport-only",
+            api_base="https://sdk-default.example/v1",
         )
         assert response.data[0].url == "https://example.com/image.png"
         assert not session.is_closed
diff --git a/tests/unit/llms/openai_like/chat/test_openai_like_chat_handler.py b/tests/unit/llms/openai_like/chat/test_openai_like_chat_handler.py
index 75b60b2dd6c..3df1efe311b 100644
--- a/tests/unit/llms/openai_like/chat/test_openai_like_chat_handler.py
+++ b/tests/unit/llms/openai_like/chat/test_openai_like_chat_handler.py
@@ -4,9 +4,10 @@ from typing import Final
 from unittest.mock import Mock
 
 import httpx
+import pytest
 
-from litellm.llms.custom_httpx.http_handler import HTTPHandler
-from litellm.llms.openai_like.chat.handler import make_sync_call
+from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler, HTTPHandler
+from litellm.llms.openai_like.chat.handler import make_call, make_sync_call
 
 _FAKE_STREAMED_REPLY: Final = {
     "id": "chatcmpl-fake-stream",
@@ -73,3 +74,35 @@ def test_fake_stream_keeps_reasoning_every_tool_call_and_token_detail():
     assert [call.function.name for call in delta.tool_calls] == ["get_weather", "get_time"]
     assert chunks[0].usage.prompt_tokens_details.cached_tokens == 64
     assert chunks[0].usage.completion_tokens_details.reasoning_tokens == 1920
+
+
+_LINE_SEPARATED_TEXT: Final = "before\u2028between\u2029after"
+
+
+def _streamed_reply(request: httpx.Request) -> httpx.Response:
+    chunk: Final = {"id": "chatcmpl-separators", "choices": [{"index": 0, "delta": {"content": _LINE_SEPARATED_TEXT}}]}
+    body: Final = f"data: {json.dumps(chunk, ensure_ascii=False)}\n\ndata: [DONE]\n\n"
+    return httpx.Response(200, stream=httpx.ByteStream(body.encode()))
+
+
+async def _streamed_chunks(sync_stream: bool) -> list[dict[str, object]]:
+    call_args: Final = {
+        "api_base": "https://openai-like.example/v1/chat/completions",
+        "headers": {},
+        "data": json.dumps({"model": "openai/gpt-oss-120b", "messages": [], "stream": True}),
+        "model": "openai/gpt-oss-120b",
+        "messages": [],
+        "logging_obj": Mock(),
+    }
+    transport: Final = httpx.MockTransport(_streamed_reply)
+    if sync_stream:
+        return list(make_sync_call(client=HTTPHandler(client=httpx.Client(transport=transport)), **call_args))
+    return [chunk async for chunk in await make_call(client=AsyncHTTPHandler(transport=transport), **call_args)]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("sync_stream", [True, False])
+async def test_stream_keeps_unicode_line_separators_inside_the_delta(sync_stream: bool) -> None:
+    chunks: Final = await _streamed_chunks(sync_stream)
+
+    assert "".join(str(chunk["text"]) for chunk in chunks) == _LINE_SEPARATED_TEXT
diff --git a/tests/unit/llms/snowflake/chat/test_snowflake_chat_transformation.py b/tests/unit/llms/snowflake/chat/test_snowflake_chat_transformation.py
index f9d12b7eeea..36c319d9524 100644
--- a/tests/unit/llms/snowflake/chat/test_snowflake_chat_transformation.py
+++ b/tests/unit/llms/snowflake/chat/test_snowflake_chat_transformation.py
@@ -902,20 +902,14 @@ class TestSnowflakeChatCompletion:
 
     @pytest.mark.parametrize("sync_mode", [True, False])
     def test_chat_completion_snowflake_stream(self, sync_mode):
-        raw_chunks = _streaming_chunks()
+        sse_body = "".join(f"data: {chunk}\n\n" for chunk in _streaming_chunks()) + "data: [DONE]\n\n"
+        mock_resp = httpx.Response(
+            200,
+            headers={"content-type": "text/event-stream"},
+            stream=httpx.ByteStream(sse_body.encode()),
+        )
 
         if sync_mode:
-
-            def _iter_lines():
-                for chunk in raw_chunks:
-                    yield f"data: {chunk}"
-                yield "data: [DONE]"
-
-            mock_resp = MagicMock()
-            mock_resp.iter_lines.return_value = _iter_lines()
-            mock_resp.status_code = 200
-            mock_resp.headers = {"content-type": "text/event-stream"}
-
             with patch.object(HTTPHandler, "post", return_value=mock_resp) as mock_post:
                 response = completion(
                     model="snowflake/mistral-7b",
@@ -930,16 +924,6 @@ class TestSnowflakeChatCompletion:
                 mock_post.assert_called_once()
         else:
 
-            async def _aiter_lines():
-                for chunk in raw_chunks:
-                    yield f"data: {chunk}"
-                yield "data: [DONE]"
-
-            mock_resp = MagicMock()
-            mock_resp.aiter_lines.return_value = _aiter_lines()
-            mock_resp.status_code = 200
-            mock_resp.headers = {"content-type": "text/event-stream"}
-
             async def _run():
                 with patch.object(
                     AsyncHTTPHandler,
@@ -964,8 +948,8 @@ class TestSnowflakeChatCompletion:
 
             chunks_received = asyncio.run(_run())
 
-        assert len(chunks_received) > 0
         content = "".join(c.choices[0].delta.content for c in chunks_received if c.choices[0].delta.content)
+        assert content == "The sky is blue"
 
 
 async def test_snowflake_claude_async_completion_inlines_remote_images_off_the_event_loop(async_only_image_fetch):
diff --git a/tests/unit/llms/tencent/image_edit/__init__.py b/tests/unit/llms/tencent/image_edit/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/unit/llms/tencent/image_edit/test_tencent_image_edit_transformation.py b/tests/unit/llms/tencent/image_edit/test_tencent_image_edit_transformation.py
new file mode 100644
index 00000000000..506c43f6cba
--- /dev/null
+++ b/tests/unit/llms/tencent/image_edit/test_tencent_image_edit_transformation.py
@@ -0,0 +1,232 @@
+import base64
+import io
+import json
+from typing import Final
+
+import httpx
+import pytest
+
+import litellm
+from litellm.llms.custom_httpx.http_handler import HTTPHandler
+
+PNG_BYTES: Final = b"\x89PNG\r\n\x1a\n" + b"\x00" * 32
+TOKENHUB_RESPONSE: Final[dict[str, object]] = {
+    "created": 1792551838,
+    "data": [{"output_format": "jpeg", "size": "2048x2048", "url": "https://cos.example/edited.jpg"}],
+    "model": "doubao-seedream-5-0-lite",
+    "tokenhub_usage": {"total_tokens": 21875},
+    "request_id": "4f795d48-b227-4c35-af2c-1a0ba288b6b6",
+}
+
+
+def _client(captured: dict[str, object]) -> HTTPHandler:
+    def respond(request: httpx.Request) -> httpx.Response:
+        captured["url"] = str(request.url)
+        captured["content_type"] = request.headers.get("content-type")
+        captured["authorization"] = request.headers.get("authorization")
+        captured["body"] = json.loads(request.content)
+        return httpx.Response(200, json=TOKENHUB_RESPONSE)
+
+    return HTTPHandler(client=httpx.Client(transport=httpx.MockTransport(respond)))
+
+
+def test_edit_sends_uploaded_images_as_data_urls_in_a_json_body() -> None:
+    captured: Final[dict[str, object]] = {}
+    png_data_url: Final = f"data:image/png;base64,{base64.b64encode(PNG_BYTES).decode()}"
+
+    response: Final = litellm.image_edit(
+        model="tencent/seedream-image-v5.0-lite",
+        image=[PNG_BYTES, io.BytesIO(PNG_BYTES), "https://ref.example/style.png"],
+        prompt="turn the square into a paper lantern",
+        size="2K",
+        api_key="sk-tokenhub",
+        client=_client(captured),
+    )
+
+    assert captured["url"] == "https://tokenhub-intl.tencentcloudmaas.com/v1/wand/si-image/generation"
+    assert captured["content_type"] == "application/json"
+    assert captured["authorization"] == "Bearer sk-tokenhub"
+    assert captured["body"] == {
+        "model": "seedream-image-v5.0-lite",
+        "prompt": "turn the square into a paper lantern",
+        "images": [png_data_url, png_data_url, "https://ref.example/style.png"],
+        "size": "2K",
+    }
+    assert response.data[0].url == "https://cos.example/edited.jpg"
+    assert response.usage.total_tokens == 21875
+
+
+def test_edit_rejects_a_mask_without_drop_params() -> None:
+    captured: Final[dict[str, object]] = {}
+
+    with pytest.raises(litellm.UnsupportedParamsError):
+        litellm.image_edit(
+            model="tencent/seedream-image-v5.0-pro",
+            image=PNG_BYTES,
+            mask=PNG_BYTES,
+            prompt="turn the square into a paper lantern",
+            api_key="sk-tokenhub",
+            client=_client(captured),
+        )
+
+    assert captured == {}
+
+
+def test_edit_drops_a_mask_under_drop_params() -> None:
+    captured: Final[dict[str, object]] = {}
+
+    litellm.image_edit(
+        model="tencent/seedream-image-v5.0-pro",
+        image=PNG_BYTES,
+        mask=PNG_BYTES,
+        prompt="turn the square into a paper lantern",
+        api_key="sk-tokenhub",
+        client=_client(captured),
+        drop_params=True,
+    )
+
+    assert captured["body"] == {
+        "model": "seedream-image-v5.0-pro",
+        "prompt": "turn the square into a paper lantern",
+        "images": [f"data:image/png;base64,{base64.b64encode(PNG_BYTES).decode()}"],
+    }
+
+
+def test_edit_is_not_offered_for_tencent_models_outside_seedream() -> None:
+    captured: Final[dict[str, object]] = {}
+
+    with pytest.raises(Exception, match="image edit is not supported for tencent"):
+        litellm.image_edit(
+            model="tencent/hy-image-v3.5-preview",
+            image=PNG_BYTES,
+            prompt="turn the square into a paper lantern",
+            api_key="sk-tokenhub",
+            client=_client(captured),
+        )
+
+    assert captured == {}
+
+
+@pytest.mark.parametrize(
+    ("form_params", "expected_body_params"),
+    [
+        ({"watermark": "false", "seed": "7"}, {"watermark": False, "seed": 7}),
+        ({"watermark": "True", "seed": "-1"}, {"watermark": True, "seed": -1}),
+        ({"watermark": "maybe"}, {"watermark": "maybe"}),
+        (
+            {"layer_decomposition": "true", "optimize_prompt_options[mode]": "fast"},
+            {"layer_decomposition": True, "optimize_prompt_options": {"mode": "fast"}},
+        ),
+        (
+            {"sequential_image_generation_options[max_images]": "3", "user": "12345"},
+            {"sequential_image_generation_options": {"max_images": 3}, "user": "12345"},
+        ),
+    ],
+)
+def test_edit_parses_tokenhub_values_sent_as_form_strings(
+    form_params: dict[str, object], expected_body_params: dict[str, object]
+) -> None:
+    captured: Final[dict[str, object]] = {}
+
+    litellm.image_edit(
+        model="tencent/seedream-image-v5.0-flash",
+        image=PNG_BYTES,
+        prompt="turn the square into a paper lantern",
+        api_key="sk-tokenhub",
+        client=_client(captured),
+        **form_params,
+    )
+
+    assert captured["body"] == {
+        "model": "seedream-image-v5.0-flash",
+        "prompt": "turn the square into a paper lantern",
+        "images": [f"data:image/png;base64,{base64.b64encode(PNG_BYTES).decode()}"],
+        **expected_body_params,
+    }
+
+
+@pytest.mark.parametrize(
+    ("params", "expected_body_params"),
+    [
+        ({"background": "auto", "watermark": False}, {"watermark": False}),
+        ({"watermark": False, "seed": 7, "additional_drop_params": ["watermark"]}, {"seed": 7}),
+        ({"extra_body": {"watermark": False}, "additional_drop_params": ["watermark"]}, {}),
+    ],
+)
+def test_edit_keeps_dropped_params_out_of_the_tokenhub_body(
+    params: dict[str, object], expected_body_params: dict[str, object]
+) -> None:
+    captured: Final[dict[str, object]] = {}
+
+    litellm.image_edit(
+        model="tencent/seedream-image-v5.0-flash",
+        image=PNG_BYTES,
+        prompt="turn the square into a paper lantern",
+        api_key="sk-tokenhub",
+        client=_client(captured),
+        **params,
+    )
+
+    assert captured["body"] == {
+        "model": "seedream-image-v5.0-flash",
+        "prompt": "turn the square into a paper lantern",
+        "images": [f"data:image/png;base64,{base64.b64encode(PNG_BYTES).decode()}"],
+        **expected_body_params,
+    }
+
+
+@pytest.mark.parametrize(
+    ("params", "expected_body_params"),
+    [
+        ({"extra_body": {"response_format": "b64_json"}}, {"response_format": "b64_json"}),
+        ({"size": "1K", "extra_body": {"size": "2K"}}, {"size": "2K"}),
+        ({"extra_body": {"model": "seedream-image-v5.0-pro", "seed": 7}}, {"seed": 7}),
+        ({"extra_body": '{"seed": 7}'}, {}),
+    ],
+)
+def test_edit_sends_extra_body_fields_as_given(
+    params: dict[str, object], expected_body_params: dict[str, object]
+) -> None:
+    captured: Final[dict[str, object]] = {}
+
+    litellm.image_edit(
+        model="tencent/seedream-image-v5.0-flash",
+        image=PNG_BYTES,
+        prompt="turn the square into a paper lantern",
+        api_key="sk-tokenhub",
+        client=_client(captured),
+        **params,
+    )
+
+    assert captured["body"] == {
+        "model": "seedream-image-v5.0-flash",
+        "prompt": "turn the square into a paper lantern",
+        "images": [f"data:image/png;base64,{base64.b64encode(PNG_BYTES).decode()}"],
+        **expected_body_params,
+    }
+
+
+def test_edit_forwards_tokenhub_only_params_and_extra_body() -> None:
+    captured: Final[dict[str, object]] = {}
+
+    litellm.image_edit(
+        model="tencent/seedream-image-v5.0-flash",
+        image=PNG_BYTES,
+        prompt="turn the square into a paper lantern",
+        api_key="sk-tokenhub",
+        client=_client(captured),
+        user="end-user-42",
+        watermark=False,
+        seed=7,
+        extra_body={"sequential_image_generation": "disabled"},
+    )
+
+    assert captured["body"] == {
+        "model": "seedream-image-v5.0-flash",
+        "prompt": "turn the square into a paper lantern",
+        "images": [f"data:image/png;base64,{base64.b64encode(PNG_BYTES).decode()}"],
+        "user": "end-user-42",
+        "watermark": False,
+        "seed": 7,
+        "sequential_image_generation": "disabled",
+    }
diff --git a/tests/unit/llms/tencent/image_generation/__init__.py b/tests/unit/llms/tencent/image_generation/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/unit/llms/tencent/image_generation/test_tencent_image_generation_transformation.py b/tests/unit/llms/tencent/image_generation/test_tencent_image_generation_transformation.py
new file mode 100644
index 00000000000..ab16382cdae
--- /dev/null
+++ b/tests/unit/llms/tencent/image_generation/test_tencent_image_generation_transformation.py
@@ -0,0 +1,215 @@
+import json
+from typing import Final
+
+import httpx
+import openai
+import pytest
+
+import litellm
+from litellm.llms.custom_httpx.http_handler import HTTPHandler
+
+TOKENHUB_RESPONSE: Final[dict[str, object]] = {
+    "created": 1792551825,
+    "data": [{"output_format": "jpeg", "size": "1248x832", "url": "https://cos.example/lantern.jpg"}],
+    "model": "doubao-seedream-5-0-pro-260628",
+    "tokenhub_usage": {"total_tokens": 28125},
+    "request_id": "c57b0374-b5fe-47db-b4b2-751315f920aa",
+}
+
+
+def _client(captured: dict[str, object], status_code: int = 200, body: dict[str, object] | None = None) -> HTTPHandler:
+    def respond(request: httpx.Request) -> httpx.Response:
+        captured["url"] = str(request.url)
+        captured["authorization"] = request.headers.get("authorization")
+        captured["body"] = json.loads(request.content)
+        return httpx.Response(status_code, json=TOKENHUB_RESPONSE if body is None else body)
+
+    return HTTPHandler(client=httpx.Client(transport=httpx.MockTransport(respond)))
+
+
+def test_generation_posts_openai_and_tokenhub_params_to_the_wand_route() -> None:
+    captured: Final[dict[str, object]] = {}
+
+    response: Final = litellm.image_generation(
+        model="tencent/seedream-image-v5.0-pro",
+        prompt="a red paper lantern",
+        size="2K",
+        response_format="url",
+        api_key="sk-tokenhub",
+        client=_client(captured),
+        images=["https://ref.example/lantern.png"],
+        watermark=False,
+    )
+
+    assert captured["url"] == "https://tokenhub-intl.tencentcloudmaas.com/v1/wand/si-image/generation"
+    assert captured["authorization"] == "Bearer sk-tokenhub"
+    assert captured["body"] == {
+        "model": "seedream-image-v5.0-pro",
+        "prompt": "a red paper lantern",
+        "size": "2K",
+        "response_format": "url",
+        "images": ["https://ref.example/lantern.png"],
+        "watermark": False,
+    }
+    assert response.data[0].url == "https://cos.example/lantern.jpg"
+    assert response.size == "1248x832"
+    assert response.output_format == "jpeg"
+    assert response.created == 1792551825
+    assert response.usage.total_tokens == 28125
+    assert response.usage.output_tokens == 28125
+
+
+def test_generation_returns_base64_images() -> None:
+    captured: Final[dict[str, object]] = {}
+    body: Final[dict[str, object]] = {
+        **TOKENHUB_RESPONSE,
+        "data": [{"output_format": "png", "size": "1024x1024", "b64_json": "aW1n"}],
+    }
+
+    response: Final = litellm.image_generation(
+        model="tencent/seedream-image-v5.0-flash",
+        prompt="a red paper lantern",
+        response_format="b64_json",
+        api_key="sk-tokenhub",
+        client=_client(captured, body=body),
+    )
+
+    assert response.data[0].b64_json == "aW1n"
+    assert response.data[0].url is None
+
+
+@pytest.mark.parametrize(
+    ("api_base", "expected_url"),
+    [
+        ("https://tokenhub.example", "https://tokenhub.example/v1/wand/si-image/generation"),
+        ("https://tokenhub.example/v1", "https://tokenhub.example/v1/wand/si-image/generation"),
+        ("https://tokenhub.example/v1/", "https://tokenhub.example/v1/wand/si-image/generation"),
+    ],
+)
+def test_generation_resolves_a_configured_api_base_to_the_wand_route(api_base: str, expected_url: str) -> None:
+    captured: Final[dict[str, object]] = {}
+
+    litellm.image_generation(
+        model="tencent/seedream-image-v5.0-lite",
+        prompt="a red paper lantern",
+        api_key="sk-tokenhub",
+        api_base=api_base,
+        client=_client(captured),
+    )
+
+    assert captured["url"] == expected_url
+
+
+@pytest.mark.parametrize(
+    ("params", "expected_body_params"),
+    [
+        ({"n": 1}, {}),
+        ({"n": 3, "drop_params": True}, {}),
+        ({"background": "auto"}, {}),
+        ({"background": "transparent", "output_format": "png"}, {"background": "transparent", "output_format": "png"}),
+        ({"user": "end-user-42"}, {"user": "end-user-42"}),
+    ],
+)
+def test_generation_sends_only_values_tokenhub_accepts(
+    params: dict[str, object], expected_body_params: dict[str, object]
+) -> None:
+    captured: Final[dict[str, object]] = {}
+
+    litellm.image_generation(
+        model="tencent/seedream-image-v5.0-pro",
+        prompt="a red paper lantern",
+        api_key="sk-tokenhub",
+        client=_client(captured),
+        **params,
+    )
+
+    assert captured["body"] == {
+        "model": "seedream-image-v5.0-pro",
+        "prompt": "a red paper lantern",
+        **expected_body_params,
+    }
+
+
+def test_generation_rejects_more_than_one_image_without_drop_params() -> None:
+    captured: Final[dict[str, object]] = {}
+
+    with pytest.raises(litellm.UnsupportedParamsError) as exc_info:
+        litellm.image_generation(
+            model="tencent/seedream-image-v5.0-pro",
+            prompt="a red paper lantern",
+            n=2,
+            api_key="sk-tokenhub",
+            client=_client(captured),
+        )
+
+    assert exc_info.value.status_code == 400
+    assert captured == {}
+
+
+@pytest.mark.parametrize(
+    ("error", "expected_message"),
+    [
+        (
+            {
+                "error": {
+                    "message": "The model or service ID 'seedream-image-v5.0-pro' does not exist.",
+                    "code": "400004",
+                    "type": "gateway_error",
+                }
+            },
+            "does not exist",
+        ),
+        ({"Type": 2, "Code": 1001, "Msg": "Invalid param", "Desc": ""}, "Invalid param"),
+    ],
+)
+def test_generation_surfaces_the_tokenhub_error_message(error: dict[str, object], expected_message: str) -> None:
+    with pytest.raises(litellm.BadRequestError) as exc_info:
+        litellm.image_generation(
+            model="tencent/seedream-image-v5.0-pro",
+            prompt="a red paper lantern",
+            api_key="sk-tokenhub",
+            client=_client({}, status_code=400, body=error),
+        )
+
+    assert expected_message in str(exc_info.value)
+
+
+def test_generation_without_a_tokenhub_key_is_an_authentication_error(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("TENCENT_API_KEY", raising=False)
+    captured: Final[dict[str, object]] = {}
+
+    with pytest.raises(litellm.AuthenticationError) as exc_info:
+        litellm.image_generation(
+            model="tencent/seedream-image-v5.0-pro",
+            prompt="a red paper lantern",
+            client=_client(captured),
+        )
+
+    assert exc_info.value.status_code == 401
+    assert "TENCENT_API_KEY" in str(exc_info.value)
+    assert captured == {}
+
+
+def test_generation_keeps_other_tencent_image_models_on_the_openai_compatible_route() -> None:
+    captured: Final[dict[str, object]] = {}
+
+    def respond(request: httpx.Request) -> httpx.Response:
+        captured["url"] = str(request.url)
+        captured["body"] = json.loads(request.content)
+        return httpx.Response(200, json={"created": 1792551825, "data": [{"url": "https://cos.example/hy.png"}]})
+
+    response: Final = litellm.image_generation(
+        model="tencent/hy-image-v3.5-preview",
+        prompt="a red paper lantern",
+        quality="high",
+        api_key="sk-tokenhub",
+        client=openai.OpenAI(
+            api_key="sk-tokenhub",
+            base_url="https://tokenhub-intl.tencentcloudmaas.com/v1",
+            http_client=httpx.Client(transport=httpx.MockTransport(respond)),
+        ),
+    )
+
+    assert captured["url"] == "https://tokenhub-intl.tencentcloudmaas.com/v1/images/generations"
+    assert captured["body"] == {"model": "hy-image-v3.5-preview", "prompt": "a red paper lantern", "quality": "high"}
+    assert response.data[0].url == "https://cos.example/hy.png"
diff --git a/tests/unit/llms/tencent/test_tencent_cost_calculator.py b/tests/unit/llms/tencent/test_tencent_cost_calculator.py
new file mode 100644
index 00000000000..7f98ee02810
--- /dev/null
+++ b/tests/unit/llms/tencent/test_tencent_cost_calculator.py
@@ -0,0 +1,128 @@
+from typing import Final
+
+import httpx
+import openai
+import pytest
+
+import litellm
+from litellm.llms.custom_httpx.http_handler import HTTPHandler
+from litellm.types.utils import ImageObject, ImageResponse, ImageUsage, ImageUsageInputTokensDetails
+
+SEEDREAM_MODELS: Final = (
+    "tencent/seedream-image-v5.0-pro",
+    "tencent/seedream-image-v5.0-flash",
+    "tencent/seedream-image-v5.0-lite",
+)
+
+
+def _image_response(total_tokens: int, images: int = 1) -> ImageResponse:
+    return ImageResponse(
+        created=1792551825,
+        data=[ImageObject(url=f"https://cos.example/{index}.jpg") for index in range(images)],
+        usage=ImageUsage(
+            input_tokens=0,
+            input_tokens_details=ImageUsageInputTokensDetails(image_tokens=0, text_tokens=0),
+            output_tokens=total_tokens,
+            total_tokens=total_tokens,
+        ),
+    )
+
+
+@pytest.mark.parametrize("model", SEEDREAM_MODELS)
+@pytest.mark.parametrize("call_type", ["image_generation", "image_edit"])
+def test_seedream_bills_tokenhub_usage_tokens_for_a_tier_size(
+    local_model_cost_map: None, model: str, call_type: str
+) -> None:
+    token_rate: Final = litellm.model_cost[model]["output_cost_per_image_token"]
+
+    cost: Final = litellm.completion_cost(
+        completion_response=_image_response(total_tokens=56250),
+        model=model,
+        call_type=call_type,
+        size="2K",
+    )
+
+    assert cost == pytest.approx(56250 * token_rate)
+
+
+@pytest.mark.parametrize("model", SEEDREAM_MODELS)
+def test_seedream_falls_back_to_the_per_image_price_without_usage(local_model_cost_map: None, model: str) -> None:
+    per_image_price: Final = litellm.model_cost[model]["output_cost_per_image"]
+
+    cost: Final = litellm.completion_cost(
+        completion_response=_image_response(total_tokens=0, images=2),
+        model=model,
+        call_type="image_generation",
+        size="2K",
+    )
+
+    assert cost == pytest.approx(2 * per_image_price)
+
+
+async def test_a_deployment_priced_tencent_image_model_outside_seedream_bills_its_deployment_price() -> None:
+    def respond(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, json={"created": 1792551825, "data": [{"url": "https://cos.example/hy.png"}]})
+
+    router: Final = litellm.Router(
+        model_list=[
+            {
+                "model_name": "hy-image",
+                "litellm_params": {"model": "tencent/hy-image-v3.5-preview", "api_key": "sk-tokenhub"},
+                "model_info": {"input_cost_per_image": 0.04},
+            }
+        ]
+    )
+
+    response: Final = await router.aimage_generation(
+        model="hy-image",
+        prompt="a red paper lantern",
+        client=openai.AsyncOpenAI(
+            api_key="sk-tokenhub",
+            base_url="https://tokenhub-intl.tencentcloudmaas.com/v1",
+            http_client=httpx.AsyncClient(transport=httpx.MockTransport(respond)),
+        ),
+    )
+
+    assert response._hidden_params["response_cost"] == pytest.approx(0.04)
+
+
+@pytest.mark.parametrize(
+    ("deployment_price", "expected_cost"),
+    [
+        ({"output_cost_per_token": 0.000001}, 11250 * 0.000001),
+        ({"output_cost_per_image": 0.05}, 0.05),
+    ],
+)
+def test_a_seedream_deployment_priced_in_the_ui_bills_its_own_rate(
+    deployment_price: dict[str, float], expected_cost: float
+) -> None:
+    def respond(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(
+            200,
+            json={
+                "created": 1792551825,
+                "data": [{"output_format": "jpeg", "size": "1024x1024", "url": "https://cos.example/0.jpg"}],
+                "tokenhub_usage": {"total_tokens": 11250},
+            },
+        )
+
+    router: Final = litellm.Router(
+        model_list=[
+            {
+                "model_name": "seedream-flash",
+                "litellm_params": {
+                    "model": "tencent/seedream-image-v5.0-flash",
+                    "api_key": "sk-tokenhub",
+                    **deployment_price,
+                },
+            }
+        ]
+    )
+
+    response: Final = router.image_generation(
+        model="seedream-flash",
+        prompt="a red paper lantern",
+        client=HTTPHandler(client=httpx.Client(transport=httpx.MockTransport(respond))),
+    )
+
+    assert response._hidden_params["response_cost"] == pytest.approx(expected_cost)
diff --git a/tests/unit/llms/test_predibase_transformation.py b/tests/unit/llms/test_predibase_transformation.py
index a02840ed4ef..7afbd05b221 100644
--- a/tests/unit/llms/test_predibase_transformation.py
+++ b/tests/unit/llms/test_predibase_transformation.py
@@ -1,3 +1,4 @@
+import json
 from typing import Final
 from unittest.mock import AsyncMock, Mock
 
@@ -639,3 +640,49 @@ def test_predibase_completion_passes_existing_config_to_async_completion(monkeyp
 
     assert result == "async-result"
     assert captured["async_kwargs"]["predibase_config"] is captured["config_instance"]
+
+
+_LINE_SEPARATED_TEXT: Final = "before\u2028between\u2029after"
+
+
+def _generate_stream_body(text: str) -> bytes:
+    events: Final = (
+        {"token": {"text": text}},
+        {"token": {"text": ""}, "generated_text": text, "details": {"finish_reason": "eos_token"}},
+    )
+    return "".join(f"data:{json.dumps(event, ensure_ascii=False)}\n\n" for event in events).encode()
+
+
+async def _streamed_contents(sync_stream: bool) -> list[str | None]:
+    request: Final = {
+        "model": "predibase/llama-3-8b-instruct",
+        "messages": [{"role": "user", "content": "hi"}],
+        "stream": True,
+        "predibase_tenant_id": "tenant-1",
+        "api_key": "pb-key",
+        "max_retries": 0,
+    }
+    if sync_stream:
+        return [chunk.choices[0].delta.content for chunk in litellm.completion(**request)]
+    return [chunk.choices[0].delta.content async for chunk in await litellm.acompletion(**request)]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("sync_stream", [True, False])
+async def test_predibase_stream_keeps_unicode_line_separators_inside_a_token(
+    sync_stream: bool, respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr(litellm, "disable_hf_tokenizer_download", True)
+    monkeypatch.setattr(litellm, "disable_aiohttp_transport", True)
+    monkeypatch.setattr(
+        litellm,
+        "custom_prompt_dict",
+        {"llama-3-8b-instruct": {"roles": {}, "initial_prompt_value": "", "final_prompt_value": ""}},
+    )
+    respx_mock.post(
+        "https://serving.app.predibase.com/tenant-1/deployments/v2/llms/llama-3-8b-instruct/generate_stream"
+    ).mock(return_value=httpx.Response(200, content=_generate_stream_body(_LINE_SEPARATED_TEXT)))
+
+    contents: Final = await _streamed_contents(sync_stream)
+
+    assert contents == [_LINE_SEPARATED_TEXT, None]
diff --git a/tests/unit/llms/triton/test_triton.py b/tests/unit/llms/triton/test_triton.py
index 7c0de603a3e..238c30816b2 100644
--- a/tests/unit/llms/triton/test_triton.py
+++ b/tests/unit/llms/triton/test_triton.py
@@ -1,5 +1,7 @@
 import json
 import traceback
+from collections.abc import Iterator
+from typing import Final
 from unittest.mock import MagicMock, patch
 
 import httpx
@@ -210,8 +212,8 @@ def test_completion_triton_generate_api(stream, monkeypatch, respx_mock):
         mock_response = MagicMock()
         if stream:
 
-            def mock_iter_lines():
-                mock_output = "".join(
+            def mock_iter_text() -> Iterator[str]:
+                mock_output: Final = "".join(
                     [
                         'data: {"model_name":"ensemble","model_version":"1","sequence_end":false,"sequence_id":0,"sequence_start":false,"text_output":"'
                         + t
@@ -219,10 +221,9 @@ def test_completion_triton_generate_api(stream, monkeypatch, respx_mock):
                         for t in ["I", " am", " an", " AI", " assistant"]
                     ]
                 )
-                for out in mock_output.split("\n"):
-                    yield out
+                yield mock_output
 
-            mock_response.iter_lines = mock_iter_lines
+            mock_response.iter_text = mock_iter_text
         else:
 
             def return_val():
diff --git a/tests/unit/llms/vertex_ai/agent_engine/test_transformation.py b/tests/unit/llms/vertex_ai/agent_engine/test_transformation.py
index 06aaca44e8a..20333fd0465 100644
--- a/tests/unit/llms/vertex_ai/agent_engine/test_transformation.py
+++ b/tests/unit/llms/vertex_ai/agent_engine/test_transformation.py
@@ -14,7 +14,7 @@ import pytest
 
 
 from litellm.litellm_core_utils.litellm_logging import Logging
-from litellm.llms.custom_httpx.http_handler import get_async_httpx_client
+from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler, HTTPHandler, get_async_httpx_client
 from litellm.llms.vertex_ai.agent_engine.sse_iterator import (
     VertexAgentEngineResponseIterator,
 )
@@ -170,3 +170,48 @@ async def test_async_stream_wrapper_without_a_client_posts_through_the_cached_ve
     assert type(wrapper) is CustomStreamWrapper
     assert [str(request.url) for request in sent_requests] == [api_base]
     assert json.loads(sent_requests[0].content) == {"class_method": "stream_query"}
+
+
+_LINE_SEPARATED_TEXT: Final = "before\u2028between\u2029after"
+
+
+def _separated_text_reply(request: httpx.Request) -> httpx.Response:
+    chunk: Final = {"content": {"parts": [{"text": _LINE_SEPARATED_TEXT}], "role": "model"}, "finish_reason": "STOP"}
+    return httpx.Response(200, stream=httpx.ByteStream(f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n".encode()))
+
+
+async def _streamed_text(sync_stream: bool) -> str:
+    messages: Final = [{"role": "user", "content": "hi"}]
+    call_args: Final = {
+        "model": "agent_engine/123",
+        "custom_llm_provider": "vertex_ai",
+        "logging_obj": Logging(
+            model="agent_engine/123",
+            messages=messages,
+            stream=True,
+            call_type="completion" if sync_stream else "acompletion",
+            start_time=datetime(2026, 1, 1),
+            litellm_call_id="call-separators",
+            function_id="fn-separators",
+        ),
+        "api_base": "https://us-central1-aiplatform.googleapis.com/v1/reasoningEngines/123:streamQuery",
+        "headers": {},
+        "data": {"class_method": "stream_query"},
+        "messages": messages,
+        "litellm_params": {},
+    }
+    transport: Final = httpx.MockTransport(_separated_text_reply)
+    if sync_stream:
+        sync_wrapper: Final = VertexAgentEngineConfig().get_sync_custom_stream_wrapper(
+            client=HTTPHandler(client=httpx.Client(transport=transport)), **call_args
+        )
+        return "".join(chunk.choices[0].delta.content or "" for chunk in sync_wrapper)
+    async_wrapper: Final = await VertexAgentEngineConfig().get_async_custom_stream_wrapper(
+        client=AsyncHTTPHandler(transport=transport), **call_args
+    )
+    return "".join([chunk.choices[0].delta.content or "" async for chunk in async_wrapper])
+
+
+@pytest.mark.parametrize("sync_stream", [True, False])
+async def test_stream_keeps_unicode_line_separators_inside_the_text(sync_stream: bool) -> None:
+    assert await _streamed_text(sync_stream) == _LINE_SEPARATED_TEXT
diff --git a/tests/unit/llms/vertex_ai/gemini/test_vertex_and_google_ai_studio_gemini.py b/tests/unit/llms/vertex_ai/gemini/test_vertex_and_google_ai_studio_gemini.py
index 1546d1e9fe0..67c78b62151 100644
--- a/tests/unit/llms/vertex_ai/gemini/test_vertex_and_google_ai_studio_gemini.py
+++ b/tests/unit/llms/vertex_ai/gemini/test_vertex_and_google_ai_studio_gemini.py
@@ -3,8 +3,9 @@ import json
 import logging
 import re
 import threading
-from collections.abc import Awaitable, Callable, Iterator, Mapping
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterator, Mapping
 from copy import deepcopy
+from itertools import pairwise
 from typing import Final, List, Literal, cast, get_args
 from unittest.mock import MagicMock, Mock, patch
 
@@ -34,7 +35,7 @@ from litellm.llms.vertex_ai.gemini.vertex_and_google_ai_studio_gemini import (
 )
 from litellm.types.llms.base import CachedTokensDetails
 from litellm.types.llms.vertex_ai import GeminiFinishReason, RequestBody, UsageMetadata
-from litellm.types.utils import ChoiceLogprobs, ModelInfo, Usage
+from litellm.types.utils import ChoiceLogprobs, ModelInfo, ModelResponseStream, Usage
 from litellm.utils import _invalidate_model_cost_lowercase_map, CustomStreamWrapper
 from litellm.litellm_core_utils.logging_worker import GLOBAL_LOGGING_WORKER
 from litellm.integrations.custom_logger import CustomLogger
@@ -3514,6 +3515,39 @@ def test_vertex_ai_annotation_conversion():
     assert "Current time" in time_annotation["url_citation"]["title"]
 
 
+@pytest.mark.parametrize(
+    "indices, expected_indices",
+    [([2, 0], [2, 0]), ([1, 99, -1, 2, 0], [2, 0]), ([0], [0]), ([], []), ([1, 99], [])],
+    ids=["multiple-sources", "non-web-first", "single-source", "empty", "no-web"],
+)
+def test_grounding_annotations_preserve_all_web_sources(indices: list[int], expected_indices: list[int]) -> None:
+    chunks: Final = [
+        {"web": {"uri": "https://example.com/first", "title": "First"}},
+        {"retrievedContext": {"uri": "gs://documents/source"}},
+        {"web": {"uri": "https://example.com/second", "title": "Second"}},
+    ]
+    metadata: Final = {
+        "groundingChunks": chunks,
+        "groundingSupports": [
+            {"segment": {"startIndex": 4, "endIndex": 11}, "groundingChunkIndices": indices}
+        ],
+    }
+    annotations: Final = VertexGeminiConfig._convert_grounding_metadata_to_annotations([metadata], "The passage")
+    expected: Final = [
+        {
+            "type": "url_citation",
+            "url_citation": {
+                "start_index": 4,
+                "end_index": 11,
+                "url": chunks[index]["web"]["uri"],
+                "title": chunks[index]["web"]["title"],
+            },
+        }
+        for index in expected_indices
+    ]
+    assert json.dumps(annotations) == json.dumps(expected)
+
+
 def test_vertex_ai_annotation_empty_grounding_metadata():
     """
     Test handling of empty or missing grounding metadata.
@@ -10092,7 +10126,7 @@ def test_vertex_ai_streaming_response_id():
 
         mock_response = MagicMock()
         mock_response.status_code = 200
-        mock_response.iter_lines = MagicMock(return_value=stream_response())
+        mock_response.iter_text = MagicMock(return_value=stream_response())
         return mock_response
 
     logging_obj = MagicMock()
@@ -10657,6 +10691,63 @@ async def test_gemini_sends_a_boolean_for_a_gateway_default_written_as_text_or_n
     assert sent["includeThoughts"] is expected
 
 
+class _BodyInChunks(httpx.SyncByteStream, httpx.AsyncByteStream):
+    def __init__(self, chunks: tuple[bytes, ...]) -> None:
+        self._chunks: Final = chunks
+
+    def __iter__(self) -> Iterator[bytes]:
+        yield from self._chunks
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        for chunk in self._chunks:
+            yield chunk
+
+
+def _split_at(body: bytes, cuts: tuple[int, ...]) -> tuple[bytes, ...]:
+    return tuple(body[start:end] for start, end in pairwise((0, *sorted(cuts), len(body))))
+
+
+async def _gemini_stream(is_async: bool, chunks: tuple[bytes, ...]) -> list[ModelResponseStream]:
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, stream=_BodyInChunks(chunks), headers={"content-type": "text/event-stream"})
+
+    kwargs: Final = {
+        "model": "gemini/gemini-3.8-flash",
+        "messages": [{"role": "user", "content": "hi"}],
+        "stream": True,
+        "stream_options": {"include_usage": True},
+        "api_key": "fake-gemini-key",
+    }
+    if is_async:
+        stream: Final = await litellm.acompletion(
+            **kwargs, client=AsyncHTTPHandler(transport=httpx.MockTransport(handler))
+        )
+        return [chunk async for chunk in stream]
+    return list(
+        litellm.completion(**kwargs, client=HTTPHandler(client=httpx.Client(transport=httpx.MockTransport(handler))))
+    )
+
+
+@pytest.mark.parametrize("is_async", [True, False])
+async def test_gemini_stream_keeps_text_and_usage_when_a_part_contains_a_unicode_line_separator(is_async: bool) -> None:
+    events: Final = (
+        {"candidates": [{"content": {"role": "model", "parts": [{"text": "line one\u2028line two"}]}}]},
+        {
+            "candidates": [{"content": {"role": "model", "parts": [{"text": " and three"}]}, "finishReason": "STOP"}],
+            "usageMetadata": {"promptTokenCount": 10, "candidatesTokenCount": 8, "totalTokenCount": 18},
+        },
+    )
+    body: Final = "".join(f"data: {json.dumps(event, ensure_ascii=False)}\r\n\r\n" for event in events).encode()
+    cut_inside_separator_and_crlf: Final = (body.index(b"\xe2\x80\xa8") + 1, body.index(b"\r") + 1)
+
+    received: Final = await _gemini_stream(is_async, _split_at(body, cut_inside_separator_and_crlf))
+
+    usage: Final = next(chunk.usage for chunk in reversed(received) if getattr(chunk, "usage", None))
+    text: Final = "".join(c.choices[0].delta.content or "" for c in received if c.choices)
+    assert text == "line one\u2028line two and three"
+    assert (usage.prompt_tokens, usage.completion_tokens) == (10, 8)
+
+
 @pytest.mark.parametrize("chunk_indices", [[0, 1], [2, 1, 0]])
 def test_grounding_support_preserves_every_web_source(chunk_indices: list[int]) -> None:
     metadata: Final = {
diff --git a/tests/unit/llms/vertex_ai/test_http_status_201.py b/tests/unit/llms/vertex_ai/test_http_status_201.py
index 34502d5cebe..0ed469acfa7 100644
--- a/tests/unit/llms/vertex_ai/test_http_status_201.py
+++ b/tests/unit/llms/vertex_ai/test_http_status_201.py
@@ -39,8 +39,8 @@ class TestVertexAIHTTPStatus201(unittest.TestCase):
         # Create a mock response with status code 201
         mock_response = MagicMock()
         mock_response.status_code = 201
-        mock_response.aiter_lines = MagicMock()
-        mock_response.aiter_lines.return_value = ["test response"]
+        mock_response.aiter_text = MagicMock()
+        mock_response.aiter_text.return_value = ["test response"]
 
         # Setup mock client
         mock_client = MagicMock()
@@ -76,8 +76,8 @@ class TestVertexAIHTTPStatus201(unittest.TestCase):
         # Create a mock response with status code 201
         mock_response = MagicMock()
         mock_response.status_code = 201
-        mock_response.iter_lines = MagicMock()
-        mock_response.iter_lines.return_value = ["test response"]
+        mock_response.iter_text = MagicMock()
+        mock_response.iter_text.return_value = ["test response"]
         mock_post.return_value = mock_response
 
         # Call the make_sync_call function
diff --git a/tests/unit/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_messages_config.py b/tests/unit/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_messages_config.py
index 6c10d524531..5916ce9f7a1 100644
--- a/tests/unit/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_messages_config.py
+++ b/tests/unit/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_messages_config.py
@@ -6,12 +6,14 @@ from datetime import datetime, timedelta
 from queue import SimpleQueue
 from threading import get_ident
 from typing import Final
-from unittest.mock import MagicMock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 import requests
 import responses
 
+import litellm
+from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
 from litellm.llms.vertex_ai.vertex_ai_partner_models.anthropic.messages.transformation import (
     VertexAIPartnerModelsAnthropicMessagesConfig,
 )
@@ -94,6 +96,85 @@ async def test_messages_auth_load_and_refresh_leave_the_event_loop(stream: bool,
     assert headers == {"Authorization": "Bearer incoming", "anthropic-beta": "retained-beta", "x-request-id": "req-1"}
 
 
+def _vertex_client() -> MagicMock:
+    vertex_response: Final = MagicMock()
+    vertex_response.json.return_value = {
+        "id": "msg_1",
+        "type": "message",
+        "role": "assistant",
+        "content": [{"type": "text", "text": "hi"}],
+        "model": "claude-sonnet-5",
+        "stop_reason": "end_turn",
+        "stop_sequence": None,
+        "usage": {"input_tokens": 1, "output_tokens": 1},
+    }
+    client: Final = MagicMock(spec=AsyncHTTPHandler)
+    client.post = AsyncMock(return_value=vertex_response)
+    return client
+
+
+async def _send_to_vertex(client: MagicMock, caller_headers: Mapping[str, str], drop_params: bool) -> None:
+    with responses.RequestsMock(assert_all_requests_are_fired=False) as oauth:
+        oauth.add(responses.POST, "https://oauth2.googleapis.com/token", json={"access_token": "vertex-token", "expires_in": 3600})
+        await litellm.anthropic.messages.acreate(
+            model="vertex_ai/claude-sonnet-5",
+            messages=[{"role": "user", "content": "hi"}],
+            max_tokens=16,
+            vertex_ai_project="version-project",
+            vertex_ai_location="global",
+            vertex_credentials=json.dumps(
+                {
+                    "type": "authorized_user",
+                    "client_id": "version-header-client",
+                    "client_secret": "synthetic-secret",
+                    "refresh_token": "synthetic-refresh",
+                }
+            ),
+            client=client,
+            drop_params=drop_params,
+            provider_specific_header={
+                "custom_llm_provider": "vertex_ai",
+                "extra_headers": {**caller_headers, "x-request-id": "req-1"},
+            },
+        )
+
+
+@pytest.mark.parametrize(
+    ("caller_headers", "drop_params", "body_version"),
+    (
+        ({"anthropic-version": "2026-10-21"}, False, "2026-10-21"),
+        ({"Anthropic-Version": "2026-10-21"}, False, "2026-10-21"),
+        ({"anthropic-version": "vertex-2023-10-16"}, False, "vertex-2023-10-16"),
+        ({"anthropic-version": "2023-06-01"}, False, "vertex-2023-10-16"),
+        ({"anthropic-version": "2023-01-01"}, False, "vertex-2023-10-16"),
+        ({"anthropic-version": " "}, False, "vertex-2023-10-16"),
+        ({}, False, "vertex-2023-10-16"),
+        ({"anthropic-version": "latest"}, True, "vertex-2023-10-16"),
+    ),
+)
+@pytest.mark.asyncio
+async def test_caller_anthropic_version_reaches_vertex_only_in_the_body(
+    caller_headers: dict[str, str], drop_params: bool, body_version: str
+) -> None:
+    client: Final = _vertex_client()
+    await _send_to_vertex(client, caller_headers, drop_params)
+
+    sent: Final = client.post.call_args.kwargs
+    sent_header_names: Final = {name.lower() for name in sent["headers"]}
+    assert "anthropic-version" not in sent_header_names
+    assert sent["headers"]["x-request-id"] == "req-1"
+    assert json.loads(sent["data"])["anthropic_version"] == body_version
+
+
+@pytest.mark.parametrize("requested", ("2025-01-01", "latest"))
+@pytest.mark.asyncio
+async def test_unsupported_anthropic_version_is_refused_without_drop_params(requested: str) -> None:
+    client: Final = _vertex_client()
+    with pytest.raises(litellm.BadRequestError, match=f"anthropic-version={requested}. To drop unsupported params"):
+        await _send_to_vertex(client, {"anthropic-version": requested}, drop_params=False)
+    client.post.assert_not_awaited()
+
+
 def test_validate_environment_uses_vertex_ai_location():
     config = VertexAIPartnerModelsAnthropicMessagesConfig()
     headers = {}
diff --git a/tests/unit/proxy/agent_endpoints/test_a2a_endpoints.py b/tests/unit/proxy/agent_endpoints/test_a2a_endpoints.py
index a7d7ac5627c..7abe6ad7799 100644
--- a/tests/unit/proxy/agent_endpoints/test_a2a_endpoints.py
+++ b/tests/unit/proxy/agent_endpoints/test_a2a_endpoints.py
@@ -4,10 +4,11 @@ Mock tests for A2A endpoints.
 Tests that invoke_agent_a2a properly integrates with add_litellm_data_to_request.
 """
 
+import asyncio
 import json
 import socket
 import sys
-from collections.abc import Awaitable, Callable, Mapping
+from collections.abc import AsyncIterator, Awaitable, Callable, Mapping
 from contextlib import AbstractContextManager, ExitStack
 from dataclasses import dataclass
 from typing import Final
@@ -24,6 +25,21 @@ from litellm.types.agents import AgentCaller
 AddLiteLLMData = Callable[..., Awaitable[dict[str, object]]]
 
 
+class _SSELineStream(httpx.AsyncByteStream):
+    def __init__(self, lines: tuple[str, ...], first_line_delay: float) -> None:
+        self._lines = lines
+        self._first_line_delay = first_line_delay
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        await asyncio.sleep(self._first_line_delay)
+        for line in self._lines:
+            yield f"{line}\n".encode()
+
+
+def _sse_upstream_response(*lines: str, first_line_delay: float = 0.0) -> httpx.Response:
+    return httpx.Response(200, stream=_SSELineStream(lines, first_line_delay))
+
+
 @dataclass(frozen=True, slots=True)
 class CapturedAgentCall:
     request_id: object
@@ -941,13 +957,7 @@ async def test_task_methods_extract_litellm_params_before_forwarding(method: str
     mock_http_response.json.return_value = upstream_response
     mock_http_response.is_success = True
 
-    async def fake_aiter_lines():
-        yield 'data: {"jsonrpc":"2.0","id":"req-1","result":{"taskId":"task-1"}}'
-
-    mock_resp = AsyncMock()
-    mock_resp.is_success = True
-    mock_resp.aiter_lines = fake_aiter_lines
-    mock_resp.aclose = AsyncMock()
+    mock_resp = _sse_upstream_response('data: {"jsonrpc":"2.0","id":"req-1","result":{"taskId":"task-1"}}')
 
     mock_async_client = MagicMock()
     mock_async_client.build_request = MagicMock(return_value=MagicMock())
@@ -982,8 +992,8 @@ async def test_task_methods_extract_litellm_params_before_forwarding(method: str
             user_api_key_dict=user_api_key_dict,
         )
         if method == "tasks/resubscribe":
-            async for _ in response.body_iterator:
-                pass
+            streamed = "".join([chunk async for chunk in response.body_iterator])
+            assert "task-1" in streamed
 
     if method == "tasks/resubscribe":
         forwarded_body = mock_async_client.build_request.call_args.kwargs["json"]
@@ -1007,14 +1017,7 @@ async def test_subscribe_to_task_returns_sse_stream():
         'data: {"jsonrpc":"2.0","id":"req-1","result":{"taskId":"task-1","status":{"state":"completed"}}}',
     ]
 
-    async def fake_aiter_lines():
-        for line in sse_lines:
-            yield line
-
-    mock_resp = AsyncMock()
-    mock_resp.is_success = True
-    mock_resp.aiter_lines = fake_aiter_lines
-    mock_resp.aclose = AsyncMock()
+    mock_resp = _sse_upstream_response(*sse_lines)
 
     mock_async_client = MagicMock()
     mock_async_client.build_request = MagicMock(return_value=MagicMock())
@@ -1064,13 +1067,9 @@ async def test_subscribe_to_task_calls_pre_call_hook():
     mock_request = _make_request_mock("tasks/resubscribe", {"id": "task-1"})
     user_api_key_dict = UserAPIKeyAuth(api_key="sk-test", user_id="u1", team_id="t1")
 
-    async def fake_aiter_lines():
-        yield 'data: {"jsonrpc":"2.0","id":"req-1","result":{"taskId":"task-1","status":{"state":"completed"}}}'
-
-    mock_resp = AsyncMock()
-    mock_resp.is_success = True
-    mock_resp.aiter_lines = fake_aiter_lines
-    mock_resp.aclose = AsyncMock()
+    mock_resp = _sse_upstream_response(
+        'data: {"jsonrpc":"2.0","id":"req-1","result":{"taskId":"task-1","status":{"state":"completed"}}}'
+    )
 
     mock_async_client = MagicMock()
     mock_async_client.build_request = MagicMock(return_value=MagicMock())
@@ -1117,9 +1116,9 @@ async def test_subscribe_to_task_calls_pre_call_hook():
         )
 
         assert response.media_type == "text/event-stream"
-        async for _ in response.body_iterator:
-            pass
+        streamed = "".join([chunk async for chunk in response.body_iterator])
 
+    assert "completed" in streamed
     mock_proxy_logging.pre_call_hook.assert_awaited_once()
     call_kwargs = mock_proxy_logging.pre_call_hook.await_args.kwargs
     assert call_kwargs.get("call_type") == "asend_message"
@@ -1149,16 +1148,10 @@ async def test_subscribe_to_task_runs_post_call_streaming_guardrail():
     mock_request = _make_request_mock("tasks/resubscribe", {"id": "task-1"})
     user_api_key_dict = UserAPIKeyAuth(api_key="sk-test", user_id="u1", team_id="t1")
 
-    async def fake_aiter_lines():
-        yield (
-            'data: {"jsonrpc":"2.0","id":"req-1","result":'
-            '{"kind":"message","parts":[{"kind":"text","text":"resubscribe-secret"}]}}'
-        )
-
-    mock_resp = AsyncMock()
-    mock_resp.is_success = True
-    mock_resp.aiter_lines = fake_aiter_lines
-    mock_resp.aclose = AsyncMock()
+    mock_resp = _sse_upstream_response(
+        'data: {"jsonrpc":"2.0","id":"req-1","result":'
+        '{"kind":"message","parts":[{"kind":"text","text":"resubscribe-secret"}]}}'
+    )
 
     mock_async_client = MagicMock()
     mock_async_client.build_request = MagicMock(return_value=MagicMock())
@@ -1600,14 +1593,7 @@ async def test_pascal_method_names_normalize_to_wire_format(pascal_method: str,
     mock_http_response.is_success = True
     mock_http_response.raise_for_status = MagicMock()
 
-    async def _empty_aiter_lines():
-        return
-        yield  # make it an async generator
-
-    mock_sse_resp = AsyncMock()
-    mock_sse_resp.is_success = True
-    mock_sse_resp.aiter_lines = _empty_aiter_lines
-    mock_sse_resp.aclose = AsyncMock()
+    mock_sse_resp = _sse_upstream_response()
 
     mock_async_client = MagicMock()
     mock_async_client.build_request = MagicMock(return_value=MagicMock())
@@ -2349,13 +2335,7 @@ async def test_task_methods_forward_trace_header(method: str):
     mock_http_response.json.return_value = upstream_response
     mock_http_response.is_success = True
 
-    async def fake_aiter_lines():
-        yield 'data: {"jsonrpc":"2.0","id":"req-1","result":{"taskId":"task-1"}}'
-
-    mock_resp = AsyncMock()
-    mock_resp.is_success = True
-    mock_resp.aiter_lines = fake_aiter_lines
-    mock_resp.aclose = AsyncMock()
+    mock_resp = _sse_upstream_response('data: {"jsonrpc":"2.0","id":"req-1","result":{"taskId":"task-1"}}')
 
     mock_async_client = MagicMock()
     mock_async_client.build_request = MagicMock(return_value=MagicMock())
@@ -2390,8 +2370,8 @@ async def test_task_methods_forward_trace_header(method: str):
             user_api_key_dict=user_api_key_dict,
         )
         if method == "tasks/resubscribe":
-            async for _ in response.body_iterator:
-                pass
+            streamed = "".join([chunk async for chunk in response.body_iterator])
+            assert "task-1" in streamed
 
     if method == "tasks/resubscribe":
         forwarded_headers = mock_async_client.build_request.call_args.kwargs["headers"]
@@ -2646,17 +2626,12 @@ def test_served_version_falls_back_to_header_when_unconfigured():
     assert _served_version(_agent(None), _request_with_a2a_header(None)) == "0.3"
 
 
-def _sse_agent_handler(lines):
-    mock_resp = AsyncMock()
-    mock_resp.is_success = True
-    mock_resp.aiter_lines = lines
-    mock_resp.aclose = AsyncMock()
-
-    mock_async_client = MagicMock()
+def _sse_agent_handler(upstream_response: httpx.Response) -> MagicMock:
+    mock_async_client: Final = MagicMock()
     mock_async_client.build_request = MagicMock(return_value=MagicMock())
-    mock_async_client.send = AsyncMock(return_value=mock_resp)
+    mock_async_client.send = AsyncMock(return_value=upstream_response)
 
-    mock_handler = MagicMock()
+    mock_handler: Final = MagicMock()
     mock_handler.client = mock_async_client
     return mock_handler
 
@@ -2685,13 +2660,13 @@ async def test_forward_jsonrpc_sse_pings_while_the_upstream_agent_is_still_silen
 
     monkeypatch.setattr(litellm, "sse_keepalive_ping_interval_seconds", 0.05)
 
-    async def _slow_lines():
-        await asyncio.sleep(0.3)
-        yield 'data: {"jsonrpc": "2.0", "id": "req-1", "result": {"kind": "task"}}'
+    slow_upstream = _sse_upstream_response(
+        'data: {"jsonrpc": "2.0", "id": "req-1", "result": {"kind": "task"}}', first_line_delay=0.3
+    )
 
     with patch(
         "litellm.llms.custom_httpx.http_handler.get_async_httpx_client",
-        return_value=_sse_agent_handler(_slow_lines),
+        return_value=_sse_agent_handler(slow_upstream),
     ):
         response = await _resubscribe_response()
         assert response.headers["x-accel-buffering"] == "no"
@@ -2713,12 +2688,11 @@ async def test_forward_jsonrpc_sse_is_untouched_while_keepalives_are_unconfigure
 
     monkeypatch.setattr(litellm, "sse_keepalive_ping_interval_seconds", None)
 
-    async def _lines():
-        yield 'data: {"jsonrpc": "2.0", "id": "req-1", "result": {"kind": "task"}}'
-
     with patch(
         "litellm.llms.custom_httpx.http_handler.get_async_httpx_client",
-        return_value=_sse_agent_handler(_lines),
+        return_value=_sse_agent_handler(
+            _sse_upstream_response('data: {"jsonrpc": "2.0", "id": "req-1", "result": {"kind": "task"}}')
+        ),
     ):
         response = await _resubscribe_response()
         assert "x-accel-buffering" not in response.headers
@@ -2728,6 +2702,28 @@ async def test_forward_jsonrpc_sse_is_untouched_while_keepalives_are_unconfigure
     assert json.loads(chunks[-1].removeprefix("data: "))["result"]["kind"] == "task"
 
 
+@pytest.mark.asyncio
+async def test_forward_jsonrpc_sse_keeps_unicode_line_separators_inside_an_event(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(litellm, "sse_keepalive_ping_interval_seconds", None)
+    separated_text: Final = "before\u2028between\u2029after"
+    event: Final = {
+        "jsonrpc": "2.0",
+        "id": "req-1",
+        "result": {"kind": "message", "parts": [{"kind": "text", "text": separated_text}]},
+    }
+
+    with patch(
+        "litellm.llms.custom_httpx.http_handler.get_async_httpx_client",
+        return_value=_sse_agent_handler(_sse_upstream_response(f"data: {json.dumps(event, ensure_ascii=False)}")),
+    ):
+        response: Final = await _resubscribe_response()
+        chunks: Final = [chunk async for chunk in response.body_iterator]
+
+    assert [json.loads(chunk.removeprefix("data: "))["result"]["parts"][0]["text"] for chunk in chunks] == [
+        separated_text
+    ]
+
+
 async def _stream_message_response():
     from litellm.proxy.agent_endpoints.a2a_endpoints import _handle_stream_message
 
diff --git a/tests/unit/proxy/anthropic_endpoints/test_streaming_model_restamp.py b/tests/unit/proxy/anthropic_endpoints/test_streaming_model_restamp.py
index 85bb8304b95..5911fcdc073 100644
--- a/tests/unit/proxy/anthropic_endpoints/test_streaming_model_restamp.py
+++ b/tests/unit/proxy/anthropic_endpoints/test_streaming_model_restamp.py
@@ -4,6 +4,7 @@ Tests for restamping the public model on Anthropic Messages streaming chunks.
 
 import json
 from collections.abc import AsyncIterator, Sequence
+from typing import Final
 
 import pytest
 
@@ -46,6 +47,28 @@ def test_restamps_sse_bytes_frame():
     assert b"event: message_start" in restamped
 
 
+def test_restamps_sse_bytes_frame_holding_a_line_separator() -> None:
+    payload: Final = {
+        "type": "message_start",
+        "message": {
+            "id": "msg_1",
+            "type": "message",
+            "role": "assistant",
+            "model": "claude-haiku-4-5-20251001",
+            "content": [{"type": "text", "text": "alpha\u2028beta"}],
+        },
+    }
+    frame: Final = f"event: message_start\ndata: {json.dumps(payload, ensure_ascii=False)}\n\n".encode()
+
+    restamped: Final = restamp_anthropic_stream_chunk_model(frame, "claude-auto-1")
+
+    assert isinstance(restamped, bytes)
+    data_line: Final = next(line for line in restamped.decode().split("\n") if line.startswith("data:"))
+    message: Final = json.loads(data_line[len("data:") :])["message"]
+    assert message["model"] == "claude-auto-1"
+    assert message["content"] == [{"type": "text", "text": "alpha\u2028beta"}]
+
+
 def test_restamps_event_dict():
     chunk = {"type": "message_start", "message": {"id": "msg_1", "model": "claude-sonnet-4-6"}}
 
diff --git a/tests/unit/proxy/db/test_accounting_ledger.py b/tests/unit/proxy/db/test_accounting_ledger.py
new file mode 100644
index 00000000000..3916fe869e6
--- /dev/null
+++ b/tests/unit/proxy/db/test_accounting_ledger.py
@@ -0,0 +1,103 @@
+import json
+from datetime import datetime, timezone
+from decimal import Decimal
+from typing import Final, Literal, NoReturn
+
+import pytest
+
+from litellm.accounting import InboundUsageEvent, Metric, MetricName, Outcome
+from litellm.proxy.db.accounting_ledger import AccountingLedger
+from litellm.types.utils import CallTypes
+
+
+def _no_transaction() -> NoReturn:
+    raise AssertionError("Invalid accounting input must not open a database transaction")
+
+
+@pytest.fixture
+def event() -> InboundUsageEvent:
+    return InboundUsageEvent(
+        event_id="caller",
+        request_id="caller",
+        call_type=CallTypes.completion,
+        started_at=datetime(2026, 1, 1, tzinfo=timezone.utc),
+        ended_at=datetime(2026, 1, 1, tzinfo=timezone.utc),
+        outcome=Outcome.SUCCEEDED,
+        dimensions=(),
+        metrics=(Metric(name=MetricName.REQUESTS, value=Decimal(1)),),
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("envelope", ["{}", "[]", '{"event":null}', '{"event":{}}', "not json"])
+async def test_invalid_envelopes_fail_before_database_access(event: InboundUsageEvent, envelope: str) -> None:
+    with pytest.raises(ValueError, match=r"Accounting envelope|validation error"):
+        await AccountingLedger(_no_transaction).insert_event(event, (), envelope=envelope)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("version", [0, -1, True, 1.5])
+@pytest.mark.parametrize("field", ["version", "schema_version"])
+async def test_invalid_versions_fail_before_database_access(
+    event: InboundUsageEvent, version: int | float, field: Literal["version", "schema_version"]
+) -> None:
+    with pytest.raises(ValueError, match="positive integers"):
+        await AccountingLedger(_no_transaction).insert_event(
+            event,
+            (),
+            envelope="{}",
+            **{field: version},  # pyright: ignore[reportArgumentType]  # Exercise invalid runtime versions
+        )
+
+
+@pytest.mark.asyncio
+async def test_constructed_invalid_events_are_revalidated(event: InboundUsageEvent) -> None:
+    invalid: Final = event.model_copy(update={"event_id": ""})
+    with pytest.raises(ValueError, match="event_id"):
+        await AccountingLedger(_no_transaction).insert_event(invalid, (), envelope="{}")
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("limit", [0, -1, 1001, True, 1.5])
+async def test_retention_rejects_invalid_batch_bounds(limit: int | float) -> None:
+    with pytest.raises(ValueError, match="batch size"):
+        await AccountingLedger(_no_transaction).purge_completed(
+            limit=limit  # pyright: ignore[reportArgumentType]  # Exercise invalid runtime batch sizes
+        )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("missing", ["both", "redelivery", "recovery"])
+async def test_retention_requires_both_safety_watermarks(missing: Literal["both", "redelivery", "recovery"]) -> None:
+    cutoff: Final = datetime(2026, 1, 1, tzinfo=timezone.utc)
+    deleted: Final = await AccountingLedger(_no_transaction).purge_completed(
+        redelivery_before=cutoff if missing == "recovery" else None,
+        recovery_before=cutoff if missing == "redelivery" else None,
+    )
+    assert deleted == 0
+
+
+@pytest.mark.asyncio
+async def test_retention_rejects_ambiguous_naive_watermarks() -> None:
+    with pytest.raises(ValueError, match="timezone"):
+        await AccountingLedger(_no_transaction).purge_completed(
+            redelivery_before=datetime(2026, 1, 1), recovery_before=datetime(2026, 1, 1, tzinfo=timezone.utc)
+        )
+
+
+@pytest.mark.asyncio
+async def test_nonfinite_context_is_rejected_before_database_access(event: InboundUsageEvent) -> None:
+    envelope: Final = json.dumps({"event": event.model_dump(mode="json"), "context": {"price": float("nan")}})
+    with pytest.raises(ValueError, match="Out of range float"):
+        await AccountingLedger(_no_transaction).insert_event(event, (), envelope=envelope)
+
+
+@pytest.mark.asyncio
+async def test_unknown_delivery_target_is_rejected_before_database_access(event: InboundUsageEvent) -> None:
+    envelope: Final = json.dumps({"event": event.model_dump(mode="json")})
+    with pytest.raises(ValueError, match="not a valid DeliveryTarget"):
+        await AccountingLedger(_no_transaction).insert_event(
+            event,
+            ("unknown",),  # pyright: ignore[reportArgumentType]  # Exercise an unknown runtime target
+            envelope=envelope,
+        )
diff --git a/tests/unit/proxy/management_endpoints/test_auto_router_endpoints.py b/tests/unit/proxy/management_endpoints/test_auto_router_endpoints.py
index 748b291d5ff..c13e3d5812b 100644
--- a/tests/unit/proxy/management_endpoints/test_auto_router_endpoints.py
+++ b/tests/unit/proxy/management_endpoints/test_auto_router_endpoints.py
@@ -170,7 +170,7 @@ async def test_preview_and_serving_share_default_model_resolution(
     explicit_default: str | None,
     expected: str,
 ):
-    from litellm.router_utils.auto_router_model_naming import validate_complexity_router_config_write
+    from litellm.router_strategy.auto_router.auto_router_model_naming import validate_complexity_router_config_write
     from litellm.types.management_endpoints.auto_router_endpoints import ComplexityRouterConfigValidationRequest
 
     config: Final = {
@@ -1240,7 +1240,7 @@ class TestAutoRouterBenchmarks:
     def test_the_listed_kinds_match_the_router_types_traffic_can_record(self):
         from typing import get_args, get_type_hints
 
-        from litellm.router_utils.auto_router_model_naming import StrategyRouterKind
+        from litellm.router_strategy.auto_router.auto_router_model_naming import StrategyRouterKind
         from litellm.types.utils import StandardLoggingRoutingDecision
 
         readonly_router_type: Final = get_type_hints(StandardLoggingRoutingDecision, include_extras=True)["router_type"]
diff --git a/tests/unit/proxy/management_endpoints/test_model_management_endpoints.py b/tests/unit/proxy/management_endpoints/test_model_management_endpoints.py
index fc6749aed0f..437d948f8f5 100644
--- a/tests/unit/proxy/management_endpoints/test_model_management_endpoints.py
+++ b/tests/unit/proxy/management_endpoints/test_model_management_endpoints.py
@@ -1,6 +1,6 @@
-import inspect
 import asyncio
 import contextlib
+import inspect
 import json
 import socket
 from collections.abc import Iterator, Mapping
@@ -1461,10 +1461,10 @@ class TestDeleteModelClearsRouterRegistry:
         add_deployment never restores, so an unguarded pop would make it permanently
         unroutable (the same cross-tenant DoS clear_cache was hardened against).
         """
+        from litellm.proxy.management_endpoints.model_management_endpoints import ModelInfoDelete
         from litellm.proxy.management_endpoints.model_management_endpoints import (
             delete_model as delete_model_endpoint,
         )
-        from litellm.proxy.management_endpoints.model_management_endpoints import ModelInfoDelete
 
         model_id = "regular-del-1"
         admin_user = UserAPIKeyAuth(user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN)
@@ -2739,11 +2739,11 @@ class TestAddAndDeleteModelLifecycle:
         - Delete same model again → raises (model not found)
         """
         from litellm.proxy.management_endpoints.model_management_endpoints import (
+            ModelInfoDelete,
             add_new_model,
-            delete_model as delete_model_endpoint,
         )
         from litellm.proxy.management_endpoints.model_management_endpoints import (
-            ModelInfoDelete,
+            delete_model as delete_model_endpoint,
         )
 
         model_id = "lifecycle-test-model-123"
@@ -2833,6 +2833,8 @@ class TestDeleteTeamBYOKModelGhost:
     async def test_delete_strips_public_name_and_refreshes_cache(self):
         from litellm.proxy.management_endpoints.model_management_endpoints import (
             ModelInfoDelete,
+        )
+        from litellm.proxy.management_endpoints.model_management_endpoints import (
             delete_model as delete_model_endpoint,
         )
 
@@ -2916,6 +2918,8 @@ class TestDeleteTeamBYOKModelGhost:
         alias cleanup (delete_team_model_alias), preserving legacy behavior."""
         from litellm.proxy.management_endpoints.model_management_endpoints import (
             ModelInfoDelete,
+        )
+        from litellm.proxy.management_endpoints.model_management_endpoints import (
             delete_model as delete_model_endpoint,
         )
 
@@ -2984,6 +2988,8 @@ class TestDeleteTeamBYOKModelGhost:
         team.models when one replica is deleted but a sibling still backs it."""
         from litellm.proxy.management_endpoints.model_management_endpoints import (
             ModelInfoDelete,
+        )
+        from litellm.proxy.management_endpoints.model_management_endpoints import (
             delete_model as delete_model_endpoint,
         )
 
@@ -3065,6 +3071,8 @@ class TestDeleteTeamBYOKModelGhost:
         deployment still serves it."""
         from litellm.proxy.management_endpoints.model_management_endpoints import (
             ModelInfoDelete,
+        )
+        from litellm.proxy.management_endpoints.model_management_endpoints import (
             delete_model as delete_model_endpoint,
         )
 
@@ -3145,6 +3153,8 @@ class TestDeleteTeamBYOKModelGhost:
         the alias would break routing that works."""
         from litellm.proxy.management_endpoints.model_management_endpoints import (
             ModelInfoDelete,
+        )
+        from litellm.proxy.management_endpoints.model_management_endpoints import (
             delete_model as delete_model_endpoint,
         )
 
@@ -3252,6 +3262,8 @@ class TestDeleteModelTeamAuth:
     async def test_proxy_admin_can_delete_model_when_team_deleted(self):
         from litellm.proxy.management_endpoints.model_management_endpoints import (
             ModelInfoDelete,
+        )
+        from litellm.proxy.management_endpoints.model_management_endpoints import (
             delete_model as delete_model_endpoint,
         )
 
@@ -3287,6 +3299,8 @@ class TestDeleteModelTeamAuth:
         """A missing team must never let a non-admin delete the orphan (no fail-open)."""
         from litellm.proxy.management_endpoints.model_management_endpoints import (
             ModelInfoDelete,
+        )
+        from litellm.proxy.management_endpoints.model_management_endpoints import (
             delete_model as delete_model_endpoint,
         )
         from litellm.proxy.proxy_server import ProxyException
@@ -3322,6 +3336,8 @@ class TestDeleteModelTeamAuth:
         """The auth check must not add a redundant team query on the live-team path."""
         from litellm.proxy.management_endpoints.model_management_endpoints import (
             ModelInfoDelete,
+        )
+        from litellm.proxy.management_endpoints.model_management_endpoints import (
             delete_model as delete_model_endpoint,
         )
         from litellm.proxy.proxy_server import ProxyException
@@ -4392,7 +4408,6 @@ class TestModelInfoCostMapEchoFilter:
 
     def test_echoed_cost_map_metadata_is_not_persisted(self):
         import litellm
-
         from litellm.proxy.management_endpoints.model_management_endpoints import update_db_model
         from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 
@@ -4418,7 +4433,6 @@ class TestModelInfoCostMapEchoFilter:
 
     def test_an_edited_value_survives_the_echo_filter(self):
         import litellm
-
         from litellm.proxy.management_endpoints.model_management_endpoints import update_db_model
         from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 
@@ -4483,7 +4497,6 @@ class TestModelInfoCostMapEchoFilter:
 
     def test_metadata_without_a_cost_map_key_is_persisted(self):
         import litellm
-
         from litellm.proxy.management_endpoints.model_management_endpoints import update_db_model
         from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
         from litellm.types.utils import echoed_cost_map_fields
@@ -4513,7 +4526,6 @@ class TestModelInfoCostMapEchoFilter:
 
     def test_a_stored_mode_survives_an_echoed_save(self):
         import litellm
-
         from litellm.proxy.management_endpoints.model_management_endpoints import update_db_model
         from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 
@@ -4536,7 +4548,6 @@ class TestModelInfoCostMapEchoFilter:
 
     def test_resetting_an_override_to_the_cost_map_value_removes_it(self):
         import litellm
-
         from litellm.proxy.management_endpoints.model_management_endpoints import update_db_model
         from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 
@@ -4560,7 +4571,6 @@ class TestModelInfoCostMapEchoFilter:
 
     def test_reset_is_recognised_after_the_router_registered_the_override(self, monkeypatch: pytest.MonkeyPatch):
         import litellm
-
         from litellm.proxy.management_endpoints.model_management_endpoints import update_db_model
         from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 
@@ -4586,7 +4596,6 @@ class TestModelInfoCostMapEchoFilter:
         from types import MappingProxyType
 
         import litellm
-
         from litellm.proxy.management_endpoints.model_management_endpoints import update_db_model
         from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 
@@ -4611,7 +4620,6 @@ class TestModelInfoCostMapEchoFilter:
 
     def test_echo_is_compared_against_the_deployments_lookup_not_the_key(self):
         import litellm
-
         from litellm.proxy.management_endpoints.model_management_endpoints import update_db_model
         from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 
@@ -4653,7 +4661,6 @@ class TestModelInfoCostMapEchoFilter:
 
     def test_base_model_wins_over_litellm_params_model_for_the_lookup(self):
         import litellm
-
         from litellm.proxy.management_endpoints.model_management_endpoints import update_db_model
         from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 
@@ -4681,7 +4688,6 @@ class TestModelInfoCostMapEchoFilter:
 
     def test_encrypted_stored_model_is_decrypted_for_the_lookup(self, monkeypatch):
         import litellm
-
         from litellm.proxy.management_endpoints.model_management_endpoints import update_db_model
         from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 
@@ -6431,7 +6437,7 @@ class TestStrategyRouterWriteValidation:
             AUTO_ROUTER_CAPABILITY_SLOT_LOCK_KEY,
             _auto_router_capability_slot,
         )
-        from litellm.router_utils.auto_router_model_naming import gated_capabilities_of
+        from litellm.router_strategy.auto_router.auto_router_model_naming import gated_capabilities_of
 
         capabilities: Final = gated_capabilities_of(effective_params)
 
@@ -6568,7 +6574,7 @@ class TestStrategyRouterWriteValidation:
         from fastapi import HTTPException
 
         from litellm.proxy.management_endpoints.model_management_endpoints import _auto_router_capability_slot
-        from litellm.router_utils.auto_router_tuning_baseline import snapshot_tuning_baselines
+        from litellm.router_strategy.auto_router.auto_router_tuning_baseline import snapshot_tuning_baselines
 
         configs = {
             "_TUNED_A": self._TUNED_A,
@@ -6624,7 +6630,7 @@ class TestStrategyRouterWriteValidation:
 
         from litellm.proxy import proxy_server
         from litellm.proxy.management_endpoints.model_management_endpoints import _auto_router_capability_slot
-        from litellm.router_utils.auto_router_tuning_baseline import snapshot_tuning_baselines
+        from litellm.router_strategy.auto_router.auto_router_tuning_baseline import snapshot_tuning_baselines
 
         fake = self._FakeDb([])
         fake.tx_obj.litellm_proxymodeltable.find_many = AsyncMock(
@@ -6669,7 +6675,7 @@ class TestStrategyRouterWriteValidation:
         row id before the slot is entered, so a second tuned router is refused before its DB write."""
         from litellm.proxy._types import ProxyException
         from litellm.proxy.management_endpoints.model_management_endpoints import add_new_model
-        from litellm.router_utils.auto_router_tuning_baseline import snapshot_tuning_baselines
+        from litellm.router_strategy.auto_router.auto_router_tuning_baseline import snapshot_tuning_baselines
 
         admin = UserAPIKeyAuth(user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN)
         baselines = snapshot_tuning_baselines([self._db_router_row("a", self._TUNED_A)])
@@ -8980,7 +8986,10 @@ class TestTeamMemberAutoRouterWrites:
         from fastapi import HTTPException
 
         from litellm.proxy.management_endpoints.model_management_endpoints import _auto_router_capability_slot
-        from litellm.proxy.management_helpers.auto_router_permissions import MemberAutoRouterWrite, validate_member_auto_router_config
+        from litellm.proxy.management_helpers.auto_router_permissions import (
+            MemberAutoRouterWrite,
+            validate_member_auto_router_config,
+        )
 
         row: Final = self._row()
         database: Final = self._database(self._team(), row)
@@ -10677,6 +10686,8 @@ class TestFederationGateScopesToWhatTheWriteTouches:
         and the team that owns the model must be able to take it off their page."""
         from litellm.proxy.management_endpoints.model_management_endpoints import (
             ModelInfoDelete,
+        )
+        from litellm.proxy.management_endpoints.model_management_endpoints import (
             delete_model as delete_model_endpoint,
         )
 
diff --git a/tests/unit/proxy/management_helpers/test_auto_router_availability.py b/tests/unit/proxy/management_helpers/test_auto_router_availability.py
index a88dcd7f66d..0eaae60b4ea 100644
--- a/tests/unit/proxy/management_helpers/test_auto_router_availability.py
+++ b/tests/unit/proxy/management_helpers/test_auto_router_availability.py
@@ -1,16 +1,15 @@
 from collections.abc import Mapping
-from typing import Final
 from types import SimpleNamespace
-
-from litellm.proxy.common_utils.encrypt_decrypt_utils import encrypt_value_helper
+from typing import Final
 
 import pytest
 
+from litellm.proxy.common_utils.encrypt_decrypt_utils import encrypt_value_helper
 from litellm.proxy.management_helpers.auto_router_availability import (
     auto_router_availability,
     build_auto_router_catalog,
 )
-from litellm.router_utils.auto_router_tuning_baseline import snapshot_tuning_baselines
+from litellm.router_strategy.auto_router.auto_router_tuning_baseline import snapshot_tuning_baselines
 
 
 def deployment(
diff --git a/tests/unit/proxy/pass_through_endpoints/llm_provider_handlers/test_anthropic_passthrough_logging_handler.py b/tests/unit/proxy/pass_through_endpoints/llm_provider_handlers/test_anthropic_passthrough_logging_handler.py
index e09a179eadf..47b6af9aeb3 100644
--- a/tests/unit/proxy/pass_through_endpoints/llm_provider_handlers/test_anthropic_passthrough_logging_handler.py
+++ b/tests/unit/proxy/pass_through_endpoints/llm_provider_handlers/test_anthropic_passthrough_logging_handler.py
@@ -2503,6 +2503,33 @@ def test_stream_was_interrupted_skips_data_lines_that_are_not_json_objects(
     assert AnthropicPassthroughLoggingHandler._stream_was_interrupted(all_chunks) is interrupted
 
 
+
+def test_stream_was_interrupted_reads_a_message_delta_whose_json_holds_unicode_line_separators() -> None:
+    message_delta: Final = {
+        "type": "message_delta",
+        "delta": {"stop_reason": "stop_sequence", "stop_sequence": "END\u2028OF\u2029TURN"},
+        "usage": {"output_tokens": 3},
+    }
+    all_chunks: Final = [
+        'data: {"type": "content_block_stop", "index": 0}',
+        f"data: {json.dumps(message_delta, ensure_ascii=False)}",
+    ]
+
+    assert AnthropicPassthroughLoggingHandler._stream_was_interrupted(all_chunks) is False
+
+
+def test_extract_model_reads_a_message_start_whose_json_holds_unicode_line_separators() -> None:
+    message_start: Final = {
+        "type": "message_start",
+        "message": {
+            "model": "claude-sonnet-5",
+            "content": [{"type": "text", "text": "Prefill\u2028line\u2029two"}],
+        },
+    }
+    chunk: Final = f"event: message_start\ndata: {json.dumps(message_start, ensure_ascii=False)}\n\n"
+
+    assert AnthropicPassthroughLoggingHandler._extract_model_from_anthropic_chunks([chunk]) == "claude-sonnet-5"
+
 @pytest.mark.asyncio
 async def test_anthropic_passthrough_handler(mock_httpx_response, mock_response, mock_logging_obj):
     """
@@ -3004,3 +3031,24 @@ def test_anthropic_passthrough_stream_bills_the_bedrock_guardrail_trace_of_the_m
     (entry,) = _recorded_guardrail_entries(mock_logging_obj)
     assert entry["guardrail_usage"] == {"topicPolicyUnits": 3, "contentPolicyUnits": 3}
     assert entry["guardrail_cost"] == pytest.approx(6 * 0.00015)
+
+
+def test_anthropic_passthrough_stream_bills_a_bedrock_guardrail_trace_whose_json_holds_unicode_line_separators(
+    monkeypatch: pytest.MonkeyPatch, mock_logging_obj: LiteLLMLoggingObj, all_chunks: list[str]
+) -> None:
+    monkeypatch.setattr(litellm, "model_cost", _BEDROCK_TRACE_PRICING)
+    mock_logging_obj.model_call_details["litellm_params"] = {"metadata": {}}
+    trace: Final = {"guardrail": {**_BEDROCK_INVOKE_TRACE["guardrail"], "actionReason": "Blocked\u2028by\u2029policy"}}
+    stop_event: Final = json.dumps({"type": "message_stop", "amazon-bedrock-trace": trace}, ensure_ascii=False)
+    AnthropicPassthroughLoggingHandler.handle_logging_anthropic_collected_chunks(
+        litellm_logging_obj=mock_logging_obj,
+        passthrough_success_handler_obj=MagicMock(),
+        url_route="/v1/messages",
+        request_body={"model": "claude", "messages": []},
+        endpoint_type=MagicMock(),
+        start_time=datetime(2025, 1, 1),
+        all_chunks=[*all_chunks, f"event: message_stop\ndata: {stop_event}\n\n"],
+        end_time=datetime(2025, 1, 1),
+    )
+    (entry,) = _recorded_guardrail_entries(mock_logging_obj)
+    assert entry["guardrail_usage"] == {"topicPolicyUnits": 3, "contentPolicyUnits": 3}
diff --git a/tests/unit/proxy/pass_through_endpoints/llm_provider_handlers/test_tinyfish_passthrough_logging_handler.py b/tests/unit/proxy/pass_through_endpoints/llm_provider_handlers/test_tinyfish_passthrough_logging_handler.py
index 1b83c5140ca..b0f84f2ecbe 100644
--- a/tests/unit/proxy/pass_through_endpoints/llm_provider_handlers/test_tinyfish_passthrough_logging_handler.py
+++ b/tests/unit/proxy/pass_through_endpoints/llm_provider_handlers/test_tinyfish_passthrough_logging_handler.py
@@ -1,6 +1,7 @@
 import asyncio
 import json
 from datetime import datetime
+from typing import Final
 from unittest.mock import AsyncMock, MagicMock
 
 import httpx
@@ -267,6 +268,12 @@ class TestRunIdFromSseFrames:
         frames = b'data: {"run_id": "run-7", "event": "INITIALIZED"}\n\ndata: {"run_id": "run-7", "event": "ACTION"}\n\n'
         assert run_id_from_sse_frames(frames) == "run-7"
 
+    def test_finds_run_id_in_a_frame_whose_json_holds_unicode_line_separators(self) -> None:
+        event: Final = {"run_id": "run-7", "event": "ACTION", "message": "Clicked\u2028Submit\u2029button"}
+        frames: Final = f"data: {json.dumps(event, ensure_ascii=False)}\n\n".encode()
+
+        assert run_id_from_sse_frames(frames) == "run-7"
+
     def test_skips_frames_without_run_id(self):
         frames = b': keepalive\n\ndata: not-json\n\ndata: {"event": "HEARTBEAT"}\n\n'
         assert run_id_from_sse_frames(frames) is None
diff --git a/tests/unit/proxy/pass_through_endpoints/test_managed_id_rewriter.py b/tests/unit/proxy/pass_through_endpoints/test_managed_id_rewriter.py
index 49bc2e9c29e..2496aa47d22 100644
--- a/tests/unit/proxy/pass_through_endpoints/test_managed_id_rewriter.py
+++ b/tests/unit/proxy/pass_through_endpoints/test_managed_id_rewriter.py
@@ -30,7 +30,7 @@ from litellm.llms.base_llm.managed_resources.utils import(
     resolve_passthrough_managed_id_provider,
 )
 from tests._vcr_conftest_common import install_live_call_probe, record_vcr_outcome
-from typing import Any
+from typing import Any, Final
 
 
 def _user() -> UserAPIKeyAuth:
@@ -254,6 +254,37 @@ async def test_streamed_response_with_cr_only_frame_delimiters_is_still_owned_an
     assert output == _response_stream_bytes(managed_id).replace(b"\n", b"\r")
 
 
+def _instructed_response_stream_bytes(raw_id: str, instructions: str) -> bytes:
+    events: Final = (
+        {"type": "response.created", "response": {"id": raw_id, "status": "in_progress", "instructions": instructions}},
+        {"type": "response.completed", "response": {"id": raw_id, "status": "completed", "instructions": instructions}},
+    )
+    return b"".join(
+        f"event: {event['type']}\ndata: {json.dumps(event, ensure_ascii=False)}\n\n".encode() for event in events
+    )
+
+
+@pytest.mark.asyncio
+async def test_streamed_response_whose_json_holds_unicode_line_separators_is_still_owned_and_rewritten() -> None:
+    instructions: Final = "Answer\u2028in\u2029verse"
+    pc: Final = _prisma_client()
+
+    output: Final = await _collect(
+        rewrite_streamed_response_ids(
+            stream=_chunks(_instructed_response_stream_bytes(RAW_RESPONSE_ID, instructions), 4096),
+            provider="openai",
+            method="POST",
+            route="/openai_passthrough/v1/responses",
+            user_api_key_dict=_user(),
+            prisma_client=pc,
+        )
+    )
+
+    pc.db.litellm_managedobjecttable.upsert.assert_awaited_once()
+    managed_id: Final = pc.db.litellm_managedobjecttable.upsert.await_args.kwargs["data"]["create"]["unified_object_id"]
+    assert output == _instructed_response_stream_bytes(managed_id, instructions)
+
+
 @pytest.mark.asyncio
 async def test_streamed_bytes_untouched_on_routes_without_a_response_id():
     pc = _prisma_client()
diff --git a/tests/unit/proxy/proxy_server/test_lifecycle.py b/tests/unit/proxy/proxy_server/test_lifecycle.py
index 11a44a0ec16..8b1d7c1222a 100644
--- a/tests/unit/proxy/proxy_server/test_lifecycle.py
+++ b/tests/unit/proxy/proxy_server/test_lifecycle.py
@@ -33,9 +33,9 @@ from pydantic import BaseModel
 from typing_extensions import TypedDict
 
 import litellm.proxy.proxy_server as ps
+from litellm.proxy.management_helpers.audit_logs import track_audit_task
 from litellm.proxy.proxy_server import (
     ProxyStartupEvent,
-    initialize_shared_aiohttp_session,
     _resolve_pydantic_type,
     _resolve_typed_dict_type,
     cleanup_router_config_variables,
@@ -43,6 +43,7 @@ from litellm.proxy.proxy_server import (
     get_litellm_model_info,
     initialize,
     initialize_from_worker_config,
+    initialize_shared_aiohttp_session,
     load_from_azure_key_vault,
     proxy_shutdown_event,
     proxy_startup_event,
@@ -50,8 +51,6 @@ from litellm.proxy.proxy_server import (
     save_worker_config,
 )
 
-from litellm.proxy.management_helpers.audit_logs import track_audit_task
-
 from .conftest import normalize
 
 # ---------------------------------------------------------------------------
@@ -1165,7 +1164,7 @@ def test_proxy_startup_event_warns_for_global_budget_without_database():
 
 @pytest.mark.asyncio
 async def test_tuning_baseline_v3_is_created_alongside_the_legacy_row():
-    from litellm.router_utils.auto_router_tuning_baseline import DEFAULT_TUNING_FINGERPRINT
+    from litellm.router_strategy.auto_router.auto_router_tuning_baseline import DEFAULT_TUNING_FINGERPRINT
 
     prisma_client = MagicMock()
     prisma_client.db.litellm_config.find_unique = AsyncMock(return_value=None)
@@ -1186,7 +1185,10 @@ async def test_tuning_baseline_v3_is_created_alongside_the_legacy_row():
 
 @pytest.mark.asyncio
 async def test_scorer_baseline_upgrade_preserves_existing_routers_and_is_not_refreshed_on_restart():
-    from litellm.router_utils.auto_router_tuning_baseline import mutable_tuned_identities, snapshot_tuning_baselines
+    from litellm.router_strategy.auto_router.auto_router_tuning_baseline import (
+        mutable_tuned_identities,
+        snapshot_tuning_baselines,
+    )
 
     deployments = [
         {
diff --git a/tests/unit/proxy/proxy_server/test_routes_queue.py b/tests/unit/proxy/proxy_server/test_routes_queue.py
index a86314e3063..5cbf89f5e68 100644
--- a/tests/unit/proxy/proxy_server/test_routes_queue.py
+++ b/tests/unit/proxy/proxy_server/test_routes_queue.py
@@ -191,6 +191,54 @@ def test_queue_chat_completions_rejects_a_request_it_cannot_queue_as_an_invalid_
     assert add_request.await_count == 0
 
 
+@pytest.mark.parametrize(
+    ("default_priority", "priority_header", "priority_fields", "expected_priority"),
+    [
+        (5, "0", {"priority": 5}, 0),
+        (5, "0", {}, 0),
+        (None, "high", {"priority": 1, "drop_params": True}, 1),
+        (None, "", {"priority": 1}, 1),
+    ],
+    ids=("header-beats-body", "header-only", "drop-params-keeps-body", "empty-header-keeps-body"),
+)
+def test_queue_chat_completions_queues_at_the_priority_header(
+    client,
+    auth_as,
+    monkeypatch: pytest.MonkeyPatch,
+    default_priority: int | None,
+    priority_header: str,
+    priority_fields: dict[str, object],
+    expected_priority: int,
+) -> None:
+    router: Final = _queue_router(monkeypatch, default_priority=default_priority)
+    payload: Final = {"model": "gpt-4", "messages": [{"role": "user", "content": "hi"}], **priority_fields}
+    with patch.object(router.scheduler, "add_request", wraps=router.scheduler.add_request) as add_request:
+        with auth_as():
+            response: Final = client.post(
+                "/queue/chat/completions", json=payload, headers={"x-litellm-priority": priority_header}
+            )
+    assert response.status_code == 200, response.text
+    assert [call.kwargs["request"].priority for call in add_request.await_args_list] == [expected_priority]
+    assert response.headers.get("x-litellm-priority") == str(expected_priority)
+
+
+def test_queue_chat_completions_rejects_a_malformed_priority_header_like_a_malformed_body_value(
+    client, auth_as, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    router: Final = _queue_router(monkeypatch, default_priority=5)
+    payload: Final = {"model": "gpt-4", "messages": [{"role": "user", "content": "hi"}], "priority": 1}
+    with patch.object(router.scheduler, "add_request", wraps=router.scheduler.add_request) as add_request:
+        with auth_as():
+            response: Final = client.post(
+                "/queue/chat/completions", json=payload, headers={"x-litellm-priority": "high"}
+            )
+    assert response.status_code == 400, response.text
+    error: Final = response.json()["error"]
+    assert (error["type"], error["param"]) == ("invalid_request_error", "priority")
+    assert "priority must be an integer" in error["message"]
+    assert add_request.await_count == 0
+
+
 def test_streamed_queue_responses_report_the_priority_the_router_queued_at(
     client, auth_as, monkeypatch: pytest.MonkeyPatch
 ) -> None:
diff --git a/tests/unit/proxy/response_polling/test_response_polling_handler.py b/tests/unit/proxy/response_polling/test_response_polling_handler.py
index 63e38ce533a..42acad28488 100644
--- a/tests/unit/proxy/response_polling/test_response_polling_handler.py
+++ b/tests/unit/proxy/response_polling/test_response_polling_handler.py
@@ -17,7 +17,7 @@ following the OpenAI Response API format.
 import asyncio
 import json
 from datetime import datetime, timezone
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Final, Optional
 from unittest.mock import AsyncMock, Mock, patch
 
 import pytest
@@ -1400,7 +1400,7 @@ def _make_sse_stream(events: list) -> Mock:
 
     async def _body_iterator():
         for event in events:
-            yield f"data: {json.dumps(event)}"
+            yield f"data: {json.dumps(event, ensure_ascii=False)}"
         yield "data: [DONE]"
 
     mock_response = Mock()
@@ -1639,6 +1639,33 @@ class TestBackgroundStreamingTerminalEvents:
         assert final_call.kwargs["status"] == "completed"
         assert final_call.kwargs["usage"] == {"input_tokens": 10, "output_tokens": 50}
 
+    @pytest.mark.asyncio
+    async def test_response_completed_whose_json_holds_unicode_line_separators_keeps_its_output(self) -> None:
+        from litellm.proxy.response_polling.background_streaming import (
+            background_streaming_task,
+        )
+
+        item: Final = {
+            "id": "item_1",
+            "type": "message",
+            "content": [{"type": "output_text", "text": "Line\u2028one\u2029two"}],
+        }
+        events: Final = [
+            {"type": "response.completed", "response": {"id": "resp_123", "status": "completed", "output": [item]}}
+        ]
+        handler: Final = AsyncMock(spec=ResponsePollingHandler)
+
+        with patch(
+            "litellm.proxy.response_polling.background_streaming.ProxyBaseLLMRequestProcessing"
+        ) as MockProcessor:
+            MockProcessor.return_value.base_process_llm_request = AsyncMock(return_value=_make_sse_stream(events))
+            await background_streaming_task(**_make_background_streaming_kwargs("poll_u2028", handler))
+
+        calls: Final = handler.update_state.call_args_list
+        outputs: Final = [call.kwargs["output"] for call in calls if "output" in call.kwargs]
+        assert outputs[-1] == [item]
+        assert calls[-1].kwargs["status"] == "completed"
+
     @pytest.mark.asyncio
     async def test_fallback_status_derived_from_event_type_when_status_field_missing(
         self,
diff --git a/tests/unit/proxy/test_common_request_processing.py b/tests/unit/proxy/test_common_request_processing.py
index 790790459c3..fdcbcbfcd05 100644
--- a/tests/unit/proxy/test_common_request_processing.py
+++ b/tests/unit/proxy/test_common_request_processing.py
@@ -35,6 +35,7 @@ from litellm.constants import (
 )
 from litellm.integrations.custom_logger import CustomLogger
 from litellm.integrations.opentelemetry import UserAPIKeyAuth
+from litellm.proxy.common_utils.user_api_key_cache import UserApiKeyCache
 from litellm.proxy.common_request_processing import (
     ProxyBaseLLMRequestProcessing,
     ProxyConfig,
@@ -513,6 +514,168 @@ class TestProxyBaseLLMRequestProcessing:
         assert exc_info.value.param == "model"
         add_litellm_data_to_request.assert_not_awaited()
 
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        ("path", "route_type", "has_router", "priority_header", "body_priority", "expected_priority"),
+        [
+            ("/v1/chat/completions", "acompletion", True, "0", 5, 0),
+            ("/v1/completions", "atext_completion", True, "0", 5, 0),
+            ("/v1/chat/completions", "acompletion", True, "1", None, 1),
+            ("/v1/completions", "atext_completion", True, "1", None, 1),
+            ("/v1/chat/completions", "acompletion", True, None, 5, 5),
+            ("/v1/chat/completions", "acompletion", True, "", 5, 5),
+            ("/cursor/chat/completions", "aresponses", True, "0", None, None),
+            ("/v1/responses", "aresponses", True, "0", 5, 5),
+            ("/v1/embeddings", "aembedding", True, "0", None, None),
+            ("/v1/chat/completions", "acompletion", False, "0", None, None),
+            ("/v1/chat/completions", "acompletion", False, "0", 5, 5),
+        ],
+        ids=(
+            "chat-header-beats-body",
+            "text-completion-header-beats-body",
+            "chat-header-only",
+            "text-completion-header-only",
+            "chat-body-only",
+            "chat-empty-header-keeps-body",
+            "cursor-responses-route-ignores-header",
+            "responses-keeps-body",
+            "embeddings-ignores-header",
+            "routerless-ignores-header",
+            "routerless-keeps-body",
+        ),
+    )
+    async def test_common_processing_pre_call_logic_applies_priority_header_only_where_the_router_schedules(
+        self,
+        path: str,
+        route_type: Literal["acompletion", "atext_completion", "aresponses", "aembedding"],
+        has_router: bool,
+        priority_header: str | None,
+        body_priority: int | None,
+        expected_priority: str | int | None,
+    ) -> None:
+        from litellm.proxy.proxy_server import ProxyConfig as RealProxyConfig
+
+        header_entries: Final[tuple[tuple[bytes, bytes], ...]] = (
+            () if priority_header is None else ((b"x-litellm-priority", priority_header.encode()),)
+        )
+        request: Final = Request(
+            {
+                "type": "http",
+                "method": "POST",
+                "path": path,
+                "scheme": "http",
+                "server": ("localhost", 4000),
+                "client": ("127.0.0.1", 12345),
+                "query_string": b"",
+                "headers": ((b"content-type", b"application/json"), *header_entries),
+            }
+        )
+        router: Final = (
+            Router(
+                model_list=[
+                    {
+                        "model_name": "qa-model",
+                        "litellm_params": {"model": "openai/gpt-4o", "api_key": "sk-test", "mock_response": "hi"},
+                    }
+                ]
+            )
+            if has_router
+            else None
+        )
+        processing_obj: Final = ProxyBaseLLMRequestProcessing(
+            data={
+                "model": "qa-model",
+                "messages": [{"role": "user", "content": "hi"}],
+                **({"priority": body_priority} if body_priority is not None else {}),
+            }
+        )
+        returned_data, _ = await processing_obj.common_processing_pre_call_logic(
+            request=request,
+            general_settings={},
+            user_api_key_dict=ProxyUserAPIKeyAuth(api_key="sk-test"),
+            proxy_logging_obj=ProxyLogging(user_api_key_cache=UserApiKeyCache()),
+            proxy_config=RealProxyConfig(),
+            route_type=route_type,
+            llm_router=router,
+        )
+
+        assert ("priority" in returned_data, returned_data.get("priority")) == (
+            expected_priority is not None,
+            expected_priority,
+        )
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        ("requested_model", "deployment_drops_params", "body_priority", "expected_priority"),
+        [
+            ("qa-model", True, 5, 5),
+            ("qa-model", True, None, None),
+            ("key-alias", True, 5, 5),
+            ("qa-model", False, 5, "high"),
+        ],
+        ids=(
+            "drop-params-keeps-body",
+            "drop-params-without-body-leaves-default",
+            "drop-params-read-from-the-aliased-deployment",
+            "no-drop-params-passes-header-on-to-400",
+        ),
+    )
+    async def test_common_processing_pre_call_logic_drops_only_a_malformed_priority_header_under_drop_params(
+        self,
+        requested_model: str,
+        deployment_drops_params: bool,
+        body_priority: int | None,
+        expected_priority: str | int | None,
+    ) -> None:
+        from litellm.proxy.proxy_server import ProxyConfig as RealProxyConfig
+
+        request: Final = Request(
+            {
+                "type": "http",
+                "method": "POST",
+                "path": "/v1/chat/completions",
+                "scheme": "http",
+                "server": ("localhost", 4000),
+                "client": ("127.0.0.1", 12345),
+                "query_string": b"",
+                "headers": ((b"content-type", b"application/json"), (b"x-litellm-priority", b"high")),
+            }
+        )
+        router: Final = Router(
+            model_list=[
+                {
+                    "model_name": "qa-model",
+                    "litellm_params": {
+                        "model": "openai/gpt-4o",
+                        "api_key": "sk-test",
+                        "mock_response": "hi",
+                        "drop_params": deployment_drops_params,
+                    },
+                }
+            ]
+        )
+        processing_obj: Final = ProxyBaseLLMRequestProcessing(
+            data={
+                "model": requested_model,
+                "messages": [{"role": "user", "content": "hi"}],
+                **({"priority": body_priority} if body_priority is not None else {}),
+            }
+        )
+        returned_data, _ = await processing_obj.common_processing_pre_call_logic(
+            request=request,
+            general_settings={},
+            user_api_key_dict=ProxyUserAPIKeyAuth(api_key="sk-test", aliases={"key-alias": "qa-model"}),
+            proxy_logging_obj=ProxyLogging(user_api_key_cache=UserApiKeyCache()),
+            proxy_config=RealProxyConfig(),
+            route_type="acompletion",
+            llm_router=router,
+        )
+
+        assert ("priority" in returned_data, returned_data.get("priority")) == (
+            expected_priority is not None,
+            expected_priority,
+        )
+
     @pytest.mark.asyncio
     @pytest.mark.parametrize("safe_memory_mode", [False, True])
     @pytest.mark.parametrize(
diff --git a/tests/unit/responses/litellm_completion_transformation/test_streaming_iterator_transformation.py b/tests/unit/responses/litellm_completion_transformation/test_streaming_iterator_transformation.py
index ed90acbd2fa..0b971bc1696 100644
--- a/tests/unit/responses/litellm_completion_transformation/test_streaming_iterator_transformation.py
+++ b/tests/unit/responses/litellm_completion_transformation/test_streaming_iterator_transformation.py
@@ -1288,6 +1288,106 @@ async def test_reasoning_item_closes_before_a_tool_call_from_the_same_chunk_open
     ]
 
 
+def _text_opening_a_tool_call_chunk(content: str, arguments: str = "") -> ModelResponseStream:
+    return ModelResponseStream(
+        id=CHAT_COMPLETION_ID,
+        created=1748575031,
+        model="claude-haiku-5-5",
+        object="chat.completion.chunk",
+        choices=[
+            StreamingChoices(
+                index=0,
+                delta=Delta(
+                    role="assistant",
+                    content=content,
+                    tool_calls=[
+                        {
+                            "id": "call_weather",
+                            "type": "function",
+                            "function": {"name": "get_weather", "arguments": arguments},
+                            "index": 0,
+                        }
+                    ],
+                ),
+                finish_reason=None,
+            )
+        ],
+    )
+
+
+def _tool_arguments_chunk(arguments: str, finish_reason: str | None = None) -> ModelResponseStream:
+    return ModelResponseStream(
+        id=CHAT_COMPLETION_ID,
+        created=1748575031,
+        model="claude-haiku-5-5",
+        object="chat.completion.chunk",
+        choices=[
+            StreamingChoices(
+                index=0,
+                delta=Delta(
+                    content=None,
+                    tool_calls=[{"type": "function", "function": {"arguments": arguments}, "index": 0}],
+                ),
+                finish_reason=finish_reason,
+            )
+        ],
+    )
+
+
+@pytest.mark.parametrize("sync_mode", [True, False])
+@pytest.mark.asyncio
+async def test_tool_call_opened_in_a_text_chunk_streams_each_argument_delta(sync_mode: bool) -> None:
+    argument_pieces: Final = ('{"', "city", '"', ': "', "Paris", '"', "}")
+    iterator: Final = _build_iterator(
+        [
+            _text_opening_a_tool_call_chunk("</think>"),
+            *(_tool_arguments_chunk(piece) for piece in argument_pieces),
+            _chunk("", finish_reason="tool_calls"),
+        ]
+    )
+
+    events: Final = await _collect_events(iterator, sync_mode)
+
+    assert _event_text(events, ResponsesAPIStreamEvents.OUTPUT_TEXT_DELTA) == "</think>"
+    assert [
+        event.delta
+        for event in events
+        if getattr(event, "type", None) == ResponsesAPIStreamEvents.FUNCTION_CALL_ARGUMENTS_DELTA
+    ] == list(argument_pieces)
+
+
+@pytest.mark.parametrize("sync_mode", [True, False])
+@pytest.mark.asyncio
+async def test_tool_call_sharing_a_chunk_with_text_opens_after_the_whole_message(sync_mode: bool) -> None:
+    iterator: Final = _build_iterator(
+        [
+            _text_opening_a_tool_call_chunk("Checking ", arguments='{"city": "Paris"}'),
+            _chunk("the "),
+            _chunk("weather now."),
+            _chunk("", finish_reason="tool_calls"),
+        ]
+    )
+
+    events: Final = await _collect_events(iterator, sync_mode)
+
+    event_types: Final = [getattr(event, "type", None) for event in events]
+    function_call_added_at: Final = next(
+        position
+        for position, event in enumerate(events)
+        if event_types[position] == ResponsesAPIStreamEvents.OUTPUT_ITEM_ADDED and event.item.type == "function_call"
+    )
+    streamed: Final = [
+        event
+        for event in events
+        if getattr(event, "type", None)
+        in (ResponsesAPIStreamEvents.OUTPUT_TEXT_DELTA, ResponsesAPIStreamEvents.FUNCTION_CALL_ARGUMENTS_DELTA)
+    ]
+    assert ResponsesAPIStreamEvents.OUTPUT_TEXT_DELTA not in event_types[function_call_added_at:]
+    assert [event.sequence_number for event in streamed] == sorted(event.sequence_number for event in streamed)
+    assert _event_text(events, ResponsesAPIStreamEvents.OUTPUT_TEXT_DELTA) == "Checking the weather now."
+    assert _event_text(events, ResponsesAPIStreamEvents.FUNCTION_CALL_ARGUMENTS_DELTA) == '{"city": "Paris"}'
+
+
 @pytest.mark.parametrize("sync_mode", [True, False])
 @pytest.mark.asyncio
 async def test_tool_only_stream_puts_the_function_call_at_output_index_zero(sync_mode: bool):
diff --git a/tests/unit/router_utils/test_auto_router_model_naming.py b/tests/unit/router_strategy/test_auto_router_model_naming.py
similarity index 99%
rename from tests/unit/router_utils/test_auto_router_model_naming.py
rename to tests/unit/router_strategy/test_auto_router_model_naming.py
index 1cfa3aa5c91..44fcfdaf5be 100644
--- a/tests/unit/router_utils/test_auto_router_model_naming.py
+++ b/tests/unit/router_strategy/test_auto_router_model_naming.py
@@ -3,9 +3,7 @@ from typing import Final
 
 import pytest
 
-from litellm.router_strategy.complexity_router.fuse_presets import get_fuse_presets
-from litellm.router_strategy.complexity_router.jev_classifier import DEFAULT_JEV_INSTRUCTIONS
-from litellm.router_utils.auto_router_model_naming import (
+from litellm.router_strategy.auto_router.auto_router_model_naming import (
     GATED_AUTO_ROUTER_CAPABILITIES,
     capability_limit_violation,
     carries_complexity_router_settings,
@@ -18,6 +16,8 @@ from litellm.router_utils.auto_router_model_naming import (
     validate_complexity_router_config_write,
     validate_strategy_router_model_write,
 )
+from litellm.router_strategy.complexity_router.fuse_presets import get_fuse_presets
+from litellm.router_strategy.complexity_router.jev_classifier import DEFAULT_JEV_INSTRUCTIONS
 
 COMPLEXITY_FIELDS = frozenset({"complexity_router_config"})
 SEMANTIC_FIELDS = frozenset({"auto_router_config", "auto_router_default_model", "auto_router_embedding_model"})
@@ -596,7 +596,7 @@ def test_custom_classifier_prompt_capability(config: Mapping[str, object], expec
     ],
 )
 def test_is_complexity_router_model(model: str | None, expected: bool) -> None:
-    from litellm.router_utils.auto_router_model_naming import is_complexity_router_model
+    from litellm.router_strategy.auto_router.auto_router_model_naming import is_complexity_router_model
 
     assert is_complexity_router_model(model) is expected
 
diff --git a/tests/unit/router_utils/test_auto_router_tuning_baseline.py b/tests/unit/router_strategy/test_auto_router_tuning_baseline.py
similarity index 99%
rename from tests/unit/router_utils/test_auto_router_tuning_baseline.py
rename to tests/unit/router_strategy/test_auto_router_tuning_baseline.py
index d0d98ce7042..4ee219a7784 100644
--- a/tests/unit/router_utils/test_auto_router_tuning_baseline.py
+++ b/tests/unit/router_strategy/test_auto_router_tuning_baseline.py
@@ -7,8 +7,7 @@ from typing import Final
 
 import pytest
 
-from litellm.router_strategy.complexity_router.config import ComplexityRouterConfig
-from litellm.router_utils.auto_router_tuning_baseline import (
+from litellm.router_strategy.auto_router.auto_router_tuning_baseline import (
     DEFAULT_TUNING_FINGERPRINT,
     HEURISTIC_V1_TUNING_FIELDS,
     heuristic_v1_router_fingerprint,
@@ -19,6 +18,7 @@ from litellm.router_utils.auto_router_tuning_baseline import (
     tuning_limit_violation,
     tuning_quota_violation,
 )
+from litellm.router_strategy.complexity_router.config import ComplexityRouterConfig
 
 _TIERS = {"SIMPLE": "cheap", "MEDIUM": "mid", "COMPLEX": "strong", "REASONING": "top"}
 _ALT_TIERS = {**_TIERS, "COMPLEX": "other-strong"}
diff --git a/tests/unit/router_utils/test_baseline_request.py b/tests/unit/router_strategy/test_baseline_request.py
similarity index 95%
rename from tests/unit/router_utils/test_baseline_request.py
rename to tests/unit/router_strategy/test_baseline_request.py
index 37d21597752..eb785a41d63 100644
--- a/tests/unit/router_utils/test_baseline_request.py
+++ b/tests/unit/router_strategy/test_baseline_request.py
@@ -1,6 +1,6 @@
 from typing import Final
 
-from litellm.router_utils.baseline_request import baseline_request, capture_baseline_parameters
+from litellm.router_strategy.auto_router.baseline_request import baseline_request, capture_baseline_parameters
 
 
 def test_baseline_snapshot_owns_nested_caller_settings_and_overrides_routed_settings() -> None:
diff --git a/tests/unit/router_strategy/test_complexity_router.py b/tests/unit/router_strategy/test_complexity_router.py
index ca39c7f5c8f..018f93779a6 100644
--- a/tests/unit/router_strategy/test_complexity_router.py
+++ b/tests/unit/router_strategy/test_complexity_router.py
@@ -24,14 +24,6 @@ from pydantic import TypeAdapter, ValidationError
 
 import litellm
 from litellm import Router
-from litellm.integrations.custom_logger import CustomLogger
-from litellm.types.utils import StandardLoggingRoutingDecision
-from litellm.router_utils.auto_router_model_naming import (
-    CUSTOMIZATION_CAPABILITY,
-    GATED_AUTO_ROUTER_CAPABILITIES,
-    HEURISTIC_V2_CAPABILITY,
-    count_capability_routers,
-)
 from litellm._logging import verbose_router_logger
 from litellm.caching.dual_cache import DualCache
 from litellm.caching.in_memory_cache import InMemoryCache
@@ -42,7 +34,19 @@ from litellm.constants import (
     RETURN_RAW_MODEL_NAME_METADATA_KEY,
     SESSION_ID_GENERATED_METADATA_KEY,
 )
+from litellm.integrations.custom_logger import CustomLogger
+from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
 from litellm.router import as_output_cap, stamped_client_ceiling
+from litellm.router_strategy.auto_router.auto_router_model_naming import (
+    CUSTOMIZATION_CAPABILITY,
+    GATED_AUTO_ROUTER_CAPABILITIES,
+    HEURISTIC_V2_CAPABILITY,
+    count_capability_routers,
+)
+from litellm.router_strategy.complexity_router.capability_classifier import (
+    CAPABILITY_CLASSIFIER_SYSTEM_PROMPT,
+    CapabilityClassifierVerdict,
+)
 from litellm.router_strategy.complexity_router.complexity_router import (
     _CLASSIFICATION_CURRENT_MESSAGE_ONLY,
     _CLASSIFICATION_WITH_CONVERSATION,
@@ -58,18 +62,14 @@ from litellm.router_strategy.complexity_router.complexity_router import (
     classification_system_prompt,
     custom_tier_classification_prompt,
 )
-from litellm.router_strategy.complexity_router.capability_classifier import (
-    CAPABILITY_CLASSIFIER_SYSTEM_PROMPT,
-    CapabilityClassifierVerdict,
-)
 from litellm.router_strategy.complexity_router.config import (
-    CapabilityCalibrationConfig,
-    CapabilityClassifierConfig,
     DEFAULT_CLASSIFICATION_RUBRIC,
     DEFAULT_CLASSIFIER_CONTEXT_WINDOW_SIZE,
     DEFAULT_COMPLEXITY_CONFIG,
     DEFAULT_TECHNICAL_KEYWORDS,
     TIER_SEVERITY_ORDER,
+    CapabilityCalibrationConfig,
+    CapabilityClassifierConfig,
     ClassificationRubric,
     ClassifierLLMConfig,
     ComplexityRouterConfig,
@@ -83,10 +83,12 @@ from litellm.router_strategy.complexity_router.jev_classifier import (
     JevUsage,
 )
 from litellm.router_strategy.complexity_router.llm_v2 import LLM_V2_PROMPT_VERSION
+from litellm.router_strategy.complexity_router.request_models import RequestComplexityRouterConfig
 from litellm.router_strategy.complexity_router.tier_predictor import (
     TierGlobalStatistic,
     TrainedTierArtifact,
 )
+from litellm.types.llms.openai import ResponsesAPIResponse
 from litellm.types.router import (
     Deployment,
     LiteLLM_Params,
@@ -94,10 +96,7 @@ from litellm.types.router import (
     RouterErrors,
     TaggedPreRoutingStrategy,
 )
-from litellm.types.llms.openai import ResponsesAPIResponse
-from litellm.router_strategy.complexity_router.request_models import RequestComplexityRouterConfig
-from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
-
+from litellm.types.utils import StandardLoggingRoutingDecision
 
 requires_semantic_router = pytest.mark.skipif(
     sys.version_info >= (3, 14), reason="The semantic-router extra excludes Python 3.14"
@@ -16299,7 +16298,6 @@ class TestTierHealthFailover:
         tests can prove the probe passes a kwargs copy and forwards the prompt arguments.
         """
         import litellm as litellm_module
-
         from litellm.types.router import RouterRateLimitError
 
         probed_kwargs = []
diff --git a/tests/unit/router_strategy/test_llm_v2.py b/tests/unit/router_strategy/test_llm_v2.py
index 3fd2e8808e7..8c1e9e48661 100644
--- a/tests/unit/router_strategy/test_llm_v2.py
+++ b/tests/unit/router_strategy/test_llm_v2.py
@@ -4,11 +4,12 @@ from typing import Final
 from unittest.mock import AsyncMock, MagicMock
 
 import pytest
-import litellm
 from pydantic import ValidationError
 
+import litellm
 from litellm import ModelResponse, Router
 from litellm.caching.dual_cache import DualCache
+from litellm.router_strategy.auto_router.auto_router_model_naming import strategy_router_dependencies
 from litellm.router_strategy.complexity_router.complexity_router import ComplexityRouter
 from litellm.router_strategy.complexity_router.config import ComplexityRouterConfig, ComplexityTier
 from litellm.router_strategy.complexity_router.fuse_presets import get_fuse_presets
@@ -21,7 +22,6 @@ from litellm.router_strategy.complexity_router.llm_v2 import (
     LLMV2Verdict,
     llm_v2_response_format,
 )
-from litellm.router_utils.auto_router_model_naming import strategy_router_dependencies
 from litellm.types.llms.openai import ResponsesAPIResponse
 
 
diff --git a/tests/unit/router_utils/test_cooldown_handlers.py b/tests/unit/router_utils/test_cooldown_handlers.py
index 24459a5a250..2e1e3acaabb 100644
--- a/tests/unit/router_utils/test_cooldown_handlers.py
+++ b/tests/unit/router_utils/test_cooldown_handlers.py
@@ -3150,8 +3150,6 @@ BENCHED: Final = (litellm.Timeout, litellm.Timeout, RouterRateLimitError, Router
             {},
             BENCHED,
         ),
-        ({"allowed_fails": 1, "fallbacks": [{"test-model": "backup-model"}]}, {}, BENCHED),
-        ({"allowed_fails": 1, "default_fallbacks": "backup-model"}, {}, BENCHED),
     ],
     ids=[
         "allowed_fails",
@@ -3160,8 +3158,6 @@ BENCHED: Final = (litellm.Timeout, litellm.Timeout, RouterRateLimitError, Router
         "policy_names_timeout",
         "allowed_fails_with_a_fallback_group",
         "allowed_fails_with_a_dict_fallback_target",
-        "allowed_fails_with_a_string_fallback_target",
-        "allowed_fails_with_a_string_default_fallbacks",
     ],
 )
 @pytest.mark.asyncio
@@ -3207,7 +3203,8 @@ async def test_router_allowed_fails_benches_a_lone_deployment_only_when_the_poli
 def test_has_fallback_group_reads_string_targets_and_skips_unparseable_entries(
     fallbacks: Sequence[Mapping[str, object]], expected: bool
 ) -> None:
-    router: Final = Router(model_list=[TIMED_OUT_DEPLOYMENT], fallbacks=list(fallbacks))
+    router: Final = Router(model_list=[TIMED_OUT_DEPLOYMENT])
+    router.fallbacks = list(fallbacks)
 
     assert _has_fallback_group(router, "test-model") is expected
 
diff --git a/tests/unit/sandbox/test_e2b_sandbox.py b/tests/unit/sandbox/test_e2b_sandbox.py
index e01b9120416..e58392ca266 100644
--- a/tests/unit/sandbox/test_e2b_sandbox.py
+++ b/tests/unit/sandbox/test_e2b_sandbox.py
@@ -7,6 +7,7 @@ integration tests live in tests/integration/sandbox/test_e2b_sandbox.py.
 """
 
 import json
+from typing import Final
 
 import httpx
 import pytest
@@ -19,19 +20,18 @@ from litellm.llms.e2b.sandbox.transformation import (
 )
 
 
+def _line_stream(lines: list[str]) -> httpx.Response:
+    return httpx.Response(200, stream=httpx.ByteStream("".join(f"{line}\n" for line in lines).encode()))
+
+
 class FakeResponse:
-    def __init__(self, *, json_data=None, lines=None, status_code=200):
+    def __init__(self, *, json_data: object = None, status_code: int = 200) -> None:
         self._json = json_data
-        self._lines = lines or []
         self.status_code = status_code
 
     def json(self):
         return self._json
 
-    async def aiter_lines(self):
-        for line in self._lines:
-            yield line
-
 
 class FakeHTTPClient:
     """Records outbound requests and returns canned responses keyed by URL."""
@@ -61,7 +61,7 @@ class FakeHTTPClient:
         if url.endswith("/execute"):
             if self.execute_raises is not None:
                 raise self.execute_raises
-            return FakeResponse(lines=self.execute_lines)
+            return _line_stream(self.execute_lines)
         raise AssertionError(f"unexpected POST {url}")
 
     async def delete(self, url, headers=None, **kwargs):
@@ -249,6 +249,20 @@ def test_parse_lines_skips_non_json_lines():
     assert result.error is None
 
 
+@pytest.mark.asyncio
+async def test_run_code_keeps_unicode_line_separators_inside_stdout() -> None:
+    separated_text: Final = "before\u2028between\u2029after\n"
+    client: Final = FakeHTTPClient(
+        execute_lines=[json.dumps({"type": "stdout", "text": separated_text, "timestamp": 1}, ensure_ascii=False)]
+    )
+    handle: Final = ContainerHandle(id="sbx_sep", provider="e2b", domain="e2b.app")
+    handle._hidden_params = {"envd_access_token": "tok"}
+
+    result: Final = await E2BSandboxConfig().arun_code(container=handle, code="print(text)", client=client)
+
+    assert result.stdout == separated_text
+
+
 @pytest.mark.asyncio
 async def test_run_code_aborts_on_output_over_cap():
     big_line = "x" * (MAX_OUTPUT_BYTES + 1)
diff --git a/tests/unit/sandbox/test_opensandbox_sandbox.py b/tests/unit/sandbox/test_opensandbox_sandbox.py
index 2928dea100e..36ae848786c 100644
--- a/tests/unit/sandbox/test_opensandbox_sandbox.py
+++ b/tests/unit/sandbox/test_opensandbox_sandbox.py
@@ -27,10 +27,13 @@ def sse(data):
     return f"data: {json.dumps(data)}"
 
 
+def _line_stream(lines: list[str]) -> httpx.Response:
+    return httpx.Response(200, stream=httpx.ByteStream("".join(f"{line}\n" for line in lines).encode()))
+
+
 class FakeResponse:
-    def __init__(self, *, json_data=None, lines=None, status_code=200):
+    def __init__(self, *, json_data: object = None, status_code: int = 200) -> None:
         self._json = json_data
-        self._lines = lines or []
         self.status_code = status_code
 
     def json(self):
@@ -40,10 +43,6 @@ class FakeResponse:
         if self.status_code >= 400:
             raise http_status_error(self.status_code)
 
-    async def aiter_lines(self):
-        for line in self._lines:
-            yield line
-
 
 class FakeHTTPClient:
     def __init__(
@@ -93,7 +92,7 @@ class FakeHTTPClient:
         if url.endswith("/code"):
             if self.execute_raises is not None:
                 raise self.execute_raises
-            return FakeResponse(lines=self.execute_lines)
+            return _line_stream(self.execute_lines)
         raise AssertionError(f"unexpected POST {url}")
 
     async def get(self, url, headers=None, params=None, **kwargs):
diff --git a/tests/unit/test_groq_streaming_encoding.py b/tests/unit/test_groq_streaming_encoding.py
index ffe87fb9890..37f05272f67 100644
--- a/tests/unit/test_groq_streaming_encoding.py
+++ b/tests/unit/test_groq_streaming_encoding.py
@@ -6,148 +6,58 @@ UTF-8 encoded content in streaming responses, specifically fixing
 the ASCII encoding error described in issue #12660.
 """
 
-import asyncio
-from unittest.mock import AsyncMock, Mock
+import json
+from typing import Final
+from unittest.mock import Mock
 
+import httpx
 import pytest
 
+from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler, HTTPHandler
 from litellm.llms.openai_like.chat.handler import make_call, make_sync_call
 
-
-class MockResponse:
-    """Mock httpx response for testing UTF-8 handling."""
-
-    def __init__(self, test_content: str):
-        self.test_content = test_content
-        self.status_code = 200
-
-    def iter_text(self, encoding="utf-8"):
-        """Mock iter_text that yields content with the specified encoding."""
-        yield self.test_content
-
-    async def aiter_text(self, encoding="utf-8"):
-        """Mock aiter_text that yields content with the specified encoding."""
-        yield self.test_content
-
-    def iter_lines(self):
-        """Mock iter_lines method for synchronous streaming."""
-        yield self.test_content
-
-    async def aiter_lines(self):
-        """Mock aiter_lines method for asynchronous streaming."""
-        yield self.test_content
-
-    def json(self):
-        return {"choices": [{"delta": {"content": "test"}}]}
+_UNICODE_TEXTS: Final = (
+    "The symbol µ represents micro",
+    "Testing © character",
+    "Testing ™ character",
+    "Testing € character",
+    "Testing 北京 character",
+    "Testing 🚀 character",
+    "Testing Ñoño character",
+)
 
 
-class MockSyncClient:
-    """Mock synchronous HTTP client for testing."""
-
-    def __init__(self, response_content: str):
-        self.response_content = response_content
-
-    def post(self, *args, **kwargs):
-        return MockResponse(self.response_content)
+def _utf8_stream_transport(text: str) -> httpx.MockTransport:
+    chunk: Final = {"choices": [{"index": 0, "delta": {"content": text}}]}
+    body: Final = f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n".encode()
+    return httpx.MockTransport(lambda request: httpx.Response(200, stream=httpx.ByteStream(body)))
 
 
-class MockAsyncClient:
-    """Mock asynchronous HTTP client for testing."""
-
-    def __init__(self, response_content: str):
-        self.response_content = response_content
-
-    async def post(self, *args, **kwargs):
-        return MockResponse(self.response_content)
+def _call_args() -> dict[str, object]:
+    return {
+        "api_base": "https://test.com/v1/chat/completions",
+        "headers": {"Authorization": "Bearer test"},
+        "data": '{"model": "test", "messages": []}',
+        "model": "test-model",
+        "messages": [],
+        "logging_obj": Mock(),
+    }
 
 
-def test_utf8_streaming_sync():
-    """Test that synchronous streaming handles UTF-8 characters correctly."""
-    # Content with the µ character that was causing issues
-    test_content = (
-        'data: {"choices":[{"delta":{"content":"The symbol µ represents micro"}}]}\n\n'
+@pytest.mark.parametrize("text", _UNICODE_TEXTS)
+def test_utf8_streaming_sync(text: str) -> None:
+    completion_stream: Final = make_sync_call(
+        client=HTTPHandler(client=httpx.Client(transport=_utf8_stream_transport(text))), **_call_args()
     )
 
-    mock_client = MockSyncClient(test_content)
-    mock_logging = Mock()
-
-    # This should not raise an ASCII encoding error
-    completion_stream = make_sync_call(
-        client=mock_client,
-        api_base="https://test.com/v1/chat/completions",
-        headers={"Authorization": "Bearer test"},
-        data='{"model": "test", "messages": []}',
-        model="test-model",
-        messages=[],
-        logging_obj=mock_logging,
-    )
-
-    # Verify we can iterate through the stream without encoding errors
-    assert completion_stream is not None
+    assert "".join(chunk["text"] for chunk in completion_stream) == text
 
 
 @pytest.mark.asyncio
-async def test_utf8_streaming_async():
-    """Test that asynchronous streaming handles UTF-8 characters correctly."""
-    # Content with the µ character that was causing issues
-    test_content = (
-        'data: {"choices":[{"delta":{"content":"The symbol µ represents micro"}}]}\n\n'
+@pytest.mark.parametrize("text", _UNICODE_TEXTS)
+async def test_utf8_streaming_async(text: str) -> None:
+    completion_stream: Final = await make_call(
+        client=AsyncHTTPHandler(transport=_utf8_stream_transport(text)), **_call_args()
     )
 
-    mock_client = MockAsyncClient(test_content)
-    mock_logging = Mock()
-
-    # This should not raise an ASCII encoding error
-    completion_stream = await make_call(
-        client=mock_client,
-        api_base="https://test.com/v1/chat/completions",
-        headers={"Authorization": "Bearer test"},
-        data='{"model": "test", "messages": []}',
-        model="test-model",
-        messages=[],
-        logging_obj=mock_logging,
-    )
-
-    # Verify we can iterate through the stream without encoding errors
-    assert completion_stream is not None
-
-
-def test_various_unicode_characters():
-    """Test streaming with various Unicode characters that could cause issues."""
-    unicode_test_cases = [
-        "µ",  # Micro symbol (the original issue)
-        "©",  # Copyright symbol
-        "™",  # Trademark symbol
-        "€",  # Euro symbol
-        "北京",  # Chinese characters
-        "🚀",  # Emoji
-        "Ñoño",  # Spanish characters with tildes
-    ]
-
-    for unicode_char in unicode_test_cases:
-        test_content = f'data: {{"choices":[{{"delta":{{"content":"Testing {unicode_char} character"}}}}]}}\n\n'
-
-        mock_client = MockSyncClient(test_content)
-        mock_logging = Mock()
-
-        # This should not raise an ASCII encoding error for any Unicode character
-        completion_stream = make_sync_call(
-            client=mock_client,
-            api_base="https://test.com/v1/chat/completions",
-            headers={"Authorization": "Bearer test"},
-            data='{"model": "test", "messages": []}',
-            model="test-model",
-            messages=[],
-            logging_obj=mock_logging,
-        )
-
-        assert (
-            completion_stream is not None
-        ), f"Failed to handle Unicode character: {unicode_char}"
-
-
-if __name__ == "__main__":
-    test_utf8_streaming_sync()
-    asyncio.run(test_utf8_streaming_async())
-    test_various_unicode_characters()
-    print("All UTF-8 streaming tests passed!")
+    assert "".join([chunk["text"] async for chunk in completion_stream]) == text
diff --git a/tests/unit/test_private_usage_aliases.py b/tests/unit/test_private_usage_aliases.py
index 1d9c2e87100..d0c5c8247d3 100644
--- a/tests/unit/test_private_usage_aliases.py
+++ b/tests/unit/test_private_usage_aliases.py
@@ -1969,7 +1969,7 @@ ALIAS_CASES: Final = (
     ("litellm.router_utils.add_retry_fallback_headers", "HiddenParamsAsyncIteratorWrapper", "_inner", "inner", True),
     ("litellm.router_utils.add_retry_fallback_headers", "", "_HiddenParamsHost", "HiddenParamsHost", False),
     (
-        "litellm.router_utils.batch_utils",
+        "litellm.litellm_core_utils.batch_utils",
         "",
         "_get_router_metadata_variable_name",
         "get_router_metadata_variable_name",
diff --git a/tests/unit/test_router/test_enforce_model_rate_limits.py b/tests/unit/test_router/test_enforce_model_rate_limits.py
index 7577064b7f9..2a260fdf0b8 100644
--- a/tests/unit/test_router/test_enforce_model_rate_limits.py
+++ b/tests/unit/test_router/test_enforce_model_rate_limits.py
@@ -6,7 +6,7 @@ regardless of the routing strategy being used.
 """
 
 import asyncio
-from datetime import timedelta
+from datetime import datetime, timedelta, timezone
 from unittest.mock import AsyncMock, MagicMock
 
 import pytest
@@ -222,11 +222,9 @@ class TestModelRateLimitingCheck:
 
         check.log_success_event(kwargs, None, None, None)
 
-        # Verify increment_cache was called
-        mock_cache.increment_cache.assert_called_once()
-        _, kwarg_params = mock_cache.increment_cache.call_args
-        assert "test-id:gpt-4:tpm:" in kwarg_params["key"]
-        assert kwarg_params["value"] == 50
+        keys = tuple(call.kwargs["key"] for call in mock_cache.increment_cache.call_args_list)
+        assert any(key.startswith("test-id:gpt-4:tpm:") for key in keys), keys
+        assert all(call.kwargs["value"] == 50 for call in mock_cache.increment_cache.call_args_list)
 
 
 class TestModelRateLimitingCheckAsync:
@@ -253,7 +251,7 @@ class TestModelRateLimitingCheckAsync:
         """Test that RateLimitError is raised when RPM limit is exceeded (async)."""
         mock_cache = MagicMock()
         mock_cache.async_get_cache = AsyncMock(return_value=None)
-        mock_cache.async_increment_cache = AsyncMock(return_value=11)  # Over limit
+        mock_cache.async_increment_cache_pipeline = AsyncMock(return_value=[11.0])  # Over limit
 
         check = ModelRateLimitingCheck(dual_cache=mock_cache)
 
@@ -274,7 +272,7 @@ class TestModelRateLimitingCheckAsync:
         """Test that requests are allowed when under the limit (async)."""
         mock_cache = MagicMock()
         mock_cache.async_get_cache = AsyncMock(return_value=None)
-        mock_cache.async_increment_cache = AsyncMock(return_value=6)
+        mock_cache.async_increment_cache_pipeline = AsyncMock(return_value=[6.0])
 
         check = ModelRateLimitingCheck(dual_cache=mock_cache)
 
@@ -339,7 +337,7 @@ class TestModelRateLimitingCheckAsync:
     ):
         redis_cache = MagicMock()
         redis_cache.async_get_cache = AsyncMock(side_effect=RedisCircuitBreakerOpenError())
-        redis_cache.async_increment = AsyncMock(return_value=2)
+        redis_cache.async_increment_pipeline = AsyncMock(return_value=[2.0])
         check = ModelRateLimitingCheck(dual_cache=_dual_cache_with_local_tpm(5, redis_cache))
 
         with pytest.raises(litellm.RateLimitError) as exc_info:
@@ -375,11 +373,9 @@ class TestModelRateLimitingCheckAsync:
 
         await check.async_log_success_event(kwargs, None, None, None)
 
-        # Verify async_increment_cache was called
-        mock_cache.async_increment_cache.assert_called_once()
-        _, kwarg_params = mock_cache.async_increment_cache.call_args
-        assert "test-id:gpt-4:tpm:" in kwarg_params["key"]
-        assert kwarg_params["value"] == 50
+        keys = tuple(call.kwargs["key"] for call in mock_cache.async_increment_cache.call_args_list)
+        assert any(key.startswith("test-id:gpt-4:tpm:") for key in keys), keys
+        assert all(call.kwargs["value"] == 50 for call in mock_cache.async_increment_cache.call_args_list)
 
 
 class TestRouterWithEnforceModelRateLimits:
@@ -466,3 +462,265 @@ class TestModelRateLimitConcurrency:
 
         assert len(successes) == 2, f"Expected 2 successes, got {len(successes)}"
         assert len(failures) == 2, f"Expected 2 rate limit errors, got {len(failures)}"
+
+
+DAY_ONE = datetime(2026, 10, 28, 23, 59, 30, tzinfo=timezone.utc)
+RPD_DEPLOYMENT = {
+    "litellm_params": {"model": "gpt-4.1-mini", "rpd": 2},
+    "model_info": {"id": "daily-test-id"},
+    "model_name": "daily-model",
+}
+RPM_AND_RPD_DEPLOYMENT = {**RPD_DEPLOYMENT, "litellm_params": {"model": "gpt-4.1-mini", "rpm": 1, "rpd": 2}}
+
+
+class Clock:
+    def __init__(self, now: datetime):
+        self.now = now
+
+    def __call__(self) -> datetime:
+        return self.now
+
+
+def _pre_call(check: ModelRateLimitingCheck, deployment: dict[str, object]) -> object:
+    return check.pre_call_check(deployment)
+
+
+async def _async_pre_call(check: ModelRateLimitingCheck, deployment: dict[str, object]) -> object:
+    return await check.async_pre_call_check(deployment)
+
+
+async def _async_log_success(check: ModelRateLimitingCheck, kwargs: dict[str, object]) -> None:
+    await check.async_log_success_event(kwargs, None, None, None)
+
+
+class TestDailyLimits:
+    def test_pre_call_check_rejects_the_request_over_rpd(self):
+        check = ModelRateLimitingCheck(dual_cache=DualCache(), clock=Clock(DAY_ONE))
+
+        assert _pre_call(check, RPD_DEPLOYMENT) == RPD_DEPLOYMENT
+        assert _pre_call(check, RPD_DEPLOYMENT) == RPD_DEPLOYMENT
+        with pytest.raises(litellm.RateLimitError) as exc_info:
+            _pre_call(check, RPD_DEPLOYMENT)
+
+        assert "RPD limit=2, current usage=3" in str(exc_info.value)
+        assert "rpd limit=2. current usage=3. id=daily-test-id, model_group=daily-model" in exc_info.value.response.text
+
+    @pytest.mark.asyncio
+    async def test_async_pre_call_check_rejects_the_request_over_rpd_and_lets_the_router_retry(self):
+        check = ModelRateLimitingCheck(dual_cache=DualCache(), clock=Clock(DAY_ONE))
+
+        assert await _async_pre_call(check, RPD_DEPLOYMENT) == RPD_DEPLOYMENT
+        assert await _async_pre_call(check, RPD_DEPLOYMENT) == RPD_DEPLOYMENT
+        with pytest.raises(litellm.RateLimitError) as exc_info:
+            await _async_pre_call(check, RPD_DEPLOYMENT)
+
+        assert "RPD limit=2" in str(exc_info.value)
+        assert exc_info.value.num_retries is None
+
+    @pytest.mark.asyncio
+    async def test_async_pre_call_check_rejects_once_the_day_tokens_reach_tpd(self):
+        deployment = {**RPD_DEPLOYMENT, "litellm_params": {"model": "gpt-4.1-mini", "tpd": 100}}
+        check = ModelRateLimitingCheck(dual_cache=DualCache(), clock=Clock(DAY_ONE))
+        kwargs = {
+            "standard_logging_object": {
+                "model_id": "daily-test-id",
+                "total_tokens": 60,
+                "hidden_params": {"litellm_model_name": "gpt-4.1-mini"},
+            }
+        }
+
+        await _async_log_success(check, kwargs)
+        assert await _async_pre_call(check, deployment) == deployment
+        await _async_log_success(check, kwargs)
+        with pytest.raises(litellm.RateLimitError) as exc_info:
+            await _async_pre_call(check, deployment)
+
+        assert "TPD limit=100, current usage=120" in str(exc_info.value)
+
+    def test_pre_call_check_minute_rejected_request_does_not_spend_rpd(self):
+        clock = Clock(DAY_ONE)
+        check = ModelRateLimitingCheck(dual_cache=DualCache(), clock=clock)
+
+        assert _pre_call(check, RPM_AND_RPD_DEPLOYMENT) == RPM_AND_RPD_DEPLOYMENT
+        with pytest.raises(litellm.RateLimitError, match="RPM limit=1"):
+            _pre_call(check, RPM_AND_RPD_DEPLOYMENT)
+        clock.now = DAY_ONE - timedelta(minutes=1)
+
+        assert _pre_call(check, RPM_AND_RPD_DEPLOYMENT) == RPM_AND_RPD_DEPLOYMENT
+        clock.now = DAY_ONE - timedelta(minutes=2)
+        with pytest.raises(litellm.RateLimitError, match="RPD limit=2, current usage=3"):
+            _pre_call(check, RPM_AND_RPD_DEPLOYMENT)
+
+    @pytest.mark.asyncio
+    async def test_async_pre_call_check_minute_rejected_request_does_not_spend_rpd(self):
+        clock = Clock(DAY_ONE)
+        check = ModelRateLimitingCheck(dual_cache=DualCache(), clock=clock)
+
+        assert await _async_pre_call(check, RPM_AND_RPD_DEPLOYMENT) == RPM_AND_RPD_DEPLOYMENT
+        with pytest.raises(litellm.RateLimitError, match="RPM limit=1"):
+            await _async_pre_call(check, RPM_AND_RPD_DEPLOYMENT)
+        clock.now = DAY_ONE - timedelta(minutes=1)
+
+        assert await _async_pre_call(check, RPM_AND_RPD_DEPLOYMENT) == RPM_AND_RPD_DEPLOYMENT
+        clock.now = DAY_ONE - timedelta(minutes=2)
+        with pytest.raises(litellm.RateLimitError, match="RPD limit=2, current usage=3"):
+            await _async_pre_call(check, RPM_AND_RPD_DEPLOYMENT)
+
+    def test_pre_call_check_rejected_requests_hand_back_rpm_and_rpd(self):
+        clock = Clock(DAY_ONE)
+        check = ModelRateLimitingCheck(dual_cache=DualCache(), clock=clock)
+
+        assert _pre_call(check, RPM_AND_RPD_DEPLOYMENT) == RPM_AND_RPD_DEPLOYMENT
+        with pytest.raises(litellm.RateLimitError, match="RPM limit=1, current usage=2"):
+            _pre_call(check, RPM_AND_RPD_DEPLOYMENT)
+        with pytest.raises(litellm.RateLimitError, match="RPM limit=1, current usage=2"):
+            _pre_call(check, RPM_AND_RPD_DEPLOYMENT)
+        clock.now = DAY_ONE - timedelta(minutes=1)
+        assert _pre_call(check, RPM_AND_RPD_DEPLOYMENT) == RPM_AND_RPD_DEPLOYMENT
+
+        clock.now = DAY_ONE - timedelta(minutes=2)
+        with pytest.raises(litellm.RateLimitError, match="RPD limit=2, current usage=3"):
+            _pre_call(check, RPM_AND_RPD_DEPLOYMENT)
+        with pytest.raises(litellm.RateLimitError, match="RPD limit=2, current usage=3"):
+            _pre_call(check, RPM_AND_RPD_DEPLOYMENT)
+
+    @pytest.mark.asyncio
+    async def test_async_pre_call_check_rejected_requests_hand_back_rpm_and_rpd(self):
+        clock = Clock(DAY_ONE)
+        check = ModelRateLimitingCheck(dual_cache=DualCache(), clock=clock)
+
+        assert await _async_pre_call(check, RPM_AND_RPD_DEPLOYMENT) == RPM_AND_RPD_DEPLOYMENT
+        with pytest.raises(litellm.RateLimitError, match="RPM limit=1, current usage=2"):
+            await _async_pre_call(check, RPM_AND_RPD_DEPLOYMENT)
+        with pytest.raises(litellm.RateLimitError, match="RPM limit=1, current usage=2"):
+            await _async_pre_call(check, RPM_AND_RPD_DEPLOYMENT)
+        clock.now = DAY_ONE - timedelta(minutes=1)
+        assert await _async_pre_call(check, RPM_AND_RPD_DEPLOYMENT) == RPM_AND_RPD_DEPLOYMENT
+
+        clock.now = DAY_ONE - timedelta(minutes=2)
+        with pytest.raises(litellm.RateLimitError, match="RPD limit=2, current usage=3"):
+            await _async_pre_call(check, RPM_AND_RPD_DEPLOYMENT)
+        with pytest.raises(litellm.RateLimitError, match="RPD limit=2, current usage=3"):
+            await _async_pre_call(check, RPM_AND_RPD_DEPLOYMENT)
+
+    @pytest.mark.asyncio
+    async def test_async_pre_call_check_refunds_rpm_and_rpd_in_one_cache_trip(self):
+        mock_cache = MagicMock()
+        mock_cache.async_get_cache = AsyncMock(return_value=None)
+        mock_cache.async_increment_cache_pipeline = AsyncMock(side_effect=[[1.0, 3.0], [0.0, 2.0]])
+        check = ModelRateLimitingCheck(dual_cache=mock_cache, clock=Clock(DAY_ONE))
+
+        with pytest.raises(litellm.RateLimitError, match="RPD limit=2, current usage=3"):
+            await _async_pre_call(check, RPM_AND_RPD_DEPLOYMENT)
+
+        assert mock_cache.async_increment_cache_pipeline.await_count == 2
+        refund = mock_cache.async_increment_cache_pipeline.call_args_list[1].kwargs["increment_list"]
+        assert [(op["key"], op["increment_value"], op["ttl"]) for op in refund] == [
+            ("daily-test-id:gpt-4.1-mini:rpm:23-59", -1, 60),
+            ("daily-test-id:gpt-4.1-mini:rpd:2026-10-28", -1, 86400),
+        ]
+
+    @pytest.mark.asyncio
+    async def test_async_pre_call_check_increments_rpm_and_rpd_in_one_cache_trip(self):
+        mock_cache = MagicMock()
+        mock_cache.async_get_cache = AsyncMock(return_value=None)
+        mock_cache.async_increment_cache_pipeline = AsyncMock(return_value=[1.0, 1.0])
+        check = ModelRateLimitingCheck(dual_cache=mock_cache, clock=Clock(DAY_ONE))
+
+        assert await _async_pre_call(check, RPM_AND_RPD_DEPLOYMENT) == RPM_AND_RPD_DEPLOYMENT
+
+        assert mock_cache.async_increment_cache_pipeline.await_count == 1
+        operations = mock_cache.async_increment_cache_pipeline.call_args.kwargs["increment_list"]
+        assert [(op["key"], op["ttl"]) for op in operations] == [
+            ("daily-test-id:gpt-4.1-mini:rpm:23-59", 60),
+            ("daily-test-id:gpt-4.1-mini:rpd:2026-10-28", 86400),
+        ]
+        assert not mock_cache.async_increment_cache.called
+
+    def test_pre_call_check_reads_the_shared_tpd_count_from_redis(self):
+        redis_cache = MagicMock()
+        redis_cache.get_cache.return_value = 100
+        deployment = {**RPD_DEPLOYMENT, "litellm_params": {"model": "gpt-4.1-mini", "tpd": 100}}
+        check = ModelRateLimitingCheck(dual_cache=DualCache(redis_cache=redis_cache), clock=Clock(DAY_ONE))
+
+        with pytest.raises(litellm.RateLimitError) as exc_info:
+            _pre_call(check, deployment)
+
+        assert "TPD limit=100, current usage=100" in str(exc_info.value)
+        assert redis_cache.get_cache.call_args.kwargs["key"] == "daily-test-id:gpt-4.1-mini:tpd:2026-10-28"
+
+    def test_rpd_count_starts_fresh_after_utc_midnight(self):
+        clock = Clock(DAY_ONE)
+        check = ModelRateLimitingCheck(dual_cache=DualCache(), clock=clock)
+        _pre_call(check, RPD_DEPLOYMENT)
+        _pre_call(check, RPD_DEPLOYMENT)
+        with pytest.raises(litellm.RateLimitError):
+            _pre_call(check, RPD_DEPLOYMENT)
+
+        clock.now = DAY_ONE + timedelta(seconds=30)
+
+        assert _pre_call(check, RPD_DEPLOYMENT) == RPD_DEPLOYMENT
+        assert _pre_call(check, RPD_DEPLOYMENT) == RPD_DEPLOYMENT
+        with pytest.raises(litellm.RateLimitError) as exc_info:
+            _pre_call(check, RPD_DEPLOYMENT)
+        assert "current usage=3" in str(exc_info.value)
+
+    @pytest.mark.parametrize(
+        ("now", "seconds_to_midnight"),
+        [
+            (DAY_ONE, 30),
+            (datetime(2026, 10, 28, 0, 0, 0, tzinfo=timezone.utc), 86400),
+            (datetime(2026, 10, 28, 12, 30, 15, 500000, tzinfo=timezone.utc), 41384),
+        ],
+    )
+    def test_daily_429_retry_after_is_seconds_until_utc_midnight(self, now: datetime, seconds_to_midnight: int):
+        deployment = {**RPD_DEPLOYMENT, "litellm_params": {"model": "gpt-4.1-mini", "rpd": 0}}
+        check = ModelRateLimitingCheck(dual_cache=DualCache(), clock=Clock(now))
+
+        with pytest.raises(litellm.RateLimitError) as exc_info:
+            _pre_call(check, deployment)
+
+        assert exc_info.value.response.headers["retry-after"] == str(seconds_to_midnight)
+
+    @pytest.mark.asyncio
+    async def test_router_serves_the_request_from_the_other_deployment_once_rpd_is_spent(self):
+        router = Router(
+            model_list=[
+                {
+                    "model_name": "daily-group",
+                    "litellm_params": {
+                        "model": "openai/gpt-4.1-mini",
+                        "api_key": "k",
+                        "mock_response": "a",
+                        "rpd": 1,
+                        "order": 1,
+                    },
+                    "model_info": {"id": "spent-first"},
+                },
+                {
+                    "model_name": "daily-group",
+                    "litellm_params": {
+                        "model": "openai/gpt-4.1-mini",
+                        "api_key": "k",
+                        "mock_response": "b",
+                        "order": 2,
+                    },
+                    "model_info": {"id": "always-free"},
+                },
+            ],
+            num_retries=1,
+        )
+        check = ModelRateLimitingCheck(dual_cache=router.cache, clock=Clock(DAY_ONE))
+        router.optional_callbacks = [check]
+        litellm.logging_callback_manager.add_litellm_callback(check)
+        try:
+            served = [
+                (await router.acompletion(model="daily-group", messages=[{"role": "user", "content": "hi"}]))
+                .choices[0]
+                .message.content
+                for _ in range(4)
+            ]
+        finally:
+            router.discard()
+
+        assert served == ["a", "b", "b", "b"]
diff --git a/tests/unit/test_router/test_io_token_rate_limits.py b/tests/unit/test_router/test_io_token_rate_limits.py
index a5a68271111..0ae22534278 100644
--- a/tests/unit/test_router/test_io_token_rate_limits.py
+++ b/tests/unit/test_router/test_io_token_rate_limits.py
@@ -859,7 +859,7 @@ class TestModelRateLimitingCheckIOTokens:
             with pytest.raises(litellm.RateLimitError):
                 await check.async_pre_call_check(deployment)
 
-        assert await dual_cache.async_get_cache(key=rpm_key) == 6
+        assert await dual_cache.async_get_cache(key=rpm_key) == 5, "the rejected request hands its rpm count back"
         assert (await dual_cache.async_get_cache(key=itpm_key) or 0) == 0
         assert ITPM_RESERVED_KEY not in request_kwargs["metadata"]
         assert any("both limit types are enforced" in record.message for record in caplog.records)
diff --git a/tests/unit/test_router/test_router.py b/tests/unit/test_router/test_router.py
index 3c7a222d9a1..300c9cff6ff 100644
--- a/tests/unit/test_router/test_router.py
+++ b/tests/unit/test_router/test_router.py
@@ -31228,3 +31228,51 @@ async def test_anthropic_caller_rate_limit_does_not_block_other_credentials(
     finally:
         await GLOBAL_LOGGING_WORKER.flush()
         await client.close()
+
+
+_FALLBACK_VALIDATION_MODEL_LIST: Final = (
+    {"model_name": "gpt-4", "litellm_params": {"model": "openai/gpt-4", "api_key": "fake-key"}},
+    {"model_name": "gpt-3.5", "litellm_params": {"model": "openai/gpt-3.5-turbo", "api_key": "fake-key"}},
+)
+
+
+@pytest.mark.parametrize(
+    ("router_kwargs", "expected_message"),
+    [
+        ({"fallbacks": [{"gpt-4": "gpt-3.5"}]}, "Fallbacks for 'gpt-4' must be a list of model names, got 'gpt-3.5'"),
+        ({"default_fallbacks": "gpt-3.5"}, "default_fallbacks must be a list of model names, got 'gpt-3.5'"),
+        (
+            {"content_policy_fallbacks": [{"gpt-4": "gpt-3.5"}]},
+            "Fallbacks for 'gpt-4' must be a list of model names, got 'gpt-3.5'",
+        ),
+    ],
+    ids=["string_fallback_target", "string_default_fallbacks", "string_content_policy_fallback_target"],
+)
+def test_router_rejects_a_string_fallback_target_at_init(
+    router_kwargs: Mapping[str, object], expected_message: str
+) -> None:
+    with pytest.raises(TypeError, match="must be a list of model names") as excinfo:
+        Router(model_list=list(_FALLBACK_VALIDATION_MODEL_LIST), **router_kwargs)
+
+    assert expected_message in str(excinfo.value)
+
+
+@pytest.mark.parametrize(
+    ("router_kwargs", "expected_fallbacks"),
+    [
+        ({"fallbacks": [{"gpt-4": ["gpt-3.5"]}]}, [{"gpt-4": ["gpt-3.5"]}]),
+        ({"default_fallbacks": ["gpt-3.5"]}, [{"*": ["gpt-3.5"]}]),
+        (
+            {"fallbacks": [{"gpt-4": [{"model": "gpt-3.5", "api_key": "other-key"}]}]},
+            [{"gpt-4": [{"model": "gpt-3.5", "api_key": "other-key"}]}],
+        ),
+        ({"fallbacks": [{"model": "gpt-3.5"}]}, [{"model": "gpt-3.5"}]),
+    ],
+    ids=["list_fallback_target", "list_default_fallbacks", "dict_override_fallback_target", "direct_target_entry"],
+)
+def test_router_keeps_supported_fallback_shapes(
+    router_kwargs: Mapping[str, object], expected_fallbacks: list[dict[str, object]]
+) -> None:
+    router: Final = Router(model_list=list(_FALLBACK_VALIDATION_MODEL_LIST), **router_kwargs)
+
+    assert router.fallbacks == expected_fallbacks
diff --git a/tests/unit/test_router/test_router_helper_utils.py b/tests/unit/test_router/test_router_helper_utils.py
index af8e7f53462..513136ae150 100644
--- a/tests/unit/test_router/test_router_helper_utils.py
+++ b/tests/unit/test_router/test_router_helper_utils.py
@@ -4,20 +4,21 @@ import gc
 import json
 import os
 import weakref
-from datetime import datetime, timezone
 from collections.abc import Iterator, Mapping
+from datetime import datetime, timezone
 from types import MethodType
 from typing import Final
 from unittest.mock import AsyncMock, MagicMock, patch
 
-import litellm
 import pytest
+
+import litellm
 from litellm import Router
 from litellm.caching.dual_cache import DualCache
 from litellm.caching.in_memory_cache import InMemoryCache
 from litellm.constants import DEFAULT_AUTO_ROUTER_MAX_INPUT_CHARS, ROUTER_USAGE_COUNTED_TOKENS_METADATA_KEY
-from litellm.integrations.SlackAlerting.slack_alerting import SlackAlerting
 from litellm.integrations.custom_logger import CustomLogger
+from litellm.integrations.SlackAlerting.slack_alerting import SlackAlerting
 from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper
 from litellm.router_strategy.adaptive_router.hooks import AdaptiveRouterPostCallHook
 from litellm.types.litellm_params import RoutingStrategyName
@@ -801,10 +802,11 @@ async def test_deployment_callback_on_failure(model_list):
 
 def test_deployment_callback_respects_cooldown_time(model_list):
     """Ensure per-model cooldown_time is honored even when exception headers are present."""
-    import httpx
     import time
     from unittest.mock import patch
 
+    import httpx
+
     router = Router(model_list=model_list)
 
     class FakeException(Exception):
@@ -1811,8 +1813,8 @@ def test_get_allowed_fails_from_policy(model_list, exception_type, exception_nam
 
 def test_initialize_alerting(model_list):
     """Test if the 'initialize_alerting' function is working correctly"""
-    from litellm.types.router import AlertingConfig
     from litellm.integrations.SlackAlerting.slack_alerting import SlackAlerting
+    from litellm.types.router import AlertingConfig
 
     router = Router(
         model_list=model_list, alerting_config=AlertingConfig(webhook_url="test")
@@ -2245,6 +2247,7 @@ def test_deployments_by_pattern(model_list):
 )
 def test_pattern_match_deployment_set_model_name(user_request_model, model_name, litellm_model, expected_model):
     from re import Match
+
     from litellm.router_utils.pattern_match_deployments import PatternMatchRouter
 
     pattern_router = PatternMatchRouter()
@@ -2702,7 +2705,7 @@ def test_handle_clientside_credential_metadata_loading(model_list, function_name
 )
 def test_handle_clientside_credential_metadata_variable_name(model_list, function_name, metadata_key):
     """Test that _handle_clientside_credential uses the correct metadata variable name based on function name"""
-    from litellm.router_utils.batch_utils import get_router_metadata_variable_name
+    from litellm.litellm_core_utils.batch_utils import get_router_metadata_variable_name
 
     router = Router(model_list=model_list)
 
diff --git a/tests/unit/test_router/test_router_surface_check.py b/tests/unit/test_router/test_router_surface_check.py
new file mode 100644
index 00000000000..a97fd029380
--- /dev/null
+++ b/tests/unit/test_router/test_router_surface_check.py
@@ -0,0 +1,58 @@
+"""
+The router surface fence (tests/code_coverage_tests/router_surface_check.py) must see every way
+outside code reaches a Router member, or new dependencies slip past the shrink-only allowlist.
+"""
+
+import ast
+import importlib.util
+import pathlib
+
+import pytest
+
+_CHECK = pathlib.Path(__file__).parents[2] / "code_coverage_tests" / "router_surface_check.py"
+
+
+@pytest.fixture(scope="module")
+def surface_check():
+    spec = importlib.util.spec_from_file_location("router_surface_check", _CHECK)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _uses(surface_check, src: str) -> set:
+    return surface_check.member_uses(ast.parse(src), surface_check.router_members())
+
+
+def test_instance_and_dynamic_access_are_uses(surface_check):
+    assert _uses(surface_check, "llm_router.get_model_list()\ngetattr(router, 'model_list')") == {
+        "get_model_list",
+        "model_list",
+    }
+
+
+def test_class_level_calls_are_uses(surface_check):
+    assert _uses(surface_check, "litellm.Router.get_valid_args()") == {"get_valid_args"}
+    assert _uses(surface_check, "from litellm import Router\nRouter.get_valid_args()") == {"get_valid_args"}
+
+
+def test_container_file_endpoints_registered_by_name_are_members(surface_check):
+    members = surface_check.router_members()
+    assert {"aupload_container_file", "upload_container_file", "alist_container_files"} <= members
+    assert _uses(surface_check, "await llm_router.aupload_container_file(file=f)") == {"aupload_container_file"}
+
+
+def test_unlisted_class_level_use_fails_the_fence(surface_check):
+    found = {
+        "members": {"outside": {"get_valid_args": {"litellm/new_module.py"}}, "router_family": {}},
+        "router_utils_imports": {},
+    }
+    allow = {"members_outside": [], "members_router_family": [], "router_utils_imports_outside": []}
+    errors = surface_check.compare(allow, found)
+    assert len(errors) == 1
+    assert "'get_valid_args' in litellm/new_module.py" in errors[0]
+
+
+def test_unrelated_receivers_are_not_uses(surface_check):
+    assert _uses(surface_check, "client.get_model_list()\nRouterConfig.model_list") == set()
diff --git a/tests/unit/test_spend_logs_guard.py b/tests/unit/test_spend_logs_guard.py
index 9ac2c923632..eb54099cf8b 100644
--- a/tests/unit/test_spend_logs_guard.py
+++ b/tests/unit/test_spend_logs_guard.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import importlib.util
 import sys
 from pathlib import Path
@@ -12,46 +14,144 @@ guard: Final = importlib.util.module_from_spec(_SPEC)
 sys.modules["spend_logs_guard"] = guard
 _SPEC.loader.exec_module(guard)
 
+SCHEMA: Final = (
+    "generator client {\n"
+    '  provider = "prisma-client-py"\n'
+    "}\n"
+    "\n"
+    "model LiteLLM_TeamTable {\n"
+    "  team_id String @id\n"
+    "}\n"
+    "\n"
+    "model LiteLLM_SpendLogs {\n"
+    "  request_id String @id\n"
+    "  api_key    String\n"
+    '  @@index([api_key], map: "LiteLLM_SpendLogs_api_key_idx")\n'
+    "}\n"
+    "\n"
+    "model LiteLLM_UserTable {\n"
+    "  user_id String @id\n"
+    "}\n"
+)
+_NO_BLOCKS: Final = {}
 
-def _diff(path: str, added: str, start: int = 10) -> str:
-    return f"diff --git a/{path} b/{path}\n--- a/{path}\n+++ b/{path}\n@@ -{start},0 +{start},1 @@\n+{added}\n"
+
+def _hunk(old_start: int, old_count: int, new_start: int, new_count: int, *lines: str) -> str:
+    body: Final = "".join(f"{line}\n" for line in lines)
+    return f"@@ -{old_start},{old_count} +{new_start},{new_count} @@\n{body}"
+
+
+def _diff(path: str, *hunks: str) -> str:
+    return f"diff --git a/{path} b/{path}\n--- a/{path}\n+++ b/{path}\n" + "".join(hunks)
+
+
+def _added(path: str, added: str, start: int = 10) -> str:
+    return _diff(path, _hunk(start, 0, start, 1, f"+{added}"))
+
+
+def _blocks(path: str, base: str = SCHEMA, head: str = SCHEMA) -> dict[str, guard.Block]:
+    return {path: guard.Block(base=guard.model_block(base), head=guard.model_block(head))}
+
+
+def _with_line(schema: str, after: int, line: str) -> str:
+    lines: Final = schema.splitlines(keepends=True)
+    return "".join(lines[:after]) + f"{line}\n" + "".join(lines[after:])
+
+
+class TestModelBlock:
+    def test_the_block_runs_from_the_model_line_through_its_closing_brace(self):
+        assert guard.model_block(SCHEMA) == range(9, 14)
+
+    def test_a_schema_without_the_model_has_an_empty_block(self):
+        assert guard.model_block(SCHEMA.replace("LiteLLM_SpendLogs", "LiteLLM_ErrorLogs")) == range(0)
 
 
 class TestSpendLogHits:
-    def test_an_added_schema_line_naming_the_table_is_a_hit(self):
+    def test_a_field_added_inside_the_block_is_a_hit_without_naming_the_table(self):
+        head: Final = _with_line(SCHEMA, 9, "  gauntlet_probe String?")
+        diff: Final = _added("schema.prisma", "  gauntlet_probe String?")
+        assert guard.spend_log_hits(diff, _blocks("schema.prisma", head=head)) == (
+            "schema.prisma: +gauntlet_probe String?",
+        )
+
+    def test_a_field_removed_from_the_block_is_a_hit(self):
+        head: Final = SCHEMA.replace("  api_key    String\n", "")
+        diff: Final = _diff("schema.prisma", _hunk(11, 1, 10, 0, "-  api_key    String"))
+        assert guard.spend_log_hits(diff, _blocks("schema.prisma", head=head)) == ("schema.prisma: -api_key    String",)
+
+    def test_the_whole_model_appearing_or_disappearing_is_a_hit(self):
+        without: Final = SCHEMA.replace(
+            SCHEMA[SCHEMA.index("model LiteLLM_SpendLogs") : SCHEMA.index("model LiteLLM_UserTable")], ""
+        )
+        body: Final = tuple(SCHEMA.splitlines()[8:14])
+        added: Final = _diff("schema.prisma", _hunk(8, 0, 9, 6, *(f"+{line}" for line in body)))
+        removed: Final = _diff("schema.prisma", _hunk(9, 6, 8, 0, *(f"-{line}" for line in body)))
+        assert len(guard.spend_log_hits(added, _blocks("schema.prisma", base=without))) == 5
+        assert len(guard.spend_log_hits(removed, _blocks("schema.prisma", head=without))) == 5
+
+    def test_a_line_naming_the_table_in_another_model_is_not_a_hit(self):
+        head: Final = _with_line(SCHEMA, 6, "  spend_logs LiteLLM_SpendLogs[]")
         diff: Final = _diff(
-            "schema.prisma", '  @@index([api_key, startTime], map: "LiteLLM_SpendLogs_api_key_startTime_idx")', 740
-        )
-        assert guard.spend_log_hits(diff) == (
-            'schema.prisma: @@index([api_key, startTime], map: "LiteLLM_SpendLogs_api_key_startTime_idx")',
+            "schema.prisma",
+            _hunk(6, 0, 7, 1, "+  spend_logs LiteLLM_SpendLogs[]"),
+            _hunk(16, 1, 17, 0, "-  user_id String @id"),
         )
+        assert guard.spend_log_hits(diff, _blocks("schema.prisma", head=head)) == ()
 
-    def test_an_added_migration_line_is_a_hit_in_any_case(self):
+    def test_each_hunk_is_placed_by_its_own_header(self):
+        head: Final = _with_line(_with_line(SCHEMA, 2, '  output   = "./client"'), 10, "  new_col String?")
+        diff: Final = _diff(
+            "schema.prisma",
+            _hunk(2, 0, 3, 1, '+  output   = "./client"'),
+            _hunk(9, 0, 11, 1, "+  new_col String?"),
+        )
+        assert guard.spend_log_hits(diff, _blocks("schema.prisma", head=head)) == ("schema.prisma: +new_col String?",)
+
+    def test_an_added_migration_line_is_a_hit_in_any_case_and_a_removed_one_is_not(self):
         path: Final = "litellm-proxy-extras/litellm_proxy_extras/migrations/20260101000000_x/migration.sql"
-        hits: Final = guard.spend_log_hits(_diff(path, 'CREATE INDEX "i" ON "litellm_spendlogs"("api_key");', 3))
-        assert hits == (f'{path}: CREATE INDEX "i" ON "litellm_spendlogs"("api_key");',)
+        diff: Final = _diff(
+            path,
+            _hunk(
+                3,
+                1,
+                3,
+                1,
+                '-DROP INDEX "LiteLLM_SpendLogs_old_idx";',
+                '+CREATE INDEX "i" ON "litellm_spendlogs"("api_key");',
+            ),
+        )
+        assert guard.spend_log_hits(diff, _NO_BLOCKS) == (
+            f'{path}: +CREATE INDEX "i" ON "litellm_spendlogs"("api_key");',
+        )
 
-    def test_a_removed_line_or_another_table_or_an_unwatched_file_is_not_a_hit(self):
-        removed: Final = "--- a/schema.prisma\n+++ b/schema.prisma\n@@ -1,1 +1,0 @@\n-model LiteLLM_SpendLogs {\n"
-        other: Final = _diff("schema.prisma", "  team_id String  // LiteLLM_TeamTable, not MyLiteLLM_SpendLogs", 5)
-        elsewhere: Final = _diff("litellm/proxy/utils.py", 'table = "LiteLLM_SpendLogs"', 5)
-        assert guard.spend_log_hits(removed + other + elsewhere) == ()
+    def test_another_table_in_a_migration_or_an_unwatched_file_is_not_a_hit(self):
+        path: Final = "litellm-proxy-extras/litellm_proxy_extras/migrations/20260101000000_x/migration.sql"
+        other: Final = _added(
+            path, 'ALTER TABLE "LiteLLM_TeamTable" ADD COLUMN "x" TEXT; -- not MyLiteLLM_SpendLogs', 5
+        )
+        elsewhere: Final = _added("litellm/proxy/utils.py", 'table = "LiteLLM_SpendLogs"', 5)
+        assert guard.spend_log_hits(other + elsewhere, _NO_BLOCKS) == ()
 
     def test_a_table_whose_name_only_starts_with_the_watched_one_is_not_a_hit(self):
-        archive: Final = _diff("schema.prisma", "model LiteLLM_SpendLogsArchive {", 900)
-        index: Final = _diff("schema.prisma", "  @@index([team_id], map: \"LiteLLM_SpendLogs_team_id_idx\")", 760)
-        assert guard.spend_log_hits(archive + index) == (
-            'schema.prisma: @@index([team_id], map: "LiteLLM_SpendLogs_team_id_idx")',
+        index: Final = '  @@index([team_id], map: "LiteLLM_SpendLogs_team_id_idx")'
+        head: Final = _with_line(_with_line(SCHEMA, 18, "model LiteLLM_SpendLogsArchive {"), 12, index)
+        diff: Final = _diff(
+            "schema.prisma",
+            _hunk(12, 0, 13, 1, f"+{index}"),
+            _hunk(18, 0, 20, 1, "+model LiteLLM_SpendLogsArchive {"),
+        )
+        assert guard.spend_log_hits(diff, _blocks("schema.prisma", head=head)) == (
+            'schema.prisma: +@@index([team_id], map: "LiteLLM_SpendLogs_team_id_idx")',
         )
 
     def test_two_files_in_one_diff_are_attributed_to_their_own_path(self):
-        diff: Final = _diff("litellm/proxy/schema.prisma", "  a LiteLLM_SpendLogs", 1) + _diff(
-            "schema.prisma", "  b String", 1
-        )
-        assert guard.spend_log_hits(diff) == ("litellm/proxy/schema.prisma: a LiteLLM_SpendLogs",)
+        head: Final = _with_line(SCHEMA, 9, "  a String")
+        diff: Final = _added("litellm/proxy/schema.prisma", "  a String") + _added("schema.prisma", "  b String", 2)
+        blocks: Final = _blocks("litellm/proxy/schema.prisma", head=head) | _blocks("schema.prisma")
+        assert guard.spend_log_hits(diff, blocks) == ("litellm/proxy/schema.prisma: +a String",)
 
 
-def _review(login: str, state: str, commit_id: str | None = "head") -> "guard.Review":
+def _review(login: str, state: str, commit_id: str | None = "head") -> guard.Review:
     return guard.Review(state=state, user=guard.Reviewer(login=login), commit_id=commit_id)
 
 
@@ -126,24 +226,29 @@ class TestApprovalCovers:
 
 class TestExitCode:
     def test_a_pull_request_without_spend_log_lines_passes_without_reviews(self, tmp_path, monkeypatch, capsys):
-        monkeypatch.setattr(guard, "added_diff", lambda base, head: _diff("schema.prisma", "  foo String", 1))
+        monkeypatch.setattr(guard, "added_diff", lambda base, head: _added("schema.prisma", "  foo String", 6))
+        monkeypatch.setattr(guard, "schema_blocks", lambda base, head: _blocks("schema.prisma"))
         reviews: Final = tmp_path / "r.json"
         reviews.write_text("[]")
         assert guard.main(["--base", "a", "--head", "b", "--approver", "kerry-berri", "--reviews", str(reviews)]) == 0
         assert "nothing to review" in capsys.readouterr().out
 
     def test_a_spend_log_change_fails_until_the_approver_approves(self, tmp_path, monkeypatch, capsys):
-        monkeypatch.setattr(guard, "added_diff", lambda base, head: _diff("schema.prisma", "  x LiteLLM_SpendLogs", 7))
+        head: Final = _with_line(SCHEMA, 9, "  x String?")
+        monkeypatch.setattr(guard, "added_diff", lambda base_sha, head_sha: _added("schema.prisma", "  x String?"))
+        monkeypatch.setattr(guard, "schema_blocks", lambda base_sha, head_sha: _blocks("schema.prisma", head=head))
         reviews: Final = tmp_path / "r.json"
         reviews.write_text('[{"user": {"login": "someone-else"}, "state": "APPROVED"}]')
         assert guard.main(["--base", "a", "--head", "b", "--approver", "kerry-berri", "--reviews", str(reviews)]) == 1
-        assert "schema.prisma: x LiteLLM_SpendLogs" in capsys.readouterr().out
+        assert "schema.prisma: +x String?" in capsys.readouterr().out
         reviews.write_text('[{"user": {"login": "kerry-berri"}, "state": "APPROVED", "commit_id": "b"}]')
         assert guard.main(["--base", "a", "--head", "b", "--approver", "kerry-berri", "--reviews", str(reviews)]) == 0
 
     def test_an_approval_before_a_new_spend_log_line_was_pushed_fails(self, tmp_path, monkeypatch, capsys):
-        monkeypatch.setattr(guard, "added_diff", lambda base, head: _diff("schema.prisma", "  x LiteLLM_SpendLogs", 7))
-        monkeypatch.setattr(guard, "reviewed_hits", lambda base, commit: () if commit == "old" else None, raising=False)
+        head: Final = _with_line(SCHEMA, 9, "  x String?")
+        monkeypatch.setattr(guard, "added_diff", lambda base_sha, head_sha: _added("schema.prisma", "  x String?"))
+        monkeypatch.setattr(guard, "schema_blocks", lambda base_sha, head_sha: _blocks("schema.prisma", head=head))
+        monkeypatch.setattr(guard, "reviewed_hits", lambda base_sha, commit: () if commit == "old" else None)
         reviews: Final = tmp_path / "r.json"
         reviews.write_text('[{"user": {"login": "kerry-berri"}, "state": "APPROVED", "commit_id": "old"}]')
         assert guard.main(["--base", "a", "--head", "b", "--approver", "kerry-berri", "--reviews", str(reviews)]) == 1
diff --git a/tests/unit/types/test_litellm_params.py b/tests/unit/types/test_litellm_params.py
index 740342f54d9..cc1ea645012 100644
--- a/tests/unit/types/test_litellm_params.py
+++ b/tests/unit/types/test_litellm_params.py
@@ -154,6 +154,8 @@ OPTION_NAMES: Final = (
     "model_info",
     "rpm",
     "tpm",
+    "rpd",
+    "tpd",
     "itpm",
     "otpm",
     "default_api_key_rpm_limit",
diff --git a/ui/litellm-dashboard/src/lib/http/schema.d.ts b/ui/litellm-dashboard/src/lib/http/schema.d.ts
index a09672d7d8f..a49f1099121 100644
--- a/ui/litellm-dashboard/src/lib/http/schema.d.ts
+++ b/ui/litellm-dashboard/src/lib/http/schema.d.ts
@@ -35647,6 +35647,8 @@ export interface components {
             regional_processing_uplift_multiplier_us?: number | null;
             /** Responses Api Version */
             responses_api_version?: string | null;
+            /** Rpd */
+            rpd?: number | null;
             /** Rpm */
             rpm?: number | null;
             /** S3 Access Key Id */
@@ -35699,6 +35701,8 @@ export interface components {
             token_exchange_profile?: string | null;
             /** Token Exchange Scope */
             token_exchange_scope?: string | null;
+            /** Tpd */
+            tpd?: number | null;
             /** Tpm */
             tpm?: number | null;
             /** Use Chat Completions Api */
@@ -51039,6 +51043,8 @@ export interface components {
             regional_processing_uplift_multiplier_us?: number | null;
             /** Responses Api Version */
             responses_api_version?: string | null;
+            /** Rpd */
+            rpd?: number | null;
             /** Rpm */
             rpm?: number | null;
             /** S3 Access Key Id */
@@ -51091,6 +51097,8 @@ export interface components {
             token_exchange_profile?: string | null;
             /** Token Exchange Scope */
             token_exchange_scope?: string | null;
+            /** Tpd */
+            tpd?: number | null;
             /** Tpm */
             tpm?: number | null;
             /** Use Chat Completions Api */