diff --git a/.circleci/config.yml b/.circleci/config.yml
index 1485f5171646..eb76244c1ab7 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -3222,7 +3222,7 @@ workflows:
           cron: "17 0,6,12,18 * * *"
           filters:
             branches:
-              only: litellm_internal_staging
+              only: main
     jobs: *migration_jobs
   integration:
     unless: << pipeline.parameters.run_migration_tests >>
@@ -3231,7 +3231,7 @@ workflows:
           name: integration-<< matrix.suite >>
           matrix:
             parameters:
-              suite: [management, accounting, database, providers, extensions, sdk, cost, browser]
+              suite: [management, accounting, database, providers, extensions, mcp, sdk, cost, browser]
           filters:
             branches:
               only:
diff --git a/.circleci/scripts/path_filter.sh b/.circleci/scripts/path_filter.sh
index cdadde732bd7..1da29f99f6a8 100755
--- a/.circleci/scripts/path_filter.sh
+++ b/.circleci/scripts/path_filter.sh
@@ -11,7 +11,7 @@ run_full() {
 
 [ -n "${CIRCLE_PULL_REQUEST:-}" ] || run_full "not a pull request"
 
-candidate_bases="main litellm_internal_staging litellm_oss_staging"
+candidate_bases="main"
 merge_base=""
 for base in $candidate_bases; do
   git fetch --quiet origin "$base" 2>/dev/null || continue
diff --git a/.circleci/scripts/run_integration.sh b/.circleci/scripts/run_integration.sh
index 7b88f23349ad..d16ac9cd124d 100644
--- a/.circleci/scripts/run_integration.sh
+++ b/.circleci/scripts/run_integration.sh
@@ -111,6 +111,15 @@ upstream_pid=$!
 if [ "$suite" = cost ]; then
   export INTEGRATION_WORKERS=8
 fi
+if [ "$suite" = mcp ]; then
+  export INTEGRATION_WORKERS=4 INTEGRATION_COVERAGE=1
+fi
+coverage_data="$PWD/$results/coverage/data"
+proxy_command=(.venv/bin/python -m integration._support.proxy)
+if [ "${INTEGRATION_COVERAGE:-0}" = 1 ]; then
+  mkdir -p "$(dirname "$coverage_data")"
+  proxy_command=(.venv/bin/python -m coverage run --rcfile=tests/integration/mcp_coverage.toml -m integration._support.proxy)
+fi
 start_proxy() {
   local port="$1"
   local log_name="$2"
@@ -133,8 +142,8 @@ start_proxy() {
     INTEGRATION_UPSTREAM_URL="$INTEGRATION_UPSTREAM_URL" \
     LITELLM_MASTER_KEY="$LITELLM_MASTER_KEY" LITELLM_SALT_KEY="$LITELLM_SALT_KEY" LITELLM_UI_PATH="$LITELLM_UI_PATH" PROXY_BASE_URL="http://127.0.0.1:$port" \
     LITELLM_MODE=PRODUCTION STORE_MODEL_IN_DB=True "${cost_map_env[@]}" \
-    AWS_EC2_METADATA_DISABLED=true DO_NOT_TRACK=1 \
-    .venv/bin/python -m integration._support.proxy --config tests/integration/proxy_config.yaml \
+    AWS_EC2_METADATA_DISABLED=true DO_NOT_TRACK=1 COVERAGE_FILE="$coverage_data" \
+    "${proxy_command[@]}" --config tests/integration/proxy_config.yaml \
     --host 127.0.0.1 --port "$port" --num_workers 1 --telemetry False \
     --use_prisma_db_push --enforce_prisma_migration_check \
     > "$results/$log_name" 2>&1 &
@@ -146,7 +155,7 @@ proxy_pid="$launched_pid"
 curl --noproxy '*' -sSf -X POST "$INTEGRATION_PROXY_URL/config/update" \
   -H "Authorization: Bearer $LITELLM_MASTER_KEY" -H 'Content-Type: application/json' \
   -d '{"router_settings": {"num_retries": 0}}' > "$results/seed-router-settings.json"
-if [ "$suite" = management ]; then
+if [ "$suite" = management ] || [ "$suite" = mcp ]; then
   export INTEGRATION_PEER_URL=http://127.0.0.1:4001
   start_proxy 4001 peer.log
   peer_pid="$launched_pid"
@@ -187,3 +196,23 @@ env -i PATH="$PATH" HOME="$HOME" PYTHONPATH="$PYTHONPATH" \
   INTEGRATION_ORDER_SEED="$INTEGRATION_ORDER_SEED" \
   LITELLM_LOCAL_MODEL_COST_MAP=True AWS_EC2_METADATA_DISABLED=true DO_NOT_TRACK=1 \
   .venv/bin/python tests/integration/run.py "$suite" --results "$results"
+
+if [ "${INTEGRATION_COVERAGE:-0}" = 1 ]; then
+  for covered_pid in "$proxy_pid" "$peer_pid"; do
+    [ -n "$covered_pid" ] || continue
+    kill -TERM -- "-$covered_pid"
+    for _ in {1..300}; do
+      kill -0 "$covered_pid" 2>/dev/null || break
+      sleep 0.1
+    done
+    wait "$covered_pid" 2>/dev/null || true
+  done
+  proxy_pid=""
+  peer_pid=""
+  COVERAGE_FILE="$coverage_data" .venv/bin/python -m coverage combine --rcfile=tests/integration/mcp_coverage.toml
+  COVERAGE_FILE="$coverage_data" .venv/bin/python -m coverage report --rcfile=tests/integration/mcp_coverage.toml \
+    > "$results/coverage/coverage.txt"
+  COVERAGE_FILE="$coverage_data" .venv/bin/python -m coverage html --rcfile=tests/integration/mcp_coverage.toml \
+    -d "$results/coverage/html"
+  tail -n 1 "$results/coverage/coverage.txt"
+fi
diff --git a/.circleci/scripts/verify_integration_browser.py b/.circleci/scripts/verify_integration_browser.py
index 6fdd353e33a2..4468fadbcde5 100644
--- a/.circleci/scripts/verify_integration_browser.py
+++ b/.circleci/scripts/verify_integration_browser.py
@@ -31,8 +31,8 @@ def main() -> None:
     result: Final = json.loads(Path(sys.argv[1]).read_text())
     assert not result.get("errors"), result.get("errors")
     expected: Final = json.loads(
-        (Path(__file__).resolve().parents[2] / "tests/integration/contracts.json").read_text()
-    )["browser"]
+        (Path(__file__).resolve().parents[2] / "tests/e2e/ui/tests/integrationCritical/expected.json").read_text()
+    )
     assert expected and result["stats"]["expected"] == len(expected)
     assert all(result["stats"][name] == 0 for name in ("unexpected", "flaky", "skipped"))
 
diff --git a/.githooks/pre-push b/.githooks/pre-push
index c2267c8501c5..dc1a73a7ba23 100755
--- a/.githooks/pre-push
+++ b/.githooks/pre-push
@@ -8,7 +8,6 @@
 #
 # Protected branches (always allowed):
 #   - main
-#   - litellm_internal_staging
 #   - dependabot/*
 #   - gh-readonly-queue/*
 #
@@ -22,7 +21,7 @@ ZERO_OID_SHA256="000000000000000000000000000000000000000000000000000000000000000
 ALLOWED_TYPES="feature|bugfix|hotfix|release|chore"
 BRANCH_PATTERN="^(${ALLOWED_TYPES})/.+"
 
-PROTECTED_NAMES="main litellm_internal_staging"
+PROTECTED_NAMES="main"
 PROTECTED_PREFIXES="dependabot/ gh-readonly-queue/"
 
 is_protected() {
@@ -78,8 +77,7 @@ if [ -n "$invalid" ]; then
     chore/bump-deps
     hotfix/auth-bypass
 
-  Protected (always allowed): main, litellm_internal_staging,
-  dependabot/*, gh-readonly-queue/*.
+  Protected (always allowed): main, dependabot/*, gh-readonly-queue/*.
 
 See https://conventional-branch.github.io/
 
diff --git a/.github/scripts/assert_ci_coverage.py b/.github/scripts/assert_ci_coverage.py
index f62451eec14c..2e008fe7ade5 100644
--- a/.github/scripts/assert_ci_coverage.py
+++ b/.github/scripts/assert_ci_coverage.py
@@ -235,9 +235,7 @@ def claims(self, relative_path: str, inner_names: frozenset[str]) -> bool:
             return True  # a `-k` this parser cannot model is assumed to claim everything
         if any(term.lower() in relative_path.lower() for term in self.excluded):
             return False
-        return not self.required or any(
-            term.lower() in name.lower() for term in self.required for name in inner_names
-        )
+        return not self.required or any(term.lower() in name.lower() for term in self.required for name in inner_names)
 
 
 def _strings(node: object) -> Iterable[str]:
@@ -307,9 +305,7 @@ def _matchable_names(relative_path: str) -> frozenset[str]:
     except (OSError, SyntaxError):
         return frozenset({relative_path})
     return frozenset({relative_path}) | frozenset(
-        node.name
-        for node in ast.walk(tree)
-        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef))
+        node.name for node in ast.walk(tree) if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef))
     )
 
 
@@ -331,9 +327,7 @@ def _deselected_everywhere(allowlist: Allowlist) -> tuple[Finding, ...]:
     slices: Final = _slices()
     named_by_workflow: Final = _workflow_named_tokens()
     globbed: Final = tuple(
-        path
-        for path in _test_files()
-        if any(_token_covers(glob, path) for slice_ in slices for glob in slice_.globs)
+        path for path in _test_files() if any(_token_covers(glob, path) for slice_ in slices for glob in slice_.globs)
     )
     return tuple(
         Finding(
@@ -363,11 +357,7 @@ def _shard_children(root: str, repo_root: pathlib.Path = REPO_ROOT) -> tuple[str
             child.relative_to(repo_root).as_posix()
             for child in (repo_root / root).iterdir()
             if not child.name.startswith(".")
-            and (
-                _holds_tests(child)
-                if child.is_dir()
-                else child.name.startswith("test_") and child.suffix == ".py"
-            )
+            and (_holds_tests(child) if child.is_dir() else child.name.startswith("test_") and child.suffix == ".py")
         )
     )
 
@@ -499,13 +489,32 @@ def _check_shards() -> int:
     return 0
 
 
+def _integration_groups(runner: pathlib.Path) -> dict[str, tuple[str, ...]]:
+    module: Final = ast.parse(runner.read_text())
+    literal: Final = next(
+        node.value
+        for node in module.body
+        if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name) and node.target.id == "GROUPS"
+    )
+    mapping: Final = literal.args[0] if isinstance(literal, ast.Call) else literal
+    return {group: tuple(folders) for group, folders in ast.literal_eval(mapping).items()}
+
+
 def _integration_ownership(repo_root: pathlib.Path = REPO_ROOT) -> tuple[frozenset[str], tuple[Finding, ...]]:
-    manifest: Final = repo_root / "tests/integration/contracts.json"
-    if not manifest.exists():
+    runner: Final = repo_root / "tests/integration/run.py"
+    if not runner.exists():
         return frozenset(), ()
-    entries: Final = json.loads(manifest.read_text())
-    paths: Final = frozenset(node.split("::", 1)[0] for node in entries["tests"])
-    browser_paths: Final = frozenset(node.split("::", 1)[0] for node in entries.get("browser", {}))
+    groups: Final = _integration_groups(runner)
+    integration_root: Final = repo_root / "tests/integration"
+    paths: Final = frozenset(
+        str(path.relative_to(repo_root))
+        for folders in groups.values()
+        for folder in folders
+        for path in (integration_root / folder).glob("test_*.py")
+    )
+    browser_manifest: Final = repo_root / "tests/e2e/ui/tests/integrationCritical/expected.json"
+    browser_nodes: Final = json.loads(browser_manifest.read_text()) if browser_manifest.exists() else ()
+    browser_paths: Final = frozenset(node.split("::", 1)[0] for node in browser_nodes)
     circle_path: Final = repo_root / ".circleci/config.yml"
     circle: Final = yaml.safe_load(circle_path.read_text()) if circle_path.exists() else {}
     steps: Final = circle.get("jobs", {}).get("integration_contracts", {}).get("steps", ())
@@ -526,15 +535,14 @@ def _integration_ownership(repo_root: pathlib.Path = REPO_ROOT) -> tuple[frozens
     )
     required: Final = (frozenset({"browser"}) if browser_paths else frozenset()) | frozenset(
         group
-        for group, folders in entries["groups"].items()
+        for group, folders in groups.items()
         if any(any(path.startswith(f"tests/integration/{folder}/") for folder in folders) for path in paths)
     )
     ungrouped: Final = frozenset(
         path
         for path in paths
         if sum(
-            any(path.startswith(f"tests/integration/{folder}/") for folder in folders)
-            for folders in entries["groups"].values()
+            any(path.startswith(f"tests/integration/{folder}/") for folder in folders) for folders in groups.values()
         )
         != 1
     )
@@ -547,10 +555,6 @@ def _integration_ownership(repo_root: pathlib.Path = REPO_ROOT) -> tuple[frozens
         Finding(path, "integration contract is also selected by GitHub Actions")
         for path in paths
         if any(_token_covers(token, path) for token in gha_tokens)
-    ) + tuple(
-        Finding(path, "canonical integration test file is missing")
-        for path in paths
-        if not (repo_root / path).is_file()
     )
     browser_commands: Final = tuple(
         scalar.value
@@ -592,7 +596,7 @@ def _integration_ownership(repo_root: pathlib.Path = REPO_ROOT) -> tuple[frozens
     ) + tuple(Finding(path, "canonical node must have exactly one integration group") for path in sorted(ungrouped))
     if not paths or not invoked or not scheduled:
         return frozenset(), findings + (
-            Finding(str(manifest.relative_to(repo_root)), "dedicated CircleCI runner is missing"),
+            Finding(str(runner.relative_to(repo_root)), "dedicated CircleCI runner is missing"),
         )
     return paths | browser_paths, findings + group_findings + browser_findings + exclusion_findings
 
diff --git a/.github/scripts/verify_linux_native_wheel.py b/.github/scripts/verify_linux_native_wheel.py
index f2b82f86b479..6b7fcd57bbc0 100644
--- a/.github/scripts/verify_linux_native_wheel.py
+++ b/.github/scripts/verify_linux_native_wheel.py
@@ -214,7 +214,7 @@ def main(
     native_module: Final = load_native_module(native_path)
     native_module_loads: Final = native_module is not None
     panic_test_hook_absent: Final = native_module is not None and not hasattr(native_module, "_panic_for_test")
-    native_size_limit: Final = 35_000_000
+    native_size_limit: Final = 40_000_000
     native_size_within_limit: Final = native_member.file_size <= native_size_limit
     validations: Final = (
         (f"Python tag is {EXPECTED_PYTHON_TAG}", python_tag == EXPECTED_PYTHON_TAG),
diff --git a/.github/workflows/check-ui-api-types.yml b/.github/workflows/check-ui-api-types.yml
index 312a80103f8e..185c20d916d4 100644
--- a/.github/workflows/check-ui-api-types.yml
+++ b/.github/workflows/check-ui-api-types.yml
@@ -4,8 +4,6 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
 
 permissions:
diff --git a/.github/workflows/ci-coverage.yml b/.github/workflows/ci-coverage.yml
index 7bc476db134a..cd36a9a7ed60 100644
--- a/.github/workflows/ci-coverage.yml
+++ b/.github/workflows/ci-coverage.yml
@@ -4,13 +4,10 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
   push:
     branches:
       - main
-      - litellm_internal_staging
 
 permissions:
   contents: read
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index d3a165a11da8..9a85ced57f69 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -67,12 +67,18 @@ jobs:
       # further up the stack are modified. The suppression is scoped to this one
       # file/rule pair via SARIF post-filtering so every other callsite of
       # py/weak-sensitive-data-hashing in the repository continues to be analyzed.
-      - name: Filter SARIF (OCI sha256)
+      # The same query fires on the HIBP k-anonymity lookup in
+      # litellm/proxy/auth/password_policy.py, where the password's SHA-1 is only
+      # a lookup key into the haveibeenpwned range API (the protocol mandates
+      # SHA-1) and the digest itself never leaves the proxy beyond its first 5
+      # characters.
+      - name: Filter SARIF (OCI sha256, HIBP sha1)
         if: matrix.language == 'python'
         uses: advanced-security/filter-sarif@2da736ff05ef065cb2894ac6892e47b5eac2c3c0 # v1.1
         with:
           patterns: |
             -litellm/llms/oci/common_utils.py:py/weak-sensitive-data-hashing
+            -litellm/proxy/auth/password_policy.py:py/weak-sensitive-data-hashing
           input: sarif-results/python.sarif
           output: sarif-results/python.sarif
 
diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index ec7e211faa15..dfad57dc5ab5 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -4,7 +4,6 @@ on:
   push:
     branches:
       - main
-      - litellm_internal_staging
     paths:
       - "litellm/**"
       - "tests/benchmarks/**"
@@ -17,7 +16,6 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
     paths:
       - "litellm/**"
       - "tests/benchmarks/**"
diff --git a/.github/workflows/cost-map-guard.yml b/.github/workflows/cost-map-guard.yml
index 61a56f1f47ef..208a75434a53 100644
--- a/.github/workflows/cost-map-guard.yml
+++ b/.github/workflows/cost-map-guard.yml
@@ -4,8 +4,6 @@ on: # zizmor: ignore[dangerous-triggers] runs the base branch's code only; the P
   pull_request_target:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
 
 permissions:
diff --git a/.github/workflows/create_daily_staging_branch.yml b/.github/workflows/create_daily_staging_branch.yml
deleted file mode 100644
index 6422b0d4dbc3..000000000000
--- a/.github/workflows/create_daily_staging_branch.yml
+++ /dev/null
@@ -1,49 +0,0 @@
-name: Create Daily Staging Branch
-
-on:
-  schedule:
-    - cron: "0 0,12 * * *" # Runs every 12 hours at midnight and noon UTC
-  workflow_dispatch: # Allow manual trigger
-
-jobs:
-  create-staging-branch:
-    if: github.repository == 'BerriAI/litellm'
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-
-    steps:
-      - name: Create daily staging branch
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          BRANCH_NAME="litellm_oss_staging_$(date +'%m_%d_%Y')"
-          echo "Creating branch: $BRANCH_NAME"
-          if gh api "repos/${{ github.repository }}/git/ref/heads/$BRANCH_NAME" --silent 2>/dev/null; then
-            echo "Branch $BRANCH_NAME already exists. Skipping creation."
-            exit 0
-          fi
-          MAIN_SHA=$(gh api "repos/${{ github.repository }}/git/ref/heads/main" --jq '.object.sha')
-          gh api "repos/${{ github.repository }}/git/refs" -f ref="refs/heads/$BRANCH_NAME" -f sha="$MAIN_SHA" --silent
-          echo "Successfully created branch: $BRANCH_NAME at $MAIN_SHA"
-
-  create-internal-dev-branch:
-    if: github.repository == 'BerriAI/litellm'
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-
-    steps:
-      - name: Create internal dev branch
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          BRANCH_NAME="litellm_internal_dev_$(date +'%m_%d_%Y')"
-          echo "Creating branch: $BRANCH_NAME"
-          if gh api "repos/${{ github.repository }}/git/ref/heads/$BRANCH_NAME" --silent 2>/dev/null; then
-            echo "Branch $BRANCH_NAME already exists. Skipping creation."
-            exit 0
-          fi
-          MAIN_SHA=$(gh api "repos/${{ github.repository }}/git/ref/heads/main" --jq '.object.sha')
-          gh api "repos/${{ github.repository }}/git/refs" -f ref="refs/heads/$BRANCH_NAME" -f sha="$MAIN_SHA" --silent
-          echo "Successfully created branch: $BRANCH_NAME at $MAIN_SHA"
diff --git a/.github/workflows/guard-fork-dependencies.yml b/.github/workflows/guard-fork-dependencies.yml
index 6b366da78d47..a0717c8e0f9b 100644
--- a/.github/workflows/guard-fork-dependencies.yml
+++ b/.github/workflows/guard-fork-dependencies.yml
@@ -4,8 +4,6 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
     paths:
       - "uv.lock"
diff --git a/.github/workflows/image-scan.yml b/.github/workflows/image-scan.yml
index c27d49ed6105..0695720733ff 100644
--- a/.github/workflows/image-scan.yml
+++ b/.github/workflows/image-scan.yml
@@ -4,7 +4,6 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
       - litellm_oss_branch
       - "litellm_**"
     paths:
diff --git a/.github/workflows/osv-scan.yml b/.github/workflows/osv-scan.yml
index 0aedeaec12a5..1c7e8b2841ae 100644
--- a/.github/workflows/osv-scan.yml
+++ b/.github/workflows/osv-scan.yml
@@ -4,8 +4,6 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
   schedule:
     - cron: "23 6 * * *"
diff --git a/.github/workflows/publish-basedpyright-base-counts.yml b/.github/workflows/publish-basedpyright-base-counts.yml
index 27d4682dbd99..34f60d259809 100644
--- a/.github/workflows/publish-basedpyright-base-counts.yml
+++ b/.github/workflows/publish-basedpyright-base-counts.yml
@@ -1,6 +1,6 @@
 name: Publish basedpyright base counts
 
-# Every commit on main or litellm_internal_staging can become a future merge-base.
+# Every commit on main can become a future merge-base.
 # Publishing its per-rule basedpyright counts as an artifact lets
 # scripts/type_check_gate.py download them in seconds instead of paying a
 # 60-110s second basedpyright pass on every fresh worktree or moved merge-base.
@@ -11,7 +11,6 @@ on:
   push:
     branches:
       - main
-      - litellm_internal_staging
   workflow_dispatch:
     inputs:
       ref:
diff --git a/.github/workflows/test-code-quality.yml b/.github/workflows/test-code-quality.yml
index 987f66773f2d..2b6adaa6af6d 100644
--- a/.github/workflows/test-code-quality.yml
+++ b/.github/workflows/test-code-quality.yml
@@ -4,13 +4,10 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
   push:
     branches:
       - main
-      - litellm_internal_staging
 
 permissions:
   contents: read
diff --git a/.github/workflows/test-linting.yml b/.github/workflows/test-linting.yml
index 592d8edf6b8d..c77d4b2ee96f 100644
--- a/.github/workflows/test-linting.yml
+++ b/.github/workflows/test-linting.yml
@@ -4,8 +4,6 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
 
 permissions:
diff --git a/.github/workflows/test-litellm-ui-build.yml b/.github/workflows/test-litellm-ui-build.yml
index 4eb6b272c43a..eace78fc2cbb 100644
--- a/.github/workflows/test-litellm-ui-build.yml
+++ b/.github/workflows/test-litellm-ui-build.yml
@@ -7,8 +7,6 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
 
 concurrency:
diff --git a/.github/workflows/test-litellm-ui-lint.yml b/.github/workflows/test-litellm-ui-lint.yml
index e03d89ee26a3..9ea5100e21b5 100644
--- a/.github/workflows/test-litellm-ui-lint.yml
+++ b/.github/workflows/test-litellm-ui-lint.yml
@@ -6,8 +6,6 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
 
 concurrency:
diff --git a/.github/workflows/test-litellm-ui-unit.yml b/.github/workflows/test-litellm-ui-unit.yml
index b93bf84320de..ee1440c6e8ba 100644
--- a/.github/workflows/test-litellm-ui-unit.yml
+++ b/.github/workflows/test-litellm-ui-unit.yml
@@ -7,13 +7,10 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
   push:
     branches:
       - main
-      - litellm_internal_staging
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
diff --git a/.github/workflows/test-mcp-dependency-resolution.yml b/.github/workflows/test-mcp-dependency-resolution.yml
index b5dc573c1c1e..463d6a7e9e83 100644
--- a/.github/workflows/test-mcp-dependency-resolution.yml
+++ b/.github/workflows/test-mcp-dependency-resolution.yml
@@ -4,8 +4,6 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
 
 permissions:
diff --git a/.github/workflows/test-postgres.yml b/.github/workflows/test-postgres.yml
index 96c514dff7c0..a1e6bf54135f 100644
--- a/.github/workflows/test-postgres.yml
+++ b/.github/workflows/test-postgres.yml
@@ -4,13 +4,10 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
   push:
     branches:
       - main
-      - litellm_internal_staging
   workflow_dispatch:
 
 permissions:
diff --git a/.github/workflows/test-redis-compat.yml b/.github/workflows/test-redis-compat.yml
index f29755a74b14..7862481173be 100644
--- a/.github/workflows/test-redis-compat.yml
+++ b/.github/workflows/test-redis-compat.yml
@@ -4,8 +4,6 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
     paths:
       - "litellm/_redis.py"
diff --git a/.github/workflows/test-rust.yml b/.github/workflows/test-rust.yml
index 64e16b512e1a..1f3b5c4d97c6 100644
--- a/.github/workflows/test-rust.yml
+++ b/.github/workflows/test-rust.yml
@@ -29,8 +29,6 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
     paths:
       - "litellm-rust/**"
diff --git a/.github/workflows/test-semgrep.yml b/.github/workflows/test-semgrep.yml
index 6e9f5e42fa21..d375824e3c9b 100644
--- a/.github/workflows/test-semgrep.yml
+++ b/.github/workflows/test-semgrep.yml
@@ -4,8 +4,6 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
 
 permissions:
diff --git a/.github/workflows/test-terraform-modules.yml b/.github/workflows/test-terraform-modules.yml
index e6896604b7f9..e2fda3207e8f 100644
--- a/.github/workflows/test-terraform-modules.yml
+++ b/.github/workflows/test-terraform-modules.yml
@@ -9,8 +9,6 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
     paths:
       - "terraform/litellm/aws/**"
diff --git a/.github/workflows/test-terraform-provider.yml b/.github/workflows/test-terraform-provider.yml
index eb7b299fd1f6..be7fd1e61dc1 100644
--- a/.github/workflows/test-terraform-provider.yml
+++ b/.github/workflows/test-terraform-provider.yml
@@ -8,8 +8,6 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
     paths:
       - "terraform/provider/**"
diff --git a/.github/workflows/test-unit-documentation.yml b/.github/workflows/test-unit-documentation.yml
index 90b6b28374e5..660c7689e2b8 100644
--- a/.github/workflows/test-unit-documentation.yml
+++ b/.github/workflows/test-unit-documentation.yml
@@ -4,13 +4,10 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
   push:
     branches:
       - main
-      - litellm_internal_staging
 
 permissions:
   contents: read
diff --git a/.github/workflows/test-unit-proxy-db.yml b/.github/workflows/test-unit-proxy-db.yml
index 9013f21931bb..4af7a1619844 100644
--- a/.github/workflows/test-unit-proxy-db.yml
+++ b/.github/workflows/test-unit-proxy-db.yml
@@ -4,13 +4,10 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
   push:
     branches:
       - main
-      - litellm_internal_staging
 
 permissions:
   contents: read
diff --git a/.github/workflows/test-unit.yml b/.github/workflows/test-unit.yml
index ac60a9b5f05e..ed87049f2d51 100644
--- a/.github/workflows/test-unit.yml
+++ b/.github/workflows/test-unit.yml
@@ -4,13 +4,10 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
   push:
     branches:
       - main
-      - litellm_internal_staging
   workflow_dispatch:
 
 permissions:
diff --git a/.github/workflows/test-vscode-extension.yml b/.github/workflows/test-vscode-extension.yml
index 886268d9e2c9..c807948e4e9c 100644
--- a/.github/workflows/test-vscode-extension.yml
+++ b/.github/workflows/test-vscode-extension.yml
@@ -6,8 +6,6 @@ on:
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
     paths:
       - "vscode-extension/**"
diff --git a/.github/workflows/zizmor.yml b/.github/workflows/zizmor.yml
index df242e5a3b6f..73f9efb8df94 100644
--- a/.github/workflows/zizmor.yml
+++ b/.github/workflows/zizmor.yml
@@ -2,12 +2,10 @@ name: GitHub Actions Security Analysis
 
 on:
   push:
-    branches: [main, litellm_internal_staging]
+    branches: [main]
   pull_request:
     branches:
       - main
-      - litellm_internal_staging
-      - litellm_oss_staging
       - "litellm_**"
 
 concurrency:
diff --git a/litellm-rust/Cargo.lock b/litellm-rust/Cargo.lock
index 332d8b3dcf01..ef032bfe55c8 100644
--- a/litellm-rust/Cargo.lock
+++ b/litellm-rust/Cargo.lock
@@ -88,6 +88,45 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "03918c3dbd7701a85c6b9887732e2921175f26c350b4563841d0958c21d57e6d"
 
+[[package]]
+name = "asn1-rs"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7f43a50ac4fdca5df8e885c21b835997f0a1cdee65494a6847694a98652d9d8"
+dependencies = [
+ "asn1-rs-derive",
+ "asn1-rs-impl",
+ "displaydoc",
+ "nom",
+ "num-traits",
+ "rusticata-macros",
+ "thiserror 2.0.19",
+ "time",
+]
+
+[[package]]
+name = "asn1-rs-derive"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3109e49b1e4909e9db6515a30c633684d68cdeaa252f215214cb4fa1a5bfee2c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "synstructure 0.13.2",
+]
+
+[[package]]
+name = "asn1-rs-impl"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "assert-json-diff"
 version = "2.0.2"
@@ -810,7 +849,7 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
 dependencies = [
- "bit-vec",
+ "bit-vec 0.8.0",
 ]
 
 [[package]]
@@ -819,6 +858,15 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
 
+[[package]]
+name = "bit-vec"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -1120,6 +1168,15 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "338089f42c427b86394a5ee60ff321da23a5c89c9d89514c829687b26359fcff"
 
+[[package]]
+name = "crc32c"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a47af21622d091a8f0fb295b88bc886ac74efcc613efc19f5d0b21de5c89e47"
+dependencies = [
+ "rustc_version",
+]
+
 [[package]]
 name = "crc32fast"
 version = "1.5.1"
@@ -1378,6 +1435,20 @@ dependencies = [
  "thiserror 2.0.19",
 ]
 
+[[package]]
+name = "der-parser"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07da5016415d5a3c4dd39b11ed26f915f52fc4e0dc197d87908bc916e51bc1a6"
+dependencies = [
+ "asn1-rs",
+ "displaydoc",
+ "nom",
+ "num-bigint 0.4.8",
+ "num-traits",
+ "rusticata-macros",
+]
+
 [[package]]
 name = "deranged"
 version = "0.5.8"
@@ -2589,21 +2660,6 @@ dependencies = [
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "jsonwebtoken"
-version = "11.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e75fe14a82d81e5f5af639997db37d8b96045938a7ac6ab18cdbe1c7467e05e1"
-dependencies = [
- "base64 0.22.1",
- "getrandom 0.2.17",
- "js-sys",
- "serde",
- "serde_json",
- "signature",
- "zeroize",
-]
-
 [[package]]
 name = "lazy_static"
 version = "1.5.0"
@@ -3119,6 +3175,7 @@ dependencies = [
  "tokio",
  "tokio-tungstenite",
  "url",
+ "veil",
  "wiremock",
 ]
 
@@ -3143,10 +3200,11 @@ version = "0.1.0"
 dependencies = [
  "aws-sdk-kms",
  "base64 0.22.1",
+ "futures-util",
  "google-cloud-auth",
  "google-cloud-kms-v1",
- "jsonwebtoken",
  "litellm-core-utils",
+ "litellm-python-compat",
  "litellm-secrets-aws",
  "litellm-secrets-azure",
  "litellm-secrets-cyberark",
@@ -3179,6 +3237,7 @@ dependencies = [
  "litellm-tracing",
  "rstest",
  "serde_json",
+ "tempfile",
  "thiserror 2.0.19",
  "tokio",
  "veil",
@@ -3215,10 +3274,12 @@ dependencies = [
  "litellm-tracing",
  "moka",
  "percent-encoding",
+ "rcgen",
  "reqwest 0.12.28",
  "rstest",
  "serde",
  "serde_json",
+ "tempfile",
  "thiserror 2.0.19",
  "tokio",
  "veil",
@@ -3230,6 +3291,7 @@ name = "litellm-secrets-google"
 version = "0.1.0"
 dependencies = [
  "base64 0.22.1",
+ "crc32c",
  "google-cloud-auth",
  "google-cloud-gax",
  "google-cloud-kms-v1",
@@ -3255,7 +3317,6 @@ version = "0.1.0"
 dependencies = [
  "litellm-core-utils",
  "litellm-secrets-types",
- "moka",
  "rstest",
  "rustify",
  "rustify_derive",
@@ -3274,6 +3335,7 @@ name = "litellm-secrets-types"
 version = "0.1.0"
 dependencies = [
  "litellm-auth-types",
+ "moka",
  "rstest",
  "serde",
  "serde_json",
@@ -3588,6 +3650,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "oid-registry"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12f40cff3dde1b6087cc5d5f5d4d65712f34016a03ed60e9c08dcc392736b5b7"
+dependencies = [
+ "asn1-rs",
+]
+
 [[package]]
 name = "once_cell"
 version = "1.21.4"
@@ -3721,6 +3792,16 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4"
 
+[[package]]
+name = "pem"
+version = "4.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d354a98a3d1251555de99e8fdd8afda05573c31b82f59063a7b0a29b5527f120"
+dependencies = [
+ "base64 0.23.1",
+ "serde_core",
+]
+
 [[package]]
 name = "percent-encoding"
 version = "2.3.2"
@@ -3899,7 +3980,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4b45fcc2344c680f5025fe57779faef368840d0bd1f42f216291f0dc4ace4744"
 dependencies = [
  "bit-set",
- "bit-vec",
+ "bit-vec 0.8.0",
  "bitflags 2.13.1",
  "num-traits",
  "rand 0.9.5",
@@ -4288,6 +4369,20 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "rcgen"
+version = "0.14.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8774e05a7d0de114588e6a28fe7e71694b82614ed569d86d8b389dfbc98b8ad8"
+dependencies = [
+ "pem",
+ "ring",
+ "rustls-pki-types",
+ "time",
+ "x509-parser",
+ "yasna",
+]
+
 [[package]]
 name = "redis"
 version = "1.7.0"
@@ -4570,6 +4665,15 @@ dependencies = [
  "semver",
 ]
 
+[[package]]
+name = "rusticata-macros"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "faf0c4a6ece9950b9abdb62b1cfcf2a68b3b67a10ba445b3bb85be2a293d0632"
+dependencies = [
+ "nom",
+]
+
 [[package]]
 name = "rustify"
 version = "0.7.0"
@@ -5046,15 +5150,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "signature"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
-dependencies = [
- "rand_core 0.6.4",
-]
-
 [[package]]
 name = "simd-adler32"
 version = "0.3.10"
@@ -6356,6 +6451,24 @@ version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"
 
+[[package]]
+name = "x509-parser"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d43b0f71ce057da06bc0851b23ee24f3f86190b07203dd8f567d0b706a185202"
+dependencies = [
+ "asn1-rs",
+ "data-encoding",
+ "der-parser",
+ "lazy_static",
+ "nom",
+ "oid-registry",
+ "ring",
+ "rusticata-macros",
+ "thiserror 2.0.19",
+ "time",
+]
+
 [[package]]
 name = "xmlparser"
 version = "0.13.6"
@@ -6368,6 +6481,16 @@ version = "0.8.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aee1b19627c7c60102ab80d3a9cbe18de90bfe03bfa6c3715447681f0e8c8af6"
 
+[[package]]
+name = "yasna"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5f6765e852b9b4dc8e2a76843e4d64d1cea8e79bcde0b6901aea8e7c7f08282"
+dependencies = [
+ "bit-vec 0.9.1",
+ "time",
+]
+
 [[package]]
 name = "yoke"
 version = "0.8.3"
@@ -6437,20 +6560,6 @@ name = "zeroize"
 version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e"
-dependencies = [
- "zeroize_derive",
-]
-
-[[package]]
-name = "zeroize_derive"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
 
 [[package]]
 name = "zerotrie"
diff --git a/litellm-rust/crates/core/Cargo.toml b/litellm-rust/crates/core/Cargo.toml
index 3bfc5bae9257..4626781f3e38 100644
--- a/litellm-rust/crates/core/Cargo.toml
+++ b/litellm-rust/crates/core/Cargo.toml
@@ -7,6 +7,7 @@ repository.workspace = true
 autotests = false
 
 [dependencies]
+litellm-secrets.workspace = true
 litellm-types.workspace = true
 litellm-core-utils.workspace = true
 litellm-host.workspace = true
@@ -36,7 +37,6 @@ url.workspace = true
 veil.workspace = true
 
 [dev-dependencies]
-litellm-secrets.workspace = true
 litellm-auth-gcp.workspace = true
 litellm-llms = { workspace = true, features = ["test-support"] }
 rstest.workspace = true
diff --git a/litellm-rust/crates/core/src/ocr/prepare.rs b/litellm-rust/crates/core/src/ocr/prepare.rs
index 54960256faae..37c0f18f6593 100644
--- a/litellm-rust/crates/core/src/ocr/prepare.rs
+++ b/litellm-rust/crates/core/src/ocr/prepare.rs
@@ -1,11 +1,9 @@
 use litellm_auth::{InputSource, SecretValue, Sourced};
-use litellm_llms::base_llm::{
-    inference::secrets::Secrets,
-    ocr::{
-        handler::OcrClient,
-        transformation::{OcrConnection, OcrCredentialInputs, PreparedOcrRequest},
-    },
+use litellm_llms::base_llm::ocr::{
+    handler::OcrClient,
+    transformation::{OcrConnection, OcrCredentialInputs, PreparedOcrRequest},
 };
+use litellm_secrets::source::Secrets;
 
 use super::provider_config::OcrProvider;
 use crate::ocr::types::{LiteLLMOcrRequest, ResolvedOcrRequest};
diff --git a/litellm-rust/crates/core/tests/ocr.rs b/litellm-rust/crates/core/tests/ocr.rs
index d376f0df784c..26cd2153e8db 100644
--- a/litellm-rust/crates/core/tests/ocr.rs
+++ b/litellm-rust/crates/core/tests/ocr.rs
@@ -11,7 +11,6 @@ use litellm_http::{
     HttpClientPool, HttpSettings, Resolution,
     media::{PublicDnsResolver, UrlPolicy},
 };
-use litellm_llms::base_llm::inference::secrets::{SecretSource, Secrets};
 use litellm_llms::base_llm::ocr::{
     error::Error as OcrError,
     handler::OcrClient,
@@ -20,6 +19,7 @@ use litellm_llms::base_llm::ocr::{
         BaseOcrConfig, LiteLLMOcrResponse, OCR_RESPONSE_MAX_BYTES, OcrTransportConfig,
     },
 };
+use litellm_secrets::source::SecretSource;
 use rstest::rstest;
 use serde_json::{Value, json};
 
@@ -32,27 +32,27 @@ use super::{
 use crate::ocr::route::{LocalOcrHost, OcrOp, OcrOpResult, ocr_machine};
 
 struct RecordingSecretSource {
-    names: Arc<Mutex<Vec<&'static str>>>,
+    names: Arc<Mutex<Vec<String>>>,
     values: &'static [(&'static str, &'static str)],
     api_base: String,
 }
 
 impl SecretSource for RecordingSecretSource {
-    fn resolve<'a>(
+    fn get_secret_str<'a>(
         &'a self,
-        names: &'a [&'static str],
-    ) -> BoxFuture<'a, Result<Secrets, litellm_secrets::Error>> {
-        *self.names.lock().unwrap() = names.to_vec();
-        let values = self.values;
-        let api_base = self.api_base.clone();
+        name: &'a str,
+    ) -> BoxFuture<'a, Result<Option<litellm_secrets::SecretValue>, litellm_secrets::Error>> {
+        self.names.lock().unwrap().push(name.to_owned());
         Box::pin(async move {
-            Ok(Arc::new(move |name: &str| match name {
-                "MISTRAL_AZURE_API_BASE" => Some(api_base.clone()),
-                _ => values
+            Ok(match name {
+                "MISTRAL_AZURE_API_BASE" => Some(self.api_base.clone()),
+                _ => self
+                    .values
                     .iter()
                     .find(|(key, _)| *key == name)
                     .map(|(_, value)| value.to_string()),
-            }) as Secrets)
+            }
+            .map(litellm_secrets::SecretValue::new))
         })
     }
 }
@@ -289,7 +289,7 @@ async fn ocr_client_uses_the_injected_http_pool_configuration() {
         UrlPolicy::default(),
         VertexAuth::default(),
         OcrSettings::default(),
-        Arc::new(litellm_llms::base_llm::inference::secrets::EnvironmentSecrets),
+        Arc::new(litellm_secrets::source::EnvironmentSecrets::default()),
     )
     .unwrap();
     crate::ocr::client::perform(&client, wire_request("mistral/model", &base, json!({})))
diff --git a/litellm-rust/crates/host-python/src/lib.rs b/litellm-rust/crates/host-python/src/lib.rs
index 4a33975a9182..37f8a2c9e4ba 100644
--- a/litellm-rust/crates/host-python/src/lib.rs
+++ b/litellm-rust/crates/host-python/src/lib.rs
@@ -27,7 +27,9 @@ pub use execution::{
 pub use fork_gate::RuntimeAlreadyStarted;
 pub use gil::{release_count, release_gil};
 pub use handle::{Execution, ExecutionBody, ExecutionStep};
-pub use marshal::{Pythonized, from_py, from_py_argument, panic_to_pyerr, to_py};
+pub use marshal::{
+    Pythonized, from_py, from_py_argument, json_loads, json_object_field, panic_to_pyerr, to_py,
+};
 
 /// Starts the interpreter and imports the standard modules the tests share, once, so
 /// parallel test threads never race a first import of `asyncio`.
diff --git a/litellm-rust/crates/host-python/src/marshal.rs b/litellm-rust/crates/host-python/src/marshal.rs
index 8f284abf9dd4..53f11d8c40a1 100644
--- a/litellm-rust/crates/host-python/src/marshal.rs
+++ b/litellm-rust/crates/host-python/src/marshal.rs
@@ -4,6 +4,7 @@ use std::panic::{AssertUnwindSafe, catch_unwind};
 use pyo3::exceptions::PyValueError;
 use pyo3::panic::PanicException;
 use pyo3::prelude::*;
+use pyo3::types::PyBytes;
 use serde::Serialize;
 use serde::de::DeserializeOwned;
 
@@ -32,6 +33,19 @@ where
         .map_err(PyErr::from)
 }
 
+pub fn json_object_field(py: Python<'_>, document: &str, name: &str) -> PyResult<Py<PyAny>> {
+    py.import("json")?
+        .call_method1("loads", (document,))?
+        .call_method1("get", (name,))
+        .map(Bound::unbind)
+}
+
+pub fn json_loads(py: Python<'_>, document: &[u8]) -> PyResult<Py<PyAny>> {
+    py.import("json")?
+        .call_method1("loads", (PyBytes::new(py, document),))
+        .map(Bound::unbind)
+}
+
 pub struct Pythonized<T>(pub T);
 
 impl<'py, T> IntoPyObject<'py> for Pythonized<T>
diff --git a/litellm-rust/crates/llms/src/base_llm/inference/mod.rs b/litellm-rust/crates/llms/src/base_llm/inference/mod.rs
deleted file mode 100644
index 10c0454f947c..000000000000
--- a/litellm-rust/crates/llms/src/base_llm/inference/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub mod secrets;
diff --git a/litellm-rust/crates/llms/src/base_llm/inference/secrets.rs b/litellm-rust/crates/llms/src/base_llm/inference/secrets.rs
deleted file mode 100644
index eb13fe95116a..000000000000
--- a/litellm-rust/crates/llms/src/base_llm/inference/secrets.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-use std::sync::Arc;
-
-use futures_util::future::BoxFuture;
-use litellm_core_utils::settings::{Lookup, ProcessEnvironment};
-use litellm_secrets::Error;
-
-pub type Secrets = Arc<dyn Lookup + Send + Sync>;
-
-pub trait SecretSource: Send + Sync {
-    fn resolve<'a>(&'a self, names: &'a [&'static str]) -> BoxFuture<'a, Result<Secrets, Error>>;
-}
-
-pub struct EnvironmentSecrets;
-
-impl SecretSource for EnvironmentSecrets {
-    fn resolve<'a>(&'a self, _names: &'a [&'static str]) -> BoxFuture<'a, Result<Secrets, Error>> {
-        Box::pin(async { Ok(Arc::new(ProcessEnvironment) as Secrets) })
-    }
-}
diff --git a/litellm-rust/crates/llms/src/base_llm/mod.rs b/litellm-rust/crates/llms/src/base_llm/mod.rs
index 9cced64b6871..8ed37da45734 100644
--- a/litellm-rust/crates/llms/src/base_llm/mod.rs
+++ b/litellm-rust/crates/llms/src/base_llm/mod.rs
@@ -2,6 +2,5 @@ pub mod anthropic_messages;
 pub mod audio_transcription;
 pub mod base_model_iterator;
 pub mod chat;
-pub mod inference;
 pub mod ocr;
 pub mod responses;
diff --git a/litellm-rust/crates/llms/src/base_llm/ocr/handler.rs b/litellm-rust/crates/llms/src/base_llm/ocr/handler.rs
index 3ec9de8197f9..9527fd20f2de 100644
--- a/litellm-rust/crates/llms/src/base_llm/ocr/handler.rs
+++ b/litellm-rust/crates/llms/src/base_llm/ocr/handler.rs
@@ -13,7 +13,6 @@ use litellm_http::{
 use serde::{Serialize, de::DeserializeOwned};
 use serde_json::Value;
 
-use crate::base_llm::inference::secrets::SecretSource;
 use crate::base_llm::ocr::{
     error::Error,
     settings::OcrSettings,
@@ -22,6 +21,7 @@ use crate::base_llm::ocr::{
         PreparedOcrRequest, decode_request_value, decode_response,
     },
 };
+use litellm_secrets::source::SecretSource;
 
 /// The route's view of one call, handed to provider code that has to reach the
 /// caller's hooks mid-flight (guardrails on the outgoing body, raw response events).
@@ -95,7 +95,7 @@ impl OcrClient {
             document_fetcher: MediaFetcher::for_test(document_http),
             vertex_auth: VertexAuth::default(),
             settings: OcrSettings::default(),
-            secrets: Arc::new(crate::base_llm::inference::secrets::EnvironmentSecrets),
+            secrets: Arc::new(litellm_secrets::source::EnvironmentSecrets::default()),
         }
     }
 
diff --git a/litellm-rust/crates/llms/src/base_llm/ocr/transformation.rs b/litellm-rust/crates/llms/src/base_llm/ocr/transformation.rs
index 0506ff3d6dfe..3f1b260bb134 100644
--- a/litellm-rust/crates/llms/src/base_llm/ocr/transformation.rs
+++ b/litellm-rust/crates/llms/src/base_llm/ocr/transformation.rs
@@ -7,6 +7,7 @@ use litellm_core_utils::{
     settings::ProcessEnvironment,
 };
 use litellm_http::outbound::{OutboundRequest, RequestSigner};
+use litellm_secrets::source::Secrets;
 use serde::{
     Deserialize, Serialize,
     de::{DeserializeOwned, IntoDeserializer},
@@ -14,13 +15,10 @@ use serde::{
 use serde_json::{Map, Value};
 use serde_with::serde_as;
 
-use crate::base_llm::{
-    inference::secrets::Secrets,
-    ocr::{
-        error::Error,
-        handler::{CallHooks, OcrClient, read_response_bytes, transform_request_body},
-        settings::OcrSettings,
-    },
+use crate::base_llm::ocr::{
+    error::Error,
+    handler::{CallHooks, OcrClient, read_response_bytes, transform_request_body},
+    settings::OcrSettings,
 };
 
 pub const OCR_RESPONSE_MAX_BYTES: usize = 64 * 1024 * 1024;
diff --git a/litellm-rust/crates/python-bridge/Cargo.toml b/litellm-rust/crates/python-bridge/Cargo.toml
index 85e6b9588dd8..a02adfaa0646 100644
--- a/litellm-rust/crates/python-bridge/Cargo.toml
+++ b/litellm-rust/crates/python-bridge/Cargo.toml
@@ -45,7 +45,7 @@ litellm-core-utils.workspace = true
 litellm-auth-gcp.workspace = true
 litellm-http.workspace = true
 litellm-llms.workspace = true
-litellm-secrets = { workspace = true, features = ["aws"] }
+litellm-secrets = { workspace = true, features = ["aws", "azure", "google", "hashicorp", "cyberark"] }
 litellm-secrets-types.workspace = true
 litellm-types.workspace = true
 litellm-host-python.workspace = true
@@ -55,6 +55,7 @@ pyo3-async-runtimes.workspace = true
 reqwest.workspace = true
 redis = { version = "1.7.0", features = ["tls-rustls"] }
 serde_json.workspace = true
+veil.workspace = true
 thiserror.workspace = true
 tokio = { workspace = true, features = ["rt", "sync"] }
 url.workspace = true
diff --git a/litellm-rust/crates/python-bridge/README.md b/litellm-rust/crates/python-bridge/README.md
index faaca233f5a4..fa8df8757ffc 100644
--- a/litellm-rust/crates/python-bridge/README.md
+++ b/litellm-rust/crates/python-bridge/README.md
@@ -1,5 +1,10 @@
-Native OCR uses `SecretSource` with `EnvironmentSecrets`, preserving process-environment reads. Readable Python secret managers still make OCR decline to the existing Python implementation. `ResolvedSecrets` and the separate `secret_manager_binding()` snapshot are inactive foundations for a later rollout
+Native OCR uses `litellm_secrets::source::SecretSource`. Built-in secret managers resolve to retained Rust backends. Custom Python managers and overrides keep the callback path. Readable managers still require the Rust secret-manager binding to be enabled
 
-Cache and secret-manager catalog entries remain Python-only, including when `LITELLM_RUST=1`. The new cache runtime is not connected to SDK or gateway caching
+The shared proxy initializer captures native configuration without loading the extension or doing native I/O. `_SecretManagerRuntime.from_client` constructs a backend on first use and keeps its handle on the Python client. The secret-manager dispatcher selects Python or Rust through `catalog.py`. Native reads call that handle; Rust routes extract the backend directly. Configuration changes replace the handle, while calls already bound to the previous backend keep using it. Handles cannot be reused after fork. Directly constructed LiteLLM managers are adapted on first native use. Manually supplied SDK clients keep their Python behavior because their credentials cannot be inferred safely. Provider implementations contain no bridge registration
+
+Retention describes ownership and lifetime. `callbacks-legacy-python::PublicCall` owns Python references for one call to preserve identity. A native cache or secret-manager handle owns shared Rust state across calls to preserve connection pools and caches. Both use existing `Py<T>` and shared Rust ownership, with execution and GIL transitions handled by `litellm-host-python`
+
+
+Cache and secret-manager catalog entries remain Python-only, including when `LITELLM_RUST=1`. This wiring does not change rollout policy
 
 OCR provider requests use the shared `litellm-http` pool. AWS and Google secret-manager SDK clients keep their SDK transports, which do not yet inherit the pool's proxy, TLS, certificate, timeout, or observability configuration. Preserve those SDK transports and configure them equivalently instead of forcing them through reqwest
diff --git a/litellm-rust/crates/python-bridge/src/lib.rs b/litellm-rust/crates/python-bridge/src/lib.rs
index 76de2ae2b7b6..54b13ba01bb3 100644
--- a/litellm-rust/crates/python-bridge/src/lib.rs
+++ b/litellm-rust/crates/python-bridge/src/lib.rs
@@ -8,10 +8,6 @@ mod logger;
 mod marshal;
 mod python_settings;
 mod routes;
-#[allow(
-    dead_code,
-    reason = "secret-manager foundations await rollout activation"
-)]
 mod secrets;
 mod tokenizer;
 
@@ -56,7 +52,11 @@ mod _native {
         let dict = module.dict();
         dict.set_item("_CacheTestHandle", py.get_type::<CacheTestHandle>())?;
         dict.set_item("_CacheTestResolver", py.get_type::<CacheTestResolver>())?;
-        dict.set_item("_ResponseCacheRuntime", py.get_type::<ResolvedCache>())
+        dict.set_item("_ResponseCacheRuntime", py.get_type::<ResolvedCache>())?;
+        dict.set_item(
+            "_SecretManagerRuntime",
+            py.get_type::<crate::secrets::runtime::NativeSecretManager>(),
+        )
     }
 }
 
diff --git a/litellm-rust/crates/python-bridge/src/routes/ocr/mod.rs b/litellm-rust/crates/python-bridge/src/routes/ocr/mod.rs
index ca5abf1f80e0..55b6b0ce21d3 100644
--- a/litellm-rust/crates/python-bridge/src/routes/ocr/mod.rs
+++ b/litellm-rust/crates/python-bridge/src/routes/ocr/mod.rs
@@ -3,17 +3,14 @@ mod errors;
 mod host;
 mod project;
 
-use std::sync::{Arc, LazyLock};
+use std::sync::LazyLock;
 
 use host::OcrRouteHost;
 use litellm_auth_gcp::VertexAuth;
 use litellm_callbacks_legacy_python::{LegacySurface, PublicCall, run_legacy_call};
 use litellm_core::ocr::route::ocr_machine;
 use litellm_core_utils::settings::ProcessEnvironment;
-use litellm_llms::base_llm::{
-    inference::secrets::{EnvironmentSecrets, SecretSource},
-    ocr::{handler::OcrClient, settings::OcrSettings},
-};
+use litellm_llms::base_llm::ocr::{handler::OcrClient, settings::OcrSettings};
 use pyo3::{
     prelude::*,
     types::{PyDict, PyTuple},
@@ -21,14 +18,11 @@ use pyo3::{
 
 use crate::{
     coercion::FieldSpec,
-    errors::RustBridgeDeclined,
     http,
     python_settings::{PythonSettings, Snapshot},
+    secrets,
 };
 
-const SECRET_MANAGER_READABLE: FieldSpec<bool> =
-    FieldSpec::new("readable", |field| field.schema_bool());
-
 const VERTEX_PROJECT: FieldSpec<Option<String>> =
     FieldSpec::new("vertex_project", |field| field.falsy_optional_string());
 const VERTEX_LOCATION: FieldSpec<Option<String>> =
@@ -58,7 +52,7 @@ fn run_ocr(
     kwargs: Bound<'_, PyDict>,
     asynchronous: bool,
 ) -> PyResult<Py<PyAny>> {
-    let secrets = process_environment_secrets(&PythonSettings::SecretManager.read(py)?)?;
+    let secrets = secrets::source(py)?;
     let config = http::call_config(py, &kwargs, asynchronous)?;
     let client = OcrClient::new(
         http::pool(),
@@ -79,15 +73,6 @@ fn run_ocr(
     )
 }
 
-fn process_environment_secrets(snapshot: &Snapshot<'_>) -> PyResult<Arc<dyn SecretSource>> {
-    if snapshot.read(&SECRET_MANAGER_READABLE)? {
-        return Err(RustBridgeDeclined::new_err(
-            "a readable secret manager is configured and the Rust route only reads the process environment",
-        ));
-    }
-    Ok(Arc::new(EnvironmentSecrets))
-}
-
 fn ocr_settings(py: Python<'_>) -> PyResult<OcrSettings> {
     project_provider_defaults(&PythonSettings::ProviderDefaults.read(py)?)
 }
@@ -123,38 +108,10 @@ pub(crate) fn aocr(
 
 #[cfg(test)]
 mod tests {
-    use pyo3::{prelude::*, types::PyDict};
-
-    use super::process_environment_secrets;
-    use crate::errors::RustBridgeDeclined;
+    use pyo3::prelude::*;
 
     use crate::python_settings::PythonSettings;
 
-    fn secret_manager<'py>(py: Python<'py>, readable: bool) -> Bound<'py, PyAny> {
-        let locals = PyDict::new(py);
-        locals.set_item("readable", readable).unwrap();
-        py.run(
-            c"import types\nmanager = types.SimpleNamespace(readable=readable)",
-            Some(&locals),
-            Some(&locals),
-        )
-        .unwrap();
-        locals.get_item("manager").unwrap().unwrap()
-    }
-
-    #[test]
-    fn a_readable_secret_manager_sends_the_call_back_to_python() {
-        Python::initialize();
-        Python::attach(|py| {
-            let declined = process_environment_secrets(
-                &PythonSettings::SecretManager.snapshot(secret_manager(py, true)),
-            )
-            .err()
-            .expect("the Rust route declines");
-            assert!(declined.is_instance_of::<RustBridgeDeclined>(py));
-        });
-    }
-
     #[test]
     fn provider_defaults_distinguish_falsey_values_and_exact_true() {
         Python::initialize();
diff --git a/litellm-rust/crates/python-bridge/src/secrets/callback.rs b/litellm-rust/crates/python-bridge/src/secrets/callback.rs
index a8e5850fe3fa..df9fc86f1774 100644
--- a/litellm-rust/crates/python-bridge/src/secrets/callback.rs
+++ b/litellm-rust/crates/python-bridge/src/secrets/callback.rs
@@ -4,11 +4,17 @@ use litellm_core_utils::settings::Lookup;
 use litellm_secrets::{
     Error, ExternalSecretManager, KeyManagementSettings, KeyManagementSystem, Secret, SecretValue,
 };
-use pyo3::{prelude::*, types::PyDict};
+use pyo3::{
+    exceptions::PyException,
+    prelude::*,
+    types::{PyDict, PyString},
+};
 
-use super::error::external_error;
+use super::error::{external_error, read_error};
 
 const HANDLER_MODULE: &str = "litellm.secret_managers.secret_manager_handler";
+const ENVIRONMENT_FALLBACK_LOG: &str =
+    "Defaulting to os.environ value for key=%s. An exception occurred - %s.\n\n%s";
 
 /// A secret manager whose reads execute in Python: a custom manager, a legacy compatible
 /// client, or a manually assigned SDK client.
@@ -33,23 +39,6 @@ impl PythonSecretManager {
 
     fn read(&self, py: Python<'_>, name: &str) -> PyResult<Option<String>> {
         let client = self.client.bind(py);
-        if self.system == Some(KeyManagementSystem::Custom)
-            || (self.system.is_none() && client.hasattr("sync_read_secret")?)
-        {
-            let kwargs = PyDict::new(py);
-            kwargs.set_item("secret_name", name)?;
-            if self.system == Some(KeyManagementSystem::Custom) {
-                let optional_params = self
-                    .settings
-                    .as_ref()
-                    .map(|settings| settings.bind(py).call_method0("model_dump"))
-                    .transpose()?;
-                kwargs.set_item("optional_params", optional_params)?;
-            }
-            return client
-                .call_method("sync_read_secret", (), Some(&kwargs))?
-                .extract();
-        }
         let kwargs = PyDict::new(py);
         kwargs.set_item("client", client)?;
         kwargs.set_item("key_manager", self.system.map_or("local", python_name))?;
@@ -58,10 +47,15 @@ impl PythonSecretManager {
             Some(settings) => kwargs.set_item("key_management_settings", settings.bind(py))?,
             None => kwargs.set_item("key_management_settings", py.None())?,
         }
-        py.import(HANDLER_MODULE)?
+        let result = py
+            .import(HANDLER_MODULE)?
             .getattr("get_secret_from_manager")?
-            .call((), Some(&kwargs))?
-            .extract()
+            .call((), Some(&kwargs))?;
+        if result.is_instance_of::<PyString>() {
+            result.extract().map(Some)
+        } else {
+            Ok(None)
+        }
     }
 }
 
@@ -92,15 +86,35 @@ impl ExternalSecretManager for PythonSecretManager {
         _environment: &'a (dyn Lookup + Send + Sync),
     ) -> Pin<Box<dyn Future<Output = Result<Option<Secret>, Error>> + Send + 'a>> {
         Box::pin(async move {
-            Python::attach(|py| {
-                self.read(py, name)
-                    .map(|value| value.map(SecretValue::new).map(Secret::String))
-                    .map_err(|error| external_error(py, error))
+            Python::attach(|py| match self.read(py, name) {
+                Ok(value) => Ok(value.map(SecretValue::new).map(Secret::String)),
+                // `get_secret` answers a failed manager read from the process environment, but
+                // only for `Exception`: cancellation and other `BaseException`s propagate.
+                Err(error) if error.is_instance_of::<PyException>(py) => {
+                    log_environment_fallback(py, name, &error)
+                        .map_err(|error| external_error(py, error))?;
+                    Err(read_error(py, error))
+                }
+                Err(error) => Err(external_error(py, error)),
             })
         })
     }
 }
 
+fn log_environment_fallback(py: Python<'_>, name: &str, error: &PyErr) -> PyResult<()> {
+    let traceback = py
+        .import("traceback")?
+        .call_method1("format_exception", (error.value(py),))?;
+    let traceback = "".into_pyobject(py)?.call_method1("join", (traceback,))?;
+    py.import("litellm._logging")?
+        .getattr("verbose_logger")?
+        .call_method1(
+            "error",
+            (ENVIRONMENT_FALLBACK_LOG, name, error.value(py), traceback),
+        )?;
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
@@ -115,16 +129,12 @@ mod tests {
     use super::{HANDLER_MODULE, PythonSecretManager, python_name};
     use crate::secrets::python_error;
 
-    #[rstest]
-    #[case::value_error("ValueError", None)]
-    #[case::value_error_with_fallback("ValueError", Some("environment-key"))]
-    #[case::cancelled("asyncio.CancelledError", None)]
-    #[case::cancelled_with_fallback("asyncio.CancelledError", Some("environment-key"))]
-    #[tokio::test]
-    async fn callback_failures_preserve_python_exceptions_even_with_environment_fallback(
-        #[case] failure_type: &str,
-        #[case] fallback: Option<&'static str>,
-    ) {
+    /// A resolver over a Python manager whose reads raise `failure_type`, with the chained
+    /// exceptions Python attaches, and `fallback` as the process environment.
+    fn failing_resolver(
+        failure_type: &str,
+        fallback: Option<&'static str>,
+    ) -> (SecretResolver, Py<PyDict>) {
         Python::initialize();
         let (reader, locals) = Python::attach(|py| {
             let locals = PyDict::new(py);
@@ -141,6 +151,13 @@ class Manager:
     def sync_read_secret(self, secret_name):
         raise failure
 manager = Manager()
+import sys, types
+for name in ('litellm', 'litellm.secret_managers'):
+    sys.modules.setdefault(name, types.ModuleType(name))
+handler = sys.modules.setdefault('litellm.secret_managers.secret_manager_handler', types.ModuleType('litellm.secret_managers.secret_manager_handler'))
+def get_secret_from_manager(**kwargs):
+    return kwargs['client'].sync_read_secret(kwargs['secret_name'])
+handler.get_secret_from_manager = get_secret_from_manager
 ",
                 Some(&locals),
                 Some(&locals),
@@ -153,7 +170,7 @@ manager = Manager()
             );
             (reader, locals.unbind())
         });
-        let resolver = SecretResolver::new(
+        let resolver = SecretResolver::new_python_compatible(
             Arc::new(SecretManagerState::new(
                 SecretManager::External(Arc::new(reader)),
                 KeyManagementSettings::default(),
@@ -162,6 +179,19 @@ manager = Manager()
             OidcResolver::default(),
         )
         .with_failure_policy(FailurePolicy::EnvironmentFallback);
+        (resolver, locals)
+    }
+
+    #[rstest]
+    #[case::cancelled("asyncio.CancelledError", None)]
+    #[case::cancelled_with_fallback("asyncio.CancelledError", Some("environment-key"))]
+    #[case::keyboard_interrupt("KeyboardInterrupt", Some("environment-key"))]
+    #[tokio::test]
+    async fn base_exceptions_propagate_unchanged_even_with_environment_fallback(
+        #[case] failure_type: &str,
+        #[case] fallback: Option<&'static str>,
+    ) {
+        let (resolver, locals) = failing_resolver(failure_type, fallback);
         let error = resolver.get_secret("API_KEY", None).await.unwrap_err();
         Python::attach(|py| {
             let original = python_error(py, &error).unwrap();
@@ -184,24 +214,96 @@ manager = Manager()
         });
     }
 
+    /// Installs a persistent `litellm._logging` stub whose `verbose_logger.error` records its
+    /// arguments, and returns those recorded for `name`.
+    fn logged_errors<'py>(py: Python<'py>, name: &str) -> Vec<Bound<'py, PyAny>> {
+        py.run(
+            c"
+import sys, types
+class Logger:
+    calls = []
+    def error(self, *args):
+        self.calls.append(args)
+logging = types.ModuleType('litellm._logging')
+logging.verbose_logger = Logger()
+sys.modules.setdefault('litellm', types.ModuleType('litellm'))
+sys.modules.setdefault('litellm._logging', logging)
+",
+            None,
+            None,
+        )
+        .unwrap();
+        py.import("litellm._logging")
+            .unwrap()
+            .getattr("verbose_logger")
+            .unwrap()
+            .getattr("calls")
+            .unwrap()
+            .try_iter()
+            .unwrap()
+            .map(Result::unwrap)
+            .filter(|call| call.get_item(1).unwrap().extract::<String>().unwrap() == name)
+            .collect()
+    }
+
+    #[rstest]
+    #[case::value_error("ValueError", None, "FALLBACK_VALUE_ERROR")]
+    #[case::value_error_with_fallback(
+        "ValueError",
+        Some("environment-key"),
+        "FALLBACK_VALUE_ERROR_WITH_ENVIRONMENT"
+    )]
+    #[case::runtime_error_with_fallback(
+        "RuntimeError",
+        Some("environment-key"),
+        "FALLBACK_RUNTIME_ERROR_WITH_ENVIRONMENT"
+    )]
+    #[tokio::test]
+    async fn exceptions_are_logged_and_answered_from_the_environment(
+        #[case] failure_type: &str,
+        #[case] fallback: Option<&'static str>,
+        #[case] name: &str,
+    ) {
+        let (resolver, _locals) = failing_resolver(failure_type, fallback);
+        Python::attach(|py| assert!(logged_errors(py, name).is_empty()));
+        let secret = resolver.get_secret(name, None).await.unwrap();
+        assert_eq!(
+            secret.map(|secret| match secret {
+                litellm_secrets::Secret::String(value) => value.expose().to_owned(),
+                other => panic!("unexpected secret {other:?}"),
+            }),
+            fallback.map(str::to_owned)
+        );
+        Python::attach(|py| {
+            let calls = logged_errors(py, name);
+            assert_eq!(calls.len(), 1);
+            assert!(
+                calls[0]
+                    .get_item(3)
+                    .unwrap()
+                    .extract::<String>()
+                    .unwrap()
+                    .contains("sync_read_secret")
+            );
+        });
+    }
+
     /// Installs a fake `get_secret_from_manager` that records its kwargs, runs `body`, and
-    /// removes the fake modules again.
+    /// removes the fake handler again; parent package stubs persist for concurrent tests.
     fn with_fake_handler<'py>(py: Python<'py>, body: impl FnOnce(&Bound<'py, PyDict>)) {
         let locals = PyDict::new(py);
         py.run(
             c"
 import sys, types
+previous_handler = sys.modules.get('litellm.secret_managers.secret_manager_handler')
 calls = []
 def get_secret_from_manager(**kwargs):
     calls.append(kwargs)
     return 'handled-' + kwargs['secret_name']
 handler = types.ModuleType('litellm.secret_managers.secret_manager_handler')
 handler.get_secret_from_manager = get_secret_from_manager
-installed = {}
 for name in ('litellm', 'litellm.secret_managers'):
-    if name not in sys.modules:
-        sys.modules[name] = types.ModuleType(name)
-        installed[name] = True
+    sys.modules.setdefault(name, types.ModuleType(name))
 sys.modules['litellm.secret_managers.secret_manager_handler'] = handler
 ",
             Some(&locals),
@@ -211,9 +313,10 @@ sys.modules['litellm.secret_managers.secret_manager_handler'] = handler
         body(&locals);
         py.run(
             c"
-sys.modules.pop('litellm.secret_managers.secret_manager_handler', None)
-for name in installed:
-    sys.modules.pop(name, None)
+if previous_handler is None:
+    sys.modules.pop('litellm.secret_managers.secret_manager_handler', None)
+else:
+    sys.modules['litellm.secret_managers.secret_manager_handler'] = previous_handler
 ",
             Some(&locals),
             Some(&locals),
@@ -221,6 +324,28 @@ for name in installed:
         .unwrap();
     }
 
+    #[rstest]
+    #[case("None")]
+    #[case("True")]
+    #[case("123")]
+    #[case("{'key': 'value'}")]
+    fn nonstring_results_are_absent_without_a_read_failure(#[case] expression: &str) {
+        Python::initialize();
+        Python::attach(|py| {
+            with_fake_handler(py, |locals| {
+                locals.set_item("expression", expression).unwrap();
+                py.run(
+                    c"handler.get_secret_from_manager = lambda **kwargs: eval(expression)",
+                    Some(locals),
+                    Some(locals),
+                )
+                .unwrap();
+                let reader = PythonSecretManager::new(py.None(), None, None);
+                assert_eq!(reader.read(py, "KEY").unwrap(), None);
+            });
+        });
+    }
+
     #[rstest]
     #[case::google_kms(KeyManagementSystem::GoogleKms)]
     #[case::azure_key_vault(KeyManagementSystem::AzureKeyVault)]
@@ -238,72 +363,6 @@ for name in installed:
         );
     }
 
-    #[rstest]
-    #[case::legacy(None, false)]
-    #[case::custom(Some(KeyManagementSystem::Custom), true)]
-    fn direct_readers_receive_compatible_kwargs(
-        #[case] system: Option<KeyManagementSystem>,
-        #[case] expects_optional_params: bool,
-    ) {
-        Python::initialize();
-        Python::attach(|py| {
-            let locals = PyDict::new(py);
-            py.run(
-                c"
-class Settings:
-    def model_dump(self):
-        return {'scope': 'custom'}
-class Manager:
-    def __init__(self):
-        self.names = []
-        self.optional_params = []
-    def sync_read_secret(self, secret_name, optional_params=None, timeout=None):
-        self.names.append(secret_name)
-        self.optional_params.append(optional_params)
-        return 'direct-' + secret_name
-manager = Manager()
-settings = Settings()
-",
-                Some(&locals),
-                Some(&locals),
-            )
-            .unwrap();
-            let manager = locals.get_item("manager").unwrap().unwrap();
-            let settings = expects_optional_params
-                .then(|| locals.get_item("settings").unwrap().unwrap().unbind());
-            let reader = PythonSecretManager::new(manager.clone().unbind(), system, settings);
-            assert_eq!(
-                reader.read(py, "API_KEY").unwrap().as_deref(),
-                Some("direct-API_KEY")
-            );
-            assert_eq!(
-                manager
-                    .getattr("names")
-                    .unwrap()
-                    .extract::<Vec<String>>()
-                    .unwrap(),
-                ["API_KEY"]
-            );
-            let optional_params = manager
-                .getattr("optional_params")
-                .unwrap()
-                .get_item(0)
-                .unwrap();
-            if expects_optional_params {
-                assert_eq!(
-                    optional_params
-                        .get_item("scope")
-                        .unwrap()
-                        .extract::<String>()
-                        .unwrap(),
-                    "custom"
-                );
-            } else {
-                assert!(optional_params.is_none());
-            }
-        });
-    }
-
     #[test]
     fn configured_systems_dispatch_through_the_python_handler_with_the_original_settings() {
         Python::initialize();
@@ -349,4 +408,57 @@ settings = Settings()
             });
         });
     }
+
+    #[rstest]
+    #[case::manually_assigned(None, "local")]
+    #[case::custom(Some(KeyManagementSystem::Custom), "custom")]
+    fn direct_readers_dispatch_through_the_python_handler_like_get_secret(
+        #[case] system: Option<KeyManagementSystem>,
+        #[case] key_manager: &str,
+    ) {
+        Python::initialize();
+        Python::attach(|py| {
+            with_fake_handler(py, |locals| {
+                py.run(
+                    c"
+class Manager:
+    def __init__(self):
+        self.names = []
+    def sync_read_secret(self, secret_name, optional_params=None, timeout=None):
+        self.names.append(secret_name)
+        return 'direct-' + secret_name
+manager = Manager()
+",
+                    Some(locals),
+                    Some(locals),
+                )
+                .unwrap();
+                let manager = locals.get_item("manager").unwrap().unwrap();
+                let reader = PythonSecretManager::new(manager.clone().unbind(), system, None);
+                assert_eq!(
+                    reader.read(py, "API_KEY").unwrap().as_deref(),
+                    Some("handled-API_KEY")
+                );
+                assert_eq!(
+                    manager
+                        .getattr("names")
+                        .unwrap()
+                        .extract::<Vec<String>>()
+                        .unwrap(),
+                    Vec::<String>::new()
+                );
+                let calls = locals.get_item("calls").unwrap().unwrap();
+                let call = calls.get_item(0).unwrap().cast_into::<PyDict>().unwrap();
+                assert!(call.get_item("client").unwrap().unwrap().is(&manager));
+                assert_eq!(
+                    call.get_item("key_manager")
+                        .unwrap()
+                        .unwrap()
+                        .extract::<String>()
+                        .unwrap(),
+                    key_manager
+                );
+            });
+        });
+    }
 }
diff --git a/litellm-rust/crates/python-bridge/src/secrets/config.rs b/litellm-rust/crates/python-bridge/src/secrets/config.rs
index 6fd380fe40c4..4a666ca1ded0 100644
--- a/litellm-rust/crates/python-bridge/src/secrets/config.rs
+++ b/litellm-rust/crates/python-bridge/src/secrets/config.rs
@@ -56,13 +56,23 @@ const SETTINGS_OBJECT: FieldSpec<Option<Py<PyAny>>> =
     FieldSpec::new("settings_object", |field| Ok(field.python_binding()));
 
 /// `litellm.secret_manager_client` as the bridge classifies it.
-#[derive(Debug)]
 pub(crate) enum SecretManagerClient {
     /// `None`: reads come from the process environment.
     Local,
     /// A custom manager, legacy compatible client, or manually assigned SDK client that keeps
     /// executing in Python.
     PythonCallback(Py<PyAny>),
+    Native(Box<SecretManager>),
+}
+
+impl std::fmt::Debug for SecretManagerClient {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.write_str(match self {
+            Self::Local => "Local",
+            Self::Native(_) => "Native",
+            Self::PythonCallback(_) => "PythonCallback",
+        })
+    }
 }
 
 /// One operation-local capture of the secret manager globals, taken while attached to Python.
@@ -79,6 +89,9 @@ pub(crate) struct SecretManagerSnapshot {
 impl SecretManagerSnapshot {
     pub(crate) fn into_state(self) -> Arc<SecretManagerState> {
         match self.client {
+            SecretManagerClient::Native(backend) => {
+                Arc::new(SecretManagerState::new(*backend, self.settings))
+            }
             SecretManagerClient::Local => Arc::new(SecretManagerState::default()),
             SecretManagerClient::PythonCallback(client) => Arc::new(SecretManagerState::new(
                 SecretManager::External(Arc::new(PythonSecretManager::new(
@@ -94,7 +107,32 @@ impl SecretManagerSnapshot {
 
 /// Reads and projects the secret manager settings group in one attached operation.
 pub(crate) fn read(py: Python<'_>) -> PyResult<SecretManagerSnapshot> {
-    Ok(project(&PythonSettings::SecretManagerBinding.read(py)?)?)
+    let snapshot = project(&PythonSettings::SecretManagerBinding.read(py)?)?;
+    let SecretManagerClient::PythonCallback(client) = &snapshot.client else {
+        return Ok(snapshot);
+    };
+    if matches!(
+        snapshot.system,
+        Some(KeyManagementSystem::Custom | KeyManagementSystem::Local)
+    ) {
+        return Ok(snapshot);
+    }
+    let Some(native) = super::runtime::NativeSecretManager::from_client(client.bind(py))? else {
+        return Ok(snapshot);
+    };
+    let backend = native.borrow(py).backend()?;
+    if snapshot
+        .system
+        .is_some_and(|system| system != backend.system())
+    {
+        return Err(pyo3::exceptions::PyValueError::new_err(
+            "native secret manager system does not match configuration",
+        ));
+    }
+    Ok(SecretManagerSnapshot {
+        client: SecretManagerClient::Native(Box::new(backend)),
+        ..snapshot
+    })
 }
 
 pub(crate) fn project(snapshot: &Snapshot<'_>) -> Result<SecretManagerSnapshot, ProjectionError> {
diff --git a/litellm-rust/crates/python-bridge/src/secrets/error.rs b/litellm-rust/crates/python-bridge/src/secrets/error.rs
index 1bf9351ee64e..5ccfd0a15542 100644
--- a/litellm-rust/crates/python-bridge/src/secrets/error.rs
+++ b/litellm-rust/crates/python-bridge/src/secrets/error.rs
@@ -17,8 +17,12 @@ pub(super) fn external_error(py: Python<'_>, error: PyErr) -> Error {
     Error::ExternalManager(Box::new(PythonSecretError(error.into_value(py))))
 }
 
+pub(super) fn read_error(py: Python<'_>, error: PyErr) -> Error {
+    Error::ExternalRead(Box::new(PythonSecretError(error.into_value(py))))
+}
+
 pub(crate) fn python_error(py: Python<'_>, error: &Error) -> Option<PyErr> {
-    let Error::ExternalManager(source) = error else {
+    let (Error::ExternalManager(source) | Error::ExternalRead(source)) = error else {
         return None;
     };
     source
diff --git a/litellm-rust/crates/python-bridge/src/secrets/mod.rs b/litellm-rust/crates/python-bridge/src/secrets/mod.rs
index c753015aa9e6..f0ad98dbbd87 100644
--- a/litellm-rust/crates/python-bridge/src/secrets/mod.rs
+++ b/litellm-rust/crates/python-bridge/src/secrets/mod.rs
@@ -1,6 +1,105 @@
 pub(crate) mod callback;
 pub(crate) mod config;
 mod error;
+mod mutation;
+mod operations;
+mod provider;
 pub(crate) mod resolved;
+pub(crate) mod runtime;
+mod vault;
+
+use std::sync::Arc;
+
+use litellm_secrets::source::{EnvironmentSecrets, SecretSource};
+use pyo3::prelude::*;
 
 pub(crate) use error::python_error;
+use resolved::ResolvedSecrets;
+
+use crate::{
+    coercion::FieldSpec,
+    errors::RustBridgeDeclined,
+    python_settings::{PythonSettings, Snapshot},
+};
+
+const READABLE: FieldSpec<bool> = FieldSpec::new("readable", |field| field.schema_bool());
+const NATIVE: FieldSpec<bool> = FieldSpec::new("native", |field| field.schema_bool());
+
+/// Where a Rust route reads provider secrets from, as `litellm.get_secret` would.
+pub(crate) fn source(py: Python<'_>) -> PyResult<Arc<dyn SecretSource>> {
+    select(&PythonSettings::SecretManager.read(py)?, || {
+        Ok(Arc::new(ResolvedSecrets::new(config::read(py)?)))
+    })
+}
+
+fn select(
+    manager: &Snapshot<'_>,
+    resolved: impl FnOnce() -> PyResult<Arc<dyn SecretSource>>,
+) -> PyResult<Arc<dyn SecretSource>> {
+    if !manager.read(&READABLE)? {
+        return Ok(Arc::new(EnvironmentSecrets::python_compatible()));
+    }
+    if !manager.read(&NATIVE)? {
+        return Err(RustBridgeDeclined::new_err(
+            "the configured secret manager is not enabled for the Rust bridge",
+        ));
+    }
+    resolved()
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use litellm_secrets::source::{EnvironmentSecrets, SecretSource};
+    use pyo3::{prelude::*, types::PyDict};
+    use rstest::rstest;
+
+    use super::select;
+    use crate::{errors::RustBridgeDeclined, python_settings::PythonSettings};
+
+    enum Selected {
+        Environment,
+        Declined,
+        Resolved,
+    }
+
+    #[rstest]
+    #[case::unreadable(false, false, Selected::Environment)]
+    #[case::unreadable_even_if_native(false, true, Selected::Environment)]
+    #[case::readable_python_only(true, false, Selected::Declined)]
+    #[case::readable_native(true, true, Selected::Resolved)]
+    fn readable_and_native_select_the_secret_source(
+        #[case] readable: bool,
+        #[case] native: bool,
+        #[case] expected: Selected,
+    ) {
+        Python::initialize();
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            locals.set_item("readable", readable).unwrap();
+            locals.set_item("native", native).unwrap();
+            let manager = py
+                .eval(
+                    c"__import__('types').SimpleNamespace(readable=readable, native=native)",
+                    None,
+                    Some(&locals),
+                )
+                .unwrap();
+            let mut resolved_called = false;
+            let selected = select(&PythonSettings::SecretManager.snapshot(manager), || {
+                resolved_called = true;
+                Ok(Arc::new(EnvironmentSecrets::python_compatible()) as Arc<dyn SecretSource>)
+            });
+            match expected {
+                Selected::Environment => assert!(selected.is_ok() && !resolved_called),
+                Selected::Resolved => assert!(selected.is_ok() && resolved_called),
+                Selected::Declined => {
+                    let error = selected.err().expect("the Rust route declines");
+                    assert!(error.is_instance_of::<RustBridgeDeclined>(py));
+                    assert!(!resolved_called);
+                }
+            }
+        });
+    }
+}
diff --git a/litellm-rust/crates/python-bridge/src/secrets/mutation.rs b/litellm-rust/crates/python-bridge/src/secrets/mutation.rs
new file mode 100644
index 000000000000..eaab06a5b126
--- /dev/null
+++ b/litellm-rust/crates/python-bridge/src/secrets/mutation.rs
@@ -0,0 +1,113 @@
+use super::operations::{PythonMutationError, PythonMutationResponse};
+use litellm_host_python::{json_loads, to_py};
+use litellm_secrets::cyberark;
+use pyo3::{exceptions::PyValueError, prelude::*, types::PyDict};
+
+pub(super) fn mutation_value(
+    result: Result<PythonMutationResponse, PythonMutationError>,
+    context: &super::vault::ErrorContext,
+) -> PyResult<Py<PyAny>> {
+    Python::attach(|py| match result {
+        Ok(PythonMutationResponse::Value(value)) => to_py(py, &value),
+        Ok(PythonMutationResponse::Json(body)) => match json_value(py, &body) {
+            Ok(value) => Ok(value),
+            Err(error) => error_value(py, error.value(py).str()?.extract()?),
+        },
+        Err(PythonMutationError::Vault(failure)) => {
+            super::vault::failure_value(py, *failure, context)
+        }
+        Err(PythonMutationError::CyberarkWrite { name, failure }) => {
+            let message = cyberark_failure(py, &name, *failure)?;
+            to_py(
+                py,
+                &serde_json::json!({"status": "error", "message": message}),
+            )
+        }
+        Err(PythonMutationError::CurrentMissing(name)) => Err(PyValueError::new_err(format!(
+            "Current secret {name} not found"
+        ))),
+        Err(PythonMutationError::ReplacementMissing(name)) => Err(PyValueError::new_err(format!(
+            "Failed to verify new secret {name}"
+        ))),
+        Err(PythonMutationError::ReplacementMismatch) => {
+            Err(PyValueError::new_err("New secret value mismatch"))
+        }
+        Err(PythonMutationError::Unsupported) => Err(PyValueError::new_err(
+            "native secret manager mutation is unavailable",
+        )),
+    })
+}
+
+fn cyberark_failure(
+    py: Python<'_>,
+    name: &str,
+    failure: cyberark::WriteFailure,
+) -> PyResult<String> {
+    let message = match failure.source {
+        cyberark::Error::Status(status) | cyberark::Error::AuthStatus(status) => {
+            let url = failure
+                .request_url
+                .as_ref()
+                .map_or("", reqwest::Url::as_str);
+            http_message(py, "POST", url, status)?
+        }
+        cyberark::Error::Operation(litellm_secrets_types::Error::UnsafeSecretName) => {
+            format!("Invalid secret_name {}", name.into_pyobject(py)?.repr()?)
+        }
+        cyberark::Error::Http(source) if failure.authentication => match os_error_code(&source) {
+            Some(code) => {
+                let reason = py.import("os")?.getattr("strerror")?.call1((code,))?;
+                py.import("builtins")?
+                    .getattr("OSError")?
+                    .call1((code, reason))?
+                    .str()?
+                    .extract()?
+            }
+            None => cyberark::Error::Http(source).to_string(),
+        },
+        cyberark::Error::Http(source) if source.is_connect() => {
+            "All connection attempts failed".to_owned()
+        }
+        source => source.to_string(),
+    };
+    Ok(if failure.authentication {
+        format!("Could not authenticate to CyberArk Conjur: {message}")
+    } else {
+        message
+    })
+}
+
+fn os_error_code(error: &(dyn std::error::Error + 'static)) -> Option<i32> {
+    error
+        .downcast_ref::<std::io::Error>()
+        .and_then(std::io::Error::raw_os_error)
+        .or_else(|| error.source().and_then(os_error_code))
+}
+
+pub(super) fn json_value(py: Python<'_>, body: &[u8]) -> PyResult<Py<PyAny>> {
+    json_loads(py, body)
+}
+
+pub(super) fn error_value(py: Python<'_>, message: String) -> PyResult<Py<PyAny>> {
+    to_py(
+        py,
+        &serde_json::json!({"status": "error", "message": message}),
+    )
+}
+
+pub(super) fn http_message(
+    py: Python<'_>,
+    method: &str,
+    url: &str,
+    status: u16,
+) -> PyResult<String> {
+    let httpx = py.import("httpx")?;
+    let request = httpx.getattr("Request")?.call1((method, url))?;
+    let kwargs = PyDict::new(py);
+    kwargs.set_item("request", request)?;
+    let response = httpx.getattr("Response")?.call((status,), Some(&kwargs))?;
+    match response.call_method0("raise_for_status") {
+        Err(error) => error.value(py).str()?.extract(),
+        Ok(_) => Ok(format!("HTTP {status}")),
+    }
+}
diff --git a/litellm-rust/crates/python-bridge/src/secrets/operations.rs b/litellm-rust/crates/python-bridge/src/secrets/operations.rs
new file mode 100644
index 000000000000..8e338741aff9
--- /dev/null
+++ b/litellm-rust/crates/python-bridge/src/secrets/operations.rs
@@ -0,0 +1,247 @@
+use litellm_core_utils::settings::Lookup;
+use litellm_secrets::Secret;
+use litellm_secrets::cyberark::AuthenticationRetry;
+use litellm_secrets::{Error, SecretManager};
+use litellm_secrets_types::{PythonSecretRead, SecretOperationContext};
+
+pub(super) struct PythonReadRequest {
+    pub secret_name: String,
+    pub primary_secret_name: Option<String>,
+    pub context: SecretOperationContext,
+    pub synchronous: bool,
+}
+
+pub(super) async fn read_python_provider(
+    manager: &SecretManager,
+    request: &PythonReadRequest,
+    _environment: &(dyn Lookup + Send + Sync),
+) -> Result<PythonSecretRead, Error> {
+    match (manager, &request.context) {
+        (SecretManager::AwsSecretsManagerV2(client), SecretOperationContext::Aws(context)) => {
+            client
+                .read_provider_payload_for_python(
+                    &request.secret_name,
+                    request.primary_secret_name.as_deref(),
+                    context,
+                    request.synchronous,
+                    _environment,
+                )
+                .await
+                .map_err(Error::from)
+        }
+        (SecretManager::HashicorpVault(client), SecretOperationContext::Hashicorp(context)) => {
+            Ok(PythonSecretRead::Value(
+                client
+                    .async_read_secret_with_context(&request.secret_name, context)
+                    .await
+                    .unwrap_or(None)
+                    .map(Secret::String),
+            ))
+        }
+        (SecretManager::Cyberark(client), SecretOperationContext::Cyberark(_)) => {
+            Ok(PythonSecretRead::Value(
+                client
+                    .read_with_retry(
+                        &request.secret_name,
+                        &Default::default(),
+                        AuthenticationRetry::Never,
+                    )
+                    .await
+                    .unwrap_or(None)
+                    .map(Secret::String),
+            ))
+        }
+        (SecretManager::GoogleSecretManager(client), SecretOperationContext::Google(_)) => client
+            .get_secret_for_python(&request.secret_name)
+            .await
+            .map(PythonSecretRead::Value)
+            .map_err(Error::from),
+        _ => Err(Error::NativeBackendUnavailable),
+    }
+}
+
+#[derive(Debug)]
+pub(super) enum PythonMutationError {
+    Unsupported,
+    Vault(Box<super::vault::Failure>),
+    CyberarkWrite {
+        name: String,
+        failure: Box<litellm_secrets::cyberark::WriteFailure>,
+    },
+    CurrentMissing(String),
+    ReplacementMissing(String),
+    ReplacementMismatch,
+}
+
+pub(super) async fn write_python_provider(
+    manager: &SecretManager,
+    name: &str,
+    value: &litellm_secrets::SecretValue,
+) -> Result<serde_json::Value, PythonMutationError> {
+    match manager {
+        SecretManager::Cyberark(client) => {
+            client
+                .write_with_retry(name, value, &Default::default(), AuthenticationRetry::Never)
+                .await
+                .map_err(|failure| PythonMutationError::CyberarkWrite {
+                    name: name.to_owned(),
+                    failure: Box::new(failure),
+                })?;
+            Ok(write_success(name))
+        }
+        _ => Err(PythonMutationError::Unsupported),
+    }
+}
+
+pub(super) async fn delete_python_provider(
+    manager: &SecretManager,
+    name: &str,
+) -> Result<serde_json::Value, PythonMutationError> {
+    match manager {
+        SecretManager::Cyberark(client) => {
+            client
+                .async_delete_secret(name, None)
+                .await
+                .map_err(|failure| PythonMutationError::CyberarkWrite {
+                    name: name.to_owned(),
+                    failure: Box::new(litellm_secrets::cyberark::WriteFailure {
+                        source: failure,
+                        request_url: None,
+                        authentication: false,
+                    }),
+                })?;
+            Ok(serde_json::json!({
+                "status": "not_supported",
+                "message": "CyberArk Conjur does not support direct secret deletion. Use policy updates to remove variables.",
+            }))
+        }
+        _ => Err(PythonMutationError::Unsupported),
+    }
+}
+
+pub(super) async fn rotate_python_provider(
+    manager: &SecretManager,
+    current_name: &str,
+    new_name: &str,
+    value: &litellm_secrets::SecretValue,
+) -> Result<serde_json::Value, PythonMutationError> {
+    match manager {
+        SecretManager::Cyberark(client) => {
+            if client
+                .read_fresh_with_retry(
+                    current_name,
+                    &Default::default(),
+                    AuthenticationRetry::Never,
+                )
+                .await
+                .ok()
+                .flatten()
+                .is_none()
+            {
+                return Err(PythonMutationError::CurrentMissing(current_name.to_owned()));
+            }
+            client
+                .write_with_retry(
+                    new_name,
+                    value,
+                    &Default::default(),
+                    AuthenticationRetry::Never,
+                )
+                .await
+                .map_err(|failure| PythonMutationError::CyberarkWrite {
+                    name: new_name.to_owned(),
+                    failure: Box::new(failure),
+                })?;
+            let actual = client
+                .read_fresh_with_retry(new_name, &Default::default(), AuthenticationRetry::Never)
+                .await
+                .ok()
+                .flatten()
+                .ok_or_else(|| PythonMutationError::ReplacementMissing(new_name.to_owned()))?;
+            if actual != *value {
+                return Err(PythonMutationError::ReplacementMismatch);
+            }
+            if current_name != new_name {
+                client.invalidate_cached_secret(current_name).await;
+            }
+            Ok(write_success(new_name))
+        }
+        _ => Err(PythonMutationError::Unsupported),
+    }
+}
+fn write_success(name: &str) -> serde_json::Value {
+    serde_json::json!({"status": "success", "message": format!("Secret {name} written successfully")})
+}
+
+pub(super) enum PythonMutationResponse {
+    Value(serde_json::Value),
+    Json(Vec<u8>),
+}
+
+pub(super) async fn write_python_provider_with_context(
+    manager: &SecretManager,
+    name: &str,
+    value: &litellm_secrets::SecretValue,
+    context: &litellm_secrets_types::SecretWriteContext,
+) -> Result<PythonMutationResponse, PythonMutationError> {
+    if let (SecretManager::HashicorpVault(client), SecretOperationContext::Hashicorp(operation)) =
+        (manager, &context.operation)
+    {
+        return super::vault::write(
+            client,
+            name,
+            value,
+            &litellm_secrets_types::SecretWriteContext {
+                description: context.description.clone(),
+                tags: context.tags.clone(),
+                operation: operation.clone(),
+            },
+        )
+        .await
+        .map(PythonMutationResponse::Json)
+        .map_err(|failure| PythonMutationError::Vault(Box::new(failure)));
+    }
+    write_python_provider(manager, name, value)
+        .await
+        .map(PythonMutationResponse::Value)
+}
+
+pub(super) async fn delete_python_provider_with_context(
+    manager: &SecretManager,
+    name: &str,
+    context: &SecretOperationContext,
+) -> Result<PythonMutationResponse, PythonMutationError> {
+    if let (SecretManager::HashicorpVault(client), SecretOperationContext::Hashicorp(context)) =
+        (manager, context)
+    {
+        super::vault::delete(client, name, context)
+            .await
+            .map_err(|failure| PythonMutationError::Vault(Box::new(failure)))?;
+        return Ok(PythonMutationResponse::Value(serde_json::json!({
+            "status": "success", "message": format!("Secret {name} deleted successfully"),
+        })));
+    }
+    delete_python_provider(manager, name)
+        .await
+        .map(PythonMutationResponse::Value)
+}
+
+pub(super) async fn rotate_python_provider_with_context(
+    manager: &SecretManager,
+    current_name: &str,
+    new_name: &str,
+    value: &litellm_secrets::SecretValue,
+    context: &SecretOperationContext,
+) -> Result<PythonMutationResponse, PythonMutationError> {
+    if let (SecretManager::HashicorpVault(client), SecretOperationContext::Hashicorp(context)) =
+        (manager, context)
+    {
+        return super::vault::rotate(client, current_name, new_name, value, context)
+            .await
+            .map(PythonMutationResponse::Json)
+            .map_err(|failure| PythonMutationError::Vault(Box::new(failure)));
+    }
+    rotate_python_provider(manager, current_name, new_name, value)
+        .await
+        .map(PythonMutationResponse::Value)
+}
diff --git a/litellm-rust/crates/python-bridge/src/secrets/provider.rs b/litellm-rust/crates/python-bridge/src/secrets/provider.rs
new file mode 100644
index 000000000000..568a0cd22284
--- /dev/null
+++ b/litellm-rust/crates/python-bridge/src/secrets/provider.rs
@@ -0,0 +1,150 @@
+use std::time::Duration;
+
+use super::operations::PythonReadRequest;
+use litellm_secrets::{KeyManagementSystem, SecretValue};
+use litellm_secrets_types::{
+    AwsOperationContext, CyberarkOperationContext, GoogleOperationContext,
+    HashicorpOperationContext, SecretOperationContext,
+};
+use pyo3::{exceptions::PyValueError, prelude::*, types::PyDict};
+
+pub(super) fn read_request(
+    system: KeyManagementSystem,
+    secret_name: String,
+    optional_params: Option<&Bound<'_, PyAny>>,
+    timeout: Option<&Bound<'_, PyAny>>,
+    primary_secret_name: Option<String>,
+    synchronous: bool,
+) -> PyResult<PythonReadRequest> {
+    let context = match system {
+        KeyManagementSystem::AwsSecretManager => {
+            let ignored = primary_secret_name
+                .as_ref()
+                .is_some_and(|value| !value.is_empty())
+                || (synchronous
+                    && litellm_secrets::aws::secret_manager::is_bootstrap_key(&secret_name));
+            SecretOperationContext::Aws(if ignored {
+                AwsOperationContext::default()
+            } else {
+                aws_context(optional_params, timeout)?
+            })
+        }
+        KeyManagementSystem::HashicorpVault => {
+            SecretOperationContext::Hashicorp(vault_context(optional_params)?)
+        }
+        KeyManagementSystem::Cyberark => {
+            SecretOperationContext::Cyberark(CyberarkOperationContext::default())
+        }
+        KeyManagementSystem::GoogleSecretManager => {
+            SecretOperationContext::Google(GoogleOperationContext::default())
+        }
+        _ => {
+            return Err(PyValueError::new_err(
+                "secret manager does not support provider reads",
+            ));
+        }
+    };
+    Ok(PythonReadRequest {
+        secret_name,
+        primary_secret_name,
+        context,
+        synchronous,
+    })
+}
+
+fn string_field(params: Option<&Bound<'_, PyDict>>, name: &str) -> PyResult<Option<String>> {
+    let value = params
+        .map(|params| params.get_item(name))
+        .transpose()?
+        .flatten();
+    match value {
+        Some(value) if value.is_truthy()? => value.extract().map(Some),
+        _ => Ok(None),
+    }
+}
+
+fn aws_context(
+    params: Option<&Bound<'_, PyAny>>,
+    timeout: Option<&Bound<'_, PyAny>>,
+) -> PyResult<AwsOperationContext> {
+    let params = params
+        .filter(|value| !value.is_none())
+        .map(|value| value.cast::<PyDict>())
+        .transpose()?;
+    Ok(AwsOperationContext {
+        access_key_id: string_field(params, "aws_access_key_id")?.map(SecretValue::new),
+        secret_access_key: string_field(params, "aws_secret_access_key")?.map(SecretValue::new),
+        session_token: string_field(params, "aws_session_token")?.map(SecretValue::new),
+        region_name: string_field(params, "aws_region_name")?,
+        role_name: string_field(params, "aws_role_name")?,
+        session_name: string_field(params, "aws_session_name")?,
+        external_id: string_field(params, "aws_external_id")?.map(SecretValue::new),
+        profile_name: string_field(params, "aws_profile_name")?,
+        web_identity_token: string_field(params, "aws_web_identity_token")?.map(SecretValue::new),
+        sts_endpoint: string_field(params, "aws_sts_endpoint")?,
+        bedrock_runtime_endpoint: string_field(params, "aws_bedrock_runtime_endpoint")?,
+        timeout: read_timeout(timeout)?,
+    })
+}
+
+fn read_timeout(value: Option<&Bound<'_, PyAny>>) -> PyResult<Option<Duration>> {
+    let Some(value) = value.filter(|value| !value.is_none()) else {
+        return Ok(None);
+    };
+    let seconds = match value.extract::<f64>() {
+        Ok(value) => Some(value),
+        Err(_) => value.getattr("read")?.extract::<Option<f64>>()?,
+    };
+    seconds
+        .map(|value| {
+            Duration::try_from_secs_f64(value).map_err(|_| PyValueError::new_err("invalid timeout"))
+        })
+        .transpose()
+}
+
+fn vault_context(params: Option<&Bound<'_, PyAny>>) -> PyResult<HashicorpOperationContext> {
+    let params = params.and_then(|value| value.cast::<PyDict>().ok());
+    let nested = params
+        .map(|params| params.get_item("secret_manager_settings"))
+        .transpose()?
+        .flatten();
+    let source = nested
+        .as_ref()
+        .and_then(|value| value.cast::<PyDict>().ok())
+        .or(params);
+    Ok(HashicorpOperationContext {
+        namespace: vault_field(source, "namespace")?,
+        mount: vault_field(source, "mount")?,
+        path_prefix: vault_field(source, "path_prefix")?,
+        data_key: vault_field(source, "data")?,
+        timeout: None,
+    })
+}
+
+fn vault_field(params: Option<&Bound<'_, PyDict>>, name: &str) -> PyResult<Option<String>> {
+    let value = params
+        .map(|params| params.get_item(name))
+        .transpose()?
+        .flatten();
+    match value {
+        Some(value) if value.is_none() => Ok(None),
+        Some(value) => value.str()?.extract().map(Some),
+        None => Ok(None),
+    }
+}
+
+pub(super) fn mutation_context(
+    system: KeyManagementSystem,
+    optional_params: Option<&Bound<'_, PyAny>>,
+    timeout: Option<&Bound<'_, PyAny>>,
+) -> PyResult<SecretOperationContext> {
+    if system == KeyManagementSystem::HashicorpVault {
+        return Ok(SecretOperationContext::Hashicorp(
+            HashicorpOperationContext {
+                timeout: read_timeout(timeout)?,
+                ..vault_context(optional_params)?
+            },
+        ));
+    }
+    Ok(SecretOperationContext::Default)
+}
diff --git a/litellm-rust/crates/python-bridge/src/secrets/resolved.rs b/litellm-rust/crates/python-bridge/src/secrets/resolved.rs
index 877c429169a9..84594c5a3dd5 100644
--- a/litellm-rust/crates/python-bridge/src/secrets/resolved.rs
+++ b/litellm-rust/crates/python-bridge/src/secrets/resolved.rs
@@ -1,10 +1,10 @@
-use std::{collections::HashMap, sync::Arc};
+use std::sync::Arc;
 
-use futures_util::{future::BoxFuture, future::try_join_all};
-use litellm_core_utils::settings::{Lookup, ProcessEnvironment};
-use litellm_llms::base_llm::inference::secrets::{SecretSource, Secrets};
+use futures_util::future::BoxFuture;
+use litellm_core_utils::settings::ProcessEnvironment;
+use litellm_secrets::source::SecretSource;
 use litellm_secrets::{
-    Error, FailurePolicy, OidcResolver, Secret, SecretManagerState, SecretResolver,
+    Error, FailurePolicy, OidcResolver, SecretManagerState, SecretResolver, SecretValue,
 };
 
 use super::config::SecretManagerSnapshot;
@@ -20,7 +20,7 @@ impl ResolvedSecrets {
 
     fn from_state(state: Arc<SecretManagerState>) -> Self {
         Self {
-            resolver: SecretResolver::new(
+            resolver: SecretResolver::new_python_compatible(
                 state,
                 Arc::new(ProcessEnvironment),
                 OidcResolver::default(),
@@ -31,41 +31,11 @@ impl ResolvedSecrets {
 }
 
 impl SecretSource for ResolvedSecrets {
-    fn resolve<'a>(&'a self, names: &'a [&'static str]) -> BoxFuture<'a, Result<Secrets, Error>> {
-        Box::pin(async move {
-            let values = try_join_all(names.iter().map(|name| async move {
-                self.resolver
-                    .get_secret(name, None)
-                    .await
-                    .map(|secret| secret.map(|secret| ((*name).to_owned(), secret_value(secret))))
-            }))
-            .await?
-            .into_iter()
-            .flatten()
-            .collect::<HashMap<_, _>>();
-            Ok(Arc::new(ResolvedLookup { values }) as Secrets)
-        })
-    }
-}
-
-struct ResolvedLookup {
-    values: HashMap<String, String>,
-}
-
-impl Lookup for ResolvedLookup {
-    fn get(&self, name: &str) -> Option<String> {
-        self.values
-            .get(name)
-            .cloned()
-            .or_else(|| ProcessEnvironment.get(name))
-    }
-}
-
-fn secret_value(secret: Secret) -> String {
-    match secret {
-        Secret::String(value) => value.expose().to_owned(),
-        Secret::Bool(value) => if value { "True" } else { "False" }.to_owned(),
-        Secret::Json(value) => value.to_string(),
+    fn get_secret_str<'a>(
+        &'a self,
+        name: &'a str,
+    ) -> BoxFuture<'a, Result<Option<SecretValue>, Error>> {
+        Box::pin(self.resolver.get_secret_str(name, None))
     }
 }
 
@@ -86,7 +56,7 @@ mod tests {
     };
 
     use super::ResolvedSecrets;
-    use litellm_llms::base_llm::inference::secrets::SecretSource;
+    use litellm_secrets::source::SecretSource;
 
     fn state(server: &MockServer, settings: KeyManagementSettings) -> Arc<SecretManagerState> {
         let client = Client::from_conf(
@@ -145,31 +115,75 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn manager_failure_falls_back_to_environment() {
+    async fn aws_read_failure_preserves_absence_without_environment_fallback() {
         let name = "LITELLM_RUST_BRIDGE_MANAGER_FAILURE";
         unsafe { std::env::set_var(name, "env-key") };
         let server = MockServer::start().await;
         Mock::given(header("x-amz-target", "secretsmanager.GetSecretValue"))
             .respond_with(ResponseTemplate::new(500))
-            .expect(1)
+            .expect(2)
             .mount(&server)
             .await;
         let result = resolve(state(&server, KeyManagementSettings::default()), name).await;
+        let missing = resolve(
+            state(&server, KeyManagementSettings::default()),
+            "LITELLM_RUST_BRIDGE_MANAGER_FAILURE_MISSING",
+        )
+        .await;
         unsafe { std::env::remove_var(name) };
-        assert_eq!(result.as_deref(), Some("env-key"));
-        assert_eq!(server.received_requests().await.unwrap().len(), 1);
+        assert_eq!(result, None);
+        assert_eq!(missing, None);
+    }
 
-        let missing_server = MockServer::start().await;
+    #[rstest::rstest]
+    #[case::capitalized_true("True")]
+    #[case::parenthesized_false("(False)")]
+    #[tokio::test]
+    async fn boolean_manager_values_are_absent_like_get_secret_str(#[case] value: &str) {
+        let name = "LITELLM_RUST_BRIDGE_BOOLEAN_VALUE";
+        let server = MockServer::start().await;
         Mock::given(header("x-amz-target", "secretsmanager.GetSecretValue"))
-            .respond_with(ResponseTemplate::new(500))
+            .respond_with(ResponseTemplate::new(200).set_body_json(json!({"SecretString": value})))
             .expect(1)
-            .mount(&missing_server)
+            .mount(&server)
             .await;
-        let missing =
-            ResolvedSecrets::from_state(state(&missing_server, KeyManagementSettings::default()))
-                .resolve(&["LITELLM_RUST_BRIDGE_MANAGER_FAILURE_MISSING"])
-                .await;
-        assert!(matches!(missing, Err(litellm_secrets::Error::Aws(_))));
+        assert_eq!(
+            resolve(state(&server, KeyManagementSettings::default()), name).await,
+            None
+        );
+    }
+
+    #[tokio::test]
+    async fn undeclared_names_are_read_from_the_manager() {
+        let declared = "LITELLM_RUST_BRIDGE_DECLARED";
+        let undeclared = "LITELLM_RUST_BRIDGE_UNDECLARED_MANAGED";
+        unsafe { std::env::set_var(undeclared, "env-key") };
+        let server = MockServer::start().await;
+        Mock::given(header("x-amz-target", "secretsmanager.GetSecretValue"))
+            .and(body_partial_json(json!({"SecretId": declared})))
+            .respond_with(
+                ResponseTemplate::new(200).set_body_json(json!({"SecretString": "declared-key"})),
+            )
+            .mount(&server)
+            .await;
+        Mock::given(header("x-amz-target", "secretsmanager.GetSecretValue"))
+            .and(body_partial_json(json!({"SecretId": undeclared})))
+            .respond_with(
+                ResponseTemplate::new(200).set_body_json(json!({"SecretString": "manager-key"})),
+            )
+            .expect(1)
+            .mount(&server)
+            .await;
+        let source = ResolvedSecrets::from_state(state(&server, KeyManagementSettings::default()));
+        let snapshot = source.resolve(&[declared]).await.unwrap();
+        assert_eq!(snapshot.get(undeclared), None);
+        let result = source
+            .get_secret_str(undeclared)
+            .await
+            .unwrap()
+            .map(|value| value.expose().to_owned());
+        unsafe { std::env::remove_var(undeclared) };
+        assert_eq!(result.as_deref(), Some("manager-key"));
     }
 
     #[tokio::test]
@@ -230,7 +244,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn undeclared_names_still_read_the_process_environment() {
+    async fn names_excluded_by_hosted_keys_read_the_process_environment() {
         let name = "LITELLM_RUST_BRIDGE_UNDECLARED";
         unsafe { std::env::set_var(name, "env-key") };
         let server = MockServer::start().await;
diff --git a/litellm-rust/crates/python-bridge/src/secrets/runtime.rs b/litellm-rust/crates/python-bridge/src/secrets/runtime.rs
new file mode 100644
index 000000000000..1a89130ee82e
--- /dev/null
+++ b/litellm-rust/crates/python-bridge/src/secrets/runtime.rs
@@ -0,0 +1,463 @@
+use std::{collections::BTreeMap, sync::Arc};
+
+use litellm_core_utils::settings::{Lookup, ProcessEnvironment};
+use litellm_host_python::{from_py, json_object_field, run_async_value, run_sync_value, to_py};
+use litellm_secrets::{
+    KeyManagementSettings, KeyManagementSystem, Secret, SecretManager, load_native_manager,
+    read_secret_from_python_manager,
+};
+use litellm_secrets_types::PythonSecretRead;
+use pyo3::{
+    exceptions::{PyAttributeError, PyRuntimeError, PyValueError},
+    prelude::*,
+};
+
+#[derive(Clone, PartialEq)]
+struct Configuration {
+    system: KeyManagementSystem,
+    settings: KeyManagementSettings,
+    environment: BTreeMap<String, String>,
+    enterprise_enabled: bool,
+}
+
+#[pyclass(frozen, name = "_SecretManagerRuntime")]
+pub(crate) struct NativeSecretManager {
+    backend: SecretManager,
+    configuration: Configuration,
+    pid: u32,
+}
+
+impl NativeSecretManager {
+    pub(super) fn backend(&self) -> PyResult<SecretManager> {
+        if self.pid != std::process::id() {
+            return Err(PyRuntimeError::new_err(
+                "native secret manager must be recreated after fork",
+            ));
+        }
+        Ok(self.backend.clone())
+    }
+
+    fn build(py: Python<'_>, configuration: Configuration) -> PyResult<Self> {
+        let values = configuration.environment.clone();
+        let environment: Arc<dyn Lookup + Send + Sync> =
+            Arc::new(move |name: &str| values.get(name).cloned());
+        let system = configuration.system;
+        let settings = configuration.settings.clone();
+        let enterprise_enabled = configuration.enterprise_enabled;
+        let backend = run_sync_value(py, async move {
+            load_native_manager(system, settings, environment, enterprise_enabled)
+                .await
+                .map_err(|error| PyValueError::new_err(error.to_string()))
+        })?;
+        Ok(Self {
+            backend,
+            configuration,
+            pid: std::process::id(),
+        })
+    }
+}
+
+#[pymethods]
+impl NativeSecretManager {
+    #[staticmethod]
+    #[pyo3(signature = (system, environment, settings=None, enterprise_enabled=false))]
+    fn from_config(
+        py: Python<'_>,
+        system: &str,
+        environment: BTreeMap<String, String>,
+        settings: Option<&Bound<'_, PyAny>>,
+        enterprise_enabled: bool,
+    ) -> PyResult<Self> {
+        let system = serde_json::from_value(serde_json::Value::String(system.to_owned()))
+            .map_err(|_| PyValueError::new_err("unknown secret manager system"))?;
+        let settings = parse_settings(settings)?;
+        Self::build(
+            py,
+            Configuration {
+                system,
+                settings,
+                environment,
+                enterprise_enabled,
+            },
+        )
+    }
+
+    #[staticmethod]
+    pub(super) fn from_client(client: &Bound<'_, PyAny>) -> PyResult<Option<Py<Self>>> {
+        let py = client.py();
+        if let Ok(native) = client.extract::<Py<Self>>() {
+            native.borrow(py).backend()?;
+            return Ok(Some(native));
+        }
+        let config = py
+            .import("litellm.rust_bridge.secret_manager")?
+            .getattr("native_secret_manager_config")?
+            .call1((client,))?;
+        if config.is_none() {
+            return Ok(None);
+        }
+        if !config.getattr("owner_type")?.is(client.get_type()) {
+            return Ok(None);
+        }
+        let methods = config
+            .getattr("methods")?
+            .extract::<Vec<(String, Py<PyAny>)>>()?;
+        for (name, original) in methods {
+            let current = client.getattr(name.as_str())?;
+            let implementation = optional_attribute(&current, "__func__")?.unwrap_or(current);
+            if !implementation.is(original.bind(py)) {
+                return Ok(None);
+            }
+        }
+        let environment_attributes: BTreeMap<String, String> = config
+            .getattr("environment_attributes")?
+            .extract::<Vec<(String, String)>>()?
+            .into_iter()
+            .collect();
+        let captured = config
+            .getattr("environment")?
+            .extract::<Vec<(String, String)>>()?;
+        let overrides = environment_attributes
+            .iter()
+            .map(|(key, attribute)| {
+                let value = attribute_path(client, attribute)?;
+                Ok((
+                    key.clone(),
+                    if value.is_none() {
+                        None
+                    } else {
+                        Some(value.str()?.extract::<String>()?)
+                    },
+                ))
+            })
+            .collect::<PyResult<Vec<_>>>()?;
+        let settings =
+            from_py::<serde_json::Map<String, serde_json::Value>>(&config.getattr("settings")?)
+                .map_err(|_| PyValueError::new_err("invalid secret manager settings"))?;
+        let attributes = config
+            .getattr("settings_attributes")?
+            .extract::<Vec<String>>()?;
+        let setting_overrides = attributes
+            .into_iter()
+            .map(|name| {
+                let value = from_py::<serde_json::Value>(&client.getattr(name.as_str())?)?;
+                Ok((name, value))
+            })
+            .collect::<PyResult<Vec<_>>>()?;
+        let configuration = Configuration {
+            system: serde_json::from_value(serde_json::Value::String(
+                config.getattr("system")?.extract()?,
+            ))
+            .map_err(|_| PyValueError::new_err("unknown secret manager system"))?,
+            settings: serde_json::from_value(serde_json::Value::Object(
+                settings.into_iter().chain(setting_overrides).collect(),
+            ))
+            .map_err(|_| PyValueError::new_err("invalid secret manager settings"))?,
+            environment: captured
+                .into_iter()
+                .filter(|(key, _)| !environment_attributes.contains_key(key))
+                .chain(
+                    overrides
+                        .into_iter()
+                        .filter_map(|(key, value)| value.map(|value| (key, value))),
+                )
+                .collect(),
+            enterprise_enabled: config.getattr("enterprise_enabled")?.extract()?,
+        };
+        if let Some(native) = cached(client, &configuration)? {
+            return Ok(Some(native));
+        }
+        let runtime = Self::build(py, configuration)?;
+        if let Some(native) = cached(client, &runtime.configuration)? {
+            return Ok(Some(native));
+        }
+        let native = Py::new(py, runtime)?;
+        client.setattr("_litellm_native_secret_manager", native.bind(py))?;
+        Ok(Some(native))
+    }
+
+    #[getter]
+    fn system(&self) -> String {
+        serde_json::to_value(self.configuration.system)
+            .expect("serializable system")
+            .as_str()
+            .expect("string system")
+            .to_owned()
+    }
+
+    #[pyo3(signature = (name, settings=None))]
+    fn read_secret(
+        &self,
+        py: Python<'_>,
+        name: String,
+        settings: Option<&Bound<'_, PyAny>>,
+    ) -> PyResult<Py<PyAny>> {
+        let backend = self.backend()?;
+        let settings = settings
+            .map(|value| parse_settings(Some(value)))
+            .transpose()?
+            .unwrap_or_else(|| self.configuration.settings.clone());
+        run_sync_value(py, async move {
+            read_secret_from_python_manager(&backend, &name, &settings, &ProcessEnvironment)
+                .await
+                .map_err(|error| python_read_error(backend.system(), &name, error))
+                .and_then(|value| python_secret_value(value, &name))
+        })
+    }
+    #[pyo3(signature = (secret_name, optional_params=None, timeout=None, primary_secret_name=None))]
+    fn sync_read_secret(
+        &self,
+        py: Python<'_>,
+        secret_name: String,
+        optional_params: Option<&Bound<'_, PyAny>>,
+        timeout: Option<&Bound<'_, PyAny>>,
+        primary_secret_name: Option<String>,
+    ) -> PyResult<Py<PyAny>> {
+        let backend = self.backend()?;
+        let request = super::provider::read_request(
+            self.configuration.system,
+            secret_name,
+            optional_params,
+            timeout,
+            primary_secret_name,
+            true,
+        )?;
+        run_sync_value(py, async move {
+            super::operations::read_python_provider(&backend, &request, &ProcessEnvironment)
+                .await
+                .map_err(|error| PyValueError::new_err(error.to_string()))
+                .and_then(|value| python_secret_value(value, &request.secret_name))
+        })
+    }
+
+    #[pyo3(signature = (secret_name, optional_params=None, timeout=None, primary_secret_name=None))]
+    fn async_read_secret<'py>(
+        &self,
+        py: Python<'py>,
+        secret_name: String,
+        optional_params: Option<&Bound<'py, PyAny>>,
+        timeout: Option<&Bound<'py, PyAny>>,
+        primary_secret_name: Option<String>,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let backend = self.backend()?;
+        let request = super::provider::read_request(
+            self.configuration.system,
+            secret_name,
+            optional_params,
+            timeout,
+            primary_secret_name,
+            false,
+        )?;
+        run_async_value(py, async move {
+            super::operations::read_python_provider(&backend, &request, &ProcessEnvironment)
+                .await
+                .map_err(|error| PyValueError::new_err(error.to_string()))
+                .and_then(|value| python_secret_value(value, &request.secret_name))
+        })
+    }
+
+    #[pyo3(signature = (secret_name, secret_value, description=None, optional_params=None, timeout=None, tags=None))]
+    #[expect(
+        clippy::too_many_arguments,
+        reason = "preserves the Python secret-manager write signature"
+    )]
+    fn async_write_secret<'py>(
+        &self,
+        py: Python<'py>,
+        secret_name: String,
+        secret_value: String,
+        description: Option<&Bound<'py, PyAny>>,
+        optional_params: Option<&Bound<'py, PyAny>>,
+        timeout: Option<&Bound<'py, PyAny>>,
+        tags: Option<&Bound<'py, PyAny>>,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let backend = self.backend()?;
+        let _ = tags;
+        let context = litellm_secrets_types::SecretWriteContext {
+            operation: super::provider::mutation_context(
+                self.configuration.system,
+                optional_params,
+                timeout,
+            )?,
+            description: if self.configuration.system == KeyManagementSystem::HashicorpVault {
+                description
+                    .filter(|value| !value.is_none())
+                    .map(|value| {
+                        if value.is_truthy()? {
+                            value.extract().map(Some)
+                        } else {
+                            Ok(None)
+                        }
+                    })
+                    .transpose()?
+                    .flatten()
+            } else {
+                None
+            },
+            ..litellm_secrets_types::SecretWriteContext::default()
+        };
+        let error_context =
+            super::vault::ErrorContext::capture(py, self.configuration.system, timeout)?;
+        run_async_value(py, async move {
+            super::mutation::mutation_value(
+                super::operations::write_python_provider_with_context(
+                    &backend,
+                    &secret_name,
+                    &litellm_secrets::SecretValue::new(secret_value),
+                    &context,
+                )
+                .await,
+                &error_context,
+            )
+        })
+    }
+
+    #[pyo3(signature = (secret_name, recovery_window_in_days=None, optional_params=None, timeout=None))]
+    fn async_delete_secret<'py>(
+        &self,
+        py: Python<'py>,
+        secret_name: String,
+        recovery_window_in_days: Option<&Bound<'py, PyAny>>,
+        optional_params: Option<&Bound<'py, PyAny>>,
+        timeout: Option<&Bound<'py, PyAny>>,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let backend = self.backend()?;
+        let _ = recovery_window_in_days;
+        let context =
+            super::provider::mutation_context(self.configuration.system, optional_params, timeout)?;
+        let error_context =
+            super::vault::ErrorContext::capture(py, self.configuration.system, timeout)?;
+        run_async_value(py, async move {
+            super::mutation::mutation_value(
+                super::operations::delete_python_provider_with_context(
+                    &backend,
+                    &secret_name,
+                    &context,
+                )
+                .await,
+                &error_context,
+            )
+        })
+    }
+
+    #[pyo3(signature = (current_secret_name, new_secret_name, new_secret_value, optional_params=None, timeout=None))]
+    fn async_rotate_secret<'py>(
+        &self,
+        py: Python<'py>,
+        current_secret_name: String,
+        new_secret_name: String,
+        new_secret_value: String,
+        optional_params: Option<&Bound<'py, PyAny>>,
+        timeout: Option<&Bound<'py, PyAny>>,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let backend = self.backend()?;
+        let context =
+            super::provider::mutation_context(self.configuration.system, optional_params, timeout)?;
+        let error_context =
+            super::vault::ErrorContext::capture(py, self.configuration.system, timeout)?;
+        run_async_value(py, async move {
+            super::mutation::mutation_value(
+                super::operations::rotate_python_provider_with_context(
+                    &backend,
+                    &current_secret_name,
+                    &new_secret_name,
+                    &litellm_secrets::SecretValue::new(new_secret_value),
+                    &context,
+                )
+                .await,
+                &error_context,
+            )
+        })
+    }
+
+    #[pyo3(signature = (name, settings=None))]
+    fn read_secret_async<'py>(
+        &self,
+        py: Python<'py>,
+        name: String,
+        settings: Option<&Bound<'py, PyAny>>,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let backend = self.backend()?;
+        let settings = settings
+            .map(|value| parse_settings(Some(value)))
+            .transpose()?
+            .unwrap_or_else(|| self.configuration.settings.clone());
+        run_async_value(py, async move {
+            read_secret_from_python_manager(&backend, &name, &settings, &ProcessEnvironment)
+                .await
+                .map_err(|error| python_read_error(backend.system(), &name, error))
+                .and_then(|value| python_secret_value(value, &name))
+        })
+    }
+}
+
+fn optional_attribute<'py>(
+    object: &Bound<'py, PyAny>,
+    name: &str,
+) -> PyResult<Option<Bound<'py, PyAny>>> {
+    match object.getattr(name) {
+        Ok(value) => Ok(Some(value)),
+        Err(error) if error.is_instance_of::<PyAttributeError>(object.py()) => Ok(None),
+        Err(error) => Err(error),
+    }
+}
+
+fn attribute_path<'py>(object: &Bound<'py, PyAny>, path: &str) -> PyResult<Bound<'py, PyAny>> {
+    match path.split_once('.') {
+        Some((head, tail)) => attribute_path(&object.getattr(head)?, tail),
+        None => object.getattr(path),
+    }
+}
+
+fn cached(
+    client: &Bound<'_, PyAny>,
+    configuration: &Configuration,
+) -> PyResult<Option<Py<NativeSecretManager>>> {
+    let Some(value) = optional_attribute(client, "_litellm_native_secret_manager")? else {
+        return Ok(None);
+    };
+    let native = value.extract::<Py<NativeSecretManager>>()?;
+    let same_configuration = native.borrow(client.py()).pid == std::process::id()
+        && &native.borrow(client.py()).configuration == configuration;
+    Ok(same_configuration.then_some(native))
+}
+
+fn parse_settings(value: Option<&Bound<'_, PyAny>>) -> PyResult<KeyManagementSettings> {
+    value
+        .map(|value| {
+            serde_json::from_value(from_py::<serde_json::Value>(value)?)
+                .map_err(|_| PyValueError::new_err("invalid secret manager settings"))
+        })
+        .transpose()
+        .map(Option::unwrap_or_default)
+}
+
+fn python_secret_value(payload: PythonSecretRead, name: &str) -> PyResult<Py<PyAny>> {
+    let value = match payload {
+        PythonSecretRead::Value(value) => value,
+        PythonSecretRead::PrimaryJson(document) => {
+            return Python::attach(|py| json_object_field(py, document.expose(), name));
+        }
+    };
+    let value = match value {
+        None => serde_json::Value::Null,
+        Some(Secret::String(value)) => serde_json::Value::String(value.expose().to_owned()),
+        Some(Secret::Bool(value)) => serde_json::Value::Bool(value),
+        Some(Secret::Json(value)) => value,
+    };
+    Python::attach(|py| to_py(py, &value))
+}
+
+fn python_read_error(
+    system: KeyManagementSystem,
+    name: &str,
+    error: litellm_secrets::Error,
+) -> PyErr {
+    let message = match (system, error) {
+        (KeyManagementSystem::Cyberark, litellm_secrets::Error::ManagedSecretMissing) => {
+            format!("No secret found in CyberArk Secret Manager for {name}")
+        }
+        (_, error) => error.to_string(),
+    };
+    PyValueError::new_err(message)
+}
diff --git a/litellm-rust/crates/python-bridge/src/secrets/vault.rs b/litellm-rust/crates/python-bridge/src/secrets/vault.rs
new file mode 100644
index 000000000000..de0fa95bcef4
--- /dev/null
+++ b/litellm-rust/crates/python-bridge/src/secrets/vault.rs
@@ -0,0 +1,182 @@
+mod operation;
+
+pub(super) use operation::{Failure, FailureKind, FailureStage, delete, rotate, write};
+
+use litellm_secrets::hashicorp::{Error, RawOperationError};
+use pyo3::prelude::*;
+
+use super::mutation::{error_value, http_message, json_value};
+
+pub(super) fn failure_value(
+    py: Python<'_>,
+    failure: Failure,
+    context: &ErrorContext,
+) -> PyResult<Py<PyAny>> {
+    let message = match *failure.kind {
+        FailureKind::Native(RawOperationError::Http {
+            method,
+            url,
+            status,
+            body,
+        }) => match failure.stage {
+            FailureStage::Current(name) if status == 404 => {
+                format!("Current secret {name} not found")
+            }
+            FailureStage::Replacement(name) if status == 404 => {
+                format!("Failed to verify new secret {name}")
+            }
+            FailureStage::Current(_) => format!(
+                "HTTP error occurred while checking current secret: {}",
+                response_text(py, &body)?
+            ),
+            FailureStage::Replacement(_) => format!(
+                "HTTP error occurred while verifying new secret: {}",
+                response_text(py, &body)?
+            ),
+            FailureStage::Mutation => http_message(py, &method, &url, status)?,
+        },
+        FailureKind::ValueMismatch { expected, actual } => {
+            let actual = json_value(py, &actual)?;
+            format!(
+                "New secret value mismatch. Expected: {}, Got: {}",
+                expected.expose(),
+                actual.bind(py).str()?
+            )
+        }
+        kind => {
+            let message = cause_message(py, kind, context)?;
+            match failure.stage {
+                FailureStage::Current(_) => {
+                    format!("Error checking current secret: {message}")
+                }
+                FailureStage::Replacement(_) => {
+                    format!("Error verifying new secret: {message}")
+                }
+                FailureStage::Mutation => message,
+            }
+        }
+    };
+    error_value(py, message)
+}
+
+fn cause_message(py: Python<'_>, kind: FailureKind, context: &ErrorContext) -> PyResult<String> {
+    Ok(match kind {
+        FailureKind::Native(RawOperationError::Local(error)) => error.to_string(),
+        FailureKind::UnsafeName(name) => {
+            format!("Invalid secret_name {}", name.into_pyobject(py)?.repr()?)
+        }
+        FailureKind::Native(RawOperationError::Timeout { method, elapsed }) => {
+            if method == "POST" {
+                let elapsed = py
+                    .import("builtins")?
+                    .call_method1("round", (elapsed.as_secs_f64(), 3))?;
+                let kwargs = pyo3::types::PyDict::new(py);
+                kwargs.set_item(
+                    "message",
+                    format!(
+                        "Connection timed out. Timeout passed={}, time taken={} seconds",
+                        context.timeout.as_deref().unwrap_or("None"),
+                        elapsed.str()?
+                    ),
+                )?;
+                kwargs.set_item("model", "default-model-name")?;
+                kwargs.set_item("llm_provider", "litellm-httpx-handler")?;
+                kwargs.set_item("headers", pyo3::types::PyDict::new(py))?;
+                py.import("litellm")?
+                    .getattr("Timeout")?
+                    .call((), Some(&kwargs))?
+                    .str()?
+                    .extract()?
+            } else if context.aiohttp {
+                "Timeout on reading data from socket".to_owned()
+            } else {
+                String::new()
+            }
+        }
+        FailureKind::Native(RawOperationError::Transport(source)) => {
+            if let Some(error) = request_error(&source) {
+                if error.is_timeout() {
+                    String::new()
+                } else if error.is_connect() {
+                    "All connection attempts failed".to_owned()
+                } else {
+                    "HashiCorp Vault request failed".to_owned()
+                }
+            } else {
+                "HashiCorp Vault request failed".to_owned()
+            }
+        }
+        FailureKind::MissingGet(value) => {
+            let value = json_value(py, &value)?;
+            match value.bind(py).getattr("get") {
+                Err(error) => error.value(py).str()?.extract()?,
+                Ok(_) => "HashiCorp Vault response payload is malformed".to_owned(),
+            }
+        }
+        FailureKind::Json(body) => match json_value(py, &body) {
+            Err(error) => error.value(py).str()?.extract()?,
+            Ok(_) => "HashiCorp Vault response payload is malformed".to_owned(),
+        },
+        FailureKind::Native(RawOperationError::Authentication {
+            source,
+            url,
+            certificate,
+        }) => {
+            let message = match source {
+                Error::LoginStatus { status } => http_message(py, "POST", &url, status)?,
+                error => error.to_string(),
+            };
+            let mechanism = if certificate { "TLS cert" } else { "AppRole" };
+            format!("Could not authenticate to Vault via {mechanism}: {message}")
+        }
+        FailureKind::Native(RawOperationError::Http {
+            method,
+            url,
+            status,
+            ..
+        }) => http_message(py, &method, &url, status)?,
+        FailureKind::ValueMismatch { .. } => "New secret value mismatch".to_owned(),
+    })
+}
+
+fn request_error<'a>(error: &'a (dyn std::error::Error + 'static)) -> Option<&'a reqwest::Error> {
+    error
+        .downcast_ref::<reqwest::Error>()
+        .or_else(|| error.source().and_then(request_error))
+}
+
+fn response_text(py: Python<'_>, body: &[u8]) -> PyResult<String> {
+    let kwargs = pyo3::types::PyDict::new(py);
+    kwargs.set_item("content", pyo3::types::PyBytes::new(py, body))?;
+    py.import("httpx")?
+        .getattr("Response")?
+        .call((200,), Some(&kwargs))?
+        .getattr("text")?
+        .extract()
+}
+
+#[derive(Default)]
+pub(super) struct ErrorContext {
+    timeout: Option<String>,
+    aiohttp: bool,
+}
+
+impl ErrorContext {
+    pub(super) fn capture(
+        py: Python<'_>,
+        system: litellm_secrets::KeyManagementSystem,
+        timeout: Option<&Bound<'_, PyAny>>,
+    ) -> PyResult<Self> {
+        if system != litellm_secrets::KeyManagementSystem::HashicorpVault {
+            return Ok(Self::default());
+        }
+        Ok(Self {
+            timeout: timeout.map(|value| value.str()?.extract()).transpose()?,
+            aiohttp: py
+                .import("litellm.llms.custom_httpx.http_handler")?
+                .getattr("AsyncHTTPHandler")?
+                .call_method0("_should_use_aiohttp_transport")?
+                .extract()?,
+        })
+    }
+}
diff --git a/litellm-rust/crates/python-bridge/src/secrets/vault/operation.rs b/litellm-rust/crates/python-bridge/src/secrets/vault/operation.rs
new file mode 100644
index 000000000000..cf56beb5efea
--- /dev/null
+++ b/litellm-rust/crates/python-bridge/src/secrets/vault/operation.rs
@@ -0,0 +1,168 @@
+use std::collections::HashMap;
+
+use litellm_secrets::{
+    SecretValue,
+    hashicorp::{Error, HashicorpVault, RawOperationError},
+};
+use litellm_secrets_types::{HashicorpOperationContext, SecretWriteContext};
+use serde_json::value::RawValue;
+
+#[derive(Debug)]
+pub(crate) enum FailureStage {
+    Mutation,
+    Current(String),
+    Replacement(String),
+}
+
+#[derive(veil::Redact)]
+pub(crate) enum FailureKind {
+    Native(RawOperationError),
+    UnsafeName(#[redact] String),
+    Json(#[redact] Vec<u8>),
+    MissingGet(#[redact] Vec<u8>),
+    ValueMismatch {
+        expected: SecretValue,
+        #[redact]
+        actual: Vec<u8>,
+    },
+}
+
+#[derive(Debug)]
+pub(crate) struct Failure {
+    pub kind: Box<FailureKind>,
+    pub stage: FailureStage,
+}
+
+impl From<FailureKind> for Failure {
+    fn from(kind: FailureKind) -> Self {
+        Self {
+            kind: Box::new(kind),
+            stage: FailureStage::Mutation,
+        }
+    }
+}
+
+impl Failure {
+    fn during(self, stage: FailureStage) -> Self {
+        if matches!(*self.kind, FailureKind::UnsafeName(_)) {
+            self
+        } else {
+            Self { stage, ..self }
+        }
+    }
+}
+
+fn native_failure(name: &str, error: RawOperationError) -> Failure {
+    match error {
+        RawOperationError::Local(Error::InvalidSecretName(_)) => {
+            FailureKind::UnsafeName(name.to_owned()).into()
+        }
+        error => FailureKind::Native(error).into(),
+    }
+}
+
+pub(crate) async fn write(
+    client: &HashicorpVault,
+    name: &str,
+    value: &SecretValue,
+    context: &SecretWriteContext<HashicorpOperationContext>,
+) -> Result<Vec<u8>, Failure> {
+    client
+        .write_raw(name, value, context)
+        .await
+        .map_err(|error| native_failure(name, error))
+}
+
+pub(crate) async fn delete(
+    client: &HashicorpVault,
+    name: &str,
+    context: &HashicorpOperationContext,
+) -> Result<(), Failure> {
+    client
+        .delete_raw(name, context)
+        .await
+        .map_err(|error| native_failure(name, error))
+}
+
+pub(crate) async fn rotate(
+    client: &HashicorpVault,
+    current_name: &str,
+    new_name: &str,
+    value: &SecretValue,
+    context: &HashicorpOperationContext,
+) -> Result<Vec<u8>, Failure> {
+    client
+        .read_raw(current_name, context)
+        .await
+        .map_err(|error| {
+            native_failure(current_name, error)
+                .during(FailureStage::Current(current_name.to_owned()))
+        })?;
+    let response = write(
+        client,
+        new_name,
+        value,
+        &SecretWriteContext {
+            description: Some(format!("Rotated from {current_name}")),
+            operation: context.clone(),
+            ..SecretWriteContext::default()
+        },
+    )
+    .await?;
+    let parsed: &RawValue =
+        serde_json::from_slice(&response).map_err(|_| FailureKind::Json(response.clone()))?;
+    let status = raw_object_field(parsed, "status")
+        .ok()
+        .flatten()
+        .and_then(|value| serde_json::from_slice::<String>(value.get().as_bytes()).ok());
+    if status.as_deref() == Some("error") {
+        return Ok(response);
+    }
+    let verification = client.read_raw(new_name, context).await.map_err(|error| {
+        native_failure(new_name, error).during(FailureStage::Replacement(new_name.to_owned()))
+    })?;
+    let parsed: &RawValue = serde_json::from_slice(&verification).map_err(|_| {
+        Failure::from(FailureKind::Json(verification.clone()))
+            .during(FailureStage::Replacement(new_name.to_owned()))
+    })?;
+    let data_key = context
+        .data_key
+        .as_deref()
+        .map(str::trim)
+        .filter(|key| !key.is_empty())
+        .unwrap_or("key");
+    let actual = verification_value(parsed, data_key).map_err(|failure| {
+        Failure::from(failure).during(FailureStage::Replacement(new_name.to_owned()))
+    })?;
+    let actual_string = serde_json::from_slice::<String>(actual.get().as_bytes()).ok();
+    if actual_string.as_deref() != Some(value.expose()) {
+        return Err(FailureKind::ValueMismatch {
+            expected: value.clone(),
+            actual: actual.get().as_bytes().to_vec(),
+        }
+        .into());
+    }
+    if current_name != new_name {
+        let _ = delete(client, current_name, context).await;
+    }
+    Ok(response)
+}
+
+fn verification_value<'a>(document: &'a RawValue, key: &str) -> Result<&'a RawValue, FailureKind> {
+    let Some(outer) = raw_object_field(document, "data")? else {
+        return Ok(RawValue::NULL);
+    };
+    let Some(inner) = raw_object_field(outer, "data")? else {
+        return Ok(RawValue::NULL);
+    };
+    Ok(raw_object_field(inner, key)?.unwrap_or(RawValue::NULL))
+}
+
+fn raw_object_field<'a>(
+    document: &'a RawValue,
+    key: &str,
+) -> Result<Option<&'a RawValue>, FailureKind> {
+    let object: HashMap<String, &RawValue> = serde_json::from_slice(document.get().as_bytes())
+        .map_err(|_| FailureKind::MissingGet(document.get().as_bytes().to_vec()))?;
+    Ok(object.get(key).copied())
+}
diff --git a/litellm-rust/crates/secrets-aws/AGENTS.md b/litellm-rust/crates/secrets-aws/AGENTS.md
new file mode 100644
index 000000000000..714f031db412
--- /dev/null
+++ b/litellm-rust/crates/secrets-aws/AGENTS.md
@@ -0,0 +1 @@
+- https://docs.aws.amazon.com/secretsmanager/latest/apireference/Welcome.html
diff --git a/litellm-rust/crates/secrets-aws/Cargo.toml b/litellm-rust/crates/secrets-aws/Cargo.toml
index 9c926bb441b8..e7a394bd2478 100644
--- a/litellm-rust/crates/secrets-aws/Cargo.toml
+++ b/litellm-rust/crates/secrets-aws/Cargo.toml
@@ -22,3 +22,4 @@ base64.workspace = true
 rstest.workspace = true
 tokio.workspace = true
 wiremock = "0.6.5"
+tempfile = "3"
diff --git a/litellm-rust/crates/secrets-aws/src/auth.rs b/litellm-rust/crates/secrets-aws/src/auth.rs
index 954cfa2f8fd4..0c32eb009898 100644
--- a/litellm-rust/crates/secrets-aws/src/auth.rs
+++ b/litellm-rust/crates/secrets-aws/src/auth.rs
@@ -7,7 +7,7 @@ use litellm_auth_aws::{
     resolve_credentials,
 };
 use litellm_core_utils::settings::Lookup;
-use litellm_secrets_types::KeyManagementSettings;
+use litellm_secrets_types::{AwsOperationContext, KeyManagementSettings};
 
 use crate::Error;
 
@@ -21,9 +21,29 @@ impl Credentials {
     pub(crate) fn new(
         settings: &KeyManagementSettings,
         environment: Arc<dyn Lookup + Send + Sync>,
+    ) -> Self {
+        Self::with_context(settings, environment, &AwsOperationContext::default())
+    }
+
+    pub(crate) fn with_context(
+        settings: &KeyManagementSettings,
+        environment: Arc<dyn Lookup + Send + Sync>,
+        context: &AwsOperationContext,
     ) -> Self {
         Self {
             config: AwsAuthConfig {
+                access_key_id: context
+                    .access_key_id
+                    .as_ref()
+                    .map(|value| value.expose().to_owned()),
+                secret_access_key: context
+                    .secret_access_key
+                    .as_ref()
+                    .map(|value| value.expose().to_owned()),
+                session_token: context
+                    .session_token
+                    .as_ref()
+                    .map(|value| value.expose().to_owned()),
                 region_name: region(settings, environment.as_ref()).ok(),
                 role_name: settings.aws_role_name.clone(),
                 session_name: settings.aws_session_name.clone(),
@@ -37,7 +57,6 @@ impl Credentials {
                     .as_ref()
                     .map(|v| v.expose().to_owned()),
                 sts_endpoint: settings.aws_sts_endpoint.clone(),
-                ..Default::default()
             },
             environment,
         }
diff --git a/litellm-rust/crates/secrets-aws/src/error.rs b/litellm-rust/crates/secrets-aws/src/error.rs
index cc9e6b697860..c8ca671e9b53 100644
--- a/litellm-rust/crates/secrets-aws/src/error.rs
+++ b/litellm-rust/crates/secrets-aws/src/error.rs
@@ -6,8 +6,6 @@ pub enum Error {
     Auth(#[from] #[redact] litellm_auth_aws::Error),
     #[error("AWS region is not configured")]
     MissingRegion,
-    #[error("AWS Secrets Manager received a non-AWS operation context")]
-    InvalidOperationContext,
     #[error("AWS Secrets Manager was constructed without context-aware configuration")]
     OperationContextUnavailable,
     #[error("KMS response has no plaintext")]
@@ -20,6 +18,12 @@ pub enum Error {
     Read(#[from] #[redact] Box<SdkError<aws_sdk_secretsmanager::operation::get_secret_value::GetSecretValueError>>),
     #[error("AWS Secrets Manager create failed")]
     Create(#[from] #[redact] Box<SdkError<aws_sdk_secretsmanager::operation::create_secret::CreateSecretError>>),
+    #[error("AWS Secrets Manager restore failed")]
+    Restore(#[from] #[redact] Box<SdkError<aws_sdk_secretsmanager::operation::restore_secret::RestoreSecretError>>),
+    #[error("AWS Secrets Manager restored update failed")]
+    Update(#[from] #[redact] Box<SdkError<aws_sdk_secretsmanager::operation::update_secret::UpdateSecretError>>),
+    #[error("AWS Secrets Manager tagging failed")]
+    Tag(#[from] #[redact] Box<SdkError<aws_sdk_secretsmanager::operation::tag_resource::TagResourceError>>),
     #[error("AWS Secrets Manager update failed")]
     Put(#[from] #[redact] Box<SdkError<aws_sdk_secretsmanager::operation::put_secret_value::PutSecretValueError>>),
     #[error("AWS Secrets Manager delete failed")]
diff --git a/litellm-rust/crates/secrets-aws/src/kms.rs b/litellm-rust/crates/secrets-aws/src/kms.rs
index a66b1c4d2fee..8c05c0161841 100644
--- a/litellm-rust/crates/secrets-aws/src/kms.rs
+++ b/litellm-rust/crates/secrets-aws/src/kms.rs
@@ -1,4 +1,3 @@
-use litellm_auth_aws::constants::AWS_REGION_NAME;
 use std::sync::Arc;
 
 use aws_sdk_kms::{
@@ -37,10 +36,7 @@ impl AwsKms {
 }
 
 pub fn validate_environment(environment: &dyn Lookup) -> Result<(), Error> {
-    environment
-        .get(AWS_REGION_NAME)
-        .map(|_| ())
-        .ok_or(Error::MissingRegion)
+    auth::region(&KeyManagementSettings::default(), environment).map(|_| ())
 }
 
 pub fn load_aws_kms(
@@ -51,9 +47,6 @@ pub fn load_aws_kms(
     if use_aws_kms != Some(true) {
         return Ok(None);
     }
-    if settings.aws_region_name.is_none() {
-        validate_environment(environment.as_ref())?;
-    }
     let config = aws_sdk_kms::Config::builder()
         .behavior_version(BehaviorVersion::latest())
         .region(Region::new(auth::region(settings, environment.as_ref())?))
diff --git a/litellm-rust/crates/secrets-aws/src/secret_manager.rs b/litellm-rust/crates/secrets-aws/src/secret_manager.rs
index 5658b6d7e11c..508d7da15c14 100644
--- a/litellm-rust/crates/secrets-aws/src/secret_manager.rs
+++ b/litellm-rust/crates/secrets-aws/src/secret_manager.rs
@@ -1,3 +1,9 @@
+mod client;
+mod read;
+mod write;
+
+pub use read::is_bootstrap_key;
+
 use litellm_auth_aws::constants::AWS_BEDROCK_RUNTIME_ENDPOINT;
 use std::{collections::BTreeMap, sync::Arc};
 
@@ -16,8 +22,9 @@ use litellm_auth_aws::constants::{
 };
 use litellm_core_utils::settings::Lookup;
 use litellm_secrets_types::{
-    AwsOperationContext, BaseSecretManager, KeyManagementSettings, Secret, SecretOperationContext,
-    SecretValue, SecretWriteContext, async_rotate_secret,
+    AwsOperationContext, BaseSecretManager, KeyManagementSettings, RotationError, Secret,
+    SecretDeleter, SecretRotator, SecretValue, SecretWriteContext, SecretWriter,
+    async_rotate_secret,
 };
 use serde_json::Value;
 
@@ -68,395 +75,4 @@ impl AwsSecretsManagerV2 {
             write_settings,
         }
     }
-
-    fn with_context_client_factory(
-        client: Client,
-        write_settings: AwsSecretWriteSettings,
-        context_client_factory: ContextClientFactory,
-    ) -> Self {
-        Self {
-            client,
-            context_client_factory: Some(Box::new(context_client_factory)),
-            write_settings,
-        }
-    }
-
-    pub fn load_aws_secret_manager(
-        use_aws_secret_manager: Option<bool>,
-        settings: KeyManagementSettings,
-        environment: Arc<dyn Lookup + Send + Sync>,
-    ) -> Result<Option<Self>, Error> {
-        if use_aws_secret_manager != Some(true) {
-            return Ok(None);
-        }
-        let context_client_factory = ContextClientFactory {
-            settings: settings.clone(),
-            environment: environment.clone(),
-            endpoint_url: environment
-                .get(AWS_BEDROCK_RUNTIME_ENDPOINT)
-                .map(|url| url.replace("bedrock-runtime", "secretsmanager")),
-        };
-        let client = context_client_factory.client(&AwsOperationContext::default())?;
-        Ok(Some(Self::with_context_client_factory(
-            client,
-            (&settings).into(),
-            context_client_factory,
-        )))
-    }
-
-    pub async fn read_secret_for_resolver(
-        &self,
-        name: &str,
-        primary_name: Option<&str>,
-        environment: &(dyn Lookup + Sync),
-    ) -> Result<Option<Secret>, Error> {
-        if bootstrap_key(name) {
-            return Ok(environment
-                .get(name)
-                .map(SecretValue::new)
-                .map(Secret::String));
-        }
-        match primary_name.filter(|name| !name.is_empty()) {
-            None => self
-                .async_read_secret(name)
-                .await
-                .map(|value| value.map(Secret::String)),
-            Some(primary) => {
-                let value = if bootstrap_key(primary) {
-                    environment.get(primary).map(SecretValue::new)
-                } else {
-                    self.async_read_secret(primary).await?
-                };
-                let Some(value) = value else {
-                    return Ok(None);
-                };
-                let object: Value =
-                    serde_json::from_str(value.expose()).map_err(|_| Error::PrimarySecret)?;
-                let object = object.as_object().ok_or(Error::PrimarySecret)?;
-                Ok(object.get(name).cloned().map(Secret::from_json))
-            }
-        }
-    }
-
-    pub async fn async_read_secret(&self, name: &str) -> Result<Option<SecretValue>, Error> {
-        Self::async_read_secret_with_client(&self.client, name).await
-    }
-
-    async fn async_read_secret_with_client(
-        client: &Client,
-        name: &str,
-    ) -> Result<Option<SecretValue>, Error> {
-        match client.get_secret_value().secret_id(name).send().await {
-            Ok(response) => response
-                .secret_string
-                .map(SecretValue::new)
-                .map(Some)
-                .ok_or(Error::MissingString),
-            Err(error)
-                if matches!(
-                    &error,
-                    aws_sdk_secretsmanager::error::SdkError::TimeoutError(_)
-                ) || matches!(&error, aws_sdk_secretsmanager::error::SdkError::DispatchFailure(failure) if failure.is_timeout()) =>
-            {
-                Err(Error::Timeout)
-            }
-            Err(error)
-                if error
-                    .as_service_error()
-                    .is_some_and(|error| error.is_resource_not_found_exception()) =>
-            {
-                Ok(None)
-            }
-            Err(error) => Err(Error::Read(Box::new(error))),
-        }
-    }
-
-    pub async fn async_write_secret(
-        &self,
-        name: &str,
-        value: &SecretValue,
-        description: Option<&str>,
-    ) -> Result<CreateSecretOutput, Error> {
-        self.async_write_secret_with_client_and_tags(&self.client, name, value, description, None)
-            .await
-    }
-
-    async fn async_write_secret_with_client_and_tags(
-        &self,
-        client: &Client,
-        name: &str,
-        value: &SecretValue,
-        description: Option<&str>,
-        tags: Option<&BTreeMap<String, String>>,
-    ) -> Result<CreateSecretOutput, Error> {
-        let response = client
-            .create_secret()
-            .name(name)
-            .secret_string(value.expose())
-            .set_description(description.filter(|v| !v.is_empty()).map(str::to_owned))
-            .set_kms_key_id(
-                self.write_settings
-                    .kms_key_id
-                    .clone()
-                    .filter(|v| !v.is_empty()),
-            )
-            .set_tags(tags.or(self.write_settings.tags.as_ref()).map(|tags| {
-                tags.iter()
-                    .map(|(key, value)| Tag::builder().key(key).value(value).build())
-                    .collect()
-            }))
-            .send()
-            .await
-            .map_err(|error| Error::Create(Box::new(error)))?;
-        if let Some(regions) = &self.write_settings.replica_regions
-            && !regions.is_empty()
-            && self
-                .async_replicate_secret_with_client(client, name, regions)
-                .await
-                .is_err()
-        {
-            litellm_tracing::warn!("secret created but replication failed");
-        }
-        Ok(response)
-    }
-
-    pub async fn async_replicate_secret(
-        &self,
-        name: &str,
-        regions: &[String],
-    ) -> Result<Option<ReplicateSecretToRegionsOutput>, Error> {
-        self.async_replicate_secret_with_client(&self.client, name, regions)
-            .await
-    }
-
-    async fn async_replicate_secret_with_client(
-        &self,
-        client: &Client,
-        name: &str,
-        regions: &[String],
-    ) -> Result<Option<ReplicateSecretToRegionsOutput>, Error> {
-        if regions.is_empty() {
-            return Ok(None);
-        }
-        client
-            .replicate_secret_to_regions()
-            .secret_id(name)
-            .set_add_replica_regions(Some(
-                regions
-                    .iter()
-                    .map(|region| ReplicaRegionType::builder().region(region).build())
-                    .collect(),
-            ))
-            .send()
-            .await
-            .map(Some)
-            .map_err(|error| Error::Replicate(Box::new(error)))
-    }
-
-    pub async fn async_put_secret_value(
-        &self,
-        name: &str,
-        value: &SecretValue,
-    ) -> Result<PutSecretValueOutput, Error> {
-        self.async_put_secret_value_with_client(&self.client, name, value)
-            .await
-    }
-
-    async fn async_put_secret_value_with_client(
-        &self,
-        client: &Client,
-        name: &str,
-        value: &SecretValue,
-    ) -> Result<PutSecretValueOutput, Error> {
-        client
-            .put_secret_value()
-            .secret_id(name)
-            .secret_string(value.expose())
-            .send()
-            .await
-            .map_err(|error| Error::Put(Box::new(error)))
-    }
-
-    pub async fn async_delete_secret(
-        &self,
-        name: &str,
-        recovery_window_in_days: Option<u32>,
-    ) -> Result<DeleteSecretOutput, Error> {
-        self.async_delete_secret_with_client(&self.client, name, recovery_window_in_days)
-            .await
-    }
-
-    async fn async_delete_secret_with_client(
-        &self,
-        client: &Client,
-        name: &str,
-        recovery_window_in_days: Option<u32>,
-    ) -> Result<DeleteSecretOutput, Error> {
-        client
-            .delete_secret()
-            .secret_id(name)
-            .set_recovery_window_in_days(recovery_window_in_days.map(i64::from))
-            .send()
-            .await
-            .map_err(|error| Error::Delete(Box::new(error)))
-    }
-
-    pub async fn async_rotate_secret(
-        &self,
-        current_name: &str,
-        new_name: &str,
-        value: &SecretValue,
-    ) -> Result<RotationResponse, Error> {
-        self.async_rotate_secret_with_context(
-            current_name,
-            new_name,
-            value,
-            &SecretOperationContext::default(),
-        )
-        .await
-    }
-
-    pub async fn async_rotate_secret_with_context(
-        &self,
-        current_name: &str,
-        new_name: &str,
-        value: &SecretValue,
-        context: &SecretOperationContext,
-    ) -> Result<RotationResponse, Error> {
-        if current_name == new_name {
-            let client = self.client_for_context(context)?;
-            return self
-                .async_put_secret_value_with_client(&client, current_name, value)
-                .await
-                .map(RotationResponse::Updated);
-        }
-        async_rotate_secret(self, current_name, new_name, value, context)
-            .await
-            .map(RotationResponse::Created)
-    }
-
-    fn client_for_context(&self, context: &SecretOperationContext) -> Result<Client, Error> {
-        match context {
-            SecretOperationContext::Default => Ok(self.client.clone()),
-            SecretOperationContext::Aws(context) if context == &AwsOperationContext::default() => {
-                Ok(self.client.clone())
-            }
-            SecretOperationContext::Aws(context) => self
-                .context_client_factory
-                .as_ref()
-                .ok_or(Error::OperationContextUnavailable)?
-                .client(context),
-            _ => Err(Error::InvalidOperationContext),
-        }
-    }
-}
-
-impl ContextClientFactory {
-    fn client(&self, context: &AwsOperationContext) -> Result<Client, Error> {
-        let settings = KeyManagementSettings {
-            aws_region_name: context
-                .region_name
-                .clone()
-                .or_else(|| self.settings.aws_region_name.clone()),
-            aws_role_name: context
-                .role_name
-                .clone()
-                .or_else(|| self.settings.aws_role_name.clone()),
-            aws_session_name: context
-                .session_name
-                .clone()
-                .or_else(|| self.settings.aws_session_name.clone()),
-            aws_external_id: context
-                .external_id
-                .clone()
-                .or_else(|| self.settings.aws_external_id.clone()),
-            aws_profile_name: context
-                .profile_name
-                .clone()
-                .or_else(|| self.settings.aws_profile_name.clone()),
-            aws_web_identity_token: context
-                .web_identity_token
-                .clone()
-                .or_else(|| self.settings.aws_web_identity_token.clone()),
-            aws_sts_endpoint: context
-                .sts_endpoint
-                .clone()
-                .or_else(|| self.settings.aws_sts_endpoint.clone()),
-            ..self.settings.clone()
-        };
-        let builder = aws_sdk_secretsmanager::Config::builder()
-            .behavior_version(BehaviorVersion::latest())
-            .region(Region::new(auth::region(
-                &settings,
-                self.environment.as_ref(),
-            )?))
-            .credentials_provider(auth::Credentials::new(&settings, self.environment.clone()));
-        let builder = match context.timeout {
-            Some(timeout) => builder.timeout_config(
-                aws_sdk_secretsmanager::config::timeout::TimeoutConfig::builder()
-                    .operation_timeout(timeout)
-                    .build(),
-            ),
-            None => builder,
-        };
-        let config = match &self.endpoint_url {
-            Some(endpoint_url) => builder.endpoint_url(endpoint_url.clone()).build(),
-            None => builder.build(),
-        };
-        Ok(Client::from_conf(config))
-    }
-}
-
-impl BaseSecretManager for AwsSecretsManagerV2 {
-    type Error = Error;
-    type WriteResponse = CreateSecretOutput;
-    type DeleteResponse = DeleteSecretOutput;
-
-    async fn async_read_secret(
-        &self,
-        name: &str,
-        context: &SecretOperationContext,
-    ) -> Result<Option<SecretValue>, Error> {
-        let client = self.client_for_context(context)?;
-        Self::async_read_secret_with_client(&client, name).await
-    }
-
-    async fn async_write_secret(
-        &self,
-        name: &str,
-        value: &SecretValue,
-        context: &SecretWriteContext,
-    ) -> Result<CreateSecretOutput, Error> {
-        let client = self.client_for_context(&context.operation)?;
-        self.async_write_secret_with_client_and_tags(
-            &client,
-            name,
-            value,
-            context.description.as_deref(),
-            (!context.tags.is_empty()).then_some(&context.tags),
-        )
-        .await
-    }
-
-    async fn async_delete_secret(
-        &self,
-        name: &str,
-        recovery_window_in_days: Option<u32>,
-        context: &SecretOperationContext,
-    ) -> Result<DeleteSecretOutput, Error> {
-        let client = self.client_for_context(context)?;
-        self.async_delete_secret_with_client(&client, name, recovery_window_in_days)
-            .await
-    }
-}
-
-fn bootstrap_key(name: &str) -> bool {
-    matches!(
-        name,
-        AWS_ACCESS_KEY_ID
-            | AWS_SECRET_ACCESS_KEY
-            | AWS_REGION_NAME
-            | AWS_REGION
-            | AWS_BEDROCK_RUNTIME_ENDPOINT
-    )
 }
diff --git a/litellm-rust/crates/secrets-aws/src/secret_manager/client.rs b/litellm-rust/crates/secrets-aws/src/secret_manager/client.rs
new file mode 100644
index 000000000000..aac998c65abf
--- /dev/null
+++ b/litellm-rust/crates/secrets-aws/src/secret_manager/client.rs
@@ -0,0 +1,116 @@
+use super::*;
+
+impl AwsSecretsManagerV2 {
+    pub(super) fn with_context_client_factory(
+        client: Client,
+        write_settings: AwsSecretWriteSettings,
+        context_client_factory: ContextClientFactory,
+    ) -> Self {
+        Self {
+            client,
+            context_client_factory: Some(Box::new(context_client_factory)),
+            write_settings,
+        }
+    }
+
+    pub fn load_aws_secret_manager(
+        use_aws_secret_manager: Option<bool>,
+        settings: KeyManagementSettings,
+        environment: Arc<dyn Lookup + Send + Sync>,
+    ) -> Result<Option<Self>, Error> {
+        if use_aws_secret_manager != Some(true) {
+            return Ok(None);
+        }
+        let context_client_factory = ContextClientFactory {
+            settings: settings.clone(),
+            environment: environment.clone(),
+            endpoint_url: environment
+                .get(AWS_BEDROCK_RUNTIME_ENDPOINT)
+                .map(|url| url.replace("bedrock-runtime", "secretsmanager")),
+        };
+        let client = context_client_factory.client(&AwsOperationContext::default())?;
+        Ok(Some(Self::with_context_client_factory(
+            client,
+            (&settings).into(),
+            context_client_factory,
+        )))
+    }
+
+    pub(super) fn client_for_context(
+        &self,
+        context: &AwsOperationContext,
+    ) -> Result<Client, Error> {
+        if context == &AwsOperationContext::default() {
+            return Ok(self.client.clone());
+        }
+        self.context_client_factory
+            .as_ref()
+            .ok_or(Error::OperationContextUnavailable)?
+            .client(context)
+    }
+}
+
+impl ContextClientFactory {
+    fn client(&self, context: &AwsOperationContext) -> Result<Client, Error> {
+        let settings = KeyManagementSettings {
+            aws_region_name: context
+                .region_name
+                .clone()
+                .or_else(|| self.settings.aws_region_name.clone()),
+            aws_role_name: context
+                .role_name
+                .clone()
+                .or_else(|| self.settings.aws_role_name.clone()),
+            aws_session_name: context
+                .session_name
+                .clone()
+                .or_else(|| self.settings.aws_session_name.clone()),
+            aws_external_id: context
+                .external_id
+                .clone()
+                .or_else(|| self.settings.aws_external_id.clone()),
+            aws_profile_name: context
+                .profile_name
+                .clone()
+                .or_else(|| self.settings.aws_profile_name.clone()),
+            aws_web_identity_token: context
+                .web_identity_token
+                .clone()
+                .or_else(|| self.settings.aws_web_identity_token.clone()),
+            aws_sts_endpoint: context
+                .sts_endpoint
+                .clone()
+                .or_else(|| self.settings.aws_sts_endpoint.clone()),
+            ..self.settings.clone()
+        };
+        let builder = aws_sdk_secretsmanager::Config::builder()
+            .behavior_version(BehaviorVersion::latest())
+            .region(Region::new(auth::region(
+                &settings,
+                self.environment.as_ref(),
+            )?))
+            .credentials_provider(auth::Credentials::with_context(
+                &settings,
+                self.environment.clone(),
+                context,
+            ));
+        let builder = match context.timeout {
+            Some(timeout) => builder.timeout_config(
+                aws_sdk_secretsmanager::config::timeout::TimeoutConfig::builder()
+                    .operation_timeout(timeout)
+                    .build(),
+            ),
+            None => builder,
+        };
+        let endpoint_url = context
+            .bedrock_runtime_endpoint
+            .as_ref()
+            .map(|url| url.replace("bedrock-runtime", "secretsmanager"))
+            .or_else(|| self.endpoint_url.clone());
+        let config = match endpoint_url {
+            Some(endpoint_url) => builder.endpoint_url(endpoint_url).build(),
+            None => builder.build(),
+        };
+        Ok(Client::from_conf(config))
+    }
+}
diff --git a/litellm-rust/crates/secrets-aws/src/secret_manager/read.rs b/litellm-rust/crates/secrets-aws/src/secret_manager/read.rs
new file mode 100644
index 000000000000..b7583f9785fc
--- /dev/null
+++ b/litellm-rust/crates/secrets-aws/src/secret_manager/read.rs
@@ -0,0 +1,225 @@
+use super::*;
+use aws_sdk_secretsmanager::config::retry::RetryConfig;
+use litellm_secrets_types::PythonSecretRead;
+
+#[derive(Clone, Copy)]
+enum ReadPolicy {
+    Native,
+    Python,
+}
+
+impl AwsSecretsManagerV2 {
+    pub async fn read_secret_for_resolver(
+        &self,
+        name: &str,
+        primary_name: Option<&str>,
+        environment: &(dyn Lookup + Sync),
+    ) -> Result<Option<Secret>, Error> {
+        let payload = self
+            .read_payload(name, primary_name, environment, ReadPolicy::Native)
+            .await?;
+        resolve_payload(payload, name)
+    }
+
+    pub async fn read_secret_for_python(
+        &self,
+        name: &str,
+        primary_name: Option<&str>,
+        environment: &(dyn Lookup + Sync),
+    ) -> Result<Option<Secret>, Error> {
+        let payload = self
+            .read_payload_for_python(name, primary_name, environment)
+            .await?;
+        resolve_payload(payload, name)
+    }
+
+    pub async fn read_payload_for_python(
+        &self,
+        name: &str,
+        primary_name: Option<&str>,
+        environment: &(dyn Lookup + Sync),
+    ) -> Result<PythonSecretRead, Error> {
+        self.read_payload(name, primary_name, environment, ReadPolicy::Python)
+            .await
+    }
+
+    pub async fn read_provider_payload_for_python(
+        &self,
+        name: &str,
+        primary_name: Option<&str>,
+        context: &AwsOperationContext,
+        synchronous: bool,
+        environment: &(dyn Lookup + Sync),
+    ) -> Result<PythonSecretRead, Error> {
+        if synchronous && is_bootstrap_key(name) {
+            return Ok(PythonSecretRead::Value(
+                environment
+                    .get(name)
+                    .map(SecretValue::new)
+                    .map(Secret::String),
+            ));
+        }
+        if let Some(primary) = primary_name.filter(|value| !value.is_empty()) {
+            let value = if synchronous && is_bootstrap_key(primary) {
+                environment.get(primary).map(SecretValue::new)
+            } else {
+                self.read_with_policy(primary, ReadPolicy::Python).await?
+            };
+            return Ok(match value.filter(|value| !value.expose().is_empty()) {
+                Some(value) => PythonSecretRead::PrimaryJson(value),
+                None => PythonSecretRead::Value(None),
+            });
+        }
+        let client = self.client_for_context(context)?;
+        let value = match Self::read_with_client(&client, name, ReadPolicy::Python).await {
+            Err(Error::Read(_) | Error::MissingString | Error::Timeout) => None,
+            result => result?,
+        };
+        Ok(PythonSecretRead::Value(value.map(Secret::String)))
+    }
+
+    async fn read_payload(
+        &self,
+        name: &str,
+        primary_name: Option<&str>,
+        environment: &(dyn Lookup + Sync),
+        policy: ReadPolicy,
+    ) -> Result<PythonSecretRead, Error> {
+        if is_bootstrap_key(name) {
+            return Ok(PythonSecretRead::Value(
+                environment
+                    .get(name)
+                    .map(SecretValue::new)
+                    .map(Secret::String),
+            ));
+        }
+        match primary_name.filter(|name| !name.is_empty()) {
+            None => self
+                .read_with_policy(name, policy)
+                .await
+                .map(|value| PythonSecretRead::Value(value.map(Secret::String))),
+            Some(primary) => {
+                let value = if is_bootstrap_key(primary) {
+                    environment.get(primary).map(SecretValue::new)
+                } else {
+                    self.read_with_policy(primary, policy).await?
+                };
+                let Some(value) = value else {
+                    return Ok(PythonSecretRead::Value(None));
+                };
+                if matches!(policy, ReadPolicy::Python) && value.expose().is_empty() {
+                    return Ok(PythonSecretRead::Value(None));
+                }
+                Ok(PythonSecretRead::PrimaryJson(value))
+            }
+        }
+    }
+
+    async fn read_with_policy(
+        &self,
+        name: &str,
+        policy: ReadPolicy,
+    ) -> Result<Option<SecretValue>, Error> {
+        match (
+            Self::read_with_client(&self.client, name, policy).await,
+            policy,
+        ) {
+            (Err(Error::Read(_) | Error::MissingString | Error::Timeout), ReadPolicy::Python) => {
+                Ok(None)
+            }
+            (result, _) => result,
+        }
+    }
+
+    pub async fn async_read_secret(&self, name: &str) -> Result<Option<SecretValue>, Error> {
+        Self::async_read_secret_with_client(&self.client, name).await
+    }
+
+    pub(super) async fn async_read_secret_with_client(
+        client: &Client,
+        name: &str,
+    ) -> Result<Option<SecretValue>, Error> {
+        Self::read_with_client(client, name, ReadPolicy::Native).await
+    }
+
+    async fn read_with_client(
+        client: &Client,
+        name: &str,
+        policy: ReadPolicy,
+    ) -> Result<Option<SecretValue>, Error> {
+        let request = client.get_secret_value().secret_id(name);
+        let response = match policy {
+            ReadPolicy::Native => request.send().await,
+            ReadPolicy::Python => {
+                request
+                    .customize()
+                    .config_override(
+                        aws_sdk_secretsmanager::config::Builder::new()
+                            .retry_config(RetryConfig::disabled()),
+                    )
+                    .send()
+                    .await
+            }
+        };
+        match response {
+            Ok(response) => response
+                .secret_string
+                .map(SecretValue::new)
+                .map(Some)
+                .ok_or(Error::MissingString),
+            Err(error)
+                if matches!(
+                    &error,
+                    aws_sdk_secretsmanager::error::SdkError::TimeoutError(_)
+                ) || matches!(&error, aws_sdk_secretsmanager::error::SdkError::DispatchFailure(failure) if failure.is_timeout()) =>
+            {
+                Err(Error::Timeout)
+            }
+            Err(error)
+                if error
+                    .as_service_error()
+                    .is_some_and(|error| error.is_resource_not_found_exception()) =>
+            {
+                Ok(None)
+            }
+            Err(error) => Err(Error::Read(Box::new(error))),
+        }
+    }
+}
+
+impl BaseSecretManager for AwsSecretsManagerV2 {
+    type Error = Error;
+    type Context = AwsOperationContext;
+
+    async fn async_read_secret(
+        &self,
+        name: &str,
+        context: &Self::Context,
+    ) -> Result<Option<SecretValue>, Error> {
+        let client = self.client_for_context(context)?;
+        Self::async_read_secret_with_client(&client, name).await
+    }
+}
+
+pub fn is_bootstrap_key(name: &str) -> bool {
+    matches!(
+        name,
+        AWS_ACCESS_KEY_ID
+            | AWS_SECRET_ACCESS_KEY
+            | AWS_REGION_NAME
+            | AWS_REGION
+            | AWS_BEDROCK_RUNTIME_ENDPOINT
+    )
+}
+
+fn resolve_payload(payload: PythonSecretRead, name: &str) -> Result<Option<Secret>, Error> {
+    match payload {
+        PythonSecretRead::Value(value) => Ok(value),
+        PythonSecretRead::PrimaryJson(document) => {
+            let object: Value =
+                serde_json::from_str(document.expose()).map_err(|_| Error::PrimarySecret)?;
+            let object = object.as_object().ok_or(Error::PrimarySecret)?;
+            Ok(object.get(name).cloned().map(Secret::from_json))
+        }
+    }
+}
diff --git a/litellm-rust/crates/secrets-aws/src/secret_manager/write.rs b/litellm-rust/crates/secrets-aws/src/secret_manager/write.rs
new file mode 100644
index 000000000000..003b559d56c4
--- /dev/null
+++ b/litellm-rust/crates/secrets-aws/src/secret_manager/write.rs
@@ -0,0 +1,329 @@
+use super::*;
+
+impl AwsSecretsManagerV2 {
+    pub async fn async_write_secret(
+        &self,
+        name: &str,
+        value: &SecretValue,
+        description: Option<&str>,
+    ) -> Result<CreateSecretOutput, Error> {
+        self.async_write_secret_with_client_and_tags(&self.client, name, value, description, None)
+            .await
+    }
+
+    pub(super) async fn async_write_secret_with_client_and_tags(
+        &self,
+        client: &Client,
+        name: &str,
+        value: &SecretValue,
+        description: Option<&str>,
+        tags: Option<&BTreeMap<String, String>>,
+    ) -> Result<CreateSecretOutput, Error> {
+        let tags = self.write_tags(tags);
+        let request = client
+            .create_secret()
+            .name(name)
+            .secret_string(value.expose())
+            .set_description(description.filter(|v| !v.is_empty()).map(str::to_owned))
+            .set_kms_key_id(self.write_kms_key_id())
+            .set_tags(tags.clone());
+        let response = match request.send().await {
+            Ok(response) => response,
+            Err(error) => self
+                .restore_and_update_secret(client, name, value, description, tags)
+                .await?
+                .ok_or_else(|| Error::Create(Box::new(error)))?,
+        };
+        if let Some(regions) = &self.write_settings.replica_regions
+            && !regions.is_empty()
+            && self
+                .async_replicate_secret_with_client(client, name, regions)
+                .await
+                .is_err()
+        {
+            litellm_tracing::warn!("secret created but replication failed");
+        }
+        Ok(response)
+    }
+
+    async fn restore_and_update_secret(
+        &self,
+        client: &Client,
+        name: &str,
+        value: &SecretValue,
+        description: Option<&str>,
+        tags: Option<Vec<Tag>>,
+    ) -> Result<Option<CreateSecretOutput>, Error> {
+        let scheduled = client
+            .describe_secret()
+            .secret_id(name)
+            .send()
+            .await
+            .is_ok_and(|response| response.deleted_date().is_some());
+        if !scheduled {
+            return Ok(None);
+        }
+        client
+            .restore_secret()
+            .secret_id(name)
+            .send()
+            .await
+            .map_err(|error| Error::Restore(Box::new(error)))?;
+        match self
+            .update_restored_secret(client, name, value, description, tags)
+            .await
+        {
+            Ok(response) => Ok(Some(response)),
+            Err(error) => {
+                self.async_delete_secret_with_client(client, name, Some(7))
+                    .await?;
+                Err(error)
+            }
+        }
+    }
+
+    fn write_kms_key_id(&self) -> Option<String> {
+        self.write_settings
+            .kms_key_id
+            .clone()
+            .filter(|value| !value.is_empty())
+    }
+
+    fn write_tags(&self, tags: Option<&BTreeMap<String, String>>) -> Option<Vec<Tag>> {
+        tags.or(self.write_settings.tags.as_ref()).map(|tags| {
+            tags.iter()
+                .map(|(key, value)| Tag::builder().key(key).value(value).build())
+                .collect()
+        })
+    }
+
+    async fn update_restored_secret(
+        &self,
+        client: &Client,
+        name: &str,
+        value: &SecretValue,
+        description: Option<&str>,
+        tags: Option<Vec<Tag>>,
+    ) -> Result<CreateSecretOutput, Error> {
+        let response = client
+            .update_secret()
+            .secret_id(name)
+            .secret_string(value.expose())
+            .set_description(
+                description
+                    .filter(|value| !value.is_empty())
+                    .map(str::to_owned),
+            )
+            .set_kms_key_id(self.write_kms_key_id())
+            .send()
+            .await
+            .map_err(|error| Error::Update(Box::new(error)))?;
+        if let Some(tags) = tags {
+            client
+                .tag_resource()
+                .secret_id(name)
+                .set_tags(Some(tags))
+                .send()
+                .await
+                .map_err(|error| Error::Tag(Box::new(error)))?;
+        }
+        Ok(CreateSecretOutput::builder()
+            .set_arn(response.arn)
+            .set_name(response.name)
+            .set_version_id(response.version_id)
+            .build())
+    }
+
+    pub async fn async_replicate_secret(
+        &self,
+        name: &str,
+        regions: &[String],
+    ) -> Result<Option<ReplicateSecretToRegionsOutput>, Error> {
+        self.async_replicate_secret_with_client(&self.client, name, regions)
+            .await
+    }
+
+    pub(super) async fn async_replicate_secret_with_client(
+        &self,
+        client: &Client,
+        name: &str,
+        regions: &[String],
+    ) -> Result<Option<ReplicateSecretToRegionsOutput>, Error> {
+        if regions.is_empty() {
+            return Ok(None);
+        }
+        client
+            .replicate_secret_to_regions()
+            .secret_id(name)
+            .set_add_replica_regions(Some(
+                regions
+                    .iter()
+                    .map(|region| ReplicaRegionType::builder().region(region).build())
+                    .collect(),
+            ))
+            .send()
+            .await
+            .map(Some)
+            .map_err(|error| Error::Replicate(Box::new(error)))
+    }
+
+    pub async fn async_put_secret_value(
+        &self,
+        name: &str,
+        value: &SecretValue,
+    ) -> Result<PutSecretValueOutput, Error> {
+        self.async_put_secret_value_with_client(&self.client, name, value)
+            .await
+    }
+
+    pub(super) async fn async_put_secret_value_with_client(
+        &self,
+        client: &Client,
+        name: &str,
+        value: &SecretValue,
+    ) -> Result<PutSecretValueOutput, Error> {
+        client
+            .put_secret_value()
+            .secret_id(name)
+            .secret_string(value.expose())
+            .send()
+            .await
+            .map_err(|error| Error::Put(Box::new(error)))
+    }
+
+    pub async fn async_delete_secret(
+        &self,
+        name: &str,
+        recovery_window_in_days: Option<u32>,
+    ) -> Result<DeleteSecretOutput, Error> {
+        self.async_delete_secret_with_client(&self.client, name, recovery_window_in_days)
+            .await
+    }
+
+    pub async fn async_delete_secret_with_context(
+        &self,
+        name: &str,
+        recovery_window_in_days: Option<u32>,
+        context: &AwsOperationContext,
+    ) -> Result<DeleteSecretOutput, Error> {
+        let client = self.client_for_context(context)?;
+        self.async_delete_secret_with_client(&client, name, recovery_window_in_days)
+            .await
+    }
+
+    pub(super) async fn async_delete_secret_with_client(
+        &self,
+        client: &Client,
+        name: &str,
+        recovery_window_in_days: Option<u32>,
+    ) -> Result<DeleteSecretOutput, Error> {
+        client
+            .delete_secret()
+            .secret_id(name)
+            .set_recovery_window_in_days(recovery_window_in_days.map(i64::from))
+            .send()
+            .await
+            .map_err(|error| Error::Delete(Box::new(error)))
+    }
+
+    pub async fn async_rotate_secret(
+        &self,
+        current_name: &str,
+        new_name: &str,
+        value: &SecretValue,
+    ) -> Result<RotationResponse, RotationError<RotationResponse, Error>> {
+        self.async_rotate_secret_with_context(
+            current_name,
+            new_name,
+            value,
+            &AwsOperationContext::default(),
+        )
+        .await
+    }
+
+    pub async fn async_rotate_secret_with_context(
+        &self,
+        current_name: &str,
+        new_name: &str,
+        value: &SecretValue,
+        context: &AwsOperationContext,
+    ) -> Result<RotationResponse, RotationError<RotationResponse, Error>> {
+        if current_name == new_name {
+            return self
+                .async_write_replacement(current_name, new_name, value, context)
+                .await
+                .map_err(RotationError::Write);
+        }
+        async_rotate_secret(self, current_name, new_name, value, context).await
+    }
+}
+
+impl SecretWriter for AwsSecretsManagerV2 {
+    type WriteResponse = CreateSecretOutput;
+
+    async fn async_write_secret(
+        &self,
+        name: &str,
+        value: &SecretValue,
+        context: &SecretWriteContext<Self::Context>,
+    ) -> Result<CreateSecretOutput, Error> {
+        let client = self.client_for_context(&context.operation)?;
+        self.async_write_secret_with_client_and_tags(
+            &client,
+            name,
+            value,
+            context.description.as_deref(),
+            (!context.tags.is_empty()).then_some(&context.tags),
+        )
+        .await
+    }
+}
+
+impl SecretDeleter for AwsSecretsManagerV2 {
+    type DeleteResponse = DeleteSecretOutput;
+
+    async fn async_delete_secret(
+        &self,
+        name: &str,
+        context: &Self::Context,
+    ) -> Result<DeleteSecretOutput, Error> {
+        self.async_delete_secret_with_context(name, Some(7), context)
+            .await
+    }
+}
+
+impl SecretRotator for AwsSecretsManagerV2 {
+    type RotationResponse = RotationResponse;
+
+    async fn async_read_secret_fresh(
+        &self,
+        name: &str,
+        context: &Self::Context,
+    ) -> Result<Option<SecretValue>, Error> {
+        BaseSecretManager::async_read_secret(self, name, context).await
+    }
+
+    async fn async_write_replacement(
+        &self,
+        current_name: &str,
+        new_name: &str,
+        value: &SecretValue,
+        context: &Self::Context,
+    ) -> Result<RotationResponse, Error> {
+        if current_name == new_name {
+            let client = self.client_for_context(context)?;
+            return self
+                .async_put_secret_value_with_client(&client, new_name, value)
+                .await
+                .map(RotationResponse::Updated);
+        }
+        SecretWriter::async_write_secret(
+            self,
+            new_name,
+            value,
+            &SecretWriteContext::rotated_from(current_name, context.clone()),
+        )
+        .await
+        .map(RotationResponse::Created)
+    }
+}
diff --git a/litellm-rust/crates/secrets-aws/tests/kms.rs b/litellm-rust/crates/secrets-aws/tests/kms.rs
index 687cca104e02..71be88e73130 100644
--- a/litellm-rust/crates/secrets-aws/tests/kms.rs
+++ b/litellm-rust/crates/secrets-aws/tests/kms.rs
@@ -60,10 +60,13 @@ fn disabled_kms_loader_does_not_require_environment_configuration(#[case] enable
 }
 
 #[rstest]
-#[case::settings(Some("configured-region"), None)]
-#[case::environment(None, Some("environment-region"))]
-fn enabled_kms_loader_accepts_either_region_source(
+#[case::settings(Some("configured-region"), None, None)]
+#[case::region_name(None, Some("AWS_REGION_NAME"), Some("environment-region"))]
+#[case::region(None, Some("AWS_REGION"), Some("environment-region"))]
+#[case::default_region(None, Some("AWS_DEFAULT_REGION"), Some("environment-region"))]
+fn enabled_kms_loader_accepts_supported_region_sources(
     #[case] configured_region: Option<&'static str>,
+    #[case] environment_region_name: Option<&'static str>,
     #[case] environment_region: Option<&'static str>,
 ) {
     use std::sync::Arc;
@@ -72,7 +75,7 @@ fn enabled_kms_loader_accepts_either_region_source(
         ..KeyManagementSettings::default()
     };
     let environment = Arc::new(move |name: &str| {
-        (name == "AWS_REGION_NAME")
+        (Some(name) == environment_region_name)
             .then(|| environment_region.map(str::to_owned))
             .flatten()
     });
diff --git a/litellm-rust/crates/secrets-aws/tests/secret_manager.rs b/litellm-rust/crates/secrets-aws/tests/secret_manager.rs
index 7dbc8b61374e..c482a1680909 100644
--- a/litellm-rust/crates/secrets-aws/tests/secret_manager.rs
+++ b/litellm-rust/crates/secrets-aws/tests/secret_manager.rs
@@ -12,8 +12,8 @@ use aws_sdk_secretsmanager::{
 };
 use litellm_secrets_aws::{AwsSecretsManagerV2, Error, RotationResponse};
 use litellm_secrets_types::{
-    AwsOperationContext, BaseSecretManager, KeyManagementSettings, SecretOperationContext,
-    SecretValue, SecretWriteContext,
+    AwsOperationContext, BaseSecretManager, KeyManagementSettings, Secret, SecretDeleter,
+    SecretValue, SecretWriteContext, SecretWriter,
 };
 use rstest::{fixture, rstest};
 use serde_json::json;
@@ -22,459 +22,13 @@ use wiremock::{
     matchers::{body_partial_json, header},
 };
 
-fn manager(server: &MockServer, settings: KeyManagementSettings) -> AwsSecretsManagerV2 {
-    let client = Client::from_conf(
-        aws_sdk_secretsmanager::Config::builder()
-            .behavior_version(BehaviorVersion::latest())
-            .region(Region::new("us-east-1"))
-            .credentials_provider(Credentials::new("test", "test", None, None, "test"))
-            .endpoint_url(server.uri())
-            .retry_config(RetryConfig::disabled())
-            .build(),
-    );
-    AwsSecretsManagerV2::new(client, (&settings).into())
-}
+#[path = "secret_manager/support.rs"]
+mod support;
+use support::*;
 
-fn loaded_manager(server: &MockServer) -> AwsSecretsManagerV2 {
-    let endpoint_url = server.uri();
-    let environment: Arc<dyn litellm_core_utils::settings::Lookup + Send + Sync> =
-        Arc::new(move |name: &str| match name {
-            "AWS_BEDROCK_RUNTIME_ENDPOINT" => Some(endpoint_url.clone()),
-            "AWS_ACCESS_KEY_ID" => Some("test".into()),
-            "AWS_SECRET_ACCESS_KEY" => Some("test".into()),
-            _ => None,
-        });
-    AwsSecretsManagerV2::load_aws_secret_manager(
-        Some(true),
-        KeyManagementSettings {
-            aws_region_name: Some("us-east-1".into()),
-            ..Default::default()
-        },
-        environment,
-    )
-    .unwrap()
-    .unwrap()
-}
-
-#[fixture]
-fn default_settings() -> KeyManagementSettings {
-    KeyManagementSettings::default()
-}
-
-#[rstest]
-#[case::string_value("KEY", Some("value"))]
-#[case::missing_value("missing", None)]
-#[case::non_string_value("BOOL", None)]
-#[tokio::test]
-async fn primary_lookup_preserves_read_semantics(
-    default_settings: KeyManagementSettings,
-    #[case] name: &str,
-    #[case] expected: Option<&str>,
-) {
-    let server = MockServer::start().await;
-    Mock::given(header("x-amz-target", "secretsmanager.GetSecretValue"))
-        .and(body_partial_json(json!({"SecretId":"primary"})))
-        .respond_with(
-            ResponseTemplate::new(200).set_body_json(
-                json!({"SecretString":json!({"KEY":"value", "BOOL":true}).to_string()}),
-            ),
-        )
-        .expect(1)
-        .mount(&server)
-        .await;
-    let manager = manager(&server, default_settings);
-    assert_eq!(
-        manager
-            .read_secret_for_resolver(name, Some("primary"), &|_: &str| None)
-            .await
-            .unwrap()
-            .and_then(|v| v.as_str().map(str::to_owned))
-            .as_deref(),
-        expected
-    );
-}
-
-#[rstest]
-#[case::access_key("AWS_ACCESS_KEY_ID")]
-#[case::secret_access_key("AWS_SECRET_ACCESS_KEY")]
-#[case::region_name("AWS_REGION_NAME")]
-#[case::region("AWS_REGION")]
-#[case::bedrock_endpoint("AWS_BEDROCK_RUNTIME_ENDPOINT")]
-#[tokio::test]
-async fn bootstrap_keys_bypass_primary_lookup(
-    default_settings: KeyManagementSettings,
-    #[case] name: &str,
-) {
-    let server = MockServer::start().await;
-    let manager = manager(&server, default_settings);
-    assert_eq!(
-        manager
-            .read_secret_for_resolver(name, Some("primary"), &|_: &str| Some("bootstrap".into()))
-            .await
-            .unwrap()
-            .unwrap()
-            .as_str()
-            .unwrap(),
-        "bootstrap"
-    );
-}
-
-#[rstest]
-#[tokio::test]
-async fn failed_read_returns_none_but_invalid_primary_json_is_an_error(
-    default_settings: KeyManagementSettings,
-) {
-    let server = MockServer::start().await;
-    Mock::given(body_partial_json(json!({"SecretId":"missing"})))
-        .respond_with(
-            ResponseTemplate::new(400).set_body_json(json!({"__type":"ResourceNotFoundException"})),
-        )
-        .mount(&server)
-        .await;
-    Mock::given(body_partial_json(json!({"SecretId":"invalid"})))
-        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"SecretString":"not-json"})))
-        .mount(&server)
-        .await;
-    Mock::given(body_partial_json(json!({"SecretId":"no-string"})))
-        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"Name":"no-string"})))
-        .mount(&server)
-        .await;
-    let manager = manager(&server, default_settings);
-    assert!(
-        manager
-            .async_read_secret("missing")
-            .await
-            .unwrap()
-            .is_none()
-    );
-    assert!(matches!(
-        manager
-            .read_secret_for_resolver("KEY", Some("invalid"), &|_: &str| None)
-            .await,
-        Err(Error::PrimarySecret)
-    ));
-    assert!(matches!(
-        manager.async_read_secret("no-string").await,
-        Err(Error::MissingString)
-    ));
-}
-
-#[rstest]
-#[tokio::test]
-async fn same_name_rotation_uses_put_and_returns_its_response(
-    default_settings: KeyManagementSettings,
-) {
-    let server = MockServer::start().await;
-    Mock::given(header("x-amz-target", "secretsmanager.PutSecretValue"))
-        .and(body_partial_json(
-            json!({"SecretId":"key", "SecretString":"replacement"}),
-        ))
-        .respond_with(
-            ResponseTemplate::new(200).set_body_json(json!({"Name":"key", "VersionId":"version"})),
-        )
-        .expect(1)
-        .mount(&server)
-        .await;
-    let response = manager(&server, default_settings)
-        .async_rotate_secret("key", "key", &SecretValue::new("replacement"))
-        .await
-        .unwrap();
-    match response {
-        RotationResponse::Updated(output) => assert_eq!(output.version_id(), Some("version")),
-        _ => panic!("rotation created a second secret"),
-    }
-    assert_eq!(server.received_requests().await.unwrap().len(), 1);
-}
-
-#[rstest]
-#[tokio::test]
-async fn renamed_rotation_reads_creates_verifies_then_deletes(
-    default_settings: KeyManagementSettings,
-) {
-    let server = MockServer::start().await;
-    let step = AtomicUsize::new(0);
-    Mock::given(wiremock::matchers::method("POST"))
-        .respond_with(move |request: &wiremock::Request| {
-            let body: serde_json::Value = request.body_json().unwrap();
-            let action = request
-                .headers
-                .get("x-amz-target")
-                .unwrap()
-                .to_str()
-                .unwrap();
-            match step.fetch_add(1, Ordering::SeqCst) {
-                0 => {
-                    assert_eq!(action, "secretsmanager.GetSecretValue");
-                    assert_eq!(body["SecretId"], "old");
-                    ResponseTemplate::new(200).set_body_json(json!({"SecretString":"old-value"}))
-                }
-                1 => {
-                    assert_eq!(action, "secretsmanager.CreateSecret");
-                    assert_eq!(body["Name"], "new");
-                    assert_eq!(body["Description"], "Rotated from old");
-                    assert_eq!(body["SecretString"], "replacement");
-                    ResponseTemplate::new(200).set_body_json(json!({"Name":"new"}))
-                }
-                2 => {
-                    assert_eq!(action, "secretsmanager.GetSecretValue");
-                    assert_eq!(body["SecretId"], "new");
-                    ResponseTemplate::new(200).set_body_json(json!({"SecretString":"replacement"}))
-                }
-                3 => {
-                    assert_eq!(action, "secretsmanager.DeleteSecret");
-                    assert_eq!(body["SecretId"], "old");
-                    assert_eq!(body["RecoveryWindowInDays"], 7);
-                    ResponseTemplate::new(200).set_body_json(json!({"Name":"old"}))
-                }
-                _ => panic!("unexpected request"),
-            }
-        })
-        .expect(4)
-        .mount(&server)
-        .await;
-    assert!(matches!(
-        manager(&server, default_settings)
-            .async_rotate_secret("old", "new", &SecretValue::new("replacement"))
-            .await
-            .unwrap(),
-        RotationResponse::Created(_)
-    ));
-}
-
-#[rstest]
-#[tokio::test]
-async fn creation_passes_tags_and_kms_and_survives_replication_failure() {
-    let server = MockServer::start().await;
-    Mock::given(header("x-amz-target", "secretsmanager.CreateSecret"))
-        .and(body_partial_json(json!({"Name":"key", "SecretString":"value", "KmsKeyId":"kms-key", "Tags":[{"Key":"stage", "Value":"test"}]})))
-        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"Name":"key"}))).expect(1).mount(&server).await;
-    Mock::given(header(
-        "x-amz-target",
-        "secretsmanager.ReplicateSecretToRegions",
-    ))
-    .and(body_partial_json(
-        json!({"SecretId":"key", "AddReplicaRegions":[{"Region":"replica-region"}]}),
-    ))
-    .respond_with(
-        ResponseTemplate::new(400).set_body_json(json!({"__type":"InvalidRequestException"})),
-    )
-    .expect(1)
-    .mount(&server)
-    .await;
-    let settings = KeyManagementSettings {
-        kms_key_id: Some("kms-key".into()),
-        tags: Some(std::collections::BTreeMap::from([(
-            "stage".into(),
-            "test".into(),
-        )])),
-        replica_regions: Some(vec!["replica-region".into()]),
-        ..Default::default()
-    };
-    let manager = manager(&server, settings);
-    assert_eq!(
-        manager
-            .async_write_secret("key", &SecretValue::new("value"), None)
-            .await
-            .unwrap()
-            .name(),
-        Some("key")
-    );
-    assert!(
-        manager
-            .async_replicate_secret("key", &[])
-            .await
-            .unwrap()
-            .is_none()
-    );
-}
-
-#[rstest]
-#[tokio::test]
-async fn trait_write_uses_typed_write_context(default_settings: KeyManagementSettings) {
-    let server = MockServer::start().await;
-    Mock::given(header("x-amz-target", "secretsmanager.CreateSecret"))
-        .and(body_partial_json(json!({
-            "Name": "key",
-            "SecretString": "value",
-            "Description": "created by caller",
-            "Tags": [{"Key": "stage", "Value": "test"}],
-        })))
-        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"Name": "key"})))
-        .expect(1)
-        .mount(&server)
-        .await;
-    let context = SecretWriteContext {
-        description: Some("created by caller".into()),
-        tags: std::collections::BTreeMap::from([("stage".into(), "test".into())]),
-        ..Default::default()
-    };
-    let response = BaseSecretManager::async_write_secret(
-        &manager(&server, default_settings),
-        "key",
-        &SecretValue::new("value"),
-        &context,
-    )
-    .await
-    .unwrap();
-    assert_eq!(response.name(), Some("key"));
-}
-
-#[rstest]
-#[tokio::test]
-async fn trait_delete_accepts_an_unspecified_recovery_window(
-    default_settings: KeyManagementSettings,
-) {
-    let server = MockServer::start().await;
-    Mock::given(header("x-amz-target", "secretsmanager.DeleteSecret"))
-        .and(body_partial_json(json!({"SecretId": "key"})))
-        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"Name": "key"})))
-        .expect(1)
-        .mount(&server)
-        .await;
-    let response = BaseSecretManager::async_delete_secret(
-        &manager(&server, default_settings),
-        "key",
-        None,
-        &SecretOperationContext::default(),
-    )
-    .await
-    .unwrap();
-    assert_eq!(response.name(), Some("key"));
-}
-
-#[rstest]
-#[tokio::test]
-async fn trait_read_uses_the_aws_region_from_its_operation_context() {
-    let server = MockServer::start().await;
-    Mock::given(header("x-amz-target", "secretsmanager.GetSecretValue"))
-        .respond_with(|request: &wiremock::Request| {
-            let authorization = request
-                .headers
-                .get("authorization")
-                .unwrap()
-                .to_str()
-                .unwrap();
-            assert!(authorization.contains("/us-west-2/secretsmanager/aws4_request"));
-            ResponseTemplate::new(200).set_body_json(json!({"SecretString": "value"}))
-        })
-        .expect(1)
-        .mount(&server)
-        .await;
-    let context = SecretOperationContext::Aws(AwsOperationContext {
-        region_name: Some("us-west-2".into()),
-        ..Default::default()
-    });
-    let value = BaseSecretManager::async_read_secret(&loaded_manager(&server), "key", &context)
-        .await
-        .unwrap();
-    assert_eq!(value.unwrap().expose(), "value");
-}
-
-#[rstest]
-#[tokio::test]
-async fn trait_read_applies_the_aws_operation_timeout() {
-    let server = MockServer::start().await;
-    Mock::given(header("x-amz-target", "secretsmanager.GetSecretValue"))
-        .respond_with(
-            ResponseTemplate::new(200)
-                .set_delay(Duration::from_secs(1))
-                .set_body_json(json!({"SecretString": "late"})),
-        )
-        .expect(1)
-        .mount(&server)
-        .await;
-    let context = SecretOperationContext::Aws(AwsOperationContext {
-        timeout: Some(Duration::from_millis(30)),
-        ..Default::default()
-    });
-    assert!(matches!(
-        BaseSecretManager::async_read_secret(&loaded_manager(&server), "key", &context).await,
-        Err(Error::Timeout)
-    ));
-}
-
-#[rstest]
-#[tokio::test]
-async fn credential_failures_are_not_swallowed_as_missing_secrets() {
-    use aws_credential_types::provider::{ProvideCredentials, error::CredentialsError, future};
-    #[derive(Debug)]
-    struct FailedCredentials;
-    impl ProvideCredentials for FailedCredentials {
-        fn provide_credentials<'a>(&'a self) -> future::ProvideCredentials<'a>
-        where
-            Self: 'a,
-        {
-            future::ProvideCredentials::ready(Err(CredentialsError::provider_error(
-                "private-auth-detail",
-            )))
-        }
-    }
-    let server = MockServer::start().await;
-    let config = aws_sdk_secretsmanager::Config::builder()
-        .behavior_version(BehaviorVersion::latest())
-        .region(Region::new("us-east-1"))
-        .credentials_provider(FailedCredentials)
-        .endpoint_url(server.uri())
-        .retry_config(RetryConfig::disabled())
-        .build();
-    let manager = AwsSecretsManagerV2::new(Client::from_conf(config), Default::default());
-    let error = manager.async_read_secret("key").await.unwrap_err();
-    assert!(!format!("{error:?}").contains("private-auth-detail"));
-    assert!(matches!(error, Error::Read(_)));
-    assert!(server.received_requests().await.unwrap().is_empty());
-}
-
-#[rstest]
-#[tokio::test]
-async fn read_timeout_is_an_error_and_cannot_be_mistaken_for_missing() {
-    let server = MockServer::start().await;
-    Mock::given(wiremock::matchers::method("POST"))
-        .respond_with(
-            ResponseTemplate::new(200)
-                .set_delay(Duration::from_secs(1))
-                .set_body_json(json!({"SecretString":"late"})),
-        )
-        .mount(&server)
-        .await;
-    let config = aws_sdk_secretsmanager::Config::builder()
-        .behavior_version(BehaviorVersion::latest())
-        .region(Region::new("us-east-1"))
-        .credentials_provider(Credentials::new("test", "test", None, None, "test"))
-        .endpoint_url(server.uri())
-        .retry_config(RetryConfig::disabled())
-        .timeout_config(
-            aws_sdk_secretsmanager::config::timeout::TimeoutConfig::builder()
-                .operation_timeout(Duration::from_millis(30))
-                .build(),
-        )
-        .build();
-    let manager = AwsSecretsManagerV2::new(Client::from_conf(config), Default::default());
-    assert!(matches!(
-        manager.async_read_secret("key").await,
-        Err(Error::Timeout)
-    ));
-}
-
-#[rstest]
-#[case::denied(400, "AccessDeniedException")]
-#[case::throttled(400, "ThrottlingException")]
-#[case::unavailable(503, "ServiceUnavailableException")]
-#[tokio::test]
-async fn service_failures_remain_errors(
-    default_settings: KeyManagementSettings,
-    #[case] status: u16,
-    #[case] code: &str,
-) {
-    let server = MockServer::start().await;
-    Mock::given(header("x-amz-target", "secretsmanager.GetSecretValue"))
-        .respond_with(ResponseTemplate::new(status).set_body_json(json!({"__type":code})))
-        .expect(1)
-        .mount(&server)
-        .await;
-    assert!(matches!(
-        manager(&server, default_settings)
-            .async_read_secret("key")
-            .await,
-        Err(Error::Read(_))
-    ));
-}
+#[path = "secret_manager/configuration.rs"]
+mod configuration;
+#[path = "secret_manager/reads.rs"]
+mod reads;
+#[path = "secret_manager/writes.rs"]
+mod writes;
diff --git a/litellm-rust/crates/secrets-aws/tests/secret_manager/configuration.rs b/litellm-rust/crates/secrets-aws/tests/secret_manager/configuration.rs
new file mode 100644
index 000000000000..40b851fd678d
--- /dev/null
+++ b/litellm-rust/crates/secrets-aws/tests/secret_manager/configuration.rs
@@ -0,0 +1,256 @@
+use super::*;
+
+#[rstest]
+#[tokio::test]
+async fn credential_failures_are_not_swallowed_as_missing_secrets() {
+    use aws_credential_types::provider::{ProvideCredentials, error::CredentialsError, future};
+    #[derive(Debug)]
+    struct FailedCredentials;
+    impl ProvideCredentials for FailedCredentials {
+        fn provide_credentials<'a>(&'a self) -> future::ProvideCredentials<'a>
+        where
+            Self: 'a,
+        {
+            future::ProvideCredentials::ready(Err(CredentialsError::provider_error(
+                "private-auth-detail",
+            )))
+        }
+    }
+    let server = MockServer::start().await;
+    let config = client_builder(&server)
+        .credentials_provider(FailedCredentials)
+        .build();
+    let manager = AwsSecretsManagerV2::new(Client::from_conf(config), Default::default());
+    let error = manager.async_read_secret("key").await.unwrap_err();
+    assert!(!format!("{error:?}").contains("private-auth-detail"));
+    assert!(matches!(error, Error::Read(_)));
+    assert!(server.received_requests().await.unwrap().is_empty());
+}
+
+#[rstest]
+#[case::environment(false)]
+#[case::operation_override(true)]
+#[tokio::test]
+async fn endpoint_overrides_replace_the_service_and_override_the_region(
+    #[case] override_context: bool,
+) {
+    let configured = MockServer::start().await;
+    let explicit = MockServer::start().await;
+    let target = if override_context {
+        &explicit
+    } else {
+        &configured
+    };
+    Mock::given(wiremock::matchers::path_regex("^/secretsmanager/?$"))
+        .and(header("x-amz-target", "secretsmanager.GetSecretValue"))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"SecretString":"value"})))
+        .expect(1)
+        .mount(target)
+        .await;
+    let endpoint = format!("{}/bedrock-runtime", configured.uri());
+    let manager = AwsSecretsManagerV2::load_aws_secret_manager(
+        Some(true),
+        KeyManagementSettings {
+            aws_region_name: Some("cn-north-1".into()),
+            ..Default::default()
+        },
+        Arc::new(move |name: &str| match name {
+            "AWS_BEDROCK_RUNTIME_ENDPOINT" => Some(endpoint.clone()),
+            "AWS_ACCESS_KEY_ID" | "AWS_SECRET_ACCESS_KEY" => Some("test".into()),
+            _ => None,
+        }),
+    )
+    .unwrap()
+    .unwrap();
+    let context = AwsOperationContext {
+        bedrock_runtime_endpoint: override_context
+            .then(|| format!("{}/bedrock-runtime", explicit.uri())),
+        ..Default::default()
+    };
+    assert_eq!(
+        BaseSecretManager::async_read_secret(&manager, "key", &context)
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "value"
+    );
+    assert!(
+        if override_context {
+            configured
+        } else {
+            explicit
+        }
+        .received_requests()
+        .await
+        .unwrap()
+        .is_empty()
+    );
+}
+
+#[rstest]
+#[case::unset(None)]
+#[case::disabled(Some(false))]
+fn disabled_secret_manager_loader_does_not_require_environment(#[case] enabled: Option<bool>) {
+    assert!(
+        AwsSecretsManagerV2::load_aws_secret_manager(
+            enabled,
+            Default::default(),
+            Arc::new(|_: &str| panic!("disabled loader consulted the environment"))
+        )
+        .unwrap()
+        .is_none()
+    );
+}
+
+#[rstest]
+#[case::role(None, None)]
+#[case::cross_account(Some("external-id"), None)]
+#[case::web_identity(None, Some("identity-token"))]
+#[tokio::test]
+async fn configured_sts_credentials_sign_the_secret_request(
+    #[case] external_id: Option<&str>,
+    #[case] identity: Option<&str>,
+) {
+    use aws_sdk_secretsmanager::primitives::{DateTime, DateTimeFormat};
+    let server = MockServer::start().await;
+    let expiry = DateTime::from(std::time::SystemTime::now() + Duration::from_secs(3600))
+        .fmt(DateTimeFormat::DateTime)
+        .unwrap();
+    let action = if identity.is_some() {
+        "AssumeRoleWithWebIdentity"
+    } else {
+        "AssumeRole"
+    };
+    let expected_external = external_id.map(str::to_owned);
+    let expected_identity = identity.map(str::to_owned);
+    Mock::given(wiremock::matchers::body_string_contains(format!("Action={action}")))
+        .respond_with(move |request: &wiremock::Request| {
+            let body = std::str::from_utf8(&request.body).unwrap();
+            assert!(body.contains("RoleArn=test-role"), "{body}");
+            assert!(body.contains("RoleSessionName=parity-session"), "{body}");
+            if let Some(value) = &expected_external { assert!(body.contains(&format!("ExternalId={value}"))); }
+            if let Some(value) = &expected_identity { assert!(body.contains(&format!("WebIdentityToken={value}"))); }
+            ResponseTemplate::new(200).set_body_string(format!(
+                "<{action}Response><{action}Result><Credentials><AccessKeyId>assumed-key</AccessKeyId>\
+                 <SecretAccessKey>assumed-secret</SecretAccessKey><SessionToken>session-token</SessionToken>\
+                 <Expiration>{expiry}</Expiration></Credentials></{action}Result></{action}Response>"))
+        }).expect(1).mount(&server).await;
+    Mock::given(header("x-amz-target", "secretsmanager.GetSecretValue"))
+        .and(header("x-amz-security-token", "session-token"))
+        .respond_with(|request: &wiremock::Request| {
+            assert!(
+                request.headers["authorization"]
+                    .to_str()
+                    .unwrap()
+                    .contains("Credential=assumed-key/")
+            );
+            ResponseTemplate::new(200).set_body_json(json!({"SecretString":"value"}))
+        })
+        .expect(1)
+        .mount(&server)
+        .await;
+    let endpoint = server.uri();
+    let manager = AwsSecretsManagerV2::load_aws_secret_manager(
+        Some(true),
+        KeyManagementSettings {
+            aws_region_name: Some("us-east-1".into()),
+            aws_role_name: Some("test-role".into()),
+            aws_session_name: Some("parity-session".into()),
+            aws_external_id: external_id.map(SecretValue::new),
+            aws_web_identity_token: identity.map(SecretValue::new),
+            aws_sts_endpoint: Some(endpoint.clone()),
+            ..Default::default()
+        },
+        Arc::new(move |name: &str| match name {
+            "AWS_BEDROCK_RUNTIME_ENDPOINT" => Some(endpoint.clone()),
+            "AWS_ACCESS_KEY_ID" | "AWS_SECRET_ACCESS_KEY" => Some("source-key".into()),
+            _ => None,
+        }),
+    )
+    .unwrap()
+    .unwrap();
+    assert_eq!(
+        manager
+            .async_read_secret("key")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "value"
+    );
+}
+
+#[tokio::test]
+async fn configured_profile_credentials_override_static_environment_credentials() {
+    const CHILD_ENDPOINT: &str = "LITELLM_SECRETS_PROFILE_TEST_ENDPOINT";
+    if let Ok(endpoint) = std::env::var(CHILD_ENDPOINT) {
+        let manager = AwsSecretsManagerV2::load_aws_secret_manager(
+            Some(true),
+            KeyManagementSettings {
+                aws_region_name: Some("us-east-1".into()),
+                aws_profile_name: Some("parity".into()),
+                ..Default::default()
+            },
+            Arc::new(move |name: &str| match name {
+                "AWS_BEDROCK_RUNTIME_ENDPOINT" => Some(endpoint.clone()),
+                "AWS_ACCESS_KEY_ID" | "AWS_SECRET_ACCESS_KEY" => Some("wrong-static-key".into()),
+                _ => None,
+            }),
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(
+            manager
+                .async_read_secret("key")
+                .await
+                .unwrap()
+                .unwrap()
+                .expose(),
+            "profile-value"
+        );
+        return;
+    }
+    let server = MockServer::start().await;
+    Mock::given(header("x-amz-target", "secretsmanager.GetSecretValue"))
+        .and(header("x-amz-security-token", "profile-session"))
+        .respond_with(|request: &wiremock::Request| {
+            assert!(
+                request.headers["authorization"]
+                    .to_str()
+                    .unwrap()
+                    .contains("Credential=profile-key/")
+            );
+            ResponseTemplate::new(200).set_body_json(json!({"SecretString":"profile-value"}))
+        })
+        .expect(1)
+        .mount(&server)
+        .await;
+    let directory = tempfile::tempdir().unwrap();
+    let credentials = directory.path().join("credentials");
+    let config = directory.path().join("config");
+    std::fs::write(&credentials, "[parity]\naws_access_key_id=profile-key\naws_secret_access_key=profile-secret\naws_session_token=profile-session\n").unwrap();
+    std::fs::write(&config, "").unwrap();
+    let endpoint = server.uri();
+    let result = tokio::task::spawn_blocking(move || {
+        std::process::Command::new(std::env::current_exe().unwrap())
+            .args([
+                "--exact",
+                "configuration::configured_profile_credentials_override_static_environment_credentials",
+                "--nocapture",
+            ])
+            .env(CHILD_ENDPOINT, endpoint)
+            .env("AWS_SHARED_CREDENTIALS_FILE", credentials)
+            .env("AWS_CONFIG_FILE", config)
+            .output()
+            .unwrap()
+    })
+    .await
+    .unwrap();
+    assert!(
+        result.status.success(),
+        "{}\n{}",
+        String::from_utf8_lossy(&result.stdout),
+        String::from_utf8_lossy(&result.stderr)
+    );
+}
diff --git a/litellm-rust/crates/secrets-aws/tests/secret_manager/reads.rs b/litellm-rust/crates/secrets-aws/tests/secret_manager/reads.rs
new file mode 100644
index 000000000000..3c39924f09f3
--- /dev/null
+++ b/litellm-rust/crates/secrets-aws/tests/secret_manager/reads.rs
@@ -0,0 +1,198 @@
+use super::*;
+
+#[rstest]
+#[case::string_value("KEY", Some(Secret::String(SecretValue::new("value"))))]
+#[case::missing_value("missing", None)]
+#[case::non_string_value("BOOL", Some(Secret::Bool(true)))]
+#[tokio::test]
+async fn primary_lookup_preserves_read_semantics(
+    default_settings: KeyManagementSettings,
+    #[case] name: &str,
+    #[case] expected: Option<Secret>,
+) {
+    let server = MockServer::start().await;
+    Mock::given(header("x-amz-target", "secretsmanager.GetSecretValue"))
+        .and(body_partial_json(json!({"SecretId":"primary"})))
+        .respond_with(
+            ResponseTemplate::new(200).set_body_json(
+                json!({"SecretString":json!({"KEY":"value", "BOOL":true}).to_string()}),
+            ),
+        )
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager = manager(&server, default_settings);
+    assert_eq!(
+        manager
+            .read_secret_for_resolver(name, Some("primary"), &|_: &str| None)
+            .await
+            .unwrap(),
+        expected
+    );
+}
+
+#[rstest]
+#[case::access_key("AWS_ACCESS_KEY_ID")]
+#[case::secret_access_key("AWS_SECRET_ACCESS_KEY")]
+#[case::region_name("AWS_REGION_NAME")]
+#[case::region("AWS_REGION")]
+#[case::bedrock_endpoint("AWS_BEDROCK_RUNTIME_ENDPOINT")]
+#[tokio::test]
+async fn bootstrap_keys_bypass_primary_lookup(
+    default_settings: KeyManagementSettings,
+    #[case] name: &str,
+) {
+    let server = MockServer::start().await;
+    let manager = manager(&server, default_settings);
+    assert_eq!(
+        manager
+            .read_secret_for_resolver(name, Some("primary"), &|_: &str| Some("bootstrap".into()))
+            .await
+            .unwrap()
+            .unwrap()
+            .as_str()
+            .unwrap(),
+        "bootstrap"
+    );
+}
+
+#[rstest]
+#[tokio::test]
+async fn failed_read_returns_none_but_invalid_primary_json_is_an_error(
+    default_settings: KeyManagementSettings,
+) {
+    let server = MockServer::start().await;
+    Mock::given(body_partial_json(json!({"SecretId":"missing"})))
+        .respond_with(
+            ResponseTemplate::new(400).set_body_json(json!({"__type":"ResourceNotFoundException"})),
+        )
+        .mount(&server)
+        .await;
+    Mock::given(body_partial_json(json!({"SecretId":"invalid"})))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"SecretString":"not-json"})))
+        .mount(&server)
+        .await;
+    Mock::given(body_partial_json(json!({"SecretId":"no-string"})))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"Name":"no-string"})))
+        .mount(&server)
+        .await;
+    let manager = manager(&server, default_settings);
+    assert!(
+        manager
+            .async_read_secret("missing")
+            .await
+            .unwrap()
+            .is_none()
+    );
+    assert!(matches!(
+        manager
+            .read_secret_for_resolver("KEY", Some("invalid"), &|_: &str| None)
+            .await,
+        Err(Error::PrimarySecret)
+    ));
+    assert!(matches!(
+        manager.async_read_secret("no-string").await,
+        Err(Error::MissingString)
+    ));
+}
+
+#[rstest]
+#[tokio::test]
+async fn trait_read_uses_the_aws_region_from_its_operation_context() {
+    let server = MockServer::start().await;
+    Mock::given(header("x-amz-target", "secretsmanager.GetSecretValue"))
+        .respond_with(|request: &wiremock::Request| {
+            let authorization = request
+                .headers
+                .get("authorization")
+                .unwrap()
+                .to_str()
+                .unwrap();
+            assert!(authorization.contains("/us-west-2/secretsmanager/aws4_request"));
+            ResponseTemplate::new(200).set_body_json(json!({"SecretString": "value"}))
+        })
+        .expect(1)
+        .mount(&server)
+        .await;
+    let context = AwsOperationContext {
+        region_name: Some("us-west-2".into()),
+        ..Default::default()
+    };
+    let value = BaseSecretManager::async_read_secret(&loaded_manager(&server), "key", &context)
+        .await
+        .unwrap();
+    assert_eq!(value.unwrap().expose(), "value");
+}
+
+#[rstest]
+#[tokio::test]
+async fn trait_read_applies_the_aws_operation_timeout() {
+    let server = MockServer::start().await;
+    Mock::given(header("x-amz-target", "secretsmanager.GetSecretValue"))
+        .respond_with(
+            ResponseTemplate::new(200)
+                .set_delay(Duration::from_secs(1))
+                .set_body_json(json!({"SecretString": "late"})),
+        )
+        .expect(1)
+        .mount(&server)
+        .await;
+    let context = AwsOperationContext {
+        timeout: Some(Duration::from_millis(30)),
+        ..Default::default()
+    };
+    assert!(matches!(
+        BaseSecretManager::async_read_secret(&loaded_manager(&server), "key", &context).await,
+        Err(Error::Timeout)
+    ));
+}
+
+#[rstest]
+#[tokio::test]
+async fn read_timeout_is_an_error_and_cannot_be_mistaken_for_missing() {
+    let server = MockServer::start().await;
+    Mock::given(wiremock::matchers::method("POST"))
+        .respond_with(
+            ResponseTemplate::new(200)
+                .set_delay(Duration::from_secs(1))
+                .set_body_json(json!({"SecretString":"late"})),
+        )
+        .mount(&server)
+        .await;
+    let config = client_builder(&server)
+        .timeout_config(
+            aws_sdk_secretsmanager::config::timeout::TimeoutConfig::builder()
+                .operation_timeout(Duration::from_millis(30))
+                .build(),
+        )
+        .build();
+    let manager = AwsSecretsManagerV2::new(Client::from_conf(config), Default::default());
+    assert!(matches!(
+        manager.async_read_secret("key").await,
+        Err(Error::Timeout)
+    ));
+}
+
+#[rstest]
+#[case::denied(400, "AccessDeniedException")]
+#[case::throttled(400, "ThrottlingException")]
+#[case::unavailable(503, "ServiceUnavailableException")]
+#[tokio::test]
+async fn service_failures_remain_errors(
+    default_settings: KeyManagementSettings,
+    #[case] status: u16,
+    #[case] code: &str,
+) {
+    let server = MockServer::start().await;
+    Mock::given(header("x-amz-target", "secretsmanager.GetSecretValue"))
+        .respond_with(ResponseTemplate::new(status).set_body_json(json!({"__type":code})))
+        .expect(1)
+        .mount(&server)
+        .await;
+    assert!(matches!(
+        manager(&server, default_settings)
+            .async_read_secret("key")
+            .await,
+        Err(Error::Read(_))
+    ));
+}
diff --git a/litellm-rust/crates/secrets-aws/tests/secret_manager/support.rs b/litellm-rust/crates/secrets-aws/tests/secret_manager/support.rs
new file mode 100644
index 000000000000..6e0df2fdab7a
--- /dev/null
+++ b/litellm-rust/crates/secrets-aws/tests/secret_manager/support.rs
@@ -0,0 +1,80 @@
+use super::*;
+
+pub(super) fn manager(server: &MockServer, settings: KeyManagementSettings) -> AwsSecretsManagerV2 {
+    let client = Client::from_conf(client_builder(server).build());
+    AwsSecretsManagerV2::new(client, (&settings).into())
+}
+
+pub(super) fn loaded_manager(server: &MockServer) -> AwsSecretsManagerV2 {
+    let endpoint_url = server.uri();
+    let environment: Arc<dyn litellm_core_utils::settings::Lookup + Send + Sync> =
+        Arc::new(move |name: &str| match name {
+            "AWS_BEDROCK_RUNTIME_ENDPOINT" => Some(endpoint_url.clone()),
+            "AWS_ACCESS_KEY_ID" => Some("test".into()),
+            "AWS_SECRET_ACCESS_KEY" => Some("test".into()),
+            _ => None,
+        });
+    AwsSecretsManagerV2::load_aws_secret_manager(
+        Some(true),
+        KeyManagementSettings {
+            aws_region_name: Some("us-east-1".into()),
+            ..Default::default()
+        },
+        environment,
+    )
+    .unwrap()
+    .unwrap()
+}
+
+#[fixture]
+pub(super) fn default_settings() -> KeyManagementSettings {
+    KeyManagementSettings::default()
+}
+
+pub(super) async fn scripted_actions(server: &MockServer, actions: Vec<Action>) {
+    let count = actions.len() as u64;
+    let step = AtomicUsize::new(0);
+    Mock::given(wiremock::matchers::method("POST"))
+        .respond_with(move |request: &wiremock::Request| {
+            let Action {
+                operation: action,
+                request: expected,
+                status,
+                response,
+            } = &actions[step.fetch_add(1, Ordering::SeqCst)];
+            assert_eq!(
+                request.headers["x-amz-target"],
+                format!("secretsmanager.{action}")
+            );
+            let body: serde_json::Value = request.body_json().unwrap();
+            let actual = serde_json::Value::Object(
+                body.as_object()
+                    .unwrap()
+                    .iter()
+                    .filter(|(key, _)| key.as_str() != "ClientRequestToken")
+                    .map(|(key, value)| (key.clone(), value.clone()))
+                    .collect(),
+            );
+            assert_eq!(&actual, expected);
+            ResponseTemplate::new(*status).set_body_json(response)
+        })
+        .expect(count)
+        .mount(server)
+        .await;
+}
+
+pub(super) struct Action {
+    pub(super) operation: &'static str,
+    pub(super) request: serde_json::Value,
+    pub(super) status: u16,
+    pub(super) response: serde_json::Value,
+}
+
+pub(super) fn client_builder(server: &MockServer) -> aws_sdk_secretsmanager::config::Builder {
+    aws_sdk_secretsmanager::Config::builder()
+        .behavior_version(BehaviorVersion::latest())
+        .region(Region::new("us-east-1"))
+        .credentials_provider(Credentials::new("test", "test", None, None, "test"))
+        .endpoint_url(server.uri())
+        .retry_config(RetryConfig::disabled())
+}
diff --git a/litellm-rust/crates/secrets-aws/tests/secret_manager/writes.rs b/litellm-rust/crates/secrets-aws/tests/secret_manager/writes.rs
new file mode 100644
index 000000000000..9968837d5492
--- /dev/null
+++ b/litellm-rust/crates/secrets-aws/tests/secret_manager/writes.rs
@@ -0,0 +1,615 @@
+use super::*;
+
+#[rstest]
+#[tokio::test]
+async fn same_name_rotation_uses_put_and_returns_its_response(
+    default_settings: KeyManagementSettings,
+) {
+    let server = MockServer::start().await;
+    Mock::given(header("x-amz-target", "secretsmanager.PutSecretValue"))
+        .and(body_partial_json(
+            json!({"SecretId":"key", "SecretString":"replacement"}),
+        ))
+        .respond_with(
+            ResponseTemplate::new(200).set_body_json(json!({"Name":"key", "VersionId":"version"})),
+        )
+        .expect(1)
+        .mount(&server)
+        .await;
+    let response = manager(&server, default_settings)
+        .async_rotate_secret("key", "key", &SecretValue::new("replacement"))
+        .await
+        .unwrap();
+    match response {
+        RotationResponse::Updated(output) => assert_eq!(output.version_id(), Some("version")),
+        _ => panic!("rotation created a second secret"),
+    }
+    assert_eq!(server.received_requests().await.unwrap().len(), 1);
+}
+
+#[rstest]
+#[tokio::test]
+async fn renamed_rotation_reads_creates_verifies_then_deletes(
+    default_settings: KeyManagementSettings,
+) {
+    let server = MockServer::start().await;
+    scripted_actions(
+        &server,
+        vec![
+            Action {
+                operation: "GetSecretValue",
+                request: json!({"SecretId":"old"}),
+                status: 200,
+                response: json!({"SecretString":"old-value"}),
+            },
+            Action {
+                operation: "CreateSecret",
+                request: json!({"Name":"new", "Description":"Rotated from old", "SecretString":"replacement"}),
+                status: 200,
+                response: json!({"Name":"new"}),
+            },
+            Action {
+                operation: "GetSecretValue",
+                request: json!({"SecretId":"new"}),
+                status: 200,
+                response: json!({"SecretString":"replacement"}),
+            },
+            Action {
+                operation: "DeleteSecret",
+                request: json!({"SecretId":"old", "RecoveryWindowInDays":7}),
+                status: 200,
+                response: json!({"Name":"old"}),
+            },
+        ],
+    ).await;
+    assert!(matches!(
+        manager(&server, default_settings)
+            .async_rotate_secret("old", "new", &SecretValue::new("replacement"))
+            .await
+            .unwrap(),
+        RotationResponse::Created(_)
+    ));
+}
+
+#[rstest]
+#[tokio::test]
+async fn creation_passes_tags_and_kms_and_survives_replication_failure() {
+    let server = MockServer::start().await;
+    Mock::given(header("x-amz-target", "secretsmanager.CreateSecret"))
+        .and(body_partial_json(json!({"Name":"key", "SecretString":"value", "KmsKeyId":"kms-key", "Tags":[{"Key":"stage", "Value":"test"}]})))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"Name":"key"}))).expect(1).mount(&server).await;
+    Mock::given(header(
+        "x-amz-target",
+        "secretsmanager.ReplicateSecretToRegions",
+    ))
+    .and(body_partial_json(
+        json!({"SecretId":"key", "AddReplicaRegions":[{"Region":"replica-region"}]}),
+    ))
+    .respond_with(
+        ResponseTemplate::new(400).set_body_json(json!({"__type":"InvalidRequestException"})),
+    )
+    .expect(1)
+    .mount(&server)
+    .await;
+    let settings = KeyManagementSettings {
+        kms_key_id: Some("kms-key".into()),
+        tags: Some(std::collections::BTreeMap::from([(
+            "stage".into(),
+            "test".into(),
+        )])),
+        replica_regions: Some(vec!["replica-region".into()]),
+        ..Default::default()
+    };
+    let manager = manager(&server, settings);
+    assert_eq!(
+        manager
+            .async_write_secret("key", &SecretValue::new("value"), None)
+            .await
+            .unwrap()
+            .name(),
+        Some("key")
+    );
+    assert!(
+        manager
+            .async_replicate_secret("key", &[])
+            .await
+            .unwrap()
+            .is_none()
+    );
+}
+
+#[rstest]
+#[tokio::test]
+async fn trait_write_uses_typed_write_context(default_settings: KeyManagementSettings) {
+    let server = MockServer::start().await;
+    Mock::given(header("x-amz-target", "secretsmanager.CreateSecret"))
+        .and(body_partial_json(json!({
+            "Name": "key",
+            "SecretString": "value",
+            "Description": "created by caller",
+            "Tags": [{"Key": "stage", "Value": "test"}],
+        })))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"Name": "key"})))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let context = SecretWriteContext {
+        description: Some("created by caller".into()),
+        tags: std::collections::BTreeMap::from([("stage".into(), "test".into())]),
+        ..Default::default()
+    };
+    let response = SecretWriter::async_write_secret(
+        &manager(&server, default_settings),
+        "key",
+        &SecretValue::new("value"),
+        &context,
+    )
+    .await
+    .unwrap();
+    assert_eq!(response.name(), Some("key"));
+}
+
+#[rstest]
+#[tokio::test]
+async fn trait_delete_uses_the_provider_recovery_policy(default_settings: KeyManagementSettings) {
+    let server = MockServer::start().await;
+    Mock::given(header("x-amz-target", "secretsmanager.DeleteSecret"))
+        .and(body_partial_json(json!({"SecretId": "key"})))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"Name": "key"})))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let response = SecretDeleter::async_delete_secret(
+        &manager(&server, default_settings),
+        "key",
+        &AwsOperationContext::default(),
+    )
+    .await
+    .unwrap();
+    assert_eq!(response.name(), Some("key"));
+}
+
+#[rstest]
+#[case::write(false)]
+#[case::rotate_back(true)]
+#[tokio::test]
+async fn recovery_window_alias_is_restored_updated_and_tagged(#[case] rotate: bool) {
+    let server = MockServer::start().await;
+    let description = if rotate {
+        "Rotated from old"
+    } else {
+        "description"
+    };
+    let write = json!({"Name":"key", "SecretString":"new", "Description":description,
+        "KmsKeyId":"kms", "Tags":[{"Key":"stage", "Value":"test"}]});
+    let actions = if rotate {
+        vec![Action {
+            operation: "GetSecretValue",
+            request: json!({"SecretId":"old"}),
+            status: 200,
+            response: json!({"SecretString":"old"}),
+        }]
+    } else {
+        vec![]
+    };
+    let recovery = vec![
+        Action {
+            operation: "CreateSecret",
+            request: write,
+            status: 400,
+            response: json!({"__type":"ResourceExistsException"}),
+        },
+        Action {
+            operation: "DescribeSecret",
+            request: json!({"SecretId":"key"}),
+            status: 200,
+            response: json!({"DeletedDate":1}),
+        },
+        Action {
+            operation: "RestoreSecret",
+            request: json!({"SecretId":"key"}),
+            status: 200,
+            response: json!({"Name":"key"}),
+        },
+        Action {
+            operation: "UpdateSecret",
+            request: json!({"SecretId":"key", "SecretString":"new", "Description":description,
+            "KmsKeyId":"kms"}),
+            status: 200,
+            response: json!({"ARN":"restored-arn", "Name":"key", "VersionId":"new-version"}),
+        },
+        Action {
+            operation: "TagResource",
+            request: json!({"SecretId":"key", "Tags":[{"Key":"stage", "Value":"test"}]}),
+            status: 200,
+            response: json!({}),
+        },
+    ];
+    let verification = if rotate {
+        vec![
+            Action {
+                operation: "GetSecretValue",
+                request: json!({"SecretId":"key"}),
+                status: 200,
+                response: json!({"SecretString":"new"}),
+            },
+            Action {
+                operation: "DeleteSecret",
+                request: json!({"SecretId":"old", "RecoveryWindowInDays":7}),
+                status: 200,
+                response: json!({}),
+            },
+        ]
+    } else {
+        vec![]
+    };
+    scripted_actions(
+        &server,
+        actions
+            .into_iter()
+            .chain(recovery)
+            .chain(verification)
+            .collect(),
+    )
+    .await;
+    let manager = manager(
+        &server,
+        KeyManagementSettings {
+            kms_key_id: Some("kms".into()),
+            tags: Some(std::collections::BTreeMap::from([(
+                "stage".into(),
+                "test".into(),
+            )])),
+            ..Default::default()
+        },
+    );
+    let output = if rotate {
+        match manager
+            .async_rotate_secret("old", "key", &SecretValue::new("new"))
+            .await
+            .unwrap()
+        {
+            RotationResponse::Created(output) => output,
+            _ => panic!("expected restored alias"),
+        }
+    } else {
+        manager
+            .async_write_secret("key", &SecretValue::new("new"), Some(description))
+            .await
+            .unwrap()
+    };
+    assert_eq!(
+        (output.arn(), output.name(), output.version_id()),
+        (Some("restored-arn"), Some("key"), Some("new-version"))
+    );
+}
+
+#[rstest]
+#[case::live(200, json!({"Name":"key"}))]
+#[case::missing(400, json!({"__type":"ResourceNotFoundException"}))]
+#[case::denied(400, json!({"__type":"AccessDeniedException"}))]
+#[tokio::test]
+async fn create_failure_does_not_overwrite_an_alias_without_a_deletion_date(
+    #[case] status: u16,
+    #[case] described: serde_json::Value,
+) {
+    let server = MockServer::start().await;
+    scripted_actions(
+        &server,
+        vec![
+            Action {
+                operation: "CreateSecret",
+                request: json!({"Name":"key", "SecretString":"new"}),
+                status: 400,
+                response: json!({"__type":"ResourceExistsException"}),
+            },
+            Action {
+                operation: "DescribeSecret",
+                request: json!({"SecretId":"key"}),
+                status,
+                response: described,
+            },
+        ],
+    )
+    .await;
+    assert!(matches!(
+        manager(&server, Default::default())
+            .async_write_secret("key", &SecretValue::new("new"), None)
+            .await,
+        Err(Error::Create(_))
+    ));
+}
+
+#[derive(Clone, Copy, Debug)]
+enum RecoveryFailure {
+    Restore,
+    Update,
+    Tag,
+    DeleteAfterUpdate,
+    DeleteAfterTag,
+}
+
+#[rstest]
+#[case::unconfigured(None)]
+#[case::empty(Some(vec![]))]
+#[case::configured(Some(vec!["region-a".into(), "region-b".into()]))]
+#[tokio::test]
+async fn creation_replicates_only_to_configured_regions(#[case] regions: Option<Vec<String>>) {
+    let server = MockServer::start().await;
+    let create = vec![Action {
+        operation: "CreateSecret",
+        request: json!({"Name":"key", "SecretString":"value", "KmsKeyId":"kms-key"}),
+        status: 200,
+        response: json!({"Name":"key", "VersionId":"created"}),
+    }];
+    let replicate = regions
+        .as_ref()
+        .filter(|regions| !regions.is_empty())
+        .map(|regions| Action {
+            operation: "ReplicateSecretToRegions",
+            request: json!({"SecretId":"key", "AddReplicaRegions":regions.iter()
+            .map(|region| json!({"Region":region})).collect::<Vec<_>>()}),
+            status: 200,
+            response: json!({"ARN":"replica-arn"}),
+        });
+    scripted_actions(&server, create.into_iter().chain(replicate).collect()).await;
+    let environment: Arc<dyn litellm_core_utils::settings::Lookup + Send + Sync> = {
+        let endpoint = server.uri();
+        Arc::new(move |name: &str| match name {
+            "AWS_BEDROCK_RUNTIME_ENDPOINT" => Some(endpoint.clone()),
+            "AWS_ACCESS_KEY_ID" | "AWS_SECRET_ACCESS_KEY" => Some("test".into()),
+            _ => None,
+        })
+    };
+    let manager = AwsSecretsManagerV2::load_aws_secret_manager(
+        Some(true),
+        KeyManagementSettings {
+            aws_region_name: Some("us-east-1".into()),
+            replica_regions: regions,
+            kms_key_id: Some("kms-key".into()),
+            ..Default::default()
+        },
+        environment,
+    )
+    .unwrap()
+    .unwrap();
+    assert_eq!(
+        manager
+            .async_write_secret("key", &SecretValue::new("value"), None)
+            .await
+            .unwrap()
+            .version_id(),
+        Some("created")
+    );
+}
+
+#[rstest]
+#[case::success(200)]
+#[case::denied(403)]
+#[tokio::test]
+async fn direct_replication_returns_response_or_service_error(#[case] status: u16) {
+    let server = MockServer::start().await;
+    scripted_actions(
+        &server,
+        vec![Action {
+            operation: "ReplicateSecretToRegions",
+            request: json!({"SecretId":"key", "AddReplicaRegions":[{"Region":"region-a"}, {"Region":"region-b"}]}),
+            status,
+            response: if status == 200 {
+                json!({"ARN":"replicated-arn"})
+            } else {
+                json!({"__type":"AccessDeniedException"})
+            },
+        }],
+    ).await;
+    let result = manager(&server, Default::default())
+        .async_replicate_secret("key", &["region-a".into(), "region-b".into()])
+        .await;
+    if status == 200 {
+        assert_eq!(result.unwrap().unwrap().arn(), Some("replicated-arn"));
+    } else {
+        assert!(matches!(result, Err(Error::Replicate(_))));
+    }
+}
+
+#[rstest]
+#[case::create(false)]
+#[case::replicate(true)]
+#[tokio::test]
+async fn write_and_replication_timeouts_remain_errors(#[case] replicate: bool) {
+    let server = MockServer::start().await;
+    Mock::given(wiremock::matchers::method("POST"))
+        .respond_with(
+            ResponseTemplate::new(200)
+                .set_delay(Duration::from_secs(1))
+                .set_body_json(json!({})),
+        )
+        .expect(if replicate { 1 } else { 2 })
+        .mount(&server)
+        .await;
+    let client = Client::from_conf(
+        client_builder(&server)
+            .timeout_config(
+                aws_sdk_secretsmanager::config::timeout::TimeoutConfig::builder()
+                    .operation_timeout(Duration::from_millis(50))
+                    .build(),
+            )
+            .build(),
+    );
+    let manager = AwsSecretsManagerV2::new(client, Default::default());
+    if replicate {
+        assert!(matches!(
+            manager
+                .async_replicate_secret("key", &["region".into()])
+                .await,
+            Err(Error::Replicate(_))
+        ));
+    } else {
+        assert!(matches!(
+            manager
+                .async_write_secret("key", &SecretValue::new("value"), None)
+                .await,
+            Err(Error::Create(_))
+        ));
+    }
+}
+
+#[rstest]
+#[case::text("value")]
+#[case::json(r#"{"api_key":"test","metadata":{"team":"test"},"temperature":0.7}"#)]
+#[case::empty("")]
+#[case::unicode(" π\n ")]
+#[tokio::test]
+async fn write_read_delete_preserves_the_complete_secret_string(#[case] value: &str) {
+    let server = MockServer::start().await;
+    scripted_actions(
+        &server,
+        vec![
+            Action {
+                operation: "CreateSecret",
+                request: json!({"Name":"key", "SecretString":value, "Description":"description"}),
+                status: 200,
+                response: json!({"Name":"key"}),
+            },
+            Action {
+                operation: "GetSecretValue",
+                request: json!({"SecretId":"key"}),
+                status: 200,
+                response: json!({"SecretString":value}),
+            },
+            Action {
+                operation: "DeleteSecret",
+                request: json!({"SecretId":"key", "RecoveryWindowInDays":7}),
+                status: 200,
+                response: json!({"Name":"key"}),
+            },
+        ],
+    )
+    .await;
+    let manager = manager(&server, Default::default());
+    assert_eq!(
+        manager
+            .async_write_secret("key", &SecretValue::new(value), Some("description"))
+            .await
+            .unwrap()
+            .name(),
+        Some("key")
+    );
+    assert_eq!(
+        manager
+            .async_read_secret("key")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        value
+    );
+    assert_eq!(
+        manager
+            .async_delete_secret("key", Some(7))
+            .await
+            .unwrap()
+            .name(),
+        Some("key")
+    );
+}
+
+#[rstest]
+#[case::restore(RecoveryFailure::Restore)]
+#[case::update(RecoveryFailure::Update)]
+#[case::tag(RecoveryFailure::Tag)]
+#[case::delete_after_update(RecoveryFailure::DeleteAfterUpdate)]
+#[case::delete_after_tag(RecoveryFailure::DeleteAfterTag)]
+#[tokio::test]
+async fn failed_update_reschedules_deletion_of_a_restored_alias(#[case] failure: RecoveryFailure) {
+    let server = MockServer::start().await;
+    let response = |failed| {
+        if failed {
+            (400, json!({"__type":"InvalidRequestException"}))
+        } else {
+            (200, json!({}))
+        }
+    };
+    let (restore_status, restore_body) = response(matches!(failure, RecoveryFailure::Restore));
+    let (update_status, update_body) = response(matches!(
+        failure,
+        RecoveryFailure::Update | RecoveryFailure::DeleteAfterUpdate
+    ));
+    let (delete_status, delete_body) = response(matches!(
+        failure,
+        RecoveryFailure::DeleteAfterUpdate | RecoveryFailure::DeleteAfterTag
+    ));
+    let prefix = [
+        Action {
+            operation: "CreateSecret",
+            request: json!({"Name":"key", "SecretString":"new", "Tags":[{"Key":"stage", "Value":"test"}]}),
+            status: 400,
+            response: json!({"__type":"ResourceExistsException"}),
+        },
+        Action {
+            operation: "DescribeSecret",
+            request: json!({"SecretId":"key"}),
+            status: 200,
+            response: json!({"DeletedDate":1}),
+        },
+        Action {
+            operation: "RestoreSecret",
+            request: json!({"SecretId":"key"}),
+            status: restore_status,
+            response: restore_body,
+        },
+    ];
+    let update = (!matches!(failure, RecoveryFailure::Restore)).then_some(Action {
+        operation: "UpdateSecret",
+        request: json!({"SecretId":"key", "SecretString":"new"}),
+        status: update_status,
+        response: update_body,
+    });
+    let tag = matches!(
+        failure,
+        RecoveryFailure::Tag | RecoveryFailure::DeleteAfterTag
+    )
+    .then_some(Action {
+        operation: "TagResource",
+        request: json!({"SecretId":"key", "Tags":[{"Key":"stage", "Value":"test"}]}),
+        status: 400,
+        response: json!({"__type":"InvalidRequestException"}),
+    });
+    let delete = (!matches!(failure, RecoveryFailure::Restore)).then_some(Action {
+        operation: "DeleteSecret",
+        request: json!({"SecretId":"key", "RecoveryWindowInDays":7}),
+        status: delete_status,
+        response: delete_body,
+    });
+    scripted_actions(
+        &server,
+        prefix
+            .into_iter()
+            .chain(update)
+            .chain(tag)
+            .chain(delete)
+            .collect(),
+    )
+    .await;
+    let error = manager(
+        &server,
+        KeyManagementSettings {
+            tags: Some(std::collections::BTreeMap::from([(
+                "stage".into(),
+                "test".into(),
+            )])),
+            ..Default::default()
+        },
+    )
+    .async_write_secret("key", &SecretValue::new("new"), None)
+    .await
+    .unwrap_err();
+    match failure {
+        RecoveryFailure::Restore => assert!(matches!(error, Error::Restore(_))),
+        RecoveryFailure::Update => assert!(matches!(error, Error::Update(_))),
+        RecoveryFailure::Tag => assert!(matches!(error, Error::Tag(_))),
+        RecoveryFailure::DeleteAfterUpdate | RecoveryFailure::DeleteAfterTag => {
+            assert!(matches!(error, Error::Delete(_)))
+        }
+    }
+}
diff --git a/litellm-rust/crates/secrets-azure/AGENTS.md b/litellm-rust/crates/secrets-azure/AGENTS.md
new file mode 100644
index 000000000000..8fcd32a6c0c3
--- /dev/null
+++ b/litellm-rust/crates/secrets-azure/AGENTS.md
@@ -0,0 +1 @@
+- https://learn.microsoft.com/en-us/rest/api/keyvault/secrets/get-secret/get-secret
diff --git a/litellm-rust/crates/secrets-azure/Cargo.toml b/litellm-rust/crates/secrets-azure/Cargo.toml
index 96db7f235ef8..7e8a79f89ef1 100644
--- a/litellm-rust/crates/secrets-azure/Cargo.toml
+++ b/litellm-rust/crates/secrets-azure/Cargo.toml
@@ -6,6 +6,7 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
+tokio.workspace = true
 litellm-auth-azure.workspace = true
 litellm-auth-types.workspace = true
 litellm-secrets-types.workspace = true
@@ -17,7 +18,6 @@ veil.workspace = true
 percent-encoding = "2.3"
 
 [dev-dependencies]
-tokio.workspace = true
 wiremock = "0.6.5"
 rstest.workspace = true
 serde_json.workspace = true
diff --git a/litellm-rust/crates/secrets-azure/src/error.rs b/litellm-rust/crates/secrets-azure/src/error.rs
index 9b20efe4f7c6..2862f08a56c5 100644
--- a/litellm-rust/crates/secrets-azure/src/error.rs
+++ b/litellm-rust/crates/secrets-azure/src/error.rs
@@ -1,5 +1,9 @@
 #[derive(thiserror::Error, veil::Redact)]
 pub enum Error {
+    #[error(transparent)]
+    Operation(#[from] litellm_secrets_types::Error),
+    #[error("secret manager operation timed out")]
+    Timeout,
     #[error("{0} environment variable is missing")]
     MissingEnvironment(&'static str),
     #[error("AZURE_KEY_VAULT_URI is not a valid https vault URL")]
diff --git a/litellm-rust/crates/secrets-azure/src/key_vault.rs b/litellm-rust/crates/secrets-azure/src/key_vault.rs
index 81ad0331ca78..13e59f8e4ac0 100644
--- a/litellm-rust/crates/secrets-azure/src/key_vault.rs
+++ b/litellm-rust/crates/secrets-azure/src/key_vault.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;
 use litellm_auth_azure::{AzureAuthInputs, AzureAuthService, ConfigValue};
 use litellm_auth_types::{InputSource, Sourced};
 use litellm_core_utils::settings::Lookup;
-use litellm_secrets_types::{Secret, SecretValue};
+use litellm_secrets_types::{AzureOperationContext, BaseSecretManager, Secret, SecretValue};
 use percent_encoding::{AsciiSet, NON_ALPHANUMERIC};
 use serde::Deserialize;
 
@@ -77,6 +77,12 @@ impl AzureKeyVault {
     }
 
     pub async fn get_secret(&self, name: &str) -> Result<Option<Secret>, Error> {
+        BaseSecretManager::async_read_secret(self, name, &AzureOperationContext::default())
+            .await
+            .map(|value| value.map(Secret::String))
+    }
+
+    async fn read(&self, name: &str) -> Result<Option<SecretValue>, Error> {
         let token = self
             .auth
             .get_azure_ad_token(&self.inputs, &|key| self.environment.get(key))
@@ -91,6 +97,7 @@ impl AzureKeyVault {
             .client
             .get(url)
             .bearer_auth(token.value().secret().expose())
+            .header(reqwest::header::ACCEPT, "application/json")
             .send()
             .await
             .map_err(Error::Http)?;
@@ -102,7 +109,7 @@ impl AzureKeyVault {
         }
         let payload: SecretResponse = response.json().await.map_err(Error::Http)?;
         let value = payload.value.ok_or(Error::MissingValue)?;
-        Ok(Some(Secret::String(SecretValue::new(value))))
+        Ok(Some(SecretValue::new(value)))
     }
 }
 
@@ -113,3 +120,59 @@ fn scope_for(vault: &reqwest::Url) -> String {
         .map_or(host, |(_, remainder)| remainder);
     format!("https://{resource}/.default")
 }
+
+impl BaseSecretManager for AzureKeyVault {
+    type Error = Error;
+    type Context = AzureOperationContext;
+
+    async fn async_read_secret(
+        &self,
+        name: &str,
+        context: &Self::Context,
+    ) -> Result<Option<SecretValue>, Error> {
+        match context.timeout {
+            Some(timeout) => tokio::time::timeout(timeout, self.read(name))
+                .await
+                .map_err(|_| Error::Timeout)?,
+            None => self.read(name).await,
+        }
+    }
+}
+
+pub trait AzureTokenProvider: Send + Sync {
+    fn get_token<'a>(
+        &'a self,
+        scope: &'a str,
+        environment: &'a (dyn Lookup + Send + Sync),
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<SecretValue, Error>> + Send + 'a>>;
+}
+
+#[derive(Default)]
+pub struct NativeAzureTokenProvider {
+    auth: AzureAuthService,
+}
+
+impl AzureTokenProvider for NativeAzureTokenProvider {
+    fn get_token<'a>(
+        &'a self,
+        scope: &'a str,
+        environment: &'a (dyn Lookup + Send + Sync),
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<SecretValue, Error>> + Send + 'a>>
+    {
+        Box::pin(async move {
+            let inputs = AzureAuthInputs {
+                azure_scope: ConfigValue::Value(Sourced::new(
+                    scope.to_owned(),
+                    InputSource::Deployment,
+                )),
+                enable_azure_ad_token_refresh: Sourced::new(true, InputSource::Deployment),
+                ..Default::default()
+            };
+            self.auth
+                .get_azure_ad_token(&inputs, &|name| environment.get(name))
+                .await?
+                .map(|token| SecretValue::new(token.value().secret().expose()))
+                .ok_or(Error::MissingCredentials)
+        })
+    }
+}
diff --git a/litellm-rust/crates/secrets-azure/src/lib.rs b/litellm-rust/crates/secrets-azure/src/lib.rs
index c0094fc033ba..8c1a182db6ba 100644
--- a/litellm-rust/crates/secrets-azure/src/lib.rs
+++ b/litellm-rust/crates/secrets-azure/src/lib.rs
@@ -4,4 +4,4 @@ mod error;
 mod key_vault;
 
 pub use error::Error;
-pub use key_vault::AzureKeyVault;
+pub use key_vault::{AzureKeyVault, AzureTokenProvider, NativeAzureTokenProvider};
diff --git a/litellm-rust/crates/secrets-azure/tests/key_vault.rs b/litellm-rust/crates/secrets-azure/tests/key_vault.rs
index 3b199f812642..a21149db3458 100644
--- a/litellm-rust/crates/secrets-azure/tests/key_vault.rs
+++ b/litellm-rust/crates/secrets-azure/tests/key_vault.rs
@@ -25,6 +25,7 @@ async fn reads_secret_with_bearer_token_and_api_version() {
     Mock::given(path("/secrets/OPENAI-API-KEY"))
         .and(query_param("api-version", "7.4"))
         .and(header("authorization", "Bearer fake"))
+        .and(header("accept", "application/json"))
         .respond_with(
             ResponseTemplate::new(200)
                 .set_body_json(serde_json::json!({"value": "s3cret", "id": "secret-id"})),
@@ -42,6 +43,23 @@ async fn reads_secret_with_bearer_token_and_api_version() {
     assert_eq!(secret, Secret::String(SecretValue::new("s3cret")));
 }
 
+#[rstest]
+#[tokio::test]
+async fn preserves_secret_contents_and_redacts_debug_output() {
+    let server = MockServer::start().await;
+    let value = " \tvalue-π\n";
+    Mock::given(path("/secrets/NAME"))
+        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({"value": value})))
+        .expect(1)
+        .mount(&server)
+        .await;
+
+    let secret = manager(&server).get_secret("NAME").await.unwrap().unwrap();
+
+    assert_eq!(secret.as_str(), Some(value));
+    assert!(!format!("{secret:?}").contains(value));
+}
+
 #[rstest]
 #[tokio::test]
 async fn percent_encodes_secret_name_path_segment() {
@@ -230,3 +248,22 @@ async fn parity_fixture_matches_python_backend_contract(parity_fixture: Fixture)
         }
     }
 }
+
+#[tokio::test]
+async fn trait_read_limits_the_operation_duration() {
+    use litellm_secrets_types::{AzureOperationContext, BaseSecretManager};
+    use std::time::Duration;
+    let server = MockServer::start().await;
+    Mock::given(wiremock::matchers::method("GET"))
+        .respond_with(ResponseTemplate::new(200).set_delay(Duration::from_secs(1)))
+        .mount(&server)
+        .await;
+    let manager = manager(&server);
+    let context = AzureOperationContext {
+        timeout: Some(Duration::from_millis(30)),
+    };
+    assert!(matches!(
+        BaseSecretManager::async_read_secret(&manager, "key", &context).await,
+        Err(Error::Timeout)
+    ));
+}
diff --git a/litellm-rust/crates/secrets-cyberark/AGENTS.md b/litellm-rust/crates/secrets-cyberark/AGENTS.md
new file mode 100644
index 000000000000..608850729c4d
--- /dev/null
+++ b/litellm-rust/crates/secrets-cyberark/AGENTS.md
@@ -0,0 +1 @@
+- https://docs.cyberark.com/conjur-open-source/latest/en/content/developer/conjur_api_retrieve_secret.htm
diff --git a/litellm-rust/crates/secrets-cyberark/Cargo.toml b/litellm-rust/crates/secrets-cyberark/Cargo.toml
index c1613f964030..1c280171f4c2 100644
--- a/litellm-rust/crates/secrets-cyberark/Cargo.toml
+++ b/litellm-rust/crates/secrets-cyberark/Cargo.toml
@@ -19,7 +19,9 @@ percent-encoding = "2.3"
 tokio = { workspace = true, features = ["sync"] }
 
 [dev-dependencies]
+rcgen = "0.14.10"
 rstest.workspace = true
+tempfile = "3.27.0"
 tokio.workspace = true
 wiremock = "0.6.5"
 serde.workspace = true
diff --git a/litellm-rust/crates/secrets-cyberark/src/error.rs b/litellm-rust/crates/secrets-cyberark/src/error.rs
index 5a14f4f3db86..3dfeb95fe26a 100644
--- a/litellm-rust/crates/secrets-cyberark/src/error.rs
+++ b/litellm-rust/crates/secrets-cyberark/src/error.rs
@@ -1,5 +1,7 @@
 #[derive(thiserror::Error, veil::Redact)]
 pub enum Error {
+    #[error("CyberArk Conjur operation timed out")]
+    Timeout,
     #[error("CyberArk Conjur HTTP request failed")]
     Http(
         #[from]
diff --git a/litellm-rust/crates/secrets-cyberark/src/lib.rs b/litellm-rust/crates/secrets-cyberark/src/lib.rs
index 5288f8116b13..74a8b6febf21 100644
--- a/litellm-rust/crates/secrets-cyberark/src/lib.rs
+++ b/litellm-rust/crates/secrets-cyberark/src/lib.rs
@@ -4,4 +4,4 @@ mod error;
 mod secret_manager;
 
 pub use error::Error;
-pub use secret_manager::{CyberArkSecretManager, DeleteOutcome};
+pub use secret_manager::{AuthenticationRetry, CyberArkSecretManager, DeleteOutcome, WriteFailure};
diff --git a/litellm-rust/crates/secrets-cyberark/src/secret_manager.rs b/litellm-rust/crates/secrets-cyberark/src/secret_manager.rs
index dd36cf183d8f..252a99c917f7 100644
--- a/litellm-rust/crates/secrets-cyberark/src/secret_manager.rs
+++ b/litellm-rust/crates/secrets-cyberark/src/secret_manager.rs
@@ -1,9 +1,14 @@
+mod client;
+mod read;
+mod write;
+
 use std::{fs, sync::Arc, time::Duration};
 
 use base64::{Engine, engine::general_purpose::STANDARD};
 use litellm_core_utils::settings::Lookup;
 use litellm_secrets_types::{
-    BaseSecretManager, SecretOperationContext, SecretValue, SecretWriteContext,
+    BaseSecretManager, CyberarkOperationContext, RotationError, SecretCache, SecretDeleter,
+    SecretRotator, SecretValue, SecretWriteContext, SecretWriter, async_rotate_secret,
     validate_secret_name,
 };
 use moka::future::Cache;
@@ -23,6 +28,7 @@ const DEFAULT_API_BASE: &str = "http://127.0.0.1:8080";
 const DEFAULT_ACCOUNT: &str = "default";
 const DEFAULT_USERNAME: &str = "admin";
 const DEFAULT_REFRESH_INTERVAL: Duration = Duration::from_secs(300);
+const MAX_TOKEN_LIFETIME: Duration = Duration::from_secs(7 * 60);
 const SECRET_NAME_SAFE: &AsciiSet = &NON_ALPHANUMERIC
     .remove(b'-')
     .remove(b'_')
@@ -37,7 +43,7 @@ pub struct CyberArkSecretManager {
     username: String,
     api_key: SecretValue,
     token: Cache<(), SecretValue>,
-    secrets: Cache<String, SecretValue>,
+    secrets: SecretCache<String, SecretValue>,
     authentication_lock: Arc<tokio::sync::Mutex<()>>,
 }
 
@@ -46,346 +52,53 @@ pub enum DeleteOutcome {
     NotSupported,
 }
 
-impl CyberArkSecretManager {
-    pub fn with_client(
-        client: reqwest::Client,
-        endpoint: reqwest::Url,
-        account: String,
-        username: String,
-        api_key: SecretValue,
-        refresh_interval: Option<Duration>,
-    ) -> Self {
-        let endpoint = normalize_endpoint(endpoint);
-        let ttl = refresh_interval
-            .filter(|interval| !interval.is_zero())
-            .unwrap_or(DEFAULT_REFRESH_INTERVAL);
-        let token = Cache::builder().time_to_live(ttl).build();
-        let secrets = Cache::builder().time_to_live(ttl).build();
+#[derive(Clone, Copy)]
+pub enum AuthenticationRetry {
+    Never,
+    Unauthorized,
+}
+
+#[derive(veil::Redact)]
+pub struct WriteFailure {
+    pub source: Error,
+    #[redact]
+    pub request_url: Option<reqwest::Url>,
+    pub authentication: bool,
+}
+
+impl WriteFailure {
+    fn local(source: Error) -> Self {
         Self {
-            client,
-            endpoint,
-            account,
-            username,
-            api_key,
-            token,
-            secrets,
-            authentication_lock: Arc::new(tokio::sync::Mutex::new(())),
+            source,
+            request_url: None,
+            authentication: false,
         }
     }
 
-    pub fn new(
-        environment: Arc<dyn Lookup + Send + Sync>,
-        enterprise_enabled: bool,
-    ) -> Result<Self, Error> {
-        let api_key = environment.get(CYBERARK_API_KEY).unwrap_or_default();
-        let cert = environment.get(CYBERARK_CLIENT_CERT).unwrap_or_default();
-        let key = environment.get(CYBERARK_CLIENT_KEY).unwrap_or_default();
-        if api_key.is_empty() && (cert.is_empty() || key.is_empty()) {
-            return Err(Error::MissingCredentials);
-        }
-        if !enterprise_enabled {
-            return Err(Error::EnterpriseRequired);
-        }
-        let verify = environment
-            .get(CYBERARK_SSL_VERIFY)
-            .map(|value| !value.trim().eq_ignore_ascii_case("false"))
-            .unwrap_or(true);
-        let mut builder = reqwest::Client::builder();
-        if !verify {
-            litellm_tracing::warn!(
-                "CyberArk SSL verification is disabled. This is insecure and should only be used for testing with self-signed certificates."
-            );
-            builder = builder.danger_accept_invalid_certs(true);
-        }
-        if !cert.is_empty() && !key.is_empty() {
-            let certificate = fs::read(cert).map_err(|_| Error::ClientCertificate)?;
-            let private_key = fs::read(key).map_err(|_| Error::ClientCertificate)?;
-            let identity = reqwest::Identity::from_pem(&[certificate, private_key].concat())
-                .map_err(|_| Error::ClientCertificate)?;
-            builder = builder.identity(identity);
+    fn request(source: Error, url: reqwest::Url) -> Self {
+        Self {
+            source,
+            request_url: Some(url),
+            authentication: false,
         }
-        let client = builder.build()?;
-        let endpoint = reqwest::Url::parse(
-            &environment
-                .get(CYBERARK_API_BASE)
-                .unwrap_or_else(|| DEFAULT_API_BASE.to_owned()),
-        )
-        .map_err(|_| Error::Endpoint)?;
-        let account = environment
-            .get(CYBERARK_ACCOUNT)
-            .unwrap_or_else(|| DEFAULT_ACCOUNT.to_owned());
-        let username = environment
-            .get(CYBERARK_USERNAME)
-            .unwrap_or_else(|| DEFAULT_USERNAME.to_owned());
-        let refresh_interval = environment
-            .get(CYBERARK_REFRESH_INTERVAL)
-            .map(|value| {
-                value
-                    .parse::<u64>()
-                    .map(Duration::from_secs)
-                    .map_err(|_| Error::RefreshInterval)
-            })
-            .transpose()?;
-        Ok(Self::with_client(
-            client,
-            endpoint,
-            account,
-            username,
-            SecretValue::new(api_key),
-            refresh_interval,
-        ))
     }
+}
 
+impl CyberArkSecretManager {
     fn secret_url(&self, name: &str) -> Result<reqwest::Url, Error> {
         let encoded = utf8_percent_encode(name, SECRET_NAME_SAFE);
         self.endpoint
             .join(&format!("secrets/{}/variable/{}", self.account, encoded))
             .map_err(|_| Error::Endpoint)
     }
-
-    async fn authenticate(&self, context: &SecretOperationContext) -> Result<SecretValue, Error> {
-        if let Some(token) = self.token.get(&()).await {
-            return Ok(token);
-        }
-        let _guard = self.authentication_lock.lock().await;
-        if let Some(token) = self.token.get(&()).await {
-            return Ok(token);
-        }
-        let url = self
-            .endpoint
-            .join(&format!(
-                "authn/{}/{}/authenticate",
-                self.account, self.username
-            ))
-            .map_err(|_| Error::Endpoint)?;
-        let response = with_timeout(
-            self.client.post(url).body(self.api_key.expose().to_owned()),
-            context,
-        )
-        .send()
-        .await?;
-        if !response.status().is_success() {
-            return Err(Error::AuthStatus(response.status().as_u16()));
-        }
-        let token = SecretValue::new(STANDARD.encode(response.text().await?));
-        self.token.insert((), token.clone()).await;
-        Ok(token)
-    }
-
-    async fn authorization_header(
-        &self,
-        context: &SecretOperationContext,
-    ) -> Result<String, Error> {
-        Ok(format!(
-            "Token token=\"{}\"",
-            self.authenticate(context).await?.expose()
-        ))
-    }
-
-    pub async fn async_read_secret(&self, name: &str) -> Result<Option<SecretValue>, Error> {
-        self.async_read_secret_with_context(name, &SecretOperationContext::default())
-            .await
-    }
-
-    pub async fn async_read_secret_with_context(
-        &self,
-        name: &str,
-        context: &SecretOperationContext,
-    ) -> Result<Option<SecretValue>, Error> {
-        if let Some(value) = self.secrets.get(name).await {
-            return Ok(Some(value));
-        }
-        let response = with_timeout(
-            self.client
-                .get(self.secret_url(name)?)
-                .header("Authorization", self.authorization_header(context).await?),
-            context,
-        )
-        .send()
-        .await?;
-        if response.status() == reqwest::StatusCode::NOT_FOUND {
-            return Ok(None);
-        }
-        if !response.status().is_success() {
-            return Err(Error::Status(response.status().as_u16()));
-        }
-        let value = SecretValue::new(response.text().await?);
-        self.secrets.insert(name.to_owned(), value.clone()).await;
-        Ok(Some(value))
-    }
-
-    pub async fn async_write_secret(
-        &self,
-        name: &str,
-        value: &SecretValue,
-        description: Option<&str>,
-    ) -> Result<(), Error> {
-        self.async_write_secret_with_context(
-            name,
-            value,
-            description,
-            &SecretOperationContext::default(),
-        )
-        .await
-    }
-
-    pub async fn async_write_secret_with_context(
-        &self,
-        name: &str,
-        value: &SecretValue,
-        _description: Option<&str>,
-        context: &SecretOperationContext,
-    ) -> Result<(), Error> {
-        validate_secret_name(name)?;
-        self.ensure_variable_exists(name, context).await;
-        let response = with_timeout(
-            self.client
-                .post(self.secret_url(name)?)
-                .header("Authorization", self.authorization_header(context).await?)
-                .body(value.expose().to_owned()),
-            context,
-        )
-        .send()
-        .await?;
-        if !response.status().is_success() {
-            return Err(Error::Status(response.status().as_u16()));
-        }
-        self.secrets.insert(name.to_owned(), value.clone()).await;
-        Ok(())
-    }
-
-    async fn ensure_variable_exists(&self, name: &str, context: &SecretOperationContext) {
-        let policy_url = self
-            .endpoint
-            .join(&format!("policies/{}/policy/root", self.account));
-        let Ok(policy_url) = policy_url else {
-            litellm_tracing::warn!("Could not build CyberArk policy endpoint");
-            return;
-        };
-        let Ok(authorization) = self.authorization_header(context).await else {
-            litellm_tracing::warn!(
-                "Could not authenticate while ensuring CyberArk variable exists"
-            );
-            return;
-        };
-        let body = format!(
-            "- !variable {}\n",
-            serde_json::to_string(name).expect("serializing a string cannot fail")
-        );
-        let response = with_timeout(
-            self.client
-                .post(policy_url)
-                .header("Authorization", authorization)
-                .header("Content-Type", "application/x-yaml")
-                .body(body),
-            context,
-        )
-        .send()
-        .await;
-        match response {
-            Ok(response) if response.status().is_success() => {}
-            Ok(response)
-                if matches!(
-                    response.status(),
-                    reqwest::StatusCode::CONFLICT | reqwest::StatusCode::UNPROCESSABLE_ENTITY
-                ) =>
-            {
-                litellm_tracing::debug!(
-                    "CyberArk variable policy already exists or conflicts: {}",
-                    response.status()
-                );
-            }
-            Ok(response) => {
-                litellm_tracing::warn!(
-                    "Could not ensure CyberArk variable exists: {}",
-                    response.status()
-                );
-            }
-            Err(error) => {
-                litellm_tracing::warn!("Error ensuring CyberArk variable exists: {error}");
-            }
-        }
-    }
-
-    pub async fn async_delete_secret(
-        &self,
-        name: &str,
-        recovery_window_in_days: Option<u32>,
-    ) -> Result<DeleteOutcome, Error> {
-        self.async_delete_secret_with_context(
-            name,
-            recovery_window_in_days,
-            &SecretOperationContext::default(),
-        )
-        .await
-    }
-
-    pub async fn async_delete_secret_with_context(
-        &self,
-        name: &str,
-        _recovery_window_in_days: Option<u32>,
-        _context: &SecretOperationContext,
-    ) -> Result<DeleteOutcome, Error> {
-        litellm_tracing::warn!(
-            "CyberArk Conjur does not support direct secret deletion. Secrets must be removed through policy updates."
-        );
-        self.secrets.invalidate(name).await;
-        Ok(DeleteOutcome::NotSupported)
-    }
-}
-
-impl BaseSecretManager for CyberArkSecretManager {
-    type Error = Error;
-    type WriteResponse = ();
-    type DeleteResponse = DeleteOutcome;
-
-    async fn async_read_secret(
-        &self,
-        name: &str,
-        context: &SecretOperationContext,
-    ) -> Result<Option<SecretValue>, Error> {
-        self.async_read_secret_with_context(name, context).await
-    }
-
-    async fn async_write_secret(
-        &self,
-        name: &str,
-        value: &SecretValue,
-        context: &SecretWriteContext,
-    ) -> Result<(), Error> {
-        self.async_write_secret_with_context(
-            name,
-            value,
-            context.description.as_deref(),
-            &context.operation,
-        )
-        .await
-    }
-
-    async fn async_delete_secret(
-        &self,
-        name: &str,
-        recovery_window_in_days: Option<u32>,
-        context: &SecretOperationContext,
-    ) -> Result<DeleteOutcome, Error> {
-        self.async_delete_secret_with_context(name, recovery_window_in_days, context)
-            .await
-    }
 }
 
 fn with_timeout(
     request: reqwest::RequestBuilder,
-    context: &SecretOperationContext,
+    context: &CyberarkOperationContext,
 ) -> reqwest::RequestBuilder {
-    match context.timeout() {
+    match context.timeout {
         Some(timeout) => request.timeout(timeout),
         None => request,
     }
 }
-
-fn normalize_endpoint(mut endpoint: reqwest::Url) -> reqwest::Url {
-    if !endpoint.path().ends_with('/') {
-        endpoint.set_path(&format!("{}/", endpoint.path()));
-    }
-    endpoint
-}
diff --git a/litellm-rust/crates/secrets-cyberark/src/secret_manager/client.rs b/litellm-rust/crates/secrets-cyberark/src/secret_manager/client.rs
new file mode 100644
index 000000000000..1d99fe474d5c
--- /dev/null
+++ b/litellm-rust/crates/secrets-cyberark/src/secret_manager/client.rs
@@ -0,0 +1,147 @@
+use super::*;
+
+impl CyberArkSecretManager {
+    pub fn with_client(
+        client: reqwest::Client,
+        endpoint: reqwest::Url,
+        account: String,
+        username: String,
+        api_key: SecretValue,
+        refresh_interval: Option<Duration>,
+    ) -> Self {
+        let endpoint = normalize_endpoint(endpoint);
+        let ttl = refresh_interval
+            .filter(|interval| !interval.is_zero())
+            .unwrap_or(DEFAULT_REFRESH_INTERVAL);
+        let token = Cache::builder()
+            .time_to_live(ttl.min(MAX_TOKEN_LIFETIME))
+            .build();
+        let secrets = SecretCache::new(200, ttl);
+        Self {
+            client,
+            endpoint,
+            account,
+            username,
+            api_key,
+            token,
+            secrets,
+            authentication_lock: Arc::new(tokio::sync::Mutex::new(())),
+        }
+    }
+
+    pub fn new(
+        environment: Arc<dyn Lookup + Send + Sync>,
+        enterprise_enabled: bool,
+    ) -> Result<Self, Error> {
+        let api_key = environment.get(CYBERARK_API_KEY).unwrap_or_default();
+        let cert = environment.get(CYBERARK_CLIENT_CERT).unwrap_or_default();
+        let key = environment.get(CYBERARK_CLIENT_KEY).unwrap_or_default();
+        if api_key.is_empty() && (cert.is_empty() || key.is_empty()) {
+            return Err(Error::MissingCredentials);
+        }
+        if !enterprise_enabled {
+            return Err(Error::EnterpriseRequired);
+        }
+        let verify = environment
+            .get(CYBERARK_SSL_VERIFY)
+            .map(|value| !value.trim().eq_ignore_ascii_case("false"))
+            .unwrap_or(true);
+        let mut builder = reqwest::Client::builder();
+        if !verify {
+            litellm_tracing::warn!(
+                "CyberArk SSL verification is disabled. This is insecure and should only be used for testing with self-signed certificates."
+            );
+            builder = builder.danger_accept_invalid_certs(true);
+        }
+        if !cert.is_empty() && !key.is_empty() {
+            let certificate = fs::read(cert).map_err(|_| Error::ClientCertificate)?;
+            let private_key = fs::read(key).map_err(|_| Error::ClientCertificate)?;
+            let identity = reqwest::Identity::from_pem(&[certificate, private_key].concat())
+                .map_err(|_| Error::ClientCertificate)?;
+            builder = builder.identity(identity);
+        }
+        let client = builder.build()?;
+        let endpoint = reqwest::Url::parse(
+            &environment
+                .get(CYBERARK_API_BASE)
+                .unwrap_or_else(|| DEFAULT_API_BASE.to_owned()),
+        )
+        .map_err(|_| Error::Endpoint)?;
+        let account = environment
+            .get(CYBERARK_ACCOUNT)
+            .unwrap_or_else(|| DEFAULT_ACCOUNT.to_owned());
+        let username = environment
+            .get(CYBERARK_USERNAME)
+            .unwrap_or_else(|| DEFAULT_USERNAME.to_owned());
+        let refresh_interval = environment
+            .get(CYBERARK_REFRESH_INTERVAL)
+            .map(|value| {
+                value
+                    .parse::<u64>()
+                    .map(Duration::from_secs)
+                    .map_err(|_| Error::RefreshInterval)
+            })
+            .transpose()?;
+        Ok(Self::with_client(
+            client,
+            endpoint,
+            account,
+            username,
+            SecretValue::new(api_key),
+            refresh_interval,
+        ))
+    }
+
+    pub(super) fn authentication_url(&self) -> Result<reqwest::Url, Error> {
+        self.endpoint
+            .join(&format!(
+                "authn/{}/{}/authenticate",
+                self.account,
+                utf8_percent_encode(&self.username, SECRET_NAME_SAFE)
+            ))
+            .map_err(|_| Error::Endpoint)
+    }
+
+    pub(super) async fn authenticate(
+        &self,
+        context: &CyberarkOperationContext,
+    ) -> Result<SecretValue, Error> {
+        if let Some(token) = self.token.get(&()).await {
+            return Ok(token);
+        }
+        let _guard = self.authentication_lock.lock().await;
+        if let Some(token) = self.token.get(&()).await {
+            return Ok(token);
+        }
+        let url = self.authentication_url()?;
+        let response = with_timeout(
+            self.client.post(url).body(self.api_key.expose().to_owned()),
+            context,
+        )
+        .send()
+        .await?;
+        if !response.status().is_success() {
+            return Err(Error::AuthStatus(response.status().as_u16()));
+        }
+        let token = SecretValue::new(STANDARD.encode(response.text().await?));
+        self.token.insert((), token.clone()).await;
+        Ok(token)
+    }
+
+    pub(super) async fn authorization_header(
+        &self,
+        context: &CyberarkOperationContext,
+    ) -> Result<String, Error> {
+        Ok(format!(
+            "Token token=\"{}\"",
+            self.authenticate(context).await?.expose()
+        ))
+    }
+}
+
+fn normalize_endpoint(mut endpoint: reqwest::Url) -> reqwest::Url {
+    if !endpoint.path().ends_with('/') {
+        endpoint.set_path(&format!("{}/", endpoint.path()));
+    }
+    endpoint
+}
diff --git a/litellm-rust/crates/secrets-cyberark/src/secret_manager/read.rs b/litellm-rust/crates/secrets-cyberark/src/secret_manager/read.rs
new file mode 100644
index 000000000000..daa9ed1114d0
--- /dev/null
+++ b/litellm-rust/crates/secrets-cyberark/src/secret_manager/read.rs
@@ -0,0 +1,118 @@
+use super::*;
+
+impl CyberArkSecretManager {
+    pub async fn async_read_secret(&self, name: &str) -> Result<Option<SecretValue>, Error> {
+        self.async_read_secret_with_context(name, &CyberarkOperationContext::default())
+            .await
+    }
+
+    pub async fn async_read_secret_with_context(
+        &self,
+        name: &str,
+        context: &CyberarkOperationContext,
+    ) -> Result<Option<SecretValue>, Error> {
+        self.read_with_retry(name, context, AuthenticationRetry::Unauthorized)
+            .await
+    }
+
+    pub async fn read_with_retry(
+        &self,
+        name: &str,
+        context: &CyberarkOperationContext,
+        retry: AuthenticationRetry,
+    ) -> Result<Option<SecretValue>, Error> {
+        validate_secret_name(name)?;
+        let read = self.secrets.read(
+            name.to_owned(),
+            self.read_uncached_with_retry(name, context, retry),
+        );
+        match context.timeout {
+            Some(timeout) => tokio::time::timeout(timeout, read)
+                .await
+                .map_err(|_| Error::Timeout)?,
+            None => read.await,
+        }
+    }
+
+    pub(super) async fn read_uncached(
+        &self,
+        name: &str,
+        context: &CyberarkOperationContext,
+    ) -> Result<Option<SecretValue>, Error> {
+        self.read_uncached_with_retry(name, context, AuthenticationRetry::Unauthorized)
+            .await
+    }
+
+    pub async fn read_fresh_with_retry(
+        &self,
+        name: &str,
+        context: &CyberarkOperationContext,
+        retry: AuthenticationRetry,
+    ) -> Result<Option<SecretValue>, Error> {
+        validate_secret_name(name)?;
+        self.secrets
+            .refresh(
+                name.to_owned(),
+                self.read_uncached_with_retry(name, context, retry),
+            )
+            .await
+    }
+
+    pub async fn invalidate_cached_secret(&self, name: &str) {
+        self.secrets.invalidate(&name.to_owned()).await;
+    }
+
+    pub(super) async fn read_uncached_with_retry(
+        &self,
+        name: &str,
+        context: &CyberarkOperationContext,
+        retry: AuthenticationRetry,
+    ) -> Result<Option<SecretValue>, Error> {
+        let had_cached_token = self.token.get(&()).await.is_some();
+        let response = with_timeout(
+            self.client
+                .get(self.secret_url(name)?)
+                .header("Authorization", self.authorization_header(context).await?),
+            context,
+        )
+        .send()
+        .await?;
+        let response = if matches!(retry, AuthenticationRetry::Unauthorized)
+            && had_cached_token
+            && response.status() == reqwest::StatusCode::UNAUTHORIZED
+        {
+            self.token.invalidate(&()).await;
+            with_timeout(
+                self.client
+                    .get(self.secret_url(name)?)
+                    .header("Authorization", self.authorization_header(context).await?),
+                context,
+            )
+            .send()
+            .await?
+        } else {
+            response
+        };
+        if response.status() == reqwest::StatusCode::NOT_FOUND {
+            return Ok(None);
+        }
+        if !response.status().is_success() {
+            return Err(Error::Status(response.status().as_u16()));
+        }
+        let value = SecretValue::new(response.text().await?);
+        Ok(Some(value))
+    }
+}
+
+impl BaseSecretManager for CyberArkSecretManager {
+    type Error = Error;
+    type Context = CyberarkOperationContext;
+
+    async fn async_read_secret(
+        &self,
+        name: &str,
+        context: &Self::Context,
+    ) -> Result<Option<SecretValue>, Error> {
+        self.async_read_secret_with_context(name, context).await
+    }
+}
diff --git a/litellm-rust/crates/secrets-cyberark/src/secret_manager/write.rs b/litellm-rust/crates/secrets-cyberark/src/secret_manager/write.rs
new file mode 100644
index 000000000000..265c5fc6b28d
--- /dev/null
+++ b/litellm-rust/crates/secrets-cyberark/src/secret_manager/write.rs
@@ -0,0 +1,262 @@
+use super::*;
+
+impl CyberArkSecretManager {
+    pub async fn async_write_secret(
+        &self,
+        name: &str,
+        value: &SecretValue,
+        description: Option<&str>,
+    ) -> Result<(), Error> {
+        self.async_write_secret_with_context(
+            name,
+            value,
+            description,
+            &CyberarkOperationContext::default(),
+        )
+        .await
+    }
+
+    pub async fn async_write_secret_with_context(
+        &self,
+        name: &str,
+        value: &SecretValue,
+        _description: Option<&str>,
+        context: &CyberarkOperationContext,
+    ) -> Result<(), Error> {
+        self.write_with_retry(name, value, context, AuthenticationRetry::Unauthorized)
+            .await
+            .map_err(|failure| failure.source)
+    }
+
+    pub async fn write_with_retry(
+        &self,
+        name: &str,
+        value: &SecretValue,
+        context: &CyberarkOperationContext,
+        retry: AuthenticationRetry,
+    ) -> Result<(), WriteFailure> {
+        validate_secret_name(name).map_err(|source| WriteFailure::local(source.into()))?;
+        self.ensure_variable_exists(name, context).await;
+        let url = self.secret_url(name).map_err(WriteFailure::local)?;
+        let response = self.post_value(&url, value, context).await?;
+        let response = if matches!(retry, AuthenticationRetry::Unauthorized)
+            && response.status() == reqwest::StatusCode::UNAUTHORIZED
+        {
+            self.token.invalidate(&()).await;
+            self.post_value(&url, value, context).await?
+        } else {
+            response
+        };
+        if !response.status().is_success() {
+            return Err(WriteFailure::request(
+                Error::Status(response.status().as_u16()),
+                url,
+            ));
+        }
+        self.secrets.insert(name.to_owned(), value.clone()).await;
+        Ok(())
+    }
+
+    async fn post_value(
+        &self,
+        url: &reqwest::Url,
+        value: &SecretValue,
+        context: &CyberarkOperationContext,
+    ) -> Result<reqwest::Response, WriteFailure> {
+        let authorization =
+            self.authorization_header(context)
+                .await
+                .map_err(|source| WriteFailure {
+                    source,
+                    request_url: self.authentication_url().ok(),
+                    authentication: true,
+                })?;
+        with_timeout(
+            self.client
+                .post(url.clone())
+                .header("Authorization", authorization)
+                .body(value.expose().to_owned()),
+            context,
+        )
+        .send()
+        .await
+        .map_err(|source| WriteFailure::request(source.into(), url.clone()))
+    }
+
+    pub(super) async fn ensure_variable_exists(
+        &self,
+        name: &str,
+        context: &CyberarkOperationContext,
+    ) {
+        let policy_url = self
+            .endpoint
+            .join(&format!("policies/{}/policy/root", self.account));
+        let Ok(policy_url) = policy_url else {
+            litellm_tracing::warn!("Could not build CyberArk policy endpoint");
+            return;
+        };
+        let Ok(authorization) = self.authorization_header(context).await else {
+            litellm_tracing::warn!(
+                "Could not authenticate while ensuring CyberArk variable exists"
+            );
+            return;
+        };
+        let body = format!(
+            "- !variable {}\n",
+            serde_json::to_string(name).expect("serializing a string cannot fail")
+        );
+        let response = with_timeout(
+            self.client
+                .post(policy_url)
+                .header("Authorization", authorization)
+                .header("Content-Type", "application/x-yaml")
+                .body(body),
+            context,
+        )
+        .send()
+        .await;
+        match response {
+            Ok(response) if response.status().is_success() => {}
+            Ok(response)
+                if matches!(
+                    response.status(),
+                    reqwest::StatusCode::CONFLICT | reqwest::StatusCode::UNPROCESSABLE_ENTITY
+                ) =>
+            {
+                litellm_tracing::debug!(
+                    "CyberArk variable policy already exists or conflicts: {}",
+                    response.status()
+                );
+            }
+            Ok(response) => {
+                litellm_tracing::warn!(
+                    "Could not ensure CyberArk variable exists: {}",
+                    response.status()
+                );
+            }
+            Err(error) => {
+                litellm_tracing::warn!("Error ensuring CyberArk variable exists: {error}");
+            }
+        }
+    }
+
+    pub async fn async_rotate_secret(
+        &self,
+        current_name: &str,
+        new_name: &str,
+        value: &SecretValue,
+    ) -> Result<(), RotationError<(), Error>> {
+        self.async_rotate_secret_with_context(
+            current_name,
+            new_name,
+            value,
+            &CyberarkOperationContext::default(),
+        )
+        .await
+    }
+
+    pub async fn async_rotate_secret_with_context(
+        &self,
+        current_name: &str,
+        new_name: &str,
+        value: &SecretValue,
+        context: &CyberarkOperationContext,
+    ) -> Result<(), RotationError<(), Error>> {
+        async_rotate_secret(self, current_name, new_name, value, context).await
+    }
+
+    pub async fn async_delete_secret(
+        &self,
+        name: &str,
+        recovery_window_in_days: Option<u32>,
+    ) -> Result<DeleteOutcome, Error> {
+        self.async_delete_secret_with_context(
+            name,
+            recovery_window_in_days,
+            &CyberarkOperationContext::default(),
+        )
+        .await
+    }
+
+    pub async fn async_delete_secret_with_context(
+        &self,
+        name: &str,
+        _recovery_window_in_days: Option<u32>,
+        _context: &CyberarkOperationContext,
+    ) -> Result<DeleteOutcome, Error> {
+        litellm_tracing::warn!(
+            "CyberArk Conjur does not support direct secret deletion. Secrets must be removed through policy updates."
+        );
+        self.secrets.invalidate(&name.to_owned()).await;
+        Ok(DeleteOutcome::NotSupported)
+    }
+}
+
+impl SecretWriter for CyberArkSecretManager {
+    type WriteResponse = ();
+
+    async fn async_write_secret(
+        &self,
+        name: &str,
+        value: &SecretValue,
+        context: &SecretWriteContext<Self::Context>,
+    ) -> Result<(), Error> {
+        self.async_write_secret_with_context(
+            name,
+            value,
+            context.description.as_deref(),
+            &context.operation,
+        )
+        .await
+    }
+}
+
+impl SecretDeleter for CyberArkSecretManager {
+    type DeleteResponse = DeleteOutcome;
+
+    async fn async_delete_secret(
+        &self,
+        name: &str,
+        context: &Self::Context,
+    ) -> Result<DeleteOutcome, Error> {
+        self.async_delete_secret_with_context(name, None, context)
+            .await
+    }
+}
+
+impl SecretRotator for CyberArkSecretManager {
+    type RotationResponse = ();
+
+    async fn async_read_secret_fresh(
+        &self,
+        name: &str,
+        context: &Self::Context,
+    ) -> Result<Option<SecretValue>, Error> {
+        validate_secret_name(name)?;
+        let read = self
+            .secrets
+            .refresh(name.to_owned(), self.read_uncached(name, context));
+        match context.timeout {
+            Some(timeout) => tokio::time::timeout(timeout, read)
+                .await
+                .map_err(|_| Error::Timeout)?,
+            None => read.await,
+        }
+    }
+
+    async fn async_write_replacement(
+        &self,
+        current_name: &str,
+        new_name: &str,
+        value: &SecretValue,
+        context: &Self::Context,
+    ) -> Result<(), Error> {
+        SecretWriter::async_write_secret(
+            self,
+            new_name,
+            value,
+            &SecretWriteContext::rotated_from(current_name, context.clone()),
+        )
+        .await
+    }
+}
diff --git a/litellm-rust/crates/secrets-cyberark/tests/secret_manager.rs b/litellm-rust/crates/secrets-cyberark/tests/secret_manager.rs
index 59964d90d50d..2048e067b6e2 100644
--- a/litellm-rust/crates/secrets-cyberark/tests/secret_manager.rs
+++ b/litellm-rust/crates/secrets-cyberark/tests/secret_manager.rs
@@ -1,10 +1,14 @@
-use std::{sync::Arc, time::Duration};
+use std::{
+    sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    },
+    time::Duration,
+};
 
 use base64::{Engine, engine::general_purpose::STANDARD};
 use litellm_secrets_cyberark::{CyberArkSecretManager, DeleteOutcome, Error};
-use litellm_secrets_types::{
-    BaseSecretManager, CyberarkOperationContext, SecretOperationContext, SecretValue,
-};
+use litellm_secrets_types::{BaseSecretManager, CyberarkOperationContext, SecretValue};
 use rstest::{fixture, rstest};
 use serde::Deserialize;
 use wiremock::{
@@ -12,546 +16,13 @@ use wiremock::{
     matchers::{body_string, header, method, path},
 };
 
-const TOKEN_JSON: &str = r#"{"protected":"p","payload":"q","signature":"s"}"#;
-
-#[derive(Deserialize)]
-struct ParityFixture {
-    endpoint: String,
-    account: String,
-    username: String,
-    api_key: String,
-    authenticate_path: String,
-    token_json: String,
-    authorization_header: String,
-    policy_path: String,
-    secrets: Vec<ParitySecret>,
-}
-
-#[derive(Deserialize)]
-struct ParitySecret {
-    name: String,
-    path: String,
-    policy_body: String,
-}
-
-#[derive(Debug)]
-struct RawPath(String);
-
-impl Match for RawPath {
-    fn matches(&self, request: &Request) -> bool {
-        request.url.path() == self.0
-    }
-}
-
-#[fixture]
-fn parity_fixture() -> ParityFixture {
-    serde_json::from_str(include_str!("fixtures/parity.json")).unwrap()
-}
-
-fn manager(server: &MockServer, ttl: Duration) -> CyberArkSecretManager {
-    CyberArkSecretManager::with_client(
-        reqwest::Client::new(),
-        server.uri().parse().unwrap(),
-        "acct".into(),
-        "admin".into(),
-        SecretValue::new("k3y"),
-        Some(ttl),
-    )
-}
-
-async fn mount_auth(server: &MockServer, expected: u64) {
-    Mock::given(method("POST"))
-        .and(path("/authn/acct/admin/authenticate"))
-        .and(body_string("k3y"))
-        .respond_with(ResponseTemplate::new(200).set_body_string(TOKEN_JSON))
-        .expect(expected)
-        .mount(server)
-        .await;
-}
-
-#[rstest]
-#[tokio::test]
-async fn successful_reads_cache_auth_secret_and_redact_values() {
-    let server = MockServer::start().await;
-    mount_auth(&server, 1).await;
-    let token = STANDARD.encode(TOKEN_JSON);
-    Mock::given(path("/secrets/acct/variable/OPENAI_API_KEY"))
-        .and(header("authorization", format!("Token token=\"{token}\"")))
-        .respond_with(ResponseTemplate::new(200).set_body_string("sk-live"))
-        .expect(1)
-        .mount(&server)
-        .await;
-    let manager = manager(&server, Duration::from_secs(60));
-
-    for _ in 0..2 {
-        let value = manager
-            .async_read_secret("OPENAI_API_KEY")
-            .await
-            .unwrap()
-            .unwrap();
-        assert_eq!(value.expose(), "sk-live");
-        assert!(!format!("{value:?}").contains("sk-live"));
-    }
-}
-
-#[rstest]
-#[tokio::test]
-async fn concurrent_reads_share_authentication_request() {
-    let server = MockServer::start().await;
-    Mock::given(path("/authn/acct/admin/authenticate"))
-        .and(body_string("k3y"))
-        .respond_with(
-            ResponseTemplate::new(200)
-                .set_body_string(TOKEN_JSON)
-                .set_delay(Duration::from_millis(20)),
-        )
-        .expect(1)
-        .mount(&server)
-        .await;
-    Mock::given(path("/secrets/acct/variable/key"))
-        .and(header(
-            "authorization",
-            format!("Token token=\"{}\"", STANDARD.encode(TOKEN_JSON)),
-        ))
-        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
-        .expect(2)
-        .mount(&server)
-        .await;
-    let manager = manager(&server, Duration::from_secs(60));
-
-    let (first, second) = tokio::join!(
-        manager.async_read_secret("key"),
-        manager.async_read_secret("key")
-    );
-
-    assert_eq!(first.unwrap().unwrap().expose(), "value");
-    assert_eq!(second.unwrap().unwrap().expose(), "value");
-}
-
-#[rstest]
-#[case::not_found(404)]
-#[case::unauthorized(401)]
-#[case::forbidden(403)]
-#[case::server_error(500)]
-#[tokio::test]
-async fn failed_reads_are_not_cached(#[case] status: u16) {
-    let server = MockServer::start().await;
-    mount_auth(&server, 1).await;
-    let failing = Mock::given(path("/secrets/acct/variable/key"))
-        .respond_with(ResponseTemplate::new(status))
-        .expect(1)
-        .mount_as_scoped(&server)
-        .await;
-    let manager = manager(&server, Duration::from_secs(60));
-    let result = manager.async_read_secret("key").await;
-    if status == 404 {
-        assert_eq!(result.unwrap(), None);
-    } else {
-        assert!(matches!(result, Err(Error::Status(actual)) if actual == status));
-    }
-    drop(failing);
-    Mock::given(path("/secrets/acct/variable/key"))
-        .respond_with(ResponseTemplate::new(200).set_body_string("recovered"))
-        .expect(1)
-        .mount(&server)
-        .await;
-    for _ in 0..2 {
-        assert_eq!(
-            manager
-                .async_read_secret("key")
-                .await
-                .unwrap()
-                .unwrap()
-                .expose(),
-            "recovered"
-        );
-    }
-}
-
-#[rstest]
-#[tokio::test]
-async fn failed_authentication_is_not_cached_and_does_not_read_secret() {
-    let server = MockServer::start().await;
-    let failing = Mock::given(path("/authn/acct/admin/authenticate"))
-        .respond_with(ResponseTemplate::new(401))
-        .expect(1)
-        .mount_as_scoped(&server)
-        .await;
-    let unused_secret = Mock::given(path("/secrets/acct/variable/key"))
-        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
-        .expect(0)
-        .mount_as_scoped(&server)
-        .await;
-    let manager = manager(&server, Duration::from_secs(60));
-    assert!(matches!(
-        manager.async_read_secret("key").await,
-        Err(Error::AuthStatus(401))
-    ));
-    drop(unused_secret);
-    drop(failing);
-    mount_auth(&server, 1).await;
-    Mock::given(path("/secrets/acct/variable/key"))
-        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
-        .expect(1)
-        .mount(&server)
-        .await;
-    assert_eq!(
-        manager
-            .async_read_secret("key")
-            .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "value"
-    );
-}
-
-#[rstest]
-#[tokio::test]
-async fn trait_read_applies_cyberark_operation_timeout_to_authentication() {
-    let server = MockServer::start().await;
-    Mock::given(path("/authn/acct/admin/authenticate"))
-        .respond_with(
-            ResponseTemplate::new(200)
-                .set_body_string(TOKEN_JSON)
-                .set_delay(Duration::from_millis(50)),
-        )
-        .mount(&server)
-        .await;
-    let manager = manager(&server, Duration::from_secs(60));
-    let context = SecretOperationContext::Cyberark(CyberarkOperationContext {
-        timeout: Some(Duration::from_millis(10)),
-    });
-
-    let result = BaseSecretManager::async_read_secret(&manager, "key", &context).await;
-
-    assert!(matches!(result, Err(Error::Http(error)) if error.is_timeout()));
-}
-
-#[rstest]
-#[tokio::test]
-async fn expired_tokens_and_secrets_are_fetched_again() {
-    let server = MockServer::start().await;
-    mount_auth(&server, 2).await;
-    Mock::given(path("/secrets/acct/variable/key"))
-        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
-        .expect(2)
-        .mount(&server)
-        .await;
-    let manager = manager(&server, Duration::from_millis(1));
-    for _ in 0..2 {
-        assert!(manager.async_read_secret("key").await.unwrap().is_some());
-        tokio::time::sleep(Duration::from_millis(5)).await;
-    }
-}
-
-#[rstest]
-#[case::plain("OPENAI_API_KEY")]
-#[case::path("team/app/key")]
-#[case::punctuation("a b+c.d-e_f~g")]
-#[case::quote("needs \"quote\"")]
-#[tokio::test]
-async fn secret_names_use_python_quote_encoding(parity_fixture: ParityFixture, #[case] name: &str) {
-    let secret = parity_fixture
-        .secrets
-        .iter()
-        .find(|secret| secret.name == name)
-        .unwrap();
-    let server = MockServer::start().await;
-    mount_auth(&server, 1).await;
-    Mock::given(RawPath(secret.path.clone()))
-        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
-        .expect(1)
-        .mount(&server)
-        .await;
-    assert_eq!(
-        manager(&server, Duration::from_secs(60))
-            .async_read_secret(name)
-            .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "value"
-    );
-}
-
-#[rstest]
-#[case::created(201)]
-#[case::already_exists(409)]
-#[case::unprocessable(422)]
-#[case::server_error(500)]
-#[tokio::test]
-async fn writes_tolerate_policy_status_and_cache_value(#[case] policy_status: u16) {
-    let server = MockServer::start().await;
-    mount_auth(&server, 1).await;
-    Mock::given(path("/policies/acct/policy/root"))
-        .and(header("content-type", "application/x-yaml"))
-        .and(body_string("- !variable \"team/app\"\n"))
-        .respond_with(ResponseTemplate::new(policy_status))
-        .expect(1)
-        .mount(&server)
-        .await;
-    Mock::given(path("/secrets/acct/variable/team%2Fapp"))
-        .and(body_string("v"))
-        .respond_with(ResponseTemplate::new(200))
-        .expect(1)
-        .mount(&server)
-        .await;
-    let manager = manager(&server, Duration::from_secs(60));
-    manager
-        .async_write_secret("team/app", &SecretValue::new("v"), None)
-        .await
-        .unwrap();
-    assert_eq!(
-        manager
-            .async_read_secret("team/app")
-            .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "v"
-    );
-}
-
-#[rstest]
-#[tokio::test]
-async fn failed_value_write_is_not_cached() {
-    let server = MockServer::start().await;
-    mount_auth(&server, 1).await;
-    Mock::given(path("/policies/acct/policy/root"))
-        .respond_with(ResponseTemplate::new(409))
-        .mount(&server)
-        .await;
-    Mock::given(path("/secrets/acct/variable/key"))
-        .and(body_string("v"))
-        .respond_with(ResponseTemplate::new(403))
-        .expect(1)
-        .mount(&server)
-        .await;
-    Mock::given(path("/secrets/acct/variable/key"))
-        .respond_with(ResponseTemplate::new(200).set_body_string("recovered"))
-        .expect(1)
-        .mount(&server)
-        .await;
-    let manager = manager(&server, Duration::from_secs(60));
-    assert!(matches!(
-        manager
-            .async_write_secret("key", &SecretValue::new("v"), None)
-            .await,
-        Err(Error::Status(403))
-    ));
-    assert_eq!(
-        manager
-            .async_read_secret("key")
-            .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "recovered"
-    );
-}
-
-#[rstest]
-#[case::parent("../etc")]
-#[case::embedded_parent("team/../etc")]
-#[case::control("key\n")]
-#[tokio::test]
-async fn unsafe_names_fail_before_http_calls(#[case] name: &str) {
-    let server = MockServer::start().await;
-    let manager = manager(&server, Duration::from_secs(60));
-    assert!(matches!(
-        manager
-            .async_write_secret(name, &SecretValue::new("v"), None)
-            .await,
-        Err(Error::Operation(
-            litellm_secrets_types::Error::UnsafeSecretName
-        ))
-    ));
-}
-
-#[rstest]
-#[tokio::test]
-async fn delete_invalidates_cache_and_reports_not_supported() {
-    let server = MockServer::start().await;
-    mount_auth(&server, 1).await;
-    Mock::given(path("/secrets/acct/variable/key"))
-        .respond_with(ResponseTemplate::new(200).set_body_string("v"))
-        .expect(2)
-        .mount(&server)
-        .await;
-    let manager = manager(&server, Duration::from_secs(60));
-    assert_eq!(
-        manager
-            .async_read_secret("key")
-            .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "v"
-    );
-    assert_eq!(
-        manager.async_delete_secret("key", Some(7)).await.unwrap(),
-        DeleteOutcome::NotSupported
-    );
-    assert_eq!(
-        manager
-            .async_read_secret("key")
-            .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "v"
-    );
-}
-
-#[rstest]
-fn new_validates_credentials_before_license_and_configuration() {
-    let empty: Arc<dyn litellm_core_utils::settings::Lookup + Send + Sync> =
-        Arc::new(|_: &str| None);
-    assert!(matches!(
-        CyberArkSecretManager::new(empty, true),
-        Err(Error::MissingCredentials)
-    ));
-    assert!(matches!(
-        CyberArkSecretManager::new(
-            Arc::new(|name: &str| (name == "CYBERARK_API_KEY").then(|| "k3y".into())),
-            false
-        ),
-        Err(Error::EnterpriseRequired)
-    ));
-    assert!(matches!(
-        CyberArkSecretManager::new(
-            Arc::new(|name: &str| (name == "CYBERARK_CLIENT_CERT").then(|| "cert".into())),
-            true
-        ),
-        Err(Error::MissingCredentials)
-    ));
-    assert!(matches!(
-        CyberArkSecretManager::new(
-            Arc::new(|name: &str| match name {
-                "CYBERARK_API_KEY" => Some("k3y".into()),
-                "CYBERARK_REFRESH_INTERVAL" => Some("abc".into()),
-                _ => None,
-            }),
-            true
-        ),
-        Err(Error::RefreshInterval)
-    ));
-    assert!(matches!(
-        CyberArkSecretManager::new(
-            Arc::new(|name: &str| match name {
-                "CYBERARK_API_KEY" => Some("k3y".into()),
-                "CYBERARK_API_BASE" => Some("not a url".into()),
-                _ => None,
-            }),
-            true
-        ),
-        Err(Error::Endpoint)
-    ));
-}
-
-#[rstest]
-#[tokio::test]
-async fn new_reads_environment_defaults_end_to_end() {
-    let server = MockServer::start().await;
-    Mock::given(path("/authn/default/admin/authenticate"))
-        .and(body_string("k3y"))
-        .respond_with(ResponseTemplate::new(200).set_body_string(TOKEN_JSON))
-        .mount(&server)
-        .await;
-    Mock::given(path("/secrets/default/variable/key"))
-        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
-        .mount(&server)
-        .await;
-    let endpoint = server.uri();
-    let manager = CyberArkSecretManager::new(
-        Arc::new(move |name: &str| match name {
-            "CYBERARK_API_BASE" => Some(endpoint.clone()),
-            "CYBERARK_API_KEY" => Some("k3y".into()),
-            _ => None,
-        }),
-        true,
-    )
-    .unwrap();
-    assert_eq!(
-        manager
-            .async_read_secret("key")
-            .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "value"
-    );
-}
-
-#[rstest]
-fn new_reports_missing_client_certificate_files() {
-    assert!(matches!(
-        CyberArkSecretManager::new(
-            Arc::new(|name: &str| match name {
-                "CYBERARK_CLIENT_CERT" => Some("/missing/cert".into()),
-                "CYBERARK_CLIENT_KEY" => Some("/missing/key".into()),
-                _ => None,
-            }),
-            true
-        ),
-        Err(Error::ClientCertificate)
-    ));
-}
-
-#[rstest]
-#[tokio::test]
-async fn trailing_slash_endpoint_preserves_base_path() {
-    let server = MockServer::start().await;
-    Mock::given(path("/prefix/authn/acct/admin/authenticate"))
-        .and(body_string("k3y"))
-        .respond_with(ResponseTemplate::new(200).set_body_string(TOKEN_JSON))
-        .expect(1)
-        .mount(&server)
-        .await;
-    Mock::given(path("/prefix/secrets/acct/variable/key"))
-        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
-        .mount(&server)
-        .await;
-    let endpoint = format!("{}/prefix/", server.uri()).parse().unwrap();
-    let manager = CyberArkSecretManager::with_client(
-        reqwest::Client::new(),
-        endpoint,
-        "acct".into(),
-        "admin".into(),
-        SecretValue::new("k3y"),
-        Some(Duration::from_secs(60)),
-    );
-    assert_eq!(
-        manager
-            .async_read_secret("key")
-            .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "value"
-    );
-}
+#[path = "secret_manager/support.rs"]
+mod support;
+use support::*;
 
-#[rstest]
-fn parity_fixture_matches_authentication_contract(parity_fixture: ParityFixture) {
-    assert_eq!(parity_fixture.endpoint, "http://conjur.test:8080");
-    assert_eq!(parity_fixture.account, "acct");
-    assert_eq!(parity_fixture.username, "admin");
-    assert_eq!(parity_fixture.api_key, "k3y");
-    assert_eq!(
-        parity_fixture.authenticate_path,
-        "/authn/acct/admin/authenticate"
-    );
-    assert_eq!(parity_fixture.token_json, TOKEN_JSON);
-    assert_eq!(
-        parity_fixture.authorization_header,
-        format!("Token token=\"{}\"", STANDARD.encode(TOKEN_JSON))
-    );
-    assert_eq!(parity_fixture.policy_path, "/policies/acct/policy/root");
-    assert_eq!(parity_fixture.secrets.len(), 4);
-    assert_eq!(
-        parity_fixture.secrets[1].policy_body,
-        "- !variable \"team/app/key\"\n"
-    );
-}
+#[path = "secret_manager/configuration.rs"]
+mod configuration;
+#[path = "secret_manager/reads.rs"]
+mod reads;
+#[path = "secret_manager/writes.rs"]
+mod writes;
diff --git a/litellm-rust/crates/secrets-cyberark/tests/secret_manager/configuration.rs b/litellm-rust/crates/secrets-cyberark/tests/secret_manager/configuration.rs
new file mode 100644
index 000000000000..fbd4317f446f
--- /dev/null
+++ b/litellm-rust/crates/secrets-cyberark/tests/secret_manager/configuration.rs
@@ -0,0 +1,452 @@
+use super::*;
+
+#[rstest]
+#[tokio::test]
+async fn successful_reads_cache_auth_secret_and_redact_values() {
+    let server = MockServer::start().await;
+    mount_auth(&server, 1).await;
+    let token = STANDARD.encode(TOKEN_JSON);
+    Mock::given(path("/secrets/acct/variable/OPENAI_API_KEY"))
+        .and(header("authorization", format!("Token token=\"{token}\"")))
+        .respond_with(ResponseTemplate::new(200).set_body_string("sk-live"))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager = manager(&server, Duration::from_secs(60));
+
+    for _ in 0..2 {
+        let value = manager
+            .async_read_secret("OPENAI_API_KEY")
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(value.expose(), "sk-live");
+        assert!(!format!("{value:?}").contains("sk-live"));
+    }
+}
+
+#[rstest]
+#[tokio::test]
+async fn concurrent_reads_share_authentication_and_secret_requests() {
+    let server = MockServer::start().await;
+    Mock::given(path("/authn/acct/admin/authenticate"))
+        .and(body_string("k3y"))
+        .respond_with(
+            ResponseTemplate::new(200)
+                .set_body_string(TOKEN_JSON)
+                .set_delay(Duration::from_millis(20)),
+        )
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(path("/secrets/acct/variable/key"))
+        .and(header(
+            "authorization",
+            format!("Token token=\"{}\"", STANDARD.encode(TOKEN_JSON)),
+        ))
+        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager = manager(&server, Duration::from_secs(60));
+
+    let (first, second) = tokio::join!(
+        manager.async_read_secret("key"),
+        manager.async_read_secret("key")
+    );
+
+    assert_eq!(first.unwrap().unwrap().expose(), "value");
+    assert_eq!(second.unwrap().unwrap().expose(), "value");
+}
+
+#[rstest]
+#[case::host("host/team/app", "/authn/acct/host%2Fteam%2Fapp/authenticate")]
+#[case::user("alice@devops", "/authn/acct/alice%40devops/authenticate")]
+#[tokio::test]
+async fn authentication_encodes_login(#[case] username: &str, #[case] expected_path: &str) {
+    let server = MockServer::start().await;
+    Mock::given(RawPath(expected_path.to_owned()))
+        .and(method("POST"))
+        .and(body_string("k3y"))
+        .respond_with(ResponseTemplate::new(200).set_body_string(TOKEN_JSON))
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(path("/secrets/acct/variable/key"))
+        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
+        .mount(&server)
+        .await;
+    let manager = CyberArkSecretManager::with_client(
+        reqwest::Client::new(),
+        server.uri().parse().unwrap(),
+        "acct".into(),
+        username.into(),
+        SecretValue::new("k3y"),
+        None,
+    );
+
+    assert_eq!(
+        manager
+            .async_read_secret("key")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "value"
+    );
+}
+
+#[rstest]
+#[tokio::test]
+async fn rejected_cached_token_is_reauthenticated_once() {
+    let server = MockServer::start().await;
+    mount_auth(&server, 2).await;
+    Mock::given(path("/secrets/acct/variable/first"))
+        .respond_with(ResponseTemplate::new(200).set_body_string("first-value"))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let attempts = Arc::new(AtomicUsize::new(0));
+    let attempts_for_response = Arc::clone(&attempts);
+    Mock::given(path("/secrets/acct/variable/second"))
+        .respond_with(move |_: &Request| {
+            if attempts_for_response.fetch_add(1, Ordering::SeqCst) == 0 {
+                ResponseTemplate::new(401)
+            } else {
+                ResponseTemplate::new(200).set_body_string("second-value")
+            }
+        })
+        .expect(2)
+        .mount(&server)
+        .await;
+    let manager = manager(&server, Duration::from_secs(600));
+
+    assert_eq!(
+        manager
+            .async_read_secret("first")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "first-value"
+    );
+    assert_eq!(
+        manager
+            .async_read_secret("second")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "second-value"
+    );
+    assert_eq!(attempts.load(Ordering::SeqCst), 2);
+}
+
+#[rstest]
+#[tokio::test]
+async fn failed_authentication_is_not_cached_and_does_not_read_secret() {
+    let server = MockServer::start().await;
+    let failing = Mock::given(path("/authn/acct/admin/authenticate"))
+        .respond_with(ResponseTemplate::new(401))
+        .expect(1)
+        .mount_as_scoped(&server)
+        .await;
+    let unused_secret = Mock::given(path("/secrets/acct/variable/key"))
+        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
+        .expect(0)
+        .mount_as_scoped(&server)
+        .await;
+    let manager = manager(&server, Duration::from_secs(60));
+    assert!(matches!(
+        manager.async_read_secret("key").await,
+        Err(Error::AuthStatus(401))
+    ));
+    drop(unused_secret);
+    drop(failing);
+    mount_auth(&server, 1).await;
+    Mock::given(path("/secrets/acct/variable/key"))
+        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
+        .expect(1)
+        .mount(&server)
+        .await;
+    assert_eq!(
+        manager
+            .async_read_secret("key")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "value"
+    );
+}
+
+#[rstest]
+#[tokio::test]
+async fn trait_read_applies_cyberark_operation_timeout_to_authentication() {
+    let server = MockServer::start().await;
+    Mock::given(path("/authn/acct/admin/authenticate"))
+        .respond_with(
+            ResponseTemplate::new(200)
+                .set_body_string(TOKEN_JSON)
+                .set_delay(Duration::from_millis(50)),
+        )
+        .mount(&server)
+        .await;
+    let manager = manager(&server, Duration::from_secs(60));
+    let context = CyberarkOperationContext {
+        timeout: Some(Duration::from_millis(10)),
+    };
+
+    let result = BaseSecretManager::async_read_secret(&manager, "key", &context).await;
+
+    match result {
+        Err(Error::Timeout) => {}
+        Err(Error::Http(error)) => assert!(error.is_timeout()),
+        other => panic!("expected timeout, got {other:?}"),
+    }
+}
+
+#[rstest]
+fn new_validates_credentials_before_license_and_configuration() {
+    let empty: Arc<dyn litellm_core_utils::settings::Lookup + Send + Sync> =
+        Arc::new(|_: &str| None);
+    assert!(matches!(
+        CyberArkSecretManager::new(empty, true),
+        Err(Error::MissingCredentials)
+    ));
+    assert!(matches!(
+        CyberArkSecretManager::new(
+            Arc::new(|name: &str| (name == "CYBERARK_API_KEY").then(|| "k3y".into())),
+            false
+        ),
+        Err(Error::EnterpriseRequired)
+    ));
+    assert!(matches!(
+        CyberArkSecretManager::new(
+            Arc::new(|name: &str| (name == "CYBERARK_CLIENT_CERT").then(|| "cert".into())),
+            true
+        ),
+        Err(Error::MissingCredentials)
+    ));
+    assert!(matches!(
+        CyberArkSecretManager::new(
+            Arc::new(|name: &str| match name {
+                "CYBERARK_API_KEY" => Some("k3y".into()),
+                "CYBERARK_REFRESH_INTERVAL" => Some("abc".into()),
+                _ => None,
+            }),
+            true
+        ),
+        Err(Error::RefreshInterval)
+    ));
+    assert!(matches!(
+        CyberArkSecretManager::new(
+            Arc::new(|name: &str| match name {
+                "CYBERARK_API_KEY" => Some("k3y".into()),
+                "CYBERARK_API_BASE" => Some("not a url".into()),
+                _ => None,
+            }),
+            true
+        ),
+        Err(Error::Endpoint)
+    ));
+}
+
+#[rstest]
+fn certificate_only_credentials_are_validated_as_a_client_identity() {
+    let result = CyberArkSecretManager::new(
+        Arc::new(|name: &str| match name {
+            "CYBERARK_CLIENT_CERT" => Some("/missing/cert".into()),
+            "CYBERARK_CLIENT_KEY" => Some("/missing/key".into()),
+            _ => None,
+        }),
+        true,
+    );
+
+    assert!(matches!(result, Err(Error::ClientCertificate)));
+}
+
+#[rstest]
+#[case::certificate_only("")]
+#[case::certificate_and_api_key("k3y")]
+#[tokio::test]
+async fn configured_client_identity_preserves_auth_request_and_read_result(
+    client_identity_directory: tempfile::TempDir,
+    #[case] api_key: &'static str,
+) {
+    let server = MockServer::start().await;
+    Mock::given(method("POST"))
+        .and(path("/authn/default/admin/authenticate"))
+        .and(body_string(api_key))
+        .respond_with(ResponseTemplate::new(200).set_body_string(TOKEN_JSON))
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(method("GET"))
+        .and(path("/secrets/default/variable/key"))
+        .and(header(
+            "authorization",
+            format!("Token token=\"{}\"", STANDARD.encode(TOKEN_JSON)),
+        ))
+        .respond_with(ResponseTemplate::new(200).set_body_string(" value\n"))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let endpoint = server.uri();
+    let certificate = client_identity_directory.path().join("client.crt");
+    let key = client_identity_directory.path().join("client.key");
+    let manager = CyberArkSecretManager::new(
+        Arc::new(move |name: &str| match name {
+            "CYBERARK_API_BASE" => Some(endpoint.clone()),
+            "CYBERARK_API_KEY" => Some(api_key.into()),
+            "CYBERARK_CLIENT_CERT" => Some(certificate.to_str().unwrap().into()),
+            "CYBERARK_CLIENT_KEY" => Some(key.to_str().unwrap().into()),
+            _ => None,
+        }),
+        true,
+    )
+    .unwrap();
+
+    assert!(server.received_requests().await.unwrap().is_empty());
+    assert_eq!(
+        manager
+            .async_read_secret("key")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        " value\n"
+    );
+}
+
+#[rstest]
+#[case::certificate_only("", "client.crt")]
+#[case::key_only("", "client.key")]
+#[case::certificate_with_api_key("k3y", "client.crt")]
+#[case::key_with_api_key("k3y", "client.key")]
+fn invalid_client_identity_is_not_ignored(
+    client_identity_directory: tempfile::TempDir,
+    #[case] api_key: &'static str,
+    #[case] invalid_file: &str,
+) {
+    std::fs::write(
+        client_identity_directory.path().join(invalid_file),
+        "not PEM",
+    )
+    .unwrap();
+    let certificate = client_identity_directory.path().join("client.crt");
+    let key = client_identity_directory.path().join("client.key");
+
+    let result = CyberArkSecretManager::new(
+        Arc::new(move |name: &str| match name {
+            "CYBERARK_API_KEY" => Some(api_key.into()),
+            "CYBERARK_CLIENT_CERT" => Some(certificate.to_str().unwrap().into()),
+            "CYBERARK_CLIENT_KEY" => Some(key.to_str().unwrap().into()),
+            _ => None,
+        }),
+        true,
+    );
+
+    assert!(matches!(result, Err(Error::ClientCertificate)));
+}
+
+#[rstest]
+#[case::certificate_only("")]
+#[case::certificate_and_api_key("k3y")]
+fn client_identity_does_not_bypass_the_enterprise_requirement(#[case] api_key: &'static str) {
+    let result = CyberArkSecretManager::new(
+        Arc::new(move |name: &str| match name {
+            "CYBERARK_API_KEY" => Some(api_key.into()),
+            "CYBERARK_CLIENT_CERT" => Some("/missing/cert".into()),
+            "CYBERARK_CLIENT_KEY" => Some("/missing/key".into()),
+            _ => None,
+        }),
+        false,
+    );
+
+    assert!(matches!(result, Err(Error::EnterpriseRequired)));
+}
+
+#[rstest]
+#[tokio::test]
+async fn new_reads_environment_defaults_end_to_end() {
+    let server = MockServer::start().await;
+    Mock::given(path("/authn/default/admin/authenticate"))
+        .and(body_string("k3y"))
+        .respond_with(ResponseTemplate::new(200).set_body_string(TOKEN_JSON))
+        .mount(&server)
+        .await;
+    Mock::given(path("/secrets/default/variable/key"))
+        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
+        .mount(&server)
+        .await;
+    let endpoint = server.uri();
+    let manager = CyberArkSecretManager::new(
+        Arc::new(move |name: &str| match name {
+            "CYBERARK_API_BASE" => Some(endpoint.clone()),
+            "CYBERARK_API_KEY" => Some("k3y".into()),
+            _ => None,
+        }),
+        true,
+    )
+    .unwrap();
+    assert_eq!(
+        manager
+            .async_read_secret("key")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "value"
+    );
+}
+
+#[rstest]
+fn new_reports_missing_client_certificate_files() {
+    assert!(matches!(
+        CyberArkSecretManager::new(
+            Arc::new(|name: &str| match name {
+                "CYBERARK_API_KEY" => Some("k3y".into()),
+                "CYBERARK_CLIENT_CERT" => Some("/missing/cert".into()),
+                "CYBERARK_CLIENT_KEY" => Some("/missing/key".into()),
+                _ => None,
+            }),
+            true
+        ),
+        Err(Error::ClientCertificate)
+    ));
+}
+
+#[rstest]
+#[tokio::test]
+async fn trailing_slash_endpoint_preserves_base_path() {
+    let server = MockServer::start().await;
+    Mock::given(path("/prefix/authn/acct/admin/authenticate"))
+        .and(body_string("k3y"))
+        .respond_with(ResponseTemplate::new(200).set_body_string(TOKEN_JSON))
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(path("/prefix/secrets/acct/variable/key"))
+        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
+        .mount(&server)
+        .await;
+    let endpoint = format!("{}/prefix/", server.uri()).parse().unwrap();
+    let manager = CyberArkSecretManager::with_client(
+        reqwest::Client::new(),
+        endpoint,
+        "acct".into(),
+        "admin".into(),
+        SecretValue::new("k3y"),
+        Some(Duration::from_secs(60)),
+    );
+    assert_eq!(
+        manager
+            .async_read_secret("key")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "value"
+    );
+}
diff --git a/litellm-rust/crates/secrets-cyberark/tests/secret_manager/reads.rs b/litellm-rust/crates/secrets-cyberark/tests/secret_manager/reads.rs
new file mode 100644
index 000000000000..3e5515841ed3
--- /dev/null
+++ b/litellm-rust/crates/secrets-cyberark/tests/secret_manager/reads.rs
@@ -0,0 +1,145 @@
+use super::*;
+
+#[rstest]
+#[tokio::test]
+async fn a_rejected_refreshed_token_surfaces_the_error_without_another_retry() {
+    let server = MockServer::start().await;
+    mount_auth(&server, 2).await;
+    Mock::given(path("/secrets/acct/variable/first"))
+        .respond_with(ResponseTemplate::new(200).set_body_string("first-value"))
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(path("/secrets/acct/variable/second"))
+        .respond_with(ResponseTemplate::new(401))
+        .expect(2)
+        .mount(&server)
+        .await;
+    let manager = manager(&server, Duration::from_secs(60));
+    assert_eq!(
+        manager
+            .async_read_secret("first")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "first-value"
+    );
+
+    let result = tokio::time::timeout(Duration::from_secs(5), manager.async_read_secret("second"))
+        .await
+        .expect("authentication retries must terminate");
+
+    assert!(matches!(result, Err(Error::Status(401))));
+}
+
+#[rstest]
+#[case::not_found(404)]
+#[case::unauthorized(401)]
+#[case::forbidden(403)]
+#[case::server_error(500)]
+#[tokio::test]
+async fn failed_reads_are_not_cached(#[case] status: u16) {
+    let server = MockServer::start().await;
+    mount_auth(&server, 1).await;
+    let failing = Mock::given(path("/secrets/acct/variable/key"))
+        .respond_with(ResponseTemplate::new(status))
+        .expect(1)
+        .mount_as_scoped(&server)
+        .await;
+    let manager = manager(&server, Duration::from_secs(60));
+    let result = manager.async_read_secret("key").await;
+    if status == 404 {
+        assert_eq!(result.unwrap(), None);
+    } else {
+        assert!(matches!(result, Err(Error::Status(actual)) if actual == status));
+    }
+    drop(failing);
+    Mock::given(path("/secrets/acct/variable/key"))
+        .respond_with(ResponseTemplate::new(200).set_body_string("recovered"))
+        .expect(1)
+        .mount(&server)
+        .await;
+    for _ in 0..2 {
+        assert_eq!(
+            manager
+                .async_read_secret("key")
+                .await
+                .unwrap()
+                .unwrap()
+                .expose(),
+            "recovered"
+        );
+    }
+}
+
+#[rstest]
+#[tokio::test]
+async fn expired_tokens_and_secrets_are_fetched_again() {
+    let server = MockServer::start().await;
+    mount_auth(&server, 2).await;
+    Mock::given(path("/secrets/acct/variable/key"))
+        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
+        .expect(2)
+        .mount(&server)
+        .await;
+    let manager = manager(&server, Duration::from_millis(1));
+    for _ in 0..2 {
+        assert!(manager.async_read_secret("key").await.unwrap().is_some());
+        tokio::time::sleep(Duration::from_millis(5)).await;
+    }
+}
+
+#[rstest]
+#[case::plain("OPENAI_API_KEY")]
+#[case::path("team/app/key")]
+#[case::punctuation("a b+c.d-e_f~g")]
+#[case::quote("needs \"quote\"")]
+#[tokio::test]
+async fn secret_names_use_python_quote_encoding(parity_fixture: ParityFixture, #[case] name: &str) {
+    let secret = parity_fixture
+        .secrets
+        .iter()
+        .find(|secret| secret.name == name)
+        .unwrap();
+    let server = MockServer::start().await;
+    mount_auth(&server, 1).await;
+    Mock::given(RawPath(secret.path.clone()))
+        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
+        .expect(1)
+        .mount(&server)
+        .await;
+    assert_eq!(
+        manager(&server, Duration::from_secs(60))
+            .async_read_secret(name)
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "value"
+    );
+}
+
+#[rstest]
+#[case::parent("../etc")]
+#[case::embedded_parent("team/../etc")]
+#[case::control("key\n")]
+#[tokio::test]
+async fn unsafe_names_fail_before_http_calls(#[case] name: &str) {
+    let server = MockServer::start().await;
+    let manager = manager(&server, Duration::from_secs(60));
+    assert!(matches!(
+        manager.async_read_secret(name).await,
+        Err(Error::Operation(
+            litellm_secrets_types::Error::UnsafeSecretName
+        ))
+    ));
+    assert!(matches!(
+        manager
+            .async_write_secret(name, &SecretValue::new("v"), None)
+            .await,
+        Err(Error::Operation(
+            litellm_secrets_types::Error::UnsafeSecretName
+        ))
+    ));
+}
diff --git a/litellm-rust/crates/secrets-cyberark/tests/secret_manager/support.rs b/litellm-rust/crates/secrets-cyberark/tests/secret_manager/support.rs
new file mode 100644
index 000000000000..f5ba7a632735
--- /dev/null
+++ b/litellm-rust/crates/secrets-cyberark/tests/secret_manager/support.rs
@@ -0,0 +1,70 @@
+use super::*;
+
+pub(super) const TOKEN_JSON: &str = r#"{"protected":"p","payload":"q","signature":"s"}"#;
+
+#[derive(Deserialize)]
+pub(super) struct ParityFixture {
+    pub(super) account: String,
+    pub(super) username: String,
+    pub(super) api_key: String,
+    pub(super) authenticate_path: String,
+    pub(super) token_json: String,
+    pub(super) authorization_header: String,
+    pub(super) policy_path: String,
+    pub(super) secrets: Vec<ParitySecret>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct ParitySecret {
+    pub(super) name: String,
+    pub(super) path: String,
+    pub(super) policy_body: String,
+}
+
+#[derive(Debug)]
+pub(super) struct RawPath(pub(super) String);
+
+impl Match for RawPath {
+    fn matches(&self, request: &Request) -> bool {
+        request.url.path() == self.0
+    }
+}
+
+#[fixture]
+pub(super) fn parity_fixture() -> ParityFixture {
+    serde_json::from_str(include_str!("../fixtures/parity.json")).unwrap()
+}
+
+#[fixture]
+pub(super) fn client_identity_directory() -> tempfile::TempDir {
+    let identity = rcgen::generate_simple_self_signed(vec!["localhost".into()]).unwrap();
+    let directory = tempfile::tempdir().unwrap();
+    std::fs::write(directory.path().join("client.crt"), identity.cert.pem()).unwrap();
+    std::fs::write(
+        directory.path().join("client.key"),
+        identity.signing_key.serialize_pem(),
+    )
+    .unwrap();
+    directory
+}
+
+pub(super) fn manager(server: &MockServer, ttl: Duration) -> CyberArkSecretManager {
+    CyberArkSecretManager::with_client(
+        reqwest::Client::new(),
+        server.uri().parse().unwrap(),
+        "acct".into(),
+        "admin".into(),
+        SecretValue::new("k3y"),
+        Some(ttl),
+    )
+}
+
+pub(super) async fn mount_auth(server: &MockServer, expected: u64) {
+    Mock::given(method("POST"))
+        .and(path("/authn/acct/admin/authenticate"))
+        .and(body_string("k3y"))
+        .respond_with(ResponseTemplate::new(200).set_body_string(TOKEN_JSON))
+        .expect(expected)
+        .mount(server)
+        .await;
+}
diff --git a/litellm-rust/crates/secrets-cyberark/tests/secret_manager/writes.rs b/litellm-rust/crates/secrets-cyberark/tests/secret_manager/writes.rs
new file mode 100644
index 000000000000..331a26c61196
--- /dev/null
+++ b/litellm-rust/crates/secrets-cyberark/tests/secret_manager/writes.rs
@@ -0,0 +1,450 @@
+use super::*;
+
+#[rstest]
+#[tokio::test]
+async fn rejected_write_token_is_reauthenticated_once() {
+    let server = MockServer::start().await;
+    mount_auth(&server, 2).await;
+    Mock::given(path("/policies/acct/policy/root"))
+        .respond_with(ResponseTemplate::new(409))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let attempts = Arc::new(AtomicUsize::new(0));
+    let attempts_for_response = Arc::clone(&attempts);
+    Mock::given(method("POST"))
+        .and(path("/secrets/acct/variable/key"))
+        .and(body_string("value"))
+        .respond_with(move |_: &Request| {
+            if attempts_for_response.fetch_add(1, Ordering::SeqCst) == 0 {
+                ResponseTemplate::new(401)
+            } else {
+                ResponseTemplate::new(200)
+            }
+        })
+        .expect(2)
+        .mount(&server)
+        .await;
+    let manager = manager(&server, Duration::from_secs(600));
+
+    manager
+        .async_write_secret("key", &SecretValue::new("value"), None)
+        .await
+        .unwrap();
+    assert_eq!(attempts.load(Ordering::SeqCst), 2);
+    assert_eq!(
+        manager
+            .async_read_secret("key")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "value"
+    );
+}
+
+#[rstest]
+#[case::created(201)]
+#[case::already_exists(409)]
+#[case::unprocessable(422)]
+#[case::server_error(500)]
+#[tokio::test]
+async fn writes_tolerate_policy_status_and_cache_value(#[case] policy_status: u16) {
+    let server = MockServer::start().await;
+    mount_auth(&server, 1).await;
+    Mock::given(path("/policies/acct/policy/root"))
+        .and(header("content-type", "application/x-yaml"))
+        .and(body_string("- !variable \"team/app\"\n"))
+        .respond_with(ResponseTemplate::new(policy_status))
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(path("/secrets/acct/variable/team%2Fapp"))
+        .and(body_string("v"))
+        .respond_with(ResponseTemplate::new(200))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager = manager(&server, Duration::from_secs(60));
+    manager
+        .async_write_secret("team/app", &SecretValue::new("v"), None)
+        .await
+        .unwrap();
+    assert_eq!(
+        manager
+            .async_read_secret("team/app")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "v"
+    );
+}
+
+#[rstest]
+#[tokio::test]
+async fn failed_value_write_is_not_cached() {
+    let server = MockServer::start().await;
+    mount_auth(&server, 1).await;
+    Mock::given(path("/policies/acct/policy/root"))
+        .respond_with(ResponseTemplate::new(409))
+        .mount(&server)
+        .await;
+    Mock::given(path("/secrets/acct/variable/key"))
+        .and(body_string("v"))
+        .respond_with(ResponseTemplate::new(403))
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(path("/secrets/acct/variable/key"))
+        .respond_with(ResponseTemplate::new(200).set_body_string("recovered"))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager = manager(&server, Duration::from_secs(60));
+    assert!(matches!(
+        manager
+            .async_write_secret("key", &SecretValue::new("v"), None)
+            .await,
+        Err(Error::Status(403))
+    ));
+    assert_eq!(
+        manager
+            .async_read_secret("key")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "recovered"
+    );
+}
+
+#[rstest]
+#[tokio::test]
+async fn delete_invalidates_cache_and_reports_not_supported() {
+    let server = MockServer::start().await;
+    mount_auth(&server, 1).await;
+    Mock::given(path("/secrets/acct/variable/key"))
+        .respond_with(ResponseTemplate::new(200).set_body_string("v"))
+        .expect(2)
+        .mount(&server)
+        .await;
+    let manager = manager(&server, Duration::from_secs(60));
+    assert_eq!(
+        manager
+            .async_read_secret("key")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "v"
+    );
+    assert_eq!(
+        manager.async_delete_secret("key", Some(7)).await.unwrap(),
+        DeleteOutcome::NotSupported
+    );
+    assert_eq!(
+        manager
+            .async_read_secret("key")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "v"
+    );
+}
+
+#[rstest]
+#[tokio::test]
+async fn writes_match_python_parity_fixture(parity_fixture: ParityFixture) {
+    let server = MockServer::start().await;
+    Mock::given(method("POST"))
+        .and(path(&parity_fixture.authenticate_path))
+        .and(body_string(&parity_fixture.api_key))
+        .respond_with(ResponseTemplate::new(200).set_body_string(&parity_fixture.token_json))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager = CyberArkSecretManager::with_client(
+        reqwest::Client::new(),
+        server.uri().parse().unwrap(),
+        parity_fixture.account,
+        parity_fixture.username,
+        SecretValue::new(parity_fixture.api_key),
+        Some(Duration::from_secs(60)),
+    );
+    for secret in parity_fixture.secrets {
+        Mock::given(method("POST"))
+            .and(path(&parity_fixture.policy_path))
+            .and(header(
+                "authorization",
+                &parity_fixture.authorization_header,
+            ))
+            .and(header("content-type", "application/x-yaml"))
+            .and(body_string(&secret.policy_body))
+            .respond_with(ResponseTemplate::new(201))
+            .expect(1)
+            .mount(&server)
+            .await;
+        Mock::given(method("POST"))
+            .and(RawPath(secret.path))
+            .and(header(
+                "authorization",
+                &parity_fixture.authorization_header,
+            ))
+            .and(body_string("value"))
+            .respond_with(ResponseTemplate::new(201))
+            .expect(1)
+            .mount(&server)
+            .await;
+        manager
+            .async_write_secret(&secret.name, &SecretValue::new("value"), None)
+            .await
+            .unwrap();
+        assert_eq!(
+            manager
+                .async_read_secret(&secret.name)
+                .await
+                .unwrap()
+                .unwrap()
+                .expose(),
+            "value"
+        );
+    }
+}
+
+#[rstest]
+#[tokio::test]
+#[ignore]
+async fn live_conjur_round_trip() {
+    let endpoint: reqwest::Url = std::env::var("CYBERARK_API_BASE").unwrap().parse().unwrap();
+    let account = std::env::var("CYBERARK_ACCOUNT").unwrap();
+    let username = std::env::var("CYBERARK_USERNAME").unwrap();
+    let api_key = SecretValue::new(std::env::var("CYBERARK_API_KEY").unwrap());
+    let name = format!(
+        "{}-{}",
+        std::env::var("LITELLM_CONJUR_LIVE_SECRET_NAME").unwrap(),
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos()
+    );
+    let manager = CyberArkSecretManager::with_client(
+        reqwest::Client::new(),
+        endpoint.clone(),
+        account.clone(),
+        username.clone(),
+        api_key.clone(),
+        Some(Duration::from_secs(60)),
+    );
+
+    assert!(manager.async_read_secret(&name).await.unwrap().is_none());
+    for expected in ["first-π\n", " second-π "] {
+        manager
+            .async_write_secret(&name, &SecretValue::new(expected), None)
+            .await
+            .unwrap();
+        let verifier = CyberArkSecretManager::with_client(
+            reqwest::Client::new(),
+            endpoint.clone(),
+            account.clone(),
+            username.clone(),
+            api_key.clone(),
+            Some(Duration::from_secs(60)),
+        );
+        assert_eq!(
+            verifier
+                .async_read_secret(&name)
+                .await
+                .unwrap()
+                .unwrap()
+                .expose(),
+            expected
+        );
+    }
+    manager
+        .async_rotate_secret(&name, &name, &SecretValue::new("rotated-value"))
+        .await
+        .unwrap();
+    let alias = format!("{name}-rotated");
+    manager
+        .async_rotate_secret(&name, &alias, &SecretValue::new("new-alias-value"))
+        .await
+        .unwrap();
+    assert_eq!(
+        manager
+            .async_read_secret(&name)
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "rotated-value"
+    );
+    assert_eq!(
+        manager
+            .async_read_secret(&alias)
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "new-alias-value"
+    );
+}
+
+#[rstest]
+#[case::same_alias("old")]
+#[case::new_alias("new")]
+#[tokio::test]
+async fn rotation_stores_the_replacement_and_retains_other_aliases(#[case] new_name: &'static str) {
+    use std::sync::atomic::{AtomicBool, Ordering};
+    let server = MockServer::start().await;
+    mount_auth(&server, 1).await;
+    let written = Arc::new(AtomicBool::new(false));
+    let read_state = written.clone();
+    Mock::given(method("GET"))
+        .respond_with(move |request: &wiremock::Request| {
+            let name = request.url.path().rsplit('/').next().unwrap();
+            let value = if name == new_name && read_state.load(Ordering::SeqCst) {
+                "new-value"
+            } else {
+                "old-value"
+            };
+            ResponseTemplate::new(200).set_body_string(value)
+        })
+        .expect(if new_name == "old" { 2 } else { 3 })
+        .mount(&server)
+        .await;
+    Mock::given(method("POST"))
+        .and(path("/policies/acct/policy/root"))
+        .and(body_string(format!("- !variable \"{new_name}\"\n")))
+        .respond_with(ResponseTemplate::new(201))
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(method("POST"))
+        .and(path(format!("/secrets/acct/variable/{new_name}")))
+        .and(body_string("new-value"))
+        .respond_with(move |_: &wiremock::Request| {
+            written.store(true, Ordering::SeqCst);
+            ResponseTemplate::new(201)
+        })
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager = manager(&server, Duration::from_secs(60));
+    manager
+        .async_rotate_secret("old", new_name, &SecretValue::new("new-value"))
+        .await
+        .unwrap();
+    assert_eq!(
+        manager
+            .async_read_secret(new_name)
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "new-value"
+    );
+    assert_eq!(
+        manager
+            .async_read_secret("old")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        if new_name == "old" {
+            "new-value"
+        } else {
+            "old-value"
+        }
+    );
+    assert!(
+        server
+            .received_requests()
+            .await
+            .unwrap()
+            .iter()
+            .all(|request| request.method != "DELETE")
+    );
+}
+
+#[tokio::test]
+async fn rotation_verifies_the_remote_value_instead_of_the_write_cache() {
+    let server = MockServer::start().await;
+    mount_auth(&server, 1).await;
+    Mock::given(method("GET"))
+        .respond_with(ResponseTemplate::new(200).set_body_string("unchanged"))
+        .expect(2)
+        .mount(&server)
+        .await;
+    Mock::given(method("POST"))
+        .and(path("/policies/acct/policy/root"))
+        .respond_with(ResponseTemplate::new(201))
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(method("POST"))
+        .and(path("/secrets/acct/variable/new"))
+        .respond_with(ResponseTemplate::new(201))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let result = manager(&server, Duration::from_secs(60))
+        .async_rotate_secret("old", "new", &SecretValue::new("replacement"))
+        .await;
+    assert!(matches!(
+        result,
+        Err(litellm_secrets_types::RotationError::Verification {
+            source: Error::Operation(litellm_secrets_types::Error::NewSecretMismatch),
+            ..
+        })
+    ));
+}
+
+#[rstest]
+#[case::colon("foo: bar")]
+#[case::comment("foo # bar")]
+#[case::plain("plain-alias")]
+#[case::email("team/user@example.com")]
+#[case::quote("needs \"quote\"")]
+#[case::backslash("a\\b")]
+#[tokio::test]
+async fn policy_writes_preserve_yaml_metacharacters_as_one_variable(#[case] name: &'static str) {
+    let server = MockServer::start().await;
+    mount_auth(&server, 1).await;
+    Mock::given(method("POST"))
+        .and(path("/policies/acct/policy/root"))
+        .respond_with(move |request: &wiremock::Request| {
+            let body = std::str::from_utf8(&request.body).unwrap();
+            let scalar = body
+                .strip_prefix("- !variable ")
+                .unwrap()
+                .strip_suffix('\n')
+                .unwrap();
+            assert_eq!(serde_json::from_str::<String>(scalar).unwrap(), name);
+            ResponseTemplate::new(201)
+        })
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(method("POST"))
+        .and(body_string("value"))
+        .respond_with(ResponseTemplate::new(201))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager = manager(&server, Duration::from_secs(60));
+    manager
+        .async_write_secret(name, &SecretValue::new("value"), None)
+        .await
+        .unwrap();
+    assert_eq!(
+        manager
+            .async_read_secret(name)
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "value"
+    );
+}
diff --git a/litellm-rust/crates/secrets-google/AGENTS.md b/litellm-rust/crates/secrets-google/AGENTS.md
new file mode 100644
index 000000000000..2ad447f15b34
--- /dev/null
+++ b/litellm-rust/crates/secrets-google/AGENTS.md
@@ -0,0 +1 @@
+- https://docs.cloud.google.com/secret-manager/docs/reference/rest/v1/projects.secrets.versions/access
diff --git a/litellm-rust/crates/secrets-google/Cargo.toml b/litellm-rust/crates/secrets-google/Cargo.toml
index daecf20ff9e8..805eb80740dd 100644
--- a/litellm-rust/crates/secrets-google/Cargo.toml
+++ b/litellm-rust/crates/secrets-google/Cargo.toml
@@ -6,14 +6,16 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
+moka.workspace = true
+tokio.workspace = true
 litellm-auth-gcp = { workspace = true, features = ["google-sdk"] }
 litellm-secrets-types.workspace = true
 litellm-auth-types.workspace = true
 litellm-core-utils.workspace = true
 base64.workspace = true
+crc32c = "0.6.8"
 serde_json.workspace = true
 thiserror.workspace = true
-moka.workspace = true
 veil.workspace = true
 google-cloud-kms-v1 = "1.14.0"
 google-cloud-gax = { version = "1.14.0", default-features = false }
@@ -24,5 +26,4 @@ reqwest.workspace = true
 [dev-dependencies]
 google-cloud-auth.workspace = true
 rstest.workspace = true
-tokio.workspace = true
 wiremock = "0.6.5"
diff --git a/litellm-rust/crates/secrets-google/src/error.rs b/litellm-rust/crates/secrets-google/src/error.rs
index a94cc8c2de62..159e4983ddc3 100644
--- a/litellm-rust/crates/secrets-google/src/error.rs
+++ b/litellm-rust/crates/secrets-google/src/error.rs
@@ -1,5 +1,9 @@
 #[derive(thiserror::Error, veil::Redact)]
 pub enum Error {
+    #[error(transparent)]
+    Operation(#[from] litellm_secrets_types::Error),
+    #[error("secret manager operation timed out")]
+    Timeout,
     #[error("Google KMS client configuration failed")]
     Client(
         #[from]
@@ -34,6 +38,8 @@ pub enum Error {
     RefreshInterval,
     #[error("payload is not valid base64")]
     Base64(#[from] base64::DecodeError),
+    #[error("Google Secret Manager payload checksum mismatch")]
+    Checksum,
     #[error("decrypted value is not UTF-8")]
     Utf8,
     #[error("invalid Google Secret Manager endpoint")]
diff --git a/litellm-rust/crates/secrets-google/src/kms.rs b/litellm-rust/crates/secrets-google/src/kms.rs
index 3a247edaa356..78ebae008f7e 100644
--- a/litellm-rust/crates/secrets-google/src/kms.rs
+++ b/litellm-rust/crates/secrets-google/src/kms.rs
@@ -36,12 +36,10 @@ impl GoogleKms {
 }
 
 pub fn validate_environment(environment: &dyn Lookup) -> Result<(), Error> {
-    for key in [GOOGLE_APPLICATION_CREDENTIALS, GOOGLE_KMS_RESOURCE_NAME] {
-        if environment.get(key).is_none() {
-            return Err(Error::MissingEnvironment(key));
-        }
-    }
-    Ok(())
+    environment
+        .get(GOOGLE_KMS_RESOURCE_NAME)
+        .map(|_| ())
+        .ok_or(Error::MissingEnvironment(GOOGLE_KMS_RESOURCE_NAME))
 }
 
 pub async fn load_google_kms(
@@ -52,13 +50,16 @@ pub async fn load_google_kms(
         return Ok(None);
     }
     validate_environment(environment.as_ref())?;
-    let credentials = environment
-        .get(GOOGLE_APPLICATION_CREDENTIALS)
-        .ok_or(Error::MissingEnvironment(GOOGLE_APPLICATION_CREDENTIALS))?;
     let resource_name = environment
         .get(GOOGLE_KMS_RESOURCE_NAME)
         .ok_or(Error::MissingEnvironment(GOOGLE_KMS_RESOURCE_NAME))?;
-    let credentials = auth::credentials(None, Some(SecretValue::new(credentials)), environment);
+    let credentials = auth::credentials(
+        None,
+        environment
+            .get(GOOGLE_APPLICATION_CREDENTIALS)
+            .map(SecretValue::new),
+        environment,
+    );
     let client = KeyManagementService::builder()
         .with_credentials(credentials)
         .build()
diff --git a/litellm-rust/crates/secrets-google/src/secret_manager.rs b/litellm-rust/crates/secrets-google/src/secret_manager.rs
index 3c34d9cbcc44..b8787999e12f 100644
--- a/litellm-rust/crates/secrets-google/src/secret_manager.rs
+++ b/litellm-rust/crates/secrets-google/src/secret_manager.rs
@@ -2,8 +2,9 @@ use std::{sync::Arc, time::Duration};
 
 use base64::{Engine, engine::general_purpose::STANDARD};
 use litellm_core_utils::settings::Lookup;
-use litellm_secrets_types::{Secret, SecretValue};
-use moka::future::Cache;
+use litellm_secrets_types::{
+    BaseSecretManager, GoogleOperationContext, Secret, SecretCache, SecretValue,
+};
 use serde::Deserialize;
 
 use litellm_auth_gcp::GoogleCredentials;
@@ -26,7 +27,8 @@ pub struct GoogleSecretManager {
     credentials: Arc<GoogleCredentials>,
     endpoint: reqwest::Url,
     project: String,
-    cache: Cache<String, SecretValue>,
+    cache: SecretCache<String, SecretValue>,
+    python_misses: moka::future::Cache<String, ()>,
     always_read: bool,
 }
 
@@ -38,6 +40,8 @@ struct Response {
 #[derive(Deserialize)]
 struct Payload {
     data: Option<String>,
+    #[serde(rename = "dataCrc32c")]
+    data_crc32c: Option<String>,
 }
 
 impl GoogleSecretManager {
@@ -59,16 +63,17 @@ impl GoogleSecretManager {
         let ttl = refresh_interval
             .filter(|ttl| !ttl.is_zero())
             .unwrap_or(DEFAULT_CACHE_TTL);
-        let cache = Cache::builder()
-            .max_capacity(CACHE_CAPACITY)
-            .time_to_live(ttl)
-            .build();
+        let cache = SecretCache::new(CACHE_CAPACITY, ttl);
         Ok(Self {
             client,
             credentials: Arc::new(credentials),
             endpoint,
             project,
             cache,
+            python_misses: moka::future::Cache::builder()
+                .max_capacity(CACHE_CAPACITY)
+                .time_to_live(ttl)
+                .build(),
             always_read,
         })
     }
@@ -116,11 +121,38 @@ impl GoogleSecretManager {
         &self,
         name: &str,
     ) -> Result<Option<Secret>, Error> {
-        if !self.always_read
-            && let Some(cached) = self.cache.get(name).await
-        {
-            return Ok(Some(Secret::String(cached)));
+        BaseSecretManager::async_read_secret(self, name, &GoogleOperationContext::default())
+            .await
+            .map(|value| value.map(Secret::String))
+    }
+
+    pub async fn get_secret_for_python(&self, name: &str) -> Result<Option<Secret>, Error> {
+        if !self.always_read && self.python_misses.get(name).await.is_some() {
+            return Ok(None);
+        }
+        let result = self.get_secret_from_google_secret_manager(name).await;
+        if matches!(
+            result,
+            Ok(None) | Err(Error::Status(_) | Error::MissingPayload)
+        ) {
+            self.python_misses.insert(name.to_owned(), ()).await;
+        }
+        match result {
+            Ok(None) => Err(Error::Status(404)),
+            result => result,
         }
+    }
+
+    async fn read(&self, name: &str) -> Result<Option<SecretValue>, Error> {
+        if self.always_read {
+            return self.read_uncached(name).await;
+        }
+        self.cache
+            .read(name.to_owned(), self.read_uncached(name))
+            .await
+    }
+
+    async fn read_uncached(&self, name: &str) -> Result<Option<SecretValue>, Error> {
         let url = self
             .endpoint
             .join(&format!(
@@ -145,13 +177,39 @@ impl GoogleSecretManager {
             return Err(Error::Status(response.status().as_u16()));
         }
         let response: Response = response.json().await?;
-        let Some(data) = response.payload.and_then(|payload| payload.data) else {
+        let Some(payload) = response.payload else {
+            return Err(Error::MissingPayload);
+        };
+        let Some(data) = payload.data else {
             return Err(Error::MissingPayload);
         };
         let bytes = STANDARD.decode(data)?;
+        if let Some(expected) = payload.data_crc32c {
+            let expected = expected.parse::<u32>().map_err(|_| Error::Checksum)?;
+            if crc32c::crc32c(&bytes) != expected {
+                return Err(Error::Checksum);
+            }
+        }
         let plaintext = String::from_utf8(bytes).map_err(|_| Error::Utf8)?;
         let value = SecretValue::new(plaintext);
-        self.cache.insert(name.to_owned(), value.clone()).await;
-        Ok(Some(Secret::String(value)))
+        Ok(Some(value))
+    }
+}
+
+impl BaseSecretManager for GoogleSecretManager {
+    type Error = Error;
+    type Context = GoogleOperationContext;
+
+    async fn async_read_secret(
+        &self,
+        name: &str,
+        context: &Self::Context,
+    ) -> Result<Option<SecretValue>, Error> {
+        match context.timeout {
+            Some(timeout) => tokio::time::timeout(timeout, self.read(name))
+                .await
+                .map_err(|_| Error::Timeout)?,
+            None => self.read(name).await,
+        }
     }
 }
diff --git a/litellm-rust/crates/secrets-google/tests/kms.rs b/litellm-rust/crates/secrets-google/tests/kms.rs
index 9739a46b10cf..0ccdcc9036fe 100644
--- a/litellm-rust/crates/secrets-google/tests/kms.rs
+++ b/litellm-rust/crates/secrets-google/tests/kms.rs
@@ -42,22 +42,41 @@ async fn google_kms_decrypts_using_the_configured_resource() {
 #[case::unset(None)]
 #[case::disabled(Some(false))]
 #[tokio::test]
-async fn disabled_google_kms_loader_does_not_require_environment_configuration(
+async fn disabled_google_kms_loader_does_not_read_environment_configuration(
     #[case] enabled: Option<bool>,
 ) {
     use std::sync::Arc;
     assert!(
-        litellm_secrets_google::load_google_kms(enabled, Arc::new(|_: &str| None))
+        litellm_secrets_google::load_google_kms(
+            enabled,
+            Arc::new(|name: &str| panic!("disabled Google KMS read {name}")),
+        )
+        .await
+        .unwrap()
+        .is_none()
+    );
+}
+
+#[rstest]
+#[tokio::test]
+async fn enabled_google_kms_loader_accepts_application_default_credentials() {
+    use std::sync::Arc;
+    let environment = Arc::new(|name: &str| {
+        (name == "GOOGLE_KMS_RESOURCE_NAME")
+            .then(|| "projects/project/locations/global/keyRings/ring/cryptoKeys/key".to_owned())
+    });
+
+    assert!(
+        litellm_secrets_google::load_google_kms(Some(true), environment)
             .await
             .unwrap()
-            .is_none()
+            .is_some()
     );
 }
 
 #[rstest]
-#[case::credentials_missing(None, None, "GOOGLE_APPLICATION_CREDENTIALS")]
-#[case::resource_missing(Some("credentials"), None, "GOOGLE_KMS_RESOURCE_NAME")]
-fn enabled_google_kms_requires_all_environment_values(
+#[case::resource_missing(None, None, "GOOGLE_KMS_RESOURCE_NAME")]
+fn enabled_google_kms_requires_resource_name(
     #[case] credentials: Option<&str>,
     #[case] resource: Option<&str>,
     #[case] missing: &'static str,
@@ -75,9 +94,13 @@ fn enabled_google_kms_requires_all_environment_values(
 }
 
 #[rstest]
-fn complete_google_kms_environment_is_valid() {
+#[case::service_account_file(Some("credentials"))]
+#[case::application_default_credentials(None)]
+fn google_kms_environment_is_valid_without_required_credential_file(
+    #[case] credentials: Option<&str>,
+) {
     let environment = |name: &str| match name {
-        "GOOGLE_APPLICATION_CREDENTIALS" => Some("credentials".to_owned()),
+        "GOOGLE_APPLICATION_CREDENTIALS" => credentials.map(str::to_owned),
         "GOOGLE_KMS_RESOURCE_NAME" => Some("resource".to_owned()),
         _ => None,
     };
diff --git a/litellm-rust/crates/secrets-google/tests/secret_manager.rs b/litellm-rust/crates/secrets-google/tests/secret_manager.rs
index 867dcf935c10..0d7efc4b1b3c 100644
--- a/litellm-rust/crates/secrets-google/tests/secret_manager.rs
+++ b/litellm-rust/crates/secrets-google/tests/secret_manager.rs
@@ -61,12 +61,43 @@ async fn successful_reads_use_auth_latest_version_and_cache_including_empty_valu
     }
 }
 
+#[tokio::test]
+async fn matching_checksum_is_accepted_and_cached() {
+    let server = MockServer::start().await;
+    let value = "private-value";
+    Mock::given(path(
+        "/v1/projects/project/secrets/key/versions/latest:access",
+    ))
+    .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
+        "payload": {
+            "data": STANDARD.encode(value),
+            "dataCrc32c": crc32c::crc32c(value.as_bytes()).to_string()
+        }
+    })))
+    .expect(1)
+    .mount(&server)
+    .await;
+    let manager = manager(&server, false, Duration::from_secs(60));
+    for _ in 0..2 {
+        assert_eq!(
+            manager
+                .get_secret_from_google_secret_manager("key")
+                .await
+                .unwrap()
+                .unwrap()
+                .as_str(),
+            Some(value)
+        );
+    }
+}
+
 enum ExpectedReadFailure {
     Missing,
     Status(u16),
     MissingPayload,
     Base64,
     Utf8,
+    Checksum,
 }
 
 #[rstest]
@@ -90,6 +121,11 @@ enum ExpectedReadFailure {
     serde_json::json!({"payload":{"data":STANDARD.encode([0xff])}}),
     ExpectedReadFailure::Utf8
 )]
+#[case::checksum_mismatch(
+    200,
+    serde_json::json!({"payload":{"data":STANDARD.encode("corrupt"),"dataCrc32c":"0"}}),
+    ExpectedReadFailure::Checksum
+)]
 #[tokio::test]
 async fn failed_or_missing_reads_are_not_cached(
     default_ttl: Duration,
@@ -117,6 +153,7 @@ async fn failed_or_missing_reads_are_not_cached(
         }
         ExpectedReadFailure::Base64 => assert!(matches!(result, Err(Error::Base64(_)))),
         ExpectedReadFailure::Utf8 => assert!(matches!(result, Err(Error::Utf8))),
+        ExpectedReadFailure::Checksum => assert!(matches!(result, Err(Error::Checksum))),
     }
     drop(failing);
     Mock::given(path(
@@ -235,3 +272,129 @@ async fn cache_preserves_raw_values(default_ttl: Duration, #[case] raw: &str) {
         );
     }
 }
+
+#[tokio::test]
+async fn trait_read_limits_the_operation_duration() {
+    use litellm_secrets_types::{BaseSecretManager, GoogleOperationContext};
+    use std::time::Duration;
+    let server = MockServer::start().await;
+    Mock::given(wiremock::matchers::method("GET"))
+        .respond_with(ResponseTemplate::new(200).set_delay(Duration::from_secs(1)))
+        .mount(&server)
+        .await;
+    let manager = manager(&server, false, Duration::from_secs(60));
+    let context = GoogleOperationContext {
+        timeout: Some(Duration::from_millis(30)),
+    };
+    assert!(matches!(
+        BaseSecretManager::async_read_secret(&manager, "key", &context).await,
+        Err(Error::Timeout)
+    ));
+}
+
+#[tokio::test]
+async fn concurrent_reads_share_one_secret_request() {
+    let server = MockServer::start().await;
+    Mock::given(wiremock::matchers::method("GET"))
+        .respond_with(
+            ResponseTemplate::new(200)
+                .set_body_json(serde_json::json!({"payload": {"data": STANDARD.encode("value")}}))
+                .set_delay(Duration::from_millis(20)),
+        )
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager = manager(&server, false, Duration::from_secs(60));
+    let (first, second) = tokio::join!(
+        manager.get_secret_from_google_secret_manager("key"),
+        manager.get_secret_from_google_secret_manager("key")
+    );
+    assert_eq!(first.unwrap().unwrap().as_str(), Some("value"));
+    assert_eq!(second.unwrap().unwrap().as_str(), Some("value"));
+}
+
+#[rstest]
+#[case::missing(404, serde_json::json!({}))]
+#[case::failure(403, serde_json::json!({}))]
+#[case::no_payload(200, serde_json::json!({"payload":{}}))]
+#[tokio::test]
+async fn python_reads_reuse_cached_absence_until_expiry(
+    #[case] status: u16,
+    #[case] body: serde_json::Value,
+    #[values(false, true)] always_read: bool,
+) {
+    let server = MockServer::start().await;
+    let manager = manager(&server, always_read, Duration::from_secs(60));
+    let failing = Mock::given(path(
+        "/v1/projects/project/secrets/key/versions/latest:access",
+    ))
+    .respond_with(ResponseTemplate::new(status).set_body_json(body))
+    .expect(1)
+    .mount_as_scoped(&server)
+    .await;
+    let result = manager.get_secret_for_python("key").await;
+    match status {
+        404 => assert!(matches!(result, Err(Error::Status(404)))),
+        403 => assert!(matches!(result, Err(Error::Status(403)))),
+        200 => assert!(matches!(result, Err(Error::MissingPayload))),
+        _ => unreachable!(),
+    }
+    drop(failing);
+    Mock::given(path(
+        "/v1/projects/project/secrets/key/versions/latest:access",
+    ))
+    .respond_with(
+        ResponseTemplate::new(200)
+            .set_body_json(serde_json::json!({"payload":{"data":STANDARD.encode("recovered")}})),
+    )
+    .expect(u64::from(always_read))
+    .mount(&server)
+    .await;
+    assert_eq!(
+        manager
+            .get_secret_for_python("key")
+            .await
+            .unwrap()
+            .as_ref()
+            .and_then(|value| value.as_str()),
+        always_read.then_some("recovered")
+    );
+}
+
+#[tokio::test]
+async fn python_cached_absence_expires_and_allows_recovery() {
+    let server = MockServer::start().await;
+    let manager = manager(&server, false, Duration::from_millis(20));
+    let missing = Mock::given(path(
+        "/v1/projects/project/secrets/key/versions/latest:access",
+    ))
+    .respond_with(ResponseTemplate::new(404))
+    .expect(1)
+    .mount_as_scoped(&server)
+    .await;
+    assert!(matches!(
+        manager.get_secret_for_python("key").await,
+        Err(Error::Status(404))
+    ));
+    drop(missing);
+    tokio::time::sleep(Duration::from_millis(40)).await;
+    Mock::given(path(
+        "/v1/projects/project/secrets/key/versions/latest:access",
+    ))
+    .respond_with(
+        ResponseTemplate::new(200)
+            .set_body_json(serde_json::json!({"payload":{"data":STANDARD.encode("recovered")}})),
+    )
+    .expect(1)
+    .mount(&server)
+    .await;
+    assert_eq!(
+        manager
+            .get_secret_for_python("key")
+            .await
+            .unwrap()
+            .unwrap()
+            .as_str(),
+        Some("recovered")
+    );
+}
diff --git a/litellm-rust/crates/secrets-hashicorp/AGENTS.md b/litellm-rust/crates/secrets-hashicorp/AGENTS.md
new file mode 100644
index 000000000000..ba1d5f6e330a
--- /dev/null
+++ b/litellm-rust/crates/secrets-hashicorp/AGENTS.md
@@ -0,0 +1 @@
+- https://developer.hashicorp.com/vault/api-docs/secret/kv/kv-v2
diff --git a/litellm-rust/crates/secrets-hashicorp/Cargo.toml b/litellm-rust/crates/secrets-hashicorp/Cargo.toml
index c646e02ef09d..c049ba127e5d 100644
--- a/litellm-rust/crates/secrets-hashicorp/Cargo.toml
+++ b/litellm-rust/crates/secrets-hashicorp/Cargo.toml
@@ -8,11 +8,10 @@ repository.workspace = true
 [dependencies]
 litellm-core-utils.workspace = true
 litellm-secrets-types.workspace = true
-moka.workspace = true
 rustify.workspace = true
 rustify_derive.workspace = true
 serde.workspace = true
-serde_json.workspace = true
+serde_json = { workspace = true, features = ["raw_value"] }
 thiserror.workspace = true
 tokio.workspace = true
 vaultrs.workspace = true
diff --git a/litellm-rust/crates/secrets-hashicorp/src/error.rs b/litellm-rust/crates/secrets-hashicorp/src/error.rs
index 664f9ab18dd7..1813cb486bc9 100644
--- a/litellm-rust/crates/secrets-hashicorp/src/error.rs
+++ b/litellm-rust/crates/secrets-hashicorp/src/error.rs
@@ -3,9 +3,9 @@ pub enum Error {
     #[error("HashiCorp Vault requires an enterprise license")]
     EnterpriseRequired,
     #[error("invalid secret name")]
-    InvalidSecretName(#[from] litellm_secrets_types::Error),
-    #[error("HashiCorp Vault received an incompatible operation context")]
-    InvalidOperationContext,
+    InvalidSecretName(litellm_secrets_types::Error),
+    #[error(transparent)]
+    Operation(#[from] litellm_secrets_types::Error),
     #[error("HashiCorp Vault client failed")]
     Client(
         #[from]
@@ -31,6 +31,10 @@ pub enum Error {
     MalformedPayload,
     #[error("HashiCorp Vault secret value is not a string")]
     NonStringValue,
+    #[error("HashiCorp Vault data key conflicts with description")]
+    DataKeyConflictsWithDescription,
+    #[error("HashiCorp Vault secret version exceeds CAS range")]
+    CasVersionOverflow,
     #[error("HashiCorp Vault operation timed out")]
     Timeout,
     #[error("invalid HashiCorp Vault refresh interval")]
diff --git a/litellm-rust/crates/secrets-hashicorp/src/lib.rs b/litellm-rust/crates/secrets-hashicorp/src/lib.rs
index 0c2b05647f8f..7aab5a38b011 100644
--- a/litellm-rust/crates/secrets-hashicorp/src/lib.rs
+++ b/litellm-rust/crates/secrets-hashicorp/src/lib.rs
@@ -7,4 +7,4 @@ pub mod secret_manager;
 
 pub use config::{AppRoleAuth, HashicorpVaultConfig, TlsCertAuth};
 pub use error::Error;
-pub use secret_manager::{HashicorpVault, SecretLocation};
+pub use secret_manager::{HashicorpVault, RawOperationError, SecretLocation};
diff --git a/litellm-rust/crates/secrets-hashicorp/src/secret_manager.rs b/litellm-rust/crates/secrets-hashicorp/src/secret_manager.rs
index a4d1efb4ff64..f0d4fe8c0b48 100644
--- a/litellm-rust/crates/secrets-hashicorp/src/secret_manager.rs
+++ b/litellm-rust/crates/secrets-hashicorp/src/secret_manager.rs
@@ -1,3 +1,8 @@
+mod client;
+mod raw;
+mod read;
+mod write;
+
 use std::{
     collections::HashMap,
     fmt,
@@ -8,15 +13,16 @@ use std::{
 
 use litellm_core_utils::settings::Lookup;
 use litellm_secrets_types::{
-    BaseSecretManager, HashicorpOperationContext, SecretOperationContext, SecretValue,
-    SecretWriteContext, async_rotate_secret, validate_secret_name,
+    BaseSecretManager, HashicorpOperationContext, RotationError, SecretCache, SecretDeleter,
+    SecretRotator, SecretValue, SecretWriteContext, SecretWriter, async_rotate_secret,
+    validate_secret_name,
 };
-use moka::future::Cache;
 use rustify::errors::ClientError as RustifyClientError;
 use serde_json::Value;
 use tokio::sync::Mutex;
 use vaultrs::{
     api,
+    api::kv2::requests::SetSecretRequestOptions,
     auth::approle,
     client::{Identity, VaultClient, VaultClientSettingsBuilder},
     error::ClientError,
@@ -25,6 +31,8 @@ use vaultrs::{
 
 use crate::{Error, HashicorpVaultConfig, TlsCertAuth, cert_login::CertLoginRequest};
 
+pub use raw::RawOperationError;
+
 const CACHE_CAPACITY: u64 = 200;
 
 #[derive(Clone)]
@@ -49,7 +57,7 @@ struct CacheKey {
 #[derive(Clone)]
 pub struct HashicorpVault {
     config: HashicorpVaultConfig,
-    cache: Cache<CacheKey, SecretValue>,
+    cache: SecretCache<CacheKey, SecretValue>,
     auth_client: Arc<Mutex<Option<CachedClient>>>,
 }
 
@@ -79,10 +87,7 @@ impl HashicorpVault {
         if !enterprise_enabled {
             return Err(Error::EnterpriseRequired);
         }
-        let cache: Cache<CacheKey, SecretValue> = Cache::builder()
-            .max_capacity(CACHE_CAPACITY)
-            .time_to_live(config.refresh_interval)
-            .build();
+        let cache = SecretCache::new(CACHE_CAPACITY, config.refresh_interval);
         Ok(Self {
             config,
             cache,
@@ -91,21 +96,21 @@ impl HashicorpVault {
     }
 
     pub fn secret_location(&self, secret_name: &str) -> Result<SecretLocation, Error> {
-        self.secret_location_with_context(secret_name, &SecretOperationContext::default())
+        self.secret_location_with_context(secret_name, &HashicorpOperationContext::default())
     }
 
     pub fn secret_location_with_context(
         &self,
         secret_name: &str,
-        context: &SecretOperationContext,
+        context: &HashicorpOperationContext,
     ) -> Result<SecretLocation, Error> {
         validate_secret_name(secret_name).map_err(Error::InvalidSecretName)?;
-        let operation: Option<&HashicorpOperationContext> = hashicorp_context(context)?;
         let path: String = [
-            operation
-                .and_then(|operation| operation.path_prefix.as_deref())
-                .and_then(path_component)
-                .or_else(|| self.config.path_prefix.clone()),
+            context
+                .path_prefix
+                .as_deref()
+                .or(self.config.path_prefix.as_deref())
+                .and_then(path_component),
             Some(secret_name.to_owned()),
         ]
         .into_iter()
@@ -113,11 +118,17 @@ impl HashicorpVault {
         .collect::<Vec<String>>()
         .join("/");
         Ok(SecretLocation {
-            namespace: self.config.secret_namespace().map(str::to_owned),
-            mount: operation
-                .and_then(|operation| operation.mount.as_deref())
+            namespace: context
+                .namespace
+                .as_deref()
+                .or(self.config.secret_namespace())
+                .and_then(path_component),
+            mount: context
+                .mount
+                .as_deref()
+                .or(Some(self.config.mount.as_str()))
                 .and_then(path_component)
-                .unwrap_or_else(|| self.config.mount.clone()),
+                .unwrap_or_else(|| "secret".to_owned()),
             path,
         })
     }
@@ -125,249 +136,6 @@ impl HashicorpVault {
     pub fn config(&self) -> &HashicorpVaultConfig {
         &self.config
     }
-
-    pub async fn async_read_secret(&self, secret_name: &str) -> Result<Option<SecretValue>, Error> {
-        self.async_read_secret_with_context(secret_name, &SecretOperationContext::default())
-            .await
-    }
-
-    pub async fn async_read_secret_with_context(
-        &self,
-        secret_name: &str,
-        context: &SecretOperationContext,
-    ) -> Result<Option<SecretValue>, Error> {
-        let location: SecretLocation = self.secret_location_with_context(secret_name, context)?;
-        let data_key: String = data_key(context)?;
-        let cache_key = CacheKey {
-            location: location.clone(),
-            data_key: data_key.clone(),
-        };
-        if let Some(value) = self.cache.get(&cache_key).await {
-            return Ok(Some(value));
-        }
-        let data: Option<HashMap<String, Value>> = with_timeout(context, async {
-            let client: Arc<VaultClient> = self.vault_client().await?;
-            match kv2::read(client.as_ref(), &location.mount, &location.path).await {
-                Ok(data) => Ok(Some(data)),
-                Err(error) if api_status(&error) == Some(404) => Ok(None),
-                Err(error) => Err(map_api_error(error, ErrorContext::Read)),
-            }
-        })
-        .await?;
-        let Some(data) = data else {
-            return Ok(None);
-        };
-        let Some(value) = data.get(&data_key) else {
-            return Ok(None);
-        };
-        let value: &str = value.as_str().ok_or(Error::NonStringValue)?;
-        let value: SecretValue = SecretValue::new(value);
-        self.cache.insert(cache_key, value.clone()).await;
-        Ok(Some(value))
-    }
-
-    pub async fn async_write_secret(
-        &self,
-        secret_name: &str,
-        value: SecretValue,
-        description: Option<&str>,
-    ) -> Result<Value, Error> {
-        self.async_write_secret_with_context(
-            secret_name,
-            &value,
-            &SecretWriteContext {
-                description: description.map(str::to_owned),
-                ..SecretWriteContext::default()
-            },
-        )
-        .await
-    }
-
-    pub async fn async_write_secret_with_context(
-        &self,
-        secret_name: &str,
-        value: &SecretValue,
-        context: &SecretWriteContext,
-    ) -> Result<Value, Error> {
-        let location: SecretLocation =
-            self.secret_location_with_context(secret_name, &context.operation)?;
-        let data_key: String = data_key(&context.operation)?;
-        let data: HashMap<String, Value> = match context.description.as_deref() {
-            Some(description) => [
-                (data_key, Value::String(value.expose().to_owned())),
-                (
-                    "description".to_owned(),
-                    Value::String(description.to_owned()),
-                ),
-            ]
-            .into_iter()
-            .collect(),
-            None => [(data_key, Value::String(value.expose().to_owned()))]
-                .into_iter()
-                .collect(),
-        };
-        let metadata = with_timeout(&context.operation, async {
-            let client: Arc<VaultClient> = self.vault_client().await?;
-            kv2::set(client.as_ref(), &location.mount, &location.path, &data)
-                .await
-                .map_err(|error| map_api_error(error, ErrorContext::Secret))
-        })
-        .await?;
-        self.cache.invalidate_all();
-        serde_json::to_value(metadata)
-            .map_err(|source| Error::Client(ClientError::JsonParseError { source }))
-    }
-
-    pub async fn async_delete_secret(&self, secret_name: &str) -> Result<(), Error> {
-        self.async_delete_secret_with_context(secret_name, &SecretOperationContext::default())
-            .await
-    }
-
-    pub async fn async_delete_secret_with_context(
-        &self,
-        secret_name: &str,
-        context: &SecretOperationContext,
-    ) -> Result<(), Error> {
-        let location: SecretLocation = self.secret_location_with_context(secret_name, context)?;
-        with_timeout(context, async {
-            let client: Arc<VaultClient> = self.vault_client().await?;
-            kv2::delete_latest(client.as_ref(), &location.mount, &location.path)
-                .await
-                .map_err(|error| map_api_error(error, ErrorContext::Secret))
-        })
-        .await?;
-        self.cache.invalidate_all();
-        Ok(())
-    }
-
-    pub async fn async_rotate_secret(
-        &self,
-        current_name: &str,
-        new_name: &str,
-        value: &SecretValue,
-    ) -> Result<Value, Error> {
-        self.async_rotate_secret_with_context(
-            current_name,
-            new_name,
-            value,
-            &SecretOperationContext::default(),
-        )
-        .await
-    }
-
-    pub async fn async_rotate_secret_with_context(
-        &self,
-        current_name: &str,
-        new_name: &str,
-        value: &SecretValue,
-        context: &SecretOperationContext,
-    ) -> Result<Value, Error> {
-        async_rotate_secret(self, current_name, new_name, value, context).await
-    }
-
-    async fn vault_client(&self) -> Result<Arc<VaultClient>, Error> {
-        let mut cached = self.auth_client.lock().await;
-        if let Some(entry) = cached.as_ref()
-            && entry
-                .expires_at
-                .is_none_or(|expires_at| expires_at > Instant::now())
-        {
-            return Ok(entry.client.clone());
-        }
-
-        let (client, expires_at): (VaultClient, Option<Instant>) =
-            match (self.config.approle.as_ref(), self.config.tls_cert.as_ref()) {
-                (Some(approle), _) => {
-                    let login_client: VaultClient =
-                        self.build_client(self.config.login_namespace(), "")?;
-                    let auth = approle::login(
-                        &login_client,
-                        &approle.mount_path,
-                        &approle.role_id,
-                        approle.secret_id.expose(),
-                    )
-                    .await
-                    .map_err(|error| map_api_error(error, ErrorContext::Login))?;
-                    (
-                        self.build_client(self.config.secret_namespace(), &auth.client_token)?,
-                        token_expiry(auth.lease_duration),
-                    )
-                }
-                (None, Some(tls)) => {
-                    let login_client: VaultClient =
-                        self.build_client(self.config.login_namespace(), "")?;
-                    let endpoint: CertLoginRequest = CertLoginRequest::new(tls.role.as_deref());
-                    let auth = api::auth(&login_client, endpoint)
-                        .await
-                        .map_err(|error| map_api_error(error, ErrorContext::Login))?;
-                    (
-                        self.build_client(self.config.secret_namespace(), &auth.client_token)?,
-                        token_expiry(auth.lease_duration),
-                    )
-                }
-                (None, None) => {
-                    let token: SecretValue =
-                        self.config.token.clone().ok_or(Error::NoAuthConfigured)?;
-                    (
-                        self.build_client(self.config.secret_namespace(), token.expose())?,
-                        None,
-                    )
-                }
-            };
-        let client: Arc<VaultClient> = Arc::new(client);
-        *cached = Some(CachedClient {
-            client: client.clone(),
-            expires_at,
-        });
-        Ok(client)
-    }
-
-    fn build_client(&self, namespace: Option<&str>, token: &str) -> Result<VaultClient, Error> {
-        let settings = VaultClientSettingsBuilder::default()
-            .address(&self.config.address)
-            .token(token.to_owned())
-            .namespace(namespace.map(str::to_owned))
-            .identity(identity_for(self.config.tls_cert.as_ref())?)
-            .ca_certs(Vec::new())
-            .verify(true)
-            .build()
-            .map_err(|message| Error::ClientSettings {
-                message: message.to_string(),
-            })?;
-        VaultClient::new(settings).map_err(Error::Client)
-    }
-}
-
-impl BaseSecretManager for HashicorpVault {
-    type Error = Error;
-    type WriteResponse = Value;
-    type DeleteResponse = ();
-
-    async fn async_read_secret(
-        &self,
-        name: &str,
-        context: &SecretOperationContext,
-    ) -> Result<Option<SecretValue>, Error> {
-        HashicorpVault::async_read_secret_with_context(self, name, context).await
-    }
-
-    async fn async_write_secret(
-        &self,
-        name: &str,
-        value: &SecretValue,
-        context: &SecretWriteContext,
-    ) -> Result<Value, Error> {
-        HashicorpVault::async_write_secret_with_context(self, name, value, context).await
-    }
-
-    async fn async_delete_secret(
-        &self,
-        name: &str,
-        _recovery_window_in_days: Option<u32>,
-        context: &SecretOperationContext,
-    ) -> Result<(), Error> {
-        HashicorpVault::async_delete_secret_with_context(self, name, context).await
-    }
 }
 
 #[derive(Clone, Copy)]
@@ -377,37 +145,26 @@ enum ErrorContext {
     Secret,
 }
 
-fn hashicorp_context(
-    context: &SecretOperationContext,
-) -> Result<Option<&HashicorpOperationContext>, Error> {
-    match context {
-        SecretOperationContext::Hashicorp(context) => Ok(Some(context)),
-        SecretOperationContext::Default => Ok(None),
-        SecretOperationContext::Aws(_) | SecretOperationContext::Cyberark(_) => {
-            Err(Error::InvalidOperationContext)
-        }
-    }
-}
-
 fn path_component(value: &str) -> Option<String> {
     let value: &str = value.trim().trim_matches('/');
     (!value.is_empty()).then(|| value.to_owned())
 }
 
-fn data_key(context: &SecretOperationContext) -> Result<String, Error> {
-    Ok(hashicorp_context(context)?
-        .and_then(|context| context.data_key.as_deref())
+fn data_key(context: &HashicorpOperationContext) -> String {
+    context
+        .data_key
+        .as_deref()
         .map(str::trim)
         .filter(|data_key| !data_key.is_empty())
         .map(str::to_owned)
-        .unwrap_or_else(|| "key".to_owned()))
+        .unwrap_or_else(|| "key".to_owned())
 }
 
 async fn with_timeout<T>(
-    context: &SecretOperationContext,
+    context: &HashicorpOperationContext,
     operation: impl Future<Output = Result<T, Error>>,
 ) -> Result<T, Error> {
-    match context.timeout() {
+    match context.timeout {
         Some(timeout) => tokio::time::timeout(timeout, operation)
             .await
             .map_err(|_| Error::Timeout)?,
@@ -415,26 +172,6 @@ async fn with_timeout<T>(
     }
 }
 
-fn identity_for(tls: Option<&TlsCertAuth>) -> Result<Option<Identity>, Error> {
-    tls.map(|tls| {
-        let cert: Vec<u8> = std::fs::read(&tls.cert_path).map_err(|source| Error::TlsIdentity {
-            path: tls.cert_path.clone(),
-            message: source.to_string(),
-        })?;
-        let key: Vec<u8> = std::fs::read(&tls.key_path).map_err(|source| Error::TlsIdentity {
-            path: tls.key_path.clone(),
-            message: source.to_string(),
-        })?;
-        Identity::from_pem(&[cert.as_slice(), key.as_slice()].concat()).map_err(|source| {
-            Error::TlsIdentity {
-                path: tls.cert_path.clone(),
-                message: source.to_string(),
-            }
-        })
-    })
-    .transpose()
-}
-
 fn map_api_error(error: ClientError, context: ErrorContext) -> Error {
     match error {
         ClientError::APIError { code, .. } => match context {
@@ -478,7 +215,3 @@ fn malformed_response(context: ErrorContext) -> Error {
         ErrorContext::Secret => Error::Client(ClientError::ResponseDataEmptyError),
     }
 }
-
-fn token_expiry(lease_duration: u64) -> Option<Instant> {
-    (lease_duration > 0).then(|| Instant::now() + Duration::from_secs(lease_duration))
-}
diff --git a/litellm-rust/crates/secrets-hashicorp/src/secret_manager/client.rs b/litellm-rust/crates/secrets-hashicorp/src/secret_manager/client.rs
new file mode 100644
index 000000000000..c1dc073dcf83
--- /dev/null
+++ b/litellm-rust/crates/secrets-hashicorp/src/secret_manager/client.rs
@@ -0,0 +1,115 @@
+use super::*;
+
+impl HashicorpVault {
+    pub(super) async fn client_for_location(
+        &self,
+        location: &SecretLocation,
+    ) -> Result<Arc<VaultClient>, Error> {
+        let client = self.vault_client().await?;
+        if client.settings.namespace == location.namespace {
+            return Ok(client);
+        }
+        self.build_client(location.namespace.as_deref(), &client.settings.token)
+            .map(Arc::new)
+    }
+
+    pub(super) async fn vault_client(&self) -> Result<Arc<VaultClient>, Error> {
+        let mut cached = self.auth_client.lock().await;
+        if let Some(entry) = cached.as_ref()
+            && entry
+                .expires_at
+                .is_none_or(|expires_at| expires_at > Instant::now())
+        {
+            return Ok(entry.client.clone());
+        }
+
+        let (client, expires_at): (VaultClient, Option<Instant>) =
+            match (self.config.approle.as_ref(), self.config.tls_cert.as_ref()) {
+                (Some(approle), _) => {
+                    let login_client: VaultClient =
+                        self.build_client(self.config.login_namespace(), "")?;
+                    let auth = approle::login(
+                        &login_client,
+                        &approle.mount_path,
+                        &approle.role_id,
+                        approle.secret_id.expose(),
+                    )
+                    .await
+                    .map_err(|error| map_api_error(error, ErrorContext::Login))?;
+                    (
+                        self.build_client(self.config.secret_namespace(), &auth.client_token)?,
+                        token_expiry(auth.lease_duration),
+                    )
+                }
+                (None, Some(tls)) => {
+                    let login_client: VaultClient =
+                        self.build_client(self.config.login_namespace(), "")?;
+                    let endpoint: CertLoginRequest = CertLoginRequest::new(tls.role.as_deref());
+                    let auth = api::auth(&login_client, endpoint)
+                        .await
+                        .map_err(|error| map_api_error(error, ErrorContext::Login))?;
+                    (
+                        self.build_client(self.config.secret_namespace(), &auth.client_token)?,
+                        token_expiry(auth.lease_duration),
+                    )
+                }
+                (None, None) => {
+                    let token: SecretValue =
+                        self.config.token.clone().ok_or(Error::NoAuthConfigured)?;
+                    (
+                        self.build_client(self.config.secret_namespace(), token.expose())?,
+                        None,
+                    )
+                }
+            };
+        let client: Arc<VaultClient> = Arc::new(client);
+        *cached = Some(CachedClient {
+            client: client.clone(),
+            expires_at,
+        });
+        Ok(client)
+    }
+
+    pub(super) fn build_client(
+        &self,
+        namespace: Option<&str>,
+        token: &str,
+    ) -> Result<VaultClient, Error> {
+        let settings = VaultClientSettingsBuilder::default()
+            .address(&self.config.address)
+            .token(token.to_owned())
+            .namespace(namespace.map(str::to_owned))
+            .identity(identity_for(self.config.tls_cert.as_ref())?)
+            .ca_certs(Vec::new())
+            .verify(true)
+            .build()
+            .map_err(|message| Error::ClientSettings {
+                message: message.to_string(),
+            })?;
+        VaultClient::new(settings).map_err(Error::Client)
+    }
+}
+
+fn identity_for(tls: Option<&TlsCertAuth>) -> Result<Option<Identity>, Error> {
+    tls.map(|tls| {
+        let cert: Vec<u8> = std::fs::read(&tls.cert_path).map_err(|source| Error::TlsIdentity {
+            path: tls.cert_path.clone(),
+            message: source.to_string(),
+        })?;
+        let key: Vec<u8> = std::fs::read(&tls.key_path).map_err(|source| Error::TlsIdentity {
+            path: tls.key_path.clone(),
+            message: source.to_string(),
+        })?;
+        Identity::from_pem(&[cert.as_slice(), key.as_slice()].concat()).map_err(|source| {
+            Error::TlsIdentity {
+                path: tls.cert_path.clone(),
+                message: source.to_string(),
+            }
+        })
+    })
+    .transpose()
+}
+
+fn token_expiry(lease_duration: u64) -> Option<Instant> {
+    (lease_duration > 0).then(|| Instant::now() + Duration::from_secs(lease_duration))
+}
diff --git a/litellm-rust/crates/secrets-hashicorp/src/secret_manager/raw.rs b/litellm-rust/crates/secrets-hashicorp/src/secret_manager/raw.rs
new file mode 100644
index 000000000000..0325561a7a01
--- /dev/null
+++ b/litellm-rust/crates/secrets-hashicorp/src/secret_manager/raw.rs
@@ -0,0 +1,155 @@
+use super::*;
+use rustify::{client::Client as _, endpoint::Endpoint};
+use vaultrs::api::kv2::requests::{
+    DeleteLatestSecretVersionRequest, ReadSecretRequest, SetSecretRequest,
+};
+
+#[derive(veil::Redact)]
+pub enum RawOperationError {
+    Local(Error),
+    Authentication {
+        source: Error,
+        url: String,
+        certificate: bool,
+    },
+    Http {
+        method: String,
+        url: String,
+        status: u16,
+        #[redact]
+        body: Vec<u8>,
+    },
+    Transport(#[redact] RustifyClientError),
+    Timeout {
+        method: String,
+        elapsed: Duration,
+    },
+}
+
+impl HashicorpVault {
+    pub async fn write_raw(
+        &self,
+        name: &str,
+        value: &SecretValue,
+        context: &SecretWriteContext<HashicorpOperationContext>,
+    ) -> Result<Vec<u8>, RawOperationError> {
+        let location = self
+            .secret_location_with_context(name, &context.operation)
+            .map_err(RawOperationError::Local)?;
+        let data = super::write::write_data(value, context).map_err(RawOperationError::Local)?;
+        let response = self
+            .raw_request(
+                &location,
+                SetSecretRequest {
+                    mount: location.mount.clone(),
+                    path: location.path.clone(),
+                    data,
+                    options: None,
+                },
+                &context.operation,
+            )
+            .await?;
+        self.cache
+            .invalidate_where(move |key| key.location == location);
+        Ok(response)
+    }
+
+    pub async fn delete_raw(
+        &self,
+        name: &str,
+        context: &HashicorpOperationContext,
+    ) -> Result<(), RawOperationError> {
+        let location = self
+            .secret_location_with_context(name, context)
+            .map_err(RawOperationError::Local)?;
+        self.raw_request(
+            &location,
+            DeleteLatestSecretVersionRequest {
+                mount: location.mount.clone(),
+                path: location.path.clone(),
+            },
+            context,
+        )
+        .await?;
+        self.cache
+            .invalidate_where(move |key| key.location == location);
+        Ok(())
+    }
+
+    pub async fn read_raw(
+        &self,
+        name: &str,
+        context: &HashicorpOperationContext,
+    ) -> Result<Vec<u8>, RawOperationError> {
+        let location = self
+            .secret_location_with_context(name, context)
+            .map_err(RawOperationError::Local)?;
+        self.raw_request(
+            &location,
+            ReadSecretRequest {
+                mount: location.mount.clone(),
+                path: location.path.clone(),
+                version: None,
+            },
+            context,
+        )
+        .await
+    }
+
+    async fn raw_request(
+        &self,
+        location: &SecretLocation,
+        endpoint: impl Endpoint,
+        context: &HashicorpOperationContext,
+    ) -> Result<Vec<u8>, RawOperationError> {
+        let client = self.client_for_location(location).await.map_err(|source| {
+            let certificate = self.config.approle.is_none();
+            let mount = self
+                .config
+                .approle
+                .as_ref()
+                .map_or("cert", |auth| auth.mount_path.as_str());
+            RawOperationError::Authentication {
+                source,
+                certificate,
+                url: format!("{}/v1/auth/{mount}/login", self.config.address),
+            }
+        })?;
+        let request = endpoint
+            .with_middleware(&client.middle)
+            .request(client.http.base())
+            .map_err(RawOperationError::Transport)?;
+        let method = request.method().to_string();
+        let url = format!(
+            "{}/v1/{}{}/data/{}",
+            self.config.address,
+            location
+                .namespace
+                .as_ref()
+                .map(|ns| format!("{ns}/"))
+                .unwrap_or_default(),
+            location.mount,
+            location.path
+        );
+        let started = Instant::now();
+        let response = match context.timeout {
+            Some(timeout) => tokio::time::timeout(timeout, client.http.send(request))
+                .await
+                .map_err(|_| RawOperationError::Timeout {
+                    method: method.clone(),
+                    elapsed: started.elapsed(),
+                })?,
+            None => client.http.send(request).await,
+        }
+        .map_err(RawOperationError::Transport)?;
+        if !response.status().is_success() {
+            return Err(RawOperationError::Http {
+                method,
+                url,
+                status: response.status().as_u16(),
+                body: response.into_body(),
+            });
+        }
+        Ok(response.into_body())
+    }
+}
diff --git a/litellm-rust/crates/secrets-hashicorp/src/secret_manager/read.rs b/litellm-rust/crates/secrets-hashicorp/src/secret_manager/read.rs
new file mode 100644
index 000000000000..f88fa46b868f
--- /dev/null
+++ b/litellm-rust/crates/secrets-hashicorp/src/secret_manager/read.rs
@@ -0,0 +1,63 @@
+use super::*;
+
+impl HashicorpVault {
+    pub async fn async_read_secret(&self, secret_name: &str) -> Result<Option<SecretValue>, Error> {
+        self.async_read_secret_with_context(secret_name, &HashicorpOperationContext::default())
+            .await
+    }
+
+    pub async fn async_read_secret_with_context(
+        &self,
+        secret_name: &str,
+        context: &HashicorpOperationContext,
+    ) -> Result<Option<SecretValue>, Error> {
+        let location: SecretLocation = self.secret_location_with_context(secret_name, context)?;
+        let data_key: String = data_key(context);
+        let cache_key = CacheKey {
+            location: location.clone(),
+            data_key: data_key.clone(),
+        };
+        with_timeout(
+            context,
+            self.cache
+                .read(cache_key, self.read_uncached(&location, &data_key)),
+        )
+        .await
+    }
+
+    pub(super) async fn read_uncached(
+        &self,
+        location: &SecretLocation,
+        data_key: &str,
+    ) -> Result<Option<SecretValue>, Error> {
+        let client = self.client_for_location(location).await?;
+        let data: Option<HashMap<String, Value>> =
+            match kv2::read(client.as_ref(), &location.mount, &location.path).await {
+                Ok(data) => Some(data),
+                Err(error) if api_status(&error) == Some(404) => None,
+                Err(error) => return Err(map_api_error(error, ErrorContext::Read)),
+            };
+        let Some(data) = data else {
+            return Ok(None);
+        };
+        let Some(value) = data.get(data_key) else {
+            return Ok(None);
+        };
+        let value: &str = value.as_str().ok_or(Error::NonStringValue)?;
+        let value: SecretValue = SecretValue::new(value);
+        Ok(Some(value))
+    }
+}
+
+impl BaseSecretManager for HashicorpVault {
+    type Error = Error;
+    type Context = HashicorpOperationContext;
+
+    async fn async_read_secret(
+        &self,
+        name: &str,
+        context: &Self::Context,
+    ) -> Result<Option<SecretValue>, Error> {
+        HashicorpVault::async_read_secret_with_context(self, name, context).await
+    }
+}
diff --git a/litellm-rust/crates/secrets-hashicorp/src/secret_manager/write.rs b/litellm-rust/crates/secrets-hashicorp/src/secret_manager/write.rs
new file mode 100644
index 000000000000..0b1acb3a179d
--- /dev/null
+++ b/litellm-rust/crates/secrets-hashicorp/src/secret_manager/write.rs
@@ -0,0 +1,190 @@
+use super::*;
+
+impl HashicorpVault {
+    pub async fn async_write_secret(
+        &self,
+        secret_name: &str,
+        value: SecretValue,
+        description: Option<&str>,
+    ) -> Result<Value, Error> {
+        self.async_write_secret_with_context(
+            secret_name,
+            &value,
+            &SecretWriteContext {
+                description: description.map(str::to_owned),
+                ..SecretWriteContext::default()
+            },
+        )
+        .await
+    }
+
+    pub async fn async_write_secret_with_context(
+        &self,
+        secret_name: &str,
+        value: &SecretValue,
+        context: &SecretWriteContext<HashicorpOperationContext>,
+    ) -> Result<Value, Error> {
+        let location: SecretLocation =
+            self.secret_location_with_context(secret_name, &context.operation)?;
+        let data = write_data(value, context)?;
+        let metadata = with_timeout(&context.operation, async {
+            let client = self.client_for_location(&location).await?;
+            match kv2::set(client.as_ref(), &location.mount, &location.path, &data).await {
+                Ok(metadata) => Ok(metadata),
+                Err(error) if api_status(&error) == Some(400) => {
+                    let version =
+                        match kv2::read_metadata(client.as_ref(), &location.mount, &location.path)
+                            .await
+                        {
+                            Ok(metadata) => u32::try_from(metadata.current_version)
+                                .map_err(|_| Error::CasVersionOverflow)?,
+                            Err(error) if api_status(&error) == Some(404) => 0,
+                            Err(_) => return Err(map_api_error(error, ErrorContext::Secret)),
+                        };
+                    kv2::set_with_options(
+                        client.as_ref(),
+                        &location.mount,
+                        &location.path,
+                        &data,
+                        SetSecretRequestOptions { cas: version },
+                    )
+                    .await
+                    .map_err(|error| map_api_error(error, ErrorContext::Secret))
+                }
+                Err(error) => Err(map_api_error(error, ErrorContext::Secret)),
+            }
+        })
+        .await?;
+        self.cache
+            .invalidate_where(move |key| key.location == location);
+        serde_json::to_value(metadata)
+            .map_err(|source| Error::Client(ClientError::JsonParseError { source }))
+    }
+
+    pub async fn async_delete_secret(&self, secret_name: &str) -> Result<(), Error> {
+        self.async_delete_secret_with_context(secret_name, &HashicorpOperationContext::default())
+            .await
+    }
+
+    pub async fn async_delete_secret_with_context(
+        &self,
+        secret_name: &str,
+        context: &HashicorpOperationContext,
+    ) -> Result<(), Error> {
+        let location: SecretLocation = self.secret_location_with_context(secret_name, context)?;
+        with_timeout(context, async {
+            let client = self.client_for_location(&location).await?;
+            kv2::delete_latest(client.as_ref(), &location.mount, &location.path)
+                .await
+                .map_err(|error| map_api_error(error, ErrorContext::Secret))
+        })
+        .await?;
+        self.cache
+            .invalidate_where(move |key| key.location == location);
+        Ok(())
+    }
+
+    pub async fn async_rotate_secret(
+        &self,
+        current_name: &str,
+        new_name: &str,
+        value: &SecretValue,
+    ) -> Result<Value, RotationError<Value, Error>> {
+        self.async_rotate_secret_with_context(
+            current_name,
+            new_name,
+            value,
+            &HashicorpOperationContext::default(),
+        )
+        .await
+    }
+
+    pub async fn async_rotate_secret_with_context(
+        &self,
+        current_name: &str,
+        new_name: &str,
+        value: &SecretValue,
+        context: &HashicorpOperationContext,
+    ) -> Result<Value, RotationError<Value, Error>> {
+        async_rotate_secret(self, current_name, new_name, value, context).await
+    }
+}
+
+impl SecretWriter for HashicorpVault {
+    type WriteResponse = Value;
+
+    async fn async_write_secret(
+        &self,
+        name: &str,
+        value: &SecretValue,
+        context: &SecretWriteContext<Self::Context>,
+    ) -> Result<Value, Error> {
+        HashicorpVault::async_write_secret_with_context(self, name, value, context).await
+    }
+}
+
+impl SecretDeleter for HashicorpVault {
+    type DeleteResponse = ();
+
+    async fn async_delete_secret(&self, name: &str, context: &Self::Context) -> Result<(), Error> {
+        HashicorpVault::async_delete_secret_with_context(self, name, context).await
+    }
+}
+
+impl SecretRotator for HashicorpVault {
+    type RotationResponse = Value;
+
+    async fn async_read_secret_fresh(
+        &self,
+        name: &str,
+        context: &Self::Context,
+    ) -> Result<Option<SecretValue>, Error> {
+        let location = self.secret_location_with_context(name, context)?;
+        let data_key = data_key(context);
+        let key = CacheKey {
+            location: location.clone(),
+            data_key: data_key.clone(),
+        };
+        with_timeout(
+            context,
+            self.cache
+                .refresh(key, self.read_uncached(&location, &data_key)),
+        )
+        .await
+    }
+
+    async fn async_write_replacement(
+        &self,
+        current_name: &str,
+        new_name: &str,
+        value: &SecretValue,
+        context: &Self::Context,
+    ) -> Result<Value, Error> {
+        SecretWriter::async_write_secret(
+            self,
+            new_name,
+            value,
+            &SecretWriteContext::rotated_from(current_name, context.clone()),
+        )
+        .await
+    }
+}
+
+pub(super) fn write_data(
+    value: &SecretValue,
+    context: &SecretWriteContext<HashicorpOperationContext>,
+) -> Result<Value, Error> {
+    let data_key = data_key(&context.operation);
+    if context.description.is_some() && data_key == "description" {
+        return Err(Error::DataKeyConflictsWithDescription);
+    }
+    let data = std::iter::once((data_key, Value::String(value.expose().to_owned())))
+        .chain(
+            context
+                .description
+                .as_ref()
+                .map(|description| ("description".to_owned(), Value::String(description.clone()))),
+        )
+        .collect();
+    Ok(Value::Object(data))
+}
diff --git a/litellm-rust/crates/secrets-hashicorp/tests/secret_manager.rs b/litellm-rust/crates/secrets-hashicorp/tests/secret_manager.rs
index 6b322de4d8dd..668871d3fc7a 100644
--- a/litellm-rust/crates/secrets-hashicorp/tests/secret_manager.rs
+++ b/litellm-rust/crates/secrets-hashicorp/tests/secret_manager.rs
@@ -3,8 +3,8 @@ use std::{collections::HashMap, sync::Arc, time::Duration};
 use litellm_core_utils::settings::Lookup;
 use litellm_secrets_hashicorp::{Error, HashicorpVault, HashicorpVaultConfig};
 use litellm_secrets_types::{
-    AwsOperationContext, BaseSecretManager, CyberarkOperationContext, HashicorpOperationContext,
-    SecretOperationContext, SecretValue, SecretWriteContext,
+    BaseSecretManager, HashicorpOperationContext, RotationError, SecretDeleter, SecretValue,
+    SecretWriteContext, SecretWriter,
 };
 use rstest::{fixture, rstest};
 use serde::Deserialize;
@@ -14,923 +14,13 @@ use wiremock::{
     matchers::{body_json, header, method, path},
 };
 
-fn config(server: &MockServer, values: &[(&str, &str)]) -> HashicorpVaultConfig {
-    let mut environment_values: HashMap<String, String> = values
-        .iter()
-        .map(|(name, value)| ((*name).to_owned(), (*value).to_owned()))
-        .collect();
-    environment_values.insert("HCP_VAULT_ADDR".to_owned(), server.uri());
-    let environment: Arc<dyn Lookup + Send + Sync> =
-        Arc::new(move |name: &str| environment_values.get(name).cloned());
-    HashicorpVaultConfig::from_environment(environment.as_ref()).unwrap()
-}
+#[path = "secret_manager/support.rs"]
+mod support;
+use support::*;
 
-fn manager(server: &MockServer, values: &[(&str, &str)]) -> HashicorpVault {
-    HashicorpVault::from_config(config(server, values), true).unwrap()
-}
-
-fn auth_response(token: &str, lease_duration: u64) -> serde_json::Value {
-    json!({
-        "auth": {
-            "client_token": token,
-            "accessor": "",
-            "policies": [],
-            "token_policies": [],
-            "metadata": null,
-            "lease_duration": lease_duration,
-            "renewable": false,
-            "entity_id": "",
-            "token_type": "service",
-            "orphan": false
-        },
-        "lease_id": "",
-        "lease_duration": lease_duration,
-        "renewable": false,
-        "request_id": "",
-        "warnings": null,
-        "wrap_info": null
-    })
-}
-
-fn read_response(data: serde_json::Value) -> serde_json::Value {
-    json!({
-        "data": {
-            "data": data,
-            "metadata": {
-                "created_time": "",
-                "deletion_time": "",
-                "custom_metadata": null,
-                "destroyed": false,
-                "version": 1
-            }
-        },
-        "lease_id": "",
-        "lease_duration": 0,
-        "renewable": false,
-        "request_id": "",
-        "warnings": null,
-        "wrap_info": null
-    })
-}
-
-#[fixture]
-fn token_values() -> Vec<(&'static str, &'static str)> {
-    vec![("HCP_VAULT_TOKEN", "token")]
-}
-
-#[rstest]
-#[tokio::test]
-async fn token_reads_use_vault_headers_and_cache_values(token_values: Vec<(&str, &str)>) {
-    let server: MockServer = MockServer::start().await;
-    Mock::given(method("GET"))
-        .and(path("/v1/secret/data/name"))
-        .and(header("X-Vault-Token", "token"))
-        .respond_with(
-            ResponseTemplate::new(200).set_body_json(read_response(json!({"key": "value"}))),
-        )
-        .expect(1)
-        .mount(&server)
-        .await;
-    let manager: HashicorpVault = manager(&server, &token_values);
-
-    assert_eq!(
-        manager
-            .async_read_secret("name")
-            .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "value"
-    );
-    let requests = server.received_requests().await.unwrap();
-    assert!(
-        requests
-            .iter()
-            .all(|request| !request.headers.contains_key("X-Vault-Namespace"))
-    );
-    assert_eq!(
-        manager
-            .async_read_secret("name")
-            .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "value"
-    );
-}
-
-#[rstest]
-#[tokio::test]
-async fn namespace_mount_and_prefix_are_sanitized_in_the_url() {
-    let server: MockServer = MockServer::start().await;
-    Mock::given(method("GET"))
-        .and(path("/v1/kv-prod/data/virtual-keys/name"))
-        .and(header("X-Vault-Namespace", "team-a"))
-        .respond_with(
-            ResponseTemplate::new(200).set_body_json(read_response(json!({"key": "value"}))),
-        )
-        .expect(1)
-        .mount(&server)
-        .await;
-    let manager: HashicorpVault = manager(
-        &server,
-        &[
-            ("HCP_VAULT_TOKEN", "token"),
-            ("HCP_VAULT_SECRET_NAMESPACE", " /team-a/ "),
-            ("HCP_VAULT_MOUNT_NAME", " /kv-prod/ "),
-            ("HCP_VAULT_PATH_PREFIX", " /virtual-keys/ "),
-        ],
-    );
-
-    let location = manager.secret_location("name").unwrap();
-    assert_eq!(location.namespace.as_deref(), Some("team-a"));
-    assert_eq!(location.mount, "kv-prod");
-    assert_eq!(location.path, "virtual-keys/name");
-    assert!(manager.async_read_secret("name").await.unwrap().is_some());
-}
-
-#[rstest]
-fn trailing_address_slashes_are_removed() {
-    let environment: Arc<dyn Lookup + Send + Sync> = Arc::new(|name: &str| match name {
-        "HCP_VAULT_ADDR" => Some("http://vault.test:8200///".to_owned()),
-        "HCP_VAULT_TOKEN" => Some("token".to_owned()),
-        _ => None,
-    });
-    let config: HashicorpVaultConfig =
-        HashicorpVaultConfig::from_environment(environment.as_ref()).unwrap();
-    let manager: HashicorpVault = HashicorpVault::from_config(config, true).unwrap();
-
-    assert_eq!(
-        manager.secret_location("name").unwrap(),
-        litellm_secrets_hashicorp::SecretLocation {
-            namespace: None,
-            mount: "secret".to_owned(),
-            path: "name".to_owned(),
-        }
-    );
-}
-
-#[rstest]
-#[case::negative("-1")]
-#[case::not_a_number("not-a-number")]
-fn invalid_refresh_intervals_are_rejected(#[case] value: &str) {
-    let environment: Arc<dyn Lookup + Send + Sync> = Arc::new(move |name: &str| match name {
-        "HCP_VAULT_REFRESH_INTERVAL" => Some(value.to_owned()),
-        _ => None,
-    });
-
-    assert!(matches!(
-        HashicorpVaultConfig::from_environment(environment.as_ref()),
-        Err(Error::RefreshInterval)
-    ));
-}
-
-#[rstest]
-#[tokio::test]
-async fn approle_login_uses_namespace_and_reuses_the_token() {
-    let server: MockServer = MockServer::start().await;
-    Mock::given(method("POST"))
-        .and(path("/v1/auth/custom-approle/login"))
-        .and(header("X-Vault-Namespace", "login-root"))
-        .and(body_json(json!({"role_id": "role", "secret_id": "secret"})))
-        .respond_with(ResponseTemplate::new(200).set_body_json(auth_response("login-token", 3600)))
-        .expect(1)
-        .mount(&server)
-        .await;
-    Mock::given(method("GET"))
-        .and(path("/v1/secret/data/name"))
-        .and(header("X-Vault-Token", "login-token"))
-        .and(header("X-Vault-Namespace", "secret-root"))
-        .respond_with(
-            ResponseTemplate::new(200).set_body_json(read_response(json!({"key": "value"}))),
-        )
-        .expect(1)
-        .mount(&server)
-        .await;
-    Mock::given(method("GET"))
-        .and(path("/v1/secret/data/name-2"))
-        .respond_with(ResponseTemplate::new(404).set_body_json(json!({"errors": ["missing"]})))
-        .expect(1)
-        .mount(&server)
-        .await;
-    let manager: HashicorpVault = manager(
-        &server,
-        &[
-            ("HCP_VAULT_APPROLE_ROLE_ID", "role"),
-            ("HCP_VAULT_APPROLE_SECRET_ID", "secret"),
-            ("HCP_VAULT_APPROLE_MOUNT_PATH", "custom-approle"),
-            ("HCP_VAULT_NAMESPACE", "secret-root"),
-            ("HCP_VAULT_LOGIN_NAMESPACE", "login-root"),
-        ],
-    );
-
-    assert!(manager.async_read_secret("name").await.unwrap().is_some());
-    assert!(manager.async_read_secret("name-2").await.unwrap().is_none());
-}
-
-#[rstest]
-#[tokio::test]
-async fn approle_tokens_expire_after_the_vault_lease() {
-    let server: MockServer = MockServer::start().await;
-    Mock::given(method("POST"))
-        .and(path("/v1/auth/approle/login"))
-        .respond_with(ResponseTemplate::new(200).set_body_json(auth_response("login-token", 1)))
-        .expect(2)
-        .mount(&server)
-        .await;
-    Mock::given(method("GET"))
-        .respond_with(
-            ResponseTemplate::new(200).set_body_json(read_response(json!({"key": "value"}))),
-        )
-        .expect(2)
-        .mount(&server)
-        .await;
-    let manager: HashicorpVault = manager(
-        &server,
-        &[
-            ("HCP_VAULT_APPROLE_ROLE_ID", "role"),
-            ("HCP_VAULT_APPROLE_SECRET_ID", "secret"),
-            ("HCP_VAULT_REFRESH_INTERVAL", "0"),
-        ],
-    );
-
-    assert!(manager.async_read_secret("first").await.unwrap().is_some());
-    tokio::time::sleep(Duration::from_secs(1) + Duration::from_millis(50)).await;
-    assert!(manager.async_read_secret("second").await.unwrap().is_some());
-}
-
-#[rstest]
-#[tokio::test]
-async fn tls_login_posts_the_role_and_uses_the_client_identity() {
-    let server: MockServer = MockServer::start().await;
-    let directory: tempfile::TempDir = tempfile::tempdir().unwrap();
-    let cert_path = directory.path().join("client.crt");
-    let key_path = directory.path().join("client.key");
-    std::fs::write(&cert_path, TEST_CERTIFICATE).unwrap();
-    std::fs::write(&key_path, TEST_PRIVATE_KEY).unwrap();
-    Mock::given(method("POST"))
-        .and(path("/v1/auth/cert/login"))
-        .and(header("X-Vault-Namespace", "login-ns"))
-        .respond_with(ResponseTemplate::new(200).set_body_json(auth_response("cert-token", 0)))
-        .expect(2)
-        .mount(&server)
-        .await;
-    Mock::given(method("GET"))
-        .and(path("/v1/secret/data/name"))
-        .and(header("X-Vault-Token", "cert-token"))
-        .and(header("X-Vault-Namespace", "secret-ns"))
-        .respond_with(
-            ResponseTemplate::new(200).set_body_json(read_response(json!({"key": "value"}))),
-        )
-        .expect(2)
-        .mount(&server)
-        .await;
-    let role_values: HashMap<String, String> = HashMap::from([
-        ("HCP_VAULT_ADDR".to_owned(), server.uri()),
-        (
-            "HCP_VAULT_CLIENT_CERT".to_owned(),
-            cert_path.to_str().unwrap().to_owned(),
-        ),
-        (
-            "HCP_VAULT_CLIENT_KEY".to_owned(),
-            key_path.to_str().unwrap().to_owned(),
-        ),
-        ("HCP_VAULT_CERT_ROLE".to_owned(), "vault-role".to_owned()),
-        (
-            "HCP_VAULT_LOGIN_NAMESPACE".to_owned(),
-            "login-ns".to_owned(),
-        ),
-        (
-            "HCP_VAULT_SECRET_NAMESPACE".to_owned(),
-            "secret-ns".to_owned(),
-        ),
-    ]);
-    let role_environment: Arc<dyn Lookup + Send + Sync> =
-        Arc::new(move |name: &str| role_values.get(name).cloned());
-    let role_manager: HashicorpVault = HashicorpVault::new(role_environment, true).unwrap();
-    assert!(
-        role_manager
-            .async_read_secret("name")
-            .await
-            .unwrap()
-            .is_some()
-    );
-
-    let no_role_values: HashMap<String, String> = HashMap::from([
-        ("HCP_VAULT_ADDR".to_owned(), server.uri()),
-        (
-            "HCP_VAULT_CLIENT_CERT".to_owned(),
-            cert_path.to_str().unwrap().to_owned(),
-        ),
-        (
-            "HCP_VAULT_CLIENT_KEY".to_owned(),
-            key_path.to_str().unwrap().to_owned(),
-        ),
-        (
-            "HCP_VAULT_LOGIN_NAMESPACE".to_owned(),
-            "login-ns".to_owned(),
-        ),
-        (
-            "HCP_VAULT_SECRET_NAMESPACE".to_owned(),
-            "secret-ns".to_owned(),
-        ),
-    ]);
-    let no_role_environment: Arc<dyn Lookup + Send + Sync> =
-        Arc::new(move |name: &str| no_role_values.get(name).cloned());
-    let no_role_manager: HashicorpVault = HashicorpVault::new(no_role_environment, true).unwrap();
-    assert!(
-        no_role_manager
-            .async_read_secret("name")
-            .await
-            .unwrap()
-            .is_some()
-    );
-    let login_bodies: Vec<serde_json::Value> = server
-        .received_requests()
-        .await
-        .unwrap()
-        .iter()
-        .filter(|request| request.method.as_str() == "POST")
-        .map(|request| serde_json::from_slice(&request.body).unwrap())
-        .collect();
-    assert!(login_bodies.contains(&json!({"name": "vault-role"})));
-    assert!(login_bodies.contains(&json!({})));
-}
-
-#[derive(Clone, Copy)]
-enum ExpectedRead {
-    Missing,
-    Malformed,
-    NonString,
-}
-
-#[rstest]
-#[case::missing(404, json!({"errors": ["missing"]}), ExpectedRead::Missing)]
-#[case::malformed(200, json!({"data": "invalid"}), ExpectedRead::Malformed)]
-#[case::missing_key(200, json!({}), ExpectedRead::Missing)]
-#[case::non_string(200, json!({"key": 1}), ExpectedRead::NonString)]
-#[tokio::test]
-async fn read_responses_distinguish_absence_and_malformed_payloads(
-    token_values: Vec<(&str, &str)>,
-    #[case] status: u16,
-    #[case] body: serde_json::Value,
-    #[case] expected: ExpectedRead,
-) {
-    let server: MockServer = MockServer::start().await;
-    Mock::given(method("GET"))
-        .respond_with(ResponseTemplate::new(status).set_body_json(
-            if status == 200 && !matches!(expected, ExpectedRead::Malformed) {
-                read_response(body)
-            } else {
-                body
-            },
-        ))
-        .expect(1)
-        .mount(&server)
-        .await;
-    let result: Result<Option<SecretValue>, Error> = manager(&server, &token_values)
-        .async_read_secret("name")
-        .await;
-    match expected {
-        ExpectedRead::Missing => assert!(result.unwrap().is_none()),
-        ExpectedRead::Malformed => assert!(matches!(result, Err(Error::MalformedPayload))),
-        ExpectedRead::NonString => assert!(matches!(result, Err(Error::NonStringValue))),
-    }
-}
-
-#[rstest]
-#[tokio::test]
-async fn write_and_delete_invalidate_the_read_cache(token_values: Vec<(&str, &str)>) {
-    let server: MockServer = MockServer::start().await;
-    Mock::given(method("GET"))
-        .and(path("/v1/secret/data/name"))
-        .respond_with(
-            ResponseTemplate::new(200).set_body_json(read_response(json!({"key": "value"}))),
-        )
-        .expect(2)
-        .mount(&server)
-        .await;
-    Mock::given(method("POST"))
-        .and(path("/v1/secret/data/name"))
-        .and(body_json(
-            json!({"data": {"key": "updated", "description": "description"}}),
-        ))
-        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
-            "data": {
-                "created_time": "",
-                "deletion_time": "",
-                "custom_metadata": null,
-                "destroyed": false,
-                "version": 2
-            },
-            "lease_id": "",
-            "lease_duration": 0,
-            "renewable": false,
-            "request_id": "",
-            "warnings": null,
-            "wrap_info": null
-        })))
-        .expect(1)
-        .mount(&server)
-        .await;
-    Mock::given(method("DELETE"))
-        .and(path("/v1/secret/data/name"))
-        .respond_with(ResponseTemplate::new(204))
-        .expect(1)
-        .mount(&server)
-        .await;
-    let manager: HashicorpVault = manager(&server, &token_values);
-
-    assert!(manager.async_read_secret("name").await.unwrap().is_some());
-    assert!(
-        manager
-            .async_write_secret("name", SecretValue::new("updated"), Some("description"))
-            .await
-            .is_ok()
-    );
-    assert!(manager.async_read_secret("name").await.unwrap().is_some());
-    manager.async_delete_secret("name").await.unwrap();
-}
-
-#[rstest]
-#[tokio::test]
-async fn base_manager_context_overrides_vault_location_and_data_key(
-    token_values: Vec<(&str, &str)>,
-) {
-    let server: MockServer = MockServer::start().await;
-    Mock::given(method("GET"))
-        .and(path("/v1/alternate/data/managed/name"))
-        .respond_with(
-            ResponseTemplate::new(200).set_body_json(read_response(json!({"api_token": "value"}))),
-        )
-        .expect(2)
-        .mount(&server)
-        .await;
-    Mock::given(method("POST"))
-        .and(path("/v1/alternate/data/managed/name"))
-        .and(body_json(json!({
-            "data": {"api_token": "updated", "description": "Managed key"}
-        })))
-        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
-            "data": {
-                "created_time": "",
-                "deletion_time": "",
-                "custom_metadata": null,
-                "destroyed": false,
-                "version": 2
-            },
-            "lease_id": "",
-            "lease_duration": 0,
-            "renewable": false,
-            "request_id": "",
-            "warnings": null,
-            "wrap_info": null
-        })))
-        .expect(1)
-        .mount(&server)
-        .await;
-    Mock::given(method("DELETE"))
-        .and(path("/v1/alternate/data/managed/name"))
-        .respond_with(ResponseTemplate::new(204))
-        .expect(1)
-        .mount(&server)
-        .await;
-    let manager: HashicorpVault = manager(&server, &token_values);
-    let operation = SecretOperationContext::Hashicorp(HashicorpOperationContext {
-        mount: Some(" /alternate/ ".to_owned()),
-        path_prefix: Some(" /managed/ ".to_owned()),
-        data_key: Some("api_token".to_owned()),
-        ..HashicorpOperationContext::default()
-    });
-    let write_context = SecretWriteContext {
-        description: Some("Managed key".to_owned()),
-        operation: operation.clone(),
-        ..SecretWriteContext::default()
-    };
-
-    assert_eq!(
-        BaseSecretManager::async_read_secret(&manager, "name", &operation)
-            .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "value"
-    );
-    BaseSecretManager::async_write_secret(
-        &manager,
-        "name",
-        &SecretValue::new("updated"),
-        &write_context,
-    )
-    .await
-    .unwrap();
-    assert!(
-        BaseSecretManager::async_read_secret(&manager, "name", &operation)
-            .await
-            .unwrap()
-            .is_some()
-    );
-    BaseSecretManager::async_delete_secret(&manager, "name", None, &operation)
-        .await
-        .unwrap();
-}
-
-#[rstest]
-#[tokio::test]
-async fn reads_cache_each_data_key_for_the_same_vault_path(token_values: Vec<(&str, &str)>) {
-    let server: MockServer = MockServer::start().await;
-    Mock::given(method("GET"))
-        .and(path("/v1/secret/data/name"))
-        .respond_with(
-            ResponseTemplate::new(200).set_body_json(read_response(json!({
-                "key": "primary",
-                "alternate": "secondary"
-            }))),
-        )
-        .expect(2)
-        .mount(&server)
-        .await;
-    let manager: HashicorpVault = manager(&server, &token_values);
-    let alternate = SecretOperationContext::Hashicorp(HashicorpOperationContext {
-        data_key: Some("alternate".to_owned()),
-        ..HashicorpOperationContext::default()
-    });
-
-    assert_eq!(
-        manager
-            .async_read_secret("name")
-            .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "primary"
-    );
-    assert_eq!(
-        BaseSecretManager::async_read_secret(&manager, "name", &alternate)
-            .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "secondary"
-    );
-    assert_eq!(
-        manager
-            .async_read_secret("name")
-            .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "primary"
-    );
-}
-
-#[rstest]
-#[tokio::test]
-async fn base_manager_context_timeout_limits_vault_io(token_values: Vec<(&str, &str)>) {
-    let server: MockServer = MockServer::start().await;
-    Mock::given(method("GET"))
-        .and(path("/v1/secret/data/name"))
-        .respond_with(
-            ResponseTemplate::new(200)
-                .set_delay(Duration::from_millis(100))
-                .set_body_json(read_response(json!({"key": "value"}))),
-        )
-        .expect(1)
-        .mount(&server)
-        .await;
-    let manager: HashicorpVault = manager(&server, &token_values);
-    let context = SecretOperationContext::Hashicorp(HashicorpOperationContext {
-        timeout: Some(Duration::from_millis(10)),
-        ..HashicorpOperationContext::default()
-    });
-
-    assert!(matches!(
-        BaseSecretManager::async_read_secret(&manager, "name", &context).await,
-        Err(Error::Timeout)
-    ));
-}
-
-#[rstest]
-#[case::aws(SecretOperationContext::Aws(AwsOperationContext::default()))]
-#[case::cyberark(SecretOperationContext::Cyberark(CyberarkOperationContext::default()))]
-#[tokio::test]
-async fn foreign_contexts_cannot_access_vault_secrets(
-    token_values: Vec<(&str, &str)>,
-    #[case] context: SecretOperationContext,
-    #[values(false, true)] cached: bool,
-) {
-    let server = MockServer::start().await;
-    Mock::given(method("GET"))
-        .and(path("/v1/secret/data/name"))
-        .respond_with(
-            ResponseTemplate::new(200).set_body_json(read_response(json!({"key": "value"}))),
-        )
-        .expect(u64::from(cached))
-        .mount(&server)
-        .await;
-    let manager = manager(&server, &token_values);
-    if cached {
-        assert!(manager.async_read_secret("name").await.unwrap().is_some());
-    }
-    assert!(matches!(
-        BaseSecretManager::async_read_secret(&manager, "name", &context).await,
-        Err(Error::InvalidOperationContext)
-    ));
-    assert!(matches!(
-        BaseSecretManager::async_write_secret(
-            &manager,
-            "name",
-            &SecretValue::new("replacement"),
-            &SecretWriteContext {
-                operation: context.clone(),
-                ..SecretWriteContext::default()
-            },
-        )
-        .await,
-        Err(Error::InvalidOperationContext)
-    ));
-    assert!(matches!(
-        BaseSecretManager::async_delete_secret(&manager, "name", None, &context).await,
-        Err(Error::InvalidOperationContext)
-    ));
-    assert!(matches!(
-        manager
-            .async_rotate_secret_with_context(
-                "name",
-                "new",
-                &SecretValue::new("replacement"),
-                &context
-            )
-            .await,
-        Err(Error::InvalidOperationContext)
-    ));
-    assert_eq!(
-        server.received_requests().await.unwrap().len(),
-        usize::from(cached)
-    );
-}
-
-#[rstest]
-#[tokio::test]
-async fn rotation_applies_timeout_to_each_request(token_values: Vec<(&str, &str)>) {
-    let server = MockServer::start().await;
-    let timeout = Duration::from_secs(1);
-    let delay = timeout / 2;
-    Mock::given(method("GET"))
-        .and(path("/v1/alternate/data/managed/current"))
-        .respond_with(
-            ResponseTemplate::new(200)
-                .set_delay(delay)
-                .set_body_json(read_response(json!({"api_token": "original"}))),
-        )
-        .mount(&server)
-        .await;
-    Mock::given(method("POST"))
-        .and(path("/v1/alternate/data/managed/new"))
-        .and(body_json(json!({
-            "data": {"api_token": "replacement", "description": "Rotated from current"}
-        })))
-        .respond_with(
-            ResponseTemplate::new(200)
-                .set_delay(delay)
-                .set_body_json(json!({
-                    "data": {
-                        "created_time": "",
-                        "deletion_time": "",
-                        "custom_metadata": null,
-                        "destroyed": false,
-                        "version": 1
-                    },
-                    "lease_id": "",
-                    "lease_duration": 0,
-                    "renewable": false,
-                    "request_id": "",
-                    "warnings": null,
-                    "wrap_info": null
-                })),
-        )
-        .mount(&server)
-        .await;
-    Mock::given(method("GET"))
-        .and(path("/v1/alternate/data/managed/new"))
-        .respond_with(
-            ResponseTemplate::new(200)
-                .set_delay(delay)
-                .set_body_json(read_response(json!({"api_token": "replacement"}))),
-        )
-        .mount(&server)
-        .await;
-    Mock::given(method("DELETE"))
-        .and(path("/v1/alternate/data/managed/current"))
-        .respond_with(ResponseTemplate::new(204).set_delay(delay))
-        .mount(&server)
-        .await;
-    let manager = manager(&server, &token_values);
-    let context = SecretOperationContext::Hashicorp(HashicorpOperationContext {
-        timeout: Some(timeout),
-        mount: Some("alternate".to_owned()),
-        path_prefix: Some("managed".to_owned()),
-        data_key: Some("api_token".to_owned()),
-    });
-
-    manager
-        .async_rotate_secret_with_context(
-            "current",
-            "new",
-            &SecretValue::new("replacement"),
-            &context,
-        )
-        .await
-        .unwrap();
-    let requests = server.received_requests().await.unwrap();
-    let operations: Vec<_> = requests
-        .iter()
-        .map(|request| (request.method.as_str(), request.url.path()))
-        .collect();
-    assert_eq!(
-        operations,
-        [
-            ("GET", "/v1/alternate/data/managed/current"),
-            ("POST", "/v1/alternate/data/managed/new"),
-            ("GET", "/v1/alternate/data/managed/new"),
-            ("DELETE", "/v1/alternate/data/managed/current"),
-        ]
-    );
-}
-
-#[rstest]
-#[tokio::test]
-async fn no_auth_and_invalid_names_fail_without_requests() {
-    let server: MockServer = MockServer::start().await;
-    let manager: HashicorpVault = manager(&server, &[]);
-
-    assert!(matches!(
-        manager.async_read_secret("name").await,
-        Err(Error::NoAuthConfigured)
-    ));
-    assert!(matches!(
-        manager.async_read_secret("../name").await,
-        Err(Error::InvalidSecretName(_))
-    ));
-    assert!(server.received_requests().await.unwrap().is_empty());
-}
-
-#[rstest]
-#[tokio::test]
-async fn debug_output_redacts_authentication_values() {
-    let server: MockServer = MockServer::start().await;
-    let manager: HashicorpVault =
-        HashicorpVault::from_config(config(&server, &[("HCP_VAULT_TOKEN", "token-value")]), true)
-            .unwrap();
-    let debug: String = format!("{manager:?}");
-    assert!(!debug.contains("token-value"));
-    assert!(!debug.contains("secret-id"));
-}
-
-#[derive(Deserialize)]
-struct ParityCase {
-    env: HashMap<String, String>,
-    expected_secret_url: String,
-    expected_login_url: Option<String>,
-    expected_login_namespace: Option<String>,
-    expected_secret_namespace: Option<String>,
-    secret_name: String,
-}
-
-#[fixture]
-fn parity_cases() -> Vec<ParityCase> {
-    serde_json::from_str(include_str!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/../../../tests/test_litellm/secret_managers/hashicorp_vault_parity.json"
-    )))
-    .unwrap()
-}
-
-#[rstest]
-fn configuration_matches_python_parity_fixture(parity_cases: Vec<ParityCase>) {
-    for case in parity_cases {
-        let values: HashMap<String, String> = case.env.clone();
-        let environment: Arc<dyn Lookup + Send + Sync> =
-            Arc::new(move |name: &str| values.get(name).cloned());
-        let config: HashicorpVaultConfig =
-            HashicorpVaultConfig::from_environment(environment.as_ref()).unwrap();
-        let manager: HashicorpVault = HashicorpVault::from_config(config.clone(), true).unwrap();
-        let location = manager.secret_location(&case.secret_name).unwrap();
-        let namespace = location
-            .namespace
-            .as_deref()
-            .map(|namespace| format!("{namespace}/"))
-            .unwrap_or_default();
-        assert_eq!(
-            format!(
-                "{}/v1/{}{}/data/{}",
-                config.address, namespace, location.mount, location.path
-            ),
-            case.expected_secret_url
-        );
-        let login_url = config.approle.as_ref().map_or_else(
-            || {
-                config
-                    .tls_cert
-                    .as_ref()
-                    .map(|_| format!("{}/v1/auth/cert/login", config.address))
-            },
-            |approle| {
-                Some(format!(
-                    "{}/v1/auth/{}/login",
-                    config.address, approle.mount_path
-                ))
-            },
-        );
-        assert_eq!(login_url, case.expected_login_url);
-        assert_eq!(
-            manager.config().login_namespace(),
-            case.expected_login_namespace.as_deref()
-        );
-        assert_eq!(
-            manager.config().secret_namespace(),
-            case.expected_secret_namespace.as_deref()
-        );
-    }
-}
-
-#[rstest]
-#[tokio::test]
-#[ignore]
-async fn live_vault_round_trip() {
-    let environment: Arc<dyn Lookup + Send + Sync> =
-        Arc::new(litellm_core_utils::settings::ProcessEnvironment);
-    let manager: HashicorpVault = HashicorpVault::new(environment, true).unwrap();
-    let name: String = std::env::var("LITELLM_VAULT_LIVE_SECRET_NAME").unwrap();
-    let value: SecretValue = SecretValue::new("native-live-value");
-    let location = manager.secret_location(&name).unwrap();
-    println!(
-        "native provenance: {} vaultrs {} {:?} {} {}",
-        module_path!(),
-        manager.config().address,
-        location.namespace,
-        location.mount,
-        location.path
-    );
-    manager
-        .async_write_secret(&name, value.clone(), None)
-        .await
-        .unwrap();
-    assert_eq!(
-        manager.async_read_secret(&name).await.unwrap().unwrap(),
-        value
-    );
-    manager.async_delete_secret(&name).await.unwrap();
-    assert!(manager.async_read_secret(&name).await.unwrap().is_none());
-}
-
-const TEST_CERTIFICATE: &str = "-----BEGIN CERTIFICATE-----
-MIIDDzCCAfegAwIBAgIUeMzLFLM/mRbPGbNAew5N2UTscocwDQYJKoZIhvcNAQEL
-BQAwFzEVMBMGA1UEAwwMbGl0ZWxsbS10ZXN0MB4XDTI2MDkyMTIwMjA1OVoXDTI2
-MDkyMjIwMjA1OVowFzEVMBMGA1UEAwwMbGl0ZWxsbS10ZXN0MIIBIjANBgkqhkiG
-9w0BAQEFAAOCAQ8AMIIBCgKCAQEAveYoSUJXybmkHmQsBfhBcv2Ob5Oy8ejZu+B3
-vTnrPumW4ANi1XXKBSazRGB3fEtAgr+3KhKeHaSKEQeBwJkAEBfdmQv0tpXICwHs
-1kFNtU0owy54HVW5/ia+LMszsFcPzVIoMnbUOuiKr9RaV7P+IEFzILPBVuV4DoYH
-yocjD3+9QNqokWgNL8LK37JijmNEFVaKFz0X6SyL2VRDlfPWTEBK52Gp/pvDgA6G
-eTSfyI+kCm9h5ECTYUAtmatk9WPVS8sWOqV1EXVanFyYBU+mDxoywAS1/6CHeIPh
-bNmCOZjPoO9qWBJ7ZyGhOconBigXY8qnlXymev+44IPHrx4urwIDAQABo1MwUTAd
-BgNVHQ4EFgQUvaZrZ6HKtbr3ekeZmgy4b5Pq95QwHwYDVR0jBBgwFoAUvaZrZ6HK
-tbr3ekeZmgy4b5Pq95QwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOC
-AQEAEejrD8d1qDxW55XxQ4IC31rufoEvDV955jyvh2kALPaN/i5oWsBGI+UAQZna
-aaoQXwzlmHrtDUBWl0LztVTUamIleUep2+PLLauqqt43vxppxMX8Jn2mnPO20YE/
-hIzGx0jN/LBG8PDyLSvHdlgjP9ofA4Vg4rTQugdXRgOvlCE/epnH/MADcg9KYJtJ
-C1RObCIkL3LcdUbjStJRCY/U/FeWcgyncEPz95OFDkbrlNDajb6o6CkYfouqvhTc
-8XlgjjAVKIbAbRgbVu3elsquuFM97x2DzWDjkrMNmDt1FJ9ubK36gL6B3o0UMaoQ
-00R7x/eqvH+EkWa/2ekW9lpleQ==
------END CERTIFICATE-----
-";
-
-const TEST_PRIVATE_KEY: &str = "-----BEGIN PRIVATE KEY-----
-MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC95ihJQlfJuaQe
-ZCwF+EFy/Y5vk7Lx6Nm74He9Oes+6ZbgA2LVdcoFJrNEYHd8S0CCv7cqEp4dpIoR
-B4HAmQAQF92ZC/S2lcgLAezWQU21TSjDLngdVbn+Jr4syzOwVw/NUigydtQ66Iqv
-1FpXs/4gQXMgs8FW5XgOhgfKhyMPf71A2qiRaA0vwsrfsmKOY0QVVooXPRfpLIvZ
-VEOV89ZMQErnYan+m8OADoZ5NJ/Ij6QKb2HkQJNhQC2Zq2T1Y9VLyxY6pXURdVqc
-XJgFT6YPGjLABLX/oId4g+Fs2YI5mM+g72pYEntnIaE5yicGKBdjyqeVfKZ6/7jg
-g8evHi6vAgMBAAECggEAGdJjlP6b8Fa5bdaCM/ebcrbuuNZVJVbb0JPHxGfNSLs7
-pE9hj5QaOdQW2Uviw3h6F61ZCzQH4xD+Iy2po5ZKb2XHYKnDB1bboj+LRGER337T
-9aJqe9at2VTMVEv3Rdm40NsEk0QcPLxlK16NQFK90gYEUSSQPDAswJDSG2R/zHn+
-vADI907mW/goEJHeLn8PWGlNlSiR6x+5JJtq+GXCzUzVvJYQSCLGxCSl2x2H+0g7
-NhFI0zPpdzNmO/h+yhzaFb6Rp5U8+ZsnZ3qYjQ/03gw1myTDKJt1YaO9JvArnNYX
-hcJQQ8Rt0bHhcrZA16bBOpqZlo5pKCicwI/netgN8QKBgQDcFz7AzdJ26sMSV32V
-rwrMgIoggt8qDjO1ARwqW35A1TIge0FoW4M4KpsXQGGfT341uU1esXEcyZ/1L/5X
-3ql2gX4DbOYLZLWYzZGR2hq33oi8HkhN98QrEwL9emSH8NqYX3Xxja3PrmCrSYJe
-Zbnd9TIm2XkxyMoyXJu6M/QvnwKBgQDc4dzqTbxoGEGa5MuJoGmMwPnqgdG9UM5J
-eExVnh7osxc2sOdsiPeRjjQTxs9v2kJwctC359OJoo9yGaaJeSghU4LEWJo1sqnA
-fzSCLammYvtVAtniyNv5Mxk/6Uimi4NNDKaAKB+m4K2uSn3U9AmY7KPYMGaSbS9W
-XSnobjxm8QKBgC8bPpAvvWs8ZhIn7bY659nLbUT2HeO3dHO6UBf0yzn/J6JyHxbB
-93zvCZDZc8uQTRgcmCW7XtVlhjoJUqvl+Wlm39zF0xr/LCsPXKfWAb/2/lcdOCaP
-8Emz4QD10EyUTYUtcWYJB/mafhBLRH8F0Nlj4J8WDu2L51MOJTqeYhZLAoGAWffN
-icocAbJPlo22sdoa4+/+W5yBF8GAJMDRJtZ+9H1t6SLpQHYRkMIBSETkXUTjZvX9
-Ocs9iIQkNW9pO/mTdO+VBfCo71JUfknR02xR+6m5gYjlws/ZeYlssXGN2/hbhNiw
-QOcW7Vv6olFJK6Iy/oz0t6wPO3kpnN3Zogi0paECgYEAwo44M1DdYCtV0snhmYM9
-5u0mPfYt5P2SVLXyUbr+vFTfrTL/WKnXIJgbsnj3Gvf+GIZv9tKcXhSNmEHQCYX4
-X3w9iTPddCHuvZ1fpufi2TyArJh0OkoNtLXJHTKrHjf2N+61AQzFiv5WieJrdE+H
-qr32PTUuVGPyO9LyTY4/RL0=
------END PRIVATE KEY-----
-";
+#[path = "secret_manager/configuration.rs"]
+mod configuration;
+#[path = "secret_manager/reads.rs"]
+mod reads;
+#[path = "secret_manager/writes.rs"]
+mod writes;
diff --git a/litellm-rust/crates/secrets-hashicorp/tests/secret_manager/configuration.rs b/litellm-rust/crates/secrets-hashicorp/tests/secret_manager/configuration.rs
new file mode 100644
index 000000000000..be3059ce9863
--- /dev/null
+++ b/litellm-rust/crates/secrets-hashicorp/tests/secret_manager/configuration.rs
@@ -0,0 +1,335 @@
+use super::*;
+
+#[rstest]
+fn trailing_address_slashes_are_removed() {
+    let environment: Arc<dyn Lookup + Send + Sync> = Arc::new(|name: &str| match name {
+        "HCP_VAULT_ADDR" => Some("http://vault.test:8200///".to_owned()),
+        "HCP_VAULT_TOKEN" => Some("token".to_owned()),
+        _ => None,
+    });
+    let config: HashicorpVaultConfig =
+        HashicorpVaultConfig::from_environment(environment.as_ref()).unwrap();
+    let manager: HashicorpVault = HashicorpVault::from_config(config, true).unwrap();
+
+    assert_eq!(
+        manager.secret_location("name").unwrap(),
+        litellm_secrets_hashicorp::SecretLocation {
+            namespace: None,
+            mount: "secret".to_owned(),
+            path: "name".to_owned(),
+        }
+    );
+}
+
+#[rstest]
+#[case::negative("-1")]
+#[case::not_a_number("not-a-number")]
+fn invalid_refresh_intervals_are_rejected(#[case] value: &str) {
+    let environment: Arc<dyn Lookup + Send + Sync> = Arc::new(move |name: &str| match name {
+        "HCP_VAULT_REFRESH_INTERVAL" => Some(value.to_owned()),
+        _ => None,
+    });
+
+    assert!(matches!(
+        HashicorpVaultConfig::from_environment(environment.as_ref()),
+        Err(Error::RefreshInterval)
+    ));
+}
+
+#[rstest]
+#[tokio::test]
+async fn approle_login_uses_namespace_and_reuses_the_token() {
+    let server: MockServer = MockServer::start().await;
+    Mock::given(method("POST"))
+        .and(path("/v1/auth/custom-approle/login"))
+        .and(header("X-Vault-Namespace", "login-root"))
+        .and(body_json(json!({"role_id": "role", "secret_id": "secret"})))
+        .respond_with(ResponseTemplate::new(200).set_body_json(auth_response("login-token", 3600)))
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(method("GET"))
+        .and(path("/v1/secret/data/name"))
+        .and(header("X-Vault-Token", "login-token"))
+        .and(header("X-Vault-Namespace", "secret-root"))
+        .respond_with(
+            ResponseTemplate::new(200).set_body_json(read_response(json!({"key": "value"}))),
+        )
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(method("GET"))
+        .and(path("/v1/secret/data/name-2"))
+        .respond_with(ResponseTemplate::new(404).set_body_json(json!({"errors": ["missing"]})))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager: HashicorpVault = manager(
+        &server,
+        &[
+            ("HCP_VAULT_APPROLE_ROLE_ID", "role"),
+            ("HCP_VAULT_APPROLE_SECRET_ID", "secret"),
+            ("HCP_VAULT_APPROLE_MOUNT_PATH", "custom-approle"),
+            ("HCP_VAULT_NAMESPACE", "secret-root"),
+            ("HCP_VAULT_LOGIN_NAMESPACE", "login-root"),
+        ],
+    );
+
+    assert!(manager.async_read_secret("name").await.unwrap().is_some());
+    assert!(manager.async_read_secret("name-2").await.unwrap().is_none());
+}
+
+#[rstest]
+#[tokio::test]
+async fn tls_login_posts_the_role_and_uses_the_client_identity() {
+    let server: MockServer = MockServer::start().await;
+    let directory: tempfile::TempDir = tempfile::tempdir().unwrap();
+    let cert_path = directory.path().join("client.crt");
+    let key_path = directory.path().join("client.key");
+    std::fs::write(&cert_path, TEST_CERTIFICATE).unwrap();
+    std::fs::write(&key_path, TEST_PRIVATE_KEY).unwrap();
+    Mock::given(method("POST"))
+        .and(path("/v1/auth/cert/login"))
+        .and(header("X-Vault-Namespace", "login-ns"))
+        .respond_with(ResponseTemplate::new(200).set_body_json(auth_response("cert-token", 0)))
+        .expect(2)
+        .mount(&server)
+        .await;
+    Mock::given(method("GET"))
+        .and(path("/v1/secret/data/name"))
+        .and(header("X-Vault-Token", "cert-token"))
+        .and(header("X-Vault-Namespace", "secret-ns"))
+        .respond_with(
+            ResponseTemplate::new(200).set_body_json(read_response(json!({"key": "value"}))),
+        )
+        .expect(2)
+        .mount(&server)
+        .await;
+    let role_values: HashMap<String, String> = HashMap::from([
+        ("HCP_VAULT_ADDR".to_owned(), server.uri()),
+        (
+            "HCP_VAULT_CLIENT_CERT".to_owned(),
+            cert_path.to_str().unwrap().to_owned(),
+        ),
+        (
+            "HCP_VAULT_CLIENT_KEY".to_owned(),
+            key_path.to_str().unwrap().to_owned(),
+        ),
+        ("HCP_VAULT_CERT_ROLE".to_owned(), "vault-role".to_owned()),
+        (
+            "HCP_VAULT_LOGIN_NAMESPACE".to_owned(),
+            "login-ns".to_owned(),
+        ),
+        (
+            "HCP_VAULT_SECRET_NAMESPACE".to_owned(),
+            "secret-ns".to_owned(),
+        ),
+    ]);
+    let role_environment: Arc<dyn Lookup + Send + Sync> =
+        Arc::new(move |name: &str| role_values.get(name).cloned());
+    let role_manager: HashicorpVault = HashicorpVault::new(role_environment, true).unwrap();
+    assert!(
+        role_manager
+            .async_read_secret("name")
+            .await
+            .unwrap()
+            .is_some()
+    );
+
+    let no_role_values: HashMap<String, String> = HashMap::from([
+        ("HCP_VAULT_ADDR".to_owned(), server.uri()),
+        (
+            "HCP_VAULT_CLIENT_CERT".to_owned(),
+            cert_path.to_str().unwrap().to_owned(),
+        ),
+        (
+            "HCP_VAULT_CLIENT_KEY".to_owned(),
+            key_path.to_str().unwrap().to_owned(),
+        ),
+        (
+            "HCP_VAULT_LOGIN_NAMESPACE".to_owned(),
+            "login-ns".to_owned(),
+        ),
+        (
+            "HCP_VAULT_SECRET_NAMESPACE".to_owned(),
+            "secret-ns".to_owned(),
+        ),
+    ]);
+    let no_role_environment: Arc<dyn Lookup + Send + Sync> =
+        Arc::new(move |name: &str| no_role_values.get(name).cloned());
+    let no_role_manager: HashicorpVault = HashicorpVault::new(no_role_environment, true).unwrap();
+    assert!(
+        no_role_manager
+            .async_read_secret("name")
+            .await
+            .unwrap()
+            .is_some()
+    );
+    let login_bodies: Vec<serde_json::Value> = server
+        .received_requests()
+        .await
+        .unwrap()
+        .iter()
+        .filter(|request| request.method.as_str() == "POST")
+        .map(|request| serde_json::from_slice(&request.body).unwrap())
+        .collect();
+    assert!(login_bodies.contains(&json!({"name": "vault-role"})));
+    assert!(login_bodies.contains(&json!({})));
+}
+
+#[rstest]
+#[tokio::test]
+async fn no_auth_and_invalid_names_fail_without_requests() {
+    let server: MockServer = MockServer::start().await;
+    let manager: HashicorpVault = manager(&server, &[]);
+
+    assert!(matches!(
+        manager.async_read_secret("name").await,
+        Err(Error::NoAuthConfigured)
+    ));
+    assert!(matches!(
+        manager.async_read_secret("../name").await,
+        Err(Error::InvalidSecretName(_))
+    ));
+    assert!(server.received_requests().await.unwrap().is_empty());
+}
+
+#[rstest]
+#[tokio::test]
+async fn debug_output_redacts_authentication_values() {
+    let server: MockServer = MockServer::start().await;
+    let manager: HashicorpVault =
+        HashicorpVault::from_config(config(&server, &[("HCP_VAULT_TOKEN", "token-value")]), true)
+            .unwrap();
+    let debug: String = format!("{manager:?}");
+    assert!(!debug.contains("token-value"));
+    assert!(!debug.contains("secret-id"));
+}
+
+#[rstest]
+fn configuration_matches_python_parity_fixture(parity_cases: Vec<ParityCase>) {
+    for case in parity_cases {
+        let values: HashMap<String, String> = case.env.clone();
+        let environment: Arc<dyn Lookup + Send + Sync> =
+            Arc::new(move |name: &str| values.get(name).cloned());
+        let config: HashicorpVaultConfig =
+            HashicorpVaultConfig::from_environment(environment.as_ref()).unwrap();
+        let manager: HashicorpVault = HashicorpVault::from_config(config.clone(), true).unwrap();
+        let location = manager.secret_location(&case.secret_name).unwrap();
+        let namespace = location
+            .namespace
+            .as_deref()
+            .map(|namespace| format!("{namespace}/"))
+            .unwrap_or_default();
+        assert_eq!(
+            format!(
+                "{}/v1/{}{}/data/{}",
+                config.address, namespace, location.mount, location.path
+            ),
+            case.expected_secret_url
+        );
+        let login_url = config.approle.as_ref().map_or_else(
+            || {
+                config
+                    .tls_cert
+                    .as_ref()
+                    .map(|_| format!("{}/v1/auth/cert/login", config.address))
+            },
+            |approle| {
+                Some(format!(
+                    "{}/v1/auth/{}/login",
+                    config.address, approle.mount_path
+                ))
+            },
+        );
+        assert_eq!(login_url, case.expected_login_url);
+        assert_eq!(
+            manager.config().login_namespace(),
+            case.expected_login_namespace.as_deref()
+        );
+        assert_eq!(
+            manager.config().secret_namespace(),
+            case.expected_secret_namespace.as_deref()
+        );
+    }
+}
+
+#[rstest]
+#[case::separate(
+    Some("legacy"),
+    Some("root"),
+    Some("teams/team-a"),
+    Some("root"),
+    Some("teams/team-a")
+)]
+#[case::legacy(Some("admin"), None, None, Some("admin"), Some("admin"))]
+#[case::login_override(Some("admin"), Some("root"), None, Some("root"), Some("admin"))]
+#[case::secret_override(
+    Some("admin"),
+    None,
+    Some("teams/team-a"),
+    Some("admin"),
+    Some("teams/team-a")
+)]
+#[case::no_namespace(None, None, None, None, None)]
+#[tokio::test]
+async fn login_and_secret_namespaces_follow_python_precedence(
+    #[case] legacy: Option<&str>,
+    #[case] login: Option<&str>,
+    #[case] secret: Option<&str>,
+    #[case] expected_login: Option<&'static str>,
+    #[case] expected_secret: Option<&'static str>,
+) {
+    let server = MockServer::start().await;
+    Mock::given(method("POST"))
+        .and(path("/v1/auth/approle/login"))
+        .and(body_json(json!({"role_id":"role", "secret_id":"secret"})))
+        .respond_with(move |request: &wiremock::Request| {
+            assert_eq!(
+                request
+                    .headers
+                    .get("X-Vault-Namespace")
+                    .map(|value| value.to_str().unwrap()),
+                expected_login
+            );
+            ResponseTemplate::new(200).set_body_json(auth_response("login-token", 3600))
+        })
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(method("GET"))
+        .and(path("/v1/secret/data/key"))
+        .and(header("X-Vault-Token", "login-token"))
+        .respond_with(move |request: &wiremock::Request| {
+            assert_eq!(
+                request
+                    .headers
+                    .get("X-Vault-Namespace")
+                    .map(|value| value.to_str().unwrap()),
+                expected_secret
+            );
+            ResponseTemplate::new(200).set_body_json(read_response(json!({"key":"value"})))
+        })
+        .expect(1)
+        .mount(&server)
+        .await;
+    let values: Vec<_> = [
+        ("HCP_VAULT_NAMESPACE", legacy),
+        ("HCP_VAULT_LOGIN_NAMESPACE", login),
+        ("HCP_VAULT_SECRET_NAMESPACE", secret),
+        ("HCP_VAULT_APPROLE_ROLE_ID", Some("role")),
+        ("HCP_VAULT_APPROLE_SECRET_ID", Some("secret")),
+    ]
+    .into_iter()
+    .filter_map(|(key, value)| value.map(|value| (key, value)))
+    .collect();
+    assert_eq!(
+        manager(&server, &values)
+            .async_read_secret("key")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "value"
+    );
+}
diff --git a/litellm-rust/crates/secrets-hashicorp/tests/secret_manager/reads.rs b/litellm-rust/crates/secrets-hashicorp/tests/secret_manager/reads.rs
new file mode 100644
index 000000000000..0c662eb5b553
--- /dev/null
+++ b/litellm-rust/crates/secrets-hashicorp/tests/secret_manager/reads.rs
@@ -0,0 +1,385 @@
+use super::*;
+
+#[rstest]
+#[tokio::test]
+async fn token_reads_use_vault_headers_and_cache_values(token_values: Vec<(&str, &str)>) {
+    let server: MockServer = MockServer::start().await;
+    Mock::given(method("GET"))
+        .and(path("/v1/secret/data/name"))
+        .and(header("X-Vault-Token", "token"))
+        .respond_with(
+            ResponseTemplate::new(200).set_body_json(read_response(json!({"key": "value"}))),
+        )
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager: HashicorpVault = manager(&server, &token_values);
+
+    assert_eq!(
+        manager
+            .async_read_secret("name")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "value"
+    );
+    let requests = server.received_requests().await.unwrap();
+    assert!(
+        requests
+            .iter()
+            .all(|request| !request.headers.contains_key("X-Vault-Namespace"))
+    );
+    assert_eq!(
+        manager
+            .async_read_secret("name")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "value"
+    );
+}
+
+#[rstest]
+#[tokio::test]
+async fn namespace_mount_and_prefix_are_sanitized_in_the_url() {
+    let server: MockServer = MockServer::start().await;
+    Mock::given(method("GET"))
+        .and(path("/v1/kv-prod/data/virtual-keys/name"))
+        .and(header("X-Vault-Namespace", "team-a"))
+        .respond_with(
+            ResponseTemplate::new(200).set_body_json(read_response(json!({"key": "value"}))),
+        )
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager: HashicorpVault = manager(
+        &server,
+        &[
+            ("HCP_VAULT_TOKEN", "token"),
+            ("HCP_VAULT_SECRET_NAMESPACE", " /team-a/ "),
+            ("HCP_VAULT_MOUNT_NAME", " /kv-prod/ "),
+            ("HCP_VAULT_PATH_PREFIX", " /virtual-keys/ "),
+        ],
+    );
+
+    let location = manager.secret_location("name").unwrap();
+    assert_eq!(location.namespace.as_deref(), Some("team-a"));
+    assert_eq!(location.mount, "kv-prod");
+    assert_eq!(location.path, "virtual-keys/name");
+    assert!(manager.async_read_secret("name").await.unwrap().is_some());
+}
+
+#[rstest]
+#[tokio::test]
+async fn approle_tokens_expire_after_the_vault_lease() {
+    let server: MockServer = MockServer::start().await;
+    Mock::given(method("POST"))
+        .and(path("/v1/auth/approle/login"))
+        .respond_with(ResponseTemplate::new(200).set_body_json(auth_response("login-token", 1)))
+        .expect(2)
+        .mount(&server)
+        .await;
+    Mock::given(method("GET"))
+        .respond_with(
+            ResponseTemplate::new(200).set_body_json(read_response(json!({"key": "value"}))),
+        )
+        .expect(2)
+        .mount(&server)
+        .await;
+    let manager: HashicorpVault = manager(
+        &server,
+        &[
+            ("HCP_VAULT_APPROLE_ROLE_ID", "role"),
+            ("HCP_VAULT_APPROLE_SECRET_ID", "secret"),
+            ("HCP_VAULT_REFRESH_INTERVAL", "0"),
+        ],
+    );
+
+    assert!(manager.async_read_secret("first").await.unwrap().is_some());
+    tokio::time::sleep(Duration::from_secs(1) + Duration::from_millis(50)).await;
+    assert!(manager.async_read_secret("second").await.unwrap().is_some());
+}
+
+#[derive(Clone, Copy)]
+enum ExpectedRead {
+    Missing,
+    Malformed,
+    NonString,
+}
+
+#[rstest]
+#[case::missing(404, json!({"errors": ["missing"]}), ExpectedRead::Missing)]
+#[case::malformed(200, json!({"data": "invalid"}), ExpectedRead::Malformed)]
+#[case::missing_key(200, json!({}), ExpectedRead::Missing)]
+#[case::non_string(200, json!({"key": 1}), ExpectedRead::NonString)]
+#[tokio::test]
+async fn read_responses_distinguish_absence_and_malformed_payloads(
+    token_values: Vec<(&str, &str)>,
+    #[case] status: u16,
+    #[case] body: serde_json::Value,
+    #[case] expected: ExpectedRead,
+) {
+    let server: MockServer = MockServer::start().await;
+    Mock::given(method("GET"))
+        .respond_with(ResponseTemplate::new(status).set_body_json(
+            if status == 200 && !matches!(expected, ExpectedRead::Malformed) {
+                read_response(body)
+            } else {
+                body
+            },
+        ))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let result: Result<Option<SecretValue>, Error> = manager(&server, &token_values)
+        .async_read_secret("name")
+        .await;
+    match expected {
+        ExpectedRead::Missing => assert!(result.unwrap().is_none()),
+        ExpectedRead::Malformed => assert!(matches!(result, Err(Error::MalformedPayload))),
+        ExpectedRead::NonString => assert!(matches!(result, Err(Error::NonStringValue))),
+    }
+}
+
+#[rstest]
+#[tokio::test]
+async fn base_manager_context_overrides_vault_location_and_data_key(
+    token_values: Vec<(&str, &str)>,
+) {
+    let server: MockServer = MockServer::start().await;
+    Mock::given(method("GET"))
+        .and(path("/v1/alternate/data/managed/name"))
+        .respond_with(
+            ResponseTemplate::new(200).set_body_json(read_response(json!({"api_token": "value"}))),
+        )
+        .expect(2)
+        .mount(&server)
+        .await;
+    Mock::given(method("POST"))
+        .and(path("/v1/alternate/data/managed/name"))
+        .and(body_json(json!({
+            "data": {"api_token": "updated", "description": "Managed key"}
+        })))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+            "data": {
+                "created_time": "",
+                "deletion_time": "",
+                "custom_metadata": null,
+                "destroyed": false,
+                "version": 2
+            },
+            "lease_id": "",
+            "lease_duration": 0,
+            "renewable": false,
+            "request_id": "",
+            "warnings": null,
+            "wrap_info": null
+        })))
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(method("DELETE"))
+        .and(path("/v1/alternate/data/managed/name"))
+        .respond_with(ResponseTemplate::new(204))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager: HashicorpVault = manager(&server, &token_values);
+    let operation = HashicorpOperationContext {
+        mount: Some(" /alternate/ ".to_owned()),
+        path_prefix: Some(" /managed/ ".to_owned()),
+        data_key: Some("api_token".to_owned()),
+        ..HashicorpOperationContext::default()
+    };
+    let write_context = SecretWriteContext {
+        description: Some("Managed key".to_owned()),
+        operation: operation.clone(),
+        ..SecretWriteContext::default()
+    };
+
+    assert_eq!(
+        BaseSecretManager::async_read_secret(&manager, "name", &operation)
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "value"
+    );
+    SecretWriter::async_write_secret(
+        &manager,
+        "name",
+        &SecretValue::new("updated"),
+        &write_context,
+    )
+    .await
+    .unwrap();
+    assert!(
+        BaseSecretManager::async_read_secret(&manager, "name", &operation)
+            .await
+            .unwrap()
+            .is_some()
+    );
+    SecretDeleter::async_delete_secret(&manager, "name", &operation)
+        .await
+        .unwrap();
+}
+
+#[rstest]
+#[tokio::test]
+async fn rejects_description_that_would_replace_the_secret_value(token_values: Vec<(&str, &str)>) {
+    let server: MockServer = MockServer::start().await;
+    let manager: HashicorpVault = manager(&server, &token_values);
+    let context = SecretWriteContext {
+        description: Some("metadata".to_owned()),
+        operation: HashicorpOperationContext {
+            data_key: Some("description".to_owned()),
+            ..HashicorpOperationContext::default()
+        },
+        ..SecretWriteContext::default()
+    };
+
+    assert!(matches!(
+        manager
+            .async_write_secret_with_context("name", &SecretValue::new("secret"), &context)
+            .await,
+        Err(Error::DataKeyConflictsWithDescription)
+    ));
+    assert!(server.received_requests().await.unwrap().is_empty());
+}
+
+#[rstest]
+#[tokio::test]
+async fn reads_cache_each_data_key_for_the_same_vault_path(token_values: Vec<(&str, &str)>) {
+    let server: MockServer = MockServer::start().await;
+    Mock::given(method("GET"))
+        .and(path("/v1/secret/data/name"))
+        .respond_with(
+            ResponseTemplate::new(200).set_body_json(read_response(json!({
+                "key": "primary",
+                "alternate": "secondary"
+            }))),
+        )
+        .expect(2)
+        .mount(&server)
+        .await;
+    let manager: HashicorpVault = manager(&server, &token_values);
+    let alternate = HashicorpOperationContext {
+        data_key: Some("alternate".to_owned()),
+        ..HashicorpOperationContext::default()
+    };
+
+    assert_eq!(
+        manager
+            .async_read_secret("name")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "primary"
+    );
+    assert_eq!(
+        BaseSecretManager::async_read_secret(&manager, "name", &alternate)
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "secondary"
+    );
+    assert_eq!(
+        manager
+            .async_read_secret("name")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "primary"
+    );
+}
+
+#[rstest]
+#[tokio::test]
+async fn base_manager_context_timeout_limits_vault_io(token_values: Vec<(&str, &str)>) {
+    let server: MockServer = MockServer::start().await;
+    Mock::given(method("GET"))
+        .and(path("/v1/secret/data/name"))
+        .respond_with(
+            ResponseTemplate::new(200)
+                .set_delay(Duration::from_millis(100))
+                .set_body_json(read_response(json!({"key": "value"}))),
+        )
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager: HashicorpVault = manager(&server, &token_values);
+    let context = HashicorpOperationContext {
+        timeout: Some(Duration::from_millis(10)),
+        ..HashicorpOperationContext::default()
+    };
+
+    assert!(matches!(
+        BaseSecretManager::async_read_secret(&manager, "name", &context).await,
+        Err(Error::Timeout)
+    ));
+}
+
+#[rstest]
+#[tokio::test]
+async fn concurrent_reads_share_a_load_but_verification_fetches_fresh(
+    token_values: Vec<(&str, &str)>,
+) {
+    use litellm_secrets_types::SecretRotator;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    let server = MockServer::start().await;
+    let reads = AtomicUsize::new(0);
+    Mock::given(method("GET"))
+        .and(path("/v1/secret/data/name"))
+        .respond_with(move |_: &wiremock::Request| {
+            let value = if reads.fetch_add(1, Ordering::SeqCst) == 0 {
+                "old"
+            } else {
+                "new"
+            };
+            ResponseTemplate::new(200)
+                .set_body_json(read_response(json!({"key": value})))
+                .set_delay(Duration::from_millis(20))
+        })
+        .expect(2)
+        .mount(&server)
+        .await;
+    let manager = manager(&server, &token_values);
+    let (first, second) = tokio::join!(
+        manager.async_read_secret("name"),
+        manager.async_read_secret("name")
+    );
+    assert_eq!(first.unwrap().unwrap().expose(), "old");
+    assert_eq!(second.unwrap().unwrap().expose(), "old");
+    assert_eq!(
+        manager
+            .async_read_secret("name")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "old"
+    );
+    assert_eq!(
+        manager
+            .async_read_secret_fresh("name", &HashicorpOperationContext::default())
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "new"
+    );
+    assert_eq!(
+        manager
+            .async_read_secret("name")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "new"
+    );
+}
diff --git a/litellm-rust/crates/secrets-hashicorp/tests/secret_manager/support.rs b/litellm-rust/crates/secrets-hashicorp/tests/secret_manager/support.rs
new file mode 100644
index 000000000000..30e46f93248e
--- /dev/null
+++ b/litellm-rust/crates/secrets-hashicorp/tests/secret_manager/support.rs
@@ -0,0 +1,175 @@
+use super::*;
+
+pub(super) fn config(server: &MockServer, values: &[(&str, &str)]) -> HashicorpVaultConfig {
+    let mut environment_values: HashMap<String, String> = values
+        .iter()
+        .map(|(name, value)| ((*name).to_owned(), (*value).to_owned()))
+        .collect();
+    environment_values.insert("HCP_VAULT_ADDR".to_owned(), server.uri());
+    let environment: Arc<dyn Lookup + Send + Sync> =
+        Arc::new(move |name: &str| environment_values.get(name).cloned());
+    HashicorpVaultConfig::from_environment(environment.as_ref()).unwrap()
+}
+
+pub(super) fn manager(server: &MockServer, values: &[(&str, &str)]) -> HashicorpVault {
+    HashicorpVault::from_config(config(server, values), true).unwrap()
+}
+
+pub(super) fn auth_response(token: &str, lease_duration: u64) -> serde_json::Value {
+    json!({
+        "auth": {
+            "client_token": token,
+            "accessor": "",
+            "policies": [],
+            "token_policies": [],
+            "metadata": null,
+            "lease_duration": lease_duration,
+            "renewable": false,
+            "entity_id": "",
+            "token_type": "service",
+            "orphan": false
+        },
+        "lease_id": "",
+        "lease_duration": lease_duration,
+        "renewable": false,
+        "request_id": "",
+        "warnings": null,
+        "wrap_info": null
+    })
+}
+
+pub(super) fn read_response(data: serde_json::Value) -> serde_json::Value {
+    json!({
+        "data": {
+            "data": data,
+            "metadata": {
+                "created_time": "",
+                "deletion_time": "",
+                "custom_metadata": null,
+                "destroyed": false,
+                "version": 1
+            }
+        },
+        "lease_id": "",
+        "lease_duration": 0,
+        "renewable": false,
+        "request_id": "",
+        "warnings": null,
+        "wrap_info": null
+    })
+}
+
+pub(super) fn metadata_response(version: u64) -> serde_json::Value {
+    json!({
+        "data": {
+            "cas_required": true,
+            "created_time": "",
+            "current_version": version,
+            "delete_version_after": "0s",
+            "max_versions": 0,
+            "oldest_version": 1,
+            "updated_time": "",
+            "custom_metadata": null,
+            "versions": {}
+        },
+        "lease_id": "",
+        "lease_duration": 0,
+        "renewable": false,
+        "request_id": "",
+        "warnings": null,
+        "wrap_info": null
+    })
+}
+
+pub(super) fn write_response(version: u64) -> serde_json::Value {
+    json!({
+        "data": {
+            "created_time": "",
+            "deletion_time": "",
+            "custom_metadata": null,
+            "destroyed": false,
+            "version": version
+        },
+        "lease_id": "",
+        "lease_duration": 0,
+        "renewable": false,
+        "request_id": "",
+        "warnings": null,
+        "wrap_info": null
+    })
+}
+
+#[fixture]
+pub(super) fn token_values() -> Vec<(&'static str, &'static str)> {
+    vec![("HCP_VAULT_TOKEN", "token")]
+}
+
+#[derive(Deserialize)]
+pub(super) struct ParityCase {
+    pub(super) env: HashMap<String, String>,
+    pub(super) expected_secret_url: String,
+    pub(super) expected_login_url: Option<String>,
+    pub(super) expected_login_namespace: Option<String>,
+    pub(super) expected_secret_namespace: Option<String>,
+    pub(super) secret_name: String,
+}
+
+#[fixture]
+pub(super) fn parity_cases() -> Vec<ParityCase> {
+    serde_json::from_str(include_str!(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/../../../tests/test_litellm/secret_managers/hashicorp_vault_parity.json"
+    )))
+    .unwrap()
+}
+
+pub(super) const TEST_CERTIFICATE: &str = "-----BEGIN CERTIFICATE-----
+MIIDDzCCAfegAwIBAgIUeMzLFLM/mRbPGbNAew5N2UTscocwDQYJKoZIhvcNAQEL
+BQAwFzEVMBMGA1UEAwwMbGl0ZWxsbS10ZXN0MB4XDTI2MDkyMTIwMjA1OVoXDTI2
+MDkyMjIwMjA1OVowFzEVMBMGA1UEAwwMbGl0ZWxsbS10ZXN0MIIBIjANBgkqhkiG
+9w0BAQEFAAOCAQ8AMIIBCgKCAQEAveYoSUJXybmkHmQsBfhBcv2Ob5Oy8ejZu+B3
+vTnrPumW4ANi1XXKBSazRGB3fEtAgr+3KhKeHaSKEQeBwJkAEBfdmQv0tpXICwHs
+1kFNtU0owy54HVW5/ia+LMszsFcPzVIoMnbUOuiKr9RaV7P+IEFzILPBVuV4DoYH
+yocjD3+9QNqokWgNL8LK37JijmNEFVaKFz0X6SyL2VRDlfPWTEBK52Gp/pvDgA6G
+eTSfyI+kCm9h5ECTYUAtmatk9WPVS8sWOqV1EXVanFyYBU+mDxoywAS1/6CHeIPh
+bNmCOZjPoO9qWBJ7ZyGhOconBigXY8qnlXymev+44IPHrx4urwIDAQABo1MwUTAd
+BgNVHQ4EFgQUvaZrZ6HKtbr3ekeZmgy4b5Pq95QwHwYDVR0jBBgwFoAUvaZrZ6HK
+tbr3ekeZmgy4b5Pq95QwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOC
+AQEAEejrD8d1qDxW55XxQ4IC31rufoEvDV955jyvh2kALPaN/i5oWsBGI+UAQZna
+aaoQXwzlmHrtDUBWl0LztVTUamIleUep2+PLLauqqt43vxppxMX8Jn2mnPO20YE/
+hIzGx0jN/LBG8PDyLSvHdlgjP9ofA4Vg4rTQugdXRgOvlCE/epnH/MADcg9KYJtJ
+C1RObCIkL3LcdUbjStJRCY/U/FeWcgyncEPz95OFDkbrlNDajb6o6CkYfouqvhTc
+8XlgjjAVKIbAbRgbVu3elsquuFM97x2DzWDjkrMNmDt1FJ9ubK36gL6B3o0UMaoQ
+00R7x/eqvH+EkWa/2ekW9lpleQ==
+-----END CERTIFICATE-----
+";
+
+pub(super) const TEST_PRIVATE_KEY: &str = "-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC95ihJQlfJuaQe
+ZCwF+EFy/Y5vk7Lx6Nm74He9Oes+6ZbgA2LVdcoFJrNEYHd8S0CCv7cqEp4dpIoR
+B4HAmQAQF92ZC/S2lcgLAezWQU21TSjDLngdVbn+Jr4syzOwVw/NUigydtQ66Iqv
+1FpXs/4gQXMgs8FW5XgOhgfKhyMPf71A2qiRaA0vwsrfsmKOY0QVVooXPRfpLIvZ
+VEOV89ZMQErnYan+m8OADoZ5NJ/Ij6QKb2HkQJNhQC2Zq2T1Y9VLyxY6pXURdVqc
+XJgFT6YPGjLABLX/oId4g+Fs2YI5mM+g72pYEntnIaE5yicGKBdjyqeVfKZ6/7jg
+g8evHi6vAgMBAAECggEAGdJjlP6b8Fa5bdaCM/ebcrbuuNZVJVbb0JPHxGfNSLs7
+pE9hj5QaOdQW2Uviw3h6F61ZCzQH4xD+Iy2po5ZKb2XHYKnDB1bboj+LRGER337T
+9aJqe9at2VTMVEv3Rdm40NsEk0QcPLxlK16NQFK90gYEUSSQPDAswJDSG2R/zHn+
+vADI907mW/goEJHeLn8PWGlNlSiR6x+5JJtq+GXCzUzVvJYQSCLGxCSl2x2H+0g7
+NhFI0zPpdzNmO/h+yhzaFb6Rp5U8+ZsnZ3qYjQ/03gw1myTDKJt1YaO9JvArnNYX
+hcJQQ8Rt0bHhcrZA16bBOpqZlo5pKCicwI/netgN8QKBgQDcFz7AzdJ26sMSV32V
+rwrMgIoggt8qDjO1ARwqW35A1TIge0FoW4M4KpsXQGGfT341uU1esXEcyZ/1L/5X
+3ql2gX4DbOYLZLWYzZGR2hq33oi8HkhN98QrEwL9emSH8NqYX3Xxja3PrmCrSYJe
+Zbnd9TIm2XkxyMoyXJu6M/QvnwKBgQDc4dzqTbxoGEGa5MuJoGmMwPnqgdG9UM5J
+eExVnh7osxc2sOdsiPeRjjQTxs9v2kJwctC359OJoo9yGaaJeSghU4LEWJo1sqnA
+fzSCLammYvtVAtniyNv5Mxk/6Uimi4NNDKaAKB+m4K2uSn3U9AmY7KPYMGaSbS9W
+XSnobjxm8QKBgC8bPpAvvWs8ZhIn7bY659nLbUT2HeO3dHO6UBf0yzn/J6JyHxbB
+93zvCZDZc8uQTRgcmCW7XtVlhjoJUqvl+Wlm39zF0xr/LCsPXKfWAb/2/lcdOCaP
+8Emz4QD10EyUTYUtcWYJB/mafhBLRH8F0Nlj4J8WDu2L51MOJTqeYhZLAoGAWffN
+icocAbJPlo22sdoa4+/+W5yBF8GAJMDRJtZ+9H1t6SLpQHYRkMIBSETkXUTjZvX9
+Ocs9iIQkNW9pO/mTdO+VBfCo71JUfknR02xR+6m5gYjlws/ZeYlssXGN2/hbhNiw
+QOcW7Vv6olFJK6Iy/oz0t6wPO3kpnN3Zogi0paECgYEAwo44M1DdYCtV0snhmYM9
+5u0mPfYt5P2SVLXyUbr+vFTfrTL/WKnXIJgbsnj3Gvf+GIZv9tKcXhSNmEHQCYX4
+X3w9iTPddCHuvZ1fpufi2TyArJh0OkoNtLXJHTKrHjf2N+61AQzFiv5WieJrdE+H
+qr32PTUuVGPyO9LyTY4/RL0=
+-----END PRIVATE KEY-----
+";
diff --git a/litellm-rust/crates/secrets-hashicorp/tests/secret_manager/writes.rs b/litellm-rust/crates/secrets-hashicorp/tests/secret_manager/writes.rs
new file mode 100644
index 000000000000..e2468e90c200
--- /dev/null
+++ b/litellm-rust/crates/secrets-hashicorp/tests/secret_manager/writes.rs
@@ -0,0 +1,542 @@
+use super::*;
+
+#[rstest]
+#[tokio::test]
+async fn write_and_delete_invalidate_the_read_cache(token_values: Vec<(&str, &str)>) {
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    let server = MockServer::start().await;
+    let revision = Arc::new(AtomicUsize::new(0));
+    let current = revision.clone();
+    Mock::given(method("GET"))
+        .and(path("/v1/secret/data/name"))
+        .respond_with(
+            move |_: &wiremock::Request| match current.load(Ordering::SeqCst) {
+                0 => ResponseTemplate::new(200).set_body_json(read_response(
+                    json!({"key": "old", "alternate": "old-alternate"}),
+                )),
+                1 => ResponseTemplate::new(200).set_body_json(read_response(
+                    json!({"key": "updated", "alternate": "updated-alternate"}),
+                )),
+                _ => ResponseTemplate::new(404).set_body_json(json!({"errors": ["missing"]})),
+            },
+        )
+        .expect(5)
+        .mount(&server)
+        .await;
+    Mock::given(method("GET"))
+        .and(path("/v1/secret/data/unrelated"))
+        .respond_with(
+            ResponseTemplate::new(200).set_body_json(read_response(json!({"key": "unrelated"}))),
+        )
+        .expect(1)
+        .mount(&server)
+        .await;
+    let written = revision.clone();
+    Mock::given(method("POST"))
+        .and(path("/v1/secret/data/name"))
+        .respond_with(move |_: &wiremock::Request| {
+            written.store(1, Ordering::SeqCst);
+            ResponseTemplate::new(200).set_body_json(write_response(2))
+        })
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(method("DELETE"))
+        .and(path("/v1/secret/data/name"))
+        .respond_with(move |_: &wiremock::Request| {
+            revision.store(2, Ordering::SeqCst);
+            ResponseTemplate::new(204)
+        })
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager = manager(&server, &token_values);
+    let alternate = HashicorpOperationContext {
+        data_key: Some("alternate".into()),
+        ..Default::default()
+    };
+    assert_eq!(
+        manager
+            .async_read_secret("name")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "old"
+    );
+    assert_eq!(
+        BaseSecretManager::async_read_secret(&manager, "name", &alternate)
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "old-alternate"
+    );
+    assert_eq!(
+        manager
+            .async_read_secret("unrelated")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "unrelated"
+    );
+    manager
+        .async_write_secret("name", SecretValue::new("updated"), None)
+        .await
+        .unwrap();
+    assert_eq!(
+        manager
+            .async_read_secret("name")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "updated"
+    );
+    assert_eq!(
+        BaseSecretManager::async_read_secret(&manager, "name", &alternate)
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "updated-alternate"
+    );
+    manager.async_delete_secret("name").await.unwrap();
+    assert!(manager.async_read_secret("name").await.unwrap().is_none());
+    assert_eq!(
+        manager
+            .async_read_secret("unrelated")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "unrelated"
+    );
+}
+
+#[rstest]
+#[case::existing(200, 2)]
+#[case::new_secret(404, 0)]
+#[tokio::test]
+async fn cas_required_writes_retry_with_the_current_version(
+    token_values: Vec<(&str, &str)>,
+    #[case] metadata_status: u16,
+    #[case] expected_cas: u64,
+) {
+    let server: MockServer = MockServer::start().await;
+    Mock::given(method("POST"))
+        .and(path("/v1/secret/data/name"))
+        .and(body_json(json!({"data": {"key": "value"}})))
+        .respond_with(ResponseTemplate::new(400).set_body_json(json!({"errors": ["CAS required"]})))
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(method("GET"))
+        .and(path("/v1/secret/metadata/name"))
+        .respond_with(
+            ResponseTemplate::new(metadata_status).set_body_json(metadata_response(expected_cas)),
+        )
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(method("POST"))
+        .and(path("/v1/secret/data/name"))
+        .and(body_json(json!({
+            "data": {"key": "value"},
+            "options": {"cas": expected_cas}
+        })))
+        .respond_with(ResponseTemplate::new(200).set_body_json(write_response(expected_cas + 1)))
+        .expect(1)
+        .mount(&server)
+        .await;
+
+    let result = manager(&server, &token_values)
+        .async_write_secret("name", SecretValue::new("value"), None)
+        .await;
+
+    assert!(result.is_ok());
+}
+
+#[rstest]
+#[tokio::test]
+async fn failed_cas_lookup_preserves_the_write_error(token_values: Vec<(&str, &str)>) {
+    let server: MockServer = MockServer::start().await;
+    Mock::given(method("POST"))
+        .and(path("/v1/secret/data/name"))
+        .respond_with(
+            ResponseTemplate::new(400).set_body_json(json!({"errors": ["write rejected"]})),
+        )
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(method("GET"))
+        .and(path("/v1/secret/metadata/name"))
+        .respond_with(ResponseTemplate::new(403).set_body_json(json!({"errors": ["forbidden"]})))
+        .expect(1)
+        .mount(&server)
+        .await;
+
+    let result = manager(&server, &token_values)
+        .async_write_secret("name", SecretValue::new("value"), None)
+        .await;
+
+    assert!(matches!(result, Err(Error::Status { status: 400 })));
+}
+
+#[rstest]
+#[tokio::test]
+async fn rotation_applies_timeout_to_each_request(token_values: Vec<(&str, &str)>) {
+    let server = MockServer::start().await;
+    let timeout = Duration::from_secs(1);
+    let delay = timeout / 2;
+    Mock::given(method("GET"))
+        .and(header("X-Vault-Namespace", "team"))
+        .and(path("/v1/alternate/data/managed/current"))
+        .respond_with(
+            ResponseTemplate::new(200)
+                .set_delay(delay)
+                .set_body_json(read_response(json!({"api_token": "original"}))),
+        )
+        .mount(&server)
+        .await;
+    Mock::given(method("POST"))
+        .and(header("X-Vault-Namespace", "team"))
+        .and(path("/v1/alternate/data/managed/new"))
+        .and(body_json(json!({
+            "data": {"api_token": "replacement", "description": "Rotated from current"}
+        })))
+        .respond_with(
+            ResponseTemplate::new(200)
+                .set_delay(delay)
+                .set_body_json(json!({
+                    "data": {
+                        "created_time": "",
+                        "deletion_time": "",
+                        "custom_metadata": null,
+                        "destroyed": false,
+                        "version": 1
+                    },
+                    "lease_id": "",
+                    "lease_duration": 0,
+                    "renewable": false,
+                    "request_id": "",
+                    "warnings": null,
+                    "wrap_info": null
+                })),
+        )
+        .mount(&server)
+        .await;
+    Mock::given(method("GET"))
+        .and(header("X-Vault-Namespace", "team"))
+        .and(path("/v1/alternate/data/managed/new"))
+        .respond_with(
+            ResponseTemplate::new(200)
+                .set_delay(delay)
+                .set_body_json(read_response(json!({"api_token": "replacement"}))),
+        )
+        .mount(&server)
+        .await;
+    Mock::given(method("DELETE"))
+        .and(header("X-Vault-Namespace", "team"))
+        .and(path("/v1/alternate/data/managed/current"))
+        .respond_with(ResponseTemplate::new(204).set_delay(delay))
+        .mount(&server)
+        .await;
+    let manager = manager(&server, &token_values);
+    let context = HashicorpOperationContext {
+        namespace: Some("team".into()),
+        timeout: Some(timeout),
+        mount: Some("alternate".to_owned()),
+        path_prefix: Some("managed".to_owned()),
+        data_key: Some("api_token".to_owned()),
+    };
+
+    manager
+        .async_rotate_secret_with_context(
+            "current",
+            "new",
+            &SecretValue::new("replacement"),
+            &context,
+        )
+        .await
+        .unwrap();
+    let requests = server.received_requests().await.unwrap();
+    let operations: Vec<_> = requests
+        .iter()
+        .map(|request| (request.method.as_str(), request.url.path()))
+        .collect();
+    assert_eq!(
+        operations,
+        [
+            ("GET", "/v1/alternate/data/managed/current"),
+            ("POST", "/v1/alternate/data/managed/new"),
+            ("GET", "/v1/alternate/data/managed/new"),
+            ("DELETE", "/v1/alternate/data/managed/current"),
+        ]
+    );
+}
+
+#[rstest]
+#[tokio::test]
+#[ignore]
+async fn live_vault_round_trip() {
+    let environment: Arc<dyn Lookup + Send + Sync> =
+        Arc::new(litellm_core_utils::settings::ProcessEnvironment);
+    let manager: HashicorpVault = HashicorpVault::new(environment, true).unwrap();
+    let name: String = std::env::var("LITELLM_VAULT_LIVE_SECRET_NAME").unwrap();
+    let value: SecretValue = SecretValue::new("native-live-value");
+    let location = manager.secret_location(&name).unwrap();
+    println!(
+        "native provenance: {} vaultrs {} {:?} {} {}",
+        module_path!(),
+        manager.config().address,
+        location.namespace,
+        location.mount,
+        location.path
+    );
+    manager
+        .async_write_secret(&name, value.clone(), None)
+        .await
+        .unwrap();
+    assert_eq!(
+        manager.async_read_secret(&name).await.unwrap().unwrap(),
+        value
+    );
+    let replacement = SecretValue::new("replacement-π\n");
+    manager
+        .async_write_secret(&name, replacement.clone(), None)
+        .await
+        .unwrap();
+    assert_eq!(
+        manager.async_read_secret(&name).await.unwrap().unwrap(),
+        replacement
+    );
+    manager.async_delete_secret(&name).await.unwrap();
+    assert!(manager.async_read_secret(&name).await.unwrap().is_none());
+}
+
+#[rstest]
+#[tokio::test]
+async fn same_name_rotation_keeps_the_replacement(token_values: Vec<(&str, &str)>) {
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    let server = MockServer::start().await;
+    let reads = AtomicUsize::new(0);
+    Mock::given(method("GET"))
+        .and(path("/v1/secret/data/name"))
+        .respond_with(move |_: &wiremock::Request| {
+            let value = if reads.fetch_add(1, Ordering::SeqCst) == 0 {
+                "original"
+            } else {
+                "replacement"
+            };
+            ResponseTemplate::new(200).set_body_json(read_response(json!({"key": value})))
+        })
+        .expect(2)
+        .mount(&server)
+        .await;
+    Mock::given(method("POST"))
+        .and(path("/v1/secret/data/name"))
+        .and(body_json(json!({"data": {"key": "replacement", "description": "Rotated from name"}})))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+            "data": {"created_time": "", "deletion_time": "", "custom_metadata": null, "destroyed": false, "version": 2},
+            "lease_id": "", "lease_duration": 0, "renewable": false, "request_id": "", "warnings": null, "wrap_info": null
+        }))).expect(1).mount(&server).await;
+    Mock::given(method("DELETE"))
+        .respond_with(ResponseTemplate::new(204))
+        .expect(0)
+        .mount(&server)
+        .await;
+    let manager = manager(&server, &token_values);
+    manager
+        .async_rotate_secret("name", "name", &SecretValue::new("replacement"))
+        .await
+        .unwrap();
+    assert_eq!(
+        manager
+            .async_read_secret("name")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "replacement"
+    );
+}
+
+#[rstest]
+#[case::verification(false)]
+#[case::retirement(true)]
+#[tokio::test]
+async fn rotation_reports_partial_completion_without_losing_the_write_response(
+    token_values: Vec<(&str, &str)>,
+    #[case] verified: bool,
+) {
+    let server = MockServer::start().await;
+    Mock::given(method("GET"))
+        .and(path("/v1/secret/data/old"))
+        .respond_with(
+            ResponseTemplate::new(200).set_body_json(read_response(json!({"key": "old"}))),
+        )
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(method("POST"))
+        .and(path("/v1/secret/data/new"))
+        .respond_with(ResponseTemplate::new(200).set_body_json(write_response(2)))
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(method("GET"))
+        .and(path("/v1/secret/data/new"))
+        .respond_with(ResponseTemplate::new(200).set_body_json(read_response(
+            json!({"key": if verified { "replacement" } else { "stale" }}),
+        )))
+        .expect(1)
+        .mount(&server)
+        .await;
+    Mock::given(method("DELETE"))
+        .and(path("/v1/secret/data/old"))
+        .respond_with(ResponseTemplate::new(403).set_body_json(json!({"errors": ["denied"]})))
+        .expect(u64::from(verified))
+        .mount(&server)
+        .await;
+    let result = manager(&server, &token_values)
+        .async_rotate_secret("old", "new", &SecretValue::new("replacement"))
+        .await;
+    match result {
+        Err(RotationError::Verification { response, source }) if !verified => {
+            assert_eq!(response["version"], 2);
+            assert!(matches!(
+                source,
+                Error::Operation(litellm_secrets_types::Error::NewSecretMismatch)
+            ));
+        }
+        Err(RotationError::Retirement { response, source }) if verified => {
+            assert_eq!(response["version"], 2);
+            assert!(matches!(source, Error::Status { status: 403 }));
+        }
+        other => panic!("unexpected rotation outcome: {other:?}"),
+    }
+}
+
+#[rstest]
+#[case::different_namespace(
+    " /team-b/ ",
+    " /alternate/ ",
+    " /prefix/ ",
+    Some("team-b"),
+    "/v1/alternate/data/prefix/key"
+)]
+#[case::clear_namespace("", "", "", None, "/v1/secret/data/key")]
+#[tokio::test]
+async fn operation_overrides_isolate_cached_targets_and_apply_to_writes_and_deletes(
+    #[case] namespace: &str,
+    #[case] mount: &str,
+    #[case] prefix: &str,
+    #[case] expected_namespace: Option<&str>,
+    #[case] expected_path: &'static str,
+) {
+    let server = MockServer::start().await;
+    Mock::given(method("GET"))
+        .and(path("/v1/configured/data/configured/key"))
+        .and(header("X-Vault-Namespace", "team-a"))
+        .respond_with(
+            ResponseTemplate::new(200).set_body_json(read_response(json!({"key":"default-value"}))),
+        )
+        .expect(1)
+        .mount(&server)
+        .await;
+    let namespace_header = expected_namespace.map(str::to_owned);
+    Mock::given(path(expected_path))
+        .respond_with(move |request: &wiremock::Request| {
+            assert_eq!(
+                request
+                    .headers
+                    .get("X-Vault-Namespace")
+                    .map(|value| value.to_str().unwrap()),
+                namespace_header.as_deref()
+            );
+            match request.method.as_str() {
+                "GET" => ResponseTemplate::new(200)
+                    .set_body_json(read_response(json!({"password":"override-value"}))),
+                "POST" => {
+                    assert_eq!(
+                        request.body_json::<serde_json::Value>().unwrap(),
+                        json!({"data":{"password":"written"}})
+                    );
+                    ResponseTemplate::new(200).set_body_json(write_response(2))
+                }
+                "DELETE" => ResponseTemplate::new(204),
+                _ => panic!("unexpected method"),
+            }
+        })
+        .expect(4)
+        .mount(&server)
+        .await;
+    let manager = manager(
+        &server,
+        &[
+            ("HCP_VAULT_TOKEN", "token"),
+            ("HCP_VAULT_SECRET_NAMESPACE", "team-a"),
+            ("HCP_VAULT_MOUNT_NAME", "configured"),
+            ("HCP_VAULT_PATH_PREFIX", "configured"),
+        ],
+    );
+    let context = HashicorpOperationContext {
+        namespace: Some(namespace.into()),
+        mount: Some(mount.into()),
+        path_prefix: Some(prefix.into()),
+        data_key: Some("password".into()),
+        ..Default::default()
+    };
+    for _ in 0..2 {
+        assert_eq!(
+            manager
+                .async_read_secret("key")
+                .await
+                .unwrap()
+                .unwrap()
+                .expose(),
+            "default-value"
+        );
+        assert_eq!(
+            BaseSecretManager::async_read_secret(&manager, "key", &context)
+                .await
+                .unwrap()
+                .unwrap()
+                .expose(),
+            "override-value"
+        );
+    }
+    SecretWriter::async_write_secret(
+        &manager,
+        "key",
+        &SecretValue::new("written"),
+        &SecretWriteContext {
+            operation: context.clone(),
+            ..Default::default()
+        },
+    )
+    .await
+    .unwrap();
+    SecretDeleter::async_delete_secret(&manager, "key", &context)
+        .await
+        .unwrap();
+    assert_eq!(
+        BaseSecretManager::async_read_secret(&manager, "key", &context)
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "override-value"
+    );
+    assert_eq!(
+        manager
+            .async_read_secret("key")
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "default-value"
+    );
+}
diff --git a/litellm-rust/crates/secrets-types/Cargo.toml b/litellm-rust/crates/secrets-types/Cargo.toml
index acd297467229..dcd06d1a7411 100644
--- a/litellm-rust/crates/secrets-types/Cargo.toml
+++ b/litellm-rust/crates/secrets-types/Cargo.toml
@@ -7,6 +7,8 @@ repository.workspace = true
 
 [dependencies]
 litellm-auth-types.workspace = true
+moka.workspace = true
+tokio = { workspace = true, features = ["sync"] }
 serde.workspace = true
 serde_json.workspace = true
 thiserror.workspace = true
diff --git a/litellm-rust/crates/secrets-types/src/base_secret_manager.rs b/litellm-rust/crates/secrets-types/src/base_secret_manager.rs
index e8aed9f280ea..737fad286620 100644
--- a/litellm-rust/crates/secrets-types/src/base_secret_manager.rs
+++ b/litellm-rust/crates/secrets-types/src/base_secret_manager.rs
@@ -1,4 +1,4 @@
-use crate::{Error, SecretOperationContext, SecretValue, SecretWriteContext};
+use crate::{Error, SecretValue, SecretWriteContext};
 
 pub fn validate_secret_name(name: &str) -> Result<(), Error> {
     if name.split('/').any(|segment| segment == "..")
@@ -11,64 +11,114 @@ pub fn validate_secret_name(name: &str) -> Result<(), Error> {
     Ok(())
 }
 
-#[expect(
-    async_fn_in_trait,
-    reason = "closed backend dispatch does not require Send bounds on generic rotation"
-)]
 pub trait BaseSecretManager {
     type Error: From<Error>;
+    type Context: Clone + Default + Send + Sync;
+
+    fn async_read_secret(
+        &self,
+        name: &str,
+        context: &Self::Context,
+    ) -> impl std::future::Future<Output = Result<Option<SecretValue>, Self::Error>> + Send;
+}
+
+pub trait SecretWriter: BaseSecretManager {
     type WriteResponse;
-    type DeleteResponse;
 
-    async fn async_read_secret(
+    fn async_write_secret(
         &self,
         name: &str,
-        context: &SecretOperationContext,
-    ) -> Result<Option<SecretValue>, Self::Error>;
-    async fn async_write_secret(
+        value: &SecretValue,
+        context: &SecretWriteContext<Self::Context>,
+    ) -> impl std::future::Future<Output = Result<Self::WriteResponse, Self::Error>> + Send;
+}
+
+pub trait SecretDeleter: BaseSecretManager {
+    type DeleteResponse;
+
+    fn async_delete_secret(
         &self,
         name: &str,
+        context: &Self::Context,
+    ) -> impl std::future::Future<Output = Result<Self::DeleteResponse, Self::Error>> + Send;
+}
+
+pub trait SecretRotator: SecretDeleter {
+    type RotationResponse;
+
+    fn async_write_replacement(
+        &self,
+        current_name: &str,
+        new_name: &str,
         value: &SecretValue,
-        context: &SecretWriteContext,
-    ) -> Result<Self::WriteResponse, Self::Error>;
-    async fn async_delete_secret(
+        context: &Self::Context,
+    ) -> impl std::future::Future<Output = Result<Self::RotationResponse, Self::Error>> + Send;
+
+    fn async_read_secret_fresh(
         &self,
         name: &str,
-        recovery_window_in_days: Option<u32>,
-        context: &SecretOperationContext,
-    ) -> Result<Self::DeleteResponse, Self::Error>;
+        context: &Self::Context,
+    ) -> impl std::future::Future<Output = Result<Option<SecretValue>, Self::Error>> + Send;
 }
 
-pub async fn async_rotate_secret<M: BaseSecretManager>(
+#[derive(Debug, PartialEq, Eq, thiserror::Error)]
+pub enum RotationError<R, E> {
+    #[error("could not read the current secret")]
+    Read(#[source] E),
+    #[error("replacement write failed; provider state may be unknown")]
+    Write(#[source] E),
+    #[error("replacement was written but could not be verified")]
+    Verification {
+        response: Box<R>,
+        #[source]
+        source: E,
+    },
+    #[error("replacement was verified but retiring the old secret failed")]
+    Retirement {
+        response: Box<R>,
+        #[source]
+        source: E,
+    },
+}
+
+pub async fn async_rotate_secret<M: SecretRotator>(
     manager: &M,
     current_name: &str,
     new_name: &str,
     value: &SecretValue,
-    context: &SecretOperationContext,
-) -> Result<M::WriteResponse, M::Error> {
+    context: &M::Context,
+) -> Result<M::RotationResponse, RotationError<M::RotationResponse, M::Error>> {
     if manager
-        .async_read_secret(current_name, context)
-        .await?
+        .async_read_secret_fresh(current_name, context)
+        .await
+        .map_err(RotationError::Read)?
         .is_none()
     {
-        return Err(Error::CurrentSecretMissing.into());
+        return Err(RotationError::Read(Error::CurrentSecretMissing.into()));
     }
     let response = manager
-        .async_write_secret(
-            new_name,
-            value,
-            &SecretWriteContext::rotated_from(current_name, context.clone()),
-        )
-        .await?;
-    if manager
-        .async_read_secret(new_name, context)
-        .await?
-        .is_none()
+        .async_write_replacement(current_name, new_name, value, context)
+        .await
+        .map_err(RotationError::Write)?;
+    let verification = match manager.async_read_secret_fresh(new_name, context).await {
+        Ok(None) => Err(Error::NewSecretMissing.into()),
+        Ok(Some(actual)) if actual != *value => Err(Error::NewSecretMismatch.into()),
+        Ok(Some(_)) => Ok(()),
+        Err(error) => Err(error),
+    };
+    if let Err(source) = verification {
+        return Err(RotationError::Verification {
+            response: Box::new(response),
+            source,
+        });
+    }
+    if current_name != new_name
+        && let Err(source) = manager.async_delete_secret(current_name, context).await
     {
-        return Err(Error::NewSecretMissing.into());
+        return Err(RotationError::Retirement {
+            response: Box::new(response),
+            source,
+        });
     }
-    manager
-        .async_delete_secret(current_name, Some(7), context)
-        .await?;
     Ok(response)
 }
diff --git a/litellm-rust/crates/secrets-types/src/cache.rs b/litellm-rust/crates/secrets-types/src/cache.rs
new file mode 100644
index 000000000000..524de1ed2f17
--- /dev/null
+++ b/litellm-rust/crates/secrets-types/src/cache.rs
@@ -0,0 +1,73 @@
+use std::{future::Future, hash::Hash, sync::Arc, time::Duration};
+
+use moka::future::Cache;
+use tokio::sync::Mutex;
+
+#[derive(Clone)]
+pub struct SecretCache<K, V> {
+    entries: Cache<K, Arc<Mutex<Option<V>>>>,
+}
+
+impl<K, V> SecretCache<K, V>
+where
+    K: Eq + Hash + Clone + Send + Sync + 'static,
+    V: Clone + Send + Sync + 'static,
+{
+    pub fn new(capacity: u64, ttl: Duration) -> Self {
+        Self {
+            entries: Cache::builder()
+                .max_capacity(capacity)
+                .time_to_live(ttl)
+                .support_invalidation_closures()
+                .build(),
+        }
+    }
+
+    pub async fn read<E>(
+        &self,
+        key: K,
+        load: impl Future<Output = Result<Option<V>, E>>,
+    ) -> Result<Option<V>, E> {
+        let entry = self
+            .entries
+            .get_with(key, async { Arc::new(Mutex::new(None)) })
+            .await;
+        let mut value = entry.lock().await;
+        if value.is_some() {
+            return Ok(value.clone());
+        }
+        // Invalidated loads only populate their detached entry, never the cache's replacement.
+        let loaded = load.await?;
+        *value = loaded.clone();
+        Ok(loaded)
+    }
+
+    pub async fn invalidate(&self, key: &K) {
+        self.entries.invalidate(key).await;
+    }
+
+    pub async fn refresh<E>(
+        &self,
+        key: K,
+        load: impl Future<Output = Result<Option<V>, E>>,
+    ) -> Result<Option<V>, E> {
+        let entry = Arc::new(Mutex::new(None));
+        let mut value = entry.lock().await;
+        self.entries.insert(key, entry.clone()).await;
+        let loaded = load.await?;
+        *value = loaded.clone();
+        Ok(loaded)
+    }
+
+    pub async fn insert(&self, key: K, value: V) {
+        self.entries
+            .insert(key, Arc::new(Mutex::new(Some(value))))
+            .await;
+    }
+
+    pub fn invalidate_where(&self, predicate: impl Fn(&K) -> bool + Send + Sync + 'static) {
+        self.entries
+            .invalidate_entries_if(move |key, _| predicate(key))
+            .expect("invalidation closures are enabled");
+    }
+}
diff --git a/litellm-rust/crates/secrets-types/src/context.rs b/litellm-rust/crates/secrets-types/src/context.rs
index 126815ab32b0..1ec493edf429 100644
--- a/litellm-rust/crates/secrets-types/src/context.rs
+++ b/litellm-rust/crates/secrets-types/src/context.rs
@@ -1,21 +1,41 @@
 use std::{collections::BTreeMap, time::Duration};
 
-use crate::SecretValue;
+use crate::{Error, KeyManagementSystem, SecretValue};
 
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub enum SecretOperationContext {
     #[default]
     Default,
     Aws(AwsOperationContext),
+    Azure(AzureOperationContext),
+    Google(GoogleOperationContext),
     Hashicorp(HashicorpOperationContext),
     Cyberark(CyberarkOperationContext),
 }
 
 impl SecretOperationContext {
+    pub fn validate_for(&self, system: KeyManagementSystem) -> Result<(), Error> {
+        let compatible = match self {
+            Self::Default => true,
+            Self::Aws(_) => system == KeyManagementSystem::AwsSecretManager,
+            Self::Azure(_) => system == KeyManagementSystem::AzureKeyVault,
+            Self::Google(_) => system == KeyManagementSystem::GoogleSecretManager,
+            Self::Hashicorp(_) => system == KeyManagementSystem::HashicorpVault,
+            Self::Cyberark(_) => system == KeyManagementSystem::Cyberark,
+        };
+        if compatible {
+            Ok(())
+        } else {
+            Err(Error::InvalidOperationContext)
+        }
+    }
+
     pub fn timeout(&self) -> Option<Duration> {
         match self {
             Self::Default => None,
             Self::Aws(context) => context.timeout,
+            Self::Azure(context) => context.timeout,
+            Self::Google(context) => context.timeout,
             Self::Hashicorp(context) => context.timeout,
             Self::Cyberark(context) => context.timeout,
         }
@@ -24,6 +44,9 @@ impl SecretOperationContext {
 
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct AwsOperationContext {
+    pub access_key_id: Option<SecretValue>,
+    pub secret_access_key: Option<SecretValue>,
+    pub session_token: Option<SecretValue>,
     pub timeout: Option<Duration>,
     pub region_name: Option<String>,
     pub role_name: Option<String>,
@@ -32,10 +55,12 @@ pub struct AwsOperationContext {
     pub profile_name: Option<String>,
     pub web_identity_token: Option<SecretValue>,
     pub sts_endpoint: Option<String>,
+    pub bedrock_runtime_endpoint: Option<String>,
 }
 
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct HashicorpOperationContext {
+    pub namespace: Option<String>,
     pub timeout: Option<Duration>,
     pub mount: Option<String>,
     pub path_prefix: Option<String>,
@@ -48,14 +73,14 @@ pub struct CyberarkOperationContext {
 }
 
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
-pub struct SecretWriteContext {
+pub struct SecretWriteContext<C = SecretOperationContext> {
     pub description: Option<String>,
     pub tags: BTreeMap<String, String>,
-    pub operation: SecretOperationContext,
+    pub operation: C,
 }
 
-impl SecretWriteContext {
-    pub fn rotated_from(current_name: &str, operation: SecretOperationContext) -> Self {
+impl<C> SecretWriteContext<C> {
+    pub fn rotated_from(current_name: &str, operation: C) -> Self {
         Self {
             description: Some(format!("Rotated from {current_name}")),
             tags: BTreeMap::new(),
@@ -63,3 +88,13 @@ impl SecretWriteContext {
         }
     }
 }
+
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub struct AzureOperationContext {
+    pub timeout: Option<Duration>,
+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub struct GoogleOperationContext {
+    pub timeout: Option<Duration>,
+}
diff --git a/litellm-rust/crates/secrets-types/src/error.rs b/litellm-rust/crates/secrets-types/src/error.rs
index cae9c7f4c695..027dd54d8cc8 100644
--- a/litellm-rust/crates/secrets-types/src/error.rs
+++ b/litellm-rust/crates/secrets-types/src/error.rs
@@ -6,4 +6,8 @@ pub enum Error {
     CurrentSecretMissing,
     #[error("new secret could not be verified")]
     NewSecretMissing,
+    #[error("new secret does not match the replacement")]
+    NewSecretMismatch,
+    #[error("secret manager received an incompatible operation context")]
+    InvalidOperationContext,
 }
diff --git a/litellm-rust/crates/secrets-types/src/lib.rs b/litellm-rust/crates/secrets-types/src/lib.rs
index d330fc7bbeaf..4d7eaf8313ea 100644
--- a/litellm-rust/crates/secrets-types/src/lib.rs
+++ b/litellm-rust/crates/secrets-types/src/lib.rs
@@ -1,17 +1,22 @@
 #![forbid(unsafe_code)]
 
 mod base_secret_manager;
+mod cache;
 mod config;
 mod context;
 mod error;
 mod value;
 
-pub use base_secret_manager::{BaseSecretManager, async_rotate_secret, validate_secret_name};
+pub use base_secret_manager::{
+    BaseSecretManager, RotationError, SecretDeleter, SecretRotator, SecretWriter,
+    async_rotate_secret, validate_secret_name,
+};
+pub use cache::SecretCache;
 pub use config::{AccessMode, KeyManagementSettings, KeyManagementSystem};
 pub use context::{
-    AwsOperationContext, CyberarkOperationContext, HashicorpOperationContext,
-    SecretOperationContext, SecretWriteContext,
+    AwsOperationContext, AzureOperationContext, CyberarkOperationContext, GoogleOperationContext,
+    HashicorpOperationContext, SecretOperationContext, SecretWriteContext,
 };
 pub use error::Error;
 pub use litellm_auth_types::SecretValue;
-pub use value::Secret;
+pub use value::{PythonSecretRead, Secret};
diff --git a/litellm-rust/crates/secrets-types/src/value.rs b/litellm-rust/crates/secrets-types/src/value.rs
index 087537fb3eb7..11f57ef4448a 100644
--- a/litellm-rust/crates/secrets-types/src/value.rs
+++ b/litellm-rust/crates/secrets-types/src/value.rs
@@ -7,6 +7,12 @@ pub enum Secret {
     Json(#[redact] serde_json::Value),
 }
 
+#[derive(Debug)]
+pub enum PythonSecretRead {
+    Value(Option<Secret>),
+    PrimaryJson(SecretValue),
+}
+
 impl From<SecretValue> for Secret {
     fn from(value: SecretValue) -> Self {
         Self::String(value)
diff --git a/litellm-rust/crates/secrets-types/tests/cache.rs b/litellm-rust/crates/secrets-types/tests/cache.rs
new file mode 100644
index 000000000000..cec4f5198e38
--- /dev/null
+++ b/litellm-rust/crates/secrets-types/tests/cache.rs
@@ -0,0 +1,162 @@
+use std::{convert::Infallible, time::Duration};
+
+use litellm_secrets_types::SecretCache;
+use rstest::rstest;
+use tokio::sync::oneshot;
+
+#[rstest]
+#[case::delete(false)]
+#[case::write(true)]
+#[tokio::test]
+async fn an_old_load_cannot_restore_a_mutated_entry(#[case] write: bool) {
+    let cache = SecretCache::new(10, Duration::from_secs(60));
+    let (started, loading) = oneshot::channel();
+    let (release, finish) = oneshot::channel();
+    let old = cache.read("key", async {
+        started.send(()).unwrap();
+        finish.await.unwrap();
+        Ok::<_, Infallible>(Some("old"))
+    });
+    let mutation = async {
+        loading.await.unwrap();
+        if write {
+            cache.insert("key", "new").await;
+        } else {
+            cache.invalidate(&"key").await;
+        }
+        release.send(()).unwrap();
+    };
+    let (old_result, ()) = tokio::join!(old, mutation);
+    assert_eq!(old_result.unwrap(), Some("old"));
+    let current = cache
+        .read("key", async { Ok::<_, Infallible>(None) })
+        .await
+        .unwrap();
+    assert_eq!(current, write.then_some("new"));
+}
+
+#[tokio::test]
+async fn location_invalidation_detaches_all_projections_and_keeps_other_secrets() {
+    let cache = SecretCache::new(10, Duration::from_secs(60));
+    cache.insert(("target", "first"), "old").await;
+    cache.insert(("unrelated", "first"), "retained").await;
+    let (started, loading) = oneshot::channel();
+    let (release, finish) = oneshot::channel();
+    let old = cache.read(("target", "second"), async {
+        started.send(()).unwrap();
+        finish.await.unwrap();
+        Ok::<_, Infallible>(Some("old"))
+    });
+    let mutation = async {
+        loading.await.unwrap();
+        cache.invalidate_where(|(location, _)| *location == "target");
+        release.send(()).unwrap();
+    };
+    let (result, ()) = tokio::join!(old, mutation);
+    assert_eq!(result.unwrap(), Some("old"));
+    for projection in ["first", "second"] {
+        assert_eq!(
+            cache
+                .read(("target", projection), async { Ok::<_, Infallible>(None) })
+                .await
+                .unwrap(),
+            None
+        );
+    }
+    assert_eq!(
+        cache
+            .read(("unrelated", "first"), async { Ok::<_, Infallible>(None) })
+            .await
+            .unwrap(),
+        Some("retained")
+    );
+}
+
+#[tokio::test]
+async fn concurrent_misses_share_a_load_and_cancellation_allows_a_retry() {
+    let cache = SecretCache::new(10, Duration::from_secs(60));
+    let (started, loading) = oneshot::channel();
+    let (release, finish) = oneshot::channel();
+    let first = cache.read("key", async {
+        started.send(()).unwrap();
+        finish.await.unwrap();
+        Ok::<_, Infallible>(Some("value"))
+    });
+    let second = async {
+        loading.await.unwrap();
+        release.send(()).unwrap();
+        cache.read("key", async { panic!("duplicate load") }).await
+    };
+    let (first, second): (_, Result<_, Infallible>) = tokio::join!(first, second);
+    assert_eq!(first.unwrap(), Some("value"));
+    assert_eq!(second.unwrap(), Some("value"));
+
+    let (started, loading) = oneshot::channel();
+    let cancelled = cache.read("cancelled", async {
+        started.send(()).unwrap();
+        std::future::pending::<Result<Option<&str>, Infallible>>().await
+    });
+    tokio::select! {
+        _ = loading => {},
+        _ = cancelled => panic!("load must remain pending"),
+    }
+    assert_eq!(
+        cache
+            .read("cancelled", async { Ok::<_, Infallible>(Some("retry")) })
+            .await
+            .unwrap(),
+        Some("retry")
+    );
+}
+
+#[tokio::test]
+async fn refresh_bypasses_cached_values_and_errors_and_absence_are_retried() {
+    let cache = SecretCache::new(10, Duration::from_secs(60));
+    cache.insert("key", "old").await;
+    assert_eq!(
+        cache
+            .refresh("key", async { Ok::<_, Infallible>(Some("fresh")) })
+            .await
+            .unwrap(),
+        Some("fresh")
+    );
+    assert_eq!(
+        cache
+            .read("key", async { Ok::<_, Infallible>(None) })
+            .await
+            .unwrap(),
+        Some("fresh")
+    );
+    for result in [Err("failure"), Ok(None), Ok(Some("recovered"))] {
+        assert_eq!(cache.read("retry", async { result }).await, result);
+    }
+}
+
+#[tokio::test]
+async fn expired_entries_reload_and_empty_values_are_cached() {
+    let cache = SecretCache::new(10, Duration::from_secs(60));
+    assert_eq!(
+        cache
+            .read("empty", async { Ok::<_, Infallible>(Some("")) })
+            .await
+            .unwrap(),
+        Some("")
+    );
+    assert_eq!(
+        cache
+            .read("empty", async { Ok::<_, Infallible>(Some("changed")) })
+            .await
+            .unwrap(),
+        Some("")
+    );
+    let expiring = SecretCache::new(10, Duration::from_nanos(1));
+    expiring.insert("key", "old").await;
+    tokio::time::sleep(Duration::from_millis(1)).await;
+    assert_eq!(
+        expiring
+            .read("key", async { Ok::<_, Infallible>(Some("new")) })
+            .await
+            .unwrap(),
+        Some("new")
+    );
+}
diff --git a/litellm-rust/crates/secrets-types/tests/context.rs b/litellm-rust/crates/secrets-types/tests/context.rs
index 7c9e91b3a9e5..a167e87954f9 100644
--- a/litellm-rust/crates/secrets-types/tests/context.rs
+++ b/litellm-rust/crates/secrets-types/tests/context.rs
@@ -1,8 +1,9 @@
 use std::{collections::BTreeMap, time::Duration};
 
 use litellm_secrets_types::{
-    AwsOperationContext, CyberarkOperationContext, HashicorpOperationContext,
-    SecretOperationContext, SecretValue, SecretWriteContext,
+    AwsOperationContext, AzureOperationContext, CyberarkOperationContext, GoogleOperationContext,
+    HashicorpOperationContext, KeyManagementSystem, SecretOperationContext, SecretValue,
+    SecretWriteContext,
 };
 use rstest::{fixture, rstest};
 
@@ -108,3 +109,40 @@ fn rotation_write_context_preserves_the_operation_context(aws_context: SecretOpe
     assert!(context.tags.is_empty());
     assert_eq!(context.operation, aws_context);
 }
+
+#[rstest]
+#[case(
+    KeyManagementSystem::AwsSecretManager,
+    SecretOperationContext::Aws(Default::default())
+)]
+#[case(KeyManagementSystem::AzureKeyVault, SecretOperationContext::Azure(AzureOperationContext { timeout: Some(Duration::from_secs(1)) }))]
+#[case(KeyManagementSystem::GoogleSecretManager, SecretOperationContext::Google(GoogleOperationContext { timeout: Some(Duration::from_secs(1)) }))]
+#[case(
+    KeyManagementSystem::HashicorpVault,
+    SecretOperationContext::Hashicorp(Default::default())
+)]
+#[case(
+    KeyManagementSystem::Cyberark,
+    SecretOperationContext::Cyberark(Default::default())
+)]
+fn provider_context_accepts_only_its_owner(
+    #[case] owner: KeyManagementSystem,
+    #[case] context: SecretOperationContext,
+) {
+    for system in [
+        KeyManagementSystem::AwsSecretManager,
+        KeyManagementSystem::AzureKeyVault,
+        KeyManagementSystem::GoogleSecretManager,
+        KeyManagementSystem::HashicorpVault,
+        KeyManagementSystem::Cyberark,
+    ] {
+        assert_eq!(context.validate_for(system).is_ok(), system == owner);
+        assert!(SecretOperationContext::Default.validate_for(system).is_ok());
+    }
+    if matches!(
+        owner,
+        KeyManagementSystem::AzureKeyVault | KeyManagementSystem::GoogleSecretManager
+    ) {
+        assert_eq!(context.timeout(), Some(Duration::from_secs(1)));
+    }
+}
diff --git a/litellm-rust/crates/secrets-types/tests/rotation.rs b/litellm-rust/crates/secrets-types/tests/rotation.rs
index 1bc5e0a9eeb4..36c1a065ffa6 100644
--- a/litellm-rust/crates/secrets-types/tests/rotation.rs
+++ b/litellm-rust/crates/secrets-types/tests/rotation.rs
@@ -1,23 +1,53 @@
 use std::sync::atomic::{AtomicUsize, Ordering};
 
 use litellm_secrets_types::{
-    BaseSecretManager, Error, HashicorpOperationContext, SecretOperationContext, SecretValue,
-    SecretWriteContext, async_rotate_secret, validate_secret_name,
+    BaseSecretManager, Error, HashicorpOperationContext, RotationError, SecretDeleter,
+    SecretOperationContext, SecretRotator, SecretValue, SecretWriteContext, SecretWriter,
+    async_rotate_secret, validate_secret_name,
 };
 use rstest::{fixture, rstest};
 
 struct Manager {
     step: AtomicUsize,
     absent_at: Option<usize>,
+    verified_value: &'static str,
     operation: SecretOperationContext,
+    delete_error: bool,
+    fail_at: Option<usize>,
 }
 
 impl BaseSecretManager for Manager {
     type Error = Error;
-    type WriteResponse = &'static str;
-    type DeleteResponse = ();
+    type Context = SecretOperationContext;
 
     async fn async_read_secret(
+        &self,
+        _name: &str,
+        _context: &Self::Context,
+    ) -> Result<Option<SecretValue>, Error> {
+        panic!("rotation must bypass cached reads")
+    }
+}
+
+impl SecretRotator for Manager {
+    type RotationResponse = &'static str;
+
+    async fn async_write_replacement(
+        &self,
+        current_name: &str,
+        new_name: &str,
+        value: &SecretValue,
+        context: &Self::Context,
+    ) -> Result<Self::RotationResponse, Error> {
+        self.async_write_secret(
+            new_name,
+            value,
+            &SecretWriteContext::rotated_from(current_name, context.clone()),
+        )
+        .await
+    }
+
+    async fn async_read_secret_fresh(
         &self,
         name: &str,
         context: &SecretOperationContext,
@@ -25,8 +55,21 @@ impl BaseSecretManager for Manager {
         assert_eq!(context, &self.operation);
         let step = self.step.fetch_add(1, Ordering::SeqCst);
         assert_eq!(name, if step == 0 { "old" } else { "new" });
-        Ok((self.absent_at != Some(step)).then(|| SecretValue::new("value")))
+        if self.fail_at == Some(step) {
+            return Err(Error::UnsafeSecretName);
+        }
+        Ok((self.absent_at != Some(step)).then(|| {
+            SecretValue::new(if step == 0 {
+                "value"
+            } else {
+                self.verified_value
+            })
+        }))
     }
+}
+
+impl SecretWriter for Manager {
+    type WriteResponse = &'static str;
 
     async fn async_write_secret(
         &self,
@@ -35,6 +78,9 @@ impl BaseSecretManager for Manager {
         context: &SecretWriteContext,
     ) -> Result<Self::WriteResponse, Error> {
         assert_eq!(self.step.fetch_add(1, Ordering::SeqCst), 1);
+        if self.fail_at == Some(1) {
+            return Err(Error::UnsafeSecretName);
+        }
         assert_eq!(name, "new");
         assert_eq!(value.expose(), "replacement");
         assert_eq!(context.description.as_deref(), Some("Rotated from old"));
@@ -42,18 +88,24 @@ impl BaseSecretManager for Manager {
         assert_eq!(context.operation, self.operation);
         Ok("provider-response")
     }
+}
+
+impl SecretDeleter for Manager {
+    type DeleteResponse = ();
 
     async fn async_delete_secret(
         &self,
         name: &str,
-        recovery_window_in_days: Option<u32>,
         context: &SecretOperationContext,
     ) -> Result<(), Error> {
         assert_eq!(self.step.fetch_add(1, Ordering::SeqCst), 3);
         assert_eq!(name, "old");
-        assert_eq!(recovery_window_in_days, Some(7));
         assert_eq!(context, &self.operation);
-        Ok(())
+        if self.delete_error {
+            Err(Error::UnsafeSecretName)
+        } else {
+            Ok(())
+        }
     }
 }
 
@@ -75,7 +127,10 @@ async fn rotation_verifies_before_deleting_and_returns_provider_response(
 ) {
     let manager = Manager {
         step: AtomicUsize::new(0),
+        delete_error: false,
+        fail_at: None,
         absent_at: None,
+        verified_value: "replacement",
         operation: operation.clone(),
     };
     assert_eq!(
@@ -88,18 +143,21 @@ async fn rotation_verifies_before_deleting_and_returns_provider_response(
 }
 
 #[rstest]
-#[case::current_secret_missing(0, Error::CurrentSecretMissing, 1)]
-#[case::new_secret_missing(2, Error::NewSecretMissing, 3)]
+#[case::current_secret_missing(0, RotationError::Read(Error::CurrentSecretMissing), 1)]
+#[case::new_secret_missing(2, RotationError::Verification { response: Box::new("provider-response"), source: Error::NewSecretMissing }, 3)]
 #[tokio::test]
 async fn missing_old_or_new_value_stops_rotation_before_deletion(
     replacement: SecretValue,
     #[case] absent_at: usize,
-    #[case] expected: Error,
+    #[case] expected: RotationError<&'static str, Error>,
     #[case] calls: usize,
 ) {
     let manager = Manager {
         step: AtomicUsize::new(0),
+        delete_error: false,
+        fail_at: None,
         absent_at: Some(absent_at),
+        verified_value: "replacement",
         operation: SecretOperationContext::default(),
     };
     assert_eq!(
@@ -156,3 +214,88 @@ fn names_reject_path_traversal_and_control_characters(#[case] name: &str) {
 fn names_allow_safe_values(#[case] name: &str) {
     assert_eq!(validate_secret_name(name), Ok(()));
 }
+
+#[tokio::test]
+async fn a_different_replacement_never_deletes_the_current_secret() {
+    let manager = Manager {
+        step: AtomicUsize::new(0),
+        delete_error: false,
+        fail_at: None,
+        absent_at: None,
+        verified_value: "stale-value",
+        operation: SecretOperationContext::Default,
+    };
+    assert_eq!(
+        async_rotate_secret(
+            &manager,
+            "old",
+            "new",
+            &SecretValue::new("replacement"),
+            &SecretOperationContext::Default
+        )
+        .await,
+        Err(RotationError::Verification {
+            response: Box::new("provider-response"),
+            source: Error::NewSecretMismatch
+        })
+    );
+    assert_eq!(manager.step.load(Ordering::SeqCst), 3);
+}
+
+#[tokio::test]
+async fn failed_retirement_preserves_the_verified_replacement_response() {
+    let manager = Manager {
+        step: AtomicUsize::new(0),
+        absent_at: None,
+        verified_value: "replacement",
+        operation: SecretOperationContext::Default,
+        delete_error: true,
+        fail_at: None,
+    };
+    assert_eq!(
+        async_rotate_secret(
+            &manager,
+            "old",
+            "new",
+            &SecretValue::new("replacement"),
+            &SecretOperationContext::Default
+        )
+        .await,
+        Err(RotationError::Retirement {
+            response: Box::new("provider-response"),
+            source: Error::UnsafeSecretName
+        })
+    );
+}
+
+#[rstest]
+#[case::read(0, RotationError::Read(Error::UnsafeSecretName))]
+#[case::write(1, RotationError::Write(Error::UnsafeSecretName))]
+#[case::verification(2, RotationError::Verification { response: Box::new("provider-response"), source: Error::UnsafeSecretName })]
+#[tokio::test]
+async fn provider_failures_stop_rotation_before_retirement(
+    #[case] fail_at: usize,
+    #[case] expected: RotationError<&'static str, Error>,
+) {
+    let manager = Manager {
+        step: AtomicUsize::new(0),
+        absent_at: None,
+        verified_value: "replacement",
+        operation: SecretOperationContext::default(),
+        delete_error: false,
+        fail_at: Some(fail_at),
+    };
+    assert_eq!(
+        async_rotate_secret(
+            &manager,
+            "old",
+            "new",
+            &SecretValue::new("replacement"),
+            &SecretOperationContext::default()
+        )
+        .await
+        .unwrap_err(),
+        expected
+    );
+    assert_eq!(manager.step.load(Ordering::SeqCst), fail_at + 1);
+}
diff --git a/litellm-rust/crates/secrets/Cargo.toml b/litellm-rust/crates/secrets/Cargo.toml
index e5f30025976b..17acc01682b0 100644
--- a/litellm-rust/crates/secrets/Cargo.toml
+++ b/litellm-rust/crates/secrets/Cargo.toml
@@ -14,6 +14,8 @@ azure = ["dep:litellm-secrets-azure"]
 cyberark = ["dep:litellm-secrets-cyberark"]
 
 [dependencies]
+futures-util.workspace = true
+litellm-python-compat = { path = "../python-compat" }
 litellm-secrets-types.workspace = true
 litellm-secrets-aws = { workspace = true, optional = true }
 litellm-secrets-google = { workspace = true, optional = true }
@@ -24,7 +26,6 @@ litellm-core-utils.workspace = true
 base64.workspace = true
 serde.workspace = true
 strum.workspace = true
-jsonwebtoken.workspace = true
 serde_json.workspace = true
 thiserror.workspace = true
 reqwest.workspace = true
diff --git a/litellm-rust/crates/secrets/PARITY.md b/litellm-rust/crates/secrets/PARITY.md
new file mode 100644
index 000000000000..aeed4ba4b83c
--- /dev/null
+++ b/litellm-rust/crates/secrets/PARITY.md
@@ -0,0 +1,277 @@
+# Python secret-manager test parity
+
+The inventory covers 132 tests in the secret-manager suites and the legacy secret-manager utility suites. It maps 108 tests to Rust coverage and identifies 24 tests owned by other layers or live environments. Rust tests exercise requests, returned values, caching, routing and failure behavior. Multiple Python tests can map to one parameterized Rust test
+
+Tests of Python extension lifecycle, SDK credential selection in `auth-azure`, proxy hooks and example subclasses remain at their owning boundary. They are called out below rather than counted as Rust secret-manager coverage. Default AWS partition endpoints are owned by the AWS SDK
+
+Azure callback absence remains `None`, while a native HTTP 404 still permits environment fallback. `azure_callback_absence_preserves_none_but_errors_fall_back` and `python_read_failures_preserve_provider_fallback_rules` cover these distinct results
+
+Native APIs preserve typed errors and explicit absence. Python-compatible reads restore Python fallback, coercion, Google negative caching and missing-value behavior. Vault namespaces use the SDK namespace header instead of Python’s equivalent URL prefix. Rotation verifies fresh provider reads instead of trusting a just-written cache entry, preventing deletion after a failed replacement
+
+Google payload corruption is intentionally rejected: malformed base64 and mismatched CRC32C values fail without populating the cache. `failed_or_missing_reads_are_not_cached` tests this correction against Python's permissive decoder and omitted checksum validation. See [RFC 4648 section 3.3](https://www.rfc-editor.org/rfc/rfc4648#section-3.3) and [Google's integrity guidance](https://docs.cloud.google.com/secret-manager/docs/data-integrity)
+
+The Python API audit found that earlier AWS fallback tests encoded the wrong expectation. Differential calls to the existing handler show that missing secrets, denied reads, missing string payloads, and missing or empty primary secrets return `None`; they do not activate environment fallback or defaults. `test_aws_absence_and_failed_reads_match_python_without_environment_fallback` compares the public getter under both dispatch decisions, including HTTP 500 responses and their exact request counts. Python-compatible AWS reads disable SDK retries, matching Python's single attempt for service errors while retaining the native API's retry configuration. The bridge resolver test `aws_read_failure_preserves_absence_without_environment_fallback` checks the same rule when environment values exist. `test_aws_primary_values_match_python_handler` checks typed values, including arbitrary-size integers. `test_aws_primary_json_errors_preserve_python_exception_details` checks the exception class, arguments, document, and position against Python
+
+Public AWS, Vault, CyberArk, and Google read methods now use catalog selection. AWS, Vault, and CyberArk keep their Python coroutine entrypoints, while Rust receives provider operation contexts. Full API replacement remains incomplete: AWS write/delete/rotation methods still need native bindings. Vault and CyberArk mutations now use native dispatch and share their native read caches. SDK-client configuration capture also needs to preserve explicit credentials, endpoints, and regions. Timeout phase handling, AWS optional-parameter side effects, per-call region selection without a base region, and environment lookup timing need further parity work. The private binding returns a Future, while the public methods retain ordinary Python coroutines as verified by lazy execution and `asyncio.create_task` tests. This follows the separation described in the PyO3 [signature](https://pyo3.rs/v0.29.2/function/signature.html) and [async](https://pyo3.rs/v0.29.2/async-await.html) guides. The catalog remains Python-only while these gaps are open
+
+## Public API audit
+
+The rollout decision comes from [catalog.py](../../../litellm/rust_bridge/catalog.py). All secret-manager rules remain `PYTHON_ONLY`; `LITELLM_RUST` does not make these incomplete routes production-ready. Differential tests pass explicit rules into the dispatch boundary
+
+| Python entrypoint | Native bridge coverage | Remaining API work |
+| --- | --- | --- |
+| `litellm.get_secret`, `get_secret_str`, `get_secret_bool` | Existing Python entrypoints dispatch supported manager reads | SDK-client configuration, environment read timing and complete failure conversion |
+| AWS `sync_read_secret`, `async_read_secret`, primary-secret helpers | Public signatures and coroutines retained; credentials, absence and typed JSON tested | Option consumption, timeout phases and region resolution |
+| AWS `async_write_secret`, `async_delete_secret`, `async_rotate_secret`, `async_replicate_secret`, `async_put_secret_value` | Rust provider operations exist | Public native dispatch, original response fields and Python error contracts |
+| Vault `sync_read_secret`, `async_read_secret` | Public signatures, nested overrides, namespace and data-key cache isolation tested | Complete timeout and initialization error parity |
+| Vault `async_write_secret`, `async_delete_secret`, `async_rotate_secret` | Public native dispatch, complete response envelopes, HTTP error dictionaries, timeouts and fresh verification tested | Authentication and input-conversion edge cases, transport retries, timeout phases and mutable configuration read points |
+| CyberArk reads, writes, deletes and rotations | Public native dispatch, shared cache, coroutine behavior, status errors and request counts tested | Other transport failures and client initialization timing |
+| Google `get_secret_from_google_secret_manager` | Public native dispatch and distinct initial/cached missing results | Credential configuration and complete error parity |
+| Azure Key Vault, AWS KMS, Google KMS SDK clients | Global secret-handler dispatch supports recognized clients | Explicit SDK credentials, endpoints, regions and caller-supplied credentials |
+| Custom managers and subclasses | Preserve Python callbacks | Caller implementations must never be replaced by built-in native managers |
+
+`_SecretManagerRuntime` is a private implementation detail, not a replacement SDK class. Its async methods return Futures; public `async def` methods retain lazy coroutine creation and `asyncio.create_task` support. Passing the same names and arguments is insufficient to claim parity until the remaining return-value, error, cache and configuration differences above are closed
+
+## [tests/test_litellm/secret_managers/test_aws_secret_manager_replication.py](../../../tests/test_litellm/secret_managers/test_aws_secret_manager_replication.py)
+
+| Python test | Rust coverage or boundary |
+| --- | --- |
+| `test_write_secret_replicates_when_configured` | [creation_replicates_only_to_configured_regions](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_write_secret_no_replication_when_not_configured` | [creation_replicates_only_to_configured_regions](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_replication_failure_does_not_fail_write` | [creation_passes_tags_and_kms_and_survives_replication_failure](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_async_replicate_secret_empty_regions_returns_empty` | [creation_passes_tags_and_kms_and_survives_replication_failure](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_async_replicate_secret_correct_payload` | [direct_replication_returns_response_or_service_error](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_replication_fires_on_create` | [creation_replicates_only_to_configured_regions](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_load_aws_secret_manager_passes_replica_regions` | [creation_replicates_only_to_configured_regions](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_write_secret_http_error_raises` | [create_failure_does_not_overwrite_an_alias_without_a_deletion_date](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_write_secret_timeout_raises` | [write_and_replication_timeouts_remain_errors](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_replicate_secret_http_error_raises` | [direct_replication_returns_response_or_service_error](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_replicate_secret_timeout_raises` | [write_and_replication_timeouts_remain_errors](../secrets-aws/tests/secret_manager/writes.rs) |
+
+## [tests/test_litellm/secret_managers/test_aws_secret_manager_rotation.py](../../../tests/test_litellm/secret_managers/test_aws_secret_manager_rotation.py)
+
+| Python test | Rust coverage or boundary |
+| --- | --- |
+| `test_rotate_secret_same_name_writes_requested_value_in_place` | [same_name_rotation_uses_put_and_returns_its_response](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_rotate_secret_different_names_persists_requested_value_and_deletes_old_alias` | [renamed_rotation_reads_creates_verifies_then_deletes](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_rotate_secret_back_to_name_inside_recovery_window_restores_and_stores_new_value` | [recovery_window_alias_is_restored_updated_and_tagged](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_write_secret_to_name_inside_recovery_window_reschedules_deletion_when_update_fails` | [failed_update_reschedules_deletion_of_a_restored_alias](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_write_secret_to_name_inside_recovery_window_restores_and_stores_new_value` | [recovery_window_alias_is_restored_updated_and_tagged](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_write_secret_to_live_existing_name_still_fails_without_overwriting` | [create_failure_does_not_overwrite_an_alias_without_a_deletion_date](../secrets-aws/tests/secret_manager/writes.rs) |
+
+## [tests/test_litellm/secret_managers/test_aws_secret_manager_v2.py](../../../tests/test_litellm/secret_managers/test_aws_secret_manager_v2.py)
+
+| Python test | Rust coverage or boundary |
+| --- | --- |
+| `test_create_secret_uses_customer_managed_kms_key_from_settings` | [creation_replicates_only_to_configured_regions](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_create_secret_omits_kms_key_id_when_not_configured` | [write_read_delete_preserves_the_complete_secret_string](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_write_and_read_json_secret` | [write_read_delete_preserves_the_complete_secret_string](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_prepare_request_builds_partition_endpoint` | AWS SDK owns partition endpoint construction. LiteLLM region selection is exercised by `trait_read_uses_the_aws_region_from_its_operation_context`; no vendor endpoint table is duplicated |
+| `test_prepare_request_explicit_bedrock_runtime_endpoint_param_still_wins` | [endpoint_overrides_replace_the_service_and_override_the_region](../secrets-aws/tests/secret_manager/configuration.rs) |
+| `test_prepare_request_env_bedrock_runtime_endpoint_still_wins` | [endpoint_overrides_replace_the_service_and_override_the_region](../secrets-aws/tests/secret_manager/configuration.rs) |
+
+## [tests/test_litellm/secret_managers/test_base_secret_manager.py](../../../tests/test_litellm/secret_managers/test_base_secret_manager.py)
+
+| Python test | Rust coverage or boundary |
+| --- | --- |
+| `test_raise_if_unsafe_secret_name_rejects_traversal_and_line_breaks` | [names_reject_path_traversal_and_control_characters](../secrets-types/tests/rotation.rs) |
+| `test_raise_if_unsafe_secret_name_allows_legitimate_aliases` | [names_allow_safe_values](../secrets-types/tests/rotation.rs) |
+
+## [tests/test_litellm/secret_managers/test_custom_secret_manager.py](../../../tests/test_litellm/secret_managers/test_custom_secret_manager.py)
+
+| Python test | Rust coverage or boundary |
+| --- | --- |
+| `test_custom_secret_manager_initialization` | Exercises the Python example subclass itself or Python default methods. Caller-authored Python implementations remain Python callbacks; resolver integration is covered by `manager_strings_are_coerced_like_literal_eval` |
+| `test_custom_secret_manager_sync_read` | Exercises the Python example subclass itself or Python default methods. Caller-authored Python implementations remain Python callbacks; resolver integration is covered by `manager_strings_are_coerced_like_literal_eval` |
+| `test_custom_secret_manager_async_read` | Exercises the Python example subclass itself or Python default methods. Caller-authored Python implementations remain Python callbacks; resolver integration is covered by `manager_strings_are_coerced_like_literal_eval` |
+| `test_custom_secret_manager_async_write` | Exercises the Python example subclass itself or Python default methods. Caller-authored Python implementations remain Python callbacks; resolver integration is covered by `manager_strings_are_coerced_like_literal_eval` |
+| `test_custom_secret_manager_async_delete` | Exercises the Python example subclass itself or Python default methods. Caller-authored Python implementations remain Python callbacks; resolver integration is covered by `manager_strings_are_coerced_like_literal_eval` |
+| `test_custom_secret_manager_integration_with_litellm` | [manager_strings_are_coerced_like_literal_eval](../secrets/tests/resolution.rs) |
+| `test_minimal_custom_secret_manager` | Exercises the Python example subclass itself or Python default methods. Caller-authored Python implementations remain Python callbacks; resolver integration is covered by `manager_strings_are_coerced_like_literal_eval` |
+
+## [tests/test_litellm/secret_managers/test_cyberark_secret_manager.py](../../../tests/test_litellm/secret_managers/test_cyberark_secret_manager.py)
+
+| Python test | Rust coverage or boundary |
+| --- | --- |
+| `test_sync_read_matches_parity_fixture` | [secret_names_use_python_quote_encoding](../secrets-cyberark/tests/secret_manager/reads.rs) |
+| `test_async_write_matches_parity_fixture` | [writes_match_python_parity_fixture](../secrets-cyberark/tests/secret_manager/writes.rs) |
+| `test_missing_credentials_raise_value_error` | [new_validates_credentials_before_license_and_configuration](../secrets-cyberark/tests/secret_manager/configuration.rs) |
+
+## [tests/test_litellm/secret_managers/test_get_azure_ad_token_provider.py](../../../tests/test_litellm/secret_managers/test_get_azure_ad_token_provider.py)
+
+| Python test | Rust coverage or boundary |
+| --- | --- |
+| `test_deployment_identity_reaches_workload_and_managed_identity_only` | Credential-selection contract belongs to `litellm-auth-azure`, not a secrets crate |
+| `test_deployment_identity_survives_a_developer_only_token_credentials_setting` | Credential-selection contract belongs to `litellm-auth-azure`, not a secrets crate |
+| `test_default_azure_credential_keeps_its_full_chain` | Credential-selection contract belongs to `litellm-auth-azure`, not a secrets crate |
+| `test_deployment_identity_refuses_to_mint_a_token_for_a_configured_service_principal` | Credential-selection contract belongs to `litellm-auth-azure`, not a secrets crate |
+| `test_deployment_identity_still_reaches_a_system_assigned_managed_identity` | Credential-selection contract belongs to `litellm-auth-azure`, not a secrets crate |
+| `test_deployment_identity_keeps_the_user_assigned_identity_under_a_dev_only_setting` | Credential-selection contract belongs to `litellm-auth-azure`, not a secrets crate |
+| `test_get_azure_ad_token_provider_client_secret_credential` | Credential-selection contract belongs to `litellm-auth-azure`, not a secrets crate |
+| `test_get_azure_ad_token_provider_managed_identity_credential` | Credential-selection contract belongs to `litellm-auth-azure`, not a secrets crate |
+| `test_get_azure_ad_token_provider_certificate_credential` | Credential-selection contract belongs to `litellm-auth-azure`, not a secrets crate |
+| `test_get_azure_ad_token_provider_password_protected_certificate_credential` | Credential-selection contract belongs to `litellm-auth-azure`, not a secrets crate |
+| `test_get_azure_ad_token_provider_default_azure_credential` | Credential-selection contract belongs to `litellm-auth-azure`, not a secrets crate |
+| `test_get_azure_ad_token_provider_prefers_workload_identity_over_managed_identity` | Credential-selection contract belongs to `litellm-auth-azure`, not a secrets crate |
+| `test_get_azure_ad_token_provider_defaults_to_default_azure_credential` | Credential-selection contract belongs to `litellm-auth-azure`, not a secrets crate |
+
+## [tests/test_litellm/secret_managers/test_hashicorp_secret_manager.py](../../../tests/test_litellm/secret_managers/test_hashicorp_secret_manager.py)
+
+| Python test | Rust coverage or boundary |
+| --- | --- |
+| `test_sync_read_uses_login_namespace_for_approle_and_secret_namespace_for_url` | [login_and_secret_namespaces_follow_python_precedence](../secrets-hashicorp/tests/secret_manager/configuration.rs) |
+| `test_login_header_is_omitted_when_no_namespace_is_configured` | [login_and_secret_namespaces_follow_python_precedence](../secrets-hashicorp/tests/secret_manager/configuration.rs) |
+| `test_sync_read_per_secret_namespace_overrides_secret_namespace` | [operation_overrides_isolate_cached_targets_and_apply_to_writes_and_deletes](../secrets-hashicorp/tests/secret_manager/writes.rs) |
+| `test_sync_read_caches_per_resolved_target` | [operation_overrides_isolate_cached_targets_and_apply_to_writes_and_deletes](../secrets-hashicorp/tests/secret_manager/writes.rs) |
+| `test_sync_read_caches_per_data_key_for_the_same_secret_path` | [reads_cache_each_data_key_for_the_same_vault_path](../secrets-hashicorp/tests/secret_manager/reads.rs) |
+| `test_async_delete_evicts_every_cached_field_of_the_secret_path` | [write_and_delete_invalidate_the_read_cache](../secrets-hashicorp/tests/secret_manager/writes.rs) |
+| `test_async_read_uses_secret_namespace_and_login_namespace` | [login_and_secret_namespaces_follow_python_precedence](../secrets-hashicorp/tests/secret_manager/configuration.rs) |
+| `test_async_write_and_read_share_the_secret_namespace_target` | [write_and_delete_invalidate_the_read_cache](../secrets-hashicorp/tests/secret_manager/writes.rs) |
+| `test_tls_login_uses_login_namespace` | [tls_login_posts_the_role_and_uses_the_client_identity](../secrets-hashicorp/tests/secret_manager/configuration.rs) |
+| `test_configuration_matches_native_parity_fixture` | [configuration_matches_python_parity_fixture](../secrets-hashicorp/tests/secret_manager/configuration.rs) |
+
+## [tests/test_litellm/secret_managers/test_secret_manager_handler.py](../../../tests/test_litellm/secret_managers/test_secret_manager_handler.py)
+
+| Python test | Rust coverage or boundary |
+| --- | --- |
+| `test_azure_key_vault_matches_rust_parity_fixture` | [parity_fixture_matches_python_backend_contract](../secrets-azure/tests/key_vault.rs) |
+
+## [tests/test_litellm/secret_managers/test_secret_managers_main.py](../../../tests/test_litellm/secret_managers/test_secret_managers_main.py)
+
+| Python test | Rust coverage or boundary |
+| --- | --- |
+| `test_oidc_google_success` | [google_expiry_caps_cache_and_preserves_audience](../secrets/tests/oidc.rs) |
+| `test_oidc_google_cached` | [google_expiry_caps_cache_and_preserves_audience](../secrets/tests/oidc.rs) |
+| `test_oidc_google_cache_ttl_capped_by_token_exp` | [google_tokens_expire_at_the_python_cache_deadline](../secrets/tests/oidc.rs) |
+| `test_oidc_google_expired_token_not_cached` | [google_expiry_caps_cache_and_preserves_audience](../secrets/tests/oidc.rs) |
+| `test_oidc_google_long_lived_token_still_capped_at_default_ttl` | [google_tokens_expire_at_the_python_cache_deadline](../secrets/tests/oidc.rs) |
+| `test_oidc_google_non_jwt_token_keeps_default_ttl` | [google_tokens_expire_at_the_python_cache_deadline](../secrets/tests/oidc.rs) |
+| `test_oidc_google_failure` | [google_oidc_failures_are_not_cached_or_hidden_by_defaults](../secrets/tests/oidc.rs) |
+| `test_oidc_circleci_success` | [environment_sources_resolve_expected_value](../secrets/tests/oidc.rs) |
+| `test_oidc_circleci_failure` | [missing_oidc_environment_is_an_error](../secrets/tests/oidc.rs) |
+| `test_oidc_github_success` | [github_requests_are_authenticated_cached_and_revalidate_environment](../secrets/tests/oidc.rs) |
+| `test_oidc_github_missing_env` | [github_requests_are_authenticated_cached_and_revalidate_environment](../secrets/tests/oidc.rs) |
+| `test_oidc_azure_file_success` | [file_allowlist_resolves_symlinks_while_environment_paths_remain_explicit](../secrets/tests/oidc.rs) |
+| `test_oidc_azure_ad_token_success` | [azure_oidc_acquires_the_requested_scope_and_preserves_failures](../secrets/tests/oidc.rs) |
+| `test_oidc_file_success` | [file_allowlist_resolves_symlinks_while_environment_paths_remain_explicit](../secrets/tests/oidc.rs) |
+| `test_oidc_file_rejects_path_outside_allowlist` | [file_allowlist_resolves_symlinks_while_environment_paths_remain_explicit](../secrets/tests/oidc.rs) |
+| `test_oidc_file_rejects_relative_path` | [file_allowlist_resolves_symlinks_while_environment_paths_remain_explicit](../secrets/tests/oidc.rs) |
+| `test_oidc_env_success` | [environment_sources_resolve_expected_value](../secrets/tests/oidc.rs) |
+| `test_oidc_env_path_success` | [file_allowlist_resolves_symlinks_while_environment_paths_remain_explicit](../secrets/tests/oidc.rs) |
+| `test_unsupported_oidc_provider` | [invalid_references_fail_before_environment_lookup](../secrets/tests/oidc.rs) |
+| `test_normalize_nonempty_secret_str` | [normalization_matches_python_without_changing_embedded_whitespace](../secrets/tests/resolution.rs) |
+| `test_secret_manager_would_be_consulted_matches_get_secret` | [gating_prediction_matches_actual_lookup](../secrets/tests/aws.rs) |
+| `test_secret_manager_would_be_consulted_is_false_without_a_client` | [prefix_is_removed_once_and_resolved_from_environment](../secrets/tests/resolution.rs) |
+
+## [tests/litellm_utils_tests/test_secret_manager.py](../../../tests/litellm_utils_tests/test_secret_manager.py)
+
+| Python test | Rust coverage or boundary |
+| --- | --- |
+| `test_aws_secret_manager` | [write_read_delete_preserves_the_complete_secret_string](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_oidc_google` | [google_expiry_caps_cache_and_preserves_audience](../secrets/tests/oidc.rs) |
+| `test_oidc_github` | [github_requests_are_authenticated_cached_and_revalidate_environment](../secrets/tests/oidc.rs) |
+| `test_oidc_circleci` | [environment_sources_resolve_expected_value](../secrets/tests/oidc.rs) |
+| `test_oidc_circleci_v2` | [environment_sources_resolve_expected_value](../secrets/tests/oidc.rs) |
+| `test_oidc_circleci_with_azure` | Quarantined live Azure token exchange, outside secrets crates. CircleCI token retrieval is covered by `environment_sources_resolve_expected_value` |
+| `test_oidc_circle_v1_with_amazon` | Quarantined live AWS token exchange, outside secrets crates. Token retrieval and STS forwarding are covered independently |
+| `test_oidc_env_variable` | [environment_sources_resolve_expected_value](../secrets/tests/oidc.rs) |
+| `test_oidc_file` | [file_allowlist_resolves_symlinks_while_environment_paths_remain_explicit](../secrets/tests/oidc.rs) |
+| `test_oidc_env_path` | [file_allowlist_resolves_symlinks_while_environment_paths_remain_explicit](../secrets/tests/oidc.rs) |
+| `test_google_secret_manager` | [successful_reads_use_auth_latest_version_and_cache_including_empty_values](../secrets-google/tests/secret_manager.rs) |
+| `test_google_secret_manager_read_in_memory` | [python_reads_reuse_cached_absence_until_expiry](../secrets-google/tests/secret_manager.rs) |
+| `test_should_read_secret_from_secret_manager` | [gating_prediction_matches_actual_lookup](../secrets/tests/aws.rs) |
+| `test_get_secret_with_access_mode` | [gating_prediction_matches_actual_lookup](../secrets/tests/aws.rs) |
+| `test_key_management_settings_defaults` | [config_preserves_defaults_nulls_and_serialized_names](../secrets-types/tests/config.rs) |
+| `test_key_management_settings_custom_values` | [config_preserves_defaults_nulls_and_serialized_names](../secrets-types/tests/config.rs) |
+| `test_async_write_secret_receives_description_and_tags` | Proxy hook behavior stays in Python. Native write metadata is covered by `trait_write_uses_typed_write_context` |
+| `test_key_management_settings_serialization_roundtrip` | [config_preserves_defaults_nulls_and_serialized_names](../secrets-types/tests/config.rs) |
+
+## [tests/litellm_utils_tests/test_get_secret.py](../../../tests/litellm_utils_tests/test_get_secret.py)
+
+| Python test | Rust coverage or boundary |
+| --- | --- |
+| `test_azure_kms` | [azure_handler_reads_missing_and_failed_secrets](../secrets/tests/azure.rs) |
+
+## [tests/litellm_utils_tests/test_aws_secret_manager.py](../../../tests/litellm_utils_tests/test_aws_secret_manager.py)
+
+| Python test | Rust coverage or boundary |
+| --- | --- |
+| `test_write_and_read_simple_secret` | [write_read_delete_preserves_the_complete_secret_string](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_write_and_read_json_secret` | [write_read_delete_preserves_the_complete_secret_string](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_read_nonexistent_secret` | [failed_read_returns_none_but_invalid_primary_json_is_an_error](../secrets-aws/tests/secret_manager/reads.rs) |
+| `test_primary_secret_functionality` | [primary_lookup_preserves_read_semantics](../secrets-aws/tests/secret_manager/reads.rs) |
+| `test_write_secret_with_description_and_tags` | [creation_passes_tags_and_kms_and_survives_replication_failure](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_secret_manager_with_iam_role_settings` | [configured_sts_credentials_sign_the_secret_request](../secrets-aws/tests/secret_manager/configuration.rs) |
+| `test_secret_manager_with_cross_account_settings` | [configured_sts_credentials_sign_the_secret_request](../secrets-aws/tests/secret_manager/configuration.rs) |
+| `test_secret_manager_with_irsa_settings` | [configured_sts_credentials_sign_the_secret_request](../secrets-aws/tests/secret_manager/configuration.rs) |
+| `test_secret_manager_with_custom_sts_endpoint` | [configured_sts_credentials_sign_the_secret_request](../secrets-aws/tests/secret_manager/configuration.rs) |
+| `test_secret_manager_with_aws_profile` | [configured_profile_credentials_override_static_environment_credentials](../secrets-aws/tests/secret_manager/configuration.rs) |
+| `test_load_aws_secret_manager_with_settings` | [creation_replicates_only_to_configured_regions](../secrets-aws/tests/secret_manager/writes.rs) |
+| `test_end_to_end_iam_role_secret_write` | Live AWS account test, not a unit test. Offline STS signing and secret writes are covered without account assumptions |
+
+## [tests/litellm_utils_tests/test_hashicorp.py](../../../tests/litellm_utils_tests/test_hashicorp.py)
+
+| Python test | Rust coverage or boundary |
+| --- | --- |
+| `test_hashicorp_secret_manager_get_secret` | [token_reads_use_vault_headers_and_cache_values](../secrets-hashicorp/tests/secret_manager/reads.rs) |
+| `test_hashicorp_secret_manager_write_secret` | [write_and_delete_invalidate_the_read_cache](../secrets-hashicorp/tests/secret_manager/writes.rs) |
+| `test_hashicorp_secret_manager_write_secret_with_team_overrides` | [operation_overrides_isolate_cached_targets_and_apply_to_writes_and_deletes](../secrets-hashicorp/tests/secret_manager/writes.rs) |
+| `test_hashicorp_secret_manager_delete_secret` | [write_and_delete_invalidate_the_read_cache](../secrets-hashicorp/tests/secret_manager/writes.rs) |
+| `test_hashicorp_secret_manager_delete_secret_with_team_overrides` | [operation_overrides_isolate_cached_targets_and_apply_to_writes_and_deletes](../secrets-hashicorp/tests/secret_manager/writes.rs) |
+| `test_hashicorp_secret_manager_tls_cert_auth` | [tls_login_posts_the_role_and_uses_the_client_identity](../secrets-hashicorp/tests/secret_manager/configuration.rs) |
+| `test_hashicorp_secret_manager_approle_auth` | [approle_login_uses_namespace_and_reuses_the_token](../secrets-hashicorp/tests/secret_manager/configuration.rs) |
+| `test_hashicorp_custom_mount_and_prefix` | [namespace_mount_and_prefix_are_sanitized_in_the_url](../secrets-hashicorp/tests/secret_manager/reads.rs) |
+| `test_hashicorp_get_url_rejects_path_traversal` | [no_auth_and_invalid_names_fail_without_requests](../secrets-hashicorp/tests/secret_manager/configuration.rs) |
+| `test_hashicorp_secret_manager_rotate_secret_different_names` | [rotation_applies_timeout_to_each_request](../secrets-hashicorp/tests/secret_manager/writes.rs) |
+| `test_hashicorp_secret_manager_rotate_secret_same_name` | [same_name_rotation_keeps_the_replacement](../secrets-hashicorp/tests/secret_manager/writes.rs) |
+| `test_hashicorp_secret_manager_rotate_secret_current_not_found` | [missing_old_or_new_value_stops_rotation_before_deletion](../secrets-types/tests/rotation.rs) |
+| `test_hashicorp_secret_manager_rotate_secret_write_fails` | [provider_failures_stop_rotation_before_retirement](../secrets-types/tests/rotation.rs) |
+| `test_hashicorp_secret_manager_rotate_secret_with_team_overrides` | [rotation_applies_timeout_to_each_request](../secrets-hashicorp/tests/secret_manager/writes.rs) |
+| `test_hashicorp_secret_manager_rotate_secret_value_mismatch` | [a_different_replacement_never_deletes_the_current_secret](../secrets-types/tests/rotation.rs) |
+
+## [tests/litellm_utils_tests/test_cyberark.py](../../../tests/litellm_utils_tests/test_cyberark.py)
+
+| Python test | Rust coverage or boundary |
+| --- | --- |
+| `test_cyberark_write_secret_rejects_yaml_injection` | [unsafe_names_fail_before_http_calls](../secrets-cyberark/tests/secret_manager/reads.rs) |
+| `test_cyberark_ensure_variable_exists_escapes_yaml_metacharacters` | [policy_writes_preserve_yaml_metacharacters_as_one_variable](../secrets-cyberark/tests/secret_manager/writes.rs) |
+| `test_cyberark_write_and_read_secret` | [writes_tolerate_policy_status_and_cache_value](../secrets-cyberark/tests/secret_manager/writes.rs) |
+| `test_cyberark_rotate_secret` | [rotation_stores_the_replacement_and_retains_other_aliases](../secrets-cyberark/tests/secret_manager/writes.rs) |
+| `test_cyberark_rotate_secret_with_new_alias` | [rotation_stores_the_replacement_and_retains_other_aliases](../secrets-cyberark/tests/secret_manager/writes.rs) |
+
+## Public provider read boundary
+
+`test_public_aws_reads_preserve_coroutines_and_per_call_credentials` verifies lazy coroutine execution, `asyncio.create_task`, positional and keyword calls, request payloads, and per-call credentials, region, and endpoint overrides. `test_public_aws_primary_reads_ignore_operation_overrides_like_python` retains Python's ignored primary-read overrides. Bootstrap keys bypass only synchronous reads, including native backend initialization
+
+Real HTTP timeouts are swallowed by AWS reads because LiteLLM's standard HTTP handler raises `litellm.Timeout`; tests that inject `httpx.TimeoutException` bypass that wrapping. `test_public_aws_read_timeouts_follow_the_python_http_handler` compares both implementations against delayed responses
+
+Vault reads retain nested overrides, Python string conversion, and cache isolation. CyberArk reuses authentication and preserves raw secret text in its cache. Python's shared cache JSON-decodes CyberArk values on subsequent reads, corrupting quoted strings and changing types. The native behavior intentionally fixes this corruption, with the Python difference shown in `test_public_cyberark_reads_reuse_authentication_and_cached_values`
+
+Google's first missing-secret read raises, while a cached miss returns `None`. `python_reads_reuse_cached_absence_until_expiry` and `python_cached_absence_expires_and_allows_recovery` retain both outcomes
+
+
+## Public CyberArk mutation boundary
+
+Public writes, deletes, and rotations retain the Python method signatures and coroutine entrypoints. Write and delete results preserve Python's status/message dictionaries. Unsupported deletion clears the shared native read cache without a provider request. Authentication and write HTTP failures preserve Python's messages and request counts, including the ignored initial authentication failure while ensuring a policy. Python-compatible reads and writes do not retry HTTP 401; native Rust retry policies remain unchanged
+
+The bridge compares connection-refused errors against Python and builds HTTP status messages through HTTPX. Other transport failures and client-initialization timing still need a complete API audit; these checks do not establish full error parity
+
+`test_public_cyberark_writes_and_deletes_share_the_read_cache` verifies real HTTP writes followed by sync and async cached reads and deletion invalidation. `test_public_cyberark_write_errors_match_python_without_http_retries`, `test_public_cyberark_connection_errors_match_python`, and `test_cyberark_handler_errors_match_python_after_cached_authentication_is_denied` compare error results against Python. Missing-extension selection remains covered for each mutation
+
+Rotation preserves the documented fresh-read safeguard. Python's base rotation checks a cache populated by the write and does not compare the stored value, so a successful response can conceal a missing or incorrect replacement. `test_public_cyberark_rotation_requires_a_fresh_matching_replacement` rejects both cases and verifies the old cache remains intact. `test_public_cyberark_rotation_stops_after_a_failed_write` preserves the old value and returns the write error without further requests. Conjur retains the old provider alias because its deletion API is unsupported
+
+
+## Public Vault mutation boundary
+
+Public Vault writes, deletes and rotation now use catalog selection. Their Python signatures and coroutine entrypoints stay unchanged. Native operations use the Vault SDK request types and authenticated client while retaining the complete response bytes for Python JSON conversion. This preserves additional response fields, key order and arbitrary-size integers. Python-compatible writes make one provider attempt; the existing native API keeps its CAS recovery behavior
+
+`test_public_vault_writes_preserve_complete_responses_and_request_fields` checks the response envelope, nested operation settings, payload and ignored tags. `test_public_vault_mutation_http_errors_match_python_without_retry` compares write/delete error dictionaries, including namespace URLs and exact request counts. Rotation tests compare current-secret failures, ordered request paths, write failures, failed verification, mismatched values, malformed verification shapes, same-name updates and best-effort old-alias deletion. A successful HTTP response containing `status: error` stops rotation and returns the original response. Verification fields remain raw JSON until Python error conversion, preserving large integers, nested values and the distinction between integer and floating-point type errors. Unsupported extension selection is checked separately for write, delete and rotate
+
+`test_public_vault_mutation_timeouts_match_python` compares operation-specific timeout messages. The elapsed duration in a POST error is measured independently, so the test checks its structure and lower bound rather than requiring two independent requests to have identical elapsed time. Phase-specific connect/read/write/pool deadlines and cached Python transport configuration still need broader parity checks
+
+Native writes retain two documented correctness safeguards. Python's `async_write_secret` does not invalidate the read cache, so a later read can return a value from before a successful write. `test_public_native_vault_write_invalidates_stale_cached_values` verifies that the native public API returns the updated provider value. Python also overwrites the secret when both the data key and description field are named `description`. `test_public_native_vault_write_rejects_description_overwriting_the_secret` rejects that collision before any request. These corrections do not change Python
+
+The raw response path does not yet establish complete Vault API parity. SDK authentication payload parsing, argument conversion, connection retry behavior, non-HTTP transport errors, nonstandard JSON encodings during rotation and configuration changes during rotation remain under audit. The catalog stays Python-only
+
+
+The Vault boundary update passed 317 provider and bridge tests, including 191 bridge cases. With the extension unavailable, 35 passed and 156 native-only cases skipped. Seven targeted mutations compiled and failed their regression tests: stripped response envelopes, ignored HTTP 400 failures, skipped replacement equality, skipped current-secret checks, stale write caches, fatal old-secret deletion failures and ignored write-error responses. The restored extension passed again. Five additional differential cases reproduced lossy large-integer error conversion before the raw-JSON correction and pass afterward. Live public native reads, writes, deletes and same-name/new-alias rotations passed against local Vault 1.20 with token and AppRole authentication, with Python HTTP construction forbidden
diff --git a/litellm-rust/crates/secrets/README.md b/litellm-rust/crates/secrets/README.md
index 0d333c7d116c..c8b01fe9b3ad 100644
--- a/litellm-rust/crates/secrets/README.md
+++ b/litellm-rust/crates/secrets/README.md
@@ -2,12 +2,42 @@
 
 Construct `SecretManagerState::new(backend, settings)` for a configured manager or use `SecretManagerState::default()` for environment lookups. The configured backend determines its provider identity. Write-only settings and names excluded by `hosted_keys` use the environment directly. `secret_manager_would_be_consulted` follows the same routing decision as resolution
 
-`get_secret` returns `Ok(Some(value))` for a found value, `Ok(None)` when no source contains the value, and `Err(error)` when lookup fails. For managed names, resolution checks the manager, then the environment, then the caller's default. An empty string, `false`, or an explicitly stored JSON null is a found value
+Native resolution distinguishes a found value, confirmed absence, and a failed read. Missing values use the caller's default, while provider errors propagate. Empty strings are found values
 
-Backend failures propagate by default. To allow fallback during a backend failure, construct the resolver with `.with_failure_policy(FailurePolicy::EnvironmentFallback)`. It then tries the environment and default, in that order. If neither exists, the original error is returned. This policy applies to manager lookups. Explicit OIDC references retain their own authentication errors and never fall back to environment secrets under the reference name
+`new_python_compatible` uses Python's environment fallback and conversion rules. Manager exceptions fall back to the environment, including custom-manager exceptions. AWS missing secrets, failed HTTP reads, missing string payloads, and missing or empty primary secrets return `None` without fallback, matching Python. The standard Python HTTP handler wraps network timeouts in `litellm.Timeout`, which AWS reads also swallow. Invalid primary JSON still raises. An absent AWS primary JSON field and a successful Azure response without a value also remain `None`. Defaults do not replace these results. `.with_failure_policy(FailurePolicy::Propagate)` exposes manager failures explicitly instead. Cancellation and other Python `BaseException`s always propagate unchanged. Explicit OIDC references keep their own errors and never use these fallbacks
 
-`get_secret` preserves value types. `get_secret_str` accepts a string default and rejects boolean or JSON values with `Error::TypeMismatch`. `get_secret_bool` accepts a boolean default and converts strings containing `true` or `false`, ignoring surrounding whitespace and ASCII case. Other strings and JSON values produce `Error::TypeMismatch`. Conversion failures never activate fallback or replace a found value with the default
+The getters follow Python's conversion policy. Environment values use case-insensitive, whitespace-trimmed boolean parsing. Manager strings become booleans only when Python literal evaluation yields a boolean; other strings retain their exact contents. Non-string manager results produce `None`. `get_secret_str` returns only strings, and `get_secret_bool` accepts booleans or strings containing `true` or `false`. A type mismatch returns `None` and does not activate fallback
 
-Provider payloads remain strings unless explicitly selecting a field from an AWS primary JSON secret. Google caches only successfully decoded string payloads, so reads have identical values and types before and after caching. Confirmed absence and failed reads are not cached. AWS resource-not-found responses and Google HTTP 404 responses indicate absence. Other provider errors remain errors, and successful responses without the required payload are malformed responses rather than missing secrets
+## Route integration
+
+Inject `Arc<dyn SecretSource>` from `litellm_secrets::source` into route preparation. `SecretResolver` implements this interface and supports arbitrary names through its asynchronous `get_secret_str`. It applies the same manager selection, conversion, and fallback policy to every lookup
+
+For synchronous provider transformations, call `source.resolve(names).await` during preparation and inject the returned `Secrets` snapshot. A snapshot contains only those names and never reads the process environment implicitly. Resolve runtime names through the source before invoking a synchronous transformation. OCR uses this pattern; other routes can adopt it as they are implemented
+
+The Python bridge uses this shared source and resolver. The shared proxy initializer captures effective configuration, and directly constructed LiteLLM managers are adapted at the dispatch boundary, and the bridge retains a native backend per configured client. Python reads and Rust routes share that backend. Custom Python implementations remain external callbacks. Rollout policy controls whether the native binding is selected. Public provider reads and Vault/CyberArk mutations use this selection; AWS mutation bindings remain unfinished. Mutations update the same native cache used by public reads. Vault retains complete write response bodies and Python-compatible error dictionaries while verifying rotation with fresh reads. The Python boundary retains primary JSON until return conversion so Python JSON numbers, values, and exception details survive unchanged
+
+## Backend contracts
+
+AWS Secrets Manager, Azure Key Vault, Google Secret Manager, Vault, and CyberArk implement `BaseSecretManager` for reads with an operation context. Foreign provider contexts are rejected before cache access or I/O. Writes and deletes use separate `SecretWriter` and `SecretDeleter` capabilities. CyberArk rotation writes and verifies the replacement while retaining the old alias because Conjur does not support deletion through this API
+
+Shared rotation verifies that the replacement has the requested value before deleting the old secret. Same-name rotation keeps the replacement. AWS same-name rotation uses its version update API directly, matching Python
+
+Backend reads preserve payload strings. Conversion belongs to the resolver. Google caches only successfully decoded payloads, so values agree before and after caching. Native reads do not cache absence or failures. Python-compatible Google reads preserve Python's negative cache and its always-read override. Resource-not-found responses indicate absence; authentication, permission, transport, and malformed successful responses remain errors
 
 The HashiCorp Vault backend is enabled with the `hashicorp` feature and reads KV v2 values from `HCP_VAULT_*` environment variables. It supports static tokens, AppRole authentication, and TLS certificate authentication
+
+## Intentional differences from Python
+
+Native backends consistently distinguish absence from failure instead of swallowing provider errors. Python-compatible resolution maps these results back to the Python handler contract before applying fallback
+
+`hosted_keys` excludes a name for every backend. Python's handler recognizes Azure `SecretClient` and Google `KeyManagementServiceClient` instances before the `local` branch, allowing excluded names to reach those providers. Rust treats that as a routing bug. `test_rust_hosted_keys_exclude_azure_sdk_clients_too` in `tests/test_litellm/rust_bridge/ocr/test_secrets.py` pins this behavior
+
+Google rejects malformed base64 and mismatched CRC32C values instead of accepting corrupted payloads. Python currently ignores the checksum and uses permissive base64 decoding. Rust follows [RFC 4648](https://www.rfc-editor.org/rfc/rfc4648#section-3.3) and [Google's integrity guidance](https://docs.cloud.google.com/secret-manager/docs/data-integrity); `failed_or_missing_reads_are_not_cached` covers rejection and recovery
+
+CyberArk cached reads preserve the original secret text. Python's shared cache attempts JSON decoding, so a secret such as `"password"` changes to `password` after the first read, and `true` changes to a Boolean. This corrupts the stored credential representation. `test_public_cyberark_reads_reuse_authentication_and_cached_values` demonstrates the Python defect and verifies stable native results
+
+## Test parity
+
+[The Python test inventory](PARITY.md) maps each secret-manager test to Rust coverage or its owning boundary
+
+AWS, Vault, and CyberArk keep client/authentication, reads, and writes/rotation in private provider modules. Their existing integration-test targets group configuration, read/cache, and write/rotation cases, with shared fixtures local to each target. Python-compatible dispatch and string coercion live separately from native dispatch
diff --git a/litellm-rust/crates/secrets/src/compatibility.rs b/litellm-rust/crates/secrets/src/compatibility.rs
new file mode 100644
index 000000000000..621f7a3f4328
--- /dev/null
+++ b/litellm-rust/crates/secrets/src/compatibility.rs
@@ -0,0 +1,82 @@
+use litellm_core_utils::settings::Lookup;
+use litellm_python_compat::{Value, literal::literal_eval};
+use litellm_secrets_types::PythonSecretRead;
+
+use crate::{
+    Error, KeyManagementSettings, KeyManagementSystem, Secret, SecretManager, SecretValue,
+    get_secret_from_manager,
+};
+
+pub async fn get_secret_from_python_manager(
+    manager: &SecretManager,
+    name: &str,
+    settings: &KeyManagementSettings,
+    environment: &(dyn Lookup + Send + Sync),
+) -> Result<Option<Secret>, Error> {
+    #[cfg(feature = "aws")]
+    if let SecretManager::AwsSecretsManagerV2(client) = manager {
+        return client
+            .read_secret_for_python(name, settings.primary_secret_name.as_deref(), environment)
+            .await
+            .map_err(Error::from);
+    }
+    let result = match manager {
+        #[cfg(feature = "cyberark")]
+        SecretManager::Cyberark(client) => Ok(client
+            .read_with_retry(
+                name,
+                &Default::default(),
+                litellm_secrets_cyberark::AuthenticationRetry::Never,
+            )
+            .await
+            .unwrap_or(None)
+            .map(Secret::String)),
+        #[cfg(feature = "google")]
+        SecretManager::GoogleSecretManager(client) => client
+            .get_secret_for_python(name)
+            .await
+            .map_err(Error::from),
+        _ => get_secret_from_manager(manager, name, settings, environment).await,
+    };
+    match result {
+        #[cfg(feature = "google")]
+        Err(Error::Google(litellm_secrets_google::Error::Status(404))) => {
+            Err(Error::ManagedSecretMissing)
+        }
+        #[cfg(feature = "azure")]
+        Err(Error::Azure(litellm_secrets_azure::Error::MissingValue)) => Ok(None),
+        Ok(None)
+            if matches!(manager, SecretManager::External(_))
+                && manager.system() == KeyManagementSystem::AzureKeyVault =>
+        {
+            Ok(None)
+        }
+        Ok(None) => Err(Error::ManagedSecretMissing),
+        result => result,
+    }
+}
+
+pub(crate) fn python_manager_string(value: SecretValue) -> Secret {
+    match literal_eval(value.expose()) {
+        Ok(Value::Bool(boolean)) => Secret::Bool(boolean),
+        _ => Secret::String(value),
+    }
+}
+
+pub async fn read_secret_from_python_manager(
+    manager: &SecretManager,
+    name: &str,
+    settings: &KeyManagementSettings,
+    environment: &(dyn Lookup + Send + Sync),
+) -> Result<PythonSecretRead, Error> {
+    #[cfg(feature = "aws")]
+    if let SecretManager::AwsSecretsManagerV2(client) = manager {
+        return client
+            .read_payload_for_python(name, settings.primary_secret_name.as_deref(), environment)
+            .await
+            .map_err(Error::from);
+    }
+    get_secret_from_python_manager(manager, name, settings, environment)
+        .await
+        .map(PythonSecretRead::Value)
+}
diff --git a/litellm-rust/crates/secrets/src/error.rs b/litellm-rust/crates/secrets/src/error.rs
index de325ff49818..07f2f205beca 100644
--- a/litellm-rust/crates/secrets/src/error.rs
+++ b/litellm-rust/crates/secrets/src/error.rs
@@ -1,5 +1,9 @@
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
+    #[error("configured secret manager did not return a secret")]
+    ManagedSecretMissing,
+    #[error("native secret backend is unavailable for this system")]
+    NativeBackendUnavailable,
     #[error("encrypted environment value is missing")]
     MissingCiphertext,
     #[error("ciphertext is not valid base64 for the configured manager")]
@@ -26,6 +30,8 @@ pub enum Error {
     TypeMismatch { expected: &'static str },
     #[error("external secret manager failed")]
     ExternalManager(#[source] Box<dyn std::error::Error + Send + Sync>),
+    #[error("external secret manager read failed")]
+    ExternalRead(#[source] Box<dyn std::error::Error + Send + Sync>),
     #[cfg(feature = "aws")]
     #[error(transparent)]
     Aws(#[from] litellm_secrets_aws::Error),
diff --git a/litellm-rust/crates/secrets/src/handler.rs b/litellm-rust/crates/secrets/src/handler.rs
index 0ae848218831..db37d7933841 100644
--- a/litellm-rust/crates/secrets/src/handler.rs
+++ b/litellm-rust/crates/secrets/src/handler.rs
@@ -7,6 +7,14 @@ use crate::{Error, KeyManagementSettings, KeyManagementSystem, Secret};
 #[cfg(any(feature = "aws", feature = "google"))]
 use crate::SecretValue;
 
+#[cfg(any(
+    feature = "google",
+    feature = "hashicorp",
+    feature = "azure",
+    feature = "cyberark"
+))]
+use litellm_secrets_types::BaseSecretManager;
+
 pub trait ExternalSecretManager: Send + Sync {
     fn system(&self) -> KeyManagementSystem;
 
@@ -103,26 +111,13 @@ pub async fn get_secret_from_manager(
             .await
             .map_err(Error::from),
         #[cfg(feature = "google")]
-        SecretManager::GoogleSecretManager(client) => client
-            .get_secret_from_google_secret_manager(secret_name)
-            .await
-            .map_err(Error::from),
+        SecretManager::GoogleSecretManager(client) => read_manager(client, secret_name).await,
         #[cfg(feature = "hashicorp")]
-        SecretManager::HashicorpVault(client) => client
-            .async_read_secret(secret_name)
-            .await
-            .map(|value| value.map(Secret::String))
-            .map_err(Error::from),
+        SecretManager::HashicorpVault(client) => read_manager(client, secret_name).await,
         #[cfg(feature = "azure")]
-        SecretManager::AzureKeyVault(client) => {
-            client.get_secret(secret_name).await.map_err(Error::from)
-        }
+        SecretManager::AzureKeyVault(client) => read_manager(client, secret_name).await,
         #[cfg(feature = "cyberark")]
-        SecretManager::Cyberark(client) => client
-            .async_read_secret(secret_name)
-            .await
-            .map(|value| value.map(Secret::String))
-            .map_err(Error::from),
+        SecretManager::Cyberark(client) => read_manager(client, secret_name).await,
     }
 }
 
@@ -160,3 +155,23 @@ fn decode_ciphertext(value: &str, mode: Base64Mode) -> Result<Vec<u8>, Error> {
     }
     Ok(ciphertext)
 }
+
+#[cfg(any(
+    feature = "google",
+    feature = "hashicorp",
+    feature = "azure",
+    feature = "cyberark"
+))]
+async fn read_manager<M: BaseSecretManager>(
+    manager: &M,
+    name: &str,
+) -> Result<Option<Secret>, Error>
+where
+    Error: From<M::Error>,
+{
+    manager
+        .async_read_secret(name, &M::Context::default())
+        .await
+        .map(|value| value.map(Secret::String))
+        .map_err(Error::from)
+}
diff --git a/litellm-rust/crates/secrets/src/lib.rs b/litellm-rust/crates/secrets/src/lib.rs
index 58aba8494fd0..8d0f05616083 100644
--- a/litellm-rust/crates/secrets/src/lib.rs
+++ b/litellm-rust/crates/secrets/src/lib.rs
@@ -1,18 +1,23 @@
 #![forbid(unsafe_code)]
 
+mod compatibility;
 mod error;
 mod handler;
+mod native;
 mod oidc;
 mod resolver;
+pub mod source;
 mod state;
 
+pub use compatibility::{get_secret_from_python_manager, read_secret_from_python_manager};
 pub use error::Error;
 pub use handler::{ExternalSecretManager, SecretManager, get_secret_from_manager};
 pub use litellm_secrets_types::{
     AccessMode, KeyManagementSettings, KeyManagementSystem, Secret, SecretValue,
 };
+pub use native::load_native_manager;
 pub use oidc::{OidcProvider, OidcReference, OidcResolver};
-pub use resolver::{FailurePolicy, SecretResolver};
+pub use resolver::{FailurePolicy, SecretResolver, normalize_nonempty_secret_str};
 pub use state::{SecretManagerState, secret_manager_would_be_consulted};
 
 #[cfg(feature = "aws")]
diff --git a/litellm-rust/crates/secrets/src/native.rs b/litellm-rust/crates/secrets/src/native.rs
new file mode 100644
index 000000000000..80f0e46245cc
--- /dev/null
+++ b/litellm-rust/crates/secrets/src/native.rs
@@ -0,0 +1,61 @@
+use std::sync::Arc;
+
+use litellm_core_utils::settings::Lookup;
+
+use crate::{Error, KeyManagementSettings, KeyManagementSystem, SecretManager};
+
+pub async fn load_native_manager(
+    system: KeyManagementSystem,
+    settings: KeyManagementSettings,
+    environment: Arc<dyn Lookup + Send + Sync>,
+    enterprise_enabled: bool,
+) -> Result<SecretManager, Error> {
+    match (system, settings, environment, enterprise_enabled) {
+        #[cfg(feature = "aws")]
+        (KeyManagementSystem::AwsSecretManager, settings, environment, _) => {
+            crate::aws::AwsSecretsManagerV2::load_aws_secret_manager(
+                Some(true),
+                settings,
+                environment,
+            )?
+            .map(SecretManager::AwsSecretsManagerV2)
+            .ok_or(Error::NativeBackendUnavailable)
+        }
+        #[cfg(feature = "aws")]
+        (KeyManagementSystem::AwsKms, settings, environment, _) => {
+            crate::aws::load_aws_kms(Some(true), &settings, environment)?
+                .map(SecretManager::AwsKms)
+                .ok_or(Error::NativeBackendUnavailable)
+        }
+        #[cfg(feature = "azure")]
+        (KeyManagementSystem::AzureKeyVault, _, environment, _) => Ok(
+            SecretManager::AzureKeyVault(crate::azure::AzureKeyVault::new(environment)?),
+        ),
+        #[cfg(feature = "google")]
+        (KeyManagementSystem::GoogleSecretManager, _, environment, enterprise_enabled) => {
+            Ok(SecretManager::GoogleSecretManager(
+                crate::google::GoogleSecretManager::new(environment, enterprise_enabled)?,
+            ))
+        }
+        #[cfg(feature = "google")]
+        (KeyManagementSystem::GoogleKms, _, environment, _) => {
+            crate::google::load_google_kms(Some(true), environment)
+                .await?
+                .map(SecretManager::GoogleKms)
+                .ok_or(Error::NativeBackendUnavailable)
+        }
+        #[cfg(feature = "hashicorp")]
+        (KeyManagementSystem::HashicorpVault, _, environment, enterprise_enabled) => {
+            Ok(SecretManager::HashicorpVault(
+                crate::hashicorp::HashicorpVault::new(environment, enterprise_enabled)?,
+            ))
+        }
+        #[cfg(feature = "cyberark")]
+        (KeyManagementSystem::Cyberark, _, environment, enterprise_enabled) => {
+            Ok(SecretManager::Cyberark(
+                crate::cyberark::CyberArkSecretManager::new(environment, enterprise_enabled)?,
+            ))
+        }
+        _ => Err(Error::NativeBackendUnavailable),
+    }
+}
diff --git a/litellm-rust/crates/secrets/src/oidc.rs b/litellm-rust/crates/secrets/src/oidc.rs
index fd477859bf66..f3c1e38ce7bb 100644
--- a/litellm-rust/crates/secrets/src/oidc.rs
+++ b/litellm-rust/crates/secrets/src/oidc.rs
@@ -3,7 +3,7 @@ use std::{
     time::{Duration, SystemTime, UNIX_EPOCH},
 };
 
-use jsonwebtoken::dangerous::insecure_decode_claims;
+use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
 use litellm_core_utils::settings::Lookup;
 use moka::future::Cache;
 use serde::Deserialize;
@@ -67,13 +67,15 @@ struct OidcTokenClaims {
 enum NumericDate {
     Number(f64),
     String(String),
+    Boolean(bool),
 }
 
 impl NumericDate {
     fn seconds(self) -> Option<f64> {
         match self {
             Self::Number(value) => Some(value),
-            Self::String(value) => value.parse().ok(),
+            Self::String(value) => value.trim().parse().ok(),
+            Self::Boolean(value) => Some(f64::from(u8::from(value))),
         }
         .filter(|value| value.is_finite())
     }
@@ -84,6 +86,8 @@ pub struct OidcResolver {
     google_identity_endpoint: reqwest::Url,
     cache: Cache<String, (SecretValue, SystemTime)>,
     clock: fn() -> SystemTime,
+    #[cfg(feature = "azure")]
+    azure_token_provider: std::sync::Arc<dyn litellm_secrets_azure::AzureTokenProvider>,
 }
 
 impl Default for OidcResolver {
@@ -110,6 +114,21 @@ impl OidcResolver {
                 .time_to_live(GOOGLE_TOKEN_MAX_TTL)
                 .build(),
             clock: SystemTime::now,
+            #[cfg(feature = "azure")]
+            azure_token_provider: std::sync::Arc::new(
+                litellm_secrets_azure::NativeAzureTokenProvider::default(),
+            ),
+        }
+    }
+
+    #[cfg(feature = "azure")]
+    pub fn with_azure_token_provider(
+        self,
+        provider: std::sync::Arc<dyn litellm_secrets_azure::AzureTokenProvider>,
+    ) -> Self {
+        Self {
+            azure_token_provider: provider,
+            ..self
         }
     }
 
@@ -141,6 +160,15 @@ impl OidcResolver {
                 if let Some(path) = environment.get(AZURE_FEDERATED_TOKEN_FILE) {
                     return read_file(&path).await.map(Some);
                 }
+                #[cfg(feature = "azure")]
+                {
+                    self.azure_token_provider
+                        .get_token(audience, environment)
+                        .await
+                        .map(Some)
+                        .map_err(Error::Azure)
+                }
+                #[cfg(not(feature = "azure"))]
                 Err(Error::UnsupportedOidc)
             }
             OidcProvider::Github => {
@@ -256,7 +284,14 @@ async fn read_allowed_file(
 
 fn oidc_token_cache_ttl(token: &str, now: SystemTime, max_ttl: Duration) -> Option<Duration> {
     let fallback = Some(max_ttl);
-    let Ok(claims) = insecure_decode_claims::<OidcTokenClaims>(token) else {
+    let segments: Vec<_> = token.split('.').collect();
+    let [_, payload, _] = segments.as_slice() else {
+        return fallback;
+    };
+    let Ok(decoded) = URL_SAFE_NO_PAD.decode(payload.trim_end_matches('=')) else {
+        return fallback;
+    };
+    let Ok(claims) = serde_json::from_slice::<OidcTokenClaims>(&decoded) else {
         return fallback;
     };
     let Some(exp) = claims.exp.and_then(NumericDate::seconds) else {
diff --git a/litellm-rust/crates/secrets/src/resolver.rs b/litellm-rust/crates/secrets/src/resolver.rs
index 597ca11b171f..69445e5b4105 100644
--- a/litellm-rust/crates/secrets/src/resolver.rs
+++ b/litellm-rust/crates/secrets/src/resolver.rs
@@ -1,6 +1,10 @@
 use std::sync::Arc;
 
-use litellm_core_utils::settings::{Lookup, ProcessEnvironment};
+use crate::compatibility::python_manager_string;
+use litellm_core_utils::{
+    serde_compat::parse_str_bool,
+    settings::{Lookup, ProcessEnvironment},
+};
 
 use crate::state::{LookupTarget, normalize_secret_name};
 use crate::{Error, OidcResolver, Secret, SecretManagerState, SecretValue};
@@ -17,6 +21,7 @@ pub struct SecretResolver {
     environment: Arc<dyn Lookup + Send + Sync>,
     oidc: OidcResolver,
     failure_policy: FailurePolicy,
+    python_compatible: bool,
 }
 
 impl Default for SecretResolver {
@@ -40,6 +45,19 @@ impl SecretResolver {
             environment,
             oidc,
             failure_policy: FailurePolicy::default(),
+            python_compatible: false,
+        }
+    }
+
+    pub fn new_python_compatible(
+        state: Arc<SecretManagerState>,
+        environment: Arc<dyn Lookup + Send + Sync>,
+        oidc: OidcResolver,
+    ) -> Self {
+        Self {
+            python_compatible: true,
+            failure_policy: FailurePolicy::EnvironmentFallback,
+            ..Self::new(state, environment, oidc)
         }
     }
 
@@ -54,6 +72,19 @@ impl SecretResolver {
         &self,
         name: &str,
         default_value: Option<Secret>,
+    ) -> Result<Option<Secret>, Error> {
+        let value = self.read(name, default_value.clone()).await?;
+        Ok(if self.python_compatible {
+            value
+        } else {
+            value.or(default_value)
+        })
+    }
+
+    async fn read(
+        &self,
+        name: &str,
+        default_value: Option<Secret>,
     ) -> Result<Option<Secret>, Error> {
         let name = normalize_secret_name(name);
         if name.starts_with("oidc/") {
@@ -61,36 +92,38 @@ impl SecretResolver {
                 .oidc
                 .resolve(name, self.environment.as_ref())
                 .await
-                .map(|value| value.map(Secret::String).or(default_value));
+                .map(|value| value.map(Secret::String));
         }
         let LookupTarget::Manager { backend, settings } = self.state.lookup_target(name) else {
-            return Ok(self.environment_secret(name).or(default_value));
+            return Ok(self.environment_value(name));
         };
-        match crate::get_secret_from_manager(backend, name, settings, self.environment.as_ref())
+        let result = if self.python_compatible {
+            crate::get_secret_from_python_manager(
+                backend,
+                name,
+                settings,
+                self.environment.as_ref(),
+            )
             .await
-        {
-            Ok(value) => Ok(value
-                .or_else(|| self.environment_secret(name))
-                .or(default_value)),
+        } else {
+            crate::get_secret_from_manager(backend, name, settings, self.environment.as_ref()).await
+        };
+        match result {
+            Ok(value) => Ok(value.and_then(|value| self.manager_value(value))),
             Err(error @ Error::ExternalManager(_)) => Err(error),
             Err(error) => match self.failure_policy {
+                FailurePolicy::Propagate if self.python_compatible => {
+                    default_value.map(Some).ok_or(error)
+                }
                 FailurePolicy::Propagate => Err(error),
-                FailurePolicy::EnvironmentFallback => self
-                    .environment_secret(name)
-                    .or(default_value)
-                    .map(Some)
-                    .ok_or(error),
+                FailurePolicy::EnvironmentFallback => Ok(self
+                    .environment
+                    .get(name)
+                    .and_then(|value| self.manager_value(Secret::String(SecretValue::new(value))))),
             },
         }
     }
 
-    fn environment_secret(&self, name: &str) -> Option<Secret> {
-        self.environment
-            .get(name)
-            .map(SecretValue::new)
-            .map(Secret::String)
-    }
-
     pub async fn get_secret_str(
         &self,
         name: &str,
@@ -102,6 +135,7 @@ impl SecretResolver {
         {
             Some(Secret::String(value)) => Ok(Some(value)),
             None => Ok(None),
+            Some(Secret::Bool(_) | Secret::Json(_)) if self.python_compatible => Ok(None),
             Some(Secret::Bool(_) | Secret::Json(_)) => {
                 Err(Error::TypeMismatch { expected: "string" })
             }
@@ -118,19 +152,57 @@ impl SecretResolver {
             .await?
         {
             Some(Secret::Bool(value)) => Ok(Some(value)),
-            Some(Secret::String(value)) => {
-                match value.expose().trim().to_ascii_lowercase().as_str() {
-                    "true" => Ok(Some(true)),
-                    "false" => Ok(Some(false)),
-                    _ => Err(Error::TypeMismatch {
-                        expected: "boolean",
-                    }),
-                }
-            }
+            Some(Secret::String(value)) => match parse_str_bool(value.expose()) {
+                Some(value) => Ok(Some(value)),
+                None if self.python_compatible => Ok(None),
+                None => Err(Error::TypeMismatch {
+                    expected: "boolean",
+                }),
+            },
+            Some(Secret::Json(_)) if self.python_compatible => Ok(None),
             Some(Secret::Json(_)) => Err(Error::TypeMismatch {
                 expected: "boolean",
             }),
             None => Ok(None),
         }
     }
+
+    fn environment_value(&self, name: &str) -> Option<Secret> {
+        let value = self.environment.get(name)?;
+        if !self.python_compatible {
+            return Some(Secret::String(SecretValue::new(value)));
+        }
+        if self
+            .state
+            .settings()
+            .is_some_and(|settings| settings.access_mode.readable())
+        {
+            return Some(python_manager_string(SecretValue::new(value)));
+        }
+        Some(
+            parse_str_bool(&value)
+                .map_or_else(|| Secret::String(SecretValue::new(value)), Secret::Bool),
+        )
+    }
+
+    fn manager_value(&self, secret: Secret) -> Option<Secret> {
+        if !self.python_compatible {
+            return Some(secret);
+        }
+
+        let Secret::String(value) = secret else {
+            return None;
+        };
+        Some(python_manager_string(value))
+    }
+}
+
+pub fn normalize_nonempty_secret_str(value: Option<&str>) -> Option<&str> {
+    value
+        .map(|value| {
+            value.trim_matches(|character: char| {
+                character.is_whitespace() || matches!(character, '\u{1c}'..='\u{1f}')
+            })
+        })
+        .filter(|value| !value.is_empty())
 }
diff --git a/litellm-rust/crates/secrets/src/source.rs b/litellm-rust/crates/secrets/src/source.rs
new file mode 100644
index 000000000000..a1615bad055b
--- /dev/null
+++ b/litellm-rust/crates/secrets/src/source.rs
@@ -0,0 +1,73 @@
+use std::{collections::HashMap, sync::Arc};
+
+use futures_util::future::{BoxFuture, try_join_all};
+use litellm_core_utils::settings::Lookup;
+
+use crate::{Error, SecretResolver, SecretValue};
+
+pub type Secrets = Arc<dyn Lookup + Send + Sync>;
+
+pub trait SecretSource: Send + Sync {
+    fn get_secret_str<'a>(
+        &'a self,
+        name: &'a str,
+    ) -> BoxFuture<'a, Result<Option<SecretValue>, Error>>;
+
+    fn resolve<'a>(&'a self, names: &'a [&str]) -> BoxFuture<'a, Result<Secrets, Error>> {
+        Box::pin(async move {
+            let values = try_join_all(names.iter().map(|name| async move {
+                self.get_secret_str(name)
+                    .await
+                    .map(|value| ((*name).to_owned(), value))
+            }))
+            .await?
+            .into_iter()
+            .collect();
+            Ok(Arc::new(SecretSnapshot { values }) as Secrets)
+        })
+    }
+}
+
+impl SecretSource for SecretResolver {
+    fn get_secret_str<'a>(
+        &'a self,
+        name: &'a str,
+    ) -> BoxFuture<'a, Result<Option<SecretValue>, Error>> {
+        Box::pin(SecretResolver::get_secret_str(self, name, None))
+    }
+}
+
+#[derive(Default)]
+pub struct EnvironmentSecrets(SecretResolver);
+
+impl EnvironmentSecrets {
+    pub fn python_compatible() -> Self {
+        Self(SecretResolver::new_python_compatible(
+            Arc::new(crate::SecretManagerState::default()),
+            Arc::new(litellm_core_utils::settings::ProcessEnvironment),
+            crate::OidcResolver::default(),
+        ))
+    }
+}
+
+impl SecretSource for EnvironmentSecrets {
+    fn get_secret_str<'a>(
+        &'a self,
+        name: &'a str,
+    ) -> BoxFuture<'a, Result<Option<SecretValue>, Error>> {
+        Box::pin(self.0.get_secret_str(name, None))
+    }
+}
+
+struct SecretSnapshot {
+    values: HashMap<String, Option<SecretValue>>,
+}
+
+impl Lookup for SecretSnapshot {
+    fn get(&self, name: &str) -> Option<String> {
+        self.values
+            .get(name)
+            .and_then(Option::as_ref)
+            .map(|value| value.expose().to_owned())
+    }
+}
diff --git a/litellm-rust/crates/secrets/tests/aws.rs b/litellm-rust/crates/secrets/tests/aws.rs
new file mode 100644
index 000000000000..174d08813392
--- /dev/null
+++ b/litellm-rust/crates/secrets/tests/aws.rs
@@ -0,0 +1,223 @@
+#![cfg(feature = "aws")]
+
+use std::sync::Arc;
+
+use litellm_secrets::{
+    AccessMode, Error, FailurePolicy, KeyManagementSettings, OidcResolver, Secret, SecretManager,
+    SecretManagerState, SecretResolver, SecretValue, aws::AwsSecretsManagerV2,
+    secret_manager_would_be_consulted,
+};
+use wiremock::{Mock, MockServer, ResponseTemplate, matchers::method};
+
+fn state(server: &MockServer, settings: KeyManagementSettings) -> SecretManagerState {
+    let endpoint = server.uri();
+    let environment = Arc::new(move |name: &str| match name {
+        "AWS_REGION_NAME" => Some("us-east-1".into()),
+        "AWS_ACCESS_KEY_ID" | "AWS_SECRET_ACCESS_KEY" => Some("test".into()),
+        "AWS_BEDROCK_RUNTIME_ENDPOINT" => Some(endpoint.clone()),
+        _ => None,
+    });
+    let manager =
+        AwsSecretsManagerV2::load_aws_secret_manager(Some(true), settings.clone(), environment)
+            .unwrap()
+            .unwrap();
+    SecretManagerState::new(SecretManager::AwsSecretsManagerV2(manager), settings)
+}
+
+#[rstest::rstest]
+#[case::missing(400, serde_json::json!({"__type":"ResourceNotFoundException"}), None)]
+#[case::denied(400, serde_json::json!({"__type":"AccessDeniedException"}), None)]
+#[case::malformed(200, serde_json::json!({}), None)]
+#[case::invalid_primary(200, serde_json::json!({"SecretString":"not-json"}), Some("primary"))]
+#[tokio::test]
+async fn read_results_follow_the_selected_failure_policy(
+    #[case] status: u16,
+    #[case] body: serde_json::Value,
+    #[case] primary_secret_name: Option<&str>,
+    #[values(FailurePolicy::Propagate, FailurePolicy::EnvironmentFallback)] policy: FailurePolicy,
+    #[values(None, Some("environment"))] environment: Option<&'static str>,
+    #[values(None, Some("default"))] default: Option<&str>,
+) {
+    let server = MockServer::start().await;
+    Mock::given(method("POST"))
+        .respond_with(ResponseTemplate::new(status).set_body_json(body.clone()))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let resolver = SecretResolver::new_python_compatible(
+        Arc::new(state(
+            &server,
+            KeyManagementSettings {
+                primary_secret_name: primary_secret_name.map(str::to_owned),
+                ..Default::default()
+            },
+        )),
+        Arc::new(move |_: &str| environment.map(str::to_owned)),
+        OidcResolver::default(),
+    )
+    .with_failure_policy(policy);
+    let result = resolver
+        .get_secret_str("KEY", default.map(SecretValue::new))
+        .await;
+    if primary_secret_name.is_none() {
+        assert_eq!(result.unwrap(), None);
+    } else if policy == FailurePolicy::EnvironmentFallback {
+        assert_eq!(
+            result.unwrap().as_ref().map(SecretValue::expose),
+            environment
+        );
+    } else if let Some(default) = default {
+        assert_eq!(result.unwrap().unwrap().expose(), default);
+    } else {
+        assert!(matches!(result, Err(Error::Aws(_))));
+    }
+}
+
+#[rstest::rstest]
+#[case::boolean(serde_json::json!(false))]
+#[case::object(serde_json::json!({"key":1}))]
+#[case::null(serde_json::Value::Null)]
+#[case::string(serde_json::json!("true"))]
+#[tokio::test]
+async fn primary_secret_values_other_than_strings_resolve_to_none(
+    #[case] value: serde_json::Value,
+) {
+    let server = MockServer::start().await;
+    Mock::given(method("POST"))
+        .respond_with(ResponseTemplate::new(200).set_body_json(
+            serde_json::json!({"SecretString":serde_json::json!({"KEY":value}).to_string()}),
+        ))
+        .expect(3)
+        .mount(&server)
+        .await;
+    let settings = KeyManagementSettings {
+        primary_secret_name: Some("primary".into()),
+        ..Default::default()
+    };
+    let resolver = SecretResolver::new_python_compatible(
+        Arc::new(state(&server, settings)),
+        Arc::new(|_: &str| Some("fallback".into())),
+        OidcResolver::default(),
+    );
+    let text = value.as_str();
+    assert_eq!(
+        resolver
+            .get_secret("KEY", Some(Secret::Bool(true)))
+            .await
+            .unwrap(),
+        text.map(|text| Secret::String(SecretValue::new(text)))
+    );
+    assert_eq!(
+        resolver
+            .get_secret_str("KEY", None)
+            .await
+            .unwrap()
+            .as_ref()
+            .map(SecretValue::expose),
+        text
+    );
+    assert_eq!(
+        resolver.get_secret_bool("KEY", None).await.unwrap(),
+        text.map(|_| true)
+    );
+}
+
+#[rstest::rstest]
+#[tokio::test]
+async fn gating_prediction_matches_actual_lookup(
+    #[values(AccessMode::ReadOnly, AccessMode::WriteOnly, AccessMode::ReadAndWrite)]
+    access_mode: AccessMode,
+    #[values(None, Some(vec![]), Some(vec!["KEY".into()]))] hosted_keys: Option<Vec<String>>,
+    #[values("os.environ/KEY", "os.environ/oidc/env/KEY")] name: &str,
+) {
+    let server = MockServer::start().await;
+    let expected = name == "os.environ/KEY"
+        && access_mode.readable()
+        && hosted_keys
+            .as_ref()
+            .is_none_or(|keys| keys.iter().any(|key| key == "KEY"));
+    Mock::given(method("POST"))
+        .respond_with(
+            ResponseTemplate::new(200).set_body_json(serde_json::json!({"SecretString":"remote"})),
+        )
+        .expect(u64::from(expected))
+        .mount(&server)
+        .await;
+    let state = state(
+        &server,
+        KeyManagementSettings {
+            access_mode,
+            hosted_keys,
+            ..Default::default()
+        },
+    );
+    assert!(state.backend().is_some());
+    assert_eq!(state.settings().unwrap().access_mode, access_mode);
+    assert_eq!(secret_manager_would_be_consulted(&state, name), expected);
+    let resolver = SecretResolver::new_python_compatible(
+        Arc::new(state),
+        Arc::new(|_: &str| Some("environment".into())),
+        OidcResolver::default(),
+    );
+    assert_eq!(
+        resolver
+            .get_secret_str(name, None)
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        if expected { "remote" } else { "environment" }
+    );
+}
+
+#[tokio::test]
+async fn aws_handler_reads_ciphertext_decodes_trims_and_redacts() {
+    use aws_sdk_kms::{
+        Client,
+        config::{BehaviorVersion, Credentials, Region},
+    };
+    use base64::{Engine, engine::general_purpose::STANDARD};
+    use litellm_secrets::{
+        Error, KeyManagementSettings, SecretManager, aws::AwsKms, get_secret_from_manager,
+    };
+    use wiremock::{Mock, MockServer, ResponseTemplate, matchers::body_json};
+
+    let server = MockServer::start().await;
+    Mock::given(body_json(
+        serde_json::json!({"CiphertextBlob": STANDARD.encode("encrypted")}),
+    ))
+    .respond_with(
+        ResponseTemplate::new(200)
+            .set_body_json(serde_json::json!({"Plaintext":STANDARD.encode(" value\n")})),
+    )
+    .expect(1)
+    .mount(&server)
+    .await;
+    let client = Client::from_conf(
+        aws_sdk_kms::Config::builder()
+            .behavior_version(BehaviorVersion::latest())
+            .region(Region::new("us-east-1"))
+            .credentials_provider(Credentials::new("test", "test", None, None, "test"))
+            .endpoint_url(server.uri())
+            .build(),
+    );
+    let manager = SecretManager::AwsKms(AwsKms::new(client));
+    let settings = KeyManagementSettings::default();
+    let value = get_secret_from_manager(&manager, "KEY", &settings, &|name: &str| {
+        assert_eq!(name, "KEY");
+        Some(format!(" {}\n", STANDARD.encode("encrypted")))
+    })
+    .await
+    .unwrap()
+    .unwrap();
+    assert_eq!(value.as_str(), Some("value"));
+    assert!(!format!("{value:?}").contains("value"));
+    assert!(matches!(
+        get_secret_from_manager(&manager, "KEY", &settings, &|_: &str| None).await,
+        Err(Error::MissingCiphertext)
+    ));
+    assert!(matches!(
+        get_secret_from_manager(&manager, "KEY", &settings, &|_: &str| Some("abc".into())).await,
+        Err(Error::InvalidCiphertext)
+    ));
+}
diff --git a/litellm-rust/crates/secrets/tests/azure.rs b/litellm-rust/crates/secrets/tests/azure.rs
new file mode 100644
index 000000000000..b844b198cd4b
--- /dev/null
+++ b/litellm-rust/crates/secrets/tests/azure.rs
@@ -0,0 +1,106 @@
+#![cfg(feature = "azure")]
+
+#[tokio::test]
+async fn azure_handler_reads_missing_and_failed_secrets() {
+    use litellm_secrets::{
+        Error, KeyManagementSettings, KeyManagementSystem, SecretManager, azure::AzureKeyVault,
+        get_secret_from_manager,
+    };
+    use wiremock::{
+        Mock, MockServer, ResponseTemplate,
+        matchers::{path, query_param},
+    };
+
+    let server = MockServer::start().await;
+    Mock::given(path("/secrets/KEY"))
+        .and(query_param("api-version", "7.4"))
+        .respond_with(
+            ResponseTemplate::new(200).set_body_json(serde_json::json!({"value": "value"})),
+        )
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager = SecretManager::AzureKeyVault(
+        AzureKeyVault::with_client(
+            reqwest::Client::new(),
+            server.uri().parse().unwrap(),
+            std::sync::Arc::new(|name: &str| (name == "AZURE_AD_TOKEN").then(|| "fake".to_owned())),
+        )
+        .unwrap(),
+    );
+    assert_eq!(manager.system(), KeyManagementSystem::AzureKeyVault);
+    let settings = KeyManagementSettings::default();
+    let value = get_secret_from_manager(&manager, "KEY", &settings, &|_: &str| None)
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(value.as_str(), Some("value"));
+
+    let not_found = Mock::given(path("/secrets/MISSING"))
+        .respond_with(ResponseTemplate::new(404))
+        .expect(1)
+        .mount_as_scoped(&server)
+        .await;
+    assert_eq!(
+        get_secret_from_manager(&manager, "MISSING", &settings, &|_: &str| None)
+            .await
+            .unwrap(),
+        None
+    );
+    drop(not_found);
+
+    Mock::given(path("/secrets/FAILED"))
+        .respond_with(ResponseTemplate::new(500))
+        .expect(1)
+        .mount(&server)
+        .await;
+    assert!(matches!(
+        get_secret_from_manager(&manager, "FAILED", &settings, &|_: &str| None).await,
+        Err(Error::Azure(_))
+    ));
+}
+
+#[rstest::rstest]
+#[case::null(serde_json::json!({"value":null}))]
+#[case::absent(serde_json::json!({}))]
+#[case::empty(serde_json::json!({"value":""}))]
+#[tokio::test]
+async fn successful_azure_responses_do_not_fall_back_when_the_value_is_empty_or_null(
+    #[case] body: serde_json::Value,
+) {
+    use litellm_secrets::{
+        OidcResolver, SecretManager, SecretManagerState, SecretResolver, SecretValue,
+        azure::AzureKeyVault,
+    };
+    use std::sync::Arc;
+    use wiremock::{Mock, MockServer, ResponseTemplate, matchers::any};
+    let server = MockServer::start().await;
+    Mock::given(any())
+        .respond_with(ResponseTemplate::new(200).set_body_json(body.clone()))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let manager = AzureKeyVault::with_client(
+        reqwest::Client::new(),
+        server.uri().parse().unwrap(),
+        Arc::new(|name: &str| (name == "AZURE_AD_TOKEN").then(|| "token".into())),
+    )
+    .unwrap();
+    let resolver = SecretResolver::new_python_compatible(
+        Arc::new(SecretManagerState::new(
+            SecretManager::AzureKeyVault(manager),
+            Default::default(),
+        )),
+        Arc::new(|_: &str| Some("environment".into())),
+        OidcResolver::default(),
+    );
+    assert_eq!(
+        resolver
+            .get_secret_str("KEY", Some(SecretValue::new("default")))
+            .await
+            .unwrap()
+            .as_ref()
+            .map(SecretValue::expose),
+        body.get("value").and_then(serde_json::Value::as_str)
+    );
+}
diff --git a/litellm-rust/crates/secrets/tests/common_read_contract.rs b/litellm-rust/crates/secrets/tests/common_read_contract.rs
new file mode 100644
index 000000000000..698e1ad8f630
--- /dev/null
+++ b/litellm-rust/crates/secrets/tests/common_read_contract.rs
@@ -0,0 +1,260 @@
+#![cfg(all(
+    feature = "aws",
+    feature = "azure",
+    feature = "google",
+    feature = "hashicorp",
+    feature = "cyberark"
+))]
+use std::sync::Arc;
+
+use base64::{Engine, engine::general_purpose::STANDARD};
+use litellm_core_utils::settings::Lookup;
+use litellm_secrets::{
+    KeyManagementSettings, SecretManager, SecretValue,
+    aws::AwsSecretsManagerV2,
+    azure::AzureKeyVault,
+    cyberark::CyberArkSecretManager,
+    get_secret_from_manager,
+    google::GoogleSecretManager,
+    hashicorp::{HashicorpVault, HashicorpVaultConfig},
+};
+use rstest::rstest;
+use serde_json::json;
+use wiremock::{
+    Mock, MockServer, ResponseTemplate,
+    matchers::{any, path},
+};
+
+#[derive(Clone, Copy, Debug)]
+enum Provider {
+    Aws,
+    Azure,
+    Google,
+    Vault,
+    Cyberark,
+}
+
+fn manager(provider: Provider, server: &MockServer) -> SecretManager {
+    let environment: Arc<dyn Lookup + Send + Sync> = Arc::new({
+        let address = server.uri();
+        move |name: &str| match name {
+            "HCP_VAULT_ADDR" | "AWS_BEDROCK_RUNTIME_ENDPOINT" => Some(address.clone()),
+            "AWS_ACCESS_KEY_ID" | "AWS_SECRET_ACCESS_KEY" => Some("test".into()),
+            "AZURE_AD_TOKEN" | "VERTEX_AI_API_KEY" | "HCP_VAULT_TOKEN" => Some("token".into()),
+            _ => None,
+        }
+    });
+    match provider {
+        Provider::Aws => SecretManager::AwsSecretsManagerV2(
+            AwsSecretsManagerV2::load_aws_secret_manager(
+                Some(true),
+                KeyManagementSettings {
+                    aws_region_name: Some("us-east-1".into()),
+                    ..Default::default()
+                },
+                environment,
+            )
+            .unwrap()
+            .unwrap(),
+        ),
+        Provider::Azure => SecretManager::AzureKeyVault(
+            AzureKeyVault::with_client(
+                reqwest::Client::new(),
+                server.uri().parse().unwrap(),
+                environment,
+            )
+            .unwrap(),
+        ),
+        Provider::Google => SecretManager::GoogleSecretManager(
+            GoogleSecretManager::with_client(
+                reqwest::Client::new(),
+                server.uri().parse().unwrap(),
+                "project".into(),
+                environment,
+                None,
+                false,
+            )
+            .unwrap(),
+        ),
+        Provider::Vault => SecretManager::HashicorpVault(
+            HashicorpVault::from_config(
+                HashicorpVaultConfig::from_environment(environment.as_ref()).unwrap(),
+                true,
+            )
+            .unwrap(),
+        ),
+        Provider::Cyberark => SecretManager::Cyberark(CyberArkSecretManager::with_client(
+            reqwest::Client::new(),
+            server.uri().parse().unwrap(),
+            "acct".into(),
+            "admin".into(),
+            SecretValue::new("key"),
+            None,
+        )),
+    }
+}
+
+fn response(provider: Provider, value: &str) -> ResponseTemplate {
+    match provider {
+        Provider::Aws => ResponseTemplate::new(200).set_body_json(json!({"SecretString": value})),
+        Provider::Azure => ResponseTemplate::new(200).set_body_json(json!({"value": value})),
+        Provider::Google => ResponseTemplate::new(200)
+            .set_body_json(json!({"payload": {"data": STANDARD.encode(value)}})),
+        Provider::Vault => ResponseTemplate::new(200).set_body_json(json!({
+            "data": {"data": {"key": value}, "metadata": {
+                "created_time": "", "deletion_time": "", "custom_metadata": null,
+                "destroyed": false, "version": 1
+            }}, "lease_id": "", "lease_duration": 0, "renewable": false,
+            "request_id": "", "warnings": null, "wrap_info": null
+        })),
+        Provider::Cyberark => ResponseTemplate::new(200).set_body_string(value),
+    }
+}
+
+#[rstest]
+#[case::aws(Provider::Aws)]
+#[case::azure(Provider::Azure)]
+#[case::google(Provider::Google)]
+#[case::vault(Provider::Vault)]
+#[case::cyberark(Provider::Cyberark)]
+#[tokio::test]
+async fn reads_preserve_values_and_distinguish_absence_from_failure(#[case] provider: Provider) {
+    let server = MockServer::start().await;
+    Mock::given(path("/authn/acct/admin/authenticate"))
+        .respond_with(ResponseTemplate::new(200).set_body_string("token"))
+        .with_priority(1)
+        .mount(&server)
+        .await;
+    let manager = manager(provider, &server);
+    let settings = KeyManagementSettings::default();
+    for (name, value) in [
+        ("TEXT", " value\n"),
+        ("EMPTY", ""),
+        ("BOOLEAN", "True"),
+        ("JSON", "{\"key\":1}"),
+    ] {
+        let guard = Mock::given(any())
+            .respond_with(response(provider, value))
+            .with_priority(2)
+            .mount_as_scoped(&server)
+            .await;
+        for _ in 0..2 {
+            let result = get_secret_from_manager(&manager, name, &settings, &|_: &str| None)
+                .await
+                .unwrap()
+                .unwrap();
+            assert_eq!(result.as_str(), Some(value));
+        }
+        drop(guard);
+    }
+    let missing = match provider {
+        Provider::Aws => ResponseTemplate::new(400)
+            .set_body_json(json!({"__type": "ResourceNotFoundException", "Message": "missing"})),
+        _ => ResponseTemplate::new(404).set_body_json(json!({"errors": ["missing"]})),
+    };
+    let guard = Mock::given(any())
+        .respond_with(missing)
+        .with_priority(2)
+        .expect(2)
+        .mount_as_scoped(&server)
+        .await;
+    for _ in 0..2 {
+        assert!(
+            get_secret_from_manager(&manager, "MISSING", &settings, &|_: &str| None)
+                .await
+                .unwrap()
+                .is_none()
+        );
+    }
+    drop(guard);
+    let guard = Mock::given(any())
+        .respond_with(ResponseTemplate::new(403).set_body_json(json!({"errors": ["forbidden"]})))
+        .with_priority(2)
+        .expect(2)
+        .mount_as_scoped(&server)
+        .await;
+    for _ in 0..2 {
+        assert!(
+            get_secret_from_manager(&manager, "FAILED", &settings, &|_: &str| None)
+                .await
+                .is_err()
+        );
+    }
+    drop(guard);
+    let guard = Mock::given(any())
+        .respond_with(response(provider, "recovered"))
+        .with_priority(2)
+        .expect(2)
+        .mount_as_scoped(&server)
+        .await;
+    for name in ["MISSING", "FAILED"] {
+        assert_eq!(
+            get_secret_from_manager(&manager, name, &settings, &|_: &str| None)
+                .await
+                .unwrap()
+                .unwrap()
+                .as_str(),
+            Some("recovered")
+        );
+    }
+    drop(guard);
+}
+
+#[rstest]
+#[case::aws(Provider::Aws)]
+#[case::azure(Provider::Azure)]
+#[case::google(Provider::Google)]
+#[case::vault(Provider::Vault)]
+#[case::cyberark(Provider::Cyberark)]
+#[tokio::test]
+async fn python_read_failures_preserve_provider_fallback_rules(
+    #[case] provider: Provider,
+    #[values(false, true)] missing: bool,
+    #[values(None, Some("environment"), Some("True"), Some("true"))] environment_value: Option<
+        &'static str,
+    >,
+) {
+    use litellm_secrets::{OidcResolver, Secret, SecretManagerState, SecretResolver};
+    let server = MockServer::start().await;
+    Mock::given(path("/authn/acct/admin/authenticate"))
+        .respond_with(ResponseTemplate::new(200).set_body_string("token"))
+        .with_priority(1)
+        .mount(&server)
+        .await;
+    let response = match (provider, missing) {
+        (Provider::Aws, true) => {
+            ResponseTemplate::new(400).set_body_json(json!({"__type":"ResourceNotFoundException"}))
+        }
+        (_, true) => ResponseTemplate::new(404).set_body_json(json!({"errors":["missing"]})),
+        (_, false) => ResponseTemplate::new(403).set_body_json(json!({"errors":["forbidden"]})),
+    };
+    Mock::given(any())
+        .respond_with(response)
+        .with_priority(2)
+        .expect(1)
+        .mount(&server)
+        .await;
+    let resolver = SecretResolver::new_python_compatible(
+        Arc::new(SecretManagerState::new(
+            manager(provider, &server),
+            KeyManagementSettings::default(),
+        )),
+        Arc::new(move |_: &str| environment_value.map(str::to_owned)),
+        OidcResolver::default(),
+    );
+    let expected = if matches!(provider, Provider::Aws) {
+        None
+    } else {
+        environment_value.map(|value| match value {
+            "True" => Secret::Bool(true),
+            value => Secret::String(SecretValue::new(value)),
+        })
+    };
+    assert_eq!(
+        resolver
+            .get_secret("KEY", Some(Secret::String(SecretValue::new("default"))))
+            .await
+            .unwrap(),
+        expected
+    );
+}
diff --git a/litellm-rust/crates/secrets/tests/cyberark.rs b/litellm-rust/crates/secrets/tests/cyberark.rs
new file mode 100644
index 000000000000..706c35752d73
--- /dev/null
+++ b/litellm-rust/crates/secrets/tests/cyberark.rs
@@ -0,0 +1,53 @@
+#![cfg(feature = "cyberark")]
+
+#[tokio::test]
+async fn cyberark_handler_reads_values_and_surfaces_errors() {
+    use std::time::Duration;
+
+    use litellm_secrets::{
+        Error, KeyManagementSettings, SecretManager, SecretValue, cyberark::CyberArkSecretManager,
+        get_secret_from_manager,
+    };
+    use wiremock::{
+        Mock, MockServer, ResponseTemplate,
+        matchers::{body_string, path},
+    };
+
+    let server = MockServer::start().await;
+    Mock::given(path("/authn/acct/admin/authenticate"))
+        .and(body_string("k3y"))
+        .respond_with(ResponseTemplate::new(200).set_body_string("token"))
+        .mount(&server)
+        .await;
+    Mock::given(path("/secrets/acct/variable/KEY"))
+        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
+        .mount(&server)
+        .await;
+    let manager = SecretManager::Cyberark(CyberArkSecretManager::with_client(
+        reqwest::Client::new(),
+        server.uri().parse().unwrap(),
+        "acct".into(),
+        "admin".into(),
+        SecretValue::new("k3y"),
+        Some(Duration::from_secs(60)),
+    ));
+    assert_eq!(
+        manager.system(),
+        litellm_secrets::KeyManagementSystem::Cyberark
+    );
+    let settings = KeyManagementSettings::default();
+    let value = get_secret_from_manager(&manager, "KEY", &settings, &|_: &str| None)
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(value.as_str(), Some("value"));
+
+    Mock::given(path("/secrets/acct/variable/ERROR"))
+        .respond_with(ResponseTemplate::new(500))
+        .mount(&server)
+        .await;
+    assert!(matches!(
+        get_secret_from_manager(&manager, "ERROR", &settings, &|_: &str| None).await,
+        Err(Error::Cyberark(_))
+    ));
+}
diff --git a/litellm-rust/crates/secrets/tests/google.rs b/litellm-rust/crates/secrets/tests/google.rs
new file mode 100644
index 000000000000..67954fedb78d
--- /dev/null
+++ b/litellm-rust/crates/secrets/tests/google.rs
@@ -0,0 +1,117 @@
+#![cfg(feature = "google")]
+
+use std::sync::Arc;
+
+#[rstest::rstest]
+#[case::missing(404)]
+#[case::failure(503)]
+#[tokio::test]
+async fn google_resolver_distinguishes_absence_from_failure(#[case] status: u16) {
+    use litellm_secrets::{
+        Error, FailurePolicy, KeyManagementSettings, OidcResolver, SecretManager,
+        SecretManagerState, SecretResolver, SecretValue, google::GoogleSecretManager,
+    };
+    use wiremock::{Mock, MockServer, ResponseTemplate, matchers::method};
+    let server = MockServer::start().await;
+    Mock::given(method("GET"))
+        .respond_with(ResponseTemplate::new(status))
+        .expect(1)
+        .mount(&server)
+        .await;
+    let environment: Arc<dyn litellm_core_utils::settings::Lookup + Send + Sync> =
+        Arc::new(|name: &str| match name {
+            "VERTEX_AI_API_KEY" => Some("token".into()),
+            "KEY" => Some("environment".into()),
+            _ => None,
+        });
+    let manager = GoogleSecretManager::with_client(
+        reqwest::Client::new(),
+        server.uri().parse().unwrap(),
+        "project".into(),
+        environment.clone(),
+        None,
+        false,
+    )
+    .unwrap();
+    let state = SecretManagerState::new(
+        SecretManager::GoogleSecretManager(manager),
+        KeyManagementSettings::default(),
+    );
+    let resolver = SecretResolver::new_python_compatible(
+        Arc::new(state),
+        environment,
+        OidcResolver::default(),
+    )
+    .with_failure_policy(FailurePolicy::Propagate);
+    let result = resolver.get_secret_str("KEY", None).await;
+    if status == 404 {
+        assert!(matches!(result, Err(Error::ManagedSecretMissing)));
+    } else {
+        assert!(
+            matches!(result, Err(Error::Google(litellm_secrets::google::Error::Status(actual))) if actual == status)
+        );
+    }
+    let fallback = resolver
+        .with_failure_policy(FailurePolicy::EnvironmentFallback)
+        .get_secret_str("KEY", None)
+        .await
+        .unwrap();
+    assert_eq!(
+        fallback.as_ref().map(SecretValue::expose),
+        Some("environment")
+    );
+}
+
+#[tokio::test]
+async fn google_handler_requires_canonical_base64_and_preserves_plaintext_whitespace() {
+    use base64::{Engine, engine::general_purpose::STANDARD};
+    use google_cloud_kms_v1::client::KeyManagementService;
+    use litellm_secrets::{
+        Error, KeyManagementSettings, SecretManager, get_secret_from_manager, google::GoogleKms,
+    };
+    use wiremock::{
+        Mock, MockServer, ResponseTemplate,
+        matchers::{body_json, path},
+    };
+
+    let server = MockServer::start().await;
+    let resource = "projects/project/locations/global/keyRings/ring/cryptoKeys/key";
+    Mock::given(path(format!("/v1/{resource}:decrypt")))
+        .and(body_json(
+            serde_json::json!({"ciphertext":STANDARD.encode("encrypted")}),
+        ))
+        .respond_with(
+            ResponseTemplate::new(200)
+                .set_body_json(serde_json::json!({"plaintext":STANDARD.encode(" value\n")})),
+        )
+        .expect(1)
+        .mount(&server)
+        .await;
+    let client = KeyManagementService::builder()
+        .with_endpoint(server.uri())
+        .with_credentials(google_cloud_auth::credentials::anonymous::Builder::new().build())
+        .build()
+        .await
+        .unwrap();
+    let manager = SecretManager::GoogleKms(GoogleKms::new(client, resource.into()));
+    let settings = KeyManagementSettings::default();
+    let value = get_secret_from_manager(&manager, "KEY", &settings, &|_: &str| {
+        Some(STANDARD.encode("encrypted"))
+    })
+    .await
+    .unwrap()
+    .unwrap();
+    assert_eq!(value.as_str(), Some(" value\n"));
+    assert!(matches!(
+        get_secret_from_manager(&manager, "KEY", &settings, &|_: &str| Some(format!(
+            " {}",
+            STANDARD.encode("encrypted")
+        )))
+        .await,
+        Err(Error::InvalidCiphertext)
+    ));
+    assert!(matches!(
+        get_secret_from_manager(&manager, "KEY", &settings, &|_: &str| None).await,
+        Err(Error::MissingCiphertext)
+    ));
+}
diff --git a/litellm-rust/crates/secrets/tests/handler.rs b/litellm-rust/crates/secrets/tests/handler.rs
deleted file mode 100644
index 2a8b7070522d..000000000000
--- a/litellm-rust/crates/secrets/tests/handler.rs
+++ /dev/null
@@ -1,363 +0,0 @@
-#[cfg(feature = "aws")]
-#[tokio::test]
-async fn aws_handler_reads_ciphertext_decodes_trims_and_redacts() {
-    use aws_sdk_kms::{
-        Client,
-        config::{BehaviorVersion, Credentials, Region},
-    };
-    use base64::{Engine, engine::general_purpose::STANDARD};
-    use litellm_secrets::{
-        Error, KeyManagementSettings, SecretManager, aws::AwsKms, get_secret_from_manager,
-    };
-    use wiremock::{Mock, MockServer, ResponseTemplate, matchers::body_json};
-
-    let server = MockServer::start().await;
-    Mock::given(body_json(
-        serde_json::json!({"CiphertextBlob": STANDARD.encode("encrypted")}),
-    ))
-    .respond_with(
-        ResponseTemplate::new(200)
-            .set_body_json(serde_json::json!({"Plaintext":STANDARD.encode(" value\n")})),
-    )
-    .expect(1)
-    .mount(&server)
-    .await;
-    let client = Client::from_conf(
-        aws_sdk_kms::Config::builder()
-            .behavior_version(BehaviorVersion::latest())
-            .region(Region::new("us-east-1"))
-            .credentials_provider(Credentials::new("test", "test", None, None, "test"))
-            .endpoint_url(server.uri())
-            .build(),
-    );
-    let manager = SecretManager::AwsKms(AwsKms::new(client));
-    let settings = KeyManagementSettings::default();
-    let value = get_secret_from_manager(&manager, "KEY", &settings, &|name: &str| {
-        assert_eq!(name, "KEY");
-        Some(format!(" {}\n", STANDARD.encode("encrypted")))
-    })
-    .await
-    .unwrap()
-    .unwrap();
-    assert_eq!(value.as_str(), Some("value"));
-    assert!(!format!("{value:?}").contains("value"));
-    assert!(matches!(
-        get_secret_from_manager(&manager, "KEY", &settings, &|_: &str| None).await,
-        Err(Error::MissingCiphertext)
-    ));
-    assert!(matches!(
-        get_secret_from_manager(&manager, "KEY", &settings, &|_: &str| Some("abc".into())).await,
-        Err(Error::InvalidCiphertext)
-    ));
-}
-
-#[cfg(feature = "google")]
-#[tokio::test]
-async fn google_handler_requires_canonical_base64_and_preserves_plaintext_whitespace() {
-    use base64::{Engine, engine::general_purpose::STANDARD};
-    use google_cloud_kms_v1::client::KeyManagementService;
-    use litellm_secrets::{
-        Error, KeyManagementSettings, SecretManager, get_secret_from_manager, google::GoogleKms,
-    };
-    use wiremock::{
-        Mock, MockServer, ResponseTemplate,
-        matchers::{body_json, path},
-    };
-
-    let server = MockServer::start().await;
-    let resource = "projects/project/locations/global/keyRings/ring/cryptoKeys/key";
-    Mock::given(path(format!("/v1/{resource}:decrypt")))
-        .and(body_json(
-            serde_json::json!({"ciphertext":STANDARD.encode("encrypted")}),
-        ))
-        .respond_with(
-            ResponseTemplate::new(200)
-                .set_body_json(serde_json::json!({"plaintext":STANDARD.encode(" value\n")})),
-        )
-        .expect(1)
-        .mount(&server)
-        .await;
-    let client = KeyManagementService::builder()
-        .with_endpoint(server.uri())
-        .with_credentials(google_cloud_auth::credentials::anonymous::Builder::new().build())
-        .build()
-        .await
-        .unwrap();
-    let manager = SecretManager::GoogleKms(GoogleKms::new(client, resource.into()));
-    let settings = KeyManagementSettings::default();
-    let value = get_secret_from_manager(&manager, "KEY", &settings, &|_: &str| {
-        Some(STANDARD.encode("encrypted"))
-    })
-    .await
-    .unwrap()
-    .unwrap();
-    assert_eq!(value.as_str(), Some(" value\n"));
-    assert!(matches!(
-        get_secret_from_manager(&manager, "KEY", &settings, &|_: &str| Some(format!(
-            " {}",
-            STANDARD.encode("encrypted")
-        )))
-        .await,
-        Err(Error::InvalidCiphertext)
-    ));
-    assert!(matches!(
-        get_secret_from_manager(&manager, "KEY", &settings, &|_: &str| None).await,
-        Err(Error::MissingCiphertext)
-    ));
-}
-#[cfg(feature = "hashicorp")]
-#[tokio::test]
-async fn hashicorp_handler_resolves_found_missing_and_failed_values() {
-    use std::sync::Arc;
-
-    use litellm_core_utils::settings::Lookup;
-    use litellm_secrets::{
-        Error, FailurePolicy, KeyManagementSettings, SecretManager, SecretManagerState,
-        SecretResolver, hashicorp::HashicorpVault, hashicorp::HashicorpVaultConfig,
-    };
-    use wiremock::{
-        Mock, MockServer, ResponseTemplate,
-        matchers::{method, path},
-    };
-
-    let found_server = MockServer::start().await;
-    Mock::given(method("GET"))
-        .and(path("/v1/secret/data/KEY"))
-        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
-            "data": {
-                "data": {"key": "remote"},
-                "metadata": {
-                    "created_time": "",
-                    "deletion_time": "",
-                    "custom_metadata": null,
-                    "destroyed": false,
-                    "version": 1
-                }
-            },
-            "lease_id": "",
-            "lease_duration": 0,
-            "renewable": false,
-            "request_id": "",
-            "warnings": null,
-            "wrap_info": null
-        })))
-        .mount(&found_server)
-        .await;
-    let found_environment: Arc<dyn Lookup + Send + Sync> = Arc::new({
-        let address = found_server.uri();
-        move |name: &str| match name {
-            "HCP_VAULT_ADDR" => Some(address.clone()),
-            "HCP_VAULT_TOKEN" => Some("token".into()),
-            _ => None,
-        }
-    });
-    let found_config = HashicorpVaultConfig::from_environment(found_environment.as_ref()).unwrap();
-    let found_manager = HashicorpVault::from_config(found_config, true).unwrap();
-    let found_resolver = SecretResolver::new(
-        Arc::new(SecretManagerState::new(
-            SecretManager::HashicorpVault(found_manager),
-            KeyManagementSettings {
-                hosted_keys: Some(vec!["KEY".into()]),
-                ..Default::default()
-            },
-        )),
-        Arc::new(|_: &str| None),
-        litellm_secrets::OidcResolver::default(),
-    );
-    assert_eq!(
-        found_resolver
-            .get_secret_str("KEY", None)
-            .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "remote"
-    );
-
-    let missing_server = MockServer::start().await;
-    Mock::given(method("GET"))
-        .respond_with(
-            ResponseTemplate::new(404).set_body_json(serde_json::json!({"errors": ["missing"]})),
-        )
-        .mount(&missing_server)
-        .await;
-    let missing_environment: Arc<dyn Lookup + Send + Sync> = Arc::new({
-        let address = missing_server.uri();
-        move |name: &str| match name {
-            "HCP_VAULT_ADDR" => Some(address.clone()),
-            "HCP_VAULT_TOKEN" => Some("token".into()),
-            _ => None,
-        }
-    });
-    let missing_config =
-        HashicorpVaultConfig::from_environment(missing_environment.as_ref()).unwrap();
-    let missing_manager = HashicorpVault::from_config(missing_config, true).unwrap();
-    let missing_state = SecretManagerState::new(
-        SecretManager::HashicorpVault(missing_manager),
-        KeyManagementSettings {
-            hosted_keys: Some(vec!["KEY".into()]),
-            ..Default::default()
-        },
-    );
-    let missing = litellm_secrets::get_secret_from_manager(
-        missing_state.backend().unwrap(),
-        "KEY",
-        missing_state.settings().unwrap(),
-        &|_: &str| None,
-    )
-    .await
-    .unwrap();
-    assert!(missing.is_none());
-
-    let failed_server = MockServer::start().await;
-    Mock::given(method("GET"))
-        .respond_with(
-            ResponseTemplate::new(500).set_body_json(serde_json::json!({"errors": ["failed"]})),
-        )
-        .mount(&failed_server)
-        .await;
-    let failed_environment: Arc<dyn Lookup + Send + Sync> = Arc::new({
-        let address = failed_server.uri();
-        move |name: &str| match name {
-            "HCP_VAULT_ADDR" => Some(address.clone()),
-            "HCP_VAULT_TOKEN" => Some("token".into()),
-            _ => None,
-        }
-    });
-    let failed_config =
-        HashicorpVaultConfig::from_environment(failed_environment.as_ref()).unwrap();
-    let failed_manager = HashicorpVault::from_config(failed_config, true).unwrap();
-    let failed_state = SecretManagerState::new(
-        SecretManager::HashicorpVault(failed_manager),
-        KeyManagementSettings {
-            hosted_keys: Some(vec!["KEY".into()]),
-            ..Default::default()
-        },
-    );
-    let failed_resolver = SecretResolver::new(
-        Arc::new(failed_state),
-        Arc::new(|_: &str| None),
-        litellm_secrets::OidcResolver::default(),
-    )
-    .with_failure_policy(FailurePolicy::Propagate);
-    assert!(matches!(
-        failed_resolver.get_secret_str("KEY", None).await,
-        Err(Error::Hashicorp(
-            litellm_secrets::hashicorp::Error::Status { status: 500 }
-        ))
-    ));
-}
-
-#[cfg(feature = "azure")]
-#[tokio::test]
-async fn azure_handler_reads_missing_and_failed_secrets() {
-    use litellm_secrets::{
-        Error, KeyManagementSettings, KeyManagementSystem, SecretManager, azure::AzureKeyVault,
-        get_secret_from_manager,
-    };
-    use wiremock::{
-        Mock, MockServer, ResponseTemplate,
-        matchers::{path, query_param},
-    };
-
-    let server = MockServer::start().await;
-    Mock::given(path("/secrets/KEY"))
-        .and(query_param("api-version", "7.4"))
-        .respond_with(
-            ResponseTemplate::new(200).set_body_json(serde_json::json!({"value": "value"})),
-        )
-        .expect(1)
-        .mount(&server)
-        .await;
-    let manager = SecretManager::AzureKeyVault(
-        AzureKeyVault::with_client(
-            reqwest::Client::new(),
-            server.uri().parse().unwrap(),
-            std::sync::Arc::new(|name: &str| (name == "AZURE_AD_TOKEN").then(|| "fake".to_owned())),
-        )
-        .unwrap(),
-    );
-    assert_eq!(manager.system(), KeyManagementSystem::AzureKeyVault);
-    let settings = KeyManagementSettings::default();
-    let value = get_secret_from_manager(&manager, "KEY", &settings, &|_: &str| None)
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(value.as_str(), Some("value"));
-
-    let not_found = Mock::given(path("/secrets/MISSING"))
-        .respond_with(ResponseTemplate::new(404))
-        .expect(1)
-        .mount_as_scoped(&server)
-        .await;
-    assert_eq!(
-        get_secret_from_manager(&manager, "MISSING", &settings, &|_: &str| None)
-            .await
-            .unwrap(),
-        None
-    );
-    drop(not_found);
-
-    Mock::given(path("/secrets/FAILED"))
-        .respond_with(ResponseTemplate::new(500))
-        .expect(1)
-        .mount(&server)
-        .await;
-    assert!(matches!(
-        get_secret_from_manager(&manager, "FAILED", &settings, &|_: &str| None).await,
-        Err(Error::Azure(_))
-    ));
-}
-
-#[cfg(feature = "cyberark")]
-#[tokio::test]
-async fn cyberark_handler_reads_values_and_surfaces_errors() {
-    use std::time::Duration;
-
-    use litellm_secrets::{
-        Error, KeyManagementSettings, SecretManager, SecretValue, cyberark::CyberArkSecretManager,
-        get_secret_from_manager,
-    };
-    use wiremock::{
-        Mock, MockServer, ResponseTemplate,
-        matchers::{body_string, path},
-    };
-
-    let server = MockServer::start().await;
-    Mock::given(path("/authn/acct/admin/authenticate"))
-        .and(body_string("k3y"))
-        .respond_with(ResponseTemplate::new(200).set_body_string("token"))
-        .mount(&server)
-        .await;
-    Mock::given(path("/secrets/acct/variable/KEY"))
-        .respond_with(ResponseTemplate::new(200).set_body_string("value"))
-        .mount(&server)
-        .await;
-    let manager = SecretManager::Cyberark(CyberArkSecretManager::with_client(
-        reqwest::Client::new(),
-        server.uri().parse().unwrap(),
-        "acct".into(),
-        "admin".into(),
-        SecretValue::new("k3y"),
-        Some(Duration::from_secs(60)),
-    ));
-    assert_eq!(
-        manager.system(),
-        litellm_secrets::KeyManagementSystem::Cyberark
-    );
-    let settings = KeyManagementSettings::default();
-    let value = get_secret_from_manager(&manager, "KEY", &settings, &|_: &str| None)
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(value.as_str(), Some("value"));
-
-    Mock::given(path("/secrets/acct/variable/ERROR"))
-        .respond_with(ResponseTemplate::new(500))
-        .mount(&server)
-        .await;
-    assert!(matches!(
-        get_secret_from_manager(&manager, "ERROR", &settings, &|_: &str| None).await,
-        Err(Error::Cyberark(_))
-    ));
-}
diff --git a/litellm-rust/crates/secrets/tests/hashicorp.rs b/litellm-rust/crates/secrets/tests/hashicorp.rs
new file mode 100644
index 000000000000..bc35b88018e8
--- /dev/null
+++ b/litellm-rust/crates/secrets/tests/hashicorp.rs
@@ -0,0 +1,143 @@
+#![cfg(feature = "hashicorp")]
+
+#[tokio::test]
+async fn hashicorp_handler_resolves_found_missing_and_failed_values() {
+    use std::sync::Arc;
+
+    use litellm_core_utils::settings::Lookup;
+    use litellm_secrets::{
+        Error, FailurePolicy, KeyManagementSettings, SecretManager, SecretManagerState,
+        SecretResolver, hashicorp::HashicorpVault, hashicorp::HashicorpVaultConfig,
+    };
+    use wiremock::{
+        Mock, MockServer, ResponseTemplate,
+        matchers::{method, path},
+    };
+
+    let found_server = MockServer::start().await;
+    Mock::given(method("GET"))
+        .and(path("/v1/secret/data/KEY"))
+        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
+            "data": {
+                "data": {"key": "remote"},
+                "metadata": {
+                    "created_time": "",
+                    "deletion_time": "",
+                    "custom_metadata": null,
+                    "destroyed": false,
+                    "version": 1
+                }
+            },
+            "lease_id": "",
+            "lease_duration": 0,
+            "renewable": false,
+            "request_id": "",
+            "warnings": null,
+            "wrap_info": null
+        })))
+        .mount(&found_server)
+        .await;
+    let found_environment: Arc<dyn Lookup + Send + Sync> = Arc::new({
+        let address = found_server.uri();
+        move |name: &str| match name {
+            "HCP_VAULT_ADDR" => Some(address.clone()),
+            "HCP_VAULT_TOKEN" => Some("token".into()),
+            _ => None,
+        }
+    });
+    let found_config = HashicorpVaultConfig::from_environment(found_environment.as_ref()).unwrap();
+    let found_manager = HashicorpVault::from_config(found_config, true).unwrap();
+    let found_resolver = SecretResolver::new_python_compatible(
+        Arc::new(SecretManagerState::new(
+            SecretManager::HashicorpVault(found_manager),
+            KeyManagementSettings {
+                hosted_keys: Some(vec!["KEY".into()]),
+                ..Default::default()
+            },
+        )),
+        Arc::new(|_: &str| None),
+        litellm_secrets::OidcResolver::default(),
+    );
+    assert_eq!(
+        found_resolver
+            .get_secret_str("KEY", None)
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "remote"
+    );
+
+    let missing_server = MockServer::start().await;
+    Mock::given(method("GET"))
+        .respond_with(
+            ResponseTemplate::new(404).set_body_json(serde_json::json!({"errors": ["missing"]})),
+        )
+        .mount(&missing_server)
+        .await;
+    let missing_environment: Arc<dyn Lookup + Send + Sync> = Arc::new({
+        let address = missing_server.uri();
+        move |name: &str| match name {
+            "HCP_VAULT_ADDR" => Some(address.clone()),
+            "HCP_VAULT_TOKEN" => Some("token".into()),
+            _ => None,
+        }
+    });
+    let missing_config =
+        HashicorpVaultConfig::from_environment(missing_environment.as_ref()).unwrap();
+    let missing_manager = HashicorpVault::from_config(missing_config, true).unwrap();
+    let missing_state = SecretManagerState::new(
+        SecretManager::HashicorpVault(missing_manager),
+        KeyManagementSettings {
+            hosted_keys: Some(vec!["KEY".into()]),
+            ..Default::default()
+        },
+    );
+    let missing = litellm_secrets::get_secret_from_manager(
+        missing_state.backend().unwrap(),
+        "KEY",
+        missing_state.settings().unwrap(),
+        &|_: &str| None,
+    )
+    .await
+    .unwrap();
+    assert!(missing.is_none());
+
+    let failed_server = MockServer::start().await;
+    Mock::given(method("GET"))
+        .respond_with(
+            ResponseTemplate::new(500).set_body_json(serde_json::json!({"errors": ["failed"]})),
+        )
+        .mount(&failed_server)
+        .await;
+    let failed_environment: Arc<dyn Lookup + Send + Sync> = Arc::new({
+        let address = failed_server.uri();
+        move |name: &str| match name {
+            "HCP_VAULT_ADDR" => Some(address.clone()),
+            "HCP_VAULT_TOKEN" => Some("token".into()),
+            _ => None,
+        }
+    });
+    let failed_config =
+        HashicorpVaultConfig::from_environment(failed_environment.as_ref()).unwrap();
+    let failed_manager = HashicorpVault::from_config(failed_config, true).unwrap();
+    let failed_state = SecretManagerState::new(
+        SecretManager::HashicorpVault(failed_manager),
+        KeyManagementSettings {
+            hosted_keys: Some(vec!["KEY".into()]),
+            ..Default::default()
+        },
+    );
+    let failed_resolver = SecretResolver::new_python_compatible(
+        Arc::new(failed_state),
+        Arc::new(|_: &str| None),
+        litellm_secrets::OidcResolver::default(),
+    )
+    .with_failure_policy(FailurePolicy::Propagate);
+    assert!(matches!(
+        failed_resolver.get_secret_str("KEY", None).await,
+        Err(Error::Hashicorp(
+            litellm_secrets::hashicorp::Error::Status { status: 500 }
+        ))
+    ));
+}
diff --git a/litellm-rust/crates/secrets/tests/oidc.rs b/litellm-rust/crates/secrets/tests/oidc.rs
index b17e7de7f9da..afc49e8231df 100644
--- a/litellm-rust/crates/secrets/tests/oidc.rs
+++ b/litellm-rust/crates/secrets/tests/oidc.rs
@@ -185,6 +185,8 @@ async fn file_allowlist_resolves_symlinks_while_environment_paths_remain_explici
 #[case::string_expiry(serde_json::json!("999"), 2)]
 #[case::fractional_expiry(serde_json::json!(1060.9), 2)]
 #[case::negative_expiry(serde_json::json!(-1), 2)]
+#[case::boolean_expiry(serde_json::json!(true), 2)]
+#[case::padded_numeric_expiry(serde_json::json!(" 999 "), 2)]
 #[case::null_expiry(serde_json::Value::Null, 1)]
 #[case::unreadable_expiry(serde_json::json!("invalid"), 1)]
 #[case::nonfinite_expiry(serde_json::json!("NaN"), 1)]
@@ -239,8 +241,9 @@ async fn google_oidc_requires_its_build_feature() {
     ));
 }
 
+#[cfg(not(feature = "azure"))]
 #[tokio::test]
-async fn azure_oidc_without_a_token_file_requires_an_unimplemented_backend() {
+async fn azure_oidc_without_a_token_file_requires_its_build_feature() {
     assert!(matches!(
         OidcResolver::default()
             .resolve("oidc/azure/scope", environment(&[]).as_ref())
@@ -293,3 +296,193 @@ async fn unreadable_expiry_keeps_python_cache_fallback(#[case] token: &str) {
         );
     }
 }
+
+#[cfg(feature = "azure")]
+#[rstest::rstest]
+#[case::success(false)]
+#[case::failed(true)]
+#[tokio::test]
+async fn azure_oidc_acquires_the_requested_scope_and_preserves_failures(#[case] failed: bool) {
+    struct Provider(bool);
+    impl litellm_secrets::azure::AzureTokenProvider for Provider {
+        fn get_token<'a>(
+            &'a self,
+            scope: &'a str,
+            environment: &'a (dyn Lookup + Send + Sync),
+        ) -> std::pin::Pin<
+            Box<
+                dyn std::future::Future<
+                        Output = Result<
+                            litellm_secrets::SecretValue,
+                            litellm_secrets::azure::Error,
+                        >,
+                    > + Send
+                    + 'a,
+            >,
+        > {
+            Box::pin(async move {
+                assert_eq!(scope, "api://audience/path");
+                assert_eq!(
+                    environment.get("AZURE_CLIENT_ID").as_deref(),
+                    Some("client-id")
+                );
+                if self.0 {
+                    Err(litellm_secrets::azure::Error::MissingCredentials)
+                } else {
+                    Ok(litellm_secrets::SecretValue::new("azure-token"))
+                }
+            })
+        }
+    }
+    let oidc = OidcResolver::default().with_azure_token_provider(Arc::new(Provider(failed)));
+    let resolver = SecretResolver::new_python_compatible(
+        Arc::new(SecretManagerState::default()),
+        environment(&[("AZURE_CLIENT_ID", "client-id")]),
+        oidc,
+    );
+    let result = resolver
+        .get_secret_str(
+            "oidc/azure/api://audience/path",
+            Some(litellm_secrets::SecretValue::new("fallback")),
+        )
+        .await;
+    if failed {
+        assert!(matches!(result, Err(Error::Azure(_))));
+    } else {
+        assert_eq!(result.unwrap().unwrap().expose(), "azure-token");
+    }
+}
+
+#[rstest::rstest]
+#[case::circleci("oidc/circleci/audience")]
+#[case::circleci_v2("oidc/circleci_v2/audience")]
+#[case::env("oidc/env/MISSING")]
+#[case::env_path("oidc/env_path/MISSING")]
+#[tokio::test]
+async fn missing_oidc_environment_is_an_error(#[case] reference: &str) {
+    assert!(matches!(
+        OidcResolver::default()
+            .resolve(reference, environment(&[]).as_ref())
+            .await,
+        Err(Error::MissingEnvironment)
+    ));
+}
+
+#[cfg(feature = "google")]
+#[tokio::test]
+async fn google_oidc_failures_are_not_cached_or_hidden_by_defaults() {
+    let server = MockServer::start().await;
+    Mock::given(method("GET"))
+        .respond_with(ResponseTemplate::new(403))
+        .expect(2)
+        .mount(&server)
+        .await;
+    let resolver = SecretResolver::new_python_compatible(
+        Arc::new(SecretManagerState::default()),
+        environment(&[]),
+        OidcResolver::new(reqwest::Client::new(), server.uri().parse().unwrap()),
+    );
+    for _ in 0..2 {
+        assert!(matches!(
+            resolver
+                .get_secret("oidc/google/audience", Some(Secret::Bool(true)))
+                .await,
+            Err(Error::OidcStatus(403))
+        ));
+    }
+}
+
+#[cfg(feature = "google")]
+#[rstest::rstest]
+#[case::short_lived(Some(1180), 120)]
+#[case::long_lived(Some(100000), 3540)]
+#[case::opaque(None, 3540)]
+#[tokio::test]
+async fn google_tokens_expire_at_the_python_cache_deadline(
+    #[case] expiry: Option<u64>,
+    #[case] ttl: u64,
+) {
+    use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
+    use std::time::{Duration, UNIX_EPOCH};
+    let server = MockServer::start().await;
+    let token = expiry.map_or_else(
+        || "opaque-token".to_owned(),
+        |expiry| {
+            format!(
+                "{}.{}.signature",
+                URL_SAFE_NO_PAD.encode(r#"{"alg":"RS256"}"#),
+                URL_SAFE_NO_PAD.encode(serde_json::json!({"exp":expiry}).to_string())
+            )
+        },
+    );
+    Mock::given(method("GET"))
+        .respond_with(ResponseTemplate::new(200).set_body_string(&token))
+        .expect(2)
+        .mount(&server)
+        .await;
+    let resolver = OidcResolver::new(reqwest::Client::new(), server.uri().parse().unwrap())
+        .with_clock(|| UNIX_EPOCH + Duration::from_secs(1000));
+    assert_eq!(
+        resolver
+            .resolve("oidc/google/audience", environment(&[]).as_ref())
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        token
+    );
+    let before_deadline = match ttl {
+        120 => resolver.with_clock(|| UNIX_EPOCH + Duration::from_secs(1119)),
+        3540 => resolver.with_clock(|| UNIX_EPOCH + Duration::from_secs(4539)),
+        _ => unreachable!(),
+    };
+    assert_eq!(
+        before_deadline
+            .resolve("oidc/google/audience", environment(&[]).as_ref())
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        token
+    );
+    let at_deadline = match ttl {
+        120 => before_deadline.with_clock(|| UNIX_EPOCH + Duration::from_secs(1120)),
+        3540 => before_deadline.with_clock(|| UNIX_EPOCH + Duration::from_secs(4540)),
+        _ => unreachable!(),
+    };
+    assert_eq!(
+        at_deadline
+            .resolve("oidc/google/audience", environment(&[]).as_ref())
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        token
+    );
+}
+
+#[cfg(feature = "google")]
+#[tokio::test]
+async fn google_cache_uses_payload_expiry_without_requiring_a_jwt_header() {
+    use std::time::{Duration, UNIX_EPOCH};
+    let server = MockServer::start().await;
+    let token = "ignored.eyJleHAiOjF9.ignored";
+    Mock::given(method("GET"))
+        .respond_with(ResponseTemplate::new(200).set_body_string(token))
+        .expect(2)
+        .mount(&server)
+        .await;
+    let resolver = OidcResolver::new(reqwest::Client::new(), server.uri().parse().unwrap())
+        .with_clock(|| UNIX_EPOCH + Duration::from_secs(1000));
+    for _ in 0..2 {
+        assert_eq!(
+            resolver
+                .resolve("oidc/google/audience", environment(&[]).as_ref())
+                .await
+                .unwrap()
+                .unwrap()
+                .expose(),
+            token
+        );
+    }
+}
diff --git a/litellm-rust/crates/secrets/tests/resolution.rs b/litellm-rust/crates/secrets/tests/resolution.rs
index 98b34a2c72e9..bed762adc59b 100644
--- a/litellm-rust/crates/secrets/tests/resolution.rs
+++ b/litellm-rust/crates/secrets/tests/resolution.rs
@@ -1,13 +1,15 @@
-use std::sync::Arc;
+use std::{future::Future, pin::Pin, sync::Arc};
 
+use litellm_core_utils::settings::Lookup;
 use litellm_secrets::{
-    Error, OidcResolver, Secret, SecretManagerState, SecretResolver, SecretValue,
+    Error, ExternalSecretManager, FailurePolicy, KeyManagementSettings, KeyManagementSystem,
+    OidcResolver, Secret, SecretManager, SecretManagerState, SecretResolver, SecretValue,
     secret_manager_would_be_consulted,
 };
 
 fn resolver(value: Option<&str>) -> SecretResolver {
     let value = value.map(str::to_owned);
-    SecretResolver::new(
+    SecretResolver::new_python_compatible(
         Arc::new(SecretManagerState::default()),
         Arc::new(move |_: &str| value.clone()),
         OidcResolver::default(),
@@ -15,76 +17,131 @@ fn resolver(value: Option<&str>) -> SecretResolver {
 }
 
 #[rstest::rstest]
-#[case("true", Some(true))]
-#[case(" FALSE ", Some(false))]
-#[case("(True)", None)]
-#[case("False # comment", None)]
-#[case("1", None)]
-#[case("secret", None)]
+#[case::environment(false)]
+#[case::manager(true)]
 #[tokio::test]
-async fn conversion_is_explicit_and_independent_of_manager_configuration(
+async fn native_reads_preserve_strings_and_report_conversion_errors(#[case] managed: bool) {
+    for raw in ["True", " FALSE ", "", "(True)", "{\"key\":1}"] {
+        let state = if managed {
+            SecretManagerState::new(
+                SecretManager::External(Arc::new(FixedManager::custom(Ok(Some(Secret::String(
+                    SecretValue::new(raw),
+                )))))),
+                KeyManagementSettings::default(),
+            )
+        } else {
+            SecretManagerState::default()
+        };
+        let resolver = SecretResolver::new(
+            Arc::new(state),
+            Arc::new(move |_: &str| Some(raw.to_owned())),
+            OidcResolver::default(),
+        );
+        assert_eq!(
+            resolver
+                .get_secret_str("key", None)
+                .await
+                .unwrap()
+                .unwrap()
+                .expose(),
+            raw
+        );
+        assert_eq!(
+            resolver.get_secret("key", None).await.unwrap(),
+            Some(Secret::String(SecretValue::new(raw)))
+        );
+        if raw == "True" || raw == " FALSE " {
+            assert_eq!(
+                resolver.get_secret_bool("key", None).await.unwrap(),
+                Some(raw == "True")
+            );
+        } else {
+            assert!(matches!(
+                resolver.get_secret_bool("key", None).await,
+                Err(Error::TypeMismatch {
+                    expected: "boolean"
+                })
+            ));
+        }
+    }
+}
+
+#[tokio::test]
+async fn native_defaults_apply_to_absence_but_never_hide_provider_failures() {
+    for reply in [Ok(None), Err(())] {
+        let resolver = SecretResolver::new(
+            Arc::new(SecretManagerState::new(
+                SecretManager::External(Arc::new(FixedManager::custom(reply.clone()))),
+                KeyManagementSettings::default(),
+            )),
+            Arc::new(|_: &str| None),
+            OidcResolver::default(),
+        );
+        let result = resolver
+            .get_secret_str("key", Some(SecretValue::new("default")))
+            .await;
+        match reply {
+            Ok(None) => assert_eq!(result.unwrap().unwrap().expose(), "default"),
+            Err(()) => assert!(matches!(result, Err(Error::MissingCiphertext))),
+            Ok(Some(_)) => unreachable!(),
+        }
+    }
+}
+
+#[rstest::rstest]
+#[case::lowercase_true("true", Some(true))]
+#[case::padded_false(" FALSE ", Some(false))]
+#[case::capitalized_true("True", Some(true))]
+#[case::parenthesized("(True)", None)]
+#[case::commented("False # comment", None)]
+#[case::number("1", None)]
+#[case::text("secret", None)]
+#[tokio::test]
+async fn environment_values_are_coerced_like_str_to_bool(
     #[case] input: &str,
     #[case] boolean: Option<bool>,
 ) {
     let resolver = resolver(Some(input));
     assert_eq!(
         resolver.get_secret("key", None).await.unwrap(),
-        Some(Secret::String(SecretValue::new(input)))
+        Some(boolean.map_or_else(|| Secret::String(SecretValue::new(input)), Secret::Bool))
     );
     assert_eq!(
         resolver
             .get_secret_str("key", None)
             .await
             .unwrap()
-            .unwrap()
-            .expose(),
-        input
+            .as_ref()
+            .map(SecretValue::expose),
+        boolean.is_none().then_some(input)
+    );
+    assert_eq!(
+        resolver.get_secret_bool("key", Some(true)).await.unwrap(),
+        boolean
     );
-    match boolean {
-        Some(value) => assert_eq!(
-            resolver.get_secret_bool("key", None).await.unwrap(),
-            Some(value)
-        ),
-        None => assert!(matches!(
-            resolver.get_secret_bool("key", Some(true)).await,
-            Err(Error::TypeMismatch {
-                expected: "boolean"
-            })
-        )),
-    }
 }
 
-#[rstest::rstest]
 #[tokio::test]
-async fn defaults_apply_only_to_absence() {
+async fn defaults_never_replace_an_absent_secret() {
     let missing = resolver(None);
-    assert_eq!(missing.get_secret("key", None).await.unwrap(), None);
+    assert_eq!(
+        missing
+            .get_secret("key", Some(Secret::Bool(false)))
+            .await
+            .unwrap(),
+        None
+    );
     assert_eq!(
         missing.get_secret_bool("key", Some(false)).await.unwrap(),
-        Some(false)
+        None
     );
     assert_eq!(
         missing
             .get_secret_str("key", Some(SecretValue::new("default")))
             .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "default"
+            .unwrap(),
+        None
     );
-    for value in [
-        Secret::Bool(false),
-        Secret::from_json(serde_json::json!({"key":1})),
-        Secret::from_json(serde_json::Value::Null),
-    ] {
-        assert_eq!(
-            missing
-                .get_secret("key", Some(value.clone()))
-                .await
-                .unwrap(),
-            Some(value)
-        );
-    }
     assert_eq!(
         resolver(Some(""))
             .get_secret_str("key", Some(SecretValue::new("default")))
@@ -96,6 +153,124 @@ async fn defaults_apply_only_to_absence() {
     );
 }
 
+struct FixedManager {
+    reply: Result<Option<Secret>, ()>,
+    system: KeyManagementSystem,
+}
+
+impl FixedManager {
+    fn custom(reply: Result<Option<Secret>, ()>) -> Self {
+        Self {
+            reply,
+            system: KeyManagementSystem::Custom,
+        }
+    }
+}
+
+impl ExternalSecretManager for FixedManager {
+    fn system(&self) -> KeyManagementSystem {
+        self.system
+    }
+
+    fn read_secret<'a>(
+        &'a self,
+        _name: &'a str,
+        _settings: &'a KeyManagementSettings,
+        _environment: &'a (dyn Lookup + Send + Sync),
+    ) -> Pin<Box<dyn Future<Output = Result<Option<Secret>, Error>> + Send + 'a>> {
+        Box::pin(async move { self.reply.clone().map_err(|()| Error::MissingCiphertext) })
+    }
+}
+
+fn managed(reply: Result<Option<Secret>, ()>, environment: Option<&'static str>) -> SecretResolver {
+    SecretResolver::new_python_compatible(
+        Arc::new(SecretManagerState::new(
+            SecretManager::External(Arc::new(FixedManager::custom(reply))),
+            KeyManagementSettings::default(),
+        )),
+        Arc::new(move |_: &str| environment.map(str::to_owned)),
+        OidcResolver::default(),
+    )
+    .with_failure_policy(FailurePolicy::EnvironmentFallback)
+}
+
+#[tokio::test]
+async fn custom_manager_absence_uses_environment_instead_of_the_default() {
+    assert_eq!(
+        managed(Ok(None), Some("environment"))
+            .get_secret("key", Some(Secret::Bool(true)))
+            .await
+            .unwrap(),
+        Some(Secret::String(SecretValue::new("environment")))
+    );
+}
+
+#[rstest::rstest]
+#[case::capitalized_true("True", Some(Secret::Bool(true)), Some(true))]
+#[case::parenthesized_false("(False)", Some(Secret::Bool(false)), Some(false))]
+#[case::lowercase_true("true", None, Some(true))]
+#[case::number("1", None, None)]
+#[case::text("secret", None, None)]
+#[tokio::test]
+async fn manager_strings_are_coerced_like_literal_eval(
+    #[case] input: &'static str,
+    #[case] literal: Option<Secret>,
+    #[case] boolean: Option<bool>,
+) {
+    let resolver = managed(Ok(Some(Secret::String(SecretValue::new(input)))), None);
+    assert_eq!(
+        resolver.get_secret("key", None).await.unwrap(),
+        Some(
+            literal
+                .clone()
+                .unwrap_or_else(|| Secret::String(SecretValue::new(input)))
+        )
+    );
+    assert_eq!(
+        resolver
+            .get_secret_str("key", None)
+            .await
+            .unwrap()
+            .as_ref()
+            .map(SecretValue::expose),
+        literal.is_none().then_some(input)
+    );
+    assert_eq!(
+        resolver.get_secret_bool("key", None).await.unwrap(),
+        boolean
+    );
+}
+
+#[rstest::rstest]
+#[case::boolean(Secret::Bool(false))]
+#[case::object(Secret::from_json(serde_json::json!({"key": 1})))]
+#[case::null(Secret::from_json(serde_json::Value::Null))]
+#[tokio::test]
+async fn non_string_manager_values_resolve_to_none(#[case] value: Secret) {
+    let resolver = managed(Ok(Some(value)), Some("environment"));
+    assert_eq!(resolver.get_secret("key", None).await.unwrap(), None);
+    assert_eq!(resolver.get_secret_str("key", None).await.unwrap(), None);
+    assert_eq!(resolver.get_secret_bool("key", None).await.unwrap(), None);
+}
+
+#[rstest::rstest]
+#[case::capitalized_true(Some("True"), Some(Secret::Bool(true)))]
+#[case::lowercase_true(Some("true"), Some(Secret::String(SecretValue::new("true"))))]
+#[case::missing(None, None)]
+#[tokio::test]
+async fn manager_failures_fall_back_to_the_environment_like_literal_eval(
+    #[case] environment: Option<&'static str>,
+    #[case] expected: Option<Secret>,
+) {
+    assert_eq!(
+        managed(Err(()), environment)
+            .get_secret("key", Some(Secret::Bool(false)))
+            .await
+            .unwrap(),
+        expected
+    );
+}
+
 #[tokio::test]
 async fn prefix_is_removed_once_and_resolved_from_environment() {
     let state = SecretManagerState::default();
@@ -103,7 +278,7 @@ async fn prefix_is_removed_once_and_resolved_from_environment() {
         &state,
         "os.environ/os.environ/KEY"
     ));
-    let resolver = SecretResolver::new(
+    let resolver = SecretResolver::new_python_compatible(
         Arc::new(state),
         Arc::new(|name: &str| (name == "os.environ/KEY").then(|| "value".into())),
         OidcResolver::default(),
@@ -129,234 +304,82 @@ async fn resolver_future_can_run_on_a_tokio_worker() {
     assert_eq!(result.unwrap().expose(), "worker-value");
 }
 
-#[cfg(feature = "aws")]
-mod aws {
-    use super::*;
-    use litellm_secrets::{
-        AccessMode, FailurePolicy, KeyManagementSettings, SecretManager, aws::AwsSecretsManagerV2,
-    };
-    use wiremock::{Mock, MockServer, ResponseTemplate, matchers::method};
-
-    fn state(server: &MockServer, settings: KeyManagementSettings) -> SecretManagerState {
-        let endpoint = server.uri();
-        let environment = Arc::new(move |name: &str| match name {
-            "AWS_REGION_NAME" => Some("us-east-1".into()),
-            "AWS_ACCESS_KEY_ID" | "AWS_SECRET_ACCESS_KEY" => Some("test".into()),
-            "AWS_BEDROCK_RUNTIME_ENDPOINT" => Some(endpoint.clone()),
-            _ => None,
-        });
-        let manager =
-            AwsSecretsManagerV2::load_aws_secret_manager(Some(true), settings.clone(), environment)
-                .unwrap()
-                .unwrap();
-        SecretManagerState::new(SecretManager::AwsSecretsManagerV2(manager), settings)
-    }
-
-    #[rstest::rstest]
-    #[case::missing(400, serde_json::json!({"__type":"ResourceNotFoundException"}), false)]
-    #[case::denied(400, serde_json::json!({"__type":"AccessDeniedException"}), true)]
-    #[case::malformed(200, serde_json::json!({}), true)]
-    #[tokio::test]
-    async fn failure_policy_preserves_errors_and_fallback_precedence(
-        #[case] status: u16,
-        #[case] body: serde_json::Value,
-        #[case] fails: bool,
-        #[values(FailurePolicy::Propagate, FailurePolicy::EnvironmentFallback)]
-        policy: FailurePolicy,
-        #[values(None, Some("environment"))] environment: Option<&'static str>,
-        #[values(None, Some("default"))] default: Option<&str>,
-    ) {
-        let server = MockServer::start().await;
-        Mock::given(method("POST"))
-            .respond_with(ResponseTemplate::new(status).set_body_json(body))
-            .expect(1)
-            .mount(&server)
-            .await;
-        let resolver = SecretResolver::new(
-            Arc::new(state(&server, KeyManagementSettings::default())),
-            Arc::new(move |_: &str| environment.map(str::to_owned)),
-            OidcResolver::default(),
-        )
-        .with_failure_policy(policy);
-        let result = resolver
-            .get_secret_str("KEY", default.map(SecretValue::new))
-            .await;
-        let fallback = environment.or(default);
-        if fails && (policy == FailurePolicy::Propagate || fallback.is_none()) {
-            assert!(matches!(result, Err(Error::Aws(_))));
-        } else {
-            assert_eq!(result.unwrap().as_ref().map(SecretValue::expose), fallback);
-        }
-    }
-
-    #[rstest::rstest]
-    #[case::boolean(serde_json::json!(false))]
-    #[case::object(serde_json::json!({"key":1}))]
-    #[case::null(serde_json::Value::Null)]
-    #[case::string(serde_json::json!("true"))]
-    #[tokio::test]
-    async fn typed_values_survive_resolution_and_accessors_reject_wrong_types(
-        #[case] value: serde_json::Value,
-    ) {
-        let server = MockServer::start().await;
-        Mock::given(method("POST"))
-            .respond_with(ResponseTemplate::new(200).set_body_json(
-                serde_json::json!({"SecretString":serde_json::json!({"KEY":value}).to_string()}),
-            ))
-            .expect(3)
-            .mount(&server)
-            .await;
-        let settings = KeyManagementSettings {
-            primary_secret_name: Some("primary".into()),
-            ..Default::default()
-        };
-        let resolver = SecretResolver::new(
-            Arc::new(state(&server, settings)),
-            Arc::new(|_: &str| Some("fallback".into())),
-            OidcResolver::default(),
-        );
-        assert_eq!(
-            resolver
-                .get_secret("KEY", Some(Secret::Bool(true)))
-                .await
-                .unwrap(),
-            Some(Secret::from_json(value.clone()))
-        );
-        match &value {
-            serde_json::Value::String(text) => assert_eq!(
-                resolver
-                    .get_secret_str("KEY", None)
-                    .await
-                    .unwrap()
-                    .unwrap()
-                    .expose(),
-                text
-            ),
-            _ => assert!(matches!(
-                resolver.get_secret_str("KEY", None).await,
-                Err(Error::TypeMismatch { expected: "string" })
-            )),
-        }
-        match value {
-            serde_json::Value::Bool(boolean) => assert_eq!(
-                resolver.get_secret_bool("KEY", None).await.unwrap(),
-                Some(boolean)
-            ),
-            serde_json::Value::String(_) => assert_eq!(
-                resolver.get_secret_bool("KEY", None).await.unwrap(),
-                Some(true)
-            ),
-            _ => assert!(matches!(
-                resolver.get_secret_bool("KEY", None).await,
-                Err(Error::TypeMismatch {
-                    expected: "boolean"
-                })
-            )),
-        }
-    }
+#[rstest::rstest]
+#[case::missing(None, None)]
+#[case::empty(Some(""), None)]
+#[case::whitespace(Some("   \t\n"), None)]
+#[case::text(Some("abc"), Some("abc"))]
+#[case::padded(Some("  xyz  "), Some("xyz"))]
+#[case::python_controls(Some("\u{1c}\u{1d}\u{1e}\u{1f}"), None)]
+#[case::unicode(Some("\u{a0}π\u{2003}"), Some("π"))]
+fn normalization_matches_python_without_changing_embedded_whitespace(
+    #[case] input: Option<&str>,
+    #[case] expected: Option<&str>,
+) {
+    assert_eq!(
+        litellm_secrets::normalize_nonempty_secret_str(input),
+        expected
+    );
+}
 
-    #[rstest::rstest]
-    #[tokio::test]
-    async fn gating_prediction_matches_actual_lookup(
-        #[values(AccessMode::ReadOnly, AccessMode::WriteOnly, AccessMode::ReadAndWrite)]
-        access_mode: AccessMode,
-        #[values(None, Some(vec![]), Some(vec!["KEY".into()]))] hosted_keys: Option<Vec<String>>,
-        #[values("os.environ/KEY", "os.environ/oidc/env/KEY")] name: &str,
-    ) {
-        let server = MockServer::start().await;
-        let expected = name == "os.environ/KEY"
-            && access_mode.readable()
-            && hosted_keys
-                .as_ref()
-                .is_none_or(|keys| keys.iter().any(|key| key == "KEY"));
-        Mock::given(method("POST"))
-            .respond_with(
-                ResponseTemplate::new(200)
-                    .set_body_json(serde_json::json!({"SecretString":"remote"})),
-            )
-            .expect(u64::from(expected))
-            .mount(&server)
-            .await;
-        let state = state(
-            &server,
+#[rstest::rstest]
+#[case::lowercase("true", false)]
+#[case::capitalized("True", true)]
+#[case::literal("(True)", true)]
+#[tokio::test]
+async fn excluded_hosted_keys_keep_the_python_manager_conversion_path(
+    #[case] raw: &'static str,
+    #[case] boolean: bool,
+) {
+    let resolver = SecretResolver::new_python_compatible(
+        Arc::new(SecretManagerState::new(
+            SecretManager::External(Arc::new(FixedManager::custom(Err(())))),
             KeyManagementSettings {
-                access_mode,
-                hosted_keys,
+                hosted_keys: Some(vec!["OTHER".into()]),
                 ..Default::default()
             },
-        );
-        assert!(state.backend().is_some());
-        assert_eq!(state.settings().unwrap().access_mode, access_mode);
-        assert_eq!(secret_manager_would_be_consulted(&state, name), expected);
-        let resolver = SecretResolver::new(
-            Arc::new(state),
-            Arc::new(|_: &str| Some("environment".into())),
-            OidcResolver::default(),
-        );
-        assert_eq!(
-            resolver
-                .get_secret_str(name, None)
-                .await
-                .unwrap()
-                .unwrap()
-                .expose(),
-            if expected { "remote" } else { "environment" }
-        );
-    }
+        )),
+        Arc::new(move |_: &str| Some(raw.to_owned())),
+        OidcResolver::default(),
+    );
+    assert_eq!(
+        resolver.get_secret("KEY", None).await.unwrap(),
+        Some(if boolean {
+            Secret::Bool(true)
+        } else {
+            Secret::String(SecretValue::new(raw))
+        })
+    );
 }
 
-#[cfg(feature = "google")]
 #[rstest::rstest]
-#[case::missing(404)]
-#[case::failure(503)]
+#[case::missing(Ok(None), None)]
+#[case::empty(
+    Ok(Some(Secret::String(SecretValue::new("")))),
+    Some(Secret::String(SecretValue::new("")))
+)]
+#[case::failed(Err(()), Some(Secret::String(SecretValue::new("environment"))))]
 #[tokio::test]
-async fn google_resolver_distinguishes_absence_from_failure(#[case] status: u16) {
-    use litellm_secrets::{
-        FailurePolicy, KeyManagementSettings, SecretManager, google::GoogleSecretManager,
-    };
-    use wiremock::{Mock, MockServer, ResponseTemplate, matchers::method};
-    let server = MockServer::start().await;
-    Mock::given(method("GET"))
-        .respond_with(ResponseTemplate::new(status))
-        .expect(2)
-        .mount(&server)
-        .await;
-    let environment: Arc<dyn litellm_core_utils::settings::Lookup + Send + Sync> =
-        Arc::new(|name: &str| match name {
-            "VERTEX_AI_API_KEY" => Some("token".into()),
-            "KEY" => Some("environment".into()),
-            _ => None,
-        });
-    let manager = GoogleSecretManager::with_client(
-        reqwest::Client::new(),
-        server.uri().parse().unwrap(),
-        "project".into(),
-        environment.clone(),
-        None,
-        false,
-    )
-    .unwrap();
-    let state = SecretManagerState::new(
-        SecretManager::GoogleSecretManager(manager),
-        KeyManagementSettings::default(),
+async fn azure_callback_absence_preserves_none_but_errors_fall_back(
+    #[case] reply: Result<Option<Secret>, ()>,
+    #[case] expected: Option<Secret>,
+) {
+    let resolver = SecretResolver::new_python_compatible(
+        Arc::new(SecretManagerState::new(
+            SecretManager::External(Arc::new(FixedManager {
+                reply,
+                system: KeyManagementSystem::AzureKeyVault,
+            })),
+            KeyManagementSettings::default(),
+        )),
+        Arc::new(|_: &str| Some("environment".into())),
+        OidcResolver::default(),
     );
-    let resolver = SecretResolver::new(Arc::new(state), environment, OidcResolver::default());
-    let result = resolver.get_secret_str("KEY", None).await;
-    if status == 404 {
-        assert_eq!(result.unwrap().unwrap().expose(), "environment");
-    } else {
-        assert!(
-            matches!(result, Err(Error::Google(litellm_secrets::google::Error::Status(actual))) if actual == status)
-        );
-    }
     assert_eq!(
         resolver
-            .with_failure_policy(FailurePolicy::EnvironmentFallback)
-            .get_secret_str("KEY", None)
+            .get_secret("key", Some(Secret::String(SecretValue::new("default"))))
             .await
-            .unwrap()
-            .unwrap()
-            .expose(),
-        "environment"
+            .unwrap(),
+        expected
     );
 }
diff --git a/litellm-rust/crates/secrets/tests/source.rs b/litellm-rust/crates/secrets/tests/source.rs
new file mode 100644
index 000000000000..b4782c6af86a
--- /dev/null
+++ b/litellm-rust/crates/secrets/tests/source.rs
@@ -0,0 +1,62 @@
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+
+    use litellm_secrets::source::{EnvironmentSecrets, SecretSource};
+
+    #[rstest]
+    #[case::lowercase_true("LITELLM_ENVIRONMENT_SECRETS_TRUE", "true", None)]
+    #[case::padded_false("LITELLM_ENVIRONMENT_SECRETS_FALSE", " FALSE ", None)]
+    #[case::text("LITELLM_ENVIRONMENT_SECRETS_TEXT", "secret", Some("secret"))]
+    #[tokio::test]
+    async fn python_environment_values_are_absent_like_get_secret_str(
+        #[case] name: &'static str,
+        #[case] value: &str,
+        #[case] expected: Option<&str>,
+    ) {
+        unsafe { std::env::set_var(name, value) };
+        let secret = EnvironmentSecrets::python_compatible()
+            .resolve(&[name])
+            .await
+            .unwrap()
+            .get(name);
+        unsafe { std::env::remove_var(name) };
+        assert_eq!(secret.as_deref(), expected);
+    }
+}
+
+#[tokio::test]
+async fn dynamic_names_use_the_same_resolver_and_snapshots_never_do_fresh_lookups() {
+    use litellm_secrets::source::SecretSource;
+    use litellm_secrets::{OidcResolver, SecretManagerState, SecretResolver};
+    use std::sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    };
+
+    let calls = Arc::new(AtomicUsize::new(0));
+    let reads = calls.clone();
+    let source = SecretResolver::new(
+        Arc::new(SecretManagerState::default()),
+        Arc::new(move |name: &str| {
+            reads.fetch_add(1, Ordering::SeqCst);
+            (name != "missing").then(|| name.to_owned())
+        }),
+        OidcResolver::default(),
+    );
+    let snapshot = source.resolve(&["declared", "missing"]).await.unwrap();
+    let name = format!("runtime-{}", "key");
+    assert_eq!(snapshot.get("declared").as_deref(), Some("declared"));
+    assert_eq!(snapshot.get("missing"), None);
+    assert_eq!(snapshot.get(&name), None);
+    assert_eq!(calls.load(Ordering::SeqCst), 2);
+    assert_eq!(
+        SecretSource::get_secret_str(&source, &name)
+            .await
+            .unwrap()
+            .unwrap()
+            .expose(),
+        name
+    );
+    assert_eq!(calls.load(Ordering::SeqCst), 3);
+}
diff --git a/litellm/litellm_core_utils/get_litellm_params.py b/litellm/litellm_core_utils/get_litellm_params.py
index 112d038039e9..f7aaef3a51ff 100644
--- a/litellm/litellm_core_utils/get_litellm_params.py
+++ b/litellm/litellm_core_utils/get_litellm_params.py
@@ -130,6 +130,7 @@ def get_litellm_params(
     api_version: str | None = None,
     max_retries: int | None = None,
     litellm_request_debug: bool | None = None,
+    stream_chunk_size: int | None = None,
     **kwargs,
 ) -> dict:
     _litellm_metadata_dict: Final = litellm_metadata if isinstance(litellm_metadata, dict) else None
@@ -192,6 +193,7 @@ def get_litellm_params(
         "max_retries": max_retries,
         "use_litellm_proxy": use_litellm_proxy,
         "litellm_request_debug": litellm_request_debug,
+        "stream_chunk_size": stream_chunk_size,
     }
 
     # Sparse extraction: only add kwargs keys that are actually present
diff --git a/litellm/llms/bedrock/chat/converse_handler.py b/litellm/llms/bedrock/chat/converse_handler.py
index 1acac7de14d8..3abe7c88fcdc 100644
--- a/litellm/llms/bedrock/chat/converse_handler.py
+++ b/litellm/llms/bedrock/chat/converse_handler.py
@@ -278,7 +278,7 @@ def completion(
     ):
         ## SETUP ##
         stream: Final = optional_params.pop("stream", None)
-        stream_chunk_size: Final = optional_params.pop("stream_chunk_size", None)
+        stream_chunk_size: Final = litellm_params.get("stream_chunk_size")
         unencoded_model_id: Final = optional_params.pop("model_id", None)
         fake_stream = optional_params.pop("fake_stream", False)
         json_mode: Final = optional_params.get("json_mode", False)
diff --git a/litellm/main.py b/litellm/main.py
index 7f4b34d28a0f..4c40d8641692 100644
--- a/litellm/main.py
+++ b/litellm/main.py
@@ -5640,6 +5640,7 @@ def completion(
             max_retries=max_retries,
             timeout=timeout,
             litellm_request_debug=kwargs.get("litellm_request_debug", False),
+            stream_chunk_size=kwargs.get("stream_chunk_size"),
             tpm=kwargs.get("tpm"),
             rpm=kwargs.get("rpm"),
             use_xai_oauth=kwargs.get("use_xai_oauth", False),
diff --git a/litellm/model_prices_and_context_window_backup.json b/litellm/model_prices_and_context_window_backup.json
index ae02744b8e10..da8013ae7098 100644
--- a/litellm/model_prices_and_context_window_backup.json
+++ b/litellm/model_prices_and_context_window_backup.json
@@ -3810,6 +3810,104 @@
         "supports_web_search": true,
         "supports_xhigh_reasoning_effort": true
     },
+    "azure_ai/gpt-6-luna": {
+        "cache_creation_input_token_cost": 1.25e-07,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.5e-07,
+        "cache_read_input_token_cost": 1e-08,
+        "cache_read_input_token_cost_above_272k_tokens": 2e-08,
+        "input_cost_per_token": 1e-07,
+        "input_cost_per_token_above_272k_tokens": 2e-07,
+        "litellm_provider": "azure_ai",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 5e-07,
+        "output_cost_per_token_above_272k_tokens": 7.5e-07,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_cache_breakpoint": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
+    "azure_ai/gpt-6-sol": {
+        "cache_creation_input_token_cost": 2.5e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 5e-06,
+        "cache_read_input_token_cost": 2e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 4e-07,
+        "input_cost_per_token": 2e-06,
+        "input_cost_per_token_above_272k_tokens": 4e-06,
+        "litellm_provider": "azure_ai",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 1e-05,
+        "output_cost_per_token_above_272k_tokens": 1.5e-05,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_cache_breakpoint": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
     "azure_ai/gpt-5.5": {
         "deprecation_date": "2027-10-26",
         "cache_read_input_token_cost": 5e-07,
@@ -3894,6 +3992,7 @@
     "azure_ai/gpt-image-2": {
         "cache_read_input_image_token_cost": 2e-06,
         "cache_read_input_token_cost": 1.25e-06,
+        "deprecation_date": "2027-10-21",
         "input_cost_per_image_token": 8e-06,
         "input_cost_per_token": 5e-06,
         "litellm_provider": "azure_ai",
@@ -7799,20 +7898,74 @@
         "supports_web_search": true,
         "supports_xhigh_reasoning_effort": true
     },
-    "azure/gpt-chat-latest": {
-        "cache_read_input_token_cost": 5e-07,
-        "deprecation_date": "2026-12-02",
-        "input_cost_per_token": 5e-06,
+    "azure/gpt-6-luna": {
+        "cache_creation_input_token_cost": 1.25e-07,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.5e-07,
+        "cache_read_input_token_cost": 1e-08,
+        "cache_read_input_token_cost_above_272k_tokens": 2e-08,
+        "input_cost_per_token": 1e-07,
+        "input_cost_per_token_above_272k_tokens": 2e-07,
         "litellm_provider": "azure",
-        "max_input_tokens": 272000,
+        "max_input_tokens": 922000,
         "max_output_tokens": 128000,
         "max_tokens": 128000,
         "mode": "chat",
-        "output_cost_per_token": 3e-05,
-        "reasoning_effort_levels": [
-            "medium"
+        "output_cost_per_token": 5e-07,
+        "output_cost_per_token_above_272k_tokens": 7.5e-07,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
         ],
-        "source": "https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
+    "azure/gpt-6-luna-2026-09-22": {
+        "cache_creation_input_token_cost": 1.25e-07,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.5e-07,
+        "cache_read_input_token_cost": 1e-08,
+        "cache_read_input_token_cost_above_272k_tokens": 2e-08,
+        "input_cost_per_token": 1e-07,
+        "input_cost_per_token_above_272k_tokens": 2e-07,
+        "litellm_provider": "azure",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 5e-07,
+        "output_cost_per_token_above_272k_tokens": 7.5e-07,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
         "supported_endpoints": [
             "/v1/chat/completions",
             "/v1/responses"
@@ -7824,8 +7977,12 @@
         "supported_output_modalities": [
             "text"
         ],
+        "supports_computer_use": true,
         "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
         "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
         "supports_parallel_function_calling": true,
         "supports_pdf_input": true,
         "supports_prompt_caching": true,
@@ -7834,9 +7991,143 @@
         "supports_system_messages": true,
         "supports_tool_choice": true,
         "supports_vision": true,
-        "supports_web_search": true
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
     },
-    "azure/chat-latest": {
+    "azure/gpt-6-sol": {
+        "cache_creation_input_token_cost": 2.5e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 5e-06,
+        "cache_read_input_token_cost": 2e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 4e-07,
+        "input_cost_per_token": 2e-06,
+        "input_cost_per_token_above_272k_tokens": 4e-06,
+        "litellm_provider": "azure",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 1e-05,
+        "output_cost_per_token_above_272k_tokens": 1.5e-05,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
+    "azure/gpt-6-sol-2026-09-22": {
+        "cache_creation_input_token_cost": 2.5e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 5e-06,
+        "cache_read_input_token_cost": 2e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 4e-07,
+        "input_cost_per_token": 2e-06,
+        "input_cost_per_token_above_272k_tokens": 4e-06,
+        "litellm_provider": "azure",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 1e-05,
+        "output_cost_per_token_above_272k_tokens": 1.5e-05,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
+    "azure/gpt-chat-latest": {
+        "cache_read_input_token_cost": 5e-07,
+        "deprecation_date": "2026-12-02",
+        "input_cost_per_token": 5e-06,
+        "litellm_provider": "azure",
+        "max_input_tokens": 272000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 3e-05,
+        "reasoning_effort_levels": [
+            "medium"
+        ],
+        "source": "https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_function_calling": true,
+        "supports_native_streaming": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true
+    },
+    "azure/chat-latest": {
         "cache_read_input_token_cost": 5e-07,
         "deprecation_date": "2026-12-02",
         "input_cost_per_token": 5e-06,
@@ -8143,6 +8434,102 @@
         "supports_web_search": true,
         "supports_xhigh_reasoning_effort": true
     },
+    "azure/us/gpt-6-luna": {
+        "cache_creation_input_token_cost": 1.375e-07,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.75e-07,
+        "cache_read_input_token_cost": 1.1e-08,
+        "cache_read_input_token_cost_above_272k_tokens": 2.2e-08,
+        "input_cost_per_token": 1.1e-07,
+        "input_cost_per_token_above_272k_tokens": 2.2e-07,
+        "litellm_provider": "azure",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 5.5e-07,
+        "output_cost_per_token_above_272k_tokens": 8.25e-07,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
+    "azure/us/gpt-6-sol": {
+        "cache_creation_input_token_cost": 2.75e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 5.5e-06,
+        "cache_read_input_token_cost": 2.2e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 4.4e-07,
+        "input_cost_per_token": 2.2e-06,
+        "input_cost_per_token_above_272k_tokens": 4.4e-06,
+        "litellm_provider": "azure",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 1.1e-05,
+        "output_cost_per_token_above_272k_tokens": 1.65e-05,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
     "azure/us/gpt-chat-latest": {
         "cache_read_input_token_cost": 5.5e-07,
         "deprecation_date": "2026-12-02",
@@ -34171,6 +34558,7 @@
         "supports_vision": true
     },
     "groq/llama-guard-3-8b": {
+        "deprecation_date": "2025-06-06",
         "input_cost_per_token": 2e-07,
         "litellm_provider": "groq",
         "max_input_tokens": 8192,
@@ -39858,21 +40246,21 @@
         "supports_web_search": false
     },
     "openrouter/deepseek/deepseek-v4-pro": {
-        "input_cost_per_token": 8.92272e-07,
+        "input_cost_per_token": 8.8044e-07,
         "input_cost_per_token_cache_hit": 4.4e-08,
         "litellm_provider": "openrouter",
         "max_input_tokens": 1048576,
         "max_output_tokens": 384000,
         "max_tokens": 384000,
         "mode": "chat",
-        "output_cost_per_token": 1.784544e-06,
+        "output_cost_per_token": 1.76088e-06,
         "source": "https://openrouter.ai/api/v1/models",
         "supports_function_calling": true,
         "supports_prompt_caching": true,
         "supports_reasoning": true,
         "supports_response_schema": true,
         "supports_tool_choice": true,
-        "cache_read_input_token_cost": 7.4356e-08,
+        "cache_read_input_token_cost": 7.337e-08,
         "supports_audio_input": false,
         "supports_pdf_input": false,
         "supports_vision": false,
@@ -39884,10 +40272,10 @@
         "cache_read_input_token_cost": 6e-09,
         "litellm_provider": "openrouter",
         "max_input_tokens": 1048576,
-        "max_output_tokens": 384000,
-        "max_tokens": 384000,
+        "max_output_tokens": 943718,
+        "max_tokens": 943718,
         "mode": "chat",
-        "off_peak_pricing": {"windows":[{"weekdays":["saturday","sunday"],"hours_utc":"00:00-00:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"00:00-01:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"04:00-06:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"10:00-00:00"}],"input_cost_per_token":1.5e-7,"output_cost_per_token":6e-7,"cache_read_input_token_cost":3e-9},
+        "off_peak_pricing": {"windows":[{"weekdays":["saturday","sunday"],"hours_utc":"00:00-00:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"00:00-01:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"04:00-06:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"10:00-00:00"}],"input_cost_per_token":3e-7,"output_cost_per_token":0.0000012,"cache_read_input_token_cost":6e-9},
         "source": "https://openrouter.ai/api/v1/models",
         "supports_audio_input": false,
         "supports_function_calling": true,
@@ -39915,7 +40303,7 @@
         "supports_response_schema": true,
         "supports_tool_choice": true,
         "cache_read_input_token_cost": 4.4e-08,
-        "off_peak_pricing": {"windows":[{"weekdays":["saturday","sunday"],"hours_utc":"00:00-00:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"00:00-01:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"04:00-06:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"10:00-00:00"}],"input_cost_per_token":6.6e-7,"output_cost_per_token":0.00000198,"cache_read_input_token_cost":2.2e-8},
+        "off_peak_pricing": {"windows":[{"weekdays":["saturday","sunday"],"hours_utc":"00:00-00:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"00:00-01:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"04:00-06:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"10:00-00:00"}],"input_cost_per_token":0.00000132,"output_cost_per_token":0.00000396,"cache_read_input_token_cost":4.4e-8},
         "supports_audio_input": false,
         "supports_pdf_input": false,
         "supports_vision": false,
@@ -54811,6 +55199,54 @@
         "supports_response_schema": false,
         "supports_web_search": false
     },
+    "gemini/gemini-3.8-flash-tts": {
+        "cache_read_input_token_cost": 1.25e-07,
+        "cache_read_input_token_cost_batches": 6.25e-08,
+        "cache_read_input_token_cost_flex": 2.5e-08,
+        "cache_read_input_token_cost_priority": 2.25e-07,
+        "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,
+        "litellm_provider": "gemini",
+        "max_input_tokens": 8192,
+        "max_output_tokens": 16384,
+        "max_tokens": 16384,
+        "mode": "audio_speech",
+        "output_cost_per_audio_token": 9e-06,
+        "output_cost_per_token": 9e-06,
+        "output_cost_per_token_batches": 4.5e-06,
+        "output_cost_per_token_flex": 4.5e-06,
+        "output_cost_per_token_priority": 1.62e-05,
+        "source": "https://ai.google.dev/gemini-api/docs/pricing",
+        "supported_endpoints": [
+            "/v1/audio/speech"
+        ]
+    },
+    "gemini/gemini-3.8-flash-lite-tts": {
+        "cache_read_input_token_cost": 1.25e-07,
+        "cache_read_input_token_cost_batches": 6.25e-08,
+        "cache_read_input_token_cost_flex": 2.5e-08,
+        "cache_read_input_token_cost_priority": 2.25e-07,
+        "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,
+        "litellm_provider": "gemini",
+        "max_input_tokens": 8192,
+        "max_output_tokens": 16384,
+        "max_tokens": 16384,
+        "mode": "audio_speech",
+        "output_cost_per_audio_token": 6e-06,
+        "output_cost_per_token": 6e-06,
+        "output_cost_per_token_batches": 3e-06,
+        "output_cost_per_token_flex": 3e-06,
+        "output_cost_per_token_priority": 1.08e-05,
+        "source": "https://ai.google.dev/gemini-api/docs/pricing",
+        "supported_endpoints": [
+            "/v1/audio/speech"
+        ]
+    },
     "gemini-2.5-flash-preview-tts": {
         "input_cost_per_token": 5e-07,
         "input_cost_per_token_batches": 2.5e-07,
@@ -55682,6 +56118,82 @@
         "supports_vision": true,
         "source": "https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-openai-gpt-6-astra.html"
     },
+    "bedrock_mantle/openai.gpt-6-sol": {
+        "input_cost_per_token": 2.2e-06,
+        "input_cost_per_token_above_272k_tokens": 4.4e-06,
+        "cache_creation_input_token_cost": 2.75e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 5.5e-06,
+        "cache_read_input_token_cost": 2.2e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 4.4e-07,
+        "output_cost_per_token": 1.1e-05,
+        "output_cost_per_token_above_272k_tokens": 1.65e-05,
+        "litellm_provider": "bedrock_mantle",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "responses",
+        "use_openai_responses_path": true,
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_none_reasoning_effort": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_xhigh_reasoning_effort": true,
+        "supports_vision": true,
+        "source": "https://docs.aws.amazon.com/bedrock/latest/userguide/model-cards-openai.html"
+    },
+    "bedrock_mantle/openai.gpt-6-luna": {
+        "input_cost_per_token": 1.1e-07,
+        "input_cost_per_token_above_272k_tokens": 2.2e-07,
+        "cache_creation_input_token_cost": 1.375e-07,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.75e-07,
+        "cache_read_input_token_cost": 1.1e-08,
+        "cache_read_input_token_cost_above_272k_tokens": 2.2e-08,
+        "output_cost_per_token": 5.5e-07,
+        "output_cost_per_token_above_272k_tokens": 8.25e-07,
+        "litellm_provider": "bedrock_mantle",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "responses",
+        "use_openai_responses_path": true,
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_none_reasoning_effort": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_xhigh_reasoning_effort": true,
+        "supports_vision": true,
+        "source": "https://docs.aws.amazon.com/bedrock/latest/userguide/model-cards-openai.html"
+    },
     "us.openai.gpt-6-astra": {
         "input_cost_per_token": 1.1e-05,
         "input_cost_per_token_above_272k_tokens": 2.2e-05,
@@ -55714,6 +56226,70 @@
         "supports_vision": true,
         "source": "https://aws.amazon.com/bedrock/pricing/"
     },
+    "us.openai.gpt-6-sol": {
+        "input_cost_per_token": 2.2e-06,
+        "input_cost_per_token_above_272k_tokens": 4.4e-06,
+        "cache_creation_input_token_cost": 2.75e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 5.5e-06,
+        "cache_read_input_token_cost": 2.2e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 4.4e-07,
+        "output_cost_per_token": 1.1e-05,
+        "output_cost_per_token_above_272k_tokens": 1.65e-05,
+        "litellm_provider": "bedrock_converse",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_none_reasoning_effort": false,
+        "supports_tool_choice": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_xhigh_reasoning_effort": true,
+        "supports_vision": true,
+        "source": "https://aws.amazon.com/bedrock/pricing/"
+    },
+    "us.openai.gpt-6-luna": {
+        "input_cost_per_token": 1.1e-07,
+        "input_cost_per_token_above_272k_tokens": 2.2e-07,
+        "cache_creation_input_token_cost": 1.375e-07,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.75e-07,
+        "cache_read_input_token_cost": 1.1e-08,
+        "cache_read_input_token_cost_above_272k_tokens": 2.2e-08,
+        "output_cost_per_token": 5.5e-07,
+        "output_cost_per_token_above_272k_tokens": 8.25e-07,
+        "litellm_provider": "bedrock_converse",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_none_reasoning_effort": false,
+        "supports_tool_choice": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_xhigh_reasoning_effort": true,
+        "supports_vision": true,
+        "source": "https://aws.amazon.com/bedrock/pricing/"
+    },
     "global.openai.gpt-6-astra": {
         "input_cost_per_token": 1e-05,
         "input_cost_per_token_above_272k_tokens": 2e-05,
@@ -55746,6 +56322,70 @@
         "supports_vision": true,
         "source": "https://aws.amazon.com/bedrock/pricing/"
     },
+    "global.openai.gpt-6-sol": {
+        "input_cost_per_token": 2e-06,
+        "input_cost_per_token_above_272k_tokens": 4e-06,
+        "cache_creation_input_token_cost": 2.5e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 5e-06,
+        "cache_read_input_token_cost": 2e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 4e-07,
+        "output_cost_per_token": 1e-05,
+        "output_cost_per_token_above_272k_tokens": 1.5e-05,
+        "litellm_provider": "bedrock_converse",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_none_reasoning_effort": false,
+        "supports_tool_choice": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_xhigh_reasoning_effort": true,
+        "supports_vision": true,
+        "source": "https://aws.amazon.com/bedrock/pricing/"
+    },
+    "global.openai.gpt-6-luna": {
+        "input_cost_per_token": 1e-07,
+        "input_cost_per_token_above_272k_tokens": 2e-07,
+        "cache_creation_input_token_cost": 1.25e-07,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.5e-07,
+        "cache_read_input_token_cost": 1e-08,
+        "cache_read_input_token_cost_above_272k_tokens": 2e-08,
+        "output_cost_per_token": 5e-07,
+        "output_cost_per_token_above_272k_tokens": 7.5e-07,
+        "litellm_provider": "bedrock_converse",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_none_reasoning_effort": false,
+        "supports_tool_choice": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_xhigh_reasoning_effort": true,
+        "supports_vision": true,
+        "source": "https://aws.amazon.com/bedrock/pricing/"
+    },
     "bedrock_mantle/openai.gpt-5.5": {
         "input_cost_per_token": 5.5e-06,
         "input_cost_per_token_above_272k_tokens": 1.1e-05,
@@ -66548,6 +67188,102 @@
         "output_cost_per_token_above_272k_tokens": 8.25e-05,
         "source": "https://prices.azure.com/api/retail/prices?$filter=serviceName%20eq%20'Foundry%20Models'%20and%20armRegionName%20eq%20'eastus'%20and%20priceType%20eq%20'Consumption'"
     },
+    "azure/eu/gpt-6-luna": {
+        "cache_creation_input_token_cost": 1.5e-07,
+        "cache_creation_input_token_cost_above_272k_tokens": 3e-07,
+        "cache_read_input_token_cost": 1.2e-08,
+        "cache_read_input_token_cost_above_272k_tokens": 2.4e-08,
+        "input_cost_per_token": 1.2e-07,
+        "input_cost_per_token_above_272k_tokens": 2.4e-07,
+        "litellm_provider": "azure",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 6e-07,
+        "output_cost_per_token_above_272k_tokens": 9e-07,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
+    "azure/eu/gpt-6-sol": {
+        "cache_creation_input_token_cost": 3e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 6e-06,
+        "cache_read_input_token_cost": 2.4e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 4.8e-07,
+        "input_cost_per_token": 2.4e-06,
+        "input_cost_per_token_above_272k_tokens": 4.8e-06,
+        "litellm_provider": "azure",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 1.2e-05,
+        "output_cost_per_token_above_272k_tokens": 1.8e-05,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
     "azure/eu/o1-mini": {
         "cache_read_input_token_cost": 6.05e-07,
         "input_cost_per_token": 1.21e-06,
@@ -68170,14 +68906,14 @@
         "supports_web_search": true
     },
     "openrouter/~deepseek/deepseek-flash-latest": {
-        "cache_read_input_token_cost": 3.6e-09,
-        "input_cost_per_token": 1.2e-07,
+        "cache_read_input_token_cost": 6e-09,
+        "input_cost_per_token": 3e-07,
         "litellm_provider": "openrouter",
         "max_input_tokens": 1048576,
         "max_output_tokens": 943718,
         "max_tokens": 943718,
         "mode": "chat",
-        "output_cost_per_token": 4.8e-07,
+        "output_cost_per_token": 1.2e-06,
         "source": "https://openrouter.ai/api/v1/models",
         "supports_audio_input": false,
         "supports_function_calling": true,
@@ -68190,14 +68926,15 @@
         "supports_web_search": false
     },
     "openrouter/~deepseek/deepseek-pro-latest": {
-        "cache_read_input_token_cost": 1.2726e-08,
-        "input_cost_per_token": 3.9996e-07,
+        "cache_read_input_token_cost": 4.4e-08,
+        "input_cost_per_token": 1.32e-06,
         "litellm_provider": "openrouter",
         "max_input_tokens": 1048576,
-        "max_output_tokens": 393216,
-        "max_tokens": 393216,
+        "max_output_tokens": 384000,
+        "max_tokens": 384000,
         "mode": "chat",
-        "output_cost_per_token": 1.19988e-06,
+        "off_peak_pricing": {"windows":[{"weekdays":["saturday","sunday"],"hours_utc":"00:00-00:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"00:00-01:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"04:00-06:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"10:00-00:00"}],"input_cost_per_token":6.6e-7,"output_cost_per_token":0.00000198,"cache_read_input_token_cost":2.2e-8},
+        "output_cost_per_token": 3.96e-06,
         "source": "https://openrouter.ai/api/v1/models",
         "supports_audio_input": false,
         "supports_function_calling": true,
@@ -68210,14 +68947,14 @@
         "supports_web_search": false
     },
     "openrouter/~deepseek/deepseek-v4-flash-latest": {
-        "cache_read_input_token_cost": 8e-09,
-        "input_cost_per_token": 3e-08,
+        "cache_read_input_token_cost": 1.6e-08,
+        "input_cost_per_token": 4e-08,
         "litellm_provider": "openrouter",
         "max_input_tokens": 1310720,
         "max_output_tokens": 943718,
         "max_tokens": 943718,
         "mode": "chat",
-        "output_cost_per_token": 8e-07,
+        "output_cost_per_token": 6.4e-07,
         "source": "https://openrouter.ai/api/v1/models",
         "supports_audio_input": false,
         "supports_function_calling": true,
@@ -68280,13 +69017,13 @@
     },
     "openrouter/~moonshotai/kimi-latest": {
         "cache_read_input_token_cost": 3e-07,
-        "input_cost_per_token": 1.4989e-06,
+        "input_cost_per_token": 3e-06,
         "litellm_provider": "openrouter",
         "max_input_tokens": 1048576,
         "max_output_tokens": 943718,
         "max_tokens": 943718,
         "mode": "chat",
-        "output_cost_per_token": 1.0758e-05,
+        "output_cost_per_token": 1.5e-05,
         "source": "https://openrouter.ai/api/v1/models",
         "supports_audio_input": false,
         "supports_function_calling": true,
@@ -68442,14 +69179,14 @@
         "supports_web_search": true
     },
     "openrouter/~z-ai/glm-flash-latest": {
-        "cache_read_input_token_cost": 1.5e-08,
-        "input_cost_per_token": 7.5e-08,
+        "cache_read_input_token_cost": 5e-08,
+        "input_cost_per_token": 1.5e-07,
         "litellm_provider": "openrouter",
         "max_input_tokens": 1310720,
         "max_output_tokens": 943718,
         "max_tokens": 943718,
         "mode": "chat",
-        "output_cost_per_token": 2.5e-07,
+        "output_cost_per_token": 5e-07,
         "source": "https://openrouter.ai/api/v1/models",
         "supports_audio_input": false,
         "supports_function_calling": true,
@@ -68485,7 +69222,7 @@
         "cache_read_input_token_cost": 2e-07,
         "input_cost_per_token": 8e-07,
         "litellm_provider": "openrouter",
-        "max_input_tokens": 1048576,
+        "max_input_tokens": 131072,
         "max_output_tokens": 32768,
         "max_tokens": 32768,
         "mode": "chat",
@@ -68505,7 +69242,7 @@
         "cache_read_input_token_cost": 7.5e-07,
         "input_cost_per_token": 3e-06,
         "litellm_provider": "openrouter",
-        "max_input_tokens": 1048576,
+        "max_input_tokens": 131072,
         "max_output_tokens": 32768,
         "max_tokens": 32768,
         "mode": "chat",
@@ -68525,7 +69262,47 @@
         "cache_read_input_token_cost": 1.8e-07,
         "input_cost_per_token": 7e-07,
         "litellm_provider": "openrouter",
-        "max_input_tokens": 1048576,
+        "max_input_tokens": 131072,
+        "max_output_tokens": 32768,
+        "max_tokens": 32768,
+        "mode": "chat",
+        "output_cost_per_token": 1.4e-06,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": false,
+        "supports_web_search": false
+    },
+    "openrouter/aion-labs/aion-3.5": {
+        "cache_read_input_token_cost": 7.5e-07,
+        "input_cost_per_token": 3e-06,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 262144,
+        "max_output_tokens": 32768,
+        "max_tokens": 32768,
+        "mode": "chat",
+        "output_cost_per_token": 6e-06,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": false,
+        "supports_web_search": false
+    },
+    "openrouter/aion-labs/aion-3.5-mini": {
+        "cache_read_input_token_cost": 1.8e-07,
+        "input_cost_per_token": 7e-07,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 262144,
         "max_output_tokens": 32768,
         "max_tokens": 32768,
         "mode": "chat",
@@ -71417,6 +72194,21 @@
         "supports_vision": false,
         "supports_web_search": false
     },
+    "openrouter/stealth/space-bunny-alpha": {
+        "input_cost_per_token": 0,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1000000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 0,
+        "source": "https://openrouter.ai/stealth/space-bunny-alpha",
+        "supports_function_calling": true,
+        "supports_reasoning": true,
+        "supports_tool_choice": true,
+        "supports_video_input": true,
+        "supports_vision": true
+    },
     "openrouter/stepfun/step-3.5-flash": {
         "input_cost_per_token": 1e-07,
         "litellm_provider": "openrouter",
@@ -71790,6 +72582,26 @@
         "supports_vision": false,
         "supports_web_search": false
     },
+    "openrouter/upstage/solar-mini4": {
+        "cache_read_input_token_cost": 5e-09,
+        "input_cost_per_token": 5e-08,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 524288,
+        "max_output_tokens": 131072,
+        "max_tokens": 131072,
+        "mode": "chat",
+        "output_cost_per_token": 2e-07,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": false,
+        "supports_web_search": false
+    },
     "openrouter/writer/palmyra-x5": {
         "input_cost_per_token": 6e-07,
         "litellm_provider": "openrouter",
@@ -72846,6 +73658,207 @@
         "supports_tool_choice": true,
         "supports_vision": true
     },
+    "openrouter/anthropic/claude-opus-5.5:batch": {
+        "cache_creation_input_token_cost": 2.5e-06,
+        "cache_creation_input_token_cost_above_1hr": 4e-06,
+        "cache_read_input_token_cost": 1e-07,
+        "input_cost_per_token": 2e-06,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1000000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 1e-05,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true
+    },
+    "openrouter/cohere/command-a-plus": {
+        "cache_read_input_token_cost": 1.5e-07,
+        "input_cost_per_token": 3e-07,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 192000,
+        "max_output_tokens": 64000,
+        "max_tokens": 64000,
+        "mode": "chat",
+        "output_cost_per_token": 1.5e-06,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": false,
+        "supports_vision": true,
+        "supports_web_search": false
+    },
+    "openrouter/deepseek/deepseek-v4.1-flash:batch": {
+        "cache_read_input_token_cost": 3.36e-09,
+        "input_cost_per_token": 1.12e-07,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1048576,
+        "max_output_tokens": 131072,
+        "max_tokens": 131072,
+        "mode": "chat",
+        "output_cost_per_token": 3.36e-07,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": false
+    },
+    "openrouter/openai/gpt-6-luna-pro:batch": {
+        "cache_creation_input_token_cost": 6.25e-08,
+        "cache_creation_input_token_cost_above_272k_tokens": 1.25e-07,
+        "cache_read_input_token_cost": 5e-09,
+        "cache_read_input_token_cost_above_272k_tokens": 1e-08,
+        "input_cost_per_token": 5e-08,
+        "input_cost_per_token_above_272k_tokens": 1e-07,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 2.5e-07,
+        "output_cost_per_token_above_272k_tokens": 3.75e-07,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true
+    },
+    "openrouter/openai/gpt-6-luna:batch": {
+        "cache_creation_input_token_cost": 6.25e-08,
+        "cache_creation_input_token_cost_above_272k_tokens": 1.25e-07,
+        "cache_read_input_token_cost": 5e-09,
+        "cache_read_input_token_cost_above_272k_tokens": 1e-08,
+        "input_cost_per_token": 5e-08,
+        "input_cost_per_token_above_272k_tokens": 1e-07,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 2.5e-07,
+        "output_cost_per_token_above_272k_tokens": 3.75e-07,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true
+    },
+    "openrouter/openai/gpt-6-sol-pro:batch": {
+        "cache_creation_input_token_cost": 1.25e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.5e-06,
+        "cache_read_input_token_cost": 1e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 2e-07,
+        "input_cost_per_token": 1e-06,
+        "input_cost_per_token_above_272k_tokens": 2e-06,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 5e-06,
+        "output_cost_per_token_above_272k_tokens": 7.5e-06,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true
+    },
+    "openrouter/openai/gpt-6-sol:batch": {
+        "cache_creation_input_token_cost": 1.25e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.5e-06,
+        "cache_read_input_token_cost": 1e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 2e-07,
+        "input_cost_per_token": 1e-06,
+        "input_cost_per_token_above_272k_tokens": 2e-06,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 5e-06,
+        "output_cost_per_token_above_272k_tokens": 7.5e-06,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true
+    },
+    "openrouter/openai/gpt-oss-20b:batch": {
+        "input_cost_per_token": 2.4e-08,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 131072,
+        "max_output_tokens": 117964,
+        "max_tokens": 117964,
+        "mode": "chat",
+        "output_cost_per_token": 1.12e-07,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": false,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": false,
+        "supports_web_search": false
+    },
+    "openrouter/qwen/qwen3.8-omni-flash": {
+        "cache_read_input_token_cost": 1.6e-08,
+        "input_cost_per_token": 1.5e-07,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1000000,
+        "max_output_tokens": 131072,
+        "max_tokens": 131072,
+        "mode": "chat",
+        "output_cost_per_token": 4.7e-07,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": true,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": false
+    },
     "vertex_ai/gemini-2.0-flash": {
         "input_cost_per_audio_token": 1e-06,
         "input_cost_per_audio_token_batches": 5e-07,
diff --git a/litellm/proxy/auth/password_policy.py b/litellm/proxy/auth/password_policy.py
index 7f06a0993d31..a883cfd6f354 100644
--- a/litellm/proxy/auth/password_policy.py
+++ b/litellm/proxy/auth/password_policy.py
@@ -107,7 +107,7 @@ def validate_password_policy(password: str, general_settings: Mapping[str, objec
     )
 
 
-def _hibp_client() -> AsyncHTTPHandler:
+def get_hibp_client() -> AsyncHTTPHandler:
     return get_async_httpx_client(
         llm_provider=httpxSpecialProvider.PasswordBreachCheck,
         params={"timeout": HIBP_TIMEOUT_SECONDS},  # mutable-ok: callee takes a bare dict (PEP 589)
@@ -155,7 +155,7 @@ async def is_password_breached(
     corpus, or HIBP is unreachable (fail open)."""
     if not is_breach_check_enabled(general_settings):
         return False
-    return await _is_password_breached(password, client if client is not None else _hibp_client())
+    return await _is_password_breached(password, client if client is not None else get_hibp_client())
 
 
 def breached_password_error() -> ProxyException:
diff --git a/litellm/proxy/management_endpoints/model_management_endpoints.py b/litellm/proxy/management_endpoints/model_management_endpoints.py
index 615a528b552a..ae294871afc0 100644
--- a/litellm/proxy/management_endpoints/model_management_endpoints.py
+++ b/litellm/proxy/management_endpoints/model_management_endpoints.py
@@ -340,8 +340,21 @@ def _raise_on_strategy_router_write_violation(
     )
 
 
+def _stored_credential_name(existing_litellm_params: GenericLiteLLMParams | None) -> str | None:
+    if existing_litellm_params is None or existing_litellm_params.litellm_credential_name is None:
+        return None
+    return decrypt_value_helper(
+        value=existing_litellm_params.litellm_credential_name,
+        key="litellm_credential_name",
+        exception_type="debug",
+        return_original_value=True,
+    )
+
+
 async def _raise_on_invalid_credential_name(
-    litellm_params: updateLiteLLMParams | None, prisma_client: PrismaClient
+    litellm_params: updateLiteLLMParams | None,
+    existing_litellm_params: GenericLiteLLMParams | None,
+    prisma_client: PrismaClient,
 ) -> None:
     if litellm_params is None or "litellm_credential_name" not in litellm_params.model_fields_set:
         return
@@ -355,6 +368,8 @@ async def _raise_on_invalid_credential_name(
             code=status.HTTP_400_BAD_REQUEST,
             param="litellm_credential_name",
         )
+    if credential_name == _stored_credential_name(existing_litellm_params):
+        return
     if CredentialAccessor.find_credential(credential_name) is not None:
         return
     stored_credential: Final = await CredentialsRepository(WriterPinnedClient(prisma_client.db)).find_by_name(
@@ -1192,7 +1207,7 @@ async def patch_model(
             existing_litellm_params=db_model.litellm_params,
             null_detaches=True,
         )
-        await _raise_on_invalid_credential_name(patch_data.litellm_params, prisma_client)
+        await _raise_on_invalid_credential_name(patch_data.litellm_params, db_model.litellm_params, prisma_client)
 
         ModelManagementAuthChecks.can_user_set_aws_session_tags(
             litellm_params=patch_data.litellm_params,
@@ -2012,18 +2027,8 @@ def can_user_attach_credential(
             return True
         if litellm_params.litellm_credential_name is None and not null_detaches:
             return True
-        existing_credential_name: Final = (
-            decrypt_value_helper(
-                value=existing_litellm_params.litellm_credential_name,
-                key="litellm_credential_name",
-                exception_type="debug",
-                return_original_value=True,
-            )
-            if existing_litellm_params is not None and existing_litellm_params.litellm_credential_name is not None
-            else None
-        )
         requested_credential_name: Final = litellm_params.litellm_credential_name
-        if requested_credential_name == existing_credential_name:
+        if requested_credential_name == _stored_credential_name(existing_litellm_params):
             return True
         if user_api_key_dict.user_role == LitellmUserRoles.PROXY_ADMIN:
             return True
diff --git a/litellm/proxy/management_endpoints/password_endpoints.py b/litellm/proxy/management_endpoints/password_endpoints.py
index 99b7c994b405..16f3e7dfcfb3 100644
--- a/litellm/proxy/management_endpoints/password_endpoints.py
+++ b/litellm/proxy/management_endpoints/password_endpoints.py
@@ -14,6 +14,7 @@
 from pydantic import TypeAdapter
 
 from litellm._logging import verbose_proxy_logger
+from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
 from litellm.proxy._types import (
     UI_TEAM_ID,
     ChangePasswordRequest,
@@ -24,7 +25,11 @@
     UserAPIKeyAuth,
 )
 from litellm.proxy.auth.login_utils import PASSWORD_SESSION_METADATA
-from litellm.proxy.auth.password_policy import validate_password_not_breached, validate_password_policy
+from litellm.proxy.auth.password_policy import (
+    get_hibp_client,
+    validate_password_not_breached,
+    validate_password_policy,
+)
 from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
 from litellm.proxy.management_endpoints.session_endpoints import revoke_ui_session_keys
 from litellm.proxy.management_helpers.audit_logs import create_object_audit_log
@@ -71,6 +76,7 @@ def _user_table(
 async def change_password(
     data: ChangePasswordRequest,
     user_api_key_dict: Annotated[UserAPIKeyAuth, Depends(user_api_key_auth)],
+    hibp_client: Annotated[AsyncHTTPHandler, Depends(get_hibp_client)],
 ) -> ChangePasswordResponse:
     """
     Change the calling user's own password.
@@ -133,7 +139,7 @@ async def change_password(
         )
 
     validate_password_policy(data.new_password, general_settings)
-    await validate_password_not_breached(data.new_password, general_settings)
+    await validate_password_not_breached(data.new_password, general_settings, hibp_client)
 
     password_update: Final[prisma_types.LiteLLM_UserTableUpdateInput] = {
         "password": hash_password(data.new_password),
diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py
index 92a75bf953a7..9a42ee75c513 100644
--- a/litellm/proxy/proxy_server.py
+++ b/litellm/proxy/proxy_server.py
@@ -6344,10 +6344,12 @@ async def load_config(self, router: litellm.Router | None, config_file_path: str
 
             ### [DEPRECATED] LOAD FROM GOOGLE KMS ### old way of loading from google kms
             use_google_kms: Final = general_settings.get("use_google_kms", False)
-            load_google_kms(use_google_kms=use_google_kms)
+            if use_google_kms:
+                self.initialize_secret_manager(KeyManagementSystem.GOOGLE_KMS.value)
             ### [DEPRECATED] LOAD FROM AZURE KEY VAULT ### old way of loading from azure secret manager
             use_azure_key_vault: Final = general_settings.get("use_azure_key_vault", False)
-            load_from_azure_key_vault(use_azure_key_vault=use_azure_key_vault)
+            if use_azure_key_vault is not False:
+                self.initialize_secret_manager(KeyManagementSystem.AZURE_KEY_VAULT.value)
             ### ALERTING ###
             self._load_alerting_settings(general_settings=general_settings)
             ### PLUGINS ###
@@ -6848,6 +6850,7 @@ def initialize_secret_manager(
         """
         Initialize the relevant secret manager if `key_management_system` is provided
         """
+        previous_client: Final[object] = litellm.secret_manager_client
         if key_management_system is not None:
             if key_management_system == KeyManagementSystem.AZURE_KEY_VAULT.value:
                 ### LOAD FROM AZURE KEY VAULT ###
@@ -6896,6 +6899,11 @@ def initialize_secret_manager(
             else:
                 raise ValueError("Invalid Key Management System selected")
 
+            from litellm.rust_bridge.secret_manager import capture_secret_manager
+
+            if litellm.secret_manager_client is not previous_client:
+                capture_secret_manager(litellm.secret_manager_client, key_management_system)
+
     def get_model_info_with_id(self, model, db_model=False) -> RouterModelInfo:
         """
         Common logic across add + delete router models
diff --git a/litellm/rust_bridge/_native.pyi b/litellm/rust_bridge/_native.pyi
index 355a5e5062e1..60d2e6224c08 100644
--- a/litellm/rust_bridge/_native.pyi
+++ b/litellm/rust_bridge/_native.pyi
@@ -2,6 +2,9 @@ from asyncio import Future
 from collections.abc import AsyncIterator, Coroutine, Iterator, Mapping, Sequence
 from typing import Never, final
 
+import httpx
+from pydantic import JsonValue
+
 from litellm.llms.base_llm.ocr.transformation import OCRResponse
 from litellm.rust_bridge.messages.entrypoints import LiteLLMMessagesRequest
 from litellm.rust_bridge.ocr.entrypoints import LiteLLMOcrRequest
@@ -371,3 +374,42 @@ __all__ = [
     "reserve_process_for_forking",
     "transcription",
 ]
+
+@final
+class _SecretManagerRuntime:
+    @staticmethod
+    def from_config(
+        system: str,
+        environment: Mapping[str, str],
+        settings: Mapping[str, object] | None = None,
+        enterprise_enabled: bool = False,
+    ) -> _SecretManagerRuntime: ...
+    @staticmethod
+    def from_client(client: object) -> _SecretManagerRuntime | None: ...
+    @property
+    def system(self) -> str: ...
+    def read_secret(self, name: str, settings: Mapping[str, object] | None = None) -> JsonValue: ...
+    def read_secret_async(self, name: str, settings: Mapping[str, object] | None = None) -> Future[JsonValue]: ...
+    def async_write_secret(
+        self, secret_name: str, secret_value: str, description: str | None = None,
+        optional_params: Mapping[str, object] | None = None,
+        timeout: float | httpx.Timeout | None = None, tags: object = None,
+    ) -> Future[dict[str, JsonValue]]: ...
+    def async_delete_secret(
+        self, secret_name: str, recovery_window_in_days: int | None = None,
+        optional_params: Mapping[str, object] | None = None,
+        timeout: float | httpx.Timeout | None = None,
+    ) -> Future[dict[str, JsonValue]]: ...
+    def async_rotate_secret(
+        self, current_secret_name: str, new_secret_name: str, new_secret_value: str,
+        optional_params: Mapping[str, object] | None = None,
+        timeout: float | httpx.Timeout | None = None,
+    ) -> Future[dict[str, JsonValue]]: ...
+    def sync_read_secret(
+        self, secret_name: str, optional_params: Mapping[str, object] | None = None,
+        timeout: float | httpx.Timeout | None = None, primary_secret_name: str | None = None,
+    ) -> JsonValue: ...
+    def async_read_secret(
+        self, secret_name: str, optional_params: Mapping[str, object] | None = None,
+        timeout: float | httpx.Timeout | None = None, primary_secret_name: str | None = None,
+    ) -> Future[JsonValue]: ...
diff --git a/litellm/rust_bridge/secret_manager.py b/litellm/rust_bridge/secret_manager.py
new file mode 100644
index 000000000000..ca7dc2e6434d
--- /dev/null
+++ b/litellm/rust_bridge/secret_manager.py
@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+import os
+from collections.abc import Awaitable, Mapping
+from dataclasses import dataclass, field
+from importlib import import_module
+from typing import Final, Protocol, runtime_checkable
+
+import httpx
+from pydantic import JsonValue
+
+from litellm.rust_bridge.bindings import NativeBinding
+from litellm.rust_bridge.catalog import Rules, SecretManagerContext, decision
+from litellm.rust_bridge.configuration import Decision
+from litellm.types.secret_managers.main import KeyManagementSettings, KeyManagementSystem
+
+
+@dataclass(frozen=True, slots=True)
+class NativeSecretManagerConfig:
+    system: str
+    environment: tuple[tuple[str, str], ...] = field(repr=False)
+    settings: Mapping[str, object] = field(repr=False)
+    enterprise_enabled: bool
+    owner_type: type[object]
+    environment_attributes: tuple[tuple[str, str], ...]
+    settings_attributes: tuple[str, ...]
+    methods: tuple[tuple[str, object], ...] = field(repr=False)
+
+
+@dataclass(frozen=True, slots=True)
+class _ClientAdapter:
+    system: KeyManagementSystem
+    module: str
+    name: str
+    methods: tuple[str, ...]
+    environment_attributes: tuple[tuple[str, str], ...] = ()
+    settings_attributes: tuple[str, ...] = ()
+    enterprise_enabled: bool = False
+
+
+_ADAPTERS: Final = (
+    _ClientAdapter(
+        KeyManagementSystem.AWS_SECRET_MANAGER,
+        "litellm.secret_managers.aws_secret_manager_v2",
+        "AWSSecretsManagerV2",
+        ("sync_read_secret", "async_read_secret"),
+        settings_attributes=(
+            "aws_region_name",
+            "aws_role_name",
+            "aws_session_name",
+            "aws_external_id",
+            "aws_profile_name",
+            "aws_web_identity_token",
+            "aws_sts_endpoint",
+            "replica_regions",
+            "kms_key_id",
+        ),
+    ),
+    _ClientAdapter(
+        KeyManagementSystem.HASHICORP_VAULT,
+        "litellm.secret_managers.hashicorp_secret_manager",
+        "HashicorpSecretManager",
+        ("sync_read_secret", "async_read_secret", "async_write_secret", "async_delete_secret", "async_rotate_secret"),
+        environment_attributes=(
+            ("HCP_VAULT_ADDR", "vault_addr"),
+            ("HCP_VAULT_TOKEN", "vault_token"),
+            ("HCP_VAULT_NAMESPACE", "vault_namespace"),
+            ("HCP_VAULT_LOGIN_NAMESPACE", "login_namespace_override"),
+            ("HCP_VAULT_SECRET_NAMESPACE", "secret_namespace_override"),
+            ("HCP_VAULT_MOUNT_NAME", "vault_mount_name"),
+            ("HCP_VAULT_PATH_PREFIX", "vault_path_prefix"),
+            ("HCP_VAULT_CLIENT_CERT", "tls_cert_path"),
+            ("HCP_VAULT_CLIENT_KEY", "tls_key_path"),
+            ("HCP_VAULT_CERT_ROLE", "vault_cert_role"),
+            ("HCP_VAULT_APPROLE_ROLE_ID", "approle_role_id"),
+            ("HCP_VAULT_APPROLE_SECRET_ID", "approle_secret_id"),
+            ("HCP_VAULT_APPROLE_MOUNT_PATH", "approle_mount_path"),
+            ("HCP_VAULT_REFRESH_INTERVAL", "cache.default_ttl"),
+        ),
+        enterprise_enabled=True,
+    ),
+    _ClientAdapter(
+        KeyManagementSystem.CYBERARK,
+        "litellm.secret_managers.cyberark_secret_manager",
+        "CyberArkSecretManager",
+        ("sync_read_secret", "async_read_secret", "async_write_secret", "async_delete_secret", "async_rotate_secret"),
+        environment_attributes=(
+            ("CYBERARK_API_BASE", "conjur_addr"),
+            ("CYBERARK_ACCOUNT", "conjur_account"),
+            ("CYBERARK_USERNAME", "conjur_username"),
+            ("CYBERARK_API_KEY", "conjur_api_key"),
+            ("CYBERARK_CLIENT_CERT", "tls_cert_path"),
+            ("CYBERARK_CLIENT_KEY", "tls_key_path"),
+            ("CYBERARK_SSL_VERIFY", "ssl_verify"),
+            ("CYBERARK_REFRESH_INTERVAL", "cache.default_ttl"),
+        ),
+        enterprise_enabled=True,
+    ),
+    _ClientAdapter(
+        KeyManagementSystem.GOOGLE_SECRET_MANAGER,
+        "litellm.secret_managers.google_secret_manager",
+        "GoogleSecretManager",
+        ("get_secret_from_google_secret_manager",),
+        environment_attributes=(
+            ("GOOGLE_SECRET_MANAGER_PROJECT_ID", "PROJECT_ID"),
+            ("GOOGLE_SECRET_MANAGER_REFRESH_INTERVAL", "cache.default_ttl"),
+            ("GOOGLE_SECRET_MANAGER_ALWAYS_READ_SECRET_MANAGER", "always_read_secret_manager"),
+        ),
+        enterprise_enabled=True,
+    ),
+)
+
+_SDK_ADAPTERS: Final = (
+    _ClientAdapter(KeyManagementSystem.AZURE_KEY_VAULT, "azure.keyvault.secrets", "SecretClient", ("get_secret",)),
+    _ClientAdapter(KeyManagementSystem.GOOGLE_KMS, "google.cloud.kms_v1", "KeyManagementServiceClient", ("decrypt",)),
+)
+
+
+def _capture(client: object, adapter: _ClientAdapter) -> NativeSecretManagerConfig:
+    prefixes: Final = ("AWS_", "AZURE_", "GOOGLE_", "VERTEX_", "GCS_", "HCP_VAULT_", "CYBERARK_")
+    config: Final = NativeSecretManagerConfig(
+        system=adapter.system.value,
+        environment=tuple(
+            (name, value)
+            for name, value in os.environ.items()
+            if name.startswith(prefixes) or name == "SECRET_MANAGER_REFRESH_INTERVAL"
+        ),
+        settings=KeyManagementSettings().model_dump(mode="json"),
+        enterprise_enabled=adapter.enterprise_enabled,
+        owner_type=type(client),
+        environment_attributes=adapter.environment_attributes,
+        settings_attributes=adapter.settings_attributes,
+        methods=tuple((name, getattr(type(client), name)) for name in adapter.methods),
+    )
+    vars(client)["_litellm_native_secret_config"] = config
+    return config
+
+
+def capture_secret_manager(client: object, system: str) -> None:
+    for adapter in (*_ADAPTERS, *_SDK_ADAPTERS):
+        if (
+            adapter.system.value == system
+            and type(client).__name__ == adapter.name
+            and type(client) is getattr(import_module(adapter.module), adapter.name)
+        ):
+            _capture(client, adapter)
+            return
+    if (
+        system == KeyManagementSystem.AWS_KMS.value
+        and type(client).__module__ == "botocore.client"
+        and type(client).__name__ == "KMS"
+    ):
+        _capture(client, _ClientAdapter(KeyManagementSystem.AWS_KMS, "botocore.client", "KMS", ("decrypt",)))
+
+
+def native_secret_manager_config(client: object) -> NativeSecretManagerConfig | None:
+    captured: Final = getattr(client, "_litellm_native_secret_config", None)
+    if isinstance(captured, NativeSecretManagerConfig):
+        return captured
+    for adapter in _ADAPTERS:
+        if type(client).__module__ == adapter.module and type(client) is getattr(
+            import_module(adapter.module), adapter.name
+        ):
+            return _capture(client, adapter)
+    return None
+
+
+class NativeSecretManagerRuntime(Protocol):
+    @property
+    def system(self) -> str: ...
+
+    def read_secret(self, name: str, settings: Mapping[str, object] | None = None) -> JsonValue: ...
+
+
+@runtime_checkable
+class NativeSecretManagerFactory(Protocol):
+    @staticmethod
+    def from_client(client: object) -> NativeSecretManagerRuntime | None: ...
+
+
+def _factory(value: object) -> NativeSecretManagerFactory | None:
+    return value if isinstance(value, NativeSecretManagerFactory) and callable(value.from_client) else None
+
+
+NATIVE_SECRET_MANAGER: Final = NativeBinding("_SecretManagerRuntime", validate=_factory)
+
+
+def resolve_native_secret_manager(
+    client: object,
+    system: str,
+    rules: Rules | None = None,
+    *,
+    binding: NativeBinding[NativeSecretManagerFactory] = NATIVE_SECRET_MANAGER,
+) -> NativeSecretManagerRuntime | None:
+    if system in ("custom", "local"):
+        return None
+    selected: Final = decision(SecretManagerContext(system=system), rules)
+    if selected is Decision.PYTHON:
+        return None
+    factory: Final = binding.load()
+    if factory is None:
+        if selected is Decision.RUST_REQUIRED:
+            raise RuntimeError("Rust secret manager runtime is unavailable")
+        return None
+    runtime: Final = factory.from_client(client)
+    if runtime is not None and runtime.system != system:
+        raise ValueError("Native secret manager system does not match configuration")
+    return runtime
+
+
+@runtime_checkable
+class NativeProviderReader(Protocol):
+    def sync_read_secret(
+        self,
+        secret_name: str,
+        optional_params: Mapping[str, object] | None = None,
+        timeout: float | httpx.Timeout | None = None,
+    ) -> str | None: ...
+
+    def async_read_secret(
+        self,
+        secret_name: str,
+        optional_params: Mapping[str, object] | None = None,
+        timeout: float | httpx.Timeout | None = None,
+    ) -> Awaitable[str | None]: ...
+
+
+def resolve_native_provider_reader(
+    client: object,
+    system: str,
+    rules: Rules | None = None,
+    *,
+    binding: NativeBinding[NativeSecretManagerFactory] = NATIVE_SECRET_MANAGER,
+) -> NativeProviderReader | None:
+    runtime: Final = resolve_native_secret_manager(client, system, rules, binding=binding)
+    if runtime is None:
+        return None
+    if not isinstance(runtime, NativeProviderReader):
+        raise TypeError("Rust secret manager provider reads are unavailable")
+    return runtime
+
+
+@runtime_checkable
+class NativeProviderWriter(Protocol):
+    def async_write_secret(
+        self,
+        secret_name: str,
+        secret_value: str,
+        description: str | None = None,
+        optional_params: Mapping[str, object] | None = None,
+        timeout: float | httpx.Timeout | None = None,
+        tags: object = None,
+    ) -> Awaitable[dict[str, JsonValue]]: ...
+
+    def async_delete_secret(
+        self,
+        secret_name: str,
+        recovery_window_in_days: int | None = 7,
+        optional_params: Mapping[str, object] | None = None,
+        timeout: float | httpx.Timeout | None = None,
+    ) -> Awaitable[dict[str, JsonValue]]: ...
+
+    def async_rotate_secret(
+        self,
+        current_secret_name: str,
+        new_secret_name: str,
+        new_secret_value: str,
+        optional_params: Mapping[str, object] | None = None,
+        timeout: float | httpx.Timeout | None = None,
+    ) -> Awaitable[dict[str, JsonValue]]: ...
+
+
+def resolve_native_provider_writer(
+    client: object,
+    system: str,
+    rules: Rules | None = None,
+    *,
+    binding: NativeBinding[NativeSecretManagerFactory] = NATIVE_SECRET_MANAGER,
+) -> NativeProviderWriter | None:
+    runtime: Final = resolve_native_secret_manager(client, system, rules, binding=binding)
+    if runtime is None:
+        return None
+    if not isinstance(runtime, NativeProviderWriter):
+        raise TypeError("Rust secret manager provider writes are unavailable")
+    return runtime
diff --git a/litellm/rust_bridge/settings.py b/litellm/rust_bridge/settings.py
index 46e96b606207..7861f50574f9 100644
--- a/litellm/rust_bridge/settings.py
+++ b/litellm/rust_bridge/settings.py
@@ -1,7 +1,10 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Final
+from typing import TYPE_CHECKING, Final
+
+if TYPE_CHECKING:
+    from litellm.rust_bridge.catalog import Rules
 
 
 @dataclass(frozen=True, slots=True)
@@ -34,6 +37,7 @@ class ProviderDefaults:
 @dataclass(frozen=True, slots=True)
 class SecretManager:
     readable: bool
+    native: bool
 
 
 @dataclass(frozen=True, slots=True)
@@ -58,12 +62,24 @@ class SecretManagerBinding:
     settings_object: object
 
 
-def secret_manager() -> SecretManager:
+def secret_manager(rules: Rules | None = None) -> SecretManager:
+    import litellm
+    from litellm.rust_bridge.catalog import SecretManagerContext, decision
+    from litellm.rust_bridge.configuration import Decision
     from litellm.secret_managers.main import (
         _should_read_secret_from_secret_manager,  # pyright: ignore[reportPrivateUsage]  # canonical resolver is private
     )
 
-    return SecretManager(readable=_should_read_secret_from_secret_manager())
+    readable: Final = _should_read_secret_from_secret_manager()
+    system: Final = (
+        litellm._key_management_system  # pyright: ignore[reportPrivateUsage]  # canonical key management globals are private
+    )
+    native: Final = (
+        readable
+        and system is not None
+        and decision(SecretManagerContext(system=system.value), rules) is not Decision.PYTHON
+    )
+    return SecretManager(readable=readable, native=native)
 
 
 def secret_manager_binding() -> SecretManagerBinding:
diff --git a/litellm/secret_managers/aws_secret_manager_v2.py b/litellm/secret_managers/aws_secret_manager_v2.py
index 3e9f4e259d54..80fe3f38c036 100644
--- a/litellm/secret_managers/aws_secret_manager_v2.py
+++ b/litellm/secret_managers/aws_secret_manager_v2.py
@@ -31,6 +31,7 @@
     get_async_httpx_client,
 )
 from litellm.proxy._types import KeyManagementSystem
+from litellm.rust_bridge.secret_manager import resolve_native_provider_reader
 from litellm.secret_managers.main import get_secret_str
 from litellm.types.llms.custom_http import httpxSpecialProvider
 from litellm.types.secret_managers.main import KeyManagementSettings
@@ -140,6 +141,10 @@ async def async_read_secret(
                 secret_name=secret_name, primary_secret_name=primary_secret_name
             )
 
+        native: Final = resolve_native_provider_reader(self, "aws_secret_manager")
+        if native is not None:
+            return await native.async_read_secret(secret_name, optional_params, timeout)
+
         endpoint_url, headers, body = self._prepare_request(
             action="GetSecretValue",
             secret_name=secret_name,
@@ -192,6 +197,10 @@ def sync_read_secret(
                 secret_name=secret_name, primary_secret_name=primary_secret_name
             )
 
+        native: Final = resolve_native_provider_reader(self, "aws_secret_manager")
+        if native is not None:
+            return native.sync_read_secret(secret_name, optional_params, timeout)
+
         endpoint_url, headers, body = self._prepare_request(
             action="GetSecretValue",
             secret_name=secret_name,
diff --git a/litellm/secret_managers/cyberark_secret_manager.py b/litellm/secret_managers/cyberark_secret_manager.py
index a49349991c5b..b28e15c44463 100644
--- a/litellm/secret_managers/cyberark_secret_manager.py
+++ b/litellm/secret_managers/cyberark_secret_manager.py
@@ -15,6 +15,7 @@
     httpxSpecialProvider,
 )
 from litellm.proxy._types import KeyManagementSystem
+from litellm.rust_bridge.secret_manager import resolve_native_provider_reader, resolve_native_provider_writer
 
 from .base_secret_manager import BaseSecretManager, raise_if_unsafe_secret_name
 from .main import str_to_bool
@@ -186,6 +187,10 @@ async def async_read_secret(
         Returns:
             Optional[str]: The secret value if found, None otherwise
         """
+        native: Final = resolve_native_provider_reader(self, "cyberark")
+        if native is not None:
+            return await native.async_read_secret(secret_name, optional_params, timeout)
+
         # Check cache first
         if self.cache.get_cache(secret_name) is not None:
             return self.cache.get_cache(secret_name)
@@ -232,6 +237,10 @@ def sync_read_secret(
         Returns:
             Optional[str]: The secret value if found, None otherwise
         """
+        native: Final = resolve_native_provider_reader(self, "cyberark")
+        if native is not None:
+            return native.sync_read_secret(secret_name, optional_params, timeout)
+
         # Check cache first
         if self.cache.get_cache(secret_name) is not None:
             return self.cache.get_cache(secret_name)
@@ -281,6 +290,12 @@ async def async_write_secret(
         Returns:
             dict: Response containing status and details of the operation
         """
+        native: Final = resolve_native_provider_writer(self, "cyberark")
+        if native is not None:
+            return await native.async_write_secret(
+                secret_name, secret_value, description, optional_params, timeout, tags
+            )
+
         async_client: Final = get_async_httpx_client(
             llm_provider=httpxSpecialProvider.SecretManager,
             params={"ssl_verify": self.ssl_verify},
@@ -326,6 +341,10 @@ async def async_delete_secret(
         Returns:
             dict: Response indicating operation not supported
         """
+        native: Final = resolve_native_provider_writer(self, "cyberark")
+        if native is not None:
+            return await native.async_delete_secret(secret_name, recovery_window_in_days, optional_params, timeout)
+
         verbose_logger.warning(
             "CyberArk Conjur does not support direct secret deletion. Secrets must be removed through policy updates."
         )
@@ -337,3 +356,28 @@ async def async_delete_secret(
             "status": "not_supported",
             "message": "CyberArk Conjur does not support direct secret deletion. Use policy updates to remove variables.",
         }
+
+    async def async_rotate_secret(
+        self,
+        current_secret_name: str,
+        new_secret_name: str,
+        new_secret_value: str,
+        optional_params: dict | None = None,
+        timeout: float | httpx.Timeout | None = None,
+    ) -> dict:
+        native: Final = resolve_native_provider_writer(self, "cyberark")
+        if native is not None:
+            return await native.async_rotate_secret(
+                current_secret_name,
+                new_secret_name,
+                new_secret_value,
+                optional_params,
+                timeout,
+            )
+        return await super().async_rotate_secret(
+            current_secret_name,
+            new_secret_name,
+            new_secret_value,
+            optional_params,
+            timeout,
+        )
diff --git a/litellm/secret_managers/dispatch.py b/litellm/secret_managers/dispatch.py
new file mode 100644
index 000000000000..4912771eb3c6
--- /dev/null
+++ b/litellm/secret_managers/dispatch.py
@@ -0,0 +1,30 @@
+from typing import Final
+
+from pydantic import JsonValue
+
+from litellm.rust_bridge.bindings import NativeBinding
+from litellm.rust_bridge.catalog import Rules
+from litellm.rust_bridge.secret_manager import (
+    NATIVE_SECRET_MANAGER,
+    NativeSecretManagerFactory,
+    resolve_native_secret_manager,
+)
+from litellm.secret_managers.secret_manager_handler import get_secret_from_manager as python_get_secret_from_manager
+from litellm.types.secret_managers.main import KeyManagementSettings
+
+
+def get_secret_from_manager(
+    client: object,
+    key_manager: str,
+    secret_name: str,
+    key_management_settings: KeyManagementSettings | None = None,
+    *,
+    rules: Rules | None = None,
+    binding: NativeBinding[NativeSecretManagerFactory] = NATIVE_SECRET_MANAGER,
+) -> JsonValue:
+    native: Final = resolve_native_secret_manager(client, key_manager, rules, binding=binding)
+    if native is None:
+        return python_get_secret_from_manager(client, key_manager, secret_name, key_management_settings)
+    return native.read_secret(
+        secret_name, key_management_settings.model_dump(mode="json") if key_management_settings is not None else None
+    )
diff --git a/litellm/secret_managers/google_secret_manager.py b/litellm/secret_managers/google_secret_manager.py
index 6674549e39c8..913fd4d52049 100644
--- a/litellm/secret_managers/google_secret_manager.py
+++ b/litellm/secret_managers/google_secret_manager.py
@@ -9,6 +9,7 @@
 from litellm.integrations.gcs_bucket.gcs_bucket_base import GCSBucketBase
 from litellm.llms.custom_httpx.http_handler import _get_httpx_client
 from litellm.proxy._types import CommonProxyErrors, KeyManagementSystem
+from litellm.rust_bridge.secret_manager import resolve_native_provider_reader
 
 
 class GoogleSecretManager(GCSBucketBase):
@@ -60,6 +61,10 @@ def get_secret_from_google_secret_manager(self, secret_name: str) -> str | None:
         Returns:
             str: The secret value if successful, None otherwise.
         """
+        native: Final = resolve_native_provider_reader(self, "google_secret_manager")
+        if native is not None:
+            return native.sync_read_secret(secret_name)
+
         if self.always_read_secret_manager is not True:
             cached_secret: Final = self.cache.get_cache(secret_name)
             if cached_secret is not None:
diff --git a/litellm/secret_managers/hashicorp_secret_manager.py b/litellm/secret_managers/hashicorp_secret_manager.py
index e37a912c7e1b..27523892d61a 100644
--- a/litellm/secret_managers/hashicorp_secret_manager.py
+++ b/litellm/secret_managers/hashicorp_secret_manager.py
@@ -16,6 +16,7 @@
     httpxSpecialProvider,
 )
 from litellm.proxy._types import KeyManagementSystem
+from litellm.rust_bridge.secret_manager import resolve_native_provider_reader, resolve_native_provider_writer
 
 from .base_secret_manager import BaseSecretManager, raise_if_unsafe_secret_name
 
@@ -405,6 +406,10 @@ async def async_read_secret(
         secret_name is just the path inside the KV mount (e.g., 'myapp/config').
         Returns the entire data dict from data.data, or None on failure.
         """
+        native: Final = resolve_native_provider_reader(self, "hashicorp_vault")
+        if native is not None:
+            return await native.async_read_secret(secret_name, optional_params, timeout)
+
         async_client: Final = get_async_httpx_client(
             llm_provider=httpxSpecialProvider.SecretManager,
         )
@@ -436,6 +441,10 @@ def sync_read_secret(
         secret_name is just the path inside the KV mount (e.g., 'myapp/config').
         Returns the entire data dict from data.data, or None on failure.
         """
+        native: Final = resolve_native_provider_reader(self, "hashicorp_vault")
+        if native is not None:
+            return native.sync_read_secret(secret_name, optional_params, timeout)
+
         sync_client: Final = _get_httpx_client()
         try:
             target: Final = self._build_secret_target(secret_name, optional_params)
@@ -476,6 +485,12 @@ async def async_write_secret(
         Returns:
             dict: Response containing status and details of the operation
         """
+        native: Final = resolve_native_provider_writer(self, "hashicorp_vault")
+        if native is not None:
+            return await native.async_write_secret(
+                secret_name, secret_value, description, optional_params, timeout, tags
+            )
+
         async_client: Final = get_async_httpx_client(
             llm_provider=httpxSpecialProvider.SecretManager,
             params={"timeout": timeout},
@@ -525,6 +540,12 @@ async def async_rotate_secret(
                   On success, returns the response from async_write_secret.
                   On error, returns {"status": "error", "message": "error message"}
         """
+        native: Final = resolve_native_provider_writer(self, "hashicorp_vault")
+        if native is not None:
+            return await native.async_rotate_secret(
+                current_secret_name, new_secret_name, new_secret_value, optional_params, timeout
+            )
+
         async_client: Final = get_async_httpx_client(
             llm_provider=httpxSpecialProvider.SecretManager,
             params={"timeout": timeout},
@@ -671,6 +692,10 @@ async def async_delete_secret(
         Returns:
             dict: Response containing status and details of the operation
         """
+        native: Final = resolve_native_provider_writer(self, "hashicorp_vault")
+        if native is not None:
+            return await native.async_delete_secret(secret_name, recovery_window_in_days, optional_params, timeout)
+
         async_client: Final = get_async_httpx_client(
             llm_provider=httpxSpecialProvider.SecretManager,
             params={"timeout": timeout},
diff --git a/litellm/secret_managers/main.py b/litellm/secret_managers/main.py
index e89fbbdab65f..f09ddd1d5a98 100644
--- a/litellm/secret_managers/main.py
+++ b/litellm/secret_managers/main.py
@@ -12,10 +12,10 @@
 from litellm._logging import verbose_logger
 from litellm.caching.caching import DualCache
 from litellm.llms.custom_httpx.http_handler import HTTPHandler
+from litellm.secret_managers.dispatch import get_secret_from_manager
 from litellm.secret_managers.get_azure_ad_token_provider import (
     get_azure_ad_token_provider,
 )
-from litellm.secret_managers.secret_manager_handler import get_secret_from_manager
 
 oidc_cache: Final = DualCache()
 
diff --git a/litellm/types/utils.py b/litellm/types/utils.py
index dfc98a9d89d1..3f8471cbde1e 100644
--- a/litellm/types/utils.py
+++ b/litellm/types/utils.py
@@ -4043,6 +4043,7 @@ def pricing_override_fields(*sources: Mapping[str, Any]) -> tuple[str, ...]:
         "no-log",
         "base_model",
         "stream_timeout",
+        "stream_chunk_size",
         "supports_system_message",
         "region_name",
         "allowed_model_region",
diff --git a/model_prices_and_context_window.json b/model_prices_and_context_window.json
index ae02744b8e10..da8013ae7098 100644
--- a/model_prices_and_context_window.json
+++ b/model_prices_and_context_window.json
@@ -3810,6 +3810,104 @@
         "supports_web_search": true,
         "supports_xhigh_reasoning_effort": true
     },
+    "azure_ai/gpt-6-luna": {
+        "cache_creation_input_token_cost": 1.25e-07,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.5e-07,
+        "cache_read_input_token_cost": 1e-08,
+        "cache_read_input_token_cost_above_272k_tokens": 2e-08,
+        "input_cost_per_token": 1e-07,
+        "input_cost_per_token_above_272k_tokens": 2e-07,
+        "litellm_provider": "azure_ai",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 5e-07,
+        "output_cost_per_token_above_272k_tokens": 7.5e-07,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_cache_breakpoint": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
+    "azure_ai/gpt-6-sol": {
+        "cache_creation_input_token_cost": 2.5e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 5e-06,
+        "cache_read_input_token_cost": 2e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 4e-07,
+        "input_cost_per_token": 2e-06,
+        "input_cost_per_token_above_272k_tokens": 4e-06,
+        "litellm_provider": "azure_ai",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 1e-05,
+        "output_cost_per_token_above_272k_tokens": 1.5e-05,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_cache_breakpoint": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
     "azure_ai/gpt-5.5": {
         "deprecation_date": "2027-10-26",
         "cache_read_input_token_cost": 5e-07,
@@ -3894,6 +3992,7 @@
     "azure_ai/gpt-image-2": {
         "cache_read_input_image_token_cost": 2e-06,
         "cache_read_input_token_cost": 1.25e-06,
+        "deprecation_date": "2027-10-21",
         "input_cost_per_image_token": 8e-06,
         "input_cost_per_token": 5e-06,
         "litellm_provider": "azure_ai",
@@ -7799,20 +7898,74 @@
         "supports_web_search": true,
         "supports_xhigh_reasoning_effort": true
     },
-    "azure/gpt-chat-latest": {
-        "cache_read_input_token_cost": 5e-07,
-        "deprecation_date": "2026-12-02",
-        "input_cost_per_token": 5e-06,
+    "azure/gpt-6-luna": {
+        "cache_creation_input_token_cost": 1.25e-07,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.5e-07,
+        "cache_read_input_token_cost": 1e-08,
+        "cache_read_input_token_cost_above_272k_tokens": 2e-08,
+        "input_cost_per_token": 1e-07,
+        "input_cost_per_token_above_272k_tokens": 2e-07,
         "litellm_provider": "azure",
-        "max_input_tokens": 272000,
+        "max_input_tokens": 922000,
         "max_output_tokens": 128000,
         "max_tokens": 128000,
         "mode": "chat",
-        "output_cost_per_token": 3e-05,
-        "reasoning_effort_levels": [
-            "medium"
+        "output_cost_per_token": 5e-07,
+        "output_cost_per_token_above_272k_tokens": 7.5e-07,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
         ],
-        "source": "https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
+    "azure/gpt-6-luna-2026-09-22": {
+        "cache_creation_input_token_cost": 1.25e-07,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.5e-07,
+        "cache_read_input_token_cost": 1e-08,
+        "cache_read_input_token_cost_above_272k_tokens": 2e-08,
+        "input_cost_per_token": 1e-07,
+        "input_cost_per_token_above_272k_tokens": 2e-07,
+        "litellm_provider": "azure",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 5e-07,
+        "output_cost_per_token_above_272k_tokens": 7.5e-07,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
         "supported_endpoints": [
             "/v1/chat/completions",
             "/v1/responses"
@@ -7824,8 +7977,12 @@
         "supported_output_modalities": [
             "text"
         ],
+        "supports_computer_use": true,
         "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
         "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
         "supports_parallel_function_calling": true,
         "supports_pdf_input": true,
         "supports_prompt_caching": true,
@@ -7834,9 +7991,143 @@
         "supports_system_messages": true,
         "supports_tool_choice": true,
         "supports_vision": true,
-        "supports_web_search": true
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
     },
-    "azure/chat-latest": {
+    "azure/gpt-6-sol": {
+        "cache_creation_input_token_cost": 2.5e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 5e-06,
+        "cache_read_input_token_cost": 2e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 4e-07,
+        "input_cost_per_token": 2e-06,
+        "input_cost_per_token_above_272k_tokens": 4e-06,
+        "litellm_provider": "azure",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 1e-05,
+        "output_cost_per_token_above_272k_tokens": 1.5e-05,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
+    "azure/gpt-6-sol-2026-09-22": {
+        "cache_creation_input_token_cost": 2.5e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 5e-06,
+        "cache_read_input_token_cost": 2e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 4e-07,
+        "input_cost_per_token": 2e-06,
+        "input_cost_per_token_above_272k_tokens": 4e-06,
+        "litellm_provider": "azure",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 1e-05,
+        "output_cost_per_token_above_272k_tokens": 1.5e-05,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
+    "azure/gpt-chat-latest": {
+        "cache_read_input_token_cost": 5e-07,
+        "deprecation_date": "2026-12-02",
+        "input_cost_per_token": 5e-06,
+        "litellm_provider": "azure",
+        "max_input_tokens": 272000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 3e-05,
+        "reasoning_effort_levels": [
+            "medium"
+        ],
+        "source": "https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_function_calling": true,
+        "supports_native_streaming": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true
+    },
+    "azure/chat-latest": {
         "cache_read_input_token_cost": 5e-07,
         "deprecation_date": "2026-12-02",
         "input_cost_per_token": 5e-06,
@@ -8143,6 +8434,102 @@
         "supports_web_search": true,
         "supports_xhigh_reasoning_effort": true
     },
+    "azure/us/gpt-6-luna": {
+        "cache_creation_input_token_cost": 1.375e-07,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.75e-07,
+        "cache_read_input_token_cost": 1.1e-08,
+        "cache_read_input_token_cost_above_272k_tokens": 2.2e-08,
+        "input_cost_per_token": 1.1e-07,
+        "input_cost_per_token_above_272k_tokens": 2.2e-07,
+        "litellm_provider": "azure",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 5.5e-07,
+        "output_cost_per_token_above_272k_tokens": 8.25e-07,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
+    "azure/us/gpt-6-sol": {
+        "cache_creation_input_token_cost": 2.75e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 5.5e-06,
+        "cache_read_input_token_cost": 2.2e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 4.4e-07,
+        "input_cost_per_token": 2.2e-06,
+        "input_cost_per_token_above_272k_tokens": 4.4e-06,
+        "litellm_provider": "azure",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 1.1e-05,
+        "output_cost_per_token_above_272k_tokens": 1.65e-05,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
     "azure/us/gpt-chat-latest": {
         "cache_read_input_token_cost": 5.5e-07,
         "deprecation_date": "2026-12-02",
@@ -34171,6 +34558,7 @@
         "supports_vision": true
     },
     "groq/llama-guard-3-8b": {
+        "deprecation_date": "2025-06-06",
         "input_cost_per_token": 2e-07,
         "litellm_provider": "groq",
         "max_input_tokens": 8192,
@@ -39858,21 +40246,21 @@
         "supports_web_search": false
     },
     "openrouter/deepseek/deepseek-v4-pro": {
-        "input_cost_per_token": 8.92272e-07,
+        "input_cost_per_token": 8.8044e-07,
         "input_cost_per_token_cache_hit": 4.4e-08,
         "litellm_provider": "openrouter",
         "max_input_tokens": 1048576,
         "max_output_tokens": 384000,
         "max_tokens": 384000,
         "mode": "chat",
-        "output_cost_per_token": 1.784544e-06,
+        "output_cost_per_token": 1.76088e-06,
         "source": "https://openrouter.ai/api/v1/models",
         "supports_function_calling": true,
         "supports_prompt_caching": true,
         "supports_reasoning": true,
         "supports_response_schema": true,
         "supports_tool_choice": true,
-        "cache_read_input_token_cost": 7.4356e-08,
+        "cache_read_input_token_cost": 7.337e-08,
         "supports_audio_input": false,
         "supports_pdf_input": false,
         "supports_vision": false,
@@ -39884,10 +40272,10 @@
         "cache_read_input_token_cost": 6e-09,
         "litellm_provider": "openrouter",
         "max_input_tokens": 1048576,
-        "max_output_tokens": 384000,
-        "max_tokens": 384000,
+        "max_output_tokens": 943718,
+        "max_tokens": 943718,
         "mode": "chat",
-        "off_peak_pricing": {"windows":[{"weekdays":["saturday","sunday"],"hours_utc":"00:00-00:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"00:00-01:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"04:00-06:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"10:00-00:00"}],"input_cost_per_token":1.5e-7,"output_cost_per_token":6e-7,"cache_read_input_token_cost":3e-9},
+        "off_peak_pricing": {"windows":[{"weekdays":["saturday","sunday"],"hours_utc":"00:00-00:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"00:00-01:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"04:00-06:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"10:00-00:00"}],"input_cost_per_token":3e-7,"output_cost_per_token":0.0000012,"cache_read_input_token_cost":6e-9},
         "source": "https://openrouter.ai/api/v1/models",
         "supports_audio_input": false,
         "supports_function_calling": true,
@@ -39915,7 +40303,7 @@
         "supports_response_schema": true,
         "supports_tool_choice": true,
         "cache_read_input_token_cost": 4.4e-08,
-        "off_peak_pricing": {"windows":[{"weekdays":["saturday","sunday"],"hours_utc":"00:00-00:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"00:00-01:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"04:00-06:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"10:00-00:00"}],"input_cost_per_token":6.6e-7,"output_cost_per_token":0.00000198,"cache_read_input_token_cost":2.2e-8},
+        "off_peak_pricing": {"windows":[{"weekdays":["saturday","sunday"],"hours_utc":"00:00-00:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"00:00-01:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"04:00-06:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"10:00-00:00"}],"input_cost_per_token":0.00000132,"output_cost_per_token":0.00000396,"cache_read_input_token_cost":4.4e-8},
         "supports_audio_input": false,
         "supports_pdf_input": false,
         "supports_vision": false,
@@ -54811,6 +55199,54 @@
         "supports_response_schema": false,
         "supports_web_search": false
     },
+    "gemini/gemini-3.8-flash-tts": {
+        "cache_read_input_token_cost": 1.25e-07,
+        "cache_read_input_token_cost_batches": 6.25e-08,
+        "cache_read_input_token_cost_flex": 2.5e-08,
+        "cache_read_input_token_cost_priority": 2.25e-07,
+        "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,
+        "litellm_provider": "gemini",
+        "max_input_tokens": 8192,
+        "max_output_tokens": 16384,
+        "max_tokens": 16384,
+        "mode": "audio_speech",
+        "output_cost_per_audio_token": 9e-06,
+        "output_cost_per_token": 9e-06,
+        "output_cost_per_token_batches": 4.5e-06,
+        "output_cost_per_token_flex": 4.5e-06,
+        "output_cost_per_token_priority": 1.62e-05,
+        "source": "https://ai.google.dev/gemini-api/docs/pricing",
+        "supported_endpoints": [
+            "/v1/audio/speech"
+        ]
+    },
+    "gemini/gemini-3.8-flash-lite-tts": {
+        "cache_read_input_token_cost": 1.25e-07,
+        "cache_read_input_token_cost_batches": 6.25e-08,
+        "cache_read_input_token_cost_flex": 2.5e-08,
+        "cache_read_input_token_cost_priority": 2.25e-07,
+        "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,
+        "litellm_provider": "gemini",
+        "max_input_tokens": 8192,
+        "max_output_tokens": 16384,
+        "max_tokens": 16384,
+        "mode": "audio_speech",
+        "output_cost_per_audio_token": 6e-06,
+        "output_cost_per_token": 6e-06,
+        "output_cost_per_token_batches": 3e-06,
+        "output_cost_per_token_flex": 3e-06,
+        "output_cost_per_token_priority": 1.08e-05,
+        "source": "https://ai.google.dev/gemini-api/docs/pricing",
+        "supported_endpoints": [
+            "/v1/audio/speech"
+        ]
+    },
     "gemini-2.5-flash-preview-tts": {
         "input_cost_per_token": 5e-07,
         "input_cost_per_token_batches": 2.5e-07,
@@ -55682,6 +56118,82 @@
         "supports_vision": true,
         "source": "https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-openai-gpt-6-astra.html"
     },
+    "bedrock_mantle/openai.gpt-6-sol": {
+        "input_cost_per_token": 2.2e-06,
+        "input_cost_per_token_above_272k_tokens": 4.4e-06,
+        "cache_creation_input_token_cost": 2.75e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 5.5e-06,
+        "cache_read_input_token_cost": 2.2e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 4.4e-07,
+        "output_cost_per_token": 1.1e-05,
+        "output_cost_per_token_above_272k_tokens": 1.65e-05,
+        "litellm_provider": "bedrock_mantle",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "responses",
+        "use_openai_responses_path": true,
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_none_reasoning_effort": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_xhigh_reasoning_effort": true,
+        "supports_vision": true,
+        "source": "https://docs.aws.amazon.com/bedrock/latest/userguide/model-cards-openai.html"
+    },
+    "bedrock_mantle/openai.gpt-6-luna": {
+        "input_cost_per_token": 1.1e-07,
+        "input_cost_per_token_above_272k_tokens": 2.2e-07,
+        "cache_creation_input_token_cost": 1.375e-07,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.75e-07,
+        "cache_read_input_token_cost": 1.1e-08,
+        "cache_read_input_token_cost_above_272k_tokens": 2.2e-08,
+        "output_cost_per_token": 5.5e-07,
+        "output_cost_per_token_above_272k_tokens": 8.25e-07,
+        "litellm_provider": "bedrock_mantle",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "responses",
+        "use_openai_responses_path": true,
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_none_reasoning_effort": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_xhigh_reasoning_effort": true,
+        "supports_vision": true,
+        "source": "https://docs.aws.amazon.com/bedrock/latest/userguide/model-cards-openai.html"
+    },
     "us.openai.gpt-6-astra": {
         "input_cost_per_token": 1.1e-05,
         "input_cost_per_token_above_272k_tokens": 2.2e-05,
@@ -55714,6 +56226,70 @@
         "supports_vision": true,
         "source": "https://aws.amazon.com/bedrock/pricing/"
     },
+    "us.openai.gpt-6-sol": {
+        "input_cost_per_token": 2.2e-06,
+        "input_cost_per_token_above_272k_tokens": 4.4e-06,
+        "cache_creation_input_token_cost": 2.75e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 5.5e-06,
+        "cache_read_input_token_cost": 2.2e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 4.4e-07,
+        "output_cost_per_token": 1.1e-05,
+        "output_cost_per_token_above_272k_tokens": 1.65e-05,
+        "litellm_provider": "bedrock_converse",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_none_reasoning_effort": false,
+        "supports_tool_choice": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_xhigh_reasoning_effort": true,
+        "supports_vision": true,
+        "source": "https://aws.amazon.com/bedrock/pricing/"
+    },
+    "us.openai.gpt-6-luna": {
+        "input_cost_per_token": 1.1e-07,
+        "input_cost_per_token_above_272k_tokens": 2.2e-07,
+        "cache_creation_input_token_cost": 1.375e-07,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.75e-07,
+        "cache_read_input_token_cost": 1.1e-08,
+        "cache_read_input_token_cost_above_272k_tokens": 2.2e-08,
+        "output_cost_per_token": 5.5e-07,
+        "output_cost_per_token_above_272k_tokens": 8.25e-07,
+        "litellm_provider": "bedrock_converse",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_none_reasoning_effort": false,
+        "supports_tool_choice": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_xhigh_reasoning_effort": true,
+        "supports_vision": true,
+        "source": "https://aws.amazon.com/bedrock/pricing/"
+    },
     "global.openai.gpt-6-astra": {
         "input_cost_per_token": 1e-05,
         "input_cost_per_token_above_272k_tokens": 2e-05,
@@ -55746,6 +56322,70 @@
         "supports_vision": true,
         "source": "https://aws.amazon.com/bedrock/pricing/"
     },
+    "global.openai.gpt-6-sol": {
+        "input_cost_per_token": 2e-06,
+        "input_cost_per_token_above_272k_tokens": 4e-06,
+        "cache_creation_input_token_cost": 2.5e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 5e-06,
+        "cache_read_input_token_cost": 2e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 4e-07,
+        "output_cost_per_token": 1e-05,
+        "output_cost_per_token_above_272k_tokens": 1.5e-05,
+        "litellm_provider": "bedrock_converse",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_none_reasoning_effort": false,
+        "supports_tool_choice": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_xhigh_reasoning_effort": true,
+        "supports_vision": true,
+        "source": "https://aws.amazon.com/bedrock/pricing/"
+    },
+    "global.openai.gpt-6-luna": {
+        "input_cost_per_token": 1e-07,
+        "input_cost_per_token_above_272k_tokens": 2e-07,
+        "cache_creation_input_token_cost": 1.25e-07,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.5e-07,
+        "cache_read_input_token_cost": 1e-08,
+        "cache_read_input_token_cost_above_272k_tokens": 2e-08,
+        "output_cost_per_token": 5e-07,
+        "output_cost_per_token_above_272k_tokens": 7.5e-07,
+        "litellm_provider": "bedrock_converse",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_none_reasoning_effort": false,
+        "supports_tool_choice": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_xhigh_reasoning_effort": true,
+        "supports_vision": true,
+        "source": "https://aws.amazon.com/bedrock/pricing/"
+    },
     "bedrock_mantle/openai.gpt-5.5": {
         "input_cost_per_token": 5.5e-06,
         "input_cost_per_token_above_272k_tokens": 1.1e-05,
@@ -66548,6 +67188,102 @@
         "output_cost_per_token_above_272k_tokens": 8.25e-05,
         "source": "https://prices.azure.com/api/retail/prices?$filter=serviceName%20eq%20'Foundry%20Models'%20and%20armRegionName%20eq%20'eastus'%20and%20priceType%20eq%20'Consumption'"
     },
+    "azure/eu/gpt-6-luna": {
+        "cache_creation_input_token_cost": 1.5e-07,
+        "cache_creation_input_token_cost_above_272k_tokens": 3e-07,
+        "cache_read_input_token_cost": 1.2e-08,
+        "cache_read_input_token_cost_above_272k_tokens": 2.4e-08,
+        "input_cost_per_token": 1.2e-07,
+        "input_cost_per_token_above_272k_tokens": 2.4e-07,
+        "litellm_provider": "azure",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 6e-07,
+        "output_cost_per_token_above_272k_tokens": 9e-07,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
+    "azure/eu/gpt-6-sol": {
+        "cache_creation_input_token_cost": 3e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 6e-06,
+        "cache_read_input_token_cost": 2.4e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 4.8e-07,
+        "input_cost_per_token": 2.4e-06,
+        "input_cost_per_token_above_272k_tokens": 4.8e-06,
+        "litellm_provider": "azure",
+        "max_input_tokens": 922000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 1.2e-05,
+        "output_cost_per_token_above_272k_tokens": 1.8e-05,
+        "search_context_cost_per_query": {
+            "search_context_size_high": 0.01,
+            "search_context_size_low": 0.01,
+            "search_context_size_medium": 0.01
+        },
+        "source": "https://azure.microsoft.com/en-us/blog/gpt-6-astra-sol-and-luna-for-production-agents-in-microsoft-foundry/",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": false,
+        "supports_native_streaming": true,
+        "supports_none_reasoning_effort": true,
+        "supports_parallel_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true,
+        "supports_xhigh_reasoning_effort": true
+    },
     "azure/eu/o1-mini": {
         "cache_read_input_token_cost": 6.05e-07,
         "input_cost_per_token": 1.21e-06,
@@ -68170,14 +68906,14 @@
         "supports_web_search": true
     },
     "openrouter/~deepseek/deepseek-flash-latest": {
-        "cache_read_input_token_cost": 3.6e-09,
-        "input_cost_per_token": 1.2e-07,
+        "cache_read_input_token_cost": 6e-09,
+        "input_cost_per_token": 3e-07,
         "litellm_provider": "openrouter",
         "max_input_tokens": 1048576,
         "max_output_tokens": 943718,
         "max_tokens": 943718,
         "mode": "chat",
-        "output_cost_per_token": 4.8e-07,
+        "output_cost_per_token": 1.2e-06,
         "source": "https://openrouter.ai/api/v1/models",
         "supports_audio_input": false,
         "supports_function_calling": true,
@@ -68190,14 +68926,15 @@
         "supports_web_search": false
     },
     "openrouter/~deepseek/deepseek-pro-latest": {
-        "cache_read_input_token_cost": 1.2726e-08,
-        "input_cost_per_token": 3.9996e-07,
+        "cache_read_input_token_cost": 4.4e-08,
+        "input_cost_per_token": 1.32e-06,
         "litellm_provider": "openrouter",
         "max_input_tokens": 1048576,
-        "max_output_tokens": 393216,
-        "max_tokens": 393216,
+        "max_output_tokens": 384000,
+        "max_tokens": 384000,
         "mode": "chat",
-        "output_cost_per_token": 1.19988e-06,
+        "off_peak_pricing": {"windows":[{"weekdays":["saturday","sunday"],"hours_utc":"00:00-00:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"00:00-01:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"04:00-06:00"},{"weekdays":["monday","tuesday","wednesday","thursday","friday"],"hours_utc":"10:00-00:00"}],"input_cost_per_token":6.6e-7,"output_cost_per_token":0.00000198,"cache_read_input_token_cost":2.2e-8},
+        "output_cost_per_token": 3.96e-06,
         "source": "https://openrouter.ai/api/v1/models",
         "supports_audio_input": false,
         "supports_function_calling": true,
@@ -68210,14 +68947,14 @@
         "supports_web_search": false
     },
     "openrouter/~deepseek/deepseek-v4-flash-latest": {
-        "cache_read_input_token_cost": 8e-09,
-        "input_cost_per_token": 3e-08,
+        "cache_read_input_token_cost": 1.6e-08,
+        "input_cost_per_token": 4e-08,
         "litellm_provider": "openrouter",
         "max_input_tokens": 1310720,
         "max_output_tokens": 943718,
         "max_tokens": 943718,
         "mode": "chat",
-        "output_cost_per_token": 8e-07,
+        "output_cost_per_token": 6.4e-07,
         "source": "https://openrouter.ai/api/v1/models",
         "supports_audio_input": false,
         "supports_function_calling": true,
@@ -68280,13 +69017,13 @@
     },
     "openrouter/~moonshotai/kimi-latest": {
         "cache_read_input_token_cost": 3e-07,
-        "input_cost_per_token": 1.4989e-06,
+        "input_cost_per_token": 3e-06,
         "litellm_provider": "openrouter",
         "max_input_tokens": 1048576,
         "max_output_tokens": 943718,
         "max_tokens": 943718,
         "mode": "chat",
-        "output_cost_per_token": 1.0758e-05,
+        "output_cost_per_token": 1.5e-05,
         "source": "https://openrouter.ai/api/v1/models",
         "supports_audio_input": false,
         "supports_function_calling": true,
@@ -68442,14 +69179,14 @@
         "supports_web_search": true
     },
     "openrouter/~z-ai/glm-flash-latest": {
-        "cache_read_input_token_cost": 1.5e-08,
-        "input_cost_per_token": 7.5e-08,
+        "cache_read_input_token_cost": 5e-08,
+        "input_cost_per_token": 1.5e-07,
         "litellm_provider": "openrouter",
         "max_input_tokens": 1310720,
         "max_output_tokens": 943718,
         "max_tokens": 943718,
         "mode": "chat",
-        "output_cost_per_token": 2.5e-07,
+        "output_cost_per_token": 5e-07,
         "source": "https://openrouter.ai/api/v1/models",
         "supports_audio_input": false,
         "supports_function_calling": true,
@@ -68485,7 +69222,7 @@
         "cache_read_input_token_cost": 2e-07,
         "input_cost_per_token": 8e-07,
         "litellm_provider": "openrouter",
-        "max_input_tokens": 1048576,
+        "max_input_tokens": 131072,
         "max_output_tokens": 32768,
         "max_tokens": 32768,
         "mode": "chat",
@@ -68505,7 +69242,7 @@
         "cache_read_input_token_cost": 7.5e-07,
         "input_cost_per_token": 3e-06,
         "litellm_provider": "openrouter",
-        "max_input_tokens": 1048576,
+        "max_input_tokens": 131072,
         "max_output_tokens": 32768,
         "max_tokens": 32768,
         "mode": "chat",
@@ -68525,7 +69262,47 @@
         "cache_read_input_token_cost": 1.8e-07,
         "input_cost_per_token": 7e-07,
         "litellm_provider": "openrouter",
-        "max_input_tokens": 1048576,
+        "max_input_tokens": 131072,
+        "max_output_tokens": 32768,
+        "max_tokens": 32768,
+        "mode": "chat",
+        "output_cost_per_token": 1.4e-06,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": false,
+        "supports_web_search": false
+    },
+    "openrouter/aion-labs/aion-3.5": {
+        "cache_read_input_token_cost": 7.5e-07,
+        "input_cost_per_token": 3e-06,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 262144,
+        "max_output_tokens": 32768,
+        "max_tokens": 32768,
+        "mode": "chat",
+        "output_cost_per_token": 6e-06,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": false,
+        "supports_web_search": false
+    },
+    "openrouter/aion-labs/aion-3.5-mini": {
+        "cache_read_input_token_cost": 1.8e-07,
+        "input_cost_per_token": 7e-07,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 262144,
         "max_output_tokens": 32768,
         "max_tokens": 32768,
         "mode": "chat",
@@ -71417,6 +72194,21 @@
         "supports_vision": false,
         "supports_web_search": false
     },
+    "openrouter/stealth/space-bunny-alpha": {
+        "input_cost_per_token": 0,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1000000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 0,
+        "source": "https://openrouter.ai/stealth/space-bunny-alpha",
+        "supports_function_calling": true,
+        "supports_reasoning": true,
+        "supports_tool_choice": true,
+        "supports_video_input": true,
+        "supports_vision": true
+    },
     "openrouter/stepfun/step-3.5-flash": {
         "input_cost_per_token": 1e-07,
         "litellm_provider": "openrouter",
@@ -71790,6 +72582,26 @@
         "supports_vision": false,
         "supports_web_search": false
     },
+    "openrouter/upstage/solar-mini4": {
+        "cache_read_input_token_cost": 5e-09,
+        "input_cost_per_token": 5e-08,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 524288,
+        "max_output_tokens": 131072,
+        "max_tokens": 131072,
+        "mode": "chat",
+        "output_cost_per_token": 2e-07,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": false,
+        "supports_web_search": false
+    },
     "openrouter/writer/palmyra-x5": {
         "input_cost_per_token": 6e-07,
         "litellm_provider": "openrouter",
@@ -72846,6 +73658,207 @@
         "supports_tool_choice": true,
         "supports_vision": true
     },
+    "openrouter/anthropic/claude-opus-5.5:batch": {
+        "cache_creation_input_token_cost": 2.5e-06,
+        "cache_creation_input_token_cost_above_1hr": 4e-06,
+        "cache_read_input_token_cost": 1e-07,
+        "input_cost_per_token": 2e-06,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1000000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 1e-05,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true
+    },
+    "openrouter/cohere/command-a-plus": {
+        "cache_read_input_token_cost": 1.5e-07,
+        "input_cost_per_token": 3e-07,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 192000,
+        "max_output_tokens": 64000,
+        "max_tokens": 64000,
+        "mode": "chat",
+        "output_cost_per_token": 1.5e-06,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": false,
+        "supports_vision": true,
+        "supports_web_search": false
+    },
+    "openrouter/deepseek/deepseek-v4.1-flash:batch": {
+        "cache_read_input_token_cost": 3.36e-09,
+        "input_cost_per_token": 1.12e-07,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1048576,
+        "max_output_tokens": 131072,
+        "max_tokens": 131072,
+        "mode": "chat",
+        "output_cost_per_token": 3.36e-07,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": false
+    },
+    "openrouter/openai/gpt-6-luna-pro:batch": {
+        "cache_creation_input_token_cost": 6.25e-08,
+        "cache_creation_input_token_cost_above_272k_tokens": 1.25e-07,
+        "cache_read_input_token_cost": 5e-09,
+        "cache_read_input_token_cost_above_272k_tokens": 1e-08,
+        "input_cost_per_token": 5e-08,
+        "input_cost_per_token_above_272k_tokens": 1e-07,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 2.5e-07,
+        "output_cost_per_token_above_272k_tokens": 3.75e-07,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true
+    },
+    "openrouter/openai/gpt-6-luna:batch": {
+        "cache_creation_input_token_cost": 6.25e-08,
+        "cache_creation_input_token_cost_above_272k_tokens": 1.25e-07,
+        "cache_read_input_token_cost": 5e-09,
+        "cache_read_input_token_cost_above_272k_tokens": 1e-08,
+        "input_cost_per_token": 5e-08,
+        "input_cost_per_token_above_272k_tokens": 1e-07,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 2.5e-07,
+        "output_cost_per_token_above_272k_tokens": 3.75e-07,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true
+    },
+    "openrouter/openai/gpt-6-sol-pro:batch": {
+        "cache_creation_input_token_cost": 1.25e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.5e-06,
+        "cache_read_input_token_cost": 1e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 2e-07,
+        "input_cost_per_token": 1e-06,
+        "input_cost_per_token_above_272k_tokens": 2e-06,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 5e-06,
+        "output_cost_per_token_above_272k_tokens": 7.5e-06,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true
+    },
+    "openrouter/openai/gpt-6-sol:batch": {
+        "cache_creation_input_token_cost": 1.25e-06,
+        "cache_creation_input_token_cost_above_272k_tokens": 2.5e-06,
+        "cache_read_input_token_cost": 1e-07,
+        "cache_read_input_token_cost_above_272k_tokens": 2e-07,
+        "input_cost_per_token": 1e-06,
+        "input_cost_per_token_above_272k_tokens": 2e-06,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1050000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 5e-06,
+        "output_cost_per_token_above_272k_tokens": 7.5e-06,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": true
+    },
+    "openrouter/openai/gpt-oss-20b:batch": {
+        "input_cost_per_token": 2.4e-08,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 131072,
+        "max_output_tokens": 117964,
+        "max_tokens": 117964,
+        "mode": "chat",
+        "output_cost_per_token": 1.12e-07,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": false,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": false,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": false,
+        "supports_web_search": false
+    },
+    "openrouter/qwen/qwen3.8-omni-flash": {
+        "cache_read_input_token_cost": 1.6e-08,
+        "input_cost_per_token": 1.5e-07,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1000000,
+        "max_output_tokens": 131072,
+        "max_tokens": 131072,
+        "mode": "chat",
+        "output_cost_per_token": 4.7e-07,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": true,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": false
+    },
     "vertex_ai/gemini-2.0-flash": {
         "input_cost_per_audio_token": 1e-06,
         "input_cost_per_audio_token_batches": 5e-07,
diff --git a/scripts/comment-fixed-issue.test.ts b/scripts/comment-fixed-issue.test.ts
index fef5c0f40074..f4242204938a 100644
--- a/scripts/comment-fixed-issue.test.ts
+++ b/scripts/comment-fixed-issue.test.ts
@@ -263,7 +263,7 @@ describe("fixedBody", () => {
 describe("fixOf", () => {
   test("a merged pull request or a commit is a fix, whatever branch it was merged into", () => {
     expect(fixOf(closure(mergedPr), "BerriAI/litellm")).toEqual({ kind: "pull_request", number: 41767, oid: MERGE_COMMIT });
-    expect(fixOf(closure({ ...mergedPr, baseRefName: "litellm_internal_staging" }), "BerriAI/litellm")).toEqual({ kind: "pull_request", number: 41767, oid: MERGE_COMMIT });
+    expect(fixOf(closure({ ...mergedPr, baseRefName: "release_branch" }), "BerriAI/litellm")).toEqual({ kind: "pull_request", number: 41767, oid: MERGE_COMMIT });
     expect(fixOf(closure(commitCloser), "BerriAI/litellm")).toEqual({ kind: "commit", oid: MERGE_COMMIT });
   });
 
@@ -315,7 +315,7 @@ describe("closeVerdict", () => {
     for (const base of ["release/v1.102.0-rc.2", "stable/v1.83.14", "v_1_83_3_stable_patch"]) {
       expect(closeVerdict(openPr(41760, { baseRefName: base }), config)).toEqual({ kind: "skip", reason: `targets the release line ${base}` });
     }
-    expect(closeVerdict(openPr(41760, { baseRefName: "litellm_internal_staging" }), config).kind).toBe("candidate");
+    expect(closeVerdict(openPr(41760, { baseRefName: "release_branch" }), config).kind).toBe("candidate");
   });
 
   test("a pull request in a fork, one that is not open, or one linking no issue is left alone", () => {
@@ -404,8 +404,8 @@ describe("handleFixedIssue", () => {
   });
 
   test("a fix merged into the retired development branch or pushed as a commit counts once it is on the default branch", async () => {
-    const stagingPr = { ...mergedPr, baseRefName: "litellm_internal_staging" };
-    const staging = openPr(41760, { baseRefName: "litellm_internal_staging", closingIssuesReferences: links(linkedIssue(ISSUE, stagingPr)) });
+    const stagingPr = { ...mergedPr, baseRefName: "release_branch" };
+    const staging = openPr(41760, { baseRefName: "release_branch", closingIssuesReferences: links(linkedIssue(ISSUE, stagingPr)) });
     const byCommit = openPr(41761, { closingIssuesReferences: links(linkedIssue(41751, commitCloser)) });
     const { api, writes } = fakeApi({ issue: closedBy(mergedPr, "CLOSED", [staging, byCommit]) });
     const { pullRequests } = await handleFixedIssue(api, config, ISSUE, noPause);
@@ -426,15 +426,15 @@ describe("handleFixedIssue", () => {
   });
 
   test("the default branch comes from the config for the containment check and the comment alike", async () => {
-    const stagingConfig = { ...config, defaultBranch: "litellm_internal_staging" };
-    const closer = { ...mergedPr, baseRefName: "litellm_internal_staging" };
+    const stagingConfig = { ...config, defaultBranch: "release_branch" };
+    const closer = { ...mergedPr, baseRefName: "release_branch" };
     const { api, writes } = fakeApi({
       issue: closedBy(closer, "CLOSED", [openPr(41760, { closingIssuesReferences: links(linkedIssue(ISSUE, closer)) })]),
-      reachable: { litellm_internal_staging: [MERGE_COMMIT] },
+      reachable: { release_branch: [MERGE_COMMIT] },
     });
     const { pullRequests } = await handleFixedIssue(api, stagingConfig, ISSUE, noPause);
-    expect(pullRequests).toEqual([{ kind: "closed", number: 41760, body: supersededBody([prFix()], "litellm_internal_staging") }]);
-    expect(writes[1]).toContain("on litellm_internal_staging, so this pull request is closed");
+    expect(pullRequests).toEqual([{ kind: "closed", number: 41760, body: supersededBody([prFix()], "release_branch") }]);
+    expect(writes[1]).toContain("on release_branch, so this pull request is closed");
   });
 
   test("the closer sits in the linked list as merged and gets neither a line nor a write", async () => {
@@ -533,11 +533,11 @@ describe("handleFixedIssue", () => {
   });
 
   test("an issue closed from the retired development branch gets no comment but still closes its linked pull requests once the fix is on the default branch", async () => {
-    const stagingPr = { ...mergedPr, baseRefName: "litellm_internal_staging" };
+    const stagingPr = { ...mergedPr, baseRefName: "release_branch" };
     const staging = openPr(41760, { closingIssuesReferences: links(linkedIssue(ISSUE, stagingPr)) });
     const { api, writes } = fakeApi({ issue: closedBy(stagingPr, "CLOSED", [staging]) });
     const { comment, pullRequests } = await handleFixedIssue(api, config, ISSUE, noPause);
-    expect(comment).toEqual({ kind: "skip", reason: "#41767 merged into litellm_internal_staging, not main" });
+    expect(comment).toEqual({ kind: "skip", reason: "#41767 merged into release_branch, not main" });
     expect(pullRequests).toEqual([{ kind: "closed", number: 41760, body: oneFixBody }]);
     expect(writes.map((write) => write.split(" ")[1])).toEqual(["/repos/BerriAI/litellm/issues/41760/comments", "/repos/BerriAI/litellm/pulls/41760"]);
   });
diff --git a/scripts/type_check_gate.py b/scripts/type_check_gate.py
index 78f74ec65a11..023b35af8fed 100644
--- a/scripts/type_check_gate.py
+++ b/scripts/type_check_gate.py
@@ -35,7 +35,7 @@
 resolution matches, and its per-rule counts are cached under the repo's git
 common dir keyed by merge-base commit, ``pyrightconfig.json``, ``uv.lock``,
 the Prisma schema, and the dependency-group set, so re-runs against the same
-branch point pay for it once. A CI workflow publishes every staging commit's counts as
+branch point pay for it once. A CI workflow publishes every main commit's counts as
 an artifact (``--emit-counts-dir`` is its entry point), and on a disk-cache miss
 the gate first tries to download the merge-base's artifact through the ``gh``
 CLI; any fetch failure falls back silently to the local base pass, so the gate
diff --git a/tests/_support/__init__.py b/tests/_support/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/tests/_support/stream_chunk_size.py b/tests/_support/stream_chunk_size.py
new file mode 100644
index 000000000000..051f552e2821
--- /dev/null
+++ b/tests/_support/stream_chunk_size.py
@@ -0,0 +1,31 @@
+from collections.abc import Mapping
+from typing import Final
+
+import litellm
+import pytest
+from litellm.integrations.custom_logger import CustomLogger
+
+
+class LitellmParamsRecorder(CustomLogger):
+    def __init__(self) -> None:
+        super().__init__()
+        self.seen: tuple[Mapping[str, object], ...] = ()
+
+    def log_pre_api_call(self, model: str, messages: object, kwargs: Mapping[str, object]) -> None:
+        params: Final = kwargs["litellm_params"]
+        assert isinstance(params, Mapping)
+        self.seen = (*self.seen, params)
+
+
+def record_litellm_params(monkeypatch: pytest.MonkeyPatch) -> LitellmParamsRecorder:
+    recorder: Final = LitellmParamsRecorder()
+    monkeypatch.setattr(litellm, "input_callback", [recorder])
+    return recorder
+
+
+def keys_at_every_depth(value: object) -> frozenset[str]:
+    if isinstance(value, Mapping):
+        return frozenset(value) | frozenset().union(*(keys_at_every_depth(item) for item in value.values()))
+    if isinstance(value, (list, tuple)):
+        return frozenset().union(*(keys_at_every_depth(item) for item in value))
+    return frozenset()
diff --git a/tests/e2e/ui/tests/integrationCritical/expected.json b/tests/e2e/ui/tests/integrationCritical/expected.json
new file mode 100644
index 000000000000..1ce8e539975b
--- /dev/null
+++ b/tests/e2e/ui/tests/integrationCritical/expected.json
@@ -0,0 +1,3 @@
+[
+  "tests/e2e/ui/tests/integrationCritical/projectDetachment.spec.ts::project creation and explicit detachment preserve saved scope and restore serving"
+]
diff --git a/tests/integration/AGENTS.md b/tests/integration/AGENTS.md
index 57b69f3830d6..0499bfc97c83 100644
--- a/tests/integration/AGENTS.md
+++ b/tests/integration/AGENTS.md
@@ -21,5 +21,7 @@ function in a full stack is not
 
 ## Where it goes
 
-By the domain a user would name: `pricing`, `spend`, `routing`. Add the node and its `covers` ids to
-`contracts.json` or collection fails. Needs no proxy, DB or Redis: `tests/unit`
+By the domain a user would name: `pricing`, `spend`, `routing`, `mcp`. A file only needs to live in a
+directory that a `GROUPS` entry in `run.py` selects; there is no manifest and no `covers` marker on new
+tests. A product bug the test exposes is `pytest.skip("BUG: <symptom>")` at the top of the body, not a
+fix in the test and not a deletion. Needs no proxy, DB or Redis: `tests/unit`
diff --git a/tests/integration/README.md b/tests/integration/README.md
index 628b6721514e..f7c1305ad2e8 100644
--- a/tests/integration/README.md
+++ b/tests/integration/README.md
@@ -2,9 +2,9 @@
 
 These tests exercise a running gateway, PostgreSQL and Redis with an owned local upstream. CircleCI owns this suite. Tests are grouped by behavior, with no automatic test retries or fallback to paid provider calls
 
-The `cost` group is driven by `cost_tracking_cases.json`, which contains the cost map, literal requests, literal provider responses and expected accounting values. Each case has a name, contract ID, cost-map model, optional deployment overrides, request body, tagged response and exact or recount expectations. Request bodies use `$MODEL` for the registered proxy model, while responses use `$REQUEST_ID` for the per-run scenario ID. To add a case, add a cost-map entry when the model is new, add the request body and exact provider response data, add hand-computed expected values and register the node ID in `contracts.json`. The upstream serves each stored response for any path under `/<scenario_id>`, while the test-owned cost map is served over loopback through `LITELLM_MODEL_COST_MAP_URL`
+The `cost` group is driven by `cost_tracking_cases.json`, which contains the cost map, literal requests, literal provider responses and expected accounting values. Each case has a name, contract ID, cost-map model, optional deployment overrides, request body, tagged response and exact or recount expectations. Request bodies use `$MODEL` for the registered proxy model, while responses use `$REQUEST_ID` for the per-run scenario ID. To add a case, add a cost-map entry when the model is new, add the request body and exact provider response data, and add hand-computed expected values. The upstream serves each stored response for any path under `/<scenario_id>`, while the test-owned cost map is served over loopback through `LITELLM_MODEL_COST_MAP_URL`
 
-Use `tests/integration/run.py management`, `accounting`, `database`, `providers`, `extensions`, `sdk` or `cost` to run a selected group. Set `INTEGRATION_PROXY_URL`, `INTEGRATION_UPSTREAM_URL`, `INTEGRATION_MASTER_KEY` and `DATABASE_URL` to an isolated test deployment. The runner selects the new domain directories explicitly; the legacy OCI and sandbox selections remain separate
+Use `tests/integration/run.py management`, `accounting`, `database`, `providers`, `extensions`, `mcp`, `sdk` or `cost` to run a selected group. The group to directory mapping is the `GROUPS` literal at the top of `run.py`; a new directory needs a `GROUPS` entry and an `OWNED_DIRECTORIES` entry in `_support/manifest.py`. Set `INTEGRATION_WORKERS` above 1 to run a group under pytest-xdist; the `mcp` job does this in CI, so MCP tests must own their resources per scenario. Set `INTEGRATION_PROXY_URL`, `INTEGRATION_UPSTREAM_URL`, `INTEGRATION_MASTER_KEY` and `DATABASE_URL` to an isolated test deployment. The runner selects the new domain directories explicitly; the legacy OCI and sandbox selections remain separate
 
 Management also requires `INTEGRATION_PEER_URL`, `REDIS_HOST` and `REDIS_PORT`. CircleCI starts two directly addressed proxy processes sharing only that job's stores. The test-only CLI wrapper supplies enterprise route entitlement, following the existing behavior suite's convention. It does not qualify license validation; run it with one worker and no reload
 
@@ -14,7 +14,7 @@ Reuse the existing canned provider handlers through `_support/upstream.py`. It r
 
 The CircleCI workflow starts its own database and Redis, restricts test-phase egress to its owned services and writes JUnit plus an executed-node manifest. Missing setup, failed cleanup or a selected test with neither a passed call nor a skip fail qualification. Skipped nodes are listed under `skipped` in `execution.json`, so the skip reasons double as the open bug list. Existing GitHub Actions jobs do not own these tests
 
-Define integration contract IDs and their canonical test nodes in `contracts.json`. Every node must declare the same IDs with `covers`. The runner checks exact collected and passed-or-skipped selections against that mapping. These IDs belong to this CircleCI suite and must not be added to the separate E2E coverage registry. A manifest declaration alone does not mean a test passed
+There is no per-node manifest. The runner fails only when pytest fails, when collection errors, or when a selected file collects zero tests. Older tests still carry `@pytest.mark.covers(...)` decorators; the marker stays registered so they collect, but the IDs are not checked against anything and new tests should not use it. The GitHub Actions coverage census reads the `GROUPS` literal in `run.py` and treats every `tests/integration/<directory>/test_*.py` file in a scheduled group as owned by CircleCI
 
 Provider sentinels currently use the controlled server, not live recordings. The provider shard also runs the existing strict replay controls for changed requests, exhausted interactions, leftover interactions and no provider connection. Future recorded scenarios must use that replay-only implementation; missing recordings cannot fall back to a real provider. The observation endpoint is destructive and the current selection runs serially against one owned upstream
 
@@ -30,6 +30,8 @@ Streaming checks send real HTTP transfer chunks, including one-byte partitions,
 
 The sdk shard exercises the SDK's own HTTP clients against local protocol peers with no gateway in the path, so a case here fails only when the client library or its wire behavior changes. The HTTP/2 case runs a hypercorn TLS peer offering h2 and http/1.1 over ALPN, drives the sync and async httpx handlers at it with `LITELLM_HTTP2` off and on, and asserts the version both the client and the peer observed on the wire. Put a test here only when it needs no proxy, database or Redis; a case that reaches the gateway belongs in one of the other shards
 
-The extensions shard reuses the existing MCP arithmetic functions with a real SDK server, and uses the built-in generic callback and guardrail transports. It checks actual tool calls after saved edits, discovery preservation, malformed/error responses, callback correlation and credential exclusion, guardrail rewriting and denial, retained OpenAI consumers, persisted toolsets and A2A wire versions
+The extensions shard uses the built-in generic callback and guardrail transports. It checks callback correlation and credential exclusion, guardrail rewriting and denial, retained OpenAI consumers and A2A wire versions
 
-Browser contracts live in `tests/e2e/ui/tests/integrationCritical` and run only through `tests/e2e/ui/integration.config.ts`. The CircleCI browser shard builds the checked-out dashboard, starts the owned proxy with that build, and verifies one exact browser result without retries or skips. The default Playwright selection excludes this directory. The focused project flow asserts the submitted create and clear values, fresh SQL state and actual blocked/restored serving while preserving model restrictions
+The mcp shard runs the MCP gateway against SDK peers owned by each test (`_support/mcp.py`): streamable HTTP, SSE and stdio peers, an OpenAPI-spec app, and an OAuth 2.1 authorization-server double. Every peer records the requests it receives so a test can assert what reached the peer, not only what the proxy answered. The shard runs with `INTEGRATION_WORKERS` set and with `INTEGRATION_COVERAGE=1`, which starts the proxy under `coverage run --parallel-mode` limited to the MCP modules and stores `coverage.txt` plus an HTML report with the job artifacts. A test that fails because the product is wrong is skipped with `pytest.skip("BUG: <symptom>")` so the skip list in `execution.json` is the open MCP bug list
+
+Browser contracts live in `tests/e2e/ui/tests/integrationCritical` and run only through `tests/e2e/ui/integration.config.ts`. The expected browser results are listed in `expected.json` in that directory and checked by `.circleci/scripts/verify_integration_browser.py`. The CircleCI browser shard builds the checked-out dashboard, starts the owned proxy with that build, and verifies one exact browser result without retries or skips. The default Playwright selection excludes this directory. The focused project flow asserts the submitted create and clear values, fresh SQL state and actual blocked/restored serving while preserving model restrictions
diff --git a/tests/integration/_support/asgi.py b/tests/integration/_support/asgi.py
index 92bcbfe42ea7..eff01a6ab13b 100644
--- a/tests/integration/_support/asgi.py
+++ b/tests/integration/_support/asgi.py
@@ -4,8 +4,8 @@
 import socket
 import threading
 import time
+from collections.abc import Callable, Iterator
 from concurrent.futures import Future
-from collections.abc import Iterator
 from contextlib import contextmanager
 from typing import Final
 
@@ -14,7 +14,7 @@
 
 
 @contextmanager
-def asgi_server(app: ASGIApp) -> Iterator[str]:
+def asgi_server(app: ASGIApp, *, before_stop: Callable[[], None] | None = None) -> Iterator[str]:
     with socket.socket() as listener:
         listener.bind(("127.0.0.1", 0))
         port: Final = listener.getsockname()[1]
@@ -47,7 +47,7 @@ def serve() -> None:
         class Capture(logging.Handler):
             def emit(self, record: logging.LogRecord) -> None:
                 if record.thread == worker.ident and record.levelno >= logging.ERROR:
-                    errors.put(record.getMessage())
+                    errors.put(self.format(record))
 
         handler: Final = Capture()
         logger: Final = logging.getLogger("uvicorn.error")
@@ -60,6 +60,8 @@ def emit(self, record: logging.LogRecord) -> None:
                 time.sleep(0.01)
             yield f"http://127.0.0.1:{port}"
         finally:
+            if before_stop is not None:
+                before_stop()
             server.should_exit = True
             worker.join(timeout=8)
             forced: Final = worker.is_alive()
diff --git a/tests/integration/_support/database.py b/tests/integration/_support/database.py
index 283d26a632ea..e7f0ebdf6032 100644
--- a/tests/integration/_support/database.py
+++ b/tests/integration/_support/database.py
@@ -8,7 +8,9 @@
 ROWS: Final = TypeAdapter(list[dict[str, JsonValue]])
 
 
-def read_rows(query: str, parameters: tuple[str, ...]) -> list[dict[str, JsonValue]]:
-    with psycopg.connect(os.environ["DATABASE_URL"], row_factory=dict_row) as connection:
+def read_rows(
+    query: str, parameters: tuple[str, ...], *, database_url: str | None = None
+) -> list[dict[str, JsonValue]]:
+    with psycopg.connect(database_url or os.environ["DATABASE_URL"], row_factory=dict_row) as connection:
         connection.execute("SET TRANSACTION READ ONLY")
         return ROWS.validate_python(connection.execute(query, parameters).fetchall())
diff --git a/tests/integration/_support/database_relay.py b/tests/integration/_support/database_relay.py
new file mode 100644
index 000000000000..46f3e17af13b
--- /dev/null
+++ b/tests/integration/_support/database_relay.py
@@ -0,0 +1,95 @@
+import asyncio
+import socket
+import threading
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import Final
+from urllib.parse import urlsplit, urlunsplit
+
+from pydantic import TypeAdapter
+
+PORT: Final = TypeAdapter(int)
+
+
+def _free_port() -> int:
+    with socket.socket() as reserve:
+        reserve.bind(("127.0.0.1", 0))
+        return PORT.validate_python(reserve.getsockname()[1])
+
+
+class DatabaseRelay:
+    def __init__(self, upstream_host: str, upstream_port: int, trigger: bytes) -> None:
+        self.port: Final = _free_port()
+        self._upstream_host: Final = upstream_host
+        self._upstream_port: Final = upstream_port
+        self._trigger: Final = trigger
+        self._loop: Final = asyncio.new_event_loop()
+        self._armed: Final = threading.Event()
+        self.tripped: Final = threading.Event()
+        self.refused = 0
+        self._writers: tuple[asyncio.StreamWriter, ...] = ()
+        self._ready: Final = threading.Event()
+        self._thread: Final = threading.Thread(target=self._run, daemon=True)
+
+    def arm(self) -> None:
+        self._armed.set()
+
+    def start(self) -> None:
+        self._thread.start()
+        assert self._ready.wait(10), "Database relay did not start"
+
+    def stop(self) -> None:
+        self._loop.call_soon_threadsafe(self._loop.stop)
+        self._thread.join(10)
+
+    def _run(self) -> None:
+        asyncio.set_event_loop(self._loop)
+        self._loop.run_until_complete(asyncio.start_server(self._serve, "127.0.0.1", self.port))
+        self._ready.set()
+        self._loop.run_forever()
+
+    def _drop_all(self) -> None:
+        for writer in self._writers:
+            writer.close()
+        self._writers = ()
+
+    async def _serve(self, client_reader: asyncio.StreamReader, client_writer: asyncio.StreamWriter) -> None:
+        if self.tripped.is_set() and self.refused < 5:
+            self.refused += 1
+            client_writer.close()
+            return
+        server_reader, server_writer = await asyncio.open_connection(self._upstream_host, self._upstream_port)
+        self._writers = (*self._writers, client_writer, server_writer)
+
+        async def forward(reader: asyncio.StreamReader, writer: asyncio.StreamWriter, inspect: bool) -> None:
+            try:
+                while chunk := await reader.read(65536):
+                    if inspect and self._armed.is_set() and not self.tripped.is_set() and self._trigger in chunk:
+                        self.tripped.set()
+                        self._drop_all()
+                        return
+                    writer.write(chunk)
+                    await writer.drain()
+            except (ConnectionError, asyncio.IncompleteReadError):
+                return
+            finally:
+                writer.close()
+
+        await asyncio.gather(
+            forward(client_reader, server_writer, True),
+            forward(server_reader, client_writer, False),
+        )
+
+
+@contextmanager
+def database_relay(database_url: str, trigger: bytes) -> Generator[tuple[DatabaseRelay, str]]:
+    parts: Final = urlsplit(database_url)
+    assert parts.hostname is not None and parts.port is not None, database_url
+    relay: Final = DatabaseRelay(parts.hostname, parts.port, trigger)
+    relay.start()
+    credentials: Final = f"{parts.username}:{parts.password}@" if parts.username else ""
+    relayed: Final = urlunsplit(parts._replace(netloc=f"{credentials}127.0.0.1:{relay.port}"))
+    try:
+        yield relay, relayed
+    finally:
+        relay.stop()
diff --git a/tests/integration/_support/manifest.py b/tests/integration/_support/manifest.py
index 0117a0df5918..aa0b27ecedaa 100644
--- a/tests/integration/_support/manifest.py
+++ b/tests/integration/_support/manifest.py
@@ -1,10 +1,5 @@
-import json
-from pathlib import Path
 from typing import Final
 
-from pydantic import TypeAdapter
-
-MAPPING: Final = TypeAdapter(dict[str, tuple[str, ...]])
 OWNED_DIRECTORIES: Final = frozenset(
     {
         "management",
@@ -23,11 +18,3 @@
         "cost_calculation",
     }
 )
-
-
-def contracts() -> dict[str, tuple[str, ...]]:
-    document: Final = json.loads((Path(__file__).resolve().parents[1] / "contracts.json").read_bytes())
-    result: Final = MAPPING.validate_python(document["tests"])
-    if not result or any(not values or any(not value.strip() for value in values) for values in result.values()):
-        raise ValueError("Integration manifest must contain nodes with contract IDs")
-    return result
diff --git a/tests/integration/_support/mcp.py b/tests/integration/_support/mcp.py
index bdf60becbaa6..a3693433de4c 100644
--- a/tests/integration/_support/mcp.py
+++ b/tests/integration/_support/mcp.py
@@ -1,33 +1,70 @@
+import asyncio
 import json
+import os
 import queue
-from collections.abc import Iterator
+import sys
+import time
+from collections.abc import Callable, Iterator, Mapping
 from contextlib import contextmanager
-from dataclasses import dataclass
-from typing import Final
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Final, Literal
 
 import httpx
 from integration._support.asgi import asgi_server
 from integration._support.client import Gateway, Scenario
 from integration._support.database import read_rows
-from mcp.server.mcpserver import MCPServer
+from integration._support.wire import Reply, Request, wire_server
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+from mcp.client.streamable_http import streamable_http_client
+from mcp.server.mcpserver import Context, MCPServer
 from mcp.server.transport_security import TransportSecuritySettings
+from mcp.types import SamplingMessage, TextContent
 from mcp_tests.mcp_e2e_upstream_server import add, multiply
-from starlette.requests import Request
+from pydantic import BaseModel
+from sse_starlette.sse import AppStatus
+from starlette.requests import Request as StarletteRequest
+from starlette.responses import Response
 from starlette.types import Message, Receive, Scope, Send
 
+Transport = Literal["http", "sse", "stdio"]
+STDIO_PEER: Final = Path(__file__).with_name("mcp_stdio_peer.py")
+
 
 @dataclass(frozen=True, slots=True)
 class McpPeer:
     url: str
     calls: queue.Queue[dict[str, object]]
+    transport: Transport = "http"
+    command: str | None = None
+    args: tuple[str, ...] = ()
+    record: Path | None = None
+    spec_path: Path | None = None
+    consumed: list[int] = field(default_factory=lambda: [0])
 
     def drain(self) -> tuple[dict[str, object], ...]:
+        if self.record is not None:
+            lines: Final = self.record.read_text().splitlines() if self.record.exists() else []
+            fresh: Final = tuple(json.loads(line) for line in lines[self.consumed[0] :])
+            self.consumed[0] = len(lines)
+            return fresh
         return tuple(self.calls.get_nowait() for _ in range(self.calls.qsize()))
 
+    def registration(self) -> dict[str, object]:
+        if self.transport == "stdio":
+            return {"transport": "stdio", "command": self.command, "args": list(self.args)}
+        if self.spec_path is not None:
+            return {"transport": "http", "url": self.url, "spec_path": str(self.spec_path)}
+        return {"transport": self.transport, "url": self.url}
 
-@contextmanager
-def mcp_peer() -> Iterator[McpPeer]:
-    service: Final = MCPServer("integration-math")
+
+class Confirmation(BaseModel):
+    confirmed: bool
+
+
+def math_service(name: str = "integration-math", *, rich: bool = False) -> MCPServer:
+    service: Final = MCPServer(name)
     service.add_tool(add)
     service.add_tool(multiply)
 
@@ -35,22 +72,61 @@ def mcp_peer() -> Iterator[McpPeer]:
     def fail() -> str:
         raise ValueError("synthetic tool failure")
 
-    app: Final = service.streamable_http_app(
-        stateless_http=True,
-        json_response=True,
-        transport_security=TransportSecuritySettings(enable_dns_rebinding_protection=False),
-    )
-    observed: Final[queue.Queue[dict[str, object]]] = queue.Queue()
+    if not rich:
+        return service
+
+    @service.tool()
+    async def slow(seconds: float) -> str:
+        await asyncio.sleep(seconds)
+        return "slept"
+
+    @service.tool()
+    async def progress(steps: int, ctx: Context) -> str:
+        for step in range(steps):
+            await ctx.report_progress(step + 1, steps, f"step {step + 1}")
+        return f"{steps} steps"
+
+    @service.tool()
+    async def sample(prompt: str, ctx: Context) -> str:
+        result: Final = await ctx.session.create_message(
+            messages=[SamplingMessage(role="user", content=TextContent(type="text", text=prompt))],
+            max_tokens=32,
+        )
+        return "sampled:" + (result.content.text if isinstance(result.content, TextContent) else "")
+
+    @service.tool()
+    async def elicit(question: str, ctx: Context) -> str:
+        result: Final = await ctx.elicit(message=question, schema=Confirmation)
+        return f"elicited:{result.action}"
+
+    @service.prompt()
+    def greeting(name: str) -> str:
+        return f"Hello, {name}"
 
+    @service.resource("status://ready")
+    def status() -> str:
+        return "ready"
+
+    @service.resource("greeting://{name}")
+    def greeting_resource(name: str) -> str:
+        return f"Hello, {name}"
+
+    return service
+
+
+def _capturing(app: Callable[[Scope, Receive, Send], object], observed: queue.Queue[dict[str, object]]):
     async def capture(scope: Scope, receive: Receive, send: Send) -> None:
         if scope["type"] != "http":
             await app(scope, receive, send)
             return
-        body: Final = await Request(scope, receive).body()
+        if scope["method"] == "GET" and scope["path"].endswith("/mcp"):
+            await Response(status_code=405, headers={"Allow": "POST, DELETE"})(scope, receive, send)
+            return
+        body: Final = await StarletteRequest(scope, receive).body()
         assert len(body) <= 65536
         if body:
-            observed.put({"body": json.loads(body), "headers": dict(scope["headers"])})
-        message: Final[Message] = {"type": "http.request", "body": body, "more_body": False}
+            observed.put({"body": json.loads(body), "headers": dict(scope["headers"]), "path": scope["path"]})
+        message: Final = {"type": "http.request", "body": body, "more_body": False}
         pending: Final = iter((message,))
 
         async def replay() -> Message:
@@ -61,35 +137,285 @@ async def replay() -> Message:
 
         await app(scope, replay, send)
 
-    with asgi_server(capture) as url:
-        yield McpPeer(url + "/mcp", observed)
+    return capture
+
+
+def _drain_sse_streams() -> None:
+    AppStatus.should_exit = True
+
+
+def _draining_sse_watcher(app: Callable[[Scope, Receive, Send], object]):
+    """sse_starlette parks a per-loop watcher that only stops once AppStatus.should_exit flips."""
+
+    async def lifespan(scope: Scope, receive: Receive, send: Send) -> None:
+        while True:
+            message: Final = await receive()
+            if message["type"] == "lifespan.startup":
+                AppStatus.should_exit = False
+                await send({"type": "lifespan.startup.complete"})
+            elif message["type"] == "lifespan.shutdown":
+                _drain_sse_streams()
+                watchers: Final = tuple(
+                    task for task in asyncio.all_tasks() if "_shutdown_watcher" in repr(task.get_coro())
+                )
+                await asyncio.gather(*watchers)
+                await send({"type": "lifespan.shutdown.complete"})
+                return
+
+    async def wrapped(scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] == "lifespan":
+            await lifespan(scope, receive, send)
+            return
+        starts: Final = [0]
+
+        async def send_once(message: Message) -> None:
+            if message["type"] == "http.response.start":
+                starts[0] += 1
+                if starts[0] == 2:
+                    await send({"type": "http.response.body", "body": b"", "more_body": False})
+            if starts[0] > 1:
+                return
+            await send(message)
+
+        await app(scope, receive, send_once)
+
+    return wrapped
+
+
+@contextmanager
+def mcp_peer(transport: Literal["http", "sse"] = "http", *, rich: bool = False) -> Iterator[McpPeer]:
+    service: Final = math_service(rich=rich)
+    security: Final = TransportSecuritySettings(enable_dns_rebinding_protection=False)
+    app: Final = (
+        _draining_sse_watcher(service.sse_app(transport_security=security))
+        if transport == "sse"
+        else service.streamable_http_app(stateless_http=True, json_response=True, transport_security=security)
+    )
+    observed: Final[queue.Queue[dict[str, object]]] = queue.Queue()
+    with asgi_server(_capturing(app, observed), before_stop=_drain_sse_streams if transport == "sse" else None) as url:
+        yield McpPeer(url + ("/sse" if transport == "sse" else "/mcp"), observed, transport)
+
+
+@contextmanager
+def stdio_peer(directory: Path, *, rich: bool = False) -> Iterator[McpPeer]:
+    record: Final = directory / f"stdio-{os.getpid()}-{time.monotonic_ns()}.jsonl"
+    yield McpPeer(
+        "",
+        queue.Queue(),
+        "stdio",
+        sys.executable,
+        (str(STDIO_PEER), str(record), "rich" if rich else "plain"),
+        record,
+    )
+
+
+JsonRpc = Mapping[str, object]
+
+
+@dataclass(frozen=True, slots=True)
+class ScriptedTool:
+    name: str
+    respond: Callable[[JsonRpc], Reply | JsonRpc]
+
+
+def jsonrpc_reply(identity: object, result: JsonRpc) -> Reply:
+    return Reply(body=json.dumps({"jsonrpc": "2.0", "id": identity, "result": result}).encode())
+
+
+def jsonrpc_error(identity: object, code: int, message: str) -> Reply:
+    return Reply(
+        body=json.dumps({"jsonrpc": "2.0", "id": identity, "error": {"code": code, "message": message}}).encode()
+    )
+
+
+@contextmanager
+def scripted_peer(*tools: ScriptedTool) -> Iterator[McpPeer]:
+    """Raw JSON-RPC peer for shapes the SDK server cannot produce: half-written bodies, stalls, wire errors."""
+    observed: Final[queue.Queue[dict[str, object]]] = queue.Queue()
+    by_name: Final = {tool.name: tool for tool in tools}
+
+    def provider(request: Request) -> Reply:
+        if request.method != "POST":
+            return Reply(status=405)
+        body: Final = json.loads(request.body)
+        observed.put({"body": body, "headers": dict(request.headers), "path": request.target})
+        if "id" not in body:
+            return Reply(status=202)
+        identity: Final = body["id"]
+        method: Final = body["method"]
+        if method == "initialize":
+            return jsonrpc_reply(
+                identity,
+                {
+                    "protocolVersion": body["params"]["protocolVersion"],
+                    "capabilities": {"tools": {}},
+                    "serverInfo": {"name": "integration-scripted-peer", "version": "1"},
+                },
+            )
+        if method == "tools/list":
+            return jsonrpc_reply(
+                identity, {"tools": [{"name": name, "inputSchema": {"type": "object"}} for name in by_name]}
+            )
+        if method != "tools/call":
+            return jsonrpc_error(identity, -32601, f"unsupported method {method}")
+        tool: Final = by_name.get(body["params"]["name"])
+        if tool is None:
+            return jsonrpc_error(identity, -32602, "unknown tool")
+        produced: Final = tool.respond(body["params"])
+        return produced if isinstance(produced, Reply) else jsonrpc_reply(identity, produced)
+
+    with wire_server(provider) as wire:
+        yield McpPeer(wire.url + "/mcp", observed)
+
+
+def text_result(text: str) -> JsonRpc:
+    return {"content": [{"type": "text", "text": text}], "isError": False}
+
+
+def slow_tool(name: str, seconds: float) -> ScriptedTool:
+    def respond(params: JsonRpc) -> JsonRpc:
+        time.sleep(seconds)
+        return text_result("slept")
+
+    return ScriptedTool(name, respond)
+
+
+def disconnecting_tool(name: str) -> ScriptedTool:
+    return ScriptedTool(name, lambda params: Reply(chunks=(b'{"jsonrpc":"2.0",', b'"id":1}'), abort_after=1))
+
+
+def echo_tool(name: str) -> ScriptedTool:
+    return ScriptedTool(name, lambda params: text_result(json.dumps(params.get("arguments", {}), sort_keys=True)))
+
+
+@contextmanager
+def openapi_peer() -> Iterator[McpPeer]:
+    """OpenAPI-described HTTP service plus the spec file the proxy turns into MCP tools."""
+    observed: Final[queue.Queue[dict[str, object]]] = queue.Queue()
+
+    def provider(request: Request) -> Reply:
+        observed.put(
+            {
+                "body": json.loads(request.body) if request.body else None,
+                "headers": dict(request.headers),
+                "path": request.target,
+                "method": request.method,
+            }
+        )
+        if request.target.startswith("/pets/") and request.method == "GET":
+            return Reply(body=json.dumps({"id": request.target.rsplit("/", 1)[1], "name": "integration-pet"}).encode())
+        if request.target == "/pets" and request.method == "POST":
+            return Reply(status=201, body=json.dumps({"created": json.loads(request.body)}).encode())
+        return Reply(status=404, body=b'{"error":"synthetic not found"}')
+
+    with wire_server(provider) as wire:
+        spec: Final = {
+            "openapi": "3.0.0",
+            "info": {"title": "integration pets", "version": "1"},
+            "servers": [{"url": wire.url}],
+            "paths": {
+                "/pets/{petId}": {
+                    "get": {
+                        "operationId": "getPet",
+                        "summary": "Fetch one pet",
+                        "parameters": [{"name": "petId", "in": "path", "required": True, "schema": {"type": "string"}}],
+                        "responses": {"200": {"description": "pet"}},
+                    }
+                },
+                "/pets": {
+                    "post": {
+                        "operationId": "createPet",
+                        "summary": "Create a pet",
+                        "requestBody": {
+                            "required": True,
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "type": "object",
+                                        "properties": {"name": {"type": "string"}},
+                                        "required": ["name"],
+                                    }
+                                }
+                            },
+                        },
+                        "responses": {"201": {"description": "created"}},
+                    }
+                },
+            },
+        }
+        yield McpPeer(wire.url, observed, spec_path=_spec_file(spec))
+
+
+def scratch_directory() -> Path:
+    path: Final = Path(os.environ.get("INTEGRATION_RESULTS_DIR", "/tmp")) / "mcp-peers"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _spec_file(spec: JsonRpc) -> Path:
+    path: Final = scratch_directory() / f"openapi-{time.monotonic_ns()}.json"
+    path.write_text(json.dumps(spec))
+    return path
+
+
+PeerKind = Literal["http", "sse", "stdio", "openapi"]
+PEER_KINDS: Final[tuple[PeerKind, ...]] = ("http", "sse", "stdio", "openapi")
+
+
+@contextmanager
+def peer_of(kind: PeerKind, *, rich: bool = False) -> Iterator[McpPeer]:
+    if kind == "openapi":
+        with openapi_peer() as candidate:
+            yield candidate
+    elif kind == "stdio":
+        with stdio_peer(scratch_directory(), rich=rich) as candidate:
+            yield candidate
+    else:
+        with mcp_peer(kind, rich=rich) as candidate:
+            yield candidate
 
 
 def register_mcp(scenario: Scenario, peer: McpPeer, alias: str, **fields: object) -> str:
     response: Final = scenario.gateway.request(
-        "POST", "/v1/mcp/server", {"server_name": alias, "alias": alias, "url": peer.url, "transport": "http", **fields}
+        "POST", "/v1/mcp/server", {"server_name": alias, "alias": alias, **peer.registration(), **fields}
     )
     identity: Final = response.json()["server_id"]
-    scenario.cleanups.callback(delete_mcp, scenario.gateway, identity)
+    scenario.cleanups.callback(forget_mcp, scenario.gateway, identity)
     assert response.status_code == 201, response.text
     return identity
 
 
+def forget_mcp(gateway: Gateway, identity: str) -> None:
+    response: Final = gateway.request("DELETE", f"/v1/mcp/server/{identity}")
+    assert response.status_code in (202, 404), response.text
+
+
 def delete_mcp(gateway: Gateway, identity: str) -> None:
     response: Final = gateway.request("DELETE", f"/v1/mcp/server/{identity}")
     assert response.status_code == 202, response.text
     assert read_rows('SELECT server_id FROM "LiteLLM_MCPServerTable" WHERE server_id = %s', (identity,)) == []
 
 
-def tool_names(gateway: Gateway, key: str, identity: str) -> dict[str, str]:
-    response: Final = gateway.client.get("/mcp-rest/tools/list", headers={"x-litellm-api-key": key})
+def listed_tools(gateway: Gateway, key: str, identity: str | None = None) -> dict[str, dict[str, object]]:
+    response: Final = gateway.client.get(
+        "/mcp-rest/tools/list",
+        headers={"x-litellm-api-key": key},
+        params={"server_id": identity} if identity else None,
+    )
     assert response.status_code == 200, response.text
     return {
-        name: tool["name"]
+        tool["name"]: tool
         for tool in response.json()["tools"]
-        if tool.get("mcp_info", {}).get("server_id") == identity
-        for name in ("add", "multiply", "fail")
-        if tool["name"].endswith(name)
+        if identity is None or tool.get("mcp_info", {}).get("server_id") == identity
+    }
+
+
+def tool_names(gateway: Gateway, key: str, identity: str) -> dict[str, str]:
+    return {
+        name: full
+        for full in listed_tools(gateway, key, identity)
+        for name in ("add", "multiply", "fail", "slow", "progress", "sample", "elicit")
+        if full.endswith(name)
     }
 
 
@@ -99,3 +425,192 @@ def call_tool(gateway: Gateway, key: str, identity: str, name: str, arguments: d
         headers={"x-litellm-api-key": key},
         json={"server_id": identity, "name": name, "arguments": arguments},
     )
+
+
+EntryPoint = Literal["mcp", "server_mcp", "root", "sse", "rest"]
+ENTRY_POINTS: Final[tuple[EntryPoint, ...]] = ("mcp", "server_mcp", "root", "sse", "rest")
+INITIALIZE: Final = {
+    "protocolVersion": "2025-06-18",
+    "capabilities": {},
+    "clientInfo": {"name": "integration", "version": "1"},
+}
+
+
+@dataclass(frozen=True, slots=True)
+class Outcome:
+    """What a caller saw from one MCP operation, normalised across entry points."""
+
+    status: int
+    error: str | None
+    tools: tuple[str, ...] = ()
+    text: str | None = None
+    raw: str = ""
+
+    @property
+    def ok(self) -> bool:
+        return self.status == 200 and self.error is None
+
+
+def _parse_rpc_body(response: httpx.Response) -> Mapping[str, object] | None:
+    if response.headers.get("content-type", "").startswith("text/event-stream"):
+        data: Final = tuple(line[5:].strip() for line in response.text.splitlines() if line.startswith("data:"))
+        return json.loads(data[-1]) if data else None
+    try:
+        return json.loads(response.text)
+    except ValueError:
+        return None
+
+
+def _outcome_from_rpc(response: httpx.Response) -> Outcome:
+    body: Final = _parse_rpc_body(response)
+    if response.status_code != 200 or body is None:
+        return Outcome(response.status_code, response.text or f"HTTP {response.status_code}", raw=response.text)
+    if "error" in body:
+        return Outcome(response.status_code, json.dumps(body["error"]), raw=response.text)
+    result: Final = body.get("result", {})
+    assert isinstance(result, dict)
+    if "tools" in result:
+        return Outcome(200, None, tuple(tool["name"] for tool in result["tools"]), raw=response.text)
+    content: Final = result.get("content", [])
+    text: Final = content[0].get("text") if content else None
+    if result.get("isError"):
+        return Outcome(200, text or "isError", text=text, raw=response.text)
+    return Outcome(200, None, text=text, raw=response.text)
+
+
+def _outcome_from_rest(response: httpx.Response) -> Outcome:
+    if response.status_code != 200:
+        return Outcome(response.status_code, response.text, raw=response.text)
+    body: Final = response.json()
+    if "tools" in body:
+        return Outcome(200, None, tuple(tool["name"] for tool in body["tools"]), raw=response.text)
+    content: Final = body.get("content", [])
+    text: Final = content[0].get("text") if content else None
+    if body.get("isError"):
+        return Outcome(200, text or "isError", text=text, raw=response.text)
+    return Outcome(200, None, text=text, raw=response.text)
+
+
+@dataclass(frozen=True, slots=True)
+class McpCaller:
+    """One caller's view of the gateway through a specific entry point."""
+
+    gateway: Gateway
+    key: str | None
+    entry: EntryPoint
+    alias: str | None = None
+    headers: Mapping[str, str] = field(default_factory=dict)
+
+    def _path(self) -> str:
+        if self.entry == "server_mcp":
+            assert self.alias is not None
+            return f"/{self.alias}/mcp"
+        return {"mcp": "/mcp", "root": "/mcp/", "sse": "/mcp/sse", "rest": "/mcp-rest"}[self.entry]
+
+    def _headers(self) -> dict[str, str]:
+        return {
+            **({"x-litellm-api-key": self.key} if self.key is not None else {}),
+            "Accept": "application/json, text/event-stream",
+            **self.headers,
+        }
+
+    def rpc(self, method: str, params: JsonRpc | None = None) -> httpx.Response:
+        if self.entry == "sse":
+            return _legacy_sse_rpc(self.gateway, self._headers(), method, params)
+        return self.gateway.client.post(
+            self._path(),
+            json={"jsonrpc": "2.0", "id": 1, "method": method, "params": dict(params or {})},
+            headers=self._headers(),
+        )
+
+    def initialize(self) -> Outcome:
+        if self.entry == "rest":
+            return Outcome(200, None)
+        return _outcome_from_rpc(self.rpc("initialize", INITIALIZE))
+
+    def list_tools(self, server_id: str | None = None) -> Outcome:
+        if self.entry == "rest":
+            return _outcome_from_rest(
+                self.gateway.client.get(
+                    "/mcp-rest/tools/list",
+                    headers=self._headers(),
+                    params={"server_id": server_id} if server_id else None,
+                )
+            )
+        return _outcome_from_rpc(self.rpc("tools/list"))
+
+    def call(self, name: str, arguments: JsonRpc, server_id: str | None = None) -> Outcome:
+        if self.entry == "rest":
+            return _outcome_from_rest(
+                self.gateway.client.post(
+                    "/mcp-rest/tools/call",
+                    headers=self._headers(),
+                    json={
+                        "name": name,
+                        "arguments": dict(arguments),
+                        **({"server_id": server_id} if server_id else {}),
+                    },
+                )
+            )
+        return _outcome_from_rpc(self.rpc("tools/call", {"name": name, "arguments": dict(arguments)}))
+
+
+def _legacy_sse_rpc(
+    gateway: Gateway, headers: Mapping[str, str], method: str, params: JsonRpc | None
+) -> httpx.Response:
+    """Drive the legacy GET /mcp/sse + POST /mcp/sse/messages pair for one request and synthesise a JSON response."""
+    with gateway.client.stream("GET", "/mcp/sse", headers=headers, timeout=15) as stream:
+        if stream.status_code != 200:
+            stream.read()
+            return httpx.Response(stream.status_code, text=stream.text)
+        lines: Final = stream.iter_lines()
+        endpoint: Final = next(line[5:].strip() for line in lines if line.startswith("data:"))
+        init: Final = gateway.client.post(
+            endpoint,
+            json={"jsonrpc": "2.0", "id": 0, "method": "initialize", "params": INITIALIZE},
+            headers=headers,
+        )
+        assert init.status_code in (200, 202), init.text
+        gateway.client.post(endpoint, json={"jsonrpc": "2.0", "method": "notifications/initialized"}, headers=headers)
+        posted: Final = gateway.client.post(
+            endpoint, json={"jsonrpc": "2.0", "id": 1, "method": method, "params": dict(params or {})}, headers=headers
+        )
+        if posted.status_code not in (200, 202):
+            return httpx.Response(posted.status_code, text=posted.text)
+        for line in lines:
+            if line.startswith("data:") and '"id": 1' in line.replace('"id":1', '"id": 1'):
+                return httpx.Response(200, text=line[5:].strip(), headers={"content-type": "application/json"})
+    return httpx.Response(599, text="legacy SSE stream ended without a reply")
+
+
+def official_client_outcomes(
+    gateway: Gateway, key: str, path: str, name: str, arguments: JsonRpc, *, legacy_sse: bool = False
+) -> tuple[Outcome, Outcome]:
+    """List then call through the official MCP client session, returning both outcomes."""
+    url: Final = str(gateway.client.base_url).rstrip("/") + path
+    headers: Final = {"x-litellm-api-key": key}
+
+    async def run() -> tuple[Outcome, Outcome]:
+        transport: Final = (
+            sse_client(url, headers=headers)
+            if legacy_sse
+            else streamable_http_client(url, http_client=httpx.AsyncClient(headers=headers, timeout=30))
+        )
+        async with transport as streams, ClientSession(streams[0], streams[1]) as session:
+            await session.initialize()
+            listed: Final = await session.list_tools()
+            result: Final = await session.call_tool(name, dict(arguments))
+            content: Final = result.content[0] if result.content else None
+            text: Final = content.text if isinstance(content, TextContent) else None
+            return (
+                Outcome(200, None, tuple(tool.name for tool in listed.tools)),
+                Outcome(200, (text or "isError") if result.is_error else None, text=text),
+            )
+
+    return asyncio.run(run())
+
+
+def tool_calls(observed: tuple[dict[str, object], ...]) -> tuple[dict[str, object], ...]:
+    return tuple(
+        item for item in observed if isinstance(item.get("body"), dict) and item["body"].get("method") == "tools/call"
+    )
diff --git a/tests/integration/_support/mcp_grants.py b/tests/integration/_support/mcp_grants.py
new file mode 100644
index 000000000000..5fa9eeaa0b6a
--- /dev/null
+++ b/tests/integration/_support/mcp_grants.py
@@ -0,0 +1,151 @@
+import uuid
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Final, Literal
+
+from integration._support.client import Gateway, Scenario, string_value
+
+Subject = Literal["key", "team", "org", "user", "end_user", "agent", "access_group", "toolset", "allowed_tools"]
+SUBJECTS: Final[tuple[Subject, ...]] = (
+    "key",
+    "team",
+    "org",
+    "user",
+    "end_user",
+    "agent",
+    "access_group",
+    "toolset",
+    "allowed_tools",
+)
+
+
+@dataclass(frozen=True, slots=True)
+class Caller:
+    """A key plus the request headers that make the proxy resolve the granted subject."""
+
+    key: str
+    headers: Mapping[str, str]
+
+
+def _mcp_permission(server_ids: tuple[str, ...]) -> dict[str, list[str]]:
+    return {"mcp_servers": list(server_ids)}
+
+
+def delete_organization(gateway: Gateway, identity: str) -> None:
+    response: Final = gateway.request("DELETE", "/organization/delete", {"organization_ids": [identity]})
+    assert response.status_code == 200, response.text
+
+
+def delete_end_user(gateway: Gateway, identity: str) -> None:
+    response: Final = gateway.request("POST", "/end_user/delete", {"user_ids": [identity]})
+    assert response.status_code == 200, response.text
+
+
+def delete_agent(gateway: Gateway, identity: str) -> None:
+    response: Final = gateway.request("DELETE", f"/v1/agents/{identity}")
+    assert response.status_code == 200, response.text
+
+
+def delete_toolset(gateway: Gateway, identity: str) -> None:
+    response: Final = gateway.request("DELETE", f"/v1/mcp/toolset/{identity}")
+    assert response.status_code in (200, 202, 204), response.text
+
+
+def create_toolset(scenario: Scenario, tools: tuple[tuple[str, str], ...]) -> str:
+    response: Final = scenario.gateway.request(
+        "POST",
+        "/v1/mcp/toolset",
+        {
+            "toolset_name": f"integration-{uuid.uuid4().hex[:10]}",
+            "tools": [{"server_id": server_id, "tool_name": tool} for server_id, tool in tools],
+        },
+    )
+    assert response.status_code == 201, response.text
+    identity: Final = string_value(response.json()["toolset_id"])
+    scenario.cleanups.callback(delete_toolset, scenario.gateway, identity)
+    return identity
+
+
+def grant(
+    scenario: Scenario,
+    subject: Subject,
+    granted: tuple[str, ...],
+    ceiling: tuple[str, ...],
+    *,
+    access_group: str | None = None,
+    allowed_tools: Mapping[str, tuple[str, ...]] | None = None,
+) -> Caller:
+    """Build a caller whose ``subject`` level grants exactly ``granted`` out of ``ceiling``.
+
+    ``ceiling`` is what the key itself can reach before the subject narrows it; the key subject grants
+    ``granted`` directly. Access groups take the group name that the granted servers were registered with,
+    and ``allowed_tools`` maps server id to the tools the key may call on it."""
+    gateway: Final = scenario.gateway
+    match subject:
+        case "key":
+            return Caller(scenario.key(object_permission=_mcp_permission(granted)), {})
+        case "team":
+            team: Final = scenario.team(object_permission=_mcp_permission(granted))
+            return Caller(scenario.key(team_id=team), {})
+        case "org":
+            created: Final = gateway.post(
+                "/organization/new",
+                {
+                    "organization_alias": f"integration-{uuid.uuid4().hex[:10]}",
+                    "object_permission": _mcp_permission(granted),
+                },
+            )
+            org: Final = string_value(created["organization_id"])
+            scenario.cleanups.callback(delete_organization, gateway, org)
+            org_team: Final = scenario.team(organization_id=org, object_permission=_mcp_permission(ceiling))
+            return Caller(scenario.key(team_id=org_team), {})
+        case "user":
+            user: Final = scenario.user(object_permission=_mcp_permission(granted))
+            return Caller(scenario.key(user_id=user, object_permission=_mcp_permission(ceiling)), {})
+        case "end_user":
+            end_user: Final = f"integration-{uuid.uuid4().hex[:10]}"
+            response: Final = gateway.request(
+                "POST", "/end_user/new", {"user_id": end_user, "object_permission": _mcp_permission(granted)}
+            )
+            assert response.status_code == 200, response.text
+            scenario.cleanups.callback(delete_end_user, gateway, end_user)
+            return Caller(scenario.key(object_permission=_mcp_permission(ceiling)), {"x-litellm-end-user-id": end_user})
+        case "agent":
+            agent: Final = gateway.post(
+                "/v1/agents",
+                {
+                    "agent_name": f"integration-{uuid.uuid4().hex[:10]}",
+                    "agent_card_params": {
+                        "protocolVersion": "0.3.0",
+                        "name": "integration",
+                        "description": "integration agent",
+                        "url": "http://127.0.0.1:1/agent",
+                        "version": "1",
+                        "capabilities": {},
+                        "defaultInputModes": ["text"],
+                        "defaultOutputModes": ["text"],
+                        "skills": [],
+                    },
+                    "object_permission": _mcp_permission(granted),
+                },
+            )
+            agent_id: Final = string_value(agent["agent_id"])
+            scenario.cleanups.callback(delete_agent, gateway, agent_id)
+            return Caller(scenario.key(agent_id=agent_id, object_permission=_mcp_permission(ceiling)), {})
+        case "access_group":
+            assert access_group is not None
+            return Caller(scenario.key(object_permission={"mcp_access_groups": [access_group]}), {})
+        case "toolset":
+            toolset: Final = create_toolset(scenario, tuple((server, "add") for server in granted))
+            return Caller(scenario.key(object_permission={"mcp_toolsets": [toolset]}), {})
+        case "allowed_tools":
+            assert allowed_tools is not None
+            return Caller(
+                scenario.key(
+                    object_permission={
+                        "mcp_servers": list(granted),
+                        "mcp_tool_permissions": {server: list(tools) for server, tools in allowed_tools.items()},
+                    }
+                ),
+                {},
+            )
diff --git a/tests/integration/_support/mcp_stdio_peer.py b/tests/integration/_support/mcp_stdio_peer.py
new file mode 100644
index 000000000000..59865f9dc74d
--- /dev/null
+++ b/tests/integration/_support/mcp_stdio_peer.py
@@ -0,0 +1,49 @@
+"""Stdio MCP peer the proxy spawns; every inbound JSON-RPC line is appended to the record file."""
+
+import sys
+from pathlib import Path
+
+sys.path[0] = str(Path(__file__).resolve().parents[2])
+
+import asyncio  # noqa: E402  # the script directory holds mcp.py, which would shadow the mcp package
+import json  # noqa: E402
+import os  # noqa: E402
+from typing import Final  # noqa: E402
+
+import anyio  # noqa: E402
+from integration._support.mcp import math_service  # noqa: E402
+from mcp.server.stdio import stdio_server  # noqa: E402
+
+
+class Recording:
+    def __init__(self, source: anyio.AsyncFile[str], record: Path) -> None:
+        self.source = source
+        self.record = record
+
+    def __aiter__(self) -> "Recording":
+        return self
+
+    async def __anext__(self) -> str:
+        line: Final = await self.source.readline()
+        if not line:
+            raise StopAsyncIteration
+        with self.record.open("a") as sink:
+            passed: Final = {name: value for name, value in os.environ.items() if name.startswith("PEER_")}
+            sink.write(json.dumps({"body": json.loads(line), "env": passed}) + "\n")
+        return line
+
+    async def readline(self) -> str:
+        return await self.__anext__()
+
+
+async def main() -> None:
+    record: Final = Path(sys.argv[1])
+    service: Final = math_service("integration-stdio", rich=sys.argv[2] == "rich")
+    stdin: Final = anyio.wrap_file(sys.stdin)
+    async with stdio_server(stdin=Recording(stdin, record)) as (read_stream, write_stream):
+        lowlevel: Final = service._lowlevel_server
+        await lowlevel.run(read_stream, write_stream, lowlevel.create_initialization_options())
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/tests/integration/_support/oauth_server.py b/tests/integration/_support/oauth_server.py
new file mode 100644
index 000000000000..cd4e452527fa
--- /dev/null
+++ b/tests/integration/_support/oauth_server.py
@@ -0,0 +1,198 @@
+"""OAuth 2.1 authorization-server double: metadata, DCR, PKCE authorization code, refresh, client credentials,
+token exchange and revocation, every request recorded."""
+
+import base64
+import hashlib
+import json
+import secrets
+import threading
+import uuid
+from collections.abc import Iterator
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import Final
+from urllib.parse import parse_qs, urlencode, urlsplit
+
+from integration._support.wire import Reply, Request, Wire, wire_server
+
+TOKEN_EXCHANGE: Final = "urn:ietf:params:oauth:grant-type:token-exchange"
+
+
+@dataclass(slots=True)
+class AuthorizationServer:
+    wire: Wire
+    clients: dict[str, str] = field(default_factory=dict)
+    codes: dict[str, dict[str, str]] = field(default_factory=dict)
+    access_tokens: dict[str, dict[str, str]] = field(default_factory=dict)
+    refresh_tokens: dict[str, dict[str, str]] = field(default_factory=dict)
+    revoked: set[str] = field(default_factory=set)
+    lock: threading.Lock = field(default_factory=threading.Lock)
+
+    @property
+    def issuer(self) -> str:
+        return self.wire.url
+
+    def drain(self) -> tuple[Request, ...]:
+        return self.wire.drain()
+
+    def token_requests(self) -> tuple[dict[str, str], ...]:
+        return tuple(
+            {name: values[0] for name, values in parse_qs(item.body.decode()).items()}
+            for item in self.drain()
+            if item.target.startswith("/token")
+        )
+
+    def is_live(self, token: str) -> bool:
+        with self.lock:
+            return token in self.access_tokens and token not in self.revoked
+
+    def issue(self, grant: str, client_id: str, subject: str, scope: str) -> dict[str, object]:
+        access: Final = f"at-{grant}-{secrets.token_urlsafe(8)}"
+        refresh: Final = f"rt-{secrets.token_urlsafe(8)}"
+        with self.lock:
+            self.access_tokens[access] = {"client_id": client_id, "subject": subject, "scope": scope, "grant": grant}
+            self.refresh_tokens[refresh] = {"client_id": client_id, "subject": subject, "scope": scope}
+        return {
+            "access_token": access,
+            "token_type": "Bearer",
+            "expires_in": 3600,
+            "refresh_token": refresh,
+            "scope": scope,
+        }
+
+
+def _pkce_matches(challenge: str, verifier: str) -> bool:
+    digest: Final = hashlib.sha256(verifier.encode()).digest()
+    return base64.urlsafe_b64encode(digest).rstrip(b"=").decode() == challenge
+
+
+def _json(status: int, body: dict[str, object]) -> Reply:
+    return Reply(status=status, body=json.dumps(body).encode())
+
+
+def _client_credentials(request: Request, form: dict[str, str]) -> tuple[str, str | None]:
+    header: Final = request.headers.get("authorization", "")
+    if header.lower().startswith("basic "):
+        decoded: Final = base64.b64decode(header.split(" ", 1)[1]).decode()
+        client_id, _, secret = decoded.partition(":")
+        return client_id, secret
+    return form.get("client_id", ""), form.get("client_secret")
+
+
+@contextmanager
+def oauth_server(*, scopes: tuple[str, ...] = ("tools.read", "tools.call")) -> Iterator[AuthorizationServer]:
+    holder: list[AuthorizationServer] = []
+
+    def respond(request: Request) -> Reply:
+        server: Final = holder[0]
+        path: Final = urlsplit(request.target).path
+        query: Final = {name: values[0] for name, values in parse_qs(urlsplit(request.target).query).items()}
+        form: Final = {name: values[0] for name, values in parse_qs(request.body.decode()).items()}
+        if path.startswith("/.well-known/oauth-authorization-server") or path == "/.well-known/openid-configuration":
+            return _json(
+                200,
+                {
+                    "issuer": server.issuer,
+                    "authorization_endpoint": server.issuer + "/authorize",
+                    "token_endpoint": server.issuer + "/token",
+                    "registration_endpoint": server.issuer + "/register",
+                    "revocation_endpoint": server.issuer + "/revoke",
+                    "introspection_endpoint": server.issuer + "/introspect",
+                    "scopes_supported": list(scopes),
+                    "response_types_supported": ["code"],
+                    "grant_types_supported": [
+                        "authorization_code",
+                        "refresh_token",
+                        "client_credentials",
+                        TOKEN_EXCHANGE,
+                    ],
+                    "code_challenge_methods_supported": ["S256"],
+                    "token_endpoint_auth_methods_supported": ["client_secret_post", "client_secret_basic", "none"],
+                },
+            )
+        if path == "/register" and request.method == "POST":
+            metadata: Final = json.loads(request.body or b"{}")
+            client_id: Final = f"dcr-{uuid.uuid4().hex[:12]}"
+            secret: Final = f"secret-{secrets.token_urlsafe(8)}"
+            with server.lock:
+                server.clients[client_id] = secret
+            return _json(
+                201,
+                {
+                    "client_id": client_id,
+                    "client_secret": secret,
+                    "client_id_issued_at": 0,
+                    "redirect_uris": metadata.get("redirect_uris", []),
+                    "grant_types": metadata.get("grant_types", ["authorization_code"]),
+                    "token_endpoint_auth_method": metadata.get("token_endpoint_auth_method", "client_secret_post"),
+                },
+            )
+        if path == "/authorize" and request.method == "GET":
+            missing: Final = tuple(
+                name for name in ("client_id", "redirect_uri", "code_challenge", "state") if name not in query
+            )
+            if missing or query.get("code_challenge_method", "S256") != "S256" or query.get("response_type") != "code":
+                return _json(400, {"error": "invalid_request", "missing": list(missing), "received": query})
+            code: Final = f"code-{secrets.token_urlsafe(8)}"
+            with server.lock:
+                server.codes[code] = {
+                    "client_id": query["client_id"],
+                    "redirect_uri": query["redirect_uri"],
+                    "code_challenge": query["code_challenge"],
+                    "scope": query.get("scope", " ".join(scopes)),
+                }
+            location: Final = (
+                query["redirect_uri"]
+                + ("&" if "?" in query["redirect_uri"] else "?")
+                + urlencode({"code": code, "state": query["state"]})
+            )
+            return Reply(status=302, body=b"", headers={"location": location})
+        if path == "/token" and request.method == "POST":
+            grant: Final = form.get("grant_type", "")
+            client_id, client_secret = _client_credentials(request, form)
+            if grant == "authorization_code":
+                with server.lock:
+                    issued: Final = server.codes.pop(form.get("code", ""), None)
+                if issued is None:
+                    return _json(400, {"error": "invalid_grant", "error_description": "unknown or reused code"})
+                if issued["client_id"] != client_id:
+                    return _json(400, {"error": "invalid_client", "error_description": "code issued to another client"})
+                if not _pkce_matches(issued["code_challenge"], form.get("code_verifier", "")):
+                    return _json(400, {"error": "invalid_grant", "error_description": "pkce verifier mismatch"})
+                return _json(200, server.issue("authorization_code", client_id, "integration-user", issued["scope"]))
+            if grant == "refresh_token":
+                with server.lock:
+                    known: Final = server.refresh_tokens.pop(form.get("refresh_token", ""), None)
+                if known is None:
+                    return _json(400, {"error": "invalid_grant", "error_description": "unknown refresh token"})
+                return _json(200, server.issue("refresh_token", known["client_id"], known["subject"], known["scope"]))
+            if grant == "client_credentials":
+                with server.lock:
+                    expected: Final = server.clients.get(client_id)
+                if not client_id or (expected is not None and expected != client_secret) or not client_secret:
+                    return _json(401, {"error": "invalid_client"})
+                return _json(200, server.issue("client_credentials", client_id, client_id, form.get("scope", "")))
+            if grant == TOKEN_EXCHANGE:
+                subject: Final = form.get("subject_token", "")
+                if not subject:
+                    return _json(400, {"error": "invalid_request", "error_description": "subject_token required"})
+                if not client_id:
+                    return _json(401, {"error": "invalid_client"})
+                token: Final = server.issue("token_exchange", client_id, f"exchanged:{subject}", form.get("scope", ""))
+                return _json(200, {**token, "issued_token_type": "urn:ietf:params:oauth:token-type:access_token"})
+            return _json(400, {"error": "unsupported_grant_type", "grant_type": grant})
+        if path == "/revoke" and request.method == "POST":
+            with server.lock:
+                server.revoked.add(form.get("token", ""))
+            return Reply(status=200, body=b"{}")
+        if path == "/introspect" and request.method == "POST":
+            token: Final = form.get("token", "")
+            with server.lock:
+                info: Final = server.access_tokens.get(token)
+                active: Final = info is not None and token not in server.revoked
+            return _json(200, {"active": active, **(info or {})})
+        return _json(404, {"error": "not_found", "path": path, "method": request.method})
+
+    with wire_server(respond) as wire:
+        holder.append(AuthorizationServer(wire))
+        yield holder[0]
diff --git a/tests/integration/_support/proxy.py b/tests/integration/_support/proxy.py
index 3139beaeb019..a444b93757d0 100644
--- a/tests/integration/_support/proxy.py
+++ b/tests/integration/_support/proxy.py
@@ -1,11 +1,19 @@
 """Run the normal single-process CLI with the existing behavior-suite test entitlement."""
 
+import signal
+import sys
+from types import FrameType
 from unittest.mock import patch
 
 from litellm import run_server
 
 
+def _exit_on_reraised_term(signum: int, frame: FrameType | None) -> None:
+    sys.exit(0)
+
+
 def main() -> None:
+    signal.signal(signal.SIGTERM, _exit_on_reraised_term)
     with patch(  # test-quality-ok: route entitlement only; license validation is outside these HTTP/DB contracts
         "litellm.proxy.auth.litellm_license.LicenseCheck.is_premium", return_value=True
     ):
diff --git a/tests/integration/authorization/test_access_group_model_listing.py b/tests/integration/authorization/test_access_group_model_listing.py
new file mode 100644
index 000000000000..9b37cc8f2322
--- /dev/null
+++ b/tests/integration/authorization/test_access_group_model_listing.py
@@ -0,0 +1,51 @@
+import uuid
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import Final
+
+import httpx
+import pytest
+
+from tests.integration._support.client import Gateway, eventually, object_value, string_value
+
+
+@contextmanager
+def _team_access_group(gateway: Gateway, team_id: str, model: str) -> Iterator[str]:
+    created: Final = gateway.request(
+        "POST",
+        "/v1/access_group",
+        {
+            "access_group_name": f"integration-{uuid.uuid4().hex}",
+            "access_model_names": [model],
+            "assigned_team_ids": [team_id],
+        },
+    )
+    assert created.status_code == 201, created.text
+    identity: Final = string_value(created.json()["access_group_id"])
+    try:
+        yield identity
+    finally:
+        deleted: Final = gateway.request("DELETE", f"/v1/access_group/{identity}")
+        assert deleted.status_code == 204, deleted.text
+
+
+def _listed_model_ids(response: httpx.Response) -> tuple[str, ...]:
+    entries: Final = response.json()["data"]
+    assert isinstance(entries, list), response.text
+    return tuple(string_value(object_value(entry)["id"]) for entry in entries)
+
+
+@pytest.mark.covers("authorization.access_groups.team_key_lists_models_granted_through_team_access_group")
+def test_team_key_lists_models_granted_through_team_access_group(gateway: Gateway) -> None:
+    with gateway.scenario() as scenario:
+        model: Final = scenario.model()
+        team_id: Final = scenario.team(models=["no-default-models"])
+        with _team_access_group(gateway, team_id, model):
+            key: Final = scenario.key(team_id=team_id)
+            response: Final = eventually(
+                lambda: gateway.request("GET", "/v1/models", key=key),
+                lambda value: value.status_code == 200 and _listed_model_ids(value) == (model,),
+                return_last_on_timeout=True,
+            )
+            assert response.status_code == 200, response.text
+            assert _listed_model_ids(response) == (model,), response.text
diff --git a/tests/integration/authorization/test_bedrock_passthrough_model_access.py b/tests/integration/authorization/test_bedrock_passthrough_model_access.py
new file mode 100644
index 000000000000..c1b54fe7e38f
--- /dev/null
+++ b/tests/integration/authorization/test_bedrock_passthrough_model_access.py
@@ -0,0 +1,65 @@
+import json
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.upstream import _aws_event_frame
+from integration._support.wire import Reply, Request, wire_server
+
+_MODEL_ID: Final = "anthropic.claude-sonnet-5-v1:0"
+_ACTIONS: Final = ("converse", "invoke", "converse-stream", "invoke-with-response-stream")
+_REQUEST_BODY: Final = {"messages": [{"role": "user", "content": [{"text": "synthetic passthrough allowlist"}]}]}
+_CONVERSE_RESPONSE: Final = json.dumps(
+    {
+        "output": {"message": {"role": "assistant", "content": [{"text": "bedrock allowlist control"}]}},
+        "stopReason": "end_turn",
+        "usage": {"inputTokens": 11, "outputTokens": 4, "totalTokens": 15},
+        "metrics": {"latencyMs": 1},
+    }
+).encode()
+_STREAM_BYTES: Final = b"".join(
+    _aws_event_frame(kind, payload, "sc", "u")
+    for kind, payload in (
+        ("messageStart", {"role": "assistant"}),
+        ("contentBlockDelta", {"delta": {"text": "bedrock allowlist control"}, "contentBlockIndex": 0}),
+        ("messageStop", {"stopReason": "end_turn"}),
+        ("metadata", {"usage": {"inputTokens": 11, "outputTokens": 4, "totalTokens": 15}}),
+    )
+)
+
+
+def bedrock_peer(request: Request) -> Reply:
+    assert request.method == "POST", request.target
+    assert json.loads(request.body)["messages"] == _REQUEST_BODY["messages"], request.body
+    if request.target.endswith("-stream"):
+        return Reply(body=_STREAM_BYTES, content_type="application/vnd.amazon.eventstream")
+    return Reply(body=_CONVERSE_RESPONSE)
+
+
+@pytest.mark.covers("authz.key_models.bedrock_passthrough_route_model_is_enforced")
+def test_key_scoped_to_one_model_cannot_call_another_through_bedrock_passthrough_routes(gateway: Gateway) -> None:
+    with wire_server(bedrock_peer) as wire, gateway.scenario() as scenario:
+        allowed: Final = scenario.model(
+            model=f"bedrock/{_MODEL_ID}",
+            api_base=wire.url,
+            aws_access_key_id="AKIASCRIPTEDPROVIDER",
+            aws_secret_access_key="scripted-secret",
+            aws_region_name="us-east-1",
+        )
+        denied: Final = scenario.model(
+            model=f"bedrock/{_MODEL_ID}",
+            api_base=wire.url,
+            aws_access_key_id="AKIASCRIPTEDPROVIDER",
+            aws_secret_access_key="scripted-secret",
+            aws_region_name="us-east-1",
+        )
+        key: Final = scenario.key(models=[allowed])
+        for action in _ACTIONS:
+            response: Final = gateway.request("POST", f"/bedrock/model/{denied}/{action}", _REQUEST_BODY, key=key)
+            assert response.status_code == 403, f"{action}: {response.status_code} {response.text}"
+            assert response.json()["error"]["type"] == "key_model_access_denied", f"{action}: {response.text}"
+            assert wire.drain() == (), f"{action} reached the provider: {response.text}"
+        for action in _ACTIONS:
+            served: Final = gateway.request("POST", f"/bedrock/model/{allowed}/{action}", _REQUEST_BODY, key=key)
+            assert served.status_code == 200, f"{action}: {served.status_code} {served.text}"
+            assert tuple(request.target for request in wire.drain()) == (f"/model/{_MODEL_ID}/{action}",), served.text
diff --git a/tests/integration/authorization/test_jwt_default_team_provisioning.py b/tests/integration/authorization/test_jwt_default_team_provisioning.py
new file mode 100644
index 000000000000..04715d128b06
--- /dev/null
+++ b/tests/integration/authorization/test_jwt_default_team_provisioning.py
@@ -0,0 +1,86 @@
+import json
+import time
+import uuid
+from pathlib import Path
+from typing import Final
+
+import jwt
+import pytest
+import yaml
+from cryptography.hazmat.primitives.asymmetric import rsa
+
+from tests.integration._support.client import Gateway, eventually
+from tests.integration._support.database import read_rows
+from tests.integration._support.process import owned_proxy
+from tests.integration._support.wire import Reply, Request, wire_server
+
+KEY_ID: Final = "integration-jwt-signing-key"
+TEAM_BUDGET: Final = 25.0
+
+
+def _jwks_reply(public_jwk: str) -> Reply:
+    return Reply(body=json.dumps({"keys": [{**json.loads(public_jwk), "kid": KEY_ID}]}).encode())
+
+
+@pytest.mark.covers("authorization.jwt.new_subject_without_team_claim_joins_default_team")
+def test_jwt_subject_without_team_claim_is_provisioned_into_configured_default_team(
+    gateway: Gateway, tmp_path: Path
+) -> None:
+    private_key: Final = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+    public_jwk: Final = jwt.algorithms.RSAAlgorithm.to_jwk(private_key.public_key())
+
+    def respond(request: Request) -> Reply:
+        assert request.method == "GET", request
+        return _jwks_reply(public_jwk)
+
+    with wire_server(respond) as jwks, gateway.scenario() as scenario:
+        team: Final = scenario.team()
+        config: Final = yaml.safe_load(Path("tests/integration/proxy_config.yaml").read_text())
+        config["general_settings"] = {
+            **config["general_settings"],
+            "enable_jwt_auth": True,
+            "litellm_jwtauth": {"user_id_jwt_field": "sub", "user_id_upsert": True},
+        }
+        config["litellm_settings"] = {
+            **config["litellm_settings"],
+            "default_internal_user_params": {
+                "user_role": "internal_user",
+                "teams": [{"team_id": team, "user_role": "user", "max_budget_in_team": TEAM_BUDGET}],
+            },
+        }
+        path: Final = tmp_path / "jwt_default_team.yaml"
+        path.write_text(yaml.safe_dump(config))
+        subject: Final = f"integration-jwt-{uuid.uuid4().hex}"
+        token: Final = jwt.encode(
+            {"sub": subject, "iat": int(time.time()), "exp": int(time.time()) + 300},
+            private_key,
+            algorithm="RS256",
+            headers={"kid": KEY_ID},
+        )
+        with owned_proxy(gateway, tmp_path, {"JWT_PUBLIC_KEY_URL": jwks.url}, config=path) as candidate:
+            model: Final = scenario.model()
+            scenario.cleanups.callback(scenario.delete_user, subject)
+            response: Final = candidate.request(
+                "POST",
+                "/v1/chat/completions",
+                {"model": model, "messages": [{"role": "user", "content": "default team control"}]},
+                key=token,
+            )
+            assert response.status_code == 200, response.text
+            assert response.json()["choices"][0]["message"]["content"] == (
+                "Hello! This is a mock response from the fake OpenAI endpoint."
+            ), response.text
+            assert read_rows(
+                'SELECT user_id, user_role, teams FROM "LiteLLM_UserTable" WHERE user_id = %s', (subject,)
+            ) == [{"user_id": subject, "user_role": "internal_user", "teams": [team]}]
+            memberships: Final = eventually(
+                lambda: read_rows(
+                    'SELECT m.team_id, b.max_budget FROM "LiteLLM_TeamMembership" m '
+                    'JOIN "LiteLLM_BudgetTable" b ON b.budget_id = m.budget_id WHERE m.user_id = %s',
+                    (subject,),
+                ),
+                lambda rows: len(rows) == 1,
+            )
+            assert memberships == [{"team_id": team, "max_budget": TEAM_BUDGET}]
+            roster: Final = read_rows('SELECT members_with_roles FROM "LiteLLM_TeamTable" WHERE team_id = %s', (team,))
+            assert {"user_id": subject, "role": "user", "user_email": None} in roster[0]["members_with_roles"], roster
diff --git a/tests/integration/authorization/test_jwt_mapped_key_email_backfill.py b/tests/integration/authorization/test_jwt_mapped_key_email_backfill.py
new file mode 100644
index 000000000000..47c8ad5f115d
--- /dev/null
+++ b/tests/integration/authorization/test_jwt_mapped_key_email_backfill.py
@@ -0,0 +1,112 @@
+import json
+import time
+import uuid
+from hashlib import sha256
+from pathlib import Path
+from typing import Final
+
+import jwt
+import pytest
+from cryptography.hazmat.primitives.asymmetric import rsa
+from integration._support.client import Gateway, eventually
+from integration._support.database import read_rows
+from integration._support.process import owned_proxy
+from integration._support.wire import Reply, Request, wire_server
+from jwt.algorithms import RSAAlgorithm
+
+AUDIENCE: Final = "litellm-integration"
+KEY_ID: Final = "integration-signing-key"
+CLIENT_CLAIM: Final = "client_id"
+
+
+def _proxy_config(directory: Path, model: str, upstream_url: str) -> Path:
+    config: Final = directory / "jwt_mapped_key_config.yaml"
+    config.write_text(
+        json.dumps(
+            {
+                "model_list": [
+                    {
+                        "model_name": model,
+                        "litellm_params": {
+                            "model": "openai/" + model,
+                            "api_base": upstream_url + "/v1",
+                            "api_key": "sk-upstream",
+                        },
+                    }
+                ],
+                "general_settings": {
+                    "master_key": "os.environ/LITELLM_MASTER_KEY",
+                    "database_url": "os.environ/DATABASE_URL",
+                    "store_model_in_db": True,
+                    "proxy_batch_write_at": 1,
+                    "proxy_batch_polling_interval": 1,
+                    "enable_jwt_auth": True,
+                    "litellm_jwtauth": {
+                        "user_id_jwt_field": "sub",
+                        "user_email_jwt_field": "email",
+                        "virtual_key_claim_field": CLIENT_CLAIM,
+                    },
+                },
+                "router_settings": {"disable_cooldowns": True},
+            }
+        )
+    )
+    return config
+
+
+def _signed_token(private_key: rsa.RSAPrivateKey, user_id: str, email: str, client_id: str) -> str:
+    now: Final = int(time.time())
+    return jwt.encode(
+        {"sub": user_id, "email": email, CLIENT_CLAIM: client_id, "aud": AUDIENCE, "iat": now, "exp": now + 300},
+        private_key,
+        algorithm="RS256",
+        headers={"kid": KEY_ID},
+    )
+
+
+@pytest.mark.covers("authorization.jwt.mapped_key_backfills_null_user_email_from_claims")
+def test_jwt_mapped_key_request_backfills_null_user_email_from_token_claims(gateway: Gateway, tmp_path: Path) -> None:
+    private_key: Final = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+    public_jwk: Final = json.loads(RSAAlgorithm.to_jwk(private_key.public_key()))
+    jwks: Final = json.dumps({"keys": [{**public_jwk, "kid": KEY_ID, "use": "sig", "alg": "RS256"}]}).encode()
+
+    def respond(request: Request) -> Reply:
+        assert request.target == "/jwks", request
+        return Reply(body=jwks)
+
+    model: Final = "integration-jwt-" + uuid.uuid4().hex
+    with wire_server(respond) as issuer:
+        config: Final = _proxy_config(tmp_path, model, gateway.upstream_url)
+        overrides: Final = {"JWT_PUBLIC_KEY_URL": issuer.url + "/jwks", "JWT_AUDIENCE": AUDIENCE}
+        with owned_proxy(gateway, tmp_path, overrides, config=config) as candidate, candidate.scenario() as scenario:
+            user: Final = scenario.user()
+            key: Final = scenario.key(user_id=user, models=[model])
+            client_id: Final = "integration-client-" + uuid.uuid4().hex
+            mapping: Final = candidate.post(
+                "/jwt/key/mapping/new", {"jwt_claim_name": CLIENT_CLAIM, "jwt_claim_value": client_id, "key": key}
+            )
+            scenario.cleanups.callback(candidate.post, "/jwt/key/mapping/delete", {"id": mapping["id"]})
+            assert read_rows('SELECT user_email FROM "LiteLLM_UserTable" WHERE user_id = %s', (user,)) == [
+                {"user_email": None}
+            ]
+            email: Final = f"{user}@integration.example"
+            token: Final = _signed_token(private_key, user, email, client_id)
+            response: Final = candidate.request(
+                "POST",
+                "/v1/chat/completions",
+                {"model": model, "messages": [{"role": "user", "content": "jwt email backfill control"}]},
+                key=token,
+            )
+            assert response.status_code == 200, response.text
+            assert read_rows('SELECT user_email FROM "LiteLLM_UserTable" WHERE user_id = %s', (user,)) == [
+                {"user_email": email}
+            ]
+            spend_rows: Final = eventually(
+                lambda: read_rows(
+                    'SELECT api_key, "user" FROM "LiteLLM_SpendLogs" WHERE request_id = %s',
+                    (str(response.json()["id"]),),
+                ),
+                lambda rows: len(rows) == 1,
+                seconds=70,
+            )
+            assert spend_rows == [{"api_key": sha256(key.encode()).hexdigest(), "user": user}]
diff --git a/tests/integration/authorization/test_object_permission_lookup.py b/tests/integration/authorization/test_object_permission_lookup.py
new file mode 100644
index 000000000000..21fba30c1657
--- /dev/null
+++ b/tests/integration/authorization/test_object_permission_lookup.py
@@ -0,0 +1,74 @@
+import time
+from typing import Final
+
+import pytest
+
+from tests.integration._support.client import Gateway, eventually
+from tests.integration._support.database import read_rows
+
+PLAIN_REQUESTS: Final = 10
+STATS_FLUSH_WINDOW_SECONDS: Final = 11.0
+
+
+def _object_permission_reads() -> int:
+    rows: Final = read_rows(
+        "SELECT seq_scan + idx_scan AS reads FROM pg_stat_user_tables WHERE relname = %s",
+        ("LiteLLM_ObjectPermissionTable",),
+    )
+    reads: Final = rows[0]["reads"]
+    assert isinstance(reads, int), rows
+    return reads
+
+
+def _settled_object_permission_reads(previous: int, unchanged_since: float) -> int:
+    changed: Final = eventually(
+        lambda: _object_permission_reads() != previous,
+        lambda drifted: drifted,
+        seconds=STATS_FLUSH_WINDOW_SECONDS - (time.monotonic() - unchanged_since),
+        return_last_on_timeout=True,
+    )
+    if not changed:
+        return previous
+    return _settled_object_permission_reads(_object_permission_reads(), time.monotonic())
+
+
+def _assert_plain_chat_served(gateway: Gateway, model: str, key: str) -> None:
+    response: Final = gateway.request(
+        "POST",
+        "/v1/chat/completions",
+        {"model": model, "messages": [{"role": "user", "content": "no vector stores"}]},
+        key=key,
+    )
+    assert response.status_code == 200, response.text
+    assert response.json()["choices"][0]["message"]["content"] == (
+        "Hello! This is a mock response from the fake OpenAI endpoint."
+    )
+
+
+def _assert_forbidden_vector_store_denied(gateway: Gateway, model: str, key: str) -> None:
+    response: Final = gateway.request(
+        "POST",
+        "/v1/chat/completions",
+        {"model": model, "messages": [{"role": "user", "content": "forbidden"}], "vector_store_ids": ["vs_forbidden"]},
+        key=key,
+    )
+    assert response.status_code == 401, response.text
+    assert response.json()["error"]["type"] == "key_vector_store_access_denied", response.text
+
+
+@pytest.mark.covers("authorization.vector_store.plain_request_skips_object_permission_lookup")
+def test_chat_request_without_vector_stores_does_not_read_object_permission_table(gateway: Gateway) -> None:
+    with gateway.scenario() as scenario:
+        model: Final = scenario.model()
+        key: Final = scenario.key(models=[model], object_permission={"vector_stores": ["vs_allowed"]})
+        _assert_plain_chat_served(gateway, model, key)
+        before_control: Final = _object_permission_reads()
+        _assert_forbidden_vector_store_denied(gateway, model, key)
+        eventually(_object_permission_reads, lambda reads: reads > before_control, seconds=15)
+        baseline: Final = _settled_object_permission_reads(_object_permission_reads(), time.monotonic())
+        for _ in range(PLAIN_REQUESTS):
+            _assert_plain_chat_served(gateway, model, key)
+        after: Final = _settled_object_permission_reads(_object_permission_reads(), time.monotonic())
+        assert after - baseline < PLAIN_REQUESTS, (
+            f"{PLAIN_REQUESTS} plain chat requests added {after - baseline} object permission reads"
+        )
diff --git a/tests/integration/compatibility/test_a2a_wire_versions.py b/tests/integration/compatibility/test_a2a_wire_versions.py
index 7a828ba2487e..2823911ace39 100644
--- a/tests/integration/compatibility/test_a2a_wire_versions.py
+++ b/tests/integration/compatibility/test_a2a_wire_versions.py
@@ -3,7 +3,6 @@
 from typing import Final
 
 import pytest
-
 from integration._support.client import Gateway
 from integration._support.database import read_rows
 from integration._support.wire import Reply, Request, wire_server
@@ -115,3 +114,103 @@ def cleanup(identity: str = identity) -> None:
             actual: Final = wire.drain()
             assert len(tuple(item for item in actual if item.method == "POST")) == 1
             assert any(item.method == "GET" for item in actual)
+
+
+@pytest.mark.covers("compatibility.a2a.versioned_card_path_agent_is_reached_with_bearer_and_blocking_send")
+def test_agent_serving_its_card_only_at_versioned_path_is_reached_with_bearer_and_answers(gateway: Gateway) -> None:
+    marker: Final = "foundry" + uuid.uuid4().hex
+    bearer: Final = "Bearer synthetic-entra-" + marker
+
+    def upstream(request: Request) -> Reply:
+        assert request.headers.get("authorization") == bearer, request.headers
+        if request.method == "GET":
+            if request.target != "/agentCard/v1.0":
+                return Reply(status=404, body=json.dumps({"error": "not found"}).encode())
+            return Reply(
+                body=json.dumps(
+                    {
+                        "protocolVersion": "0.3",
+                        "name": marker,
+                        "description": "Synthetic prompt agent",
+                        "version": "1.0.0",
+                        "url": wire.url + "/",
+                        "capabilities": {"streaming": False},
+                        "defaultInputModes": ["text"],
+                        "defaultOutputModes": ["text"],
+                        "skills": [],
+                    }
+                ).encode()
+            )
+        assert request.method == "POST" and request.target == "/", request.target
+        body: Final = json.loads(request.body)
+        assert body["jsonrpc"] == "2.0" and body["method"] == "message/send", body
+        message: Final = body["params"]["message"]
+        assert message["kind"] == "message" and message["role"] == "user", message
+        assert message["parts"] == [{"kind": "text", "text": "synthetic ping"}], message
+        return Reply(
+            body=json.dumps(
+                {
+                    "jsonrpc": "2.0",
+                    "id": body["id"],
+                    "result": {
+                        "kind": "message",
+                        "role": "agent",
+                        "messageId": marker + "-out",
+                        "parts": [{"kind": "text", "text": "synthetic pong"}],
+                    },
+                }
+            ).encode()
+        )
+
+    with wire_server(upstream) as wire, gateway.scenario() as scenario:
+        card: Final = {
+            "protocolVersion": "0.3",
+            "name": marker,
+            "description": "Synthetic prompt agent",
+            "version": "1.0.0",
+            "url": wire.url + "/",
+            "capabilities": {"streaming": False},
+            "defaultInputModes": ["text"],
+            "defaultOutputModes": ["text"],
+            "skills": [],
+        }
+        created: Final = gateway.request(
+            "POST",
+            "/v1/agents",
+            {"agent_name": marker, "agent_card_params": card, "static_headers": {"Authorization": bearer}},
+        )
+        assert created.status_code == 200, created.text
+        identity: Final = created.json()["agent_id"]
+
+        def cleanup() -> None:
+            deleted: Final = gateway.request("DELETE", f"/v1/agents/{identity}")
+            assert deleted.status_code == 200, deleted.text
+            assert read_rows('SELECT agent_id FROM "LiteLLM_AgentsTable" WHERE agent_id=%s', (identity,)) == []
+
+        scenario.cleanups.callback(cleanup)
+        response: Final = gateway.request(
+            "POST",
+            f"/a2a/{identity}",
+            {
+                "jsonrpc": "2.0",
+                "id": marker,
+                "method": "message/send",
+                "params": {
+                    "message": {
+                        "kind": "message",
+                        "role": "user",
+                        "messageId": marker + "-in",
+                        "parts": [{"kind": "text", "text": "synthetic ping"}],
+                    }
+                },
+            },
+        )
+        assert response.status_code == 200, response.text
+        body: Final = response.json()
+        assert body["jsonrpc"] == "2.0" and body["id"] == marker and "error" not in body, response.text
+        assert body["result"]["kind"] == "message", response.text
+        assert body["result"]["messageId"] == marker + "-out", response.text
+        assert body["result"]["parts"] == [{"kind": "text", "text": "synthetic pong"}], response.text
+        actual: Final = wire.drain()
+        assert tuple(item.target for item in actual if item.method == "GET")[-1] == "/agentCard/v1.0", actual
+        assert tuple(item.target for item in actual if item.method == "POST") == ("/",), actual
diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py
index d5f0726f8b0e..9c321269e387 100644
--- a/tests/integration/conftest.py
+++ b/tests/integration/conftest.py
@@ -14,7 +14,7 @@
 
 from tests.integration._support.client import Gateway, eventually, gateway_from_environment
 from tests.integration._support.generation import LIFECYCLE_SETTINGS
-from tests.integration._support.manifest import OWNED_DIRECTORIES, contracts
+from tests.integration._support.manifest import OWNED_DIRECTORIES
 
 COLLECTED: Final = pytest.StashKey[tuple[str, ...]]()
 REPORTS: Final = pytest.StashKey[list[pytest.TestReport]]()
@@ -26,7 +26,7 @@ def pytest_addoption(parser: pytest.Parser) -> None:
 
 def pytest_configure(config: pytest.Config) -> None:
     config.addinivalue_line("markers", "integration: owned real-service integration contracts")
-    config.addinivalue_line("markers", "covers(*ids): independently asserted behavior contracts")
+    config.addinivalue_line("markers", "covers(*ids): legacy contract IDs kept for existing tests, not enforced")
     config.stash[REPORTS] = []
     config.pluginmanager.register(IntegrationReportPlugin(config))
 
@@ -53,7 +53,6 @@ def pytest_collection_modifyitems(config: pytest.Config, items: list[pytest.Item
     if order_seed:
         # rebind-ok: pytest requires this hook to reorder its shared collection list in place.
         items.sort(key=lambda item: hashlib.sha256(f"{order_seed}:{item.nodeid}".encode()).digest())
-    manifest: Final = contracts()
     root: Final = Path(__file__).parent
     owned: Final = tuple(
         item
@@ -63,12 +62,7 @@ def pytest_collection_modifyitems(config: pytest.Config, items: list[pytest.Item
     if owned and os.environ.get("GITHUB_ACTIONS") == "true":
         raise pytest.UsageError("Integration contracts are owned by CircleCI")
     for item in owned:
-        if item.nodeid not in manifest:
-            raise pytest.UsageError(f"Integration node missing from manifest: {item.nodeid}")
         item.add_marker(pytest.mark.integration)
-        declared: Final = tuple(value for mark in item.iter_markers("covers") for value in mark.args)
-        if set(declared) != set(manifest[item.nodeid]):
-            raise pytest.UsageError(f"Contract mapping differs for {item.nodeid}")
     config.stash[COLLECTED] = tuple(item.nodeid for item in owned)
 
 
@@ -91,22 +85,25 @@ def pytest_sessionfinish(session: pytest.Session, exitstatus: int) -> None:
     output: Final = Path(destination)
     output.mkdir(parents=True, exist_ok=True)
     (output / "execution.json").write_text(
-        json.dumps({
-            "collected": collected,
-            "passed": passed,
-            "skipped": skipped,
-            "complete": complete,
-            "exitstatus": exitstatus,
-            "hypothesis_version": version("hypothesis"),
-            "hypothesis_seed": session.config.getoption("hypothesis_seed"),
-            "order_seed": session.config.getoption("integration_order_seed"),
-            "generation": {
-                "max_examples": LIFECYCLE_SETTINGS.max_examples,
-                "stateful_step_count": LIFECYCLE_SETTINGS.stateful_step_count,
-                "database": str(LIFECYCLE_SETTINGS.database),
-                "phases": [phase.name for phase in LIFECYCLE_SETTINGS.phases],
+        json.dumps(
+            {
+                "collected": collected,
+                "passed": passed,
+                "skipped": skipped,
+                "complete": complete,
+                "exitstatus": exitstatus,
+                "hypothesis_version": version("hypothesis"),
+                "hypothesis_seed": session.config.getoption("hypothesis_seed"),
+                "order_seed": session.config.getoption("integration_order_seed"),
+                "generation": {
+                    "max_examples": LIFECYCLE_SETTINGS.max_examples,
+                    "stateful_step_count": LIFECYCLE_SETTINGS.stateful_step_count,
+                    "database": str(LIFECYCLE_SETTINGS.database),
+                    "phases": [phase.name for phase in LIFECYCLE_SETTINGS.phases],
+                },
             },
-        }, indent=2)
+            indent=2,
+        )
         + "\n"
     )
     if not complete and exitstatus == 0:
diff --git a/tests/integration/contracts.json b/tests/integration/contracts.json
deleted file mode 100644
index 605f78b71bef..000000000000
--- a/tests/integration/contracts.json
+++ /dev/null
@@ -1,2106 +0,0 @@
-{
-  "groups": {
-    "management": [
-      "management",
-      "authorization",
-      "configuration"
-    ],
-    "accounting": [
-      "pricing",
-      "spend"
-    ],
-    "database": [
-      "database"
-    ],
-    "providers": [
-      "providers",
-      "routing",
-      "streaming"
-    ],
-    "extensions": [
-      "mcp",
-      "observability",
-      "compatibility"
-    ],
-    "sdk": [
-      "sdk"
-    ],
-    "cost": [
-      "cost_calculation"
-    ]
-  },
-  "tests": {
-    "tests/integration/management/test_key_updates.py::test_update_preserves_independent_fields_and_serving": [
-      "mgmt.key.update.preserves_independent_fields"
-    ],
-    "tests/integration/pricing/test_configured_prices.py::test_custom_price_is_reported_and_charged": [
-      "quota_management.spend_tracking.custom_price.matches_input_rates"
-    ],
-    "tests/integration/providers/test_request_boundary.py::test_internal_request_state_does_not_reach_provider": [
-      "other.provider_wire.internal_parameters_filtered"
-    ],
-    "tests/integration/pricing/test_configured_prices.py::test_default_prices_survive_nullable_sibling_and_reload": [
-      "quota_management.spend_tracking.default_prices.survive_nullable_sibling_reload"
-    ],
-    "tests/integration/providers/test_request_boundary.py::test_upstream_rejects_corruption_and_accepts_supported_metadata": [
-      "other.provider_wire.validator_rejects_corruption"
-    ],
-    "tests/integration/pricing/test_configured_prices.py::test_loaded_router_preserves_cached_defaults_during_real_requests": [
-      "quota_management.spend_tracking.default_prices.loaded_router_preserves_cached_defaults"
-    ],
-    "tests/integration/management/test_partial_update_sequences.py::test_generated_partial_updates_preserve_persisted_and_effective_state": [
-      "mgmt.key.update.generated_sequences_preserve_state"
-    ],
-    "tests/integration/management/test_partial_update_sequences.py::test_zero_false_and_empty_values_are_not_treated_as_omission": [
-      "mgmt.key.update.false_zero_and_empty_values_affect_serving"
-    ],
-    "tests/integration/management/test_partial_update_sequences.py::test_project_omission_clear_and_invalid_update_have_distinct_effects": [
-      "mgmt.key.update.project_clear_preserves_scope",
-      "mgmt.key.update.invalid_batch_is_atomic"
-    ],
-    "tests/integration/authorization/test_warmed_policy.py::test_generated_policy_changes_reach_both_warmed_workers": [
-      "mgmt.key.update.two_workers_enforce_warmed_policy"
-    ],
-    "tests/integration/authorization/test_warmed_policy.py::test_scim_deactivation_blocks_null_and_false_keys_but_preserves_other_owners": [
-      "mgmt.user.scim.deactivation_includes_nullable_blocked_keys"
-    ],
-    "tests/integration/authorization/test_warmed_policy.py::test_warmed_team_role_demotion_prevents_later_management_writes": [
-      "mgmt.team.member_update.demoted_role_cannot_write"
-    ],
-    "tests/integration/configuration/test_effective_settings.py::test_model_block_changes_actual_route_and_leaves_other_route_working": [
-      "mgmt.model.block.changes_serving_and_preserves_control"
-    ],
-    "tests/integration/configuration/test_effective_settings.py::test_saved_retry_setting_controls_real_attempts_and_restores": [
-      "mgmt.router_settings.update.changes_observed_attempt_count"
-    ],
-    "tests/integration/configuration/test_effective_settings.py::test_credential_value_update_and_model_reload_reach_provider": [
-      "mgmt.credential.update.saved_value_reaches_wire"
-    ],
-    "tests/integration/management/test_partial_update_sequences.py::test_denied_key_update_preserves_saved_grants_and_serving": [
-      "mgmt.key.update.denied_request_preserves_effective_state"
-    ],
-    "tests/integration/authorization/test_warmed_policy.py::test_expiry_and_explicit_clear_reach_both_warmed_workers": [
-      "mgmt.key.update.expiry_changes_reach_warmed_workers"
-    ],
-    "tests/integration/database/test_partition_transactions.py::test_real_partition_ddl_survives_witnessed_lock_and_is_idempotent": [
-      "other.database.partitions.lock_wait_outlives_transaction_default",
-      "other.database.partitions.repeat_preserves_rows"
-    ],
-    "tests/integration/database/test_reader_writer_regeneration.py::test_key_regeneration_uses_writer_with_a_real_readonly_reader": [
-      "other.database.regeneration.writer_updates_dependent_grants"
-    ],
-    "tests/integration/pricing/test_price_precedence.py::test_generated_zero_null_and_omitted_prices_follow_independent_arithmetic": [
-      "quota_management.spend_tracking.price_precedence.zero_and_default_rates"
-    ],
-    "tests/integration/pricing/test_price_precedence.py::test_same_upstream_aliases_keep_distinct_prices_after_reload": [
-      "quota_management.spend_tracking.alias_prices.remain_independent_on_reload"
-    ],
-    "tests/integration/pricing/test_off_peak_pricing.py::test_open_off_peak_window_bills_off_peak_rates": [
-      "quota_management.spend_tracking.off_peak_pricing.open_window_bills_off_peak_rates"
-    ],
-    "tests/integration/pricing/test_off_peak_pricing.py::test_closed_off_peak_window_bills_standard_rates": [
-      "quota_management.spend_tracking.off_peak_pricing.closed_window_bills_standard_rates"
-    ],
-    "tests/integration/spend/test_cache_and_quota.py::test_generated_cache_sequences_preserve_content_usage_and_zero_hit_cost": [
-      "quota_management.response_cache.generated_sequences_preserve_content_and_accounting"
-    ],
-    "tests/integration/spend/test_cache_and_quota.py::test_key_budget_at_boundary_blocks_provider_then_explicit_reset_restores": [
-      "quota_management.budget.key.boundary_blocks_before_provider_and_reset_restores"
-    ],
-    "tests/integration/spend/test_cache_and_quota.py::test_different_system_messages_do_not_share_a_cached_response": [
-      "quota_management.response_cache.system_messages_partition_cache_identity"
-    ],
-    "tests/integration/database/test_transaction_atomicity.py::test_access_group_second_key_constraint_failure_rolls_back_all_writes": [
-      "other.database.access_group.failed_second_write_rolls_back_first"
-    ],
-    "tests/integration/spend/test_cache_and_quota.py::test_repeated_hits_keep_response_identity_and_create_distinct_zero_cost_rows": [
-      "quota_management.response_cache.repeated_hits_preserve_identity_and_single_charge"
-    ],
-    "tests/integration/providers/test_s3_wire.py::test_sigv4_verifier_matches_published_put_and_rejects_corruption": [
-      "other.provider_wire.s3.verifier_known_answer_and_negative_controls"
-    ],
-    "tests/integration/providers/test_s3_wire.py::test_s3_sync_and_async_uploads_pass_independent_wire_verification": [
-      "other.provider_wire.s3.sync_async_reserved_keys_are_signed_and_accepted"
-    ],
-    "tests/integration/providers/test_bedrock_auth_wire.py::test_bearer_only_sdk_sync_async_requests_do_not_require_aws_credentials": [
-      "other.provider_wire.bedrock.bearer_sdk_skips_credential_chain"
-    ],
-    "tests/integration/providers/test_bedrock_auth_wire.py::test_bearer_environment_reference_loads_from_db_and_yaml_and_survives_reload": [
-      "other.provider_wire.bedrock.bearer_db_yaml_survives_reload"
-    ],
-    "tests/integration/streaming/test_stream_contracts.py::test_generated_tcp_partitions_preserve_unicode_text_identity_and_final_usage": [
-      "other.streaming.byte_partitions.preserve_text_identity_and_usage"
-    ],
-    "tests/integration/streaming/test_stream_contracts.py::test_fragmented_tool_names_and_arguments_keep_each_call_identity": [
-      "other.streaming.tools.fragmented_calls_keep_independent_arguments"
-    ],
-    "tests/integration/streaming/test_stream_contracts.py::test_proxy_stream_usage_visibility_keeps_exact_persisted_charge": [
-      "other.streaming.usage.client_visibility_preserves_persisted_accounting"
-    ],
-    "tests/integration/streaming/test_stream_contracts.py::test_truncated_http_stream_is_an_error_and_next_stream_succeeds": [
-      "other.streaming.failure.truncated_transport_raises_and_control_recovers"
-    ],
-    "tests/integration/streaming/test_stream_contracts.py::test_client_cancellation_releases_the_actual_provider_connection": [
-      "other.streaming.cancellation.closes_actual_provider_connection"
-    ],
-    "tests/integration/routing/test_observed_routing.py::test_retry_counts_and_public_errors_match_actual_provider_attempts": [
-      "other.routing.retries.several_attempts_reach_success_without_hidden_retries",
-      "other.routing.errors.nonretryable_and_exhausted_failures_remain_errors"
-    ],
-    "tests/integration/routing/test_observed_routing.py::test_loaded_fallback_selects_expected_deployment_and_keeps_response_identity": [
-      "other.routing.fallback.loaded_configuration_selects_only_permitted_target"
-    ],
-    "tests/integration/routing/test_observed_routing.py::test_saved_deployment_target_update_changes_wire_and_preserves_control": [
-      "other.routing.alias_update.persisted_target_changes_only_selected_route"
-    ],
-    "tests/integration/providers/test_bedrock_role_configuration.py::test_role_reference_from_db_and_yaml_reaches_real_sts_http_and_bedrock": [
-      "other.provider_wire.bedrock.db_yaml_role_reference_reaches_sts_and_signed_request"
-    ],
-    "tests/integration/routing/test_redis_recovery.py::test_owned_redis_outage_recovers_requests_and_real_response_cache": [
-      "other.routing.redis.owned_outage_recovers_serving_and_response_cache"
-    ],
-    "tests/integration/providers/test_anthropic_wire.py::test_anthropic_bare_string_content_item_is_rejected_as_client_error_before_the_wire[type_word]": [
-      "other.provider_wire.anthropic.bare_string_content_item_is_client_error"
-    ],
-    "tests/integration/providers/test_anthropic_wire.py::test_anthropic_bare_string_content_item_is_rejected_as_client_error_before_the_wire[plain]": [
-      "other.provider_wire.anthropic.bare_string_content_item_is_client_error"
-    ],
-    "tests/integration/providers/test_anthropic_wire.py::test_anthropic_tool_history_and_cache_tokens_keep_wire_and_accounting_contracts": [
-      "other.provider_wire.anthropic.tool_history_system_cache_and_internal_fields",
-      "quota_management.spend_tracking.cache_tokens.disjoint_classes_use_explicit_rates"
-    ],
-    "tests/integration/providers/test_fal_ai_video_wire.py::test_fal_video_create_status_and_content_follow_queue_wire_contract": [
-      "other.provider_wire.fal_ai.video_queue_create_status_and_content_download"
-    ],
-    "tests/integration/providers/test_fal_ai_video_wire.py::test_fal_video_failed_result_reports_failed_status_and_fal_error": [
-      "other.provider_wire.fal_ai.video_failed_result_surfaces_fal_error"
-    ],
-    "tests/integration/providers/test_fal_ai_video_wire.py::test_fal_h3_auto_duration_omits_duration_and_queues": [
-      "other.provider_wire.fal_ai.h3_auto_duration_omits_duration_and_queues"
-    ],
-    "tests/integration/providers/test_fal_ai_video_wire.py::test_fal_h3_oversized_size_uses_top_resolution_tier_and_queues": [
-      "other.provider_wire.fal_ai.h3_oversized_size_uses_top_resolution_tier"
-    ],
-    "tests/integration/providers/test_fal_ai_image_wire.py::test_fal_gpt_image_25_generation_sends_quality_and_size_and_charges_keyed_row": [
-      "other.provider_wire.fal_ai.gpt_image_generation_quality_size_wire_and_keyed_pricing"
-    ],
-    "tests/integration/providers/test_fal_ai_image_wire.py::test_fal_gpt_image_25_generation_prices_non_canonical_size_from_nearest_row": [
-      "other.provider_wire.fal_ai.gpt_image_generation_noncanonical_size_uses_nearest_keyed_row"
-    ],
-    "tests/integration/providers/test_fal_ai_image_wire.py::test_fal_gpt_image_sdk_response_honors_dump_options": [
-      "other.provider_wire.fal_ai.sdk_image_response_dump_options"
-    ],
-    "tests/integration/providers/test_fal_ai_image_wire.py::test_fal_flux_dev_generation_targets_dev_endpoint_and_charges_per_image": [
-      "other.provider_wire.fal_ai.flux_dev_endpoint_and_per_image_pricing"
-    ],
-    "tests/integration/providers/test_fal_ai_passthrough_wire.py::test_fal_queue_submit_charges_and_polls_pass_through_free": [
-      "other.provider_wire.fal_ai.passthrough_queue_submit_charges_and_polls_do_not"
-    ],
-    "tests/integration/providers/test_fal_ai_passthrough_wire.py::test_fal_queue_submit_prices_string_resolution_like_the_integer": [
-      "other.provider_wire.fal_ai.passthrough_queue_submit_prices_string_resolution_like_integer"
-    ],
-    "tests/integration/providers/test_fal_ai_passthrough_wire.py::test_fal_queue_submit_to_catalog_key_the_pricer_cannot_price_is_rejected_not_forwarded": [
-      "other.provider_wire.fal_ai.passthrough_queue_submit_rejects_unpriceable_catalog_key"
-    ],
-    "tests/integration/providers/test_fal_ai_image_wire.py::test_fal_gpt_image_25_edit_inlines_upload_as_data_url_and_charges_keyed_row": [
-      "other.provider_wire.fal_ai.image_edit_json_data_urls_and_keyed_pricing"
-    ],
-    "tests/integration/providers/test_fal_ai_image_wire.py::test_fal_flux_lora_depth_edit_sends_single_image_url_and_charges_flat_row": [
-      "other.provider_wire.fal_ai.flux_lora_depth_edit_single_image_url_and_flat_pricing"
-    ],
-    "tests/integration/providers/test_fal_ai_chat_wire.py::test_fal_moondream3_chat_sends_prompt_image_and_reasoning": [
-      "other.provider_wire.fal_ai.moondream3_chat_query_wire_and_token_pricing"
-    ],
-    "tests/integration/providers/test_fal_ai_chat_wire.py::test_fal_moondream3_chat_rejects_non_string_reasoning_effort_before_the_wire": [
-      "other.provider_wire.fal_ai.chat_non_string_reasoning_effort_rejected_before_wire"
-    ],
-    "tests/integration/providers/test_fal_ai_image_wire.py::test_fal_flux_dev_generation_without_deployment_api_base_uses_global_api_base": [
-      "other.provider_wire.fal_ai.global_api_base_routes_image_generation"
-    ],
-    "tests/integration/providers/test_xiaomi_mimo_wire.py::test_xiaomi_mimo_nonstream_surfaces_reasoning_and_charges_registry_price[mimo-v2.6-pro]": [
-      "other.provider_wire.xiaomi_mimo.reasoning_content_and_registry_pricing"
-    ],
-    "tests/integration/providers/test_xiaomi_mimo_wire.py::test_xiaomi_mimo_nonstream_surfaces_reasoning_and_charges_registry_price[mimo-v2.6-flash]": [
-      "other.provider_wire.xiaomi_mimo.reasoning_content_and_registry_pricing"
-    ],
-    "tests/integration/providers/test_xiaomi_mimo_wire.py::test_xiaomi_mimo_stream_delivers_reasoning_then_answer_deltas": [
-      "other.provider_wire.xiaomi_mimo.reasoning_and_answer_stream_as_deltas"
-    ],
-    "tests/integration/providers/test_xiaomi_mimo_wire.py::test_xiaomi_mimo_tool_call_is_forwarded_and_returned": [
-      "other.provider_wire.xiaomi_mimo.tool_call_survives_translation"
-    ],
-    "tests/integration/providers/test_fal_ai_video_wire.py::test_fal_h3_video_create_uses_canonical_body_and_status_path": [
-      "other.provider_wire.fal_ai.video_queue_create_status_and_content_download"
-    ],
-    "tests/integration/providers/test_fal_ai_video_wire.py::test_fal_result_probe_carries_the_deployment_extra_headers": [
-      "other.provider_wire.fal_ai.video_result_probe_forwards_extra_headers"
-    ],
-    "tests/integration/providers/test_fal_ai_video_wire.py::test_fal_result_probe_reuses_the_ssl_verify_false_client": [
-      "other.provider_wire.fal_ai.video_result_probe_honors_ssl_verify"
-    ],
-    "tests/integration/providers/test_fal_ai_video_wire.py::test_fal_provider_hanging_up_on_the_result_probe_keeps_the_completed_status": [
-      "other.provider_wire.fal_ai.video_result_probe_hangup_stays_completed"
-    ],
-    "tests/integration/mcp/test_mcp_lifecycle.py::test_saved_headers_reach_real_mcp_tool_and_survive_unrelated_edit": [
-      "mcp.call_tool.saved_headers.reach_actual_transport"
-    ],
-    "tests/integration/mcp/test_mcp_lifecycle.py::test_tool_error_remains_error_and_healthy_sibling_returns_value": [
-      "mcp.call_tool.errors.tool_failure_is_not_success"
-    ],
-    "tests/integration/mcp/test_mcp_lifecycle.py::test_generated_mcp_edits_preserve_actual_headers_and_tool_results": [
-      "other.mcp.lifecycle.generated_save_reload_preserves_effective_headers"
-    ],
-    "tests/integration/observability/test_callback_delivery.py::test_concurrent_success_and_failure_join_callbacks_and_rows_without_credentials": [
-      "other.observability.callbacks.credentials_stay_out_of_event_bodies",
-      "other.observability.callbacks.concurrent_results_join_complete_events_and_rows"
-    ],
-    "tests/integration/observability/test_otel_text_completion_choices.py::test_otel_weave_output_keeps_text_completion_provider_fields_beside_the_synthesized_message": [
-      "other.observability.otel.text_completion_choices_keep_provider_fields"
-    ],
-    "tests/integration/observability/test_guardrail_effects.py::test_guardrail_rewrites_system_and_user_in_actual_anthropic_request": [
-      "other.observability.guardrails.rewrite_reaches_correct_anthropic_positions"
-    ],
-    "tests/integration/compatibility/test_a2a_wire_versions.py::test_a2a_versions_and_legacy_casing_preserve_real_wire_and_response": [
-      "other.compatibility.a2a.supported_versions_preserve_literal_envelopes"
-    ],
-    "tests/integration/compatibility/test_persisted_toolsets.py::test_existing_toolset_format_loads_before_start_and_keeps_sibling_denied": [
-      "other.compatibility.mcp.persisted_tool_names_survive_candidate_startup"
-    ],
-    "tests/integration/mcp/test_oauth_configuration.py::test_partial_discovery_and_unrelated_edit_keep_actual_authorization_destination": [
-      "other.mcp.oauth.discovery_cannot_erase_configured_authorization_endpoint"
-    ],
-    "tests/integration/observability/test_guardrail_effects.py::test_guardrail_denial_prevents_provider_and_preserves_allowed_control": [
-      "other.observability.guardrails.denial_prevents_provider_with_allowed_control"
-    ],
-    "tests/integration/mcp/test_mcp_protocol_errors.py::test_jsonrpc_error_and_malformed_tool_result_remain_errors": [
-      "other.mcp.errors.protocol_and_malformed_results_cannot_be_empty_success"
-    ],
-    "tests/integration/compatibility/test_openai_consumer.py::test_retained_openai_clients_parse_real_proxy_tool_and_usage_responses": [
-      "other.compatibility.openai.retained_client_parses_tools_and_usage"
-    ],
-    "tests/integration/spend/test_filtered_ledger.py::test_rotated_keys_users_and_model_groups_preserve_success_failure_cache_ledger": [
-      "quota_management.spend_tracking.filtered_ledger_preserves_owner_identity_and_totals"
-    ],
-    "tests/integration/spend/test_shutdown_flush.py::test_daily_spend_batch_cancelled_while_waiting_for_a_pool_connection_is_written_by_the_final_flush": [
-      "quota_management.spend_tracking.shutdown_cancel_keeps_in_flight_daily_batch"
-    ],
-    "tests/integration/spend/test_shutdown_flush.py::test_daily_spend_batch_cancelled_while_waiting_for_a_row_lock_is_written_exactly_once": [
-      "quota_management.spend_tracking.shutdown_cancel_keeps_in_flight_daily_batch"
-    ],
-    "tests/integration/spend/test_spend_calculate.py::test_spend_calculate_rejects_unpriced_model_with_400": [
-      "quota_management.spend_tracking.spend_calculate.rejects_unpriced_model"
-    ],
-    "tests/integration/spend/test_spend_calculate.py::test_live_preview_entry_charges_cached_tokens_at_the_fresh_rate[gemini-live-2.5-flash-preview-native-audio-09-2025]": [
-      "quota_management.spend_tracking.spend_calculate.live_preview_cached_tokens_cost_fresh_rate"
-    ],
-    "tests/integration/spend/test_spend_calculate.py::test_live_preview_entry_charges_cached_tokens_at_the_fresh_rate[gemini/gemini-live-2.5-flash-preview-native-audio-09-2025]": [
-      "quota_management.spend_tracking.spend_calculate.live_preview_cached_tokens_cost_fresh_rate"
-    ],
-    "tests/integration/management/test_partial_update_sequences.py::test_restricted_actor_cannot_detach_key_from_project": [
-      "mgmt.key.update.project_detach_denied_to_restricted_actor"
-    ],
-    "tests/integration/management/test_partial_update_sequences.py::test_cross_tenant_actor_cannot_read_update_or_detach_project_key": [
-      "mgmt.key.info.cross_tenant_key_is_denied",
-      "mgmt.key.update.cross_tenant_key_is_denied",
-      "mgmt.key.update.cross_tenant_project_detach_is_denied"
-    ],
-    "tests/integration/management/test_project_lifecycle.py::test_project_new_persists_real_state": [
-      "mgmt.project.new.real_route_persists"
-    ],
-    "tests/integration/management/test_project_lifecycle.py::test_project_update_persists_real_state": [
-      "mgmt.project.update.real_route_persists"
-    ],
-    "tests/integration/management/test_project_lifecycle.py::test_project_delete_with_attached_key_refuses_and_preserves_state": [
-      "mgmt.project.delete.attached_key_refusal_preserves_state"
-    ],
-    "tests/integration/sdk/test_http2_wire.py::test_async_handler_negotiates_http2_only_when_enabled": [
-      "other.sdk_wire.http2.async_handler_negotiates_h2_only_when_enabled"
-    ],
-    "tests/integration/sdk/test_http2_wire.py::test_sync_handler_negotiates_http2_only_when_enabled": [
-      "other.sdk_wire.http2.sync_handler_negotiates_h2_only_when_enabled"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_batch_realtime_cost.py::test_batch_costs[gpt-5.6-batch-halved_rates_when_map_has_no_batch_keys]": [
-      "quota_management.spend_tracking.batch_costs.fallback_rates"
-    ],
-    "tests/integration/cost_calculation/test_batch_realtime_cost.py::test_batch_costs[gpt-5.6-batch-cached_input_halved]": [
-      "quota_management.spend_tracking.batch_costs.cached_input"
-    ],
-    "tests/integration/cost_calculation/test_batch_realtime_cost.py::test_batch_costs[gpt-5.4-batch-explicit_batch_rates_bill_cached_at_batch_input_rate]": [
-      "quota_management.spend_tracking.batch_costs.explicit_rates"
-    ],
-    "tests/integration/cost_calculation/test_batch_realtime_cost.py::test_batch_costs[gpt-5.6-batch-all_requests_failed_zero_spend]": [
-      "quota_management.spend_tracking.batch_costs.failed_requests"
-    ],
-    "tests/integration/cost_calculation/test_batch_realtime_cost.py::test_realtime_costs[gpt-realtime-mini-2025-12-15-realtime-single_turn_text_audio_cached]": [
-      "quota_management.spend_tracking.realtime_costs.single_turn"
-    ],
-    "tests/integration/cost_calculation/test_batch_realtime_cost.py::test_realtime_costs[gpt-realtime-mini-2025-12-15-realtime-two_turns_summed_into_one_row]": [
-      "quota_management.spend_tracking.realtime_costs.multiple_turns"
-    ],
-    "tests/integration/cost_calculation/test_batch_realtime_cost.py::test_realtime_costs[gpt-realtime-mini-2025-12-15-realtime-priced_from_session_created_model]": [
-      "quota_management.spend_tracking.realtime_costs.session_model"
-    ],
-    "tests/integration/cost_calculation/test_batch_realtime_cost.py::test_realtime_costs[gpt-realtime-mini-2025-12-15-realtime-session_without_turns_zero_spend]": [
-      "quota_management.spend_tracking.realtime_costs.session_without_turns"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-cache_write_5m]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-cache_write_1h]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-service_tier_flex]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-service_tier_priority]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-audio_input]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-audio_output]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-reasoning]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-service_tier_flex]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-service_tier_priority]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-web_search_medium]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-web_search_low]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-web_search_high]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.4-mini-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-audio_input]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-audio_output]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-reasoning]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-service_tier_flex]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-service_tier_priority]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-web_search_medium]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-web_search_low]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-web_search_high]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_native_json]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-upstream_500_zero_spend]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-upstream_429_zero_spend]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-cache_write_5m]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-cache_write_1h]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-service_tier_priority]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-anthropic_us_inference]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-web_search_medium]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-cache_write_5m]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-cache_write_1h]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-tiered_input_above_200k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-tiered_cache_read_above_200k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-tiered_cache_write_above_200k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-service_tier_priority]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-anthropic_fast_mode]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-anthropic_us_inference]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-web_search_medium]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-opus-5-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-cache_write_5m]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-cache_write_1h]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-tiered_input_above_200k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-tiered_cache_read_above_200k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-tiered_cache_write_above_200k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-service_tier_priority]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-anthropic_us_inference]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-web_search_medium]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-deepseek-v4p1-flash-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-deepseek-v4p1-flash-fallback_cache_read_at_half_input_rate]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-deepseek-v4p1-flash-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-deepseek-v4p1-flash-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-deepseek-v4p1-flash-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-deepseek-v4p1-flash-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-deepseek-v4p1-flash-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-deepseek-v4p1-flash-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-deepseek-v4p1-flash-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-deepseek-v4p1-flash-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-deepseek-v4p1-flash-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-kimi-k3-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-kimi-k3-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-kimi-k3-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-kimi-k3-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-kimi-k3-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-kimi-k3-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-kimi-k3-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-kimi-k3-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-kimi-k3-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-kimi-k3-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-kimi-k3-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-qwen3p8-max-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-qwen3p8-max-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-qwen3p8-max-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-qwen3p8-max-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-qwen3p8-max-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-qwen3p8-max-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-qwen3p8-max-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-qwen3p8-max-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-qwen3p8-max-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-qwen3p8-max-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks_ai-accounts-fireworks-models-qwen3p8-max-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-audio_input]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-image_input]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-reasoning]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-tiered_input_above_200k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-tiered_cache_read_above_200k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-service_tier_flex]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-service_tier_priority]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-web_search_medium]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-google_maps_grounding]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-fallback_video_tokens_at_input_rate]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-prompt_blocked]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-stream_prompt_blocked]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-audio_input]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-audio_output]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-video_input]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-service_tier_flex]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-service_tier_priority]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-web_search_per_prompt]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-google_maps_grounding]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-fallback_reasoning_at_output_rate]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-fallback_image_tokens_at_input_rate]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-prompt_blocked]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-stream_prompt_blocked]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.8-flash-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-audio_input]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-image_input]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-video_input]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-reasoning]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-tiered_input_above_200k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-tiered_cache_read_above_200k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-service_tier_flex]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-service_tier_priority]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-web_search_medium]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-google_maps_grounding]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-prompt_blocked]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-stream_prompt_blocked]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.1-pro-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-audio_input]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-audio_output]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-image_input]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-video_input]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-reasoning]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-service_tier_flex]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-service_tier_priority]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-web_search_per_prompt]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-google_maps_grounding]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-prompt_blocked]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-stream_prompt_blocked]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-reasoning]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-service_tier_flex]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-service_tier_priority]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-web_search_medium]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-web_search_low]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-web_search_high]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-file_search]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-stream_incomplete]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-stream_no_usage_incomplete]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-stream_unvalidated]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-stream_no_usage_unvalidated]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-audio_input]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-audio_output]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-reasoning]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-service_tier_flex]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-service_tier_priority]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-web_search_medium]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-web_search_low]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-web_search_high]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.4-mini-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-reasoning]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-service_tier_flex]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-service_tier_priority]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-web_search_medium]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-web_search_low]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-web_search_high]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-file_search]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-stream_incomplete]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-stream_no_usage_incomplete]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-stream_unvalidated]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-stream_no_usage_unvalidated]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.5-pro-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-audio_input]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-audio_output]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-reasoning]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-service_tier_flex]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-service_tier_priority]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-web_search_medium]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-web_search_low]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-web_search_high]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[meta.llama4-maverick-17b-instruct-v1:0-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[meta.llama4-maverick-17b-instruct-v1:0-fallback_cache_read_at_input_rate]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[meta.llama4-maverick-17b-instruct-v1:0-fallback_cache_write_at_input_rate]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[meta.llama4-maverick-17b-instruct-v1:0-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[meta.llama4-maverick-17b-instruct-v1:0-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[meta.llama4-maverick-17b-instruct-v1:0-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[meta.llama4-maverick-17b-instruct-v1:0-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[meta.llama4-maverick-17b-instruct-v1:0-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[meta.llama4-maverick-17b-instruct-v1:0-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[meta.llama4-maverick-17b-instruct-v1:0-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[meta.llama4-maverick-17b-instruct-v1:0-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[meta.llama4-maverick-17b-instruct-v1:0-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-moonshotai-Kimi-K3-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-moonshotai-Kimi-K3-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-moonshotai-Kimi-K3-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-moonshotai-Kimi-K3-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-moonshotai-Kimi-K3-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-moonshotai-Kimi-K3-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-moonshotai-Kimi-K3-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-moonshotai-Kimi-K3-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-moonshotai-Kimi-K3-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-moonshotai-Kimi-K3-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-zai-org-GLM-5.3-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-zai-org-GLM-5.3-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-zai-org-GLM-5.3-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-zai-org-GLM-5.3-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-zai-org-GLM-5.3-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-zai-org-GLM-5.3-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-zai-org-GLM-5.3-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-zai-org-GLM-5.3-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-zai-org-GLM-5.3-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together_ai-zai-org-GLM-5.3-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-cache_write_5m]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-cache_write_1h]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-tiered_input_above_200k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-tiered_cache_read_above_200k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-tiered_cache_write_above_200k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-service_tier_flex]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-service_tier_priority]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-stream_no_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-stream_no_usage_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-stream_no_usage_image_input]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-stream_response_model_override]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-stream_tool_call]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-stream_full_usage]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[whisper-next-transcriptions-per-second]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[whisper-verbose-next-transcriptions-duration]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-4o-transcribe-next-transcriptions-tokens]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[nova-next-transcriptions-per-second]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-whisper-next-transcriptions-deployment]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[tts-next-speech-per-character]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[tts-next-hd-speech-per-character]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-tts-next-speech-deployment]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[dall-e-3-next-images-standard]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[dall-e-3-next-images-hd]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[dall-e-3-next-images-wide]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[dall-e-3-next-images-two]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-image-next-images-low]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[imagen-next-images-one]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[amazon-nova-canvas-next-images-one]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-image-next-images-edit]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-text-embeddings-4-large-deployment]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-cohere-embeddings-v4]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-cohere-rerank-v4]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-embeddings-titan-v2]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[cohere-embeddings-v5]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[cohere-rerank-v4-one]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[cohere-rerank-v4-three]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[cohere-rerank-v4-total-tokens-fallback]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks-embeddings-v1]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-embeddings-002]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[omni-moderations-next-list]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[omni-moderations-next-single]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[text-completions-openai-basic]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[text-completions-openai-n-best]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[text-completions-openai-stream-usage]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[text-embeddings-3-large-dimensions]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[text-embeddings-4-small-batch]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[text-embeddings-4-small-single]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[text-embeddings-4-small-token-array]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together-completions-v1]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together-embeddings-v1]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[vertex-embeddings-text-006]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_reasoning]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_stream_cache_read]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_incomplete]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_previous_response_id]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_web_search_medium]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-responses_file_search]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_service_tier_flex]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_service_tier_priority]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_cache_write_5m]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_cache_write_1h]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_web_search]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_stream_cache_read]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_tiered_input_above_200k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-messages_input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-messages_input_text]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-messages_cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-passthrough-generate_content_priced_via_gemini_key]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-passthrough-stream_generate_content_priced_via_vertex_key]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-passthrough-messages]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-passthrough-messages_cache_read]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-passthrough-converse]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-passthrough-converse_stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[dashscope-qwen4-max-tiered_input]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[dashscope-qwen4-max-tiered_boundary_stays_lower_tier]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[dashscope-qwen4-max-tiered_second_tier]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[dashscope-qwen4-max-tiered_above_top_range]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-lite-input_below_128k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-lite-input_above_128k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-cache_creation_1h_above_200k]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[openrouter-anthropic-claude-sonnet-5-provider_reported_cost]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[openrouter-anthropic-claude-sonnet-5-token_priced]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[perplexity-sonar-next-no_search]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[deepseek-deepseek-v4-chat-prompt_cache_hit]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[deepseek-deepseek-v4-chat-no_cache_fields_bills_zero_cache]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[xai-grok-5-reasoning_folded_into_completion]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[xai-grok-5-live_search]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[xai-grok-5-provider_reported_cost]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-invoke-haiku-json]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-invoke-haiku-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-converse-profile-base-model]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-converse-eu-regional-key]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-converse-apac-bare-fallback]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-converse-nova-2-pro]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-converse-mistral-large-3-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-ai-gpt-5.4-mini-latest]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-ai-gpt-5.4-mini-latest-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-pinned-gpt-5.4-mini-stream]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[groq-qwen-3.8-json]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[groq-qwen-3.8-stream_x_groq_recount]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[cohere-command-a-v2-tokens]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[mistral-medium-2604-json]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[openai-deployment-pricing-override]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-upstream_400_zero_spend]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-upstream_401_zero_spend]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-upstream_500_stream_request_zero_spend]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_upstream_500_zero_spend]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_upstream_500_zero_spend]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-fallback_billed_to_answering_deployment]": [
-      "quota_management.spend_tracking.routing.fallback_billing"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-n_2_choices]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-finish_reason_length]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-stream_usage_in_empty_choices_chunk]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-stream_usage_in_last_delta_chunk]": [
-      "quota_management.spend_tracking.scripted_wire.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-unknown_model_response_model_unknown]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-unknown_model_response_model_known]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-chat_request_to_embedding_entry]": [
-      "quota_management.spend_tracking.cost_matrix.logs_cost"
-    ],
-    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-client_disconnect_mid_stream]": [
-      "quota_management.spend_tracking.scripted_wire.client_disconnect"
-    ],
-    "tests/integration/mcp/test_mcp_lifecycle.py::test_health_intersects_route_restricted_key_grants_in_both_management_modes": [
-      "other.mcp.health.restricted_keys_intersect_grants_in_both_modes"
-    ],
-    "tests/integration/mcp/test_mcp_lifecycle.py::test_warm_credential_removal_rejects_without_upstream_traffic": [
-      "other.mcp.credentials.warm_removal_fails_closed_without_upstream_traffic"
-    ],
-    "tests/integration/observability/test_guardrail_effects.py::test_request_selected_mcp_guardrail_blocks_direct_and_virtual_calls": [
-      "other.mcp.guardrails.request_selection_blocks_resolved_tool_without_execution"
-    ],
-    "tests/integration/mcp/test_oauth_configuration.py::test_same_url_oauth_credentials_and_revocation_are_isolated_by_user_and_server[revoke]": [
-      "other.mcp.oauth.same_url_credentials_are_isolated_by_user_and_server"
-    ],
-    "tests/integration/mcp/test_oauth_configuration.py::test_same_url_oauth_credentials_and_revocation_are_isolated_by_user_and_server[expire]": [
-      "other.mcp.oauth.same_url_credentials_are_isolated_by_user_and_server"
-    ],
-    "tests/integration/mcp/test_mcp_lifecycle.py::test_same_url_server_grants_scope_discovery_and_direct_or_virtual_execution[anonymous]": [
-      "other.mcp.permissions.same_url_servers_enforce_discovery_and_execution"
-    ],
-    "tests/integration/mcp/test_mcp_lifecycle.py::test_same_url_server_grants_scope_discovery_and_direct_or_virtual_execution[bearer]": [
-      "other.mcp.permissions.same_url_servers_enforce_discovery_and_execution"
-    ],
-    "tests/integration/management/test_budget_updates.py::test_shortening_budget_duration_moves_reset_at_onto_the_new_schedule": [
-      "mgmt.budget.update.duration_change_recomputes_reset_at"
-    ],
-    "tests/integration/management/test_organization_budget_clear.py::test_patch_organization_update_with_null_tpm_limit_clears_it_and_keeps_sibling_limits": [
-      "mgmt.organization.update.null_clears_budget_limit"
-    ],
-    "tests/integration/management/test_team_budget_duration_defaults.py::test_team_new_explicit_null_budget_duration_is_not_replaced_by_default": [
-      "mgmt.team.new.explicit_null_budget_duration_overrides_default"
-    ],
-    "tests/integration/management/test_team_member_budget_cache.py::test_team_member_default_budget_lands_in_redis_after_first_member_call": [
-      "mgmt.team_member_budget.default_budget_is_cached_in_redis_as_json"
-    ],
-    "tests/integration/observability/test_callback_delivery.py::test_streamed_responses_success_callback_carries_provider_apim_request_id": [
-      "other.observability.callbacks.streamed_responses_events_carry_provider_response_headers"
-    ],
-    "tests/integration/observability/test_guardrail_effects.py::test_bedrock_passthrough_converse_guardrail_ignores_denied_term_in_tool_definition": [
-      "other.observability.guardrails.bedrock_passthrough_converse_scans_only_caller_content"
-    ],
-    "tests/integration/pricing/test_configured_prices.py::test_cost_estimate_reports_configured_prices_for_model_absent_from_cost_map": [
-      "quota_management.cost_estimate.configured_price.reported_for_model_absent_from_cost_map"
-    ],
-    "tests/integration/pricing/test_configured_prices.py::test_saving_echoed_model_info_does_not_freeze_cost_map_price_into_deployment": [
-      "pricing.model_update.echoed_cost_map_price_is_not_persisted_as_override"
-    ],
-    "tests/integration/pricing/test_databricks_cache_pricing.py::test_databricks_cached_prompt_tokens_bill_at_cache_rates_not_input_rate": [
-      "pricing.databricks.cached_prompt_tokens_bill_at_cache_rates"
-    ],
-    "tests/integration/pricing/test_ocr_page_pricing.py::test_ocr_annotation_pages_are_billed_at_annotation_cost_per_page": [
-      "pricing.ocr.annotation_pages_billed_at_annotation_rate"
-    ],
-    "tests/integration/pricing/test_service_tier_pricing.py::test_ultrafast_service_tier_bills_ultrafast_rates_and_keeps_pricing_off_the_wire": [
-      "quota_management.spend_tracking.service_tier_pricing.ultrafast_bills_ultrafast_rates"
-    ],
-    "tests/integration/spend/test_batch_completion_accounting.py::test_completed_batch_spend_row_records_reasoning_tokens_and_error_file_failures": [
-      "quota_management.spend_tracking.batch_costs.reasoning_tokens_and_error_file_failures_recorded"
-    ],
-    "tests/integration/spend/test_batch_observability.py::test_batch_retrieval_row_sums_reasoning_tokens_and_counts_output_and_error_file_failures": [
-      "spend.batches.retrieval_row_aggregates_reasoning_tokens_and_per_request_counts"
-    ],
-    "tests/integration/spend/test_batch_poll_starvation.py::test_batches_gone_at_provider_do_not_starve_a_newer_batch_out_of_cost_polling": [
-      "quota_management.spend_tracking.batch_costs.uncostable_rows_retire_so_newer_batches_are_costed"
-    ],
-    "tests/integration/spend/test_cache_and_quota.py::test_in_flight_count_tokens_does_not_reserve_key_budget_away_from_a_completion": [
-      "quota_management.budget.key.in_flight_count_tokens_reserves_nothing_so_completion_reaches_provider"
-    ],
-    "tests/integration/spend/test_cache_and_quota.py::test_repeated_count_tokens_on_budgeted_key_does_not_reserve_budget_or_block_later_completion": [
-      "quota_management.budget.key.count_tokens_reserves_nothing_so_completion_within_budget_succeeds"
-    ],
-    "tests/integration/spend/test_daily_rollup_retry.py::test_failed_daily_user_rollup_commit_is_retried_so_spend_report_and_daily_activity_agree": [
-      "spend.daily_rollup.failed_user_commit_is_retried_until_report_and_daily_activity_agree"
-    ],
-    "tests/integration/spend/test_disconnected_bedrock_messages_stream_billing.py::test_client_disconnect_mid_bedrock_messages_stream_still_bills_terminal_usage": [
-      "spend.anthropic_messages_stream.client_disconnect_bills_terminal_bedrock_usage"
-    ],
-    "tests/integration/spend/test_failed_dispatch_tokens.py::test_provider_500_after_dispatch_records_estimated_prompt_tokens_on_failure_row": [
-      "spend.failed_dispatch.failure_row_records_estimated_input_tokens"
-    ],
-    "tests/integration/spend/test_model_router_selected_model.py::test_model_router_alias_without_router_in_name_keeps_selected_model_in_response_and_spend_log": [
-      "spend.model_router.selected_model_is_returned_and_persisted_for_plain_alias"
-    ],
-    "tests/integration/spend/test_org_budget_cli_session_token.py::test_cli_session_token_without_org_id_charges_and_caps_the_team_organization": [
-      "quota_management.organization_budget.cli_session_token_without_org_id_charges_team_organization"
-    ],
-    "tests/integration/spend/test_passthrough_budget_reservation.py::test_repeated_gemini_passthrough_calls_stay_served_while_key_spend_is_below_max_budget": [
-      "spend.budget_reservation.gemini_passthrough_success_releases_reservation_from_spend_counter"
-    ],
-    "tests/integration/spend/test_team_daily_activity_aggregated.py::test_aggregated_team_activity_reports_the_whole_range_team_spend_in_one_page": [
-      "quota_management.spend_tracking.team_daily_activity_aggregated_reports_whole_range_team_spend"
-    ],
-    "tests/integration/spend/test_team_member_spend.py::test_member_added_without_any_budget_is_charged_on_its_membership_row": [
-      "spend.team_member.member_without_budget_gets_membership_row_and_spend"
-    ],
-    "tests/integration/management/test_vector_store_config_ownership.py::test_config_store_is_listed_beside_db_store_and_survives_listing": [
-      "mgmt.vector_store.list.keeps_config_store_beside_db_stores"
-    ],
-    "tests/integration/management/test_vector_store_config_ownership.py::test_config_store_refuses_new_update_and_delete": [
-      "mgmt.vector_store.write.config_store_is_read_only"
-    ],
-    "tests/integration/management/test_vector_store_config_ownership.py::test_db_store_lifecycle_is_unchanged_beside_config_store": [
-      "mgmt.vector_store.write.db_store_lifecycle_unchanged_beside_config_store"
-    ],
-    "tests/integration/management/test_vector_store_config_ownership.py::test_chat_with_config_store_searches_upstream_and_injects_context_after_listing": [
-      "other.vector_store.chat.config_store_search_reaches_upstream_after_listing"
-    ],
-    "tests/integration/management/test_vector_store_config_ownership.py::test_passthrough_search_on_config_store_uses_yaml_credentials_after_listing": [
-      "other.vector_store.search.config_store_passthrough_uses_yaml_credentials_after_listing"
-    ],
-    "tests/integration/management/test_vector_store_config_ownership.py::test_non_admin_key_access_to_config_store_follows_grants_after_admin_listing": [
-      "authz.vector_store.list.non_admin_key_access_to_config_store_follows_grants"
-    ],
-    "tests/integration/management/test_vector_store_config_ownership.py::test_peer_process_keeps_config_store_and_sees_db_store_created_elsewhere": [
-      "mgmt.vector_store.list.peer_process_keeps_config_store_and_sees_db_store"
-    ],
-    "tests/integration/management/test_vector_store_config_ownership.py::test_concurrent_burst_keeps_config_store_and_refuses_every_config_write": [
-      "mgmt.vector_store.chaos.concurrent_burst_keeps_config_store_across_workers"
-    ],
-    "tests/integration/management/test_vector_store_config_ownership.py::test_redis_outage_keeps_config_store_served_and_recovers": [
-      "mgmt.vector_store.chaos.redis_outage_keeps_config_store_and_recovers"
-    ],
-    "tests/integration/providers/test_anthropic_advisor_wire.py::test_advisor_sub_call_reaches_the_router_deployment_with_its_key_instead_of_anthropic_unauthenticated": [
-      "providers.anthropic_messages_advisor.sub_call_uses_the_configured_advisor_deployment"
-    ],
-    "tests/integration/providers/test_azure_ai_chat_wire.py::test_azure_ai_strips_thinking_blocks_and_cache_control_from_forwarded_messages": [
-      "providers.azure_ai.anthropic_message_fields_are_stripped_before_foundry"
-    ],
-    "tests/integration/providers/test_azure_ai_flux2_image_wire.py::test_azure_flux2_flex_generation_hits_flex_provider_path_not_pro": [
-      "other.provider_wire.azure_ai.flux2_flex_generation_targets_flex_path_with_bfl_body"
-    ],
-    "tests/integration/providers/test_azure_ai_rerank_auth_wire.py::test_azure_ai_rerank_with_entra_token_and_no_api_key_sends_bearer_to_provider": [
-      "other.provider_wire.azure_ai.rerank_entra_token_without_api_key_reaches_provider"
-    ],
-    "tests/integration/providers/test_bedrock_auth_wire.py::test_client_anthropic_oauth_authorization_header_does_not_replace_bedrock_sigv4_signature": [
-      "providers.bedrock_auth.client_anthropic_oauth_token_never_replaces_sigv4_authorization"
-    ],
-    "tests/integration/providers/test_bedrock_batch_files_wire.py::test_completions_and_responses_batch_records_upload_as_anthropic_user_messages": [
-      "other.provider_wire.bedrock.batch_file_completions_and_responses_records_reach_s3_as_user_messages"
-    ],
-    "tests/integration/providers/test_bedrock_claude_thinking_wire.py::test_prefixed_opus_4_8_reasoning_effort_reaches_bedrock_as_adaptive_thinking_not_budget_tokens": [
-      "other.provider_wire.bedrock.prefixed_opus_4_8_reasoning_effort_sends_adaptive_thinking"
-    ],
-    "tests/integration/providers/test_bedrock_converse_config_blocks_wire.py::test_guardrail_and_performance_config_are_not_duplicated_inside_inference_config": [
-      "other.provider_wire.bedrock.converse_config_blocks_sent_once_at_top_level"
-    ],
-    "tests/integration/providers/test_bedrock_embedding_wire.py::test_cohere_embed_english_v3_accepts_encoding_format_and_dimensions": [
-      "other.provider_wire.bedrock.cohere_embed_english_v3_accepts_encoding_format"
-    ],
-    "tests/integration/providers/test_bedrock_gpt5_reasoning_wire.py::test_gpt5_reasoning_effort_is_accepted_and_sent_as_converse_reasoning_effort": [
-      "providers.bedrock_converse.gpt5_reasoning_effort_reaches_provider_as_reasoning_effort"
-    ],
-    "tests/integration/providers/test_bedrock_invoke_tool_search_wire.py::test_gen5_claude_bedrock_invoke_messages_tool_search_sends_bedrock_beta_field": [
-      "providers.bedrock_invoke.tool_search_gen5_claude_sends_bedrock_beta_and_reports_support"
-    ],
-    "tests/integration/providers/test_bedrock_mantle_codex_input_wire.py::test_codex_agent_message_context_compaction_and_local_shell_call_reach_mantle_as_supported_items": [
-      "other.provider_wire.bedrock_mantle.codex_history_items_reach_mantle_as_supported_types"
-    ],
-    "tests/integration/providers/test_bedrock_mantle_responses_wire.py::test_codex_agent_message_compaction_and_local_shell_items_are_rewritten_for_mantle": [
-      "providers.bedrock_mantle.codex_history_items_reach_the_wire_as_supported_input_items"
-    ],
-    "tests/integration/providers/test_bedrock_mantle_wire.py::test_bedrock_mantle_context_overflow_returns_400_saying_prompt_is_too_long": [
-      "other.provider_wire.bedrock_mantle.context_overflow_is_reported_as_prompt_too_long"
-    ],
-    "tests/integration/providers/test_bedrock_messages_web_search_replay_wire.py::test_replayed_intercepted_web_search_turn_reaches_bedrock_as_text_and_answers": [
-      "providers.bedrock_messages.replayed_intercepted_web_search_turn_is_flattened_to_text"
-    ],
-    "tests/integration/providers/test_bedrock_passthrough_stream_wire.py::test_bedrock_passthrough_converse_stream_response_carries_event_stream_content_type": [
-      "other.provider_wire.bedrock.passthrough_stream_keeps_event_stream_content_type"
-    ],
-    "tests/integration/providers/test_bedrock_rerank_wire.py::test_forwarded_client_header_on_rerank_is_excluded_from_the_sigv4_signature": [
-      "providers.bedrock_rerank.forwarded_client_headers_are_sent_unsigned"
-    ],
-    "tests/integration/providers/test_bedrock_thinking_tokens_wire.py::test_bedrock_redacted_thinking_is_not_reported_as_zero_reasoning_tokens": [
-      "other.provider_wire.bedrock.hidden_thinking_tokens_are_not_reported_as_text"
-    ],
-    "tests/integration/providers/test_dashscope_chat_wire.py::test_dashscope_chat_forwards_reasoning_effort_none_to_the_provider": [
-      "other.provider_wire.dashscope.reasoning_effort_reaches_provider"
-    ],
-    "tests/integration/providers/test_databricks_chat_wire.py::test_databricks_stream_final_usage_chunk_reaches_client_and_spend_log": [
-      "other.provider_wire.databricks.stream_usage_and_cache_reads_reach_client_and_spend_log"
-    ],
-    "tests/integration/providers/test_databricks_oauth_wire.py::test_databricks_ai_gateway_api_base_requests_oauth_token_from_workspace_origin": [
-      "other.provider_wire.databricks.oauth_token_url_uses_workspace_origin_for_ai_gateway_api_base"
-    ],
-    "tests/integration/providers/test_deepseek_vision_wire.py::test_deepseek_vision_forwards_image_url_content_list_instead_of_collapsing_to_text": [
-      "other.provider_wire.deepseek.vision_image_content_list_reaches_provider"
-    ],
-    "tests/integration/providers/test_fireworks_ai_router_slug_wire.py::test_fireworks_router_slug_chat_sends_router_resource_not_models_path": [
-      "other.provider_wire.fireworks_ai.router_slug_chat_sends_router_resource_name"
-    ],
-    "tests/integration/providers/test_fireworks_ai_router_slug_wire.py::test_fireworks_router_slug_text_completion_sends_router_resource_not_models_path": [
-      "other.provider_wire.fireworks_ai.router_slug_text_completion_sends_router_resource_name"
-    ],
-    "tests/integration/providers/test_openai_chat_wire.py::test_openai_chat_tool_choice_without_tools_is_not_forwarded": [
-      "providers.openai_chat_wire.tool_choice_without_tools_is_dropped_before_the_wire"
-    ],
-    "tests/integration/providers/test_openai_image_edit_wire.py::test_openai_compatible_image_edit_forwards_seed_form_field_to_backend": [
-      "other.provider_wire.openai.image_edit_forwards_provider_specific_form_fields"
-    ],
-    "tests/integration/providers/test_responses_bridge_incomplete.py::test_chat_over_responses_deployment_returns_length_when_output_tokens_run_out": [
-      "other.provider_wire.responses_bridge.max_output_tokens_incomplete_maps_to_length"
-    ],
-    "tests/integration/providers/test_tencent_chat_wire.py::test_tencent_thinking_is_sent_in_provider_body_instead_of_failing_the_request[reasoning_effort_none]": [
-      "other.provider_wire.tencent.thinking_reaches_provider_in_request_body"
-    ],
-    "tests/integration/providers/test_tencent_chat_wire.py::test_tencent_thinking_is_sent_in_provider_body_instead_of_failing_the_request[thinking_enabled]": [
-      "other.provider_wire.tencent.thinking_reaches_provider_in_request_body"
-    ],
-    "tests/integration/providers/test_websearch_interception_wire.py::test_capped_websearch_interception_loop_ends_turn_instead_of_exposing_internal_tool_use": [
-      "other.provider_wire.anthropic.websearch_interception_capped_loop_ends_turn_without_internal_tool_use"
-    ],
-    "tests/integration/providers/test_websearch_interception_wire.py::test_streamed_web_search_turn_capped_by_max_agentic_loops_ends_turn_with_snippets_and_ordered_blocks": [
-      "other.provider_wire.bedrock.websearch_interception_streamed_capped_turn_ends_with_native_results"
-    ],
-    "tests/integration/providers/test_xai_web_search_wire.py::test_xai_chat_web_search_is_sent_to_responses_with_instructions_and_nested_filters": [
-      "other.provider_wire.xai.chat_web_search_reaches_responses_with_instructions_and_filters"
-    ],
-    "tests/integration/routing/test_priority_rate_limit_headers.py::test_non_streaming_v1_messages_success_carries_v3_priority_rate_limit_headers": [
-      "other.routing.priority_rate_limits.v1_messages_success_exposes_v3_priority_headers"
-    ],
-    "tests/integration/routing/test_stale_cost_map_boot.py::test_config_deployment_dropped_by_stale_boot_cost_map_is_restored_after_reload": [
-      "other.routing.cost_map.config_deployment_dropped_by_stale_boot_map_is_restored_after_reload"
-    ],
-    "tests/integration/streaming/test_stream_contracts.py::test_messages_stream_completes_through_trailing_empty_choices_usage_chunk": [
-      "other.streaming.messages_bridge.empty_choices_usage_chunk_completes_stream"
-    ],
-    "tests/integration/streaming/test_stream_contracts.py::test_perplexity_stream_with_cost_breakdown_object_completes_and_bills_total_cost": [
-      "other.streaming.usage.provider_cost_object_completes_stream_and_bills_total_cost"
-    ],
-    "tests/integration/streaming/test_stream_contracts.py::test_primary_stream_with_empty_first_chunk_then_disconnect_falls_back_and_bills_the_fallback": [
-      "other.streaming.fallback.empty_leading_chunk_then_disconnect_streams_fallback_with_usage_and_spend"
-    ],
-    "tests/integration/streaming/test_stream_contracts.py::test_responses_stream_completes_through_empty_choices_metadata_and_usage_chunks": [
-      "other.streaming.responses_bridge.empty_choices_chunks_complete_stream"
-    ],
-    "tests/integration/streaming/test_stream_parallel_slot_release.py::test_failing_stream_logging_callback_does_not_leak_max_parallel_requests_slot": [
-      "streaming.max_parallel_requests.slot_released_when_stream_logging_callback_fails"
-    ],
-    "tests/integration/streaming/test_ttft_keepalive.py::test_stream_emits_sse_ping_comments_before_the_first_data_frame_while_upstream_is_silent": [
-      "streaming.keepalive.sse_pings_fill_silent_time_to_first_token"
-    ],
-    "tests/integration/observability/test_callback_delivery.py::test_response_survives_raising_success_deployment_hook[chat]": [
-      "other.observability.callbacks.raising_success_deployment_hook_keeps_response"
-    ],
-    "tests/integration/observability/test_callback_delivery.py::test_response_survives_raising_success_deployment_hook[embeddings]": [
-      "other.observability.callbacks.raising_success_deployment_hook_keeps_response"
-    ],
-    "tests/integration/observability/test_callback_delivery.py::test_response_survives_raising_success_deployment_hook[responses]": [
-      "other.observability.callbacks.raising_success_deployment_hook_keeps_response"
-    ],
-    "tests/integration/observability/test_callback_delivery.py::test_response_survives_raising_success_deployment_hook[videos]": [
-      "other.observability.callbacks.raising_success_deployment_hook_keeps_response"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_chat_completion_sdk_body_litellm_session_id_lands_as_conversation_id": [
-      "other.observability.otel.conversation_id_from_body_session_id_chat_sdk"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_chat_stream_async_sdk_x_litellm_session_id_header_lands_as_conversation_id": [
-      "other.observability.otel.conversation_id_from_header_chat_stream_async_sdk"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_messages_sdk_x_litellm_session_id_header_lands_as_conversation_id": [
-      "other.observability.otel.conversation_id_from_header_messages_sdk"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_messages_stream_async_sdk_langfuse_session_id_header_lands_as_conversation_id": [
-      "other.observability.otel.conversation_id_from_langfuse_header_messages_stream_async_sdk"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_responses_sdk_x_litellm_session_id_header_lands_as_conversation_id": [
-      "other.observability.otel.conversation_id_from_header_responses_sdk"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_responses_stream_raw_metadata_session_id_lands_as_conversation_id": [
-      "other.observability.otel.conversation_id_from_metadata_responses_stream_raw"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_chat_raw_metadata_session_id_lands_as_conversation_id": [
-      "other.observability.otel.conversation_id_from_metadata_chat_raw"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_integer_and_list_litellm_session_id_match_the_spend_row_or_are_dropped_together": [
-      "other.observability.otel.conversation_id_non_string_session_ids_match_spend_row"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_empty_string_litellm_session_id_leaves_the_span_without_a_conversation_id": [
-      "other.observability.otel.conversation_id_empty_string_session_id_is_omitted"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_five_kilobyte_session_header_round_trips_to_the_span_and_the_spend_row": [
-      "other.observability.otel.conversation_id_five_kilobyte_header_round_trips"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_duplicate_session_header_lands_once_and_unchanged": [
-      "other.observability.otel.conversation_id_duplicate_header_lands_once"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_unauthenticated_request_with_session_header_is_rejected_and_leaves_no_span": [
-      "other.observability.otel.conversation_id_unauthenticated_request_leaves_no_span"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_sink_rejecting_with_403_drops_those_spans_and_later_spans_still_land": [
-      "other.observability.otel.conversation_id_survives_sink_rejection"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_request_without_any_session_input_has_no_conversation_id": [
-      "other.observability.otel.conversation_id_absent_without_caller_session"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_generate_policy_minted_session_id_reaches_the_spend_row_but_not_the_span": [
-      "other.observability.otel.conversation_id_ignores_generated_session_id"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_generate_policy_keeps_the_langfuse_session_header_as_conversation_id": [
-      "other.observability.otel.conversation_id_langfuse_header_wins_over_generated"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_header_body_and_metadata_session_ids_resolve_to_the_same_id_as_the_spend_row": [
-      "other.observability.otel.conversation_id_header_precedence_matches_spend_row"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_three_identical_requests_produce_one_span_each_with_the_same_conversation_id": [
-      "other.observability.otel.conversation_id_repeated_requests_log_once_each"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_metadata_trace_id_alone_fills_the_spend_row_but_not_the_span": [
-      "other.observability.otel.conversation_id_ignores_trace_id_backfill"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_sink_outage_during_a_mixed_burst_lands_every_response_exactly_once_after_recovery": [
-      "other.observability.otel.conversation_id_sink_outage_recovers_exactly_once"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_slow_sink_during_a_burst_lands_every_response_exactly_once": [
-      "other.observability.otel.conversation_id_slow_sink_no_duplicates"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_killing_one_of_two_workers_mid_burst_keeps_serving_and_never_duplicates_a_span": [
-      "other.observability.otel.conversation_id_survives_worker_kill"
-    ],
-    "tests/integration/observability/test_otel_conversation_id.py::test_terminating_the_proxy_right_after_a_burst_flushes_every_span_before_exit": [
-      "other.observability.otel.conversation_id_flushes_on_shutdown"
-    ],
-    "tests/integration/management/test_user_updates_wedged_coordination_redis.py::test_user_budget_updates_return_promptly_while_coordination_redis_is_wedged": [
-      "mgmt.user.update.budget_change_returns_promptly_with_wedged_coordination_redis",
-      "mgmt.user.bulk_update.budget_change_returns_promptly_with_wedged_coordination_redis",
-      "mgmt.customer.update.budget_change_returns_promptly_with_wedged_coordination_redis",
-      "mgmt.key.reset_spend.returns_promptly_with_wedged_coordination_redis",
-      "mgmt.auth_cache_invalidation.publish_parked_by_short_redis_wedge_lands_after_recovery",
-      "mgmt.auth_cache_invalidation.burst_with_worker_kill_keeps_serving_while_redis_wedged"
-    ]
-  },
-  "browser": {
-    "tests/e2e/ui/tests/integrationCritical/projectDetachment.spec.ts::project creation and explicit detachment preserve saved scope and restore serving": [
-      "mgmt.key.ui.project_create_clear_preserves_serving_scope"
-    ]
-  }
-}
diff --git a/tests/integration/database/test_migration_entrypoint.py b/tests/integration/database/test_migration_entrypoint.py
new file mode 100644
index 000000000000..19c480b95314
--- /dev/null
+++ b/tests/integration/database/test_migration_entrypoint.py
@@ -0,0 +1,99 @@
+import os
+import shutil
+import subprocess
+import sys
+import uuid
+from collections.abc import Iterator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Final
+from urllib.parse import urlsplit, urlunsplit
+
+import psycopg
+import pytest
+from integration._support.client import Gateway
+from integration._support.process import owned_proxy
+from psycopg import sql
+from psycopg.rows import dict_row
+
+REPO_ROOT: Final = Path(__file__).resolve().parents[3]
+PRISMA_DIR: Final = REPO_ROOT / "litellm-proxy-extras" / "litellm_proxy_extras"
+MISSING_MIGRATION: Final = "20260626120000_add_mcp_tool_search_enabled"
+SHIPPED_MIGRATIONS: Final = tuple(sorted(path.name for path in (PRISMA_DIR / "migrations").iterdir() if path.is_dir()))
+
+
+@contextmanager
+def fresh_database() -> Iterator[str]:
+    name: Final = f"integration_upgrade_{uuid.uuid4().hex}"
+    admin_url: Final = os.environ["DATABASE_URL"]
+    parsed: Final = urlsplit(admin_url)
+    with psycopg.connect(admin_url, autocommit=True) as admin:
+        admin.execute(sql.SQL("CREATE DATABASE {}").format(sql.Identifier(name)))
+        try:
+            yield urlunsplit(parsed._replace(path=f"/{name}"))
+        finally:
+            admin.execute(sql.SQL("DROP DATABASE {} WITH (FORCE)").format(sql.Identifier(name)))
+
+
+def deploy_older_schema(database_url: str, directory: Path) -> None:
+    older: Final = directory / "older-release"
+    (older / "migrations").mkdir(parents=True)
+    shutil.copy(PRISMA_DIR / "schema.prisma", older / "schema.prisma")
+    shutil.copy(PRISMA_DIR / "migrations" / "migration_lock.toml", older / "migrations" / "migration_lock.toml")
+    for name in (name for name in SHIPPED_MIGRATIONS if name < MISSING_MIGRATION):
+        shutil.copytree(PRISMA_DIR / "migrations" / name, older / "migrations" / name)
+    subprocess.run(
+        [sys.executable, "-I", "-m", "prisma", "migrate", "deploy", "--schema", str(older / "schema.prisma")],
+        check=True,
+        capture_output=True,
+        text=True,
+        timeout=300,
+        env={**os.environ, "DATABASE_URL": database_url},
+    )
+
+
+def applied_migrations(database_url: str) -> tuple[str, ...]:
+    with psycopg.connect(database_url, row_factory=dict_row) as connection:
+        rows: Final = connection.execute(
+            'SELECT migration_name FROM "_prisma_migrations" '
+            "WHERE finished_at IS NOT NULL AND rolled_back_at IS NULL ORDER BY migration_name"
+        ).fetchall()
+    return tuple(str(row["migration_name"]) for row in rows)
+
+
+def object_permission_columns(database_url: str) -> tuple[str, ...]:
+    with psycopg.connect(database_url, row_factory=dict_row) as connection:
+        rows: Final = connection.execute(
+            "SELECT column_name FROM information_schema.columns "
+            "WHERE table_name = 'LiteLLM_ObjectPermissionTable' AND column_name = 'mcp_tool_search_enabled'"
+        ).fetchall()
+    return tuple(str(row["column_name"]) for row in rows)
+
+
+@pytest.mark.covers("other.database.migrations.entrypoint_deploys_pending_migrations_before_startup")
+def test_migration_entrypoint_upgrades_an_older_schema_so_the_proxy_serves_mcp_tools(
+    gateway: Gateway, tmp_path: Path
+) -> None:
+    with fresh_database() as database_url:
+        deploy_older_schema(database_url, tmp_path)
+        assert object_permission_columns(database_url) == ()
+        assert applied_migrations(database_url) == tuple(
+            name for name in SHIPPED_MIGRATIONS if name < MISSING_MIGRATION
+        )
+        entrypoint: Final = subprocess.run(
+            [sys.executable, "-I", "-m", "litellm.proxy.prisma_migration"],
+            capture_output=True,
+            text=True,
+            timeout=300,
+            cwd=REPO_ROOT,
+            env={**os.environ, "DATABASE_URL": database_url},
+        )
+        assert entrypoint.returncode == 0, entrypoint.stdout + entrypoint.stderr
+        assert object_permission_columns(database_url) == ("mcp_tool_search_enabled",), entrypoint.stdout
+        assert applied_migrations(database_url) == SHIPPED_MIGRATIONS, entrypoint.stdout
+        with owned_proxy(
+            gateway, tmp_path, {"DATABASE_URL": database_url, "DISABLE_SCHEMA_UPDATE": "true"}
+        ) as upgraded:
+            tools: Final = upgraded.request("GET", "/mcp-rest/tools/list")
+            assert tools.status_code == 200, tools.text
+            assert tools.json()["tools"] == [], tools.text
diff --git a/tests/integration/management/test_guardrail_usage_config_guardrail.py b/tests/integration/management/test_guardrail_usage_config_guardrail.py
new file mode 100644
index 000000000000..b9ba795b89b6
--- /dev/null
+++ b/tests/integration/management/test_guardrail_usage_config_guardrail.py
@@ -0,0 +1,77 @@
+import uuid
+from pathlib import Path
+from typing import Final
+
+import pytest
+import yaml
+from pydantic import JsonValue
+
+from tests.integration._support.client import Gateway, object_value, string_value
+from tests.integration._support.process import owned_proxy
+
+WINDOW: Final = {"start_date": "2026-01-01", "end_date": "2026-01-07"}
+
+
+def listed_guardrail(gateway: Gateway, guardrail_name: str) -> dict[str, JsonValue]:
+    listed: Final = gateway.get("/v2/guardrails/list")["guardrails"]
+    assert isinstance(listed, list), listed
+    matches: Final = tuple(object_value(row) for row in listed if object_value(row)["guardrail_name"] == guardrail_name)
+    assert len(matches) == 1, f"{guardrail_name} appears {len(matches)} times in {listed}"
+    return matches[0]
+
+
+@pytest.mark.covers("mgmt.guardrails.usage.config_yaml_guardrail_has_detail_and_overview_row")
+def test_config_yaml_guardrail_is_served_by_usage_detail_and_overview(gateway: Gateway, tmp_path: Path) -> None:
+    guardrail_name: Final = "tool-permission-" + uuid.uuid4().hex
+    config: Final = yaml.safe_load(Path("tests/integration/proxy_config.yaml").read_text())
+    config["guardrails"] = [
+        {
+            "guardrail_name": guardrail_name,
+            "litellm_params": {
+                "guardrail": "tool_permission",
+                "mode": "post_call",
+                "default_on": False,
+                "rules": [{"id": "deny_delete", "tool_name": "(?i)^.*(delete|drop).*", "decision": "deny"}],
+                "default_action": "allow",
+                "on_disallowed_action": "block",
+            },
+            "guardrail_info": {"type": "Tool Permission", "description": "declared in config.yaml"},
+        }
+    ]
+    path: Final = tmp_path / "guardrail.yaml"
+    path.write_text(yaml.safe_dump(config))
+    with owned_proxy(gateway, tmp_path, {}, config=path) as candidate:
+        guardrail_id: Final = string_value(listed_guardrail(candidate, guardrail_name)["guardrail_id"])
+        detail: Final = candidate.request("GET", f"/guardrails/usage/detail/{guardrail_id}", params=WINDOW)
+        assert detail.status_code == 200, detail.text
+        body: Final = object_value(detail.json())
+        assert {
+            "guardrail_id": body["guardrail_id"],
+            "guardrail_name": body["guardrail_name"],
+            "provider": body["provider"],
+            "type": body["type"],
+            "description": body["description"],
+            "requestsEvaluated": body["requestsEvaluated"],
+            "failRate": body["failRate"],
+        } == {
+            "guardrail_id": guardrail_id,
+            "guardrail_name": guardrail_name,
+            "provider": "tool_permission",
+            "type": "Tool Permission",
+            "description": "declared in config.yaml",
+            "requestsEvaluated": 0,
+            "failRate": 0.0,
+        }, detail.text
+        overview: Final = candidate.request("GET", "/guardrails/usage/overview", params=WINDOW)
+        assert overview.status_code == 200, overview.text
+        rows: Final = object_value(overview.json())["rows"]
+        assert isinstance(rows, list), overview.text
+        config_rows: Final = tuple(object_value(row) for row in rows if object_value(row)["id"] == guardrail_id)
+        assert len(config_rows) == 1, overview.text
+        assert (config_rows[0]["name"], config_rows[0]["provider"], config_rows[0]["requestsEvaluated"]) == (
+            guardrail_name,
+            "tool_permission",
+            0,
+        ), overview.text
+        missing: Final = candidate.request("GET", f"/guardrails/usage/detail/{uuid.uuid4()}", params=WINDOW)
+        assert missing.status_code == 404, missing.text
diff --git a/tests/integration/management/test_model_credential_name_updates.py b/tests/integration/management/test_model_credential_name_updates.py
new file mode 100644
index 000000000000..b5e2c8d5da6d
--- /dev/null
+++ b/tests/integration/management/test_model_credential_name_updates.py
@@ -0,0 +1,136 @@
+import uuid
+from typing import Final
+
+import httpx
+import pytest
+from pydantic import JsonValue
+
+from tests.integration._support.client import JSON_OBJECT, Gateway, Scenario, object_value, string_value
+from tests.integration._support.database import read_rows
+
+
+def _dangling_credential(gateway: Gateway, scenario: Scenario) -> str:
+    name: Final = f"credential-{uuid.uuid4().hex}"
+    gateway.post(
+        "/credentials",
+        {"credential_name": name, "credential_values": {"api_key": "synthetic-credential"}, "credential_info": {}},
+    )
+    scenario.cleanups.callback(_delete_credential_if_present, gateway, name)
+    return name
+
+
+def _delete_credential_if_present(gateway: Gateway, name: str) -> None:
+    response: Final = gateway.request("DELETE", f"/credentials/{name}")
+    assert response.status_code in (200, 404), response.text
+
+
+def _delete_credential(gateway: Gateway, name: str) -> None:
+    response: Final = gateway.request("DELETE", f"/credentials/{name}")
+    assert response.status_code == 200, response.text
+    assert read_rows('SELECT credential_name FROM "LiteLLM_CredentialsTable" WHERE credential_name = %s', (name,)) == []
+
+
+def _model_with_credential(gateway: Gateway, scenario: Scenario, credential: str, **model_info: JsonValue) -> str:
+    created: Final = gateway.post(
+        "/model/new",
+        {
+            "model_name": f"integration-{uuid.uuid4().hex}",
+            "litellm_params": {
+                "model": "openai/gpt-4o-mini",
+                "api_base": f"{gateway.upstream_url}/v1",
+                "litellm_credential_name": credential,
+                "rpm": 5,
+            },
+            "model_info": dict(model_info),
+        },
+    )
+    identity: Final = string_value(object_value(created["model_info"])["id"])
+    scenario.cleanups.callback(scenario.delete_model, identity)
+    return identity
+
+
+def _stored_params(gateway: Gateway, identity: str) -> dict[str, JsonValue]:
+    entries: Final = gateway.get("/model/info", {"litellm_model_id": identity})["data"]
+    assert isinstance(entries, list) and len(entries) == 1, entries
+    return object_value(object_value(entries[0])["litellm_params"])
+
+
+def _error(response: httpx.Response) -> dict[str, JsonValue]:
+    return object_value(JSON_OBJECT.validate_json(response.content)["error"])
+
+
+@pytest.mark.covers("mgmt.model.update.unchanged_credential_name_is_not_revalidated")
+def test_unrelated_patch_succeeds_when_resent_credential_name_is_dangling(gateway: Gateway) -> None:
+    with gateway.scenario() as scenario:
+        credential: Final = _dangling_credential(gateway, scenario)
+        identity: Final = _model_with_credential(gateway, scenario, credential)
+        _delete_credential(gateway, credential)
+        before: Final = _stored_params(gateway, identity)
+        assert before["litellm_credential_name"] == credential
+        assert before["rpm"] == 5
+        patched: Final = gateway.request(
+            "PATCH",
+            f"/model/{identity}/update",
+            {"litellm_params": {"litellm_credential_name": before["litellm_credential_name"], "rpm": 7}},
+        )
+        assert patched.status_code == 200, patched.text
+        after: Final = _stored_params(gateway, identity)
+        assert after == {**before, "rpm": 7}
+
+
+@pytest.mark.covers(
+    "mgmt.model.update.non_admin_detach_is_rejected",
+    "mgmt.model.update.empty_credential_name_is_rejected",
+)
+def test_non_admin_detach_and_empty_credential_name_still_rejected(gateway: Gateway) -> None:
+    with gateway.scenario() as scenario:
+        credential: Final = _dangling_credential(gateway, scenario)
+        user: Final = scenario.user(user_role="internal_user")
+        team: Final = scenario.team(members_with_roles=[{"user_id": user, "role": "admin"}])
+        team_admin: Final = scenario.key(user_id=user, team_id=team)
+        identity: Final = _model_with_credential(gateway, scenario, credential, team_id=team)
+        before: Final = _stored_params(gateway, identity)
+        detached: Final = gateway.request(
+            "PATCH", f"/model/{identity}/update", {"litellm_params": {"litellm_credential_name": None}}, key=team_admin
+        )
+        assert detached.status_code == 403, detached.text
+        assert _error(detached) == {
+            "message": "Only a proxy admin can detach a stored credential (litellm_credential_name) on a model. "
+            "Your role=internal_user.",
+            "type": "auth_error",
+            "param": "litellm_credential_name",
+            "code": "403",
+        }
+        emptied: Final = gateway.request(
+            "PATCH", f"/model/{identity}/update", {"litellm_params": {"litellm_credential_name": ""}}
+        )
+        assert emptied.status_code == 400, emptied.text
+        assert _error(emptied) == {
+            "message": "litellm_credential_name cannot be an empty string. Send null to detach the stored credential "
+            "or omit the field to leave it unchanged.",
+            "type": "validation_error",
+            "param": "litellm_credential_name",
+            "code": "400",
+        }
+        assert _stored_params(gateway, identity) == before
+
+
+@pytest.mark.covers("mgmt.model.update.changed_missing_credential_name_is_rejected")
+def test_changing_credential_name_to_missing_credential_is_rejected(gateway: Gateway) -> None:
+    with gateway.scenario() as scenario:
+        credential: Final = _dangling_credential(gateway, scenario)
+        identity: Final = _model_with_credential(gateway, scenario, credential)
+        _delete_credential(gateway, credential)
+        before: Final = _stored_params(gateway, identity)
+        missing: Final = f"credential-{uuid.uuid4().hex}"
+        rejected: Final = gateway.request(
+            "PATCH", f"/model/{identity}/update", {"litellm_params": {"litellm_credential_name": missing, "rpm": 7}}
+        )
+        assert rejected.status_code == 400, rejected.text
+        assert _error(rejected) == {
+            "message": f"Credential '{missing}' not found. Create it via /credentials before attaching it to a model.",
+            "type": "validation_error",
+            "param": "litellm_credential_name",
+            "code": "400",
+        }
+        assert _stored_params(gateway, identity) == before
diff --git a/tests/integration/mcp/test_mcp_access_matrix.py b/tests/integration/mcp/test_mcp_access_matrix.py
new file mode 100644
index 000000000000..13759ce245c0
--- /dev/null
+++ b/tests/integration/mcp/test_mcp_access_matrix.py
@@ -0,0 +1,124 @@
+import uuid
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.mcp import (
+    ENTRY_POINTS,
+    EntryPoint,
+    McpCaller,
+    McpPeer,
+    PeerKind,
+    peer_of,
+    register_mcp,
+    tool_calls,
+)
+from integration._support.mcp_grants import SUBJECTS, Subject, grant
+
+CALLABLE: Final = {"add": {"a": 1, "b": 2}, "multiply": {"a": 2, "b": 3}}
+RESULTS: Final = {"add": "3", "multiply": "6"}
+
+
+def _server_scoped(entry: EntryPoint, identity: str) -> str | None:
+    return identity if entry == "rest" else None
+
+
+def _name(entry: EntryPoint, alias: str, tool: str) -> str:
+    return tool if entry == "rest" else f"{alias}-{tool}"
+
+
+def _assert_denied(caller: McpCaller, peer: McpPeer, name: str, identity: str, entry: EntryPoint) -> None:
+    peer.drain()
+    outcome: Final = caller.call(name, CALLABLE["add"], _server_scoped(entry, identity))
+    assert outcome.error is not None, f"denied call succeeded: {outcome.raw}"
+    assert outcome.text not in RESULTS.values(), outcome.raw
+    assert tool_calls(peer.drain()) == (), "denied call reached the peer"
+
+
+@pytest.mark.parametrize("entry", ENTRY_POINTS)
+@pytest.mark.parametrize("subject", SUBJECTS)
+@pytest.mark.parametrize("peer_kind", ("http", "sse"))
+def test_subject_grant_lists_only_reachable_tools_and_denies_the_rest(
+    gateway: Gateway, peer_kind: PeerKind, subject: Subject, entry: EntryPoint
+) -> None:
+    with peer_of(peer_kind) as granted_peer, peer_of(peer_kind) as denied_peer, gateway.scenario() as scenario:
+        group: Final = "grp" + uuid.uuid4().hex[:8]
+        granted_alias: Final = "yes" + uuid.uuid4().hex[:8]
+        denied_alias: Final = "no" + uuid.uuid4().hex[:8]
+        granted: Final = register_mcp(scenario, granted_peer, granted_alias, mcp_access_groups=[group])
+        denied: Final = register_mcp(scenario, denied_peer, denied_alias)
+        caller: Final = grant(
+            scenario, subject, (granted,), (granted, denied), access_group=group, allowed_tools={granted: ("add",)}
+        )
+        reach: Final = McpCaller(gateway, caller.key, entry, granted_alias, caller.headers)
+        listed: Final = reach.list_tools(_server_scoped(entry, granted))
+        assert listed.ok, listed.raw
+        expected: Final = (
+            {_name(entry, granted_alias, "add")}
+            if subject in ("toolset", "allowed_tools")
+            else {_name(entry, granted_alias, tool) for tool in ("add", "multiply", "fail")}
+        )
+        assert set(listed.tools) == expected, listed.tools
+        for tool, arguments in CALLABLE.items():
+            name: Final = _name(entry, granted_alias, tool)
+            if name not in listed.tools:
+                continue
+            granted_peer.drain()
+            outcome: Final = reach.call(name, arguments, _server_scoped(entry, granted))
+            assert outcome.ok and outcome.text == RESULTS[tool], outcome.raw
+            assert [call["body"]["params"]["name"] for call in tool_calls(granted_peer.drain())] == [tool]
+        if subject in ("toolset", "allowed_tools"):
+            _assert_denied(reach, granted_peer, _name(entry, granted_alias, "multiply"), granted, entry)
+        blocked: Final = McpCaller(gateway, caller.key, entry, denied_alias, caller.headers)
+        _assert_denied(blocked, denied_peer, _name(entry, denied_alias, "add"), denied, entry)
+        denied_listed: Final = blocked.list_tools(_server_scoped(entry, denied))
+        if entry == "rest":
+            assert denied_listed.status == 403 and "access_denied" in denied_listed.raw, denied_listed.raw
+            assert denied_listed.tools == ()
+        else:
+            assert not any(name.startswith(denied_alias) for name in denied_listed.tools), denied_listed.tools
+
+
+@pytest.mark.parametrize("entry", ("mcp", "server_mcp", "rest"))
+def test_key_without_any_grant_sees_no_scoped_server(gateway: Gateway, entry: EntryPoint) -> None:
+    with peer_of("http") as peer, gateway.scenario() as scenario:
+        alias: Final = "none" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias)
+        other: Final = scenario.key(object_permission={"mcp_servers": ["no-mcp-servers"]})
+        caller: Final = McpCaller(gateway, other, entry, alias)
+        _assert_denied(caller, peer, _name(entry, alias, "add"), identity, entry)
+        listed: Final = caller.list_tools(_server_scoped(entry, identity))
+        assert not any(name.startswith(alias) for name in listed.tools), listed.tools
+
+
+@pytest.mark.parametrize("entry", ("mcp", "server_mcp", "rest", "root", "sse"))
+def test_missing_or_wrong_key_is_rejected_before_the_peer(gateway: Gateway, entry: EntryPoint) -> None:
+    with peer_of("http") as peer, gateway.scenario() as scenario:
+        alias: Final = "anon" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias)
+        for key in (None, "sk-integration-wrong-" + uuid.uuid4().hex):
+            caller: Final = McpCaller(gateway, key, entry, alias)
+            peer.drain()
+            outcome: Final = caller.call(_name(entry, alias, "add"), CALLABLE["add"], _server_scoped(entry, identity))
+            assert outcome.status in (401, 403) or outcome.error is not None, outcome.raw
+            assert outcome.text not in RESULTS.values(), outcome.raw
+            assert tool_calls(peer.drain()) == ()
+
+
+def test_same_tool_name_on_two_servers_routes_by_prefix(gateway: Gateway) -> None:
+    with peer_of("http") as first, peer_of("sse") as second, gateway.scenario() as scenario:
+        first_alias: Final = "one" + uuid.uuid4().hex[:8]
+        second_alias: Final = "two" + uuid.uuid4().hex[:8]
+        first_id: Final = register_mcp(scenario, first, first_alias)
+        second_id: Final = register_mcp(scenario, second, second_alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [first_id, second_id]})
+        caller: Final = McpCaller(gateway, key, "mcp", None)
+        listed: Final = caller.list_tools()
+        assert listed.ok and len(listed.tools) == len(set(listed.tools)) == 6, listed.tools
+        assert {f"{first_alias}-add", f"{second_alias}-add"} <= set(listed.tools)
+        first.drain()
+        second.drain()
+        outcome: Final = caller.call(f"{second_alias}-add", {"a": 5, "b": 5})
+        assert outcome.ok and outcome.text == "10", outcome.raw
+        assert tool_calls(first.drain()) == ()
+        assert [call["body"]["params"]["name"] for call in tool_calls(second.drain())] == ["add"]
diff --git a/tests/integration/mcp/test_mcp_accounting_guardrails.py b/tests/integration/mcp/test_mcp_accounting_guardrails.py
new file mode 100644
index 000000000000..4daa2c93fa19
--- /dev/null
+++ b/tests/integration/mcp/test_mcp_accounting_guardrails.py
@@ -0,0 +1,197 @@
+import uuid
+from collections.abc import Iterator
+from contextlib import contextmanager
+from hashlib import sha256
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway, JsonValue, Scenario, eventually
+from integration._support.database import read_rows
+from integration._support.mcp import (
+    ENTRY_POINTS,
+    EntryPoint,
+    McpCaller,
+    McpPeer,
+    Outcome,
+    mcp_peer,
+    register_mcp,
+    tool_calls,
+)
+
+DEFAULT_COST: Final = 0.25
+ADD_COST: Final = 0.5
+FORBIDDEN: Final = "forbidden-integration-word"
+SPEND_ROWS: Final = (
+    'SELECT call_type, model, spend, status, metadata FROM "LiteLLM_SpendLogs" WHERE api_key = %s ORDER BY "startTime"'
+)
+
+
+def _digest(key: str) -> str:
+    return sha256(key.encode()).hexdigest()
+
+
+def _rows(key: str, count: int) -> list[dict[str, JsonValue]]:
+    return eventually(lambda: read_rows(SPEND_ROWS, (_digest(key),)), lambda rows: len(rows) >= count, seconds=70)
+
+
+def _priced_server(scenario: Scenario, peer: McpPeer, alias: str) -> str:
+    return register_mcp(
+        scenario,
+        peer,
+        alias,
+        mcp_info={
+            "server_name": alias,
+            "mcp_server_cost_info": {
+                "default_cost_per_query": DEFAULT_COST,
+                "tool_name_to_cost_per_query": {"add": ADD_COST},
+            },
+        },
+    )
+
+
+def _tool_metadata(row: dict[str, JsonValue]) -> dict[str, JsonValue]:
+    metadata: Final = row["metadata"]
+    assert isinstance(metadata, dict), row
+    tool: Final = metadata.get("mcp_tool_call_metadata")
+    assert isinstance(tool, dict), metadata
+    return tool
+
+
+def _call(caller: McpCaller, name: str, arguments: dict[str, object], entry: EntryPoint, identity: str) -> Outcome:
+    return caller.call(name, arguments, identity if entry == "rest" else None)
+
+
+@pytest.mark.parametrize("entry", ENTRY_POINTS)
+def test_each_tool_call_writes_one_spend_row_with_server_tool_and_configured_cost(
+    gateway: Gateway, entry: EntryPoint
+) -> None:
+    with mcp_peer() as peer, gateway.scenario() as scenario:
+        alias: Final = "acct" + uuid.uuid4().hex[:8]
+        identity: Final = _priced_server(scenario, peer, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        caller: Final = McpCaller(gateway, key, entry, alias)
+        peer.drain()
+        assert _call(caller, f"{alias}-add", {"a": 2, "b": 3}, entry, identity).text == "5"
+        assert _call(caller, f"{alias}-multiply", {"a": 2, "b": 3}, entry, identity).text == "6"
+        assert len(tool_calls(peer.drain())) == 2
+        rows: Final = [row for row in _rows(key, 2) if row["call_type"] == "call_mcp_tool"]
+        assert len(rows) == 2, rows
+        by_tool: Final = {_tool_metadata(row)["name"]: row for row in rows}
+        assert set(by_tool) == {"add", "multiply"}, rows
+        assert float(str(by_tool["add"]["spend"])) == pytest.approx(ADD_COST)
+        assert float(str(by_tool["multiply"]["spend"])) == pytest.approx(DEFAULT_COST)
+        for row in rows:
+            assert _tool_metadata(row)["mcp_server_name"] == alias, row
+            assert row["model"] == f"MCP: {alias}-{_tool_metadata(row)['name']}", row
+        later: Final = read_rows(SPEND_ROWS, (_digest(key),))
+        assert len([row for row in later if row["call_type"] == "call_mcp_tool"]) == 2, later
+
+
+def test_key_spend_and_key_max_budget_count_mcp_tool_calls(gateway: Gateway) -> None:
+    with mcp_peer() as peer, gateway.scenario() as scenario:
+        alias: Final = "budget" + uuid.uuid4().hex[:8]
+        identity: Final = _priced_server(scenario, peer, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]}, max_budget=ADD_COST / 2)
+        caller: Final = McpCaller(gateway, key, "mcp", alias)
+        assert caller.call(f"{alias}-add", {"a": 2, "b": 3}).text == "5"
+        info: Final = eventually(
+            lambda: gateway.client.get("/key/info", params={"key": key}, headers={"x-litellm-api-key": gateway.key}),
+            lambda response: response.status_code == 200 and float(response.json()["info"]["spend"]) > 0,
+            seconds=70,
+        )
+        assert float(info.json()["info"]["spend"]) == pytest.approx(ADD_COST)
+        eventually(
+            lambda: caller.call(f"{alias}-add", {"a": 2, "b": 3}),
+            lambda outcome: outcome.error is not None,
+            seconds=70,
+        )
+        peer.drain()
+        denied: Final = caller.call(f"{alias}-add", {"a": 2, "b": 3})
+        assert denied.error is not None and "budget" in str(denied.raw).lower(), denied.raw
+        assert tool_calls(peer.drain()) == (), "over-budget call reached the peer"
+
+
+@contextmanager
+def _content_filter(gateway: Gateway, mode: str) -> Iterator[str]:
+    name: Final = "filter" + uuid.uuid4().hex[:8]
+    created: Final = gateway.client.post(
+        "/guardrails",
+        headers={"x-litellm-api-key": gateway.key},
+        json={
+            "guardrail": {
+                "guardrail_name": name,
+                "litellm_params": {
+                    "guardrail": "litellm_content_filter",
+                    "mode": mode,
+                    "default_on": True,
+                    "blocked_words": [{"keyword": FORBIDDEN, "action": "BLOCK"}],
+                },
+            }
+        },
+    )
+    assert created.status_code == 200, created.text
+    identity: Final = created.json()["guardrail_id"]
+    try:
+        yield name
+    finally:
+        deleted: Final = gateway.client.delete(f"/guardrails/{identity}", headers={"x-litellm-api-key": gateway.key})
+        assert deleted.status_code == 200, deleted.text
+
+
+@pytest.mark.parametrize("entry", ENTRY_POINTS)
+def test_pre_mcp_call_guardrail_blocks_before_the_peer_and_still_logs_spend(
+    gateway: Gateway, entry: EntryPoint
+) -> None:
+    with _content_filter(gateway, "pre_mcp_call") as guardrail, mcp_peer() as peer, gateway.scenario() as scenario:
+        alias: Final = "guard" + uuid.uuid4().hex[:8]
+        identity: Final = _priced_server(scenario, peer, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        caller: Final = McpCaller(gateway, key, entry, alias)
+        peer.drain()
+        clean: Final = _call(caller, f"{alias}-add", {"a": 2, "b": 3}, entry, identity)
+        assert clean.text == "5", clean.raw
+        blocked: Final = _call(caller, f"{alias}-add", {"a": 1, "b": FORBIDDEN}, entry, identity)
+        assert blocked.error is not None, f"guardrail-blocked call succeeded: {blocked.raw}"
+        assert FORBIDDEN in str(blocked.raw) or "blocked" in str(blocked.raw).lower(), blocked.raw
+        assert len(tool_calls(peer.drain())) == 1, "blocked call reached the peer"
+        rows: Final = [row for row in _rows(key, 2) if row["call_type"] == "call_mcp_tool"]
+        assert len(rows) == 2, rows
+        failures: Final = [row for row in rows if row["status"] == "failure"]
+        assert len(failures) == 1, rows
+        if failures[0]["model"] == "":
+            pytest.skip(
+                f"BUG: guardrail-blocked MCP call on {entry} logs a spend row with an empty model and no tool name "
+                f"(guardrail {guardrail})"
+            )
+        assert failures[0]["model"] == f"MCP: {alias}-add", failures[0]
+
+
+def test_guardrail_blocked_call_never_reaches_peer_through_the_official_client(gateway: Gateway) -> None:
+    with _content_filter(gateway, "pre_mcp_call"), mcp_peer() as peer, gateway.scenario() as scenario:
+        alias: Final = "guardsdk" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        caller: Final = McpCaller(gateway, key, "server_mcp", alias)
+        peer.drain()
+        blocked: Final = caller.call(f"{alias}-add", {"a": 1, "b": FORBIDDEN})
+        assert blocked.error is not None, blocked.raw
+        assert tool_calls(peer.drain()) == ()
+        allowed: Final = caller.call(f"{alias}-add", {"a": 4, "b": 5})
+        assert allowed.text == "9", allowed.raw
+        assert len(tool_calls(peer.drain())) == 1
+
+
+def test_guardrail_removal_stops_blocking_without_restart(gateway: Gateway) -> None:
+    with mcp_peer() as peer, gateway.scenario() as scenario:
+        alias: Final = "guardoff" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        caller: Final = McpCaller(gateway, key, "mcp", alias)
+        with _content_filter(gateway, "pre_mcp_call"):
+            assert caller.call(f"{alias}-add", {"a": 1, "b": FORBIDDEN}).error is not None
+        peer.drain()
+        eventually(
+            lambda: (caller.call(f"{alias}-add", {"a": 1, "b": FORBIDDEN}), tool_calls(peer.drain()))[1],
+            lambda calls: len(calls) >= 1,
+            seconds=40,
+        )
diff --git a/tests/integration/mcp/test_mcp_credentials.py b/tests/integration/mcp/test_mcp_credentials.py
new file mode 100644
index 000000000000..95a5e46646b4
--- /dev/null
+++ b/tests/integration/mcp/test_mcp_credentials.py
@@ -0,0 +1,194 @@
+import base64
+import uuid
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway, eventually
+from integration._support.database import read_rows
+from integration._support.mcp import (
+    ENTRY_POINTS,
+    EntryPoint,
+    McpCaller,
+    McpPeer,
+    call_tool,
+    mcp_peer,
+    register_mcp,
+    tool_calls,
+    tool_names,
+)
+
+ADD: Final = {"a": 2, "b": 3}
+STATIC_MODES: Final = (
+    ("api_key", b"x-api-key", "{secret}"),
+    ("bearer_token", b"authorization", "Bearer {secret}"),
+    ("basic", b"authorization", "Basic {basic}"),
+    ("authorization", b"authorization", "{secret}"),
+)
+
+
+def _header(call: dict[str, object], name: bytes) -> bytes | None:
+    headers: Final = call["headers"]
+    assert isinstance(headers, dict)
+    value: Final = headers.get(name)
+    return value if isinstance(value, bytes) else None
+
+
+def _one_call(peer: McpPeer) -> dict[str, object]:
+    sent: Final = tool_calls(peer.drain())
+    assert len(sent) == 1, sent
+    return sent[0]
+
+
+def _plaintext_rows(identity: str, secret: str) -> list[dict[str, object]]:
+    return read_rows(
+        'SELECT server_id FROM "LiteLLM_MCPServerTable" WHERE server_id = %s '
+        "AND (credentials::text LIKE %s OR static_headers::text LIKE %s)",
+        (identity, f"%{secret}%", f"%{secret}%"),
+    )
+
+
+@pytest.mark.parametrize(("auth_type", "header", "shape"), STATIC_MODES)
+def test_static_credential_reaches_the_peer_in_its_mode_shape_and_is_encrypted_at_rest(
+    gateway: Gateway, auth_type: str, header: bytes, shape: str
+) -> None:
+    with mcp_peer() as peer, gateway.scenario() as scenario:
+        secret: Final = "user:" + uuid.uuid4().hex
+        basic: Final = base64.b64encode(secret.encode()).decode()
+        identity: Final = register_mcp(
+            scenario, peer, "cred" + uuid.uuid4().hex[:8], auth_type=auth_type, credentials={"auth_value": secret}
+        )
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        peer.drain()
+        response: Final = call_tool(gateway, key, identity, tool_names(gateway, key, identity)["add"], ADD)
+        assert response.status_code == 200, response.text
+        assert _header(_one_call(peer), header) == shape.format(secret=secret, basic=basic).encode()
+        assert _plaintext_rows(identity, secret) == [], "credential stored in plaintext"
+
+
+def test_editing_the_credential_rotates_what_the_peer_receives(gateway: Gateway) -> None:
+    with mcp_peer() as peer, gateway.scenario() as scenario:
+        first: Final = "cred-" + uuid.uuid4().hex
+        second: Final = "cred-" + uuid.uuid4().hex
+        identity: Final = register_mcp(
+            scenario, peer, "cred" + uuid.uuid4().hex[:8], auth_type="bearer_token", credentials={"auth_value": first}
+        )
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        name: Final = tool_names(gateway, key, identity)["add"]
+        peer.drain()
+        assert call_tool(gateway, key, identity, name, ADD).status_code == 200
+        assert _header(_one_call(peer), b"authorization") == f"Bearer {first}".encode()
+        rotated: Final = gateway.request(
+            "PUT", "/v1/mcp/server", {"server_id": identity, "credentials": {"auth_value": second}}
+        )
+        assert rotated.status_code == 202, rotated.text
+        observed: Final = eventually(
+            lambda: (call_tool(gateway, key, identity, name, ADD).status_code, tool_calls(peer.drain())),
+            lambda value: any(_header(call, b"authorization") == f"Bearer {second}".encode() for call in value[1]),
+        )
+        assert all(_header(call, b"authorization") != f"Bearer {first}".encode() for call in observed[1][-1:])
+        assert _plaintext_rows(identity, second) == [] and _plaintext_rows(identity, first) == []
+
+
+@pytest.mark.parametrize("entry", ENTRY_POINTS)
+def test_caller_headers_for_other_servers_and_unknown_headers_never_reach_the_peer(
+    gateway: Gateway, entry: EntryPoint
+) -> None:
+    with mcp_peer() as peer, mcp_peer() as other, gateway.scenario() as scenario:
+        alias: Final = "cred" + uuid.uuid4().hex[:8]
+        other_alias: Final = "cred" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias)
+        other_id: Final = register_mcp(scenario, other, other_alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity, other_id]})
+        leak: Final = "leak-" + uuid.uuid4().hex
+        caller: Final = McpCaller(
+            gateway,
+            key,
+            entry,
+            alias,
+            headers={
+                f"x-mcp-{other_alias}-authorization": f"Bearer {leak}",
+                "x-integration-unknown": leak,
+                "cookie": f"session={leak}",
+            },
+        )
+        peer.drain()
+        outcome: Final = caller.call(f"{alias}-add", ADD, identity if entry in ("mcp", "root", "sse", "rest") else None)
+        assert outcome.ok, outcome.raw
+        call: Final = _one_call(peer)
+        assert leak.encode() not in b"".join(_header(call, name) or b"" for name in call["headers"]), call["headers"]
+        assert tool_calls(other.drain()) == ()
+
+
+def test_server_scoped_caller_header_reaches_only_its_server(gateway: Gateway) -> None:
+    with mcp_peer() as peer, mcp_peer() as other, gateway.scenario() as scenario:
+        alias: Final = "cred" + uuid.uuid4().hex[:8]
+        other_alias: Final = "cred" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias)
+        other_id: Final = register_mcp(scenario, other, other_alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity, other_id]})
+        token: Final = "user-" + uuid.uuid4().hex
+        caller: Final = McpCaller(
+            gateway, key, "mcp", None, headers={f"x-mcp-{alias}-authorization": f"Bearer {token}"}
+        )
+        peer.drain()
+        other.drain()
+        assert caller.call(f"{alias}-add", ADD).ok
+        assert caller.call(f"{other_alias}-add", ADD).ok
+        assert _header(_one_call(peer), b"authorization") == f"Bearer {token}".encode()
+        assert _header(_one_call(other), b"authorization") is None
+
+
+def test_extra_headers_allowlist_forwards_only_named_headers(gateway: Gateway) -> None:
+    with mcp_peer() as peer, gateway.scenario() as scenario:
+        alias: Final = "cred" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias, extra_headers=["x-tenant"])
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        caller: Final = McpCaller(gateway, key, "server_mcp", alias, headers={"x-tenant": "acme", "x-other": "no"})
+        peer.drain()
+        assert caller.call(f"{alias}-add", ADD).ok
+        call: Final = _one_call(peer)
+        assert _header(call, b"x-tenant") == b"acme"
+        assert _header(call, b"x-other") is None
+
+
+def test_byok_server_uses_the_calling_users_stored_credential_and_fails_closed_without_one(gateway: Gateway) -> None:
+    with mcp_peer() as peer, gateway.scenario() as scenario:
+        alias: Final = "byok" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias, auth_type="api_key", is_byok=True)
+        owner: Final = scenario.user()
+        stranger: Final = scenario.user()
+        owner_key: Final = scenario.key(user_id=owner, object_permission={"mcp_servers": [identity]})
+        stranger_key: Final = scenario.key(user_id=stranger, object_permission={"mcp_servers": [identity]})
+        secret: Final = "byok-" + uuid.uuid4().hex
+        stored: Final = gateway.client.post(
+            f"/v1/mcp/server/{identity}/user-credential",
+            json={"credential": secret},
+            headers={"x-litellm-api-key": owner_key},
+        )
+        assert stored.status_code in (200, 201), stored.text
+        scenario.cleanups.callback(
+            gateway.client.delete,
+            f"/v1/mcp/server/{identity}/user-credential",
+            headers={"x-litellm-api-key": owner_key},
+        )
+        assert (
+            read_rows(
+                'SELECT credential_b64 FROM "LiteLLM_MCPUserCredentials" WHERE server_id = %s AND credential_b64 LIKE %s',
+                (identity, f"%{secret}%"),
+            )
+            == []
+        )
+        name: Final = f"{alias}-add"
+        peer.drain()
+        granted: Final = call_tool(gateway, owner_key, identity, name, ADD)
+        assert granted.status_code == 200, granted.text
+        assert _header(_one_call(peer), b"x-api-key") == secret.encode()
+        denied: Final = call_tool(gateway, stranger_key, identity, name, ADD)
+        assert denied.status_code == 401, denied.text
+        assert tool_calls(peer.drain()) == ()
+        removed: Final = gateway.client.delete(
+            f"/v1/mcp/server/{identity}/user-credential", headers={"x-litellm-api-key": owner_key}
+        )
+        assert removed.status_code in (200, 204), removed.text
+        eventually(lambda: call_tool(gateway, owner_key, identity, name, ADD), lambda value: value.status_code == 401)
+        assert tool_calls(peer.drain()) == ()
diff --git a/tests/integration/mcp/test_mcp_lifecycle.py b/tests/integration/mcp/test_mcp_lifecycle.py
index b32cf97605f2..814e1e769d81 100644
--- a/tests/integration/mcp/test_mcp_lifecycle.py
+++ b/tests/integration/mcp/test_mcp_lifecycle.py
@@ -1,3 +1,4 @@
+import functools
 import json
 import uuid
 from contextlib import ExitStack
@@ -6,14 +7,22 @@
 
 import pytest
 import yaml
+from hypothesis import settings
 from hypothesis import strategies as st
 from hypothesis.stateful import RuleBasedStateMachine, invariant, rule, run_state_machine_as_test
-
-from integration._support.client import Gateway
+from integration._support.client import Gateway, eventually
 from integration._support.database import read_rows
 from integration._support.generation import LIFECYCLE_SETTINGS, bounded_http_requests
+from integration._support.mcp import (
+    McpCaller,
+    Outcome,
+    call_tool,
+    mcp_peer,
+    register_mcp,
+    tool_calls,
+    tool_names,
+)
 from integration._support.process import owned_proxy
-from integration._support.mcp import call_tool, mcp_peer, register_mcp, tool_names
 
 
 @pytest.mark.covers("mcp.call_tool.saved_headers.reach_actual_transport")
@@ -249,12 +258,12 @@ def test_same_url_server_grants_scope_discovery_and_direct_or_virtual_execution(
             for alias in aliases
         )
         for virtual in (False, True):
-            keys: Final = tuple(
+            keys = tuple(
                 scenario.key(object_permission={"mcp_servers": [server], "mcp_tool_search_enabled": virtual})
                 for server in servers
             )
             for server, alias, key in zip(servers, aliases, keys):
-                catalog: Final = gateway.request("GET", "/mcp-rest/tools/list", key=key)
+                catalog = gateway.request("GET", "/mcp-rest/tools/list", key=key)
                 assert catalog.status_code == 200, catalog.text
                 if virtual:
                     assert {tool["name"] for tool in catalog.json()["tools"]} == {
@@ -263,7 +272,7 @@ def test_same_url_server_grants_scope_discovery_and_direct_or_virtual_execution(
                         "agent_search",
                         "skill_search",
                     }, catalog.text
-                    search: Final = gateway.request(
+                    search = gateway.request(
                         "POST",
                         "/mcp-rest/tools/call",
                         {"name": "mcp_tool_search", "arguments": {"query": "add", "top_k": 10}},
@@ -278,7 +287,7 @@ def test_same_url_server_grants_scope_discovery_and_direct_or_virtual_execution(
                     assert {tool["name"] for tool in catalog.json()["tools"]} == {"add", "multiply", "fail"}
             for server_index, caller_index in ((0, 0), (1, 0), (1, 1)):
                 peer.drain()
-                response: Final = gateway.request(
+                response = gateway.request(
                     "POST",
                     "/mcp-rest/tools/call",
                     {
@@ -292,15 +301,157 @@ def test_same_url_server_grants_scope_discovery_and_direct_or_virtual_execution(
                     },
                     key=keys[caller_index],
                 )
-                observed: Final = peer.drain()
+                observed = peer.drain()
                 if server_index != caller_index:
                     assert response.status_code == 403 and "not allowed" in response.text, response.text
-                    assert observed == (), "forbidden server reached the upstream"
+                    assert tool_calls(observed) == (), "forbidden server reached the upstream"
                     continue
                 assert response.status_code == 200 and response.json()["isError"] is False, response.text
                 assert response.json()["content"][0]["text"] == "8", response.text
-                calls: Final = tuple(item for item in observed if item["body"].get("method") == "tools/call")
+                calls = tuple(item for item in observed if item["body"].get("method") == "tools/call")
                 assert len(calls) == 1
                 assert calls[0]["headers"][b"x-integration-server"] == aliases[server_index].encode()
-                expected_auth: Final = f"Bearer synthetic-{aliases[server_index]}".encode() if authenticated else None
-                assert all(item["headers"].get(b"authorization") == expected_auth for item in observed)
+                assert all(
+                    item["headers"].get(b"authorization")
+                    == (f"Bearer synthetic-{_server_alias(item)}".encode() if authenticated else None)
+                    for item in observed
+                ), observed
+
+
+def _matches_grants(expected: set[str], view: Outcome) -> bool:
+    return view.error is None and set(view.tools) == expected
+
+
+def _granted_view(worker: Gateway, key: str) -> Outcome:
+    return McpCaller(worker, key, "mcp").list_tools()
+
+
+def _server_alias(call: dict[str, object]) -> str:
+    headers: Final = call["headers"]
+    assert isinstance(headers, dict)
+    return headers[b"x-integration-server"].decode()
+
+
+@pytest.mark.timeout(600)
+def test_generated_create_edit_grant_revoke_delete_call_keeps_grants_and_tool_lists_consistent(
+    gateway: Gateway, peer: Gateway
+) -> None:
+    with mcp_peer() as upstream, bounded_http_requests((gateway, peer), limit=6000) as budget:
+
+        class Fleet(RuleBasedStateMachine):
+            def __init__(self) -> None:
+                super().__init__()
+                self.resources = ExitStack()
+                self.servers: dict[str, str] = {}
+                self.grants: dict[str, set[str]] = {}
+                self.keys: tuple[str, ...] = ()
+                try:
+                    self.scenario = self.resources.enter_context(gateway.scenario())
+                    self.create()
+                    self.keys = tuple(
+                        self.scenario.key(object_permission={"mcp_servers": list(self.servers.values())[:count]})
+                        for count in (0, 1)
+                    )
+                    self.grants = {self.keys[0]: set(), self.keys[1]: set(self.servers)}
+                except BaseException:
+                    with budget.cleanup():
+                        self.resources.close()
+                    raise
+
+            @rule()
+            def create(self) -> None:
+                if len(self.servers) >= 3:
+                    return
+                alias: Final = "fleet" + uuid.uuid4().hex[:8]
+                identity: Final = register_mcp(
+                    self.scenario, upstream, alias, static_headers={"X-Integration-Server": alias}
+                )
+                self.servers[alias] = identity
+
+            @rule(index=st.integers(0, 2), suffix=st.sampled_from(("", "renamed")))
+            def edit(self, index: int, suffix: str) -> None:
+                if not self.servers:
+                    return
+                alias: Final = sorted(self.servers)[index % len(self.servers)]
+                response: Final = gateway.request(
+                    "PUT",
+                    "/v1/mcp/server",
+                    {"server_id": self.servers[alias], "description": alias + suffix, "alias": alias},
+                )
+                assert response.status_code in (200, 202), response.text
+
+            @rule(key_index=st.integers(0, 1), index=st.integers(0, 2), granted=st.booleans())
+            def grant_or_revoke(self, key_index: int, index: int, granted: bool) -> None:
+                if not self.servers:
+                    return
+                previous: Final = self.keys[key_index]
+                alias: Final = sorted(self.servers)[index % len(self.servers)]
+                wanted: Final = (self.grants[previous] | {alias}) if granted else (self.grants[previous] - {alias})
+                key: Final = self.scenario.key(
+                    object_permission={"mcp_servers": [self.servers[a] for a in sorted(wanted)]}
+                )
+                self.keys = tuple(key if i == key_index else k for i, k in enumerate(self.keys))
+                del self.grants[previous]
+                self.grants[key] = wanted
+
+            @rule(index=st.integers(0, 2))
+            def delete(self, index: int) -> None:
+                if len(self.servers) <= 1:
+                    return
+                alias: Final = sorted(self.servers)[index % len(self.servers)]
+                response: Final = gateway.request("DELETE", f"/v1/mcp/server/{self.servers[alias]}")
+                assert response.status_code in (200, 202), response.text
+                del self.servers[alias]
+                for key in self.keys:
+                    self.grants[key].discard(alias)
+
+            @invariant()
+            def tool_lists_and_calls_match_grants_on_both_workers(self) -> None:
+                for key in self.keys:
+                    expected = {f"{alias}-{tool}" for alias in self.grants[key] for tool in ("add", "multiply", "fail")}
+                    for worker in (gateway, peer):
+                        listing = eventually(
+                            functools.partial(_granted_view, worker, key),
+                            functools.partial(_matches_grants, expected),
+                            seconds=40,
+                            return_last_on_timeout=True,
+                        )
+                        assert set(listing.tools) == expected, (worker.client.base_url, listing.raw)
+                    upstream.drain()
+                    caller = McpCaller(gateway, key, "mcp")
+                    for alias in self.grants[key]:
+                        served = caller.call(f"{alias}-add", {"a": 2, "b": 3})
+                        assert served.text == "5", served.raw
+                    reached = tool_calls(upstream.drain())
+                    assert sorted(_server_alias(call) for call in reached) == sorted(self.grants[key]), reached
+                    for alias in set(self.servers) - self.grants[key]:
+                        denied = caller.call(f"{alias}-add", {"a": 2, "b": 3})
+                        assert denied.error is not None and denied.text != "5", denied.raw
+                    assert tool_calls(upstream.drain()) == (), "a revoked or never-granted call reached the peer"
+
+            def teardown(self) -> None:
+                with budget.cleanup():
+                    self.resources.close()
+
+        run_state_machine_as_test(Fleet, settings=settings(LIFECYCLE_SETTINGS, max_examples=5, stateful_step_count=6))
+
+
+def test_key_grant_added_by_key_update_is_visible_to_mcp_tool_listing_before_the_cache_ttl(gateway: Gateway) -> None:
+    with mcp_peer() as upstream, gateway.scenario() as scenario:
+        alias: Final = "late" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, upstream, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": []})
+        assert _granted_view(gateway, key).tools == ()
+        updated: Final = gateway.request(
+            "POST", "/key/update", {"key": key, "object_permission": {"mcp_servers": [identity]}}
+        )
+        assert updated.status_code == 200, updated.text
+        seen: Final = eventually(
+            lambda: _granted_view(gateway, key), lambda view: view.tools != (), seconds=15, return_last_on_timeout=True
+        )
+        if seen.tools == ():
+            pytest.skip(
+                "BUG: a server granted through POST /key/update is missing from /mcp tools/list until the 60s "
+                "key cache TTL expires; no invalidation is published"
+            )
+        assert set(seen.tools) == {f"{alias}-add", f"{alias}-multiply", f"{alias}-fail"}, seen.raw
diff --git a/tests/integration/mcp/test_mcp_llm_endpoints.py b/tests/integration/mcp/test_mcp_llm_endpoints.py
new file mode 100644
index 000000000000..40d7c1970665
--- /dev/null
+++ b/tests/integration/mcp/test_mcp_llm_endpoints.py
@@ -0,0 +1,356 @@
+import json
+import uuid
+from collections.abc import Callable, Iterator, Mapping, Sequence
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Final, Literal
+
+import httpx
+import pytest
+from integration._support.client import Gateway, Scenario
+from integration._support.mcp import McpPeer, mcp_peer, register_mcp, tool_calls
+from integration._support.wire import Reply, Request, Wire, wire_server
+
+Surface = Literal["chat", "responses", "messages", "messages_bridge"]
+SURFACES: Final[tuple[Surface, ...]] = ("chat", "responses", "messages", "messages_bridge")
+ADD: Final = {"a": 2, "b": 3}
+ANSWER: Final = "the sum is 5"
+GATEWAY_REF: Final = {"type": "mcp", "server_url": "litellm_proxy", "server_label": "litellm"}
+AUTO: Final = {**GATEWAY_REF, "require_approval": "never"}
+
+
+def _json(body: Mapping[str, object]) -> Reply:
+    return Reply(body=json.dumps(body).encode())
+
+
+def _has_tool_result(body: Mapping[str, object]) -> bool:
+    messages: Final = body.get("messages")
+    inputs: Final = body.get("input")
+    if isinstance(messages, list):
+        return any(
+            isinstance(message, dict)
+            and (
+                message.get("role") == "tool"
+                or any(
+                    isinstance(block, dict) and block.get("type") == "tool_result"
+                    for block in (message.get("content") if isinstance(message.get("content"), list) else ())
+                )
+            )
+            for message in messages
+        )
+    if isinstance(inputs, list):
+        return any(isinstance(item, dict) and item.get("type") == "function_call_output" for item in inputs)
+    return False
+
+
+def _model_double(tool: str) -> Callable[[Request], Reply]:
+    arguments: Final = json.dumps(ADD)
+
+    def respond(request: Request) -> Reply:
+        body: Final = json.loads(request.body)
+        assert isinstance(body, dict), request.body
+        done: Final = _has_tool_result(body)
+        usage: Final = {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15}
+        if request.target.endswith("/chat/completions"):
+            message: Final = (
+                {"role": "assistant", "content": ANSWER}
+                if done
+                else {
+                    "role": "assistant",
+                    "content": None,
+                    "tool_calls": [
+                        {"id": "call_1", "type": "function", "function": {"name": tool, "arguments": arguments}}
+                    ],
+                }
+            )
+            finish: Final = "stop" if done else "tool_calls"
+            if body.get("stream") is True:
+                delta: Final = (
+                    {**message, "tool_calls": [{**call, "index": 0} for call in message["tool_calls"]]}
+                    if "tool_calls" in message
+                    else message
+                )
+                chunk: Final = {
+                    "id": "chatcmpl-1",
+                    "object": "chat.completion.chunk",
+                    "created": 1,
+                    "model": "gpt-4o-mini",
+                }
+                return Reply(
+                    content_type="text/event-stream",
+                    chunks=(
+                        f"data: {json.dumps({**chunk, 'choices': [{'index': 0, 'delta': delta, 'finish_reason': None}]})}\n\n".encode(),
+                        f"data: {json.dumps({**chunk, 'choices': [{'index': 0, 'delta': {}, 'finish_reason': finish}], 'usage': usage})}\n\n".encode(),
+                        b"data: [DONE]\n\n",
+                    ),
+                )
+            return _json(
+                {
+                    "id": "chatcmpl-1",
+                    "object": "chat.completion",
+                    "created": 1,
+                    "model": "gpt-4o-mini",
+                    "choices": [{"index": 0, "finish_reason": finish, "message": message}],
+                    "usage": usage,
+                }
+            )
+        if request.target.endswith("/messages"):
+            content: Final = (
+                [{"type": "text", "text": ANSWER}]
+                if done
+                else [{"type": "tool_use", "id": "toolu_1", "name": tool, "input": ADD}]
+            )
+            return _json(
+                {
+                    "id": "msg_1",
+                    "type": "message",
+                    "role": "assistant",
+                    "model": "claude",
+                    "content": content,
+                    "stop_reason": "end_turn" if done else "tool_use",
+                    "stop_sequence": None,
+                    "usage": {"input_tokens": 10, "output_tokens": 5},
+                }
+            )
+        assert request.target.endswith("/responses"), request.target
+        output: Final = (
+            [
+                {
+                    "type": "message",
+                    "id": "msg_1",
+                    "role": "assistant",
+                    "status": "completed",
+                    "content": [{"type": "output_text", "text": ANSWER, "annotations": []}],
+                }
+            ]
+            if done
+            else [
+                {
+                    "type": "function_call",
+                    "id": "fc_1",
+                    "call_id": "call_1",
+                    "name": tool,
+                    "arguments": arguments,
+                    "status": "completed",
+                }
+            ]
+        )
+        return _json(
+            {
+                "id": "resp_1",
+                "object": "response",
+                "created_at": 1,
+                "status": "completed",
+                "model": "gpt-4o-mini",
+                "output": output,
+                "usage": {"input_tokens": 10, "output_tokens": 5, "total_tokens": 15},
+            }
+        )
+
+    return respond
+
+
+@dataclass(frozen=True, slots=True)
+class Rig:
+    gateway: Gateway
+    scenario: Scenario
+    peer: McpPeer
+    wire: Wire
+    alias: str
+    server_id: str
+    model: str
+    surface: Surface
+
+    @property
+    def tool(self) -> str:
+        return f"{self.alias}-add"
+
+    def send(self, key: str, tools: Sequence[Mapping[str, object]], **extra: object) -> httpx.Response:
+        prompt: Final = f"add {self.alias}"
+        headers: Final = {"Authorization": f"Bearer {key}"}
+        if self.surface == "chat":
+            body: Final = {"model": self.model, "messages": [{"role": "user", "content": prompt}], "tools": list(tools)}
+            return self.gateway.client.post("/v1/chat/completions", headers=headers, json={**body, **extra}, timeout=90)
+        if self.surface == "responses":
+            return self.gateway.client.post(
+                "/v1/responses",
+                headers=headers,
+                json={"model": self.model, "input": prompt, "tools": list(tools), **extra},
+                timeout=90,
+            )
+        return self.gateway.client.post(
+            "/v1/messages",
+            headers=headers,
+            json={
+                "model": self.model,
+                "max_tokens": 64,
+                "messages": [{"role": "user", "content": prompt}],
+                "tools": list(tools),
+                **extra,
+            },
+            timeout=90,
+        )
+
+    def upstream_tools(self) -> tuple[tuple[str, ...], ...]:
+        return tuple(_tool_names(json.loads(request.body)) for request in self.wire.drain())
+
+    def final_text(self, body: Mapping[str, object]) -> str:
+        if self.surface == "chat":
+            choices: Final = body["choices"]
+            assert isinstance(choices, list), body
+            return str(choices[0]["message"]["content"])
+        if self.surface == "responses":
+            output: Final = body["output"]
+            assert isinstance(output, list), body
+            return "".join(
+                str(block["text"])
+                for item in output
+                if isinstance(item, dict) and item.get("type") == "message"
+                for block in item["content"]
+                if isinstance(block, dict) and block.get("type") == "output_text"
+            )
+        content: Final = body["content"]
+        assert isinstance(content, list), body
+        return "".join(str(block["text"]) for block in content if block.get("type") == "text")
+
+
+def _tool_names(body: Mapping[str, object]) -> tuple[str, ...]:
+    tools: Final = body.get("tools")
+    if not isinstance(tools, list):
+        return ()
+    return tuple(
+        str(tool["name"] if "name" in tool else tool["function"]["name"]) for tool in tools if isinstance(tool, dict)
+    )
+
+
+def _upstream_model(surface: Surface) -> str:
+    return {
+        "chat": "openai/gpt-4o-mini",
+        "responses": "openai/responses/gpt-4o-mini",
+        "messages": "anthropic/claude-sonnet-4-5",
+        "messages_bridge": "hosted_vllm/gpt-4o-mini",
+    }[surface]
+
+
+@contextmanager
+def _rig(gateway: Gateway, surface: Surface) -> Iterator[Rig]:
+    alias: Final = "llm" + uuid.uuid4().hex[:8]
+    with (
+        mcp_peer() as peer,
+        wire_server(_model_double(f"{alias}-add")) as wire,
+        gateway.scenario() as scenario,
+    ):
+        server_id: Final = register_mcp(scenario, peer, alias)
+        model: Final = scenario.model(model=_upstream_model(surface), api_base=wire.url + "/v1")
+        peer.drain()
+        yield Rig(gateway, scenario, peer, wire, alias, server_id, model, surface)
+
+
+def _granted_key(rig: Rig) -> str:
+    return rig.scenario.key(object_permission={"mcp_servers": [rig.server_id]})
+
+
+def _peer_add_calls(peer: McpPeer) -> tuple[dict[str, object], ...]:
+    return tuple(
+        call
+        for call in tool_calls(peer.drain())
+        if isinstance(call["body"], dict) and isinstance(call["body"].get("params"), dict)
+    )
+
+
+def _skip_if_bridge_drops_tool_result(
+    rig: Rig, requests: tuple[tuple[str, ...], ...], calls: tuple[object, ...]
+) -> None:
+    if rig.surface == "messages_bridge" and len(calls) > 1 and len(requests) > 2:
+        pytest.skip(
+            "BUG: /v1/messages MCP tool loop over a non-Anthropic model drops the tool_result message, "
+            "so the tool is re-executed until the iteration cap"
+        )
+
+
+@pytest.mark.parametrize("surface", SURFACES)
+def test_auto_approved_gateway_tool_is_listed_executed_once_and_fed_back(gateway: Gateway, surface: Surface) -> None:
+    with _rig(gateway, surface) as rig:
+        key: Final = _granted_key(rig)
+        response: Final = rig.send(key, [AUTO])
+        assert response.status_code == 200, response.text
+        calls: Final = _peer_add_calls(rig.peer)
+        requests: Final = rig.upstream_tools()
+        _skip_if_bridge_drops_tool_result(rig, requests, calls)
+        assert [call["body"]["params"]["name"] for call in calls] == ["add"], calls
+        assert calls[0]["body"]["params"]["arguments"] == ADD, calls
+        assert len(requests) == 2, requests
+        assert all(rig.tool in names for names in requests), requests
+        assert rig.final_text(response.json()) == ANSWER, response.text
+
+
+@pytest.mark.parametrize("surface", ("chat", "responses", "messages"))
+def test_gateway_tool_without_auto_approval_returns_the_call_to_the_caller_and_never_hits_the_peer(
+    gateway: Gateway, surface: Surface
+) -> None:
+    with _rig(gateway, surface) as rig:
+        key: Final = _granted_key(rig)
+        response: Final = rig.send(key, [GATEWAY_REF])
+        assert response.status_code == 200, response.text
+        assert rig.tool in response.text, response.text
+        assert rig.final_text(response.json()) != ANSWER, response.text
+        assert _peer_add_calls(rig.peer) == (), "tool ran without approval"
+        requests: Final = rig.upstream_tools()
+        assert len(requests) == 1 and rig.tool in requests[0], requests
+
+
+@pytest.mark.parametrize("surface", ("chat", "responses", "messages"))
+def test_ungranted_key_gets_no_gateway_tools_and_the_peer_is_never_reached(gateway: Gateway, surface: Surface) -> None:
+    with _rig(gateway, surface) as rig:
+        key: Final = rig.scenario.key()
+        response: Final = rig.send(key, [AUTO])
+        assert _peer_add_calls(rig.peer) == (), "denied caller reached the peer"
+        requests: Final = rig.upstream_tools()
+        assert requests and all(rig.tool not in names for names in requests), requests
+        assert response.status_code in (200, 400, 401, 403), response.text
+
+
+@pytest.mark.parametrize("surface", ("chat", "responses", "messages"))
+def test_allowed_tools_narrows_the_tool_list_handed_to_the_model(gateway: Gateway, surface: Surface) -> None:
+    with _rig(gateway, surface) as rig:
+        key: Final = _granted_key(rig)
+        response: Final = rig.send(key, [{**AUTO, "allowed_tools": [rig.tool]}])
+        assert response.status_code == 200, response.text
+        requests: Final = rig.upstream_tools()
+        assert requests and all(names == (rig.tool,) for names in requests), requests
+        assert [call["body"]["params"]["name"] for call in _peer_add_calls(rig.peer)] == ["add"]
+
+
+@pytest.mark.parametrize("surface", ("chat", "responses", "messages"))
+def test_server_scoped_gateway_url_exposes_only_that_servers_tools(gateway: Gateway, surface: Surface) -> None:
+    with _rig(gateway, surface) as rig, mcp_peer() as other_peer:
+        other: Final = "oth" + uuid.uuid4().hex[:8]
+        other_id: Final = register_mcp(rig.scenario, other_peer, other)
+        key: Final = rig.scenario.key(object_permission={"mcp_servers": [rig.server_id, other_id]})
+        response: Final = rig.send(key, [{**AUTO, "server_url": f"litellm_proxy/mcp/{rig.alias}"}])
+        assert response.status_code == 200, response.text
+        requests: Final = rig.upstream_tools()
+        assert requests, "model was never called"
+        assert all(rig.tool in names and not any(name.startswith(other) for name in names) for names in requests), (
+            requests
+        )
+        assert _peer_add_calls(other_peer) == (), "unscoped server was called"
+        assert [call["body"]["params"]["name"] for call in _peer_add_calls(rig.peer)] == ["add"]
+
+
+def test_streaming_chat_executes_the_tool_once_and_streams_the_follow_up(gateway: Gateway) -> None:
+    with _rig(gateway, "chat") as rig:
+        key: Final = _granted_key(rig)
+        response: Final = rig.send(key, [AUTO], stream=True)
+        assert response.status_code == 200, response.text
+        chunks: Final = tuple(
+            json.loads(line.removeprefix("data: "))
+            for line in response.text.splitlines()
+            if line.startswith("data: ") and line != "data: [DONE]"
+        )
+        text: Final = "".join(
+            str(chunk["choices"][0]["delta"].get("content") or "") for chunk in chunks if chunk.get("choices")
+        )
+        assert text == ANSWER, response.text
+        assert [call["body"]["params"]["name"] for call in _peer_add_calls(rig.peer)] == ["add"]
+        assert len(rig.upstream_tools()) == 2
diff --git a/tests/integration/mcp/test_mcp_management.py b/tests/integration/mcp/test_mcp_management.py
new file mode 100644
index 000000000000..917acb9a1dc3
--- /dev/null
+++ b/tests/integration/mcp/test_mcp_management.py
@@ -0,0 +1,237 @@
+import uuid
+from pathlib import Path
+from typing import Final
+
+import pytest
+import yaml
+from integration._support.client import Gateway, eventually
+from integration._support.mcp import (
+    McpCaller,
+    call_tool,
+    delete_mcp,
+    forget_mcp,
+    mcp_peer,
+    register_mcp,
+    tool_calls,
+    tool_names,
+)
+from integration._support.process import owned_proxy
+
+ADD: Final = {"a": 4, "b": 5}
+
+
+def _servers(gateway: Gateway, key: str | None = None) -> dict[str, dict[str, object]]:
+    response: Final = gateway.client.get("/v1/mcp/server", headers={"x-litellm-api-key": key or gateway.key})
+    assert response.status_code == 200, response.text
+    return {server["server_id"]: server for server in response.json()}
+
+
+def test_non_admin_key_cannot_create_edit_or_delete_servers(gateway: Gateway) -> None:
+    with mcp_peer() as peer, gateway.scenario() as scenario:
+        alias: Final = "mgmt" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias)
+        plain: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        headers: Final = {"x-litellm-api-key": plain}
+        created: Final = gateway.client.post(
+            "/v1/mcp/server",
+            json={"server_name": alias + "x", "alias": alias + "x", **peer.registration()},
+            headers=headers,
+        )
+        assert created.status_code == 403, created.text
+        edited: Final = gateway.client.put(
+            "/v1/mcp/server", json={"server_id": identity, "server_name": "hijacked"}, headers=headers
+        )
+        assert edited.status_code == 403, edited.text
+        deleted: Final = gateway.client.delete(f"/v1/mcp/server/{identity}", headers=headers)
+        assert deleted.status_code == 403, deleted.text
+        assert _servers(gateway)[identity]["server_name"] == alias
+        assert call_tool(gateway, plain, identity, tool_names(gateway, plain, identity)["add"], ADD).status_code == 200
+
+
+def test_secrets_never_appear_in_server_listing_or_detail(gateway: Gateway) -> None:
+    with mcp_peer() as peer, gateway.scenario() as scenario:
+        secret: Final = "shh-" + uuid.uuid4().hex
+        header_secret: Final = "hdr-" + uuid.uuid4().hex
+        alias: Final = "mgmt" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(
+            scenario,
+            peer,
+            alias,
+            auth_type="bearer_token",
+            credentials={"auth_value": secret},
+            static_headers={"X-Integration-Secret": header_secret},
+        )
+        viewer: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        for key in (gateway.key, viewer):
+            listing: Final = gateway.client.get("/v1/mcp/server", headers={"x-litellm-api-key": key})
+            detail: Final = gateway.client.get(f"/v1/mcp/server/{identity}", headers={"x-litellm-api-key": key})
+            assert listing.status_code == 200 and detail.status_code == 200, (listing.text, detail.text)
+            assert secret not in listing.text + detail.text, key == gateway.key
+        viewed: Final = gateway.client.get("/v1/mcp/server", headers={"x-litellm-api-key": viewer})
+        assert header_secret not in viewed.text, viewed.text
+        peer.drain()
+        assert (
+            call_tool(gateway, viewer, identity, tool_names(gateway, viewer, identity)["add"], ADD).status_code == 200
+        )
+        sent: Final = tool_calls(peer.drain())
+        assert [call["headers"][b"authorization"] for call in sent] == [f"Bearer {secret}".encode()]
+        assert [call["headers"][b"x-integration-secret"] for call in sent] == [header_secret.encode()]
+
+
+def test_edit_url_moves_calls_to_the_new_peer_without_touching_grants(gateway: Gateway) -> None:
+    with mcp_peer() as first, mcp_peer() as second, gateway.scenario() as scenario:
+        alias: Final = "mgmt" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, first, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        name: Final = tool_names(gateway, key, identity)["add"]
+        assert call_tool(gateway, key, identity, name, ADD).status_code == 200
+        assert len(tool_calls(first.drain())) == 1
+        moved: Final = gateway.request("PUT", "/v1/mcp/server", {"server_id": identity, "url": second.url})
+        assert moved.status_code == 202, moved.text
+        second.drain()
+        response: Final = eventually(
+            lambda: call_tool(gateway, key, identity, name, ADD),
+            lambda value: value.status_code == 200 and len(tool_calls(second.drain())) == 1,
+        )
+        assert response.json()["content"][0]["text"] == "9", response.text
+        assert tool_calls(first.drain()) == ()
+
+
+def test_delete_removes_listing_calls_and_database_row(gateway: Gateway) -> None:
+    with mcp_peer() as peer, gateway.scenario() as scenario:
+        alias: Final = "mgmt" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        name: Final = tool_names(gateway, key, identity)["add"]
+        delete_mcp(gateway, identity)
+        assert identity not in _servers(gateway)
+        listing: Final = gateway.client.get(
+            "/mcp-rest/tools/list", headers={"x-litellm-api-key": key}, params={"server_id": identity}
+        )
+        assert listing.status_code >= 400 or listing.json() == [], listing.text
+        peer.drain()
+        response: Final = call_tool(gateway, key, identity, name, ADD)
+        assert response.status_code >= 400, response.text
+        assert tool_calls(peer.drain()) == ()
+        caller: Final = McpCaller(gateway, key, "server_mcp", alias)
+        assert caller.list_tools().tools == (), caller.list_tools().raw
+
+
+def test_duplicate_alias_is_rejected_so_tool_prefixes_cannot_collide(gateway: Gateway) -> None:
+    with mcp_peer() as peer, gateway.scenario() as scenario:
+        alias: Final = "mgmt" + uuid.uuid4().hex[:8]
+        register_mcp(scenario, peer, alias)
+        duplicate: Final = gateway.request(
+            "POST", "/v1/mcp/server", {"server_name": alias, "alias": alias, **peer.registration()}
+        )
+        if duplicate.status_code == 201:
+            scenario.cleanups.callback(forget_mcp, gateway, duplicate.json()["server_id"])
+            pytest.skip("BUG: POST /v1/mcp/server accepts a duplicate alias, so two servers share one tool prefix")
+        assert duplicate.status_code == 400, duplicate.text
+
+
+def test_invalid_registrations_are_rejected(gateway: Gateway) -> None:
+    with mcp_peer() as peer, gateway.scenario() as scenario:
+        alias: Final = "mgmt" + uuid.uuid4().hex[:8]
+        register_mcp(scenario, peer, alias)
+        no_url: Final = gateway.request("POST", "/v1/mcp/server", {"server_name": alias + "b", "transport": "http"})
+        assert no_url.status_code in (400, 422), no_url.text
+        bad_command: Final = gateway.request(
+            "POST",
+            "/v1/mcp/server",
+            {"server_name": alias + "c", "transport": "stdio", "command": "/bin/sh", "args": ["-c", "true"]},
+        )
+        assert bad_command.status_code in (400, 422), bad_command.text
+        hyphenless: Final = gateway.request(
+            "POST", "/v1/mcp/server", {"server_name": "bad name!", **peer.registration()}
+        )
+        assert hyphenless.status_code in (400, 422), hyphenless.text
+        assert len([s for s in _servers(gateway).values() if str(s["server_name"]).startswith(alias)]) == 1
+
+
+def test_access_group_membership_follows_edits(gateway: Gateway) -> None:
+    with mcp_peer() as peer, gateway.scenario() as scenario:
+        group: Final = "grp" + uuid.uuid4().hex[:8]
+        alias: Final = "mgmt" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias, mcp_access_groups=[group])
+        key: Final = scenario.key(object_permission={"mcp_access_groups": [group]})
+        groups: Final = gateway.client.get("/v1/mcp/access_groups", headers={"x-litellm-api-key": gateway.key})
+        assert groups.status_code == 200 and group in groups.text, groups.text
+        assert "add" in tool_names(gateway, key, identity)
+        removed: Final = gateway.request("PUT", "/v1/mcp/server", {"server_id": identity, "mcp_access_groups": []})
+        assert removed.status_code == 202, removed.text
+        eventually(
+            lambda: gateway.client.get(
+                "/mcp-rest/tools/list", headers={"x-litellm-api-key": key}, params={"server_id": identity}
+            ),
+            lambda value: value.status_code >= 400 or value.json() == [],
+        )
+        peer.drain()
+        denied: Final = call_tool(gateway, key, identity, f"{alias}-add", ADD)
+        assert denied.status_code >= 400, denied.text
+        assert tool_calls(peer.drain()) == ()
+
+
+def test_peer_worker_observes_create_edit_and_delete_without_restart(gateway: Gateway, peer: Gateway) -> None:
+    with mcp_peer() as first, mcp_peer() as second, gateway.scenario() as scenario:
+        alias: Final = "mgmt" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, first, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        eventually(
+            lambda: peer.client.get(
+                "/mcp-rest/tools/list", headers={"x-litellm-api-key": key}, params={"server_id": identity}
+            ),
+            lambda value: value.status_code == 200 and value.json() != [],
+            seconds=40,
+        )
+        names: Final = tool_names(peer, key, identity)
+        assert call_tool(peer, key, identity, names["add"], ADD).status_code == 200
+        assert len(tool_calls(first.drain())) == 1
+        moved: Final = gateway.request("PUT", "/v1/mcp/server", {"server_id": identity, "url": second.url})
+        assert moved.status_code == 202, moved.text
+        eventually(
+            lambda: call_tool(peer, key, identity, names["add"], ADD),
+            lambda value: value.status_code == 200 and len(tool_calls(second.drain())) == 1,
+            seconds=40,
+        )
+        delete_mcp(gateway, identity)
+        eventually(
+            lambda: peer.client.get(
+                "/mcp-rest/tools/list", headers={"x-litellm-api-key": key}, params={"server_id": identity}
+            ),
+            lambda value: value.status_code >= 400 or value.json() == [],
+            seconds=40,
+        )
+        second.drain()
+        assert call_tool(peer, key, identity, names["add"], ADD).status_code >= 400
+        assert tool_calls(second.drain()) == ()
+
+
+def test_config_declared_server_behaves_like_database_server_but_is_read_only(gateway: Gateway, tmp_path: Path) -> None:
+    with mcp_peer() as declared_peer, mcp_peer() as database_peer:
+        config: Final = yaml.safe_load((Path(__file__).resolve().parents[1] / "proxy_config.yaml").read_text())
+        declared: Final = "declared" + uuid.uuid4().hex[:8]
+        config["mcp_servers"] = {declared: {**declared_peer.registration(), "static_headers": {"X-From": "config"}}}
+        path: Final = tmp_path / "mcp.yaml"
+        path.write_text(yaml.safe_dump(config))
+        with owned_proxy(gateway, tmp_path, {}, config=path) as candidate, candidate.scenario() as scenario:
+            servers: Final = _servers(candidate)
+            declared_id: Final = next(identity for identity, s in servers.items() if s["server_name"] == declared)
+            created: Final = register_mcp(scenario, database_peer, "database" + uuid.uuid4().hex[:8])
+            key: Final = scenario.key(object_permission={"mcp_servers": [declared_id, created]})
+            declared_names: Final = tool_names(candidate, key, declared_id)
+            assert set(declared_names) == set(tool_names(candidate, key, created)) == {"add", "multiply", "fail"}
+            declared_peer.drain()
+            response: Final = call_tool(candidate, key, declared_id, declared_names["add"], ADD)
+            assert response.status_code == 200 and response.json()["content"][0]["text"] == "9", response.text
+            sent: Final = tool_calls(declared_peer.drain())
+            assert [call["headers"][b"x-from"] for call in sent] == [b"config"]
+            edited: Final = candidate.request(
+                "PUT", "/v1/mcp/server", {"server_id": declared_id, "url": database_peer.url}
+            )
+            assert edited.status_code >= 400, edited.text
+            deleted: Final = candidate.request("DELETE", f"/v1/mcp/server/{declared_id}")
+            assert deleted.status_code >= 400, deleted.text
+            assert declared_id in _servers(candidate)
+            assert call_tool(candidate, key, declared_id, declared_names["add"], ADD).status_code == 200
+            assert len(tool_calls(declared_peer.drain())) == 1 and tool_calls(database_peer.drain()) == ()
diff --git a/tests/integration/mcp/test_mcp_oauth_flows.py b/tests/integration/mcp/test_mcp_oauth_flows.py
new file mode 100644
index 000000000000..bc83ca7ea50d
--- /dev/null
+++ b/tests/integration/mcp/test_mcp_oauth_flows.py
@@ -0,0 +1,363 @@
+import base64
+import hashlib
+import secrets
+import uuid
+from dataclasses import dataclass
+from typing import Final
+from urllib.parse import parse_qs, urlsplit
+
+import httpx
+import pytest
+from integration._support.client import Gateway, eventually
+from integration._support.database import read_rows
+from integration._support.mcp import (
+    ENTRY_POINTS,
+    EntryPoint,
+    McpCaller,
+    McpPeer,
+    call_tool,
+    mcp_peer,
+    register_mcp,
+    tool_calls,
+)
+from integration._support.oauth_server import AuthorizationServer, oauth_server
+
+ADD: Final = {"a": 2, "b": 3}
+CLIENT_REDIRECT: Final = "http://127.0.0.1:9/cb"
+ACCEPT: Final = {"Accept": "application/json, text/event-stream"}
+
+
+def _base(gateway: Gateway) -> str:
+    return str(gateway.client.base_url).rstrip("/")
+
+
+def _authorizations(peer: McpPeer) -> tuple[bytes | None, ...]:
+    return tuple(
+        value if isinstance(value := call["headers"].get(b"authorization"), bytes) else None
+        for call in tool_calls(peer.drain())
+        if isinstance(call["headers"], dict)
+    )
+
+
+def _issued_token(issued: dict[str, object]) -> str:
+    token: Final = issued["access_token"]
+    assert isinstance(token, str)
+    return token
+
+
+def _register_oauth(scenario, peer: McpPeer, auth: AuthorizationServer, alias: str, **fields: object) -> str:
+    return register_mcp(
+        scenario,
+        peer,
+        alias,
+        issuer=auth.issuer,
+        authorization_url=auth.issuer + "/authorize",
+        token_url=auth.issuer + "/token",
+        registration_url=auth.issuer + "/register",
+        **fields,
+    )
+
+
+def _plaintext_credential_rows(identity: str, secret: str) -> list[dict[str, object]]:
+    return read_rows(
+        'SELECT server_id FROM "LiteLLM_MCPServerTable" WHERE server_id = %s AND credentials::text LIKE %s',
+        (identity, f"%{secret}%"),
+    )
+
+
+def test_client_credentials_token_is_minted_once_and_sent_as_bearer(gateway: Gateway) -> None:
+    with mcp_peer() as peer, oauth_server() as auth, gateway.scenario() as scenario:
+        alias: Final = "cc" + uuid.uuid4().hex[:8]
+        secret: Final = "cc-secret-" + uuid.uuid4().hex
+        identity: Final = _register_oauth(
+            scenario,
+            peer,
+            auth,
+            alias,
+            auth_type="oauth2",
+            oauth2_flow="client_credentials",
+            credentials={"client_id": "cc-client", "client_secret": secret, "scopes": ["tools.call"]},
+        )
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        peer.drain()
+        for _ in range(2):
+            response: Final = call_tool(gateway, key, identity, f"{alias}-add", ADD)
+            assert response.status_code == 200, response.text
+        minted: Final = auth.token_requests()
+        assert [request["grant_type"] for request in minted] == ["client_credentials"], minted
+        assert minted[0]["client_id"] == "cc-client" and minted[0]["client_secret"] == secret
+        assert minted[0]["scope"] == "tools.call"
+        seen: Final = _authorizations(peer)
+        assert len(seen) == 2 and len(set(seen)) == 1, seen
+        assert seen[0] is not None and auth.is_live(seen[0].decode().removeprefix("Bearer ")), seen
+        assert secret.encode() not in (seen[0] or b""), "client secret forwarded to the peer"
+        assert _plaintext_credential_rows(identity, secret) == []
+
+
+def test_rotating_the_client_secret_forces_a_fresh_token(gateway: Gateway) -> None:
+    with mcp_peer() as peer, oauth_server() as auth, gateway.scenario() as scenario:
+        alias: Final = "cc" + uuid.uuid4().hex[:8]
+        identity: Final = _register_oauth(
+            scenario,
+            peer,
+            auth,
+            alias,
+            auth_type="oauth2",
+            oauth2_flow="client_credentials",
+            credentials={"client_id": "cc-client", "client_secret": "first-" + uuid.uuid4().hex},
+        )
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        assert call_tool(gateway, key, identity, f"{alias}-add", ADD).status_code == 200
+        before: Final = _authorizations(peer)
+        auth.drain()
+        rotated: Final = "second-" + uuid.uuid4().hex
+        edited: Final = gateway.request(
+            "PUT",
+            "/v1/mcp/server",
+            {"server_id": identity, "credentials": {"client_id": "cc-client", "client_secret": rotated}},
+        )
+        assert edited.status_code == 202, edited.text
+        after: Final = eventually(
+            lambda: (call_tool(gateway, key, identity, f"{alias}-add", ADD).status_code, _authorizations(peer)),
+            lambda value: value[0] == 200 and value[1] != () and value[1][-1] not in before,
+        )
+        assert [request["client_secret"] for request in auth.token_requests()][-1] == rotated
+        assert after[1][-1] not in before
+
+
+def test_token_exchange_swaps_the_callers_subject_token_and_never_forwards_it(gateway: Gateway) -> None:
+    with mcp_peer() as peer, oauth_server() as auth, gateway.scenario() as scenario:
+        alias: Final = "te" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(
+            scenario,
+            peer,
+            alias,
+            auth_type="oauth2_token_exchange",
+            token_exchange_endpoint=auth.issuer + "/token",
+            audience="urn:integration:peer",
+            credentials={"client_id": "te-client", "client_secret": "te-secret"},
+        )
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        subject: Final = "subject-" + uuid.uuid4().hex
+        peer.drain()
+        auth.drain()
+        response: Final = gateway.client.post(
+            "/mcp-rest/tools/call",
+            headers={"x-litellm-api-key": key, "Authorization": f"Bearer {subject}"},
+            json={"name": f"{alias}-add", "arguments": ADD, "server_id": identity},
+        )
+        assert response.status_code == 200, response.text
+        exchanged: Final = auth.token_requests()
+        assert len(exchanged) == 1, exchanged
+        assert exchanged[0]["grant_type"] == "urn:ietf:params:oauth:grant-type:token-exchange"
+        assert exchanged[0]["subject_token"] == subject
+        assert exchanged[0]["audience"] == "urn:integration:peer"
+        seen: Final = _authorizations(peer)
+        assert len(seen) == 1 and seen[0] is not None and subject.encode() not in seen[0], seen
+        assert seen[0].startswith(b"Bearer ") and auth.is_live(seen[0].decode().removeprefix("Bearer "))
+
+
+def test_token_exchange_without_a_subject_token_is_rejected_before_any_upstream_request(gateway: Gateway) -> None:
+    with mcp_peer() as peer, oauth_server() as auth, gateway.scenario() as scenario:
+        alias: Final = "te" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(
+            scenario,
+            peer,
+            alias,
+            auth_type="oauth2_token_exchange",
+            token_exchange_endpoint=auth.issuer + "/token",
+            credentials={"client_id": "te-client", "client_secret": "te-secret"},
+        )
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        peer.drain()
+        auth.drain()
+        response: Final = call_tool(gateway, key, identity, f"{alias}-add", ADD)
+        assert tool_calls(peer.drain()) == ()
+        assert auth.token_requests() == ()
+        if response.status_code == 500:
+            pytest.skip("BUG: /mcp-rest/tools/call without a subject token on a token-exchange server returns 500")
+        assert response.status_code == 401, response.text
+
+
+@pytest.mark.parametrize("entry", ENTRY_POINTS)
+def test_delegated_auth_forwards_the_callers_bearer_untouched(gateway: Gateway, entry: EntryPoint) -> None:
+    with mcp_peer() as peer, gateway.scenario() as scenario:
+        alias: Final = "dl" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias, auth_type="oauth_delegate")
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        token: Final = "user-" + uuid.uuid4().hex
+        caller: Final = McpCaller(gateway, key, entry, alias, headers={"Authorization": f"Bearer {token}"})
+        peer.drain()
+        outcome: Final = caller.call(f"{alias}-add", ADD, identity if entry in ("mcp", "root", "sse", "rest") else None)
+        assert outcome.ok, outcome.raw
+        seen: Final = _authorizations(peer)
+        if seen == (None,) and entry == "rest":
+            pytest.skip("BUG: /mcp-rest/tools/call drops the caller's Authorization on an oauth_delegate server")
+        assert seen == (f"Bearer {token}".encode(),), seen
+
+
+@dataclass(frozen=True, slots=True)
+class _Pkce:
+    verifier: str
+
+    @property
+    def challenge(self) -> str:
+        digest: Final = hashlib.sha256(self.verifier.encode()).digest()
+        return base64.urlsafe_b64encode(digest).rstrip(b"=").decode()
+
+
+def _authorize_through_gateway(
+    gateway: Gateway, auth: AuthorizationServer, alias: str, key: str, client_id: str, pkce: _Pkce
+) -> str:
+    started: Final = gateway.client.get(
+        f"/{alias}/authorize",
+        params={
+            "client_id": client_id,
+            "redirect_uri": CLIENT_REDIRECT,
+            "response_type": "code",
+            "state": "client-state",
+            "code_challenge": pkce.challenge,
+            "code_challenge_method": "S256",
+            "scope": "tools.call",
+        },
+        headers={"x-litellm-api-key": key},
+    )
+    assert started.status_code in (302, 307), started.text
+    upstream: Final = started.headers["location"]
+    assert upstream.startswith(auth.issuer + "/authorize"), upstream
+    upstream_query: Final = parse_qs(urlsplit(upstream).query)
+    assert upstream_query["code_challenge_method"] == ["S256"]
+    assert upstream_query["redirect_uri"] != [CLIENT_REDIRECT], "client redirect relayed upstream"
+    consent: Final = httpx.get(upstream, follow_redirects=False)
+    assert consent.status_code == 302, consent.text
+    callback: Final = consent.headers["location"]
+    assert callback.startswith(_base(gateway)), callback
+    returned: Final = gateway.client.get(
+        callback.removeprefix(_base(gateway)), headers={"x-litellm-api-key": key}, cookies=started.cookies
+    )
+    assert returned.status_code == 302, returned.text
+    final: Final = parse_qs(urlsplit(returned.headers["location"]).query)
+    assert returned.headers["location"].startswith(CLIENT_REDIRECT)
+    assert final["state"] == ["client-state"], final
+    return final["code"][0]
+
+
+def _redeem(gateway: Gateway, alias: str, key: str, client_id: str, code: str, pkce: _Pkce) -> httpx.Response:
+    return gateway.client.post(
+        f"/{alias}/token",
+        headers={"x-litellm-api-key": key},
+        data={
+            "grant_type": "authorization_code",
+            "code": code,
+            "code_verifier": pkce.verifier,
+            "client_id": client_id,
+            "redirect_uri": CLIENT_REDIRECT,
+        },
+    )
+
+
+def test_per_user_authorization_code_with_pkce_binds_the_token_to_the_authorizing_user(gateway: Gateway) -> None:
+    with mcp_peer() as peer, oauth_server() as auth, gateway.scenario() as scenario:
+        alias: Final = "ac" + uuid.uuid4().hex[:8]
+        identity: Final = _register_oauth(
+            scenario,
+            peer,
+            auth,
+            alias,
+            auth_type="oauth2",
+            oauth2_flow="authorization_code",
+            credentials={"client_id": "ac-client", "client_secret": "ac-secret", "scopes": ["tools.call"]},
+        )
+        owner: Final = scenario.key(user_id=scenario.user(), object_permission={"mcp_servers": [identity]})
+        stranger: Final = scenario.key(user_id=scenario.user(), object_permission={"mcp_servers": [identity]})
+        anonymous: Final = gateway.client.post(
+            f"/{alias}/mcp", headers=ACCEPT, json={"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {}}
+        )
+        assert anonymous.status_code == 401, anonymous.text
+        metadata_url: Final = anonymous.headers["www-authenticate"].split('resource_metadata="')[1].rstrip('"')
+        metadata: Final = httpx.get(metadata_url)
+        assert metadata.status_code == 200 and metadata.json()["resource"] == f"{_base(gateway)}/{alias}/mcp"
+        registered: Final = gateway.client.post(
+            f"/{alias}/register", json={"redirect_uris": [CLIENT_REDIRECT], "client_name": "integration"}
+        )
+        assert registered.status_code in (200, 201), registered.text
+        client_id: Final = registered.json()["client_id"]
+        pkce: Final = _Pkce(secrets.token_urlsafe(32))
+        code: Final = _authorize_through_gateway(gateway, auth, alias, owner, client_id, pkce)
+        wrong_verifier: Final = _redeem(gateway, alias, owner, client_id, code, _Pkce("wrong-" + pkce.verifier))
+        assert wrong_verifier.status_code == 400, wrong_verifier.text
+        assert tool_calls(peer.drain()) == ()
+        code2: Final = _authorize_through_gateway(gateway, auth, alias, owner, client_id, pkce)
+        redeemed: Final = _redeem(gateway, alias, owner, client_id, code2, pkce)
+        assert redeemed.status_code == 200, redeemed.text
+        issued: Final = redeemed.json()
+        assert auth.is_live(_issued_token(issued))
+        reused: Final = _redeem(gateway, alias, owner, client_id, code2, pkce)
+        assert reused.status_code == 400, reused.text
+        peer.drain()
+        as_owner: Final = call_tool(gateway, owner, identity, f"{alias}-add", ADD)
+        assert as_owner.status_code == 200, as_owner.text
+        assert _authorizations(peer) == (f"Bearer {_issued_token(issued)}".encode(),)
+        as_stranger: Final = call_tool(gateway, stranger, identity, f"{alias}-add", ADD)
+        assert as_stranger.status_code == 401, as_stranger.text
+        assert tool_calls(peer.drain()) == ()
+        upstream_only: Final = gateway.client.post(
+            f"/{alias}/mcp",
+            headers={**ACCEPT, "Authorization": f"Bearer {_issued_token(issued)}"},
+            json={"jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {}},
+        )
+        assert upstream_only.status_code == 401, upstream_only.text
+        assert tool_calls(peer.drain()) == ()
+        refreshed: Final = gateway.client.post(
+            f"/{alias}/token",
+            headers={"x-litellm-api-key": owner},
+            data={"grant_type": "refresh_token", "refresh_token": issued["refresh_token"], "client_id": client_id},
+        )
+        assert refreshed.status_code == 200, refreshed.text
+        assert refreshed.json()["access_token"] != issued["access_token"]
+        assert (
+            read_rows(
+                'SELECT 1 FROM "LiteLLM_MCPServerTable" WHERE server_id = %s AND credentials::text LIKE %s',
+                (identity, "%ac-secret%"),
+            )
+            == []
+        )
+
+
+def test_authorization_request_without_pkce_is_refused_before_reaching_the_authorization_server(
+    gateway: Gateway,
+) -> None:
+    with mcp_peer() as peer, oauth_server() as auth, gateway.scenario() as scenario:
+        alias: Final = "br" + uuid.uuid4().hex[:8]
+        identity: Final = _register_oauth(scenario, peer, auth, alias, auth_type="oauth_delegate", dcr_bridge=True)
+        key: Final = scenario.key(user_id=scenario.user(), object_permission={"mcp_servers": [identity]})
+        auth.drain()
+        refused: Final = gateway.client.get(
+            f"/{alias}/authorize",
+            params={"client_id": "c", "redirect_uri": CLIENT_REDIRECT, "response_type": "code", "state": "s"},
+            headers={"x-litellm-api-key": key},
+        )
+        assert refused.status_code == 400, refused.text
+        assert "PKCE" in refused.text
+        assert auth.drain() == ()
+
+
+def test_dcr_bridge_relays_client_registration_and_advertises_gateway_endpoints(gateway: Gateway) -> None:
+    with mcp_peer() as peer, oauth_server() as auth, gateway.scenario() as scenario:
+        alias: Final = "dcr" + uuid.uuid4().hex[:8]
+        _register_oauth(scenario, peer, auth, alias, auth_type="oauth_delegate", dcr_bridge=True)
+        auth.drain()
+        registered: Final = gateway.client.post(
+            f"/{alias}/register", json={"redirect_uris": [CLIENT_REDIRECT], "client_name": "integration"}
+        )
+        assert registered.status_code in (200, 201), registered.text
+        assert registered.json()["client_id"].startswith("dcr-"), registered.text
+        assert [(request.method, urlsplit(request.target).path) for request in auth.drain()] == [("POST", "/register")]
+        resource: Final = gateway.client.get(f"/.well-known/oauth-protected-resource/{alias}/mcp")
+        assert resource.status_code == 200, resource.text
+        assert resource.json()["authorization_servers"] == [f"{_base(gateway)}/{alias}"]
+        issuer: Final = gateway.client.get(f"/.well-known/oauth-authorization-server/{alias}/mcp")
+        assert issuer.status_code == 200, issuer.text
+        assert issuer.json()["authorization_endpoint"] == f"{_base(gateway)}/{alias}/authorize"
+        assert issuer.json()["token_endpoint"] == f"{_base(gateway)}/{alias}/token"
+        assert "S256" in issuer.json()["code_challenge_methods_supported"]
diff --git a/tests/integration/mcp/test_mcp_resilience.py b/tests/integration/mcp/test_mcp_resilience.py
new file mode 100644
index 000000000000..8efb54a18fd6
--- /dev/null
+++ b/tests/integration/mcp/test_mcp_resilience.py
@@ -0,0 +1,136 @@
+import uuid
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway, eventually
+from integration._support.mcp import (
+    ENTRY_POINTS,
+    EntryPoint,
+    McpCaller,
+    Outcome,
+    disconnecting_tool,
+    echo_tool,
+    listed_tools,
+    mcp_peer,
+    register_mcp,
+    scripted_peer,
+    slow_tool,
+    tool_calls,
+)
+
+
+def _call(caller: McpCaller, name: str, arguments: dict[str, object], entry: EntryPoint, identity: str) -> Outcome:
+    return caller.call(name, arguments, identity if entry == "rest" else None)
+
+
+def _health(gateway: Gateway, key: str, identity: str) -> str:
+    response: Final = gateway.client.get(
+        "/v1/mcp/server/health", headers={"x-litellm-api-key": key}, params={"server_ids": [identity]}
+    )
+    assert response.status_code == 200, response.text
+    statuses: Final = {entry["server_id"]: entry["status"] for entry in response.json()}
+    assert identity in statuses, response.text
+    return str(statuses[identity])
+
+
+@pytest.mark.parametrize("entry", ENTRY_POINTS)
+def test_tool_error_surfaces_as_error_with_the_peer_message_and_never_as_success(
+    gateway: Gateway, entry: EntryPoint
+) -> None:
+    with mcp_peer() as peer, gateway.scenario() as scenario:
+        alias: Final = "toolerr" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        caller: Final = McpCaller(gateway, key, entry, alias)
+        peer.drain()
+        outcome: Final = _call(caller, f"{alias}-fail", {}, entry, identity)
+        assert outcome.error is not None, f"failing tool reported success: {outcome.raw}"
+        assert "Error executing tool fail" in str(outcome.raw), outcome.raw
+        assert len(tool_calls(peer.drain())) == 1
+        recovered: Final = _call(caller, f"{alias}-add", {"a": 2, "b": 3}, entry, identity)
+        assert recovered.text == "5", recovered.raw
+
+
+@pytest.mark.parametrize("entry", ENTRY_POINTS)
+def test_unreachable_peer_errors_while_a_healthy_sibling_keeps_serving(gateway: Gateway, entry: EntryPoint) -> None:
+    with mcp_peer() as healthy, gateway.scenario() as scenario:
+        good: Final = "good" + uuid.uuid4().hex[:8]
+        bad: Final = "bad" + uuid.uuid4().hex[:8]
+        good_id: Final = register_mcp(scenario, healthy, good)
+        bad_id: Final = register_mcp(scenario, healthy, bad, url="http://127.0.0.1:9/mcp")
+        key: Final = scenario.key(object_permission={"mcp_servers": [good_id, bad_id]})
+        caller: Final = McpCaller(gateway, key, entry, good)
+        listing: Final = caller.list_tools(good_id if entry == "rest" else None)
+        assert listing.error is None, listing.raw
+        assert {f"{good}-add", "add"} & set(listing.tools), listing.raw
+        assert not {f"{bad}-add"} & set(listing.tools) or entry != "rest", listing.raw
+        healthy.drain()
+        served: Final = _call(caller, f"{good}-add", {"a": 2, "b": 3}, entry, good_id)
+        assert served.text == "5", served.raw
+        assert len(tool_calls(healthy.drain())) == 1
+        if entry == "server_mcp":
+            return
+        failed: Final = _call(McpCaller(gateway, key, entry, bad), f"{bad}-add", {"a": 2, "b": 3}, entry, bad_id)
+        assert failed.error is not None, f"call to unreachable peer succeeded: {failed.raw}"
+        assert failed.text != "5"
+
+
+def test_unreachable_peer_is_reported_unhealthy_and_healthy_peer_healthy(gateway: Gateway) -> None:
+    with mcp_peer() as healthy, gateway.scenario() as scenario:
+        good: Final = "hgood" + uuid.uuid4().hex[:8]
+        bad: Final = "hbad" + uuid.uuid4().hex[:8]
+        good_id: Final = register_mcp(scenario, healthy, good)
+        bad_id: Final = register_mcp(scenario, healthy, bad, url="http://127.0.0.1:9/mcp")
+        assert _health(gateway, gateway.key, good_id) == "healthy"
+        assert _health(gateway, gateway.key, bad_id) == "unhealthy"
+
+
+def test_slow_peer_beyond_configured_timeout_errors_and_does_not_hang_the_gateway(gateway: Gateway) -> None:
+    with scripted_peer(slow_tool("nap", 4), echo_tool("echo")) as peer, gateway.scenario() as scenario:
+        alias: Final = "slow" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias, timeout=1)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        caller: Final = McpCaller(gateway, key, "mcp", alias)
+        peer.drain()
+        outcome: Final = caller.call(f"{alias}-nap", {})
+        assert outcome.error is not None, f"call past the timeout succeeded: {outcome.raw}"
+        assert outcome.text != "slept"
+        quick: Final = caller.call(f"{alias}-echo", {"k": "v"})
+        assert quick.text == '{"k": "v"}', quick.raw
+
+
+def test_peer_disconnecting_mid_response_errors_and_the_next_call_succeeds(gateway: Gateway) -> None:
+    with scripted_peer(disconnecting_tool("drop"), echo_tool("echo")) as peer, gateway.scenario() as scenario:
+        alias: Final = "drop" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        for entry in ("mcp", "rest"):
+            caller = McpCaller(gateway, key, entry, alias)
+            dropped = caller.call(f"{alias}-drop", {}, identity if entry == "rest" else None)
+            assert dropped.error is not None, f"half-written reply became success on {entry}: {dropped.raw}"
+            recovered = caller.call(f"{alias}-echo", {"n": 1}, identity if entry == "rest" else None)
+            assert recovered.text == '{"n": 1}', recovered.raw
+
+
+def test_peer_restart_on_the_same_url_is_picked_up_without_gateway_restart(gateway: Gateway) -> None:
+    with gateway.scenario() as scenario:
+        alias: Final = "restart" + uuid.uuid4().hex[:8]
+        with mcp_peer() as first:
+            identity: Final = register_mcp(scenario, first, alias)
+            key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+            assert set(listed_tools(gateway, key, identity)) == {"add", "multiply", "fail"}
+        caller: Final = McpCaller(gateway, key, "mcp", alias)
+        down: Final = caller.call(f"{alias}-add", {"a": 1, "b": 1})
+        assert down.error is not None, down.raw
+        with scripted_peer(echo_tool("add")) as replacement:
+            edited: Final = gateway.request(
+                "PUT",
+                "/v1/mcp/server",
+                {"server_id": identity, "server_name": alias, "alias": alias, **replacement.registration()},
+            )
+            assert edited.status_code in (200, 202), edited.text
+            back: Final = eventually(
+                lambda: caller.call(f"{alias}-add", {"a": 1, "b": 1}), lambda outcome: outcome.error is None, seconds=40
+            )
+            assert back.text == '{"a": 1, "b": 1}', back.raw
+            assert len(tool_calls(replacement.drain())) >= 1
diff --git a/tests/integration/mcp/test_mcp_transports.py b/tests/integration/mcp/test_mcp_transports.py
new file mode 100644
index 000000000000..1862f11d07e3
--- /dev/null
+++ b/tests/integration/mcp/test_mcp_transports.py
@@ -0,0 +1,157 @@
+import json
+import uuid
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.mcp import (
+    ENTRY_POINTS,
+    PEER_KINDS,
+    EntryPoint,
+    McpCaller,
+    PeerKind,
+    mcp_peer,
+    official_client_outcomes,
+    peer_of,
+    register_mcp,
+    tool_calls,
+)
+
+ADD: Final = {"http": "add", "sse": "add", "stdio": "add", "openapi": "getpet"}
+ARGUMENTS: Final = {"add": {"a": 3, "b": 4}, "getpet": {"petId": "7"}}
+EXPECTED: Final = {"add": "7", "getpet": json.dumps({"id": "7", "name": "integration-pet"})}
+
+
+def _peer_saw_call(peer_kind: PeerKind, observed: tuple[dict[str, object], ...], tool: str) -> bool:
+    if peer_kind == "openapi":
+        return any(item.get("path") == "/pets/7" and item.get("method") == "GET" for item in observed)
+    calls: Final = tool_calls(observed)
+    return len(calls) == 1 and calls[0]["body"]["params"]["name"] == tool
+
+
+@pytest.mark.parametrize("entry", ENTRY_POINTS)
+@pytest.mark.parametrize("peer_kind", PEER_KINDS)
+def test_every_entry_point_lists_and_calls_every_peer_transport(
+    gateway: Gateway, peer_kind: PeerKind, entry: EntryPoint
+) -> None:
+    with peer_of(peer_kind) as peer, gateway.scenario() as scenario:
+        alias: Final = "tr" + uuid.uuid4().hex[:10]
+        identity: Final = register_mcp(scenario, peer, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        caller: Final = McpCaller(gateway, key, entry, alias)
+        tool: Final = ADD[peer_kind]
+        listed: Final = caller.list_tools(identity if entry == "rest" else None)
+        assert listed.ok, listed.raw
+        prefixed: Final = tool if entry == "rest" else f"{alias}-{tool}"
+        assert prefixed in listed.tools, listed.tools
+        peer.drain()
+        called: Final = caller.call(prefixed, ARGUMENTS[tool], identity if entry == "rest" else None)
+        assert called.ok, called.raw
+        assert called.text is not None and json.loads(called.text) == json.loads(EXPECTED[tool]), called.raw
+        assert _peer_saw_call(peer_kind, peer.drain(), tool)
+
+
+@pytest.mark.parametrize("peer_kind", ("http", "sse", "stdio"))
+def test_rest_and_streamable_http_agree_on_tool_list_and_result(gateway: Gateway, peer_kind: PeerKind) -> None:
+    with peer_of(peer_kind) as peer, gateway.scenario() as scenario:
+        alias: Final = "agree" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        rest: Final = McpCaller(gateway, key, "rest", alias)
+        rpc: Final = McpCaller(gateway, key, "mcp", alias)
+        rest_tools: Final = rest.list_tools(identity).tools
+        rpc_tools: Final = rpc.list_tools().tools
+        assert tuple(f"{alias}-{name}" for name in rest_tools) == rpc_tools, (rest_tools, rpc_tools)
+        rest_result: Final = rest.call("multiply", {"a": 6, "b": 7}, identity)
+        rpc_result: Final = rpc.call(f"{alias}-multiply", {"a": 6, "b": 7})
+        assert rest_result.ok and rpc_result.ok, (rest_result.raw, rpc_result.raw)
+        assert rest_result.text == rpc_result.text == "42"
+        rest_failure: Final = rest.call("fail", {}, identity)
+        rpc_failure: Final = rpc.call(f"{alias}-fail", {})
+        assert rest_failure.error is not None and rpc_failure.error is not None, (rest_failure.raw, rpc_failure.raw)
+        assert rest_failure.text == rpc_failure.text
+
+
+@pytest.mark.parametrize(
+    ("path_kind", "legacy_sse"),
+    (("aggregate", False), ("named", False), ("legacy_sse", True)),
+    ids=("official-client-/mcp", "official-client-/{server}/mcp", "official-client-/mcp/sse"),
+)
+@pytest.mark.parametrize("peer_kind", ("http", "sse"))
+def test_official_client_session_lists_and_calls_through_gateway(
+    gateway: Gateway, peer_kind: PeerKind, path_kind: str, legacy_sse: bool
+) -> None:
+    with peer_of(peer_kind) as peer, gateway.scenario() as scenario:
+        alias: Final = "sdk" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        path: Final = {"aggregate": "/mcp", "named": f"/{alias}/mcp", "legacy_sse": "/mcp/sse"}[path_kind]
+        peer.drain()
+        listed, called = official_client_outcomes(
+            gateway, key, path, f"{alias}-add", {"a": 20, "b": 22}, legacy_sse=legacy_sse
+        )
+        assert set(listed.tools) == {f"{alias}-add", f"{alias}-multiply", f"{alias}-fail"}, listed.tools
+        assert called.ok and called.text == "42", called
+        assert _peer_saw_call(peer_kind, peer.drain(), "add")
+
+
+@pytest.mark.parametrize("peer_kind", ("http", "sse", "stdio"))
+def test_prompts_resources_and_templates_are_proxied_from_rich_peer(gateway: Gateway, peer_kind: PeerKind) -> None:
+    with peer_of(peer_kind, rich=True) as peer, gateway.scenario() as scenario:
+        alias: Final = "rich" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        caller: Final = McpCaller(gateway, key, "server_mcp", alias)
+        prompts: Final = caller.rpc("prompts/list").text
+        assert f"{alias}-greeting" in prompts, prompts
+        prompt: Final = caller.rpc("prompts/get", {"name": f"{alias}-greeting", "arguments": {"name": "Ada"}}).text
+        assert "Hello, Ada" in prompt, prompt
+        resources: Final = caller.rpc("resources/list").text
+        assert "status://ready" in resources and f"{alias}-status" in resources, resources
+        read: Final = caller.rpc("resources/read", {"uri": "status://ready"}).text
+        assert '"text":"ready"' in read.replace(" ", ""), read
+        templates: Final = caller.rpc("resources/templates/list").text
+        assert "greeting://{name}" in templates, templates
+        templated: Final = caller.rpc("resources/read", {"uri": "greeting://Bob"}).text
+        assert "Hello, Bob" in templated, templated
+        methods: Final = {item["body"].get("method") for item in peer.drain() if isinstance(item.get("body"), dict)}
+        assert {
+            "prompts/list",
+            "prompts/get",
+            "resources/list",
+            "resources/read",
+            "resources/templates/list",
+        } <= methods
+
+
+@pytest.mark.parametrize("peer_kind", ("http", "sse", "stdio"))
+def test_progress_notifications_do_not_break_result_and_slow_tool_completes(
+    gateway: Gateway, peer_kind: PeerKind
+) -> None:
+    with peer_of(peer_kind, rich=True) as peer, gateway.scenario() as scenario:
+        alias: Final = "prog" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        caller: Final = McpCaller(gateway, key, "mcp", alias)
+        progressed: Final = caller.call(f"{alias}-progress", {"steps": 3})
+        assert progressed.ok and progressed.text == "3 steps", progressed.raw
+        slow: Final = caller.call(f"{alias}-slow", {"seconds": 1.5})
+        assert slow.ok and slow.text == "slept", slow.raw
+
+
+@pytest.mark.parametrize("tool", ("sample", "elicit"))
+@pytest.mark.parametrize("entry", ("mcp", "rest"))
+def test_server_initiated_sampling_and_elicitation_surface_as_errors_not_success(
+    gateway: Gateway, entry: EntryPoint, tool: str
+) -> None:
+    with mcp_peer(rich=True) as peer, gateway.scenario() as scenario:
+        alias: Final = "back" + uuid.uuid4().hex[:8]
+        identity: Final = register_mcp(scenario, peer, alias)
+        key: Final = scenario.key(object_permission={"mcp_servers": [identity]})
+        caller: Final = McpCaller(gateway, key, entry, alias)
+        name: Final = tool if entry == "rest" else f"{alias}-{tool}"
+        peer.drain()
+        outcome: Final = caller.call(name, {"prompt": "hi"} if tool == "sample" else {"question": "ok?"}, identity)
+        assert outcome.error is not None, outcome.raw
+        assert outcome.text is None or not outcome.text.startswith(("sampled:", "elicited:")), outcome.raw
+        assert len(tool_calls(peer.drain())) == 1
diff --git a/tests/integration/mcp_coverage.toml b/tests/integration/mcp_coverage.toml
new file mode 100644
index 000000000000..2357269b59f5
--- /dev/null
+++ b/tests/integration/mcp_coverage.toml
@@ -0,0 +1,15 @@
+[tool.coverage.run]
+branch = true
+parallel = true
+relative_files = true
+include = [
+    "litellm/proxy/_experimental/mcp_server/*",
+    "litellm/proxy/management_endpoints/mcp_management_endpoints.py",
+    "litellm/responses/mcp/*",
+    "litellm/experimental_mcp_client/*",
+    "litellm/proxy/guardrails/guardrail_hooks/mcp_*",
+]
+
+[tool.coverage.report]
+show_missing = true
+skip_empty = true
diff --git a/tests/integration/observability/test_guardrail_effects.py b/tests/integration/observability/test_guardrail_effects.py
index f96cae593dce..4fac42a796d4 100644
--- a/tests/integration/observability/test_guardrail_effects.py
+++ b/tests/integration/observability/test_guardrail_effects.py
@@ -5,7 +5,8 @@
 
 import pytest
 import yaml
-from integration._support.client import Gateway
+from integration._support.client import Gateway, eventually, object_value
+from integration._support.database import read_rows
 from integration._support.mcp import mcp_peer, register_mcp, tool_names
 from integration._support.process import owned_proxy
 from integration._support.wire import Reply, Request, wire_server
@@ -88,6 +89,91 @@ def provider(request: Request) -> Reply:
             assert len(policy.drain()) == len(upstream.drain()) == 1
 
 
+@pytest.mark.covers("other.observability.guardrails.anthropic_messages_caller_metadata_keeps_guardrail_spend_log")
+def test_anthropic_messages_with_caller_metadata_keeps_guardrail_information_in_spend_log(
+    gateway: Gateway, tmp_path: Path
+) -> None:
+    identity: Final = "guardrail" + uuid.uuid4().hex
+    prompt: Final = "synthetic allowed prompt " + identity
+    caller_metadata: Final = {"user_id": "device-account-session"}
+
+    def guardrail(request: Request) -> Reply:
+        assert request.target == "/beta/litellm_basic_guardrail_api"
+        assert json.loads(request.body)["texts"] == [prompt]
+        return Reply(body=json.dumps({"action": "NONE"}).encode())
+
+    def provider(request: Request) -> Reply:
+        assert request.target == "/v1/messages"
+        body: Final = json.loads(request.body)
+        assert body["messages"] == [{"role": "user", "content": prompt}]
+        assert body["metadata"] == caller_metadata
+        return Reply(
+            body=json.dumps(
+                {
+                    "id": identity,
+                    "type": "message",
+                    "role": "assistant",
+                    "model": "claude-sonnet-4-5-20250929",
+                    "content": [{"type": "text", "text": "permitted response"}],
+                    "stop_reason": "end_turn",
+                    "stop_sequence": None,
+                    "usage": {"input_tokens": 11, "output_tokens": 4},
+                }
+            ).encode()
+        )
+
+    with wire_server(guardrail) as policy, wire_server(provider) as upstream:
+        config: Final = yaml.safe_load(Path("tests/integration/proxy_config.yaml").read_text())
+        config["guardrails"] = [
+            {
+                "guardrail_name": identity,
+                "litellm_params": {
+                    "guardrail": "generic_guardrail_api",
+                    "mode": "pre_call",
+                    "default_on": True,
+                    "api_base": policy.url,
+                    "api_key": "synthetic-guardrail-key",
+                },
+            }
+        ]
+        path: Final = tmp_path / "caller-metadata.yaml"
+        path.write_text(yaml.safe_dump(config))
+        with owned_proxy(gateway, tmp_path, {}, config=path) as candidate, candidate.scenario() as scenario:
+            model: Final = scenario.model(
+                model="anthropic/claude-sonnet-4-5-20250929", api_base=upstream.url, api_key="synthetic-anthropic-key"
+            )
+            response: Final = candidate.request(
+                "POST",
+                "/v1/messages",
+                {
+                    "model": model,
+                    "max_tokens": 16,
+                    "messages": [{"role": "user", "content": prompt}],
+                    "metadata": caller_metadata,
+                },
+            )
+            assert response.status_code == 200, response.text
+            assert response.json()["content"] == [{"type": "text", "text": "permitted response"}], response.text
+            assert response.headers["x-litellm-applied-guardrails"] == identity, dict(response.headers)
+            assert len(policy.drain()) == len(upstream.drain()) == 1
+            rows: Final = eventually(
+                lambda: read_rows(
+                    'SELECT call_type, metadata FROM "LiteLLM_SpendLogs" WHERE model_group=%s',
+                    (model,),
+                ),
+                lambda values: len(values) == 1,
+                seconds=70,
+            )
+            assert rows[0]["call_type"] == "anthropic_messages", rows[0]
+            saved: Final = object_value(rows[0]["metadata"])
+            entries: Final = saved["guardrail_information"]
+            assert isinstance(entries, list) and len(entries) == 1, saved
+            entry: Final = object_value(entries[0])
+            assert entry["guardrail_name"] == identity, saved
+            assert entry["guardrail_mode"] == "pre_call", saved
+            assert entry["guardrail_status"] == "success", saved
+
+
 @pytest.mark.covers("other.observability.guardrails.denial_prevents_provider_with_allowed_control")
 def test_guardrail_denial_prevents_provider_and_preserves_allowed_control(gateway: Gateway, tmp_path: Path) -> None:
     identity: Final = "guardrail" + uuid.uuid4().hex
@@ -242,6 +328,110 @@ def runtime(request: Request) -> Reply:
             assert [json.loads(request.body)["texts"] for request in policy.drain()] == [[allowed], [denied]]
 
 
+@pytest.mark.covers("other.observability.guardrails.bedrock_post_call_scans_streamed_anthropic_messages_tool_use")
+def test_bedrock_guardrail_streams_anthropic_messages_tool_use_instead_of_chunk_builder_500(
+    gateway: Gateway, tmp_path: Path
+) -> None:
+    identity: Final = "guardrail" + uuid.uuid4().hex
+    guardrail_id: Final = "synthetic" + uuid.uuid4().hex[:8]
+    spoken: Final = "Checking the forecast"
+    frames: Final = (
+        'event: message_start\ndata: {"type": "message_start", "message": {"id": "msg_synthetic", "type": "message", '
+        '"role": "assistant", "model": "claude-sonnet-4-5-20250929", "content": [], "stop_reason": null, '
+        '"stop_sequence": null, "usage": {"input_tokens": 11, "output_tokens": 1}}}\n\n',
+        'event: content_block_start\ndata: {"type": "content_block_start", "index": 0, '
+        '"content_block": {"type": "text", "text": ""}}\n\n',
+        'event: content_block_delta\ndata: {"type": "content_block_delta", "index": 0, '
+        f'"delta": {{"type": "text_delta", "text": "{spoken}"}}}}\n\n',
+        'event: content_block_stop\ndata: {"type": "content_block_stop", "index": 0}\n\n',
+        'event: content_block_start\ndata: {"type": "content_block_start", "index": 1, '
+        '"content_block": {"type": "tool_use", "id": "toolu_synthetic", "name": "lookup_weather", "input": {}}}\n\n',
+        'event: content_block_delta\ndata: {"type": "content_block_delta", "index": 1, '
+        '"delta": {"type": "input_json_delta", "partial_json": "{\\"city\\": \\"Paris\\"}"}}\n\n',
+        'event: content_block_stop\ndata: {"type": "content_block_stop", "index": 1}\n\n',
+        'event: message_delta\ndata: {"type": "message_delta", "delta": {"stop_reason": "tool_use", '
+        '"stop_sequence": null}, "usage": {"output_tokens": 9}}\n\n',
+        'event: message_stop\ndata: {"type": "message_stop"}\n\n',
+    )
+    tools: Final = [
+        {
+            "name": "lookup_weather",
+            "description": "Look up the forecast for a city",
+            "input_schema": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
+        }
+    ]
+
+    def guardrail(request: Request) -> Reply:
+        assert request.target == f"/guardrail/{guardrail_id}/version/DRAFT/apply", request.target
+        body: Final = json.loads(request.body)
+        assert body["source"] == "OUTPUT", body
+        assert body["content"] == [{"text": {"text": spoken}}], body
+        return Reply(body=json.dumps({"action": "NONE", "outputs": [], "assessments": []}).encode())
+
+    def provider(request: Request) -> Reply:
+        assert request.target == "/v1/messages"
+        body: Final = json.loads(request.body)
+        assert body["stream"] is True, body
+        assert body["tools"] == tools, body
+        return Reply(content_type="text/event-stream", chunks=tuple(frame.encode() for frame in frames))
+
+    with wire_server(guardrail) as policy, wire_server(provider) as upstream:
+        config: Final = yaml.safe_load(Path("tests/integration/proxy_config.yaml").read_text())
+        config["guardrails"] = [
+            {
+                "guardrail_name": identity,
+                "litellm_params": {
+                    "guardrail": "bedrock",
+                    "mode": "post_call",
+                    "default_on": True,
+                    "mask_response_content": True,
+                    "guardrailIdentifier": guardrail_id,
+                    "guardrailVersion": "DRAFT",
+                    "aws_region_name": "us-east-1",
+                    "aws_access_key_id": "AKIASYNTHETICGUARDRAIL",
+                    "aws_secret_access_key": "synthetic-secret",
+                    "aws_bedrock_runtime_endpoint": policy.url,
+                },
+            }
+        ]
+        path: Final = tmp_path / "bedrock-stream.yaml"
+        path.write_text(yaml.safe_dump(config))
+        with owned_proxy(gateway, tmp_path, {}, config=path) as candidate, candidate.scenario() as scenario:
+            model: Final = scenario.model(
+                model="anthropic/claude-sonnet-4-5-20250929", api_base=upstream.url, api_key="synthetic-anthropic-key"
+            )
+            response: Final = candidate.request(
+                "POST",
+                "/v1/messages",
+                {
+                    "model": model,
+                    "max_tokens": 64,
+                    "stream": True,
+                    "tools": tools,
+                    "messages": [{"role": "user", "content": f"What is the weather in Paris? {identity}"}],
+                },
+            )
+            assert response.status_code == 200, response.text
+            head, separator, tail = response.text.partition("\n\n")
+            assert separator == "\n\n", response.text
+            assert head.startswith("event: message_start\ndata: "), response.text
+            assert json.loads(head.removeprefix("event: message_start\ndata: ")) == {
+                "type": "message_start",
+                "message": {
+                    "id": "msg_synthetic",
+                    "type": "message",
+                    "role": "assistant",
+                    "model": model,
+                    "content": [],
+                    "stop_reason": None,
+                    "stop_sequence": None,
+                    "usage": {"input_tokens": 11, "output_tokens": 1},
+                },
+            }, response.text
+            assert tail == "".join(frames[1:]), response.text
+            assert len(policy.drain()) == len(upstream.drain()) == 1
+
+
 @pytest.mark.covers("other.mcp.guardrails.request_selection_blocks_resolved_tool_without_execution")
 def test_request_selected_mcp_guardrail_blocks_direct_and_virtual_calls(gateway: Gateway, tmp_path: Path) -> None:
     guardrail = "mcp-policy-" + uuid.uuid4().hex
diff --git a/tests/integration/pricing/test_configured_prices.py b/tests/integration/pricing/test_configured_prices.py
index e39833516c27..0e4efea3a15b 100644
--- a/tests/integration/pricing/test_configured_prices.py
+++ b/tests/integration/pricing/test_configured_prices.py
@@ -8,8 +8,10 @@
 import yaml
 from pydantic import JsonValue
 
+from litellm import get_model_info
 from tests.integration._support.client import Gateway, eventually, object_value, string_value
 from tests.integration._support.database import read_rows
+from tests.integration._support.process import owned_proxy
 
 
 @pytest.mark.covers("quota_management.spend_tracking.custom_price.matches_input_rates")
@@ -169,6 +171,49 @@ def test_saving_echoed_model_info_does_not_freeze_cost_map_price_into_deployment
         assert {key: value for key, value in stored.items() if key in COST_MAP_DISPLAY_PRICING_KEYS} == {}, stored
 
 
+def displayed_model_info(gateway: Gateway, model: str) -> dict[str, JsonValue]:
+    entries: Final = gateway.get("/model/info")["data"]
+    assert isinstance(entries, list)
+    target: Final = next(object_value(entry) for entry in entries if object_value(entry)["model_name"] == model)
+    return object_value(target["model_info"])
+
+
+@pytest.mark.covers("pricing.model_update.echoed_cost_map_metadata_is_not_persisted_as_override")
+def test_saving_echoed_model_info_does_not_persist_cost_map_metadata_as_overrides(gateway: Gateway) -> None:
+    catalog_entry: Final = get_model_info("openai/gpt-4o-mini")
+    with gateway.scenario() as scenario:
+        model: Final = scenario.model()
+        displayed: Final = displayed_model_info(gateway, model)
+        identity: Final = string_value(displayed["id"])
+        assert displayed["key"] == catalog_entry["key"], displayed
+        assert displayed["max_input_tokens"] == catalog_entry["max_input_tokens"], displayed
+        saved: Final = gateway.request(
+            "PATCH", f"/model/{identity}/update", {"model_info": {**displayed, "description": "echoed ui save"}}
+        )
+        assert saved.status_code == 200, saved.text
+        stored: Final = persisted_model_info(identity)
+        assert stored["description"] == "echoed ui save", stored
+        assert {key: value for key, value in stored.items() if key in catalog_entry} == {}, stored
+
+
+@pytest.mark.covers("pricing.model_update.echoing_cost_map_value_back_clears_stored_override")
+def test_saving_the_cost_map_value_back_over_a_stored_override_clears_it(gateway: Gateway, tmp_path: Path) -> None:
+    catalog_limit: Final = get_model_info("openai/gpt-4o-mini")["max_input_tokens"]
+    assert isinstance(catalog_limit, int) and catalog_limit != 4321, catalog_limit
+    with owned_proxy(gateway, tmp_path, {}) as candidate, candidate.scenario() as scenario:
+        overridden: Final = scenario.model(model_info={"max_input_tokens": 4321})
+        displayed: Final = displayed_model_info(candidate, overridden)
+        identity: Final = string_value(displayed["id"])
+        assert displayed["max_input_tokens"] == 4321, displayed
+        assert persisted_model_info(identity)["max_input_tokens"] == 4321
+        saved: Final = candidate.request(
+            "PATCH", f"/model/{identity}/update", {"model_info": {**displayed, "max_input_tokens": catalog_limit}}
+        )
+        assert saved.status_code == 200, saved.text
+        stored: Final = persisted_model_info(identity)
+        assert "max_input_tokens" not in stored, stored
+
+
 @pytest.mark.covers("quota_management.spend_tracking.default_prices.loaded_router_preserves_cached_defaults")
 def test_loaded_router_preserves_cached_defaults_during_real_requests(gateway: Gateway, tmp_path: Path) -> None:
     from litellm import Router
diff --git a/tests/integration/pricing/test_realtime_cached_audio_pricing.py b/tests/integration/pricing/test_realtime_cached_audio_pricing.py
new file mode 100644
index 000000000000..4a7598d0cbfb
--- /dev/null
+++ b/tests/integration/pricing/test_realtime_cached_audio_pricing.py
@@ -0,0 +1,131 @@
+import asyncio
+import json
+import os
+import uuid
+from hashlib import sha256
+from typing import Final
+
+import pytest
+import websockets
+from pydantic import BaseModel, ConfigDict, JsonValue
+
+import litellm
+from tests.integration._support.client import JSON_OBJECT, Gateway, eventually
+from tests.integration._support.database import read_rows
+from tests.integration._support.upstream import delete_scenario, register_scenario
+from tests.integration.cost_calculation.cost_tracking_case import RealtimeResponse
+
+
+class RealtimeRates(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    input_cost_per_token: float
+    input_cost_per_audio_token: float
+    cache_read_input_token_cost: float
+    cache_read_input_audio_token_cost: float | None = None
+    output_cost_per_token: float
+    output_cost_per_audio_token: float
+
+
+MODEL: Final = "gpt-realtime-2"
+RATES: Final = RealtimeRates.model_validate(litellm.get_model_info(MODEL, custom_llm_provider="openai"))
+TEXT_RATE: Final = RATES.input_cost_per_token
+AUDIO_RATE: Final = RATES.input_cost_per_audio_token
+CACHED_TEXT_RATE: Final = RATES.cache_read_input_token_cost
+CACHED_AUDIO_RATE: Final = (
+    RATES.cache_read_input_token_cost
+    if RATES.cache_read_input_audio_token_cost is None
+    else RATES.cache_read_input_audio_token_cost
+)
+OUTPUT_TEXT_RATE: Final = RATES.output_cost_per_token
+OUTPUT_AUDIO_RATE: Final = RATES.output_cost_per_audio_token
+INPUT_TEXT_TOKENS: Final = 116
+INPUT_AUDIO_TOKENS: Final = 167
+CACHED_TEXT_TOKENS: Final = 64
+CACHED_AUDIO_TOKENS: Final = 128
+INPUT_TOKENS: Final = INPUT_TEXT_TOKENS + INPUT_AUDIO_TOKENS
+OUTPUT_TEXT_TOKENS: Final = 8
+OUTPUT_AUDIO_TOKENS: Final = 12
+OUTPUT_TOKENS: Final = OUTPUT_TEXT_TOKENS + OUTPUT_AUDIO_TOKENS
+EXPECTED_INPUT_COST: Final = (
+    (INPUT_TEXT_TOKENS - CACHED_TEXT_TOKENS) * TEXT_RATE
+    + CACHED_TEXT_TOKENS * CACHED_TEXT_RATE
+    + (INPUT_AUDIO_TOKENS - CACHED_AUDIO_TOKENS) * AUDIO_RATE
+    + CACHED_AUDIO_TOKENS * CACHED_AUDIO_RATE
+)
+EXPECTED_OUTPUT_COST: Final = OUTPUT_TEXT_TOKENS * OUTPUT_TEXT_RATE + OUTPUT_AUDIO_TOKENS * OUTPUT_AUDIO_RATE
+
+
+def cached_audio_response_done() -> RealtimeResponse:
+    return RealtimeResponse(
+        content_type="application/x-realtime",
+        events=(
+            {
+                "type": "response.done",
+                "event_id": "evt_$REQUEST_ID",
+                "response": {
+                    "id": "resp_$REQUEST_ID",
+                    "object": "realtime.response",
+                    "status": "completed",
+                    "output": [],
+                    "usage": {
+                        "total_tokens": INPUT_TOKENS + OUTPUT_TOKENS,
+                        "input_tokens": INPUT_TOKENS,
+                        "output_tokens": OUTPUT_TOKENS,
+                        "input_token_details": {
+                            "text_tokens": INPUT_TEXT_TOKENS,
+                            "audio_tokens": INPUT_AUDIO_TOKENS,
+                            "cached_tokens": CACHED_TEXT_TOKENS + CACHED_AUDIO_TOKENS,
+                            "cached_tokens_details": {
+                                "text_tokens": CACHED_TEXT_TOKENS,
+                                "audio_tokens": CACHED_AUDIO_TOKENS,
+                            },
+                        },
+                        "output_token_details": {
+                            "text_tokens": OUTPUT_TEXT_TOKENS,
+                            "audio_tokens": OUTPUT_AUDIO_TOKENS,
+                        },
+                    },
+                },
+            },
+        ),
+    )
+
+
+async def _one_realtime_turn(proxy_url: str, key: str, model: str) -> dict[str, JsonValue]:
+    async with websockets.connect(
+        f"{proxy_url.replace('http://', 'ws://').replace('https://', 'wss://')}/v1/realtime?model={model}",
+        additional_headers={"Authorization": f"Bearer {key}"},
+    ) as websocket:
+        session: Final = JSON_OBJECT.validate_json(await websocket.recv())
+        await websocket.send(json.dumps({"type": "response.create"}))
+        async for message in websocket:
+            if JSON_OBJECT.validate_json(message).get("type") == "response.done":
+                return session
+        raise AssertionError(f"websocket closed before response.done for {model}")
+
+
+@pytest.mark.covers("pricing.realtime.cached_audio_tokens_bill_at_audio_cache_read_rate")
+def test_realtime_cached_audio_tokens_bill_at_audio_cache_read_rate_not_full_audio_rate(gateway: Gateway) -> None:
+    with gateway.scenario() as scenario:
+        scenario_id: Final = f"realtime-cached-audio-{uuid.uuid4().hex[:12]}"
+        handle: Final = register_scenario(scenario_id, cached_audio_response_done())
+        scenario.cleanups.callback(delete_scenario, handle)
+        key: Final = scenario.key()
+        model: Final = scenario.model(
+            model=f"openai/{MODEL}", api_key=scenario_id, api_base=gateway.upstream_url.rstrip("/")
+        )
+        session: Final = asyncio.run(_one_realtime_turn(os.environ["INTEGRATION_PROXY_URL"].rstrip("/"), key, model))
+        assert session.get("type") == "session.created", session
+        rows: Final = eventually(
+            lambda: read_rows(
+                'SELECT spend, prompt_tokens, completion_tokens, call_type FROM "LiteLLM_SpendLogs" WHERE api_key = %s',
+                (sha256(key.encode()).hexdigest(),),
+            ),
+            lambda values: len(values) == 1,
+            seconds=70,
+        )
+        assert rows[0]["call_type"] == "_arealtime", rows
+        assert rows[0]["prompt_tokens"] == INPUT_TOKENS, rows
+        assert rows[0]["completion_tokens"] == OUTPUT_TOKENS, rows
+        assert float(str(rows[0]["spend"])) == pytest.approx(EXPECTED_INPUT_COST + EXPECTED_OUTPUT_COST, rel=1e-6), rows
diff --git a/tests/integration/providers/test_anthropic_advisor_wire.py b/tests/integration/providers/test_anthropic_advisor_wire.py
index 77fa27cd2a9e..b2f44d8f155e 100644
--- a/tests/integration/providers/test_anthropic_advisor_wire.py
+++ b/tests/integration/providers/test_anthropic_advisor_wire.py
@@ -1,28 +1,35 @@
 import json
 import uuid
+from pathlib import Path
 from typing import Final
 
 import pytest
+import yaml
 from integration._support.client import Gateway
+from integration._support.process import owned_proxy
 from integration._support.wire import Reply, Request, wire_server
 
 _ADVISOR_KEY: Final = "synthetic-advisor-key"
+_PROXY_ANTHROPIC_KEY: Final = "sk-proxy-owned-anthropic-secret"
 _QUESTION: Final = "which index should this query use"
 _ADVICE: Final = "use the composite index on (tenant_id, created_at)"
 _FINAL_ANSWER: Final = "done, the composite index is the right one"
 
 
-_ADVISOR_CALL_MESSAGE: Final = {
-    "role": "assistant",
-    "content": None,
-    "tool_calls": [
-        {
-            "id": "advisor-call",
-            "type": "function",
-            "function": {"name": "advisor", "arguments": json.dumps({"question": _QUESTION})},
-        }
-    ],
-}
+def _advisor_call_message(question: str) -> dict[str, object]:
+    return {
+        "role": "assistant",
+        "content": None,
+        "tool_calls": [
+            {
+                "id": "advisor-call",
+                "type": "function",
+                "function": {"name": "advisor", "arguments": json.dumps({"question": question})},
+            }
+        ],
+    }
+
+
 _FINAL_MESSAGE: Final = {"role": "assistant", "content": _FINAL_ANSWER}
 
 
@@ -41,7 +48,7 @@ def _chat_completion(identity: str, message: dict[str, object], finish_reason: s
     )
 
 
-def _executor_reply(body: dict[str, object], identity: str) -> Reply:
+def _executor_reply(body: dict[str, object], identity: str, question: str) -> Reply:
     messages: Final = body["messages"]
     assert isinstance(messages, list)
     if any(message.get("role") == "tool" for message in messages):
@@ -50,7 +57,7 @@ def _executor_reply(body: dict[str, object], identity: str) -> Reply:
     tools: Final = body["tools"]
     assert isinstance(tools, list)
     assert tools[0]["function"]["name"] == "advisor"
-    return _chat_completion(identity, _ADVISOR_CALL_MESSAGE, "tool_calls")
+    return _chat_completion(identity, _advisor_call_message(question), "tool_calls")
 
 
 @pytest.mark.covers("providers.anthropic_messages_advisor.sub_call_uses_the_configured_advisor_deployment")
@@ -58,18 +65,20 @@ def test_advisor_sub_call_reaches_the_router_deployment_with_its_key_instead_of_
     gateway: Gateway,
 ) -> None:
     identity: Final = "advisor-wire-" + uuid.uuid4().hex
+    migration: Final = "please plan the migration " + identity
+    question: Final = _QUESTION + " " + identity
 
     def respond(request: Request) -> Reply:
         body: Final = json.loads(request.body)
         if request.target == "/v1/chat/completions":
             assert request.headers["authorization"] == "Bearer integration-provider-key"
-            return _executor_reply(body, identity)
+            return _executor_reply(body, identity, question)
         assert request.target == "/v1/messages"
         assert request.headers["x-api-key"] == _ADVISOR_KEY
         assert body["model"] == "claude-opus-4-1-20250805"
         assert body["messages"] == [
-            {"role": "user", "content": "please plan the migration"},
-            {"role": "user", "content": _QUESTION},
+            {"role": "user", "content": migration},
+            {"role": "user", "content": question},
         ]
         assert "tools" not in body
         return Reply(
@@ -88,7 +97,7 @@ def respond(request: Request) -> Reply:
         )
 
     with wire_server(respond) as wire, gateway.scenario() as scenario:
-        executor: Final = scenario.model(model="hosted_vllm/llama-3.3-70b", api_base=wire.url + "/v1")
+        executor: Final = scenario.model(model="hosted_vllm/gpt-4o-mini", api_base=wire.url + "/v1")
         advisor: Final = scenario.model(
             model="anthropic/claude-opus-4-1-20250805", api_base=wire.url, api_key=_ADVISOR_KEY
         )
@@ -98,7 +107,7 @@ def respond(request: Request) -> Reply:
             {
                 "model": executor,
                 "max_tokens": 64,
-                "messages": [{"role": "user", "content": "please plan the migration"}],
+                "messages": [{"role": "user", "content": migration}],
                 "tools": [{"type": "advisor_20260301", "name": "advisor", "model": advisor}],
             },
         )
@@ -111,3 +120,82 @@ def respond(request: Request) -> Reply:
             "/v1/messages",
             "/v1/chat/completions",
         ]
+
+
+def _advice_reply(identity: str) -> Reply:
+    return Reply(
+        body=json.dumps(
+            {
+                "id": f"msg-{identity}",
+                "type": "message",
+                "role": "assistant",
+                "model": "claude-opus-4-1-20250805",
+                "content": [{"type": "text", "text": _ADVICE}],
+                "stop_reason": "end_turn",
+                "stop_sequence": None,
+                "usage": {"input_tokens": 12, "output_tokens": 6},
+            }
+        ).encode()
+    )
+
+
+@pytest.mark.covers("providers.anthropic_messages_advisor.caller_api_base_without_api_key_never_receives_the_proxy_key")
+def test_advisor_api_base_without_api_key_is_rejected_before_the_proxy_anthropic_key_reaches_the_caller_host(
+    gateway: Gateway, tmp_path: Path
+) -> None:
+    identity: Final = "advisor-leak-" + uuid.uuid4().hex
+    question: Final = _QUESTION + " " + identity
+
+    def executor(request: Request) -> Reply:
+        assert request.target == "/v1/chat/completions", request.target
+        return _executor_reply(json.loads(request.body), identity, question)
+
+    def caller_host(request: Request) -> Reply:
+        return _advice_reply(identity)
+
+    config: Final = yaml.safe_load(Path("tests/integration/proxy_config.yaml").read_text())
+    config["general_settings"]["allow_client_side_credentials"] = True
+    path: Final = tmp_path / "client-side-credentials.yaml"
+    path.write_text(yaml.safe_dump(config))
+    with (
+        wire_server(executor) as executor_wire,
+        wire_server(caller_host) as caller_wire,
+        owned_proxy(gateway, tmp_path, {"ANTHROPIC_API_KEY": _PROXY_ANTHROPIC_KEY}, config=path) as candidate,
+        candidate.scenario() as scenario,
+    ):
+        model: Final = scenario.model(model="hosted_vllm/gpt-4o-mini", api_base=executor_wire.url + "/v1")
+        response: Final = candidate.request(
+            "POST",
+            "/v1/messages",
+            {
+                "model": model,
+                "max_tokens": 64,
+                "messages": [{"role": "user", "content": "please plan the migration"}],
+                "tools": [
+                    {
+                        "type": "advisor_20260301",
+                        "name": "advisor",
+                        "model": "anthropic/claude-opus-4-1-20250805",
+                        "api_base": caller_wire.url,
+                    }
+                ],
+            },
+        )
+        received: Final = caller_wire.drain()
+        assert [
+            (request.target, request.headers.get("x-api-key"), json.loads(request.body)["messages"])
+            for request in received
+        ] == [], response.text
+        assert response.is_error, response.text
+        assert response.json() == {
+            "type": "error",
+            "error": {
+                "type": "api_error",
+                "message": (
+                    "advisor tool definition sets 'api_base' without 'api_key'. A caller-supplied api_base is only "
+                    "honored alongside a caller-supplied api_key, so the proxy's own credentials are never sent to a "
+                    "caller-chosen destination."
+                ),
+            },
+        }, response.text
+        assert executor_wire.drain() == (), response.text
diff --git a/tests/integration/providers/test_anthropic_legacy_thinking_budget_wire.py b/tests/integration/providers/test_anthropic_legacy_thinking_budget_wire.py
new file mode 100644
index 000000000000..242e5c7ec5a3
--- /dev/null
+++ b/tests/integration/providers/test_anthropic_legacy_thinking_budget_wire.py
@@ -0,0 +1,77 @@
+import json
+import uuid
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+
+_MODEL: Final = "claude-sonnet-4-6"
+_KEY: Final = "synthetic-anthropic-key"
+_THINKING: Final = {"type": "enabled", "budget_tokens": 8000}
+_TOOL: Final = {
+    "name": "read_file",
+    "description": "read a file",
+    "input_schema": {"type": "object", "properties": {"path": {"type": "string"}}, "required": ["path"]},
+}
+_NEXT_CALL: Final = {"type": "tool_use", "id": "call-2", "name": "read_file", "input": {"path": "schema.prisma"}}
+
+
+def _tool_loop_history(identity: str) -> tuple[dict[str, object], ...]:
+    return (
+        {"role": "user", "content": f"open the config for {identity}"},
+        {
+            "role": "assistant",
+            "content": [{"type": "tool_use", "id": "call-1", "name": "read_file", "input": {"path": "config.yaml"}}],
+        },
+        {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "call-1", "content": "model_list: []"}]},
+    )
+
+
+def _tool_use_reply(identity: str) -> Reply:
+    return Reply(
+        body=json.dumps(
+            {
+                "id": f"msg-{identity}",
+                "type": "message",
+                "role": "assistant",
+                "model": _MODEL,
+                "content": [_NEXT_CALL],
+                "stop_reason": "tool_use",
+                "stop_sequence": None,
+                "usage": {"input_tokens": 40, "output_tokens": 12},
+            }
+        ).encode()
+    )
+
+
+@pytest.mark.covers("providers.anthropic_messages.claude_4_6_legacy_thinking_budget_reaches_the_wire_unchanged")
+def test_claude_4_6_thinking_budget_tokens_on_messages_is_forwarded_instead_of_rewritten_to_adaptive(
+    gateway: Gateway,
+) -> None:
+    identity: Final = "legacy-thinking-" + uuid.uuid4().hex
+    history: Final = _tool_loop_history(identity)
+
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == "/v1/messages", request.target
+        assert request.headers["x-api-key"] == _KEY
+        body: Final = json.loads(request.body)
+        assert body["thinking"] == _THINKING, body
+        assert "output_config" not in body, body
+        assert body["max_tokens"] == 32768, body
+        assert body["messages"] == list(history), body
+        assert body["tools"] == [_TOOL], body
+        return _tool_use_reply(identity)
+
+    with wire_server(respond) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model=f"anthropic/{_MODEL}", api_base=wire.url, api_key=_KEY)
+        response: Final = gateway.request(
+            "POST",
+            "/v1/messages",
+            {"model": model, "max_tokens": 32768, "thinking": _THINKING, "messages": history, "tools": [_TOOL]},
+        )
+        assert response.status_code == 200, response.text
+        body: Final = response.json()
+        assert body["content"] == [_NEXT_CALL], response.text
+        assert body["stop_reason"] == "tool_use", response.text
+        assert len(wire.drain()) == 1
diff --git a/tests/integration/providers/test_anthropic_messages_fireworks_stop_wire.py b/tests/integration/providers/test_anthropic_messages_fireworks_stop_wire.py
new file mode 100644
index 000000000000..adec5784aa8c
--- /dev/null
+++ b/tests/integration/providers/test_anthropic_messages_fireworks_stop_wire.py
@@ -0,0 +1,65 @@
+import json
+import uuid
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+from pydantic import JsonValue, TypeAdapter
+
+_MODEL: Final = "accounts/fireworks/models/glm-5p3"
+_API_KEY: Final = "synthetic-fireworks-key"
+_STOP: Final = "</block>"
+_ANSWER: Final = "<verdict>allow</verdict>"
+_JSON_OBJECT: Final = TypeAdapter(dict[str, JsonValue])
+
+
+@pytest.mark.covers(
+    "providers.anthropic_messages_adapter.stop_sequences_and_disabled_thinking_reach_openai_compatible_provider_as_stop_and_reasoning_effort"
+)
+def test_messages_stop_sequences_to_fireworks_are_sent_as_stop_not_stop_sequences(gateway: Gateway) -> None:
+    prompt: Final = "classify this tool call " + uuid.uuid4().hex
+
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST"
+        assert request.target == "/chat/completions"
+        assert request.headers["authorization"] == f"Bearer {_API_KEY}"
+        body: Final = _JSON_OBJECT.validate_json(request.body)
+        assert "stop_sequences" not in body, body
+        assert body["stop"] == [_STOP], body
+        assert body["reasoning_effort"] == "none", body
+        assert body["model"] == _MODEL, body
+        assert body["messages"] == [{"role": "user", "content": prompt}], body
+        return Reply(
+            body=json.dumps(
+                {
+                    "id": "fw-classifier",
+                    "object": "chat.completion",
+                    "created": 1,
+                    "model": _MODEL,
+                    "choices": [
+                        {"index": 0, "message": {"role": "assistant", "content": _ANSWER}, "finish_reason": "stop"}
+                    ],
+                    "usage": {"prompt_tokens": 9, "completion_tokens": 6, "total_tokens": 15},
+                }
+            ).encode()
+        )
+
+    with wire_server(respond) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model=f"fireworks_ai/{_MODEL}", api_base=wire.url, api_key=_API_KEY)
+        response: Final = gateway.request(
+            "POST",
+            "/v1/messages",
+            {
+                "model": model,
+                "max_tokens": 64,
+                "messages": [{"role": "user", "content": prompt}],
+                "stop_sequences": [_STOP],
+                "thinking": {"type": "disabled"},
+            },
+        )
+        assert response.status_code == 200, response.text
+        payload: Final = _JSON_OBJECT.validate_json(response.content)
+        assert payload["content"] == [{"type": "text", "text": _ANSWER}], response.text
+        assert payload["stop_reason"] == "end_turn", response.text
+        assert [(request.method, request.target) for request in wire.drain()] == [("POST", "/chat/completions")]
diff --git a/tests/integration/providers/test_anthropic_messages_openai_bridge_wire.py b/tests/integration/providers/test_anthropic_messages_openai_bridge_wire.py
new file mode 100644
index 000000000000..72eba1d89a5d
--- /dev/null
+++ b/tests/integration/providers/test_anthropic_messages_openai_bridge_wire.py
@@ -0,0 +1,82 @@
+import json
+import uuid
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+from pydantic import JsonValue, TypeAdapter
+
+_BACKEND: Final = "gpt-5.4-mini"
+_API_KEY: Final = "synthetic-openai-key"
+_CORRECTION: Final = "Stop refactoring the parser and only fix the failing test instead."
+_JSON_OBJECT: Final = TypeAdapter(dict[str, JsonValue])
+
+
+def _responses_reply(identity: str, content: str) -> bytes:
+    return json.dumps(
+        {
+            "id": f"resp_{identity}",
+            "object": "response",
+            "created_at": 1789788253,
+            "status": "completed",
+            "model": _BACKEND,
+            "output": [
+                {
+                    "type": "message",
+                    "id": f"msg_{identity}",
+                    "status": "completed",
+                    "role": "assistant",
+                    "content": [{"type": "output_text", "text": content, "annotations": []}],
+                }
+            ],
+            "usage": {"input_tokens": 41, "output_tokens": 5, "total_tokens": 46},
+        }
+    ).encode()
+
+
+@pytest.mark.covers("providers.anthropic_messages_openai_bridge.midturn_system_correction_reaches_the_wire")
+def test_midturn_system_correction_is_forwarded_to_openai_responses(gateway: Gateway) -> None:
+    identity: Final = f"openai-midturn-system-{uuid.uuid4().hex}"
+
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST"
+        assert request.target == "/responses"
+        assert request.headers["authorization"] == f"Bearer {_API_KEY}"
+        body: Final = _JSON_OBJECT.validate_json(request.body)
+        assert body["model"] == _BACKEND
+        assert body["instructions"] == "You are a coding agent."
+        assert body["input"] == [
+            {"type": "message", "role": "user", "content": [{"type": "input_text", "text": "Fix the failing test."}]},
+            {
+                "type": "message",
+                "role": "assistant",
+                "content": [{"type": "output_text", "text": "I will start by refactoring the parser."}],
+            },
+            {"type": "message", "role": "system", "content": [{"type": "input_text", "text": _CORRECTION}]},
+            {"type": "message", "role": "user", "content": [{"type": "input_text", "text": "Continue."}]},
+        ], body
+        return Reply(body=_responses_reply(identity, "Understood."))
+
+    with wire_server(respond) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model=f"openai/{_BACKEND}", api_base=wire.url, api_key=_API_KEY)
+        response: Final = gateway.request(
+            "POST",
+            "/v1/messages",
+            {
+                "model": model,
+                "max_tokens": 64,
+                "system": "You are a coding agent.",
+                "messages": [
+                    {"role": "user", "content": "Fix the failing test."},
+                    {"role": "assistant", "content": "I will start by refactoring the parser."},
+                    {"role": "system", "content": _CORRECTION},
+                    {"role": "user", "content": "Continue."},
+                ],
+            },
+        )
+        assert response.status_code == 200, response.text
+        payload: Final = _JSON_OBJECT.validate_json(response.content)
+        assert payload["content"] == [{"type": "text", "text": "Understood."}], response.text
+        assert payload["stop_reason"] == "end_turn", response.text
+        assert [(request.method, request.target) for request in wire.drain()] == [("POST", "/responses")]
diff --git a/tests/integration/providers/test_anthropic_messages_openai_tools_wire.py b/tests/integration/providers/test_anthropic_messages_openai_tools_wire.py
new file mode 100644
index 000000000000..605fa45e17b4
--- /dev/null
+++ b/tests/integration/providers/test_anthropic_messages_openai_tools_wire.py
@@ -0,0 +1,92 @@
+import json
+import uuid
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+
+_BACKEND: Final = "gpt-5.4-mini"
+_API_KEY: Final = "synthetic-openai-key"
+_TOOL_SCHEMA: Final = {
+    "type": "object",
+    "properties": {
+        "city": {"type": "string"},
+        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
+        "include_forecast": {"type": "boolean"},
+    },
+    "required": ["city"],
+}
+
+
+@pytest.mark.covers("providers.anthropic_messages_bridge.optional_tool_properties_stay_optional_on_the_wire")
+def test_messages_tool_with_optional_properties_reaches_openai_responses_non_strict(gateway: Gateway) -> None:
+    identity: Final = f"messages-optional-tool-{uuid.uuid4().hex}"
+
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == "/responses", request.target
+        assert request.headers["authorization"] == f"Bearer {_API_KEY}"
+        body: Final = json.loads(request.body)
+        assert body["model"] == _BACKEND, body
+        assert body["tools"] == [
+            {
+                "type": "function",
+                "name": "get_weather",
+                "strict": False,
+                "description": "Current weather for a city",
+                "parameters": _TOOL_SCHEMA,
+            }
+        ], body["tools"]
+        return Reply(
+            body=json.dumps(
+                {
+                    "id": f"resp_{identity}",
+                    "object": "response",
+                    "created_at": 1789788253,
+                    "status": "completed",
+                    "model": _BACKEND,
+                    "output": [
+                        {
+                            "type": "function_call",
+                            "id": f"fc_{identity}",
+                            "call_id": f"call_{identity}",
+                            "name": "get_weather",
+                            "arguments": json.dumps({"city": "Paris"}),
+                            "status": "completed",
+                        }
+                    ],
+                    "usage": {"input_tokens": 30, "output_tokens": 9, "total_tokens": 39},
+                }
+            ).encode()
+        )
+
+    with wire_server(respond) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model=f"openai/{_BACKEND}", api_base=wire.url, api_key=_API_KEY)
+        response: Final = gateway.request(
+            "POST",
+            "/v1/messages",
+            {
+                "model": model,
+                "max_tokens": 64,
+                "messages": [{"role": "user", "content": "What is the weather in Paris?"}],
+                "tools": [
+                    {
+                        "name": "get_weather",
+                        "description": "Current weather for a city",
+                        "input_schema": _TOOL_SCHEMA,
+                    }
+                ],
+            },
+        )
+        assert response.status_code == 200, response.text
+        assert [(request.method, request.target) for request in wire.drain()] == [("POST", "/responses")]
+        body: Final = response.json()
+        assert body["stop_reason"] == "tool_use", response.text
+        assert body["content"] == [
+            {
+                "type": "tool_use",
+                "id": f"call_{identity}",
+                "name": "get_weather",
+                "input": {"city": "Paris"},
+            }
+        ], response.text
diff --git a/tests/integration/providers/test_anthropic_messages_timeout_wire.py b/tests/integration/providers/test_anthropic_messages_timeout_wire.py
new file mode 100644
index 000000000000..76c29ad7763f
--- /dev/null
+++ b/tests/integration/providers/test_anthropic_messages_timeout_wire.py
@@ -0,0 +1,58 @@
+import json
+import time
+import uuid
+from typing import Final
+
+import pytest
+from integration._support.client import JSON_OBJECT, Gateway
+from integration._support.wire import Reply, Request, wire_server
+
+_UPSTREAM_STALL_SECONDS: Final = 4.0
+_CONFIGURED_TIMEOUT_SECONDS: Final = 1.0
+
+
+@pytest.mark.covers("providers.anthropic_messages.configured_timeout_aborts_stalled_upstream")
+def test_messages_endpoint_honors_configured_timeout_against_stalled_upstream(gateway: Gateway) -> None:
+    prompt: Final = "stall-" + uuid.uuid4().hex
+
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == "/v1/messages"
+        assert request.headers["x-api-key"] == "synthetic-anthropic-key"
+        body: Final = JSON_OBJECT.validate_json(request.body)
+        assert body["model"] == "claude-sonnet-4-5-20250929"
+        assert body["messages"] == [{"role": "user", "content": prompt}]
+        assert body["max_tokens"] == 16
+        assert "timeout" not in body
+        time.sleep(_UPSTREAM_STALL_SECONDS)
+        return Reply(
+            body=json.dumps(
+                {
+                    "id": "msg_stalled",
+                    "type": "message",
+                    "role": "assistant",
+                    "model": "claude-sonnet-4-5-20250929",
+                    "content": [{"type": "text", "text": "too late"}],
+                    "stop_reason": "end_turn",
+                    "stop_sequence": None,
+                    "usage": {"input_tokens": 1, "output_tokens": 2},
+                }
+            ).encode()
+        )
+
+    with wire_server(respond) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model="anthropic/claude-sonnet-4-5-20250929",
+            api_base=wire.url,
+            api_key="synthetic-anthropic-key",
+            timeout=_CONFIGURED_TIMEOUT_SECONDS,
+        )
+        started: Final = time.monotonic()
+        response: Final = gateway.request(
+            "POST",
+            "/v1/messages",
+            {"model": model, "max_tokens": 16, "messages": [{"role": "user", "content": prompt}]},
+        )
+        elapsed: Final = time.monotonic() - started
+        assert response.status_code == 408, response.text
+        assert elapsed < _UPSTREAM_STALL_SECONDS, f"timed out only after {elapsed:.2f}s: {response.text}"
+        assert len(wire.drain()) == 1
diff --git a/tests/integration/providers/test_anthropic_thinking_signature_retry_wire.py b/tests/integration/providers/test_anthropic_thinking_signature_retry_wire.py
new file mode 100644
index 000000000000..e414d8f0d11c
--- /dev/null
+++ b/tests/integration/providers/test_anthropic_thinking_signature_retry_wire.py
@@ -0,0 +1,95 @@
+import json
+import uuid
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+
+MODEL: Final = "claude-sonnet-4-5-20250929"
+KEY: Final = "synthetic-anthropic-key"
+SIGNATURE_ERROR: Final = json.dumps(
+    {
+        "type": "error",
+        "error": {
+            "type": "invalid_request_error",
+            "message": "messages.2.content.0.thinking.signature.str: Input should be a valid string",
+        },
+    }
+).encode()
+TOOLS: Final = ({"name": "lookup", "input_schema": {"type": "object", "properties": {"key": {"type": "string"}}}},)
+
+
+def _history_with_unsigned_thinking(identity: str) -> tuple[dict[str, object], ...]:
+    return (
+        {"role": "user", "content": [{"type": "text", "text": f"first question {identity}"}]},
+        {"role": "assistant", "content": [{"type": "text", "text": "first answer"}]},
+        {"role": "user", "content": [{"type": "text", "text": "second question"}]},
+        {
+            "role": "assistant",
+            "content": [
+                {"type": "thinking", "thinking": "replayed from another provider", "signature": None},
+                {"type": "tool_use", "id": "call-1", "name": "lookup", "input": {"key": "value"}},
+            ],
+        },
+        {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "call-1", "content": "found"}]},
+    )
+
+
+@pytest.mark.covers("providers.anthropic_messages.missing_thinking_signature_400_retries_without_thinking_blocks")
+def test_missing_thinking_signature_400_retries_once_without_thinking_blocks_and_returns_200(
+    gateway: Gateway,
+) -> None:
+    identity: Final = "thinking-signature-" + uuid.uuid4().hex
+    history: Final = _history_with_unsigned_thinking(identity)
+    tool_use_only_turn: Final = {
+        "role": "assistant",
+        "content": [{"type": "tool_use", "id": "call-1", "name": "lookup", "input": {"key": "value"}}],
+    }
+
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == "/v1/messages"
+        assert request.headers["x-api-key"] == KEY
+        body: Final = json.loads(request.body)
+        assert body["model"] == MODEL
+        assert body["tools"] == list(TOOLS), body
+        if body["messages"][3]["content"][0]["type"] == "thinking":
+            assert body["messages"] == list(history), body
+            assert body["thinking"] == {"type": "enabled", "budget_tokens": 1024}, body
+            return Reply(status=400, body=SIGNATURE_ERROR)
+        assert body["messages"] == [*history[:3], tool_use_only_turn, history[4]], body
+        assert "thinking" not in body, body
+        return Reply(
+            body=json.dumps(
+                {
+                    "id": identity,
+                    "type": "message",
+                    "role": "assistant",
+                    "model": MODEL,
+                    "content": [{"type": "text", "text": "recovered without thinking history"}],
+                    "stop_reason": "end_turn",
+                    "stop_sequence": None,
+                    "usage": {"input_tokens": 30, "output_tokens": 6},
+                }
+            ).encode()
+        )
+
+    with wire_server(respond) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model=f"anthropic/{MODEL}", api_base=wire.url, api_key=KEY)
+        response: Final = gateway.request(
+            "POST",
+            "/v1/messages",
+            {
+                "model": model,
+                "max_tokens": 64,
+                "thinking": {"type": "enabled", "budget_tokens": 1024},
+                "tools": list(TOOLS),
+                "messages": list(history),
+            },
+        )
+        assert response.status_code == 200, response.text
+        body: Final = response.json()
+        assert body["id"] == identity, response.text
+        assert body["content"] == [{"type": "text", "text": "recovered without thinking history"}], response.text
+        assert body["stop_reason"] == "end_turn", response.text
+        assert [request.target for request in wire.drain()] == ["/v1/messages", "/v1/messages"]
diff --git a/tests/integration/providers/test_anthropic_wire.py b/tests/integration/providers/test_anthropic_wire.py
index 27895440712b..7e9c5be227a7 100644
--- a/tests/integration/providers/test_anthropic_wire.py
+++ b/tests/integration/providers/test_anthropic_wire.py
@@ -1,4 +1,5 @@
 import json
+import time
 import uuid
 from typing import Final
 
@@ -8,10 +9,17 @@
 from integration._support.wire import Reply, Request, wire_server
 
 
-@pytest.mark.covers("other.provider_wire.anthropic.tool_history_system_cache_and_internal_fields", "quota_management.spend_tracking.cache_tokens.disjoint_classes_use_explicit_rates")
+@pytest.mark.covers(
+    "other.provider_wire.anthropic.tool_history_system_cache_and_internal_fields",
+    "quota_management.spend_tracking.cache_tokens.disjoint_classes_use_explicit_rates",
+)
 def test_anthropic_tool_history_and_cache_tokens_keep_wire_and_accounting_contracts(gateway: Gateway) -> None:
     identity: Final = "anthropic-wire-" + uuid.uuid4().hex
-    tool_schema: Final = {"type": "object", "properties": {"x": {"type": "integer"}, "y": {"type": "integer"}}, "required": ["x", "y"]}
+    tool_schema: Final = {
+        "type": "object",
+        "properties": {"x": {"type": "integer"}, "y": {"type": "integer"}},
+        "required": ["x", "y"],
+    }
 
     def respond(request: Request) -> Reply:
         assert request.method == "POST" and request.target == "/v1/messages"
@@ -21,27 +29,80 @@ def respond(request: Request) -> Reply:
         assert body["system"] == [{"type": "text", "text": "synthetic policy", "cache_control": {"type": "ephemeral"}}]
         assert body["tools"][0]["name"] == "add" and body["tools"][0]["input_schema"] == tool_schema
         assert body["max_tokens"] == 16
-        assert not {"timeout", "stream_chunk_size", "litellm_params", "litellm_metadata", "rpm", "tpm"}.intersection(body)
+        assert not {"timeout", "stream_chunk_size", "litellm_params", "litellm_metadata", "rpm", "tpm"}.intersection(
+            body
+        )
         messages: Final = body["messages"]
         assert [message["role"] for message in messages] == ["user", "assistant", "user"]
         assert messages[0]["content"] == [{"type": "text", "text": "first"}]
-        assert messages[1]["content"] == [{"type": "tool_use", "id": "history-call", "name": "add", "input": {"x": 1, "y": 2}}]
-        assert messages[2]["content"] == [{"type": "tool_result", "tool_use_id": "history-call", "content": "3"}, {"type": "text", "text": "next"}]
-        return Reply(body=json.dumps({"id": identity, "type": "message", "role": "assistant", "model": "claude-sonnet-4-5-20250929", "content": [{"type": "tool_use", "id": "next-call", "name": "add", "input": {"x": 3, "y": 4}}], "stop_reason": "tool_use", "stop_sequence": None, "usage": {"input_tokens": 10, "output_tokens": 4, "cache_read_input_tokens": 5, "cache_creation_input_tokens": 7}}).encode())
+        assert messages[1]["content"] == [
+            {"type": "tool_use", "id": "history-call", "name": "add", "input": {"x": 1, "y": 2}}
+        ]
+        assert messages[2]["content"] == [
+            {"type": "tool_result", "tool_use_id": "history-call", "content": "3"},
+            {"type": "text", "text": "next"},
+        ]
+        return Reply(
+            body=json.dumps(
+                {
+                    "id": identity,
+                    "type": "message",
+                    "role": "assistant",
+                    "model": "claude-sonnet-4-5-20250929",
+                    "content": [{"type": "tool_use", "id": "next-call", "name": "add", "input": {"x": 3, "y": 4}}],
+                    "stop_reason": "tool_use",
+                    "stop_sequence": None,
+                    "usage": {
+                        "input_tokens": 10,
+                        "output_tokens": 4,
+                        "cache_read_input_tokens": 5,
+                        "cache_creation_input_tokens": 7,
+                    },
+                }
+            ).encode()
+        )
 
     with wire_server(respond) as wire, gateway.scenario() as scenario:
-        model: Final = scenario.model(model="anthropic/claude-sonnet-4-5-20250929", api_base=wire.url, api_key="synthetic-anthropic-key", input_cost_per_token=0.001, output_cost_per_token=0.002, cache_read_input_token_cost=0.0001, cache_creation_input_token_cost=0.002)
-        response: Final = gateway.request("POST", "/v1/chat/completions", {
-            "model": model, "max_tokens": 16, "timeout": 5,
-            "messages": [
-                {"role": "system", "content": [{"type": "text", "text": "synthetic policy", "cache_control": {"type": "ephemeral"}}]},
-                {"role": "user", "content": "first"},
-                {"role": "assistant", "tool_calls": [{"id": "history-call", "type": "function", "function": {"name": "add", "arguments": '{"x":1,"y":2}'}}]},
-                {"role": "tool", "tool_call_id": "history-call", "content": "3"},
-                {"role": "user", "content": "next"},
-            ],
-            "tools": [{"type": "function", "function": {"name": "add", "parameters": tool_schema}}],
-        })
+        model: Final = scenario.model(
+            model="anthropic/claude-sonnet-4-5-20250929",
+            api_base=wire.url,
+            api_key="synthetic-anthropic-key",
+            input_cost_per_token=0.001,
+            output_cost_per_token=0.002,
+            cache_read_input_token_cost=0.0001,
+            cache_creation_input_token_cost=0.002,
+        )
+        response: Final = gateway.request(
+            "POST",
+            "/v1/chat/completions",
+            {
+                "model": model,
+                "max_tokens": 16,
+                "timeout": 5,
+                "messages": [
+                    {
+                        "role": "system",
+                        "content": [
+                            {"type": "text", "text": "synthetic policy", "cache_control": {"type": "ephemeral"}}
+                        ],
+                    },
+                    {"role": "user", "content": "first"},
+                    {
+                        "role": "assistant",
+                        "tool_calls": [
+                            {
+                                "id": "history-call",
+                                "type": "function",
+                                "function": {"name": "add", "arguments": '{"x":1,"y":2}'},
+                            }
+                        ],
+                    },
+                    {"role": "tool", "tool_call_id": "history-call", "content": "3"},
+                    {"role": "user", "content": "next"},
+                ],
+                "tools": [{"type": "function", "function": {"name": "add", "parameters": tool_schema}}],
+            },
+        )
         assert response.status_code == 200, response.text
         body: Final = response.json()
         assert body["id"].startswith("chatcmpl-")
@@ -51,7 +112,14 @@ def respond(request: Request) -> Reply:
         assert json.loads(tool["function"]["arguments"]) == {"x": 3, "y": 4}
         assert body["usage"]["prompt_tokens"] == 22 and body["usage"]["completion_tokens"] == 4
         assert len(wire.drain()) == 1
-        rows: Final = eventually(lambda: read_rows('SELECT spend, prompt_tokens, completion_tokens, metadata FROM "LiteLLM_SpendLogs" WHERE request_id=%s', (body["id"],)), lambda values: len(values) == 1, seconds=70)
+        rows: Final = eventually(
+            lambda: read_rows(
+                'SELECT spend, prompt_tokens, completion_tokens, metadata FROM "LiteLLM_SpendLogs" WHERE request_id=%s',
+                (body["id"],),
+            ),
+            lambda values: len(values) == 1,
+            seconds=70,
+        )
         assert float(rows[0]["spend"]) == pytest.approx(10 * 0.001 + 5 * 0.0001 + 7 * 0.002 + 4 * 0.002)
         assert rows[0]["prompt_tokens"] == 22 and rows[0]["completion_tokens"] == 4
         metadata: Final = rows[0]["metadata"]
@@ -81,3 +149,58 @@ def respond(request: Request) -> Reply:
         )
         assert response.status_code == 400, response.text
         assert wire.drain() == ()
+
+
+@pytest.mark.covers("other.provider_wire.anthropic.messages_request_timeout_reaches_transport")
+def test_anthropic_messages_slow_upstream_is_cut_off_at_the_deployment_request_timeout(gateway: Gateway) -> None:
+    identity: Final = "anthropic-timeout-" + uuid.uuid4().hex
+    prompt: Final = f"slow answer {identity}"
+
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == "/v1/messages"
+        assert request.headers["x-api-key"] == "synthetic-anthropic-key"
+        body: Final = json.loads(request.body)
+        assert body["model"] == "claude-sonnet-4-5-20250929"
+        assert body["max_tokens"] == 16
+        assert body["messages"] == [{"role": "user", "content": prompt}]
+        assert not {
+            "timeout",
+            "request_timeout",
+            "stream_chunk_size",
+            "litellm_params",
+            "litellm_metadata",
+            "rpm",
+            "tpm",
+        }.intersection(body)
+        time.sleep(1.5)
+        return Reply(
+            body=json.dumps(
+                {
+                    "id": identity,
+                    "type": "message",
+                    "role": "assistant",
+                    "model": "claude-sonnet-4-5-20250929",
+                    "content": [{"type": "text", "text": "late"}],
+                    "stop_reason": "end_turn",
+                    "stop_sequence": None,
+                    "usage": {"input_tokens": 3, "output_tokens": 1},
+                }
+            ).encode()
+        )
+
+    with wire_server(respond) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model="anthropic/claude-sonnet-4-5-20250929",
+            api_base=wire.url,
+            api_key="synthetic-anthropic-key",
+            request_timeout=0.3,
+        )
+        response: Final = gateway.request(
+            "POST",
+            "/v1/messages",
+            {"model": model, "max_tokens": 16, "messages": [{"role": "user", "content": prompt}]},
+            headers={"anthropic-version": "2023-06-01"},
+        )
+        assert response.status_code == 408, response.text
+        assert "Timeout" in response.json()["error"]["message"], response.text
+        assert eventually(wire.drain, lambda requests: len(requests) == 1, seconds=5, return_last_on_timeout=True)
diff --git a/tests/integration/providers/test_bedrock_converse_client_metadata_wire.py b/tests/integration/providers/test_bedrock_converse_client_metadata_wire.py
new file mode 100644
index 000000000000..92d9ebd4a0c6
--- /dev/null
+++ b/tests/integration/providers/test_bedrock_converse_client_metadata_wire.py
@@ -0,0 +1,43 @@
+import json
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+from integration.providers.test_bedrock_auth_wire import MODEL, RESPONSE, TOKEN
+
+ANTHROPIC_BETA: Final = ["interleaved-thinking-2025-05-14"]
+CLIENT_METADATA: Final = {"originator": "codex_cli_rs", "version": "0.1.0", "session_id": "synthetic-session"}
+
+
+def converse_peer(request: Request) -> Reply:
+    assert request.method == "POST" and request.target == "/model/anthropic.claude-3-haiku-20240307-v1%3A0/converse"
+    body: Final = json.loads(request.body)
+    assert body["additionalModelRequestFields"] == {"anthropic_beta": ANTHROPIC_BETA}, body
+    return Reply(body=RESPONSE)
+
+
+@pytest.mark.covers("providers.bedrock_converse.client_metadata_is_not_forwarded_in_additional_model_request_fields")
+def test_client_metadata_is_dropped_from_converse_body_while_anthropic_beta_is_kept(gateway: Gateway) -> None:
+    with wire_server(converse_peer) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model=MODEL,
+            api_key=TOKEN,
+            aws_region_name="us-east-1",
+            aws_bedrock_runtime_endpoint=wire.url,
+        )
+        response: Final = gateway.request(
+            "POST",
+            "/v1/chat/completions",
+            {
+                "model": model,
+                "messages": [{"role": "user", "content": "synthetic codex request"}],
+                "max_tokens": 16,
+                "anthropic_beta": ANTHROPIC_BETA,
+                "client_metadata": CLIENT_METADATA,
+                "cache": {"no-cache": True},
+            },
+        )
+        assert response.status_code == 200, response.text
+        assert response.json()["choices"][0]["message"]["content"] == "bedrock wire control"
+        assert len(wire.drain()) == 1, response.text
diff --git a/tests/integration/providers/test_bedrock_deepseek_reasoning_wire.py b/tests/integration/providers/test_bedrock_deepseek_reasoning_wire.py
new file mode 100644
index 000000000000..f7391da54d9a
--- /dev/null
+++ b/tests/integration/providers/test_bedrock_deepseek_reasoning_wire.py
@@ -0,0 +1,93 @@
+import json
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+
+R1_MODEL: Final = "bedrock/converse/us.deepseek.r1-v1:0"
+V3_MODEL: Final = "bedrock/converse/deepseek.v3.2"
+TOKEN: Final = "synthetic-bedrock-bearer"
+RESPONSE: Final = json.dumps(
+    {
+        "output": {"message": {"role": "assistant", "content": [{"text": "deepseek reasoning wire control"}]}},
+        "stopReason": "end_turn",
+        "usage": {"inputTokens": 9, "outputTokens": 5, "totalTokens": 14},
+        "metrics": {"latencyMs": 1},
+    }
+).encode()
+
+
+def r1_converse_peer(request: Request) -> Reply:
+    assert request.method == "POST" and request.target == "/model/us.deepseek.r1-v1%3A0/converse", request.target
+    assert request.headers["authorization"] == f"Bearer {TOKEN}"
+    body: Final = json.loads(request.body)
+    assert body["messages"] == [{"role": "user", "content": [{"text": "synthetic r1 request"}]}]
+    assert body["inferenceConfig"] == {"maxTokens": 16}, body
+    assert body.get("additionalModelRequestFields") is None, body
+    return Reply(body=RESPONSE)
+
+
+def v3_converse_peer(request: Request) -> Reply:
+    assert request.method == "POST" and request.target == "/model/deepseek.v3.2/converse", request.target
+    assert request.headers["authorization"] == f"Bearer {TOKEN}"
+    body: Final = json.loads(request.body)
+    assert body["messages"] == [{"role": "user", "content": [{"text": "synthetic v3 request"}]}]
+    assert body["inferenceConfig"] == {"maxTokens": 16}, body
+    assert body["additionalModelRequestFields"] == {"reasoning_effort": "high"}, body
+    return Reply(body=RESPONSE)
+
+
+@pytest.mark.covers("providers.bedrock_converse.deepseek_r1_drops_thinking_and_reasoning_effort_before_provider")
+def test_deepseek_r1_thinking_and_reasoning_effort_are_dropped_instead_of_leaking_into_converse(
+    gateway: Gateway,
+) -> None:
+    with wire_server(r1_converse_peer) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model=R1_MODEL,
+            api_key=TOKEN,
+            aws_region_name="us-east-1",
+            aws_bedrock_runtime_endpoint=wire.url,
+            drop_params=True,
+        )
+        response: Final = gateway.request(
+            "POST",
+            "/v1/chat/completions",
+            {
+                "model": model,
+                "messages": [{"role": "user", "content": "synthetic r1 request"}],
+                "thinking": {"type": "enabled", "budget_tokens": 1024},
+                "reasoning_effort": "high",
+                "max_tokens": 16,
+                "cache": {"no-cache": True},
+            },
+        )
+        assert response.status_code == 200, response.text
+        assert response.json()["choices"][0]["message"]["content"] == "deepseek reasoning wire control", response.text
+        assert response.json()["usage"]["total_tokens"] == 14, response.text
+        assert len(wire.drain()) == 1
+
+
+@pytest.mark.covers("providers.bedrock_converse.deepseek_v3_reasoning_effort_reaches_provider_raw")
+def test_deepseek_v3_reasoning_effort_reaches_converse_raw_instead_of_as_anthropic_thinking(
+    gateway: Gateway,
+) -> None:
+    with wire_server(v3_converse_peer) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model=V3_MODEL, api_key=TOKEN, aws_region_name="us-east-1", aws_bedrock_runtime_endpoint=wire.url
+        )
+        response: Final = gateway.request(
+            "POST",
+            "/v1/chat/completions",
+            {
+                "model": model,
+                "messages": [{"role": "user", "content": "synthetic v3 request"}],
+                "reasoning_effort": "high",
+                "max_tokens": 16,
+                "cache": {"no-cache": True},
+            },
+        )
+        assert response.status_code == 200, response.text
+        assert response.json()["choices"][0]["message"]["content"] == "deepseek reasoning wire control", response.text
+        assert response.json()["usage"]["total_tokens"] == 14, response.text
+        assert len(wire.drain()) == 1
diff --git a/tests/integration/providers/test_bedrock_invoke_cache_usage_wire.py b/tests/integration/providers/test_bedrock_invoke_cache_usage_wire.py
new file mode 100644
index 000000000000..2638c3a2c8d8
--- /dev/null
+++ b/tests/integration/providers/test_bedrock_invoke_cache_usage_wire.py
@@ -0,0 +1,86 @@
+import json
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway, eventually
+from integration._support.database import read_rows
+from integration._support.wire import Reply, Request, wire_server
+
+MODEL_ID: Final = "us.amazon.nova-pro-v1:0"
+TOKEN: Final = "synthetic-bedrock-bearer"
+PROMPT: Final = "summarize the cached policy"
+INPUT_TOKENS: Final = 11
+OUTPUT_TOKENS: Final = 4
+CACHE_READ_TOKENS: Final = 900
+CACHE_WRITE_TOKENS: Final = 300
+INPUT_RATE: Final = 0.001
+OUTPUT_RATE: Final = 0.002
+CACHE_READ_RATE: Final = 0.0001
+CACHE_WRITE_RATE: Final = 0.0015
+RESPONSE: Final = json.dumps(
+    {
+        "output": {"message": {"role": "assistant", "content": [{"text": "cached policy summary"}]}},
+        "stopReason": "end_turn",
+        "usage": {
+            "inputTokens": INPUT_TOKENS,
+            "outputTokens": OUTPUT_TOKENS,
+            "totalTokens": INPUT_TOKENS + OUTPUT_TOKENS,
+            "cacheReadInputTokenCount": CACHE_READ_TOKENS,
+            "cacheWriteInputTokenCount": CACHE_WRITE_TOKENS,
+        },
+    }
+).encode()
+
+
+def nova_invoke_peer(request: Request) -> Reply:
+    assert request.method == "POST" and request.target == f"/model/{MODEL_ID}/invoke", request.target
+    assert request.headers["authorization"] == f"Bearer {TOKEN}"
+    body: Final = json.loads(request.body)
+    assert body["messages"] == [{"role": "user", "content": [{"text": PROMPT}]}], body
+    return Reply(body=RESPONSE)
+
+
+@pytest.mark.covers("providers.bedrock_invoke.count_suffixed_cache_usage_fields_are_reported_and_charged")
+def test_nova_invoke_count_suffixed_cache_usage_fields_are_reported_and_charged(gateway: Gateway) -> None:
+    with wire_server(nova_invoke_peer) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model=f"bedrock/invoke/{MODEL_ID}",
+            api_key=TOKEN,
+            aws_region_name="us-east-1",
+            api_base=wire.url,
+            input_cost_per_token=INPUT_RATE,
+            output_cost_per_token=OUTPUT_RATE,
+            cache_read_input_token_cost=CACHE_READ_RATE,
+            cache_creation_input_token_cost=CACHE_WRITE_RATE,
+        )
+        response: Final = gateway.request(
+            "POST",
+            "/v1/chat/completions",
+            {"model": model, "max_tokens": 32, "messages": [{"role": "user", "content": PROMPT}]},
+        )
+        assert response.status_code == 200, response.text
+        body: Final = response.json()
+        assert body["choices"][0]["message"]["content"] == "cached policy summary", response.text
+        usage: Final = body["usage"]
+        assert usage["prompt_tokens"] == INPUT_TOKENS + CACHE_READ_TOKENS + CACHE_WRITE_TOKENS, response.text
+        assert usage["completion_tokens"] == OUTPUT_TOKENS, response.text
+        assert usage["prompt_tokens_details"]["cached_tokens"] == CACHE_READ_TOKENS, response.text
+        assert usage["cache_read_input_tokens"] == CACHE_READ_TOKENS, response.text
+        assert usage["cache_creation_input_tokens"] == CACHE_WRITE_TOKENS, response.text
+        expected_cost: Final = (
+            INPUT_TOKENS * INPUT_RATE
+            + CACHE_READ_TOKENS * CACHE_READ_RATE
+            + CACHE_WRITE_TOKENS * CACHE_WRITE_RATE
+            + OUTPUT_TOKENS * OUTPUT_RATE
+        )
+        assert float(response.headers["x-litellm-response-cost"]) == pytest.approx(expected_cost), response.text
+        assert len(wire.drain()) == 1
+        rows: Final = eventually(
+            lambda: read_rows(
+                'SELECT spend, prompt_tokens FROM "LiteLLM_SpendLogs" WHERE request_id=%s', (body["id"],)
+            ),
+            lambda values: len(values) == 1,
+            seconds=70,
+        )
+        assert float(rows[0]["spend"]) == pytest.approx(expected_cost), rows
+        assert rows[0]["prompt_tokens"] == INPUT_TOKENS + CACHE_READ_TOKENS + CACHE_WRITE_TOKENS, rows
diff --git a/tests/integration/providers/test_bedrock_knowledge_base_user_context_wire.py b/tests/integration/providers/test_bedrock_knowledge_base_user_context_wire.py
new file mode 100644
index 000000000000..540b384d6947
--- /dev/null
+++ b/tests/integration/providers/test_bedrock_knowledge_base_user_context_wire.py
@@ -0,0 +1,81 @@
+import json
+import uuid
+from collections.abc import Callable
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+
+ACCESS_KEY: Final = "AKIAINTEGRATION000003"
+USER_CONTEXT: Final = {"userId": "reader@example.com"}
+QUERY: Final = "synthetic knowledge base question"
+RETRIEVE_RESPONSE: Final = json.dumps(
+    {
+        "retrievalResults": [
+            {
+                "content": {"text": "permitted document text"},
+                "score": 0.87,
+                "metadata": {
+                    "x-amz-bedrock-kb-source-uri": "s3://synthetic-bucket/permitted.pdf",
+                    "x-amz-bedrock-kb-chunk-id": "chunk-1",
+                },
+            }
+        ]
+    }
+).encode()
+
+
+def retrieve_peer(knowledge_base_id: str) -> Callable[[Request], Reply]:
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == f"/knowledgebases/{knowledge_base_id}/retrieve", (
+            request.target
+        )
+        assert request.headers["authorization"].startswith(f"AWS4-HMAC-SHA256 Credential={ACCESS_KEY}/")
+        assert json.loads(request.body) == {
+            "retrievalQuery": {"text": QUERY},
+            "retrievalConfiguration": {"vectorSearchConfiguration": {"numberOfResults": 3}},
+            "userContext": USER_CONTEXT,
+        }, request.body
+        return Reply(body=RETRIEVE_RESPONSE)
+
+    return respond
+
+
+@pytest.mark.covers("providers.bedrock_knowledge_base.search_forwards_user_context_to_retrieve")
+def test_vector_store_search_user_context_reaches_bedrock_retrieve_body(gateway: Gateway) -> None:
+    knowledge_base_id: Final = f"KB{uuid.uuid4().hex[:8].upper()}"
+    with wire_server(retrieve_peer(knowledge_base_id)) as wire, gateway.scenario() as scenario:
+        gateway.post(
+            "/vector_store/new",
+            {
+                "vector_store_id": knowledge_base_id,
+                "custom_llm_provider": "bedrock",
+                "litellm_params": {
+                    "aws_region_name": "us-east-1",
+                    "aws_access_key_id": ACCESS_KEY,
+                    "aws_secret_access_key": "synthetic-knowledge-base-secret-key",
+                    "aws_bedrock_runtime_endpoint": wire.url,
+                },
+            },
+        )
+        scenario.cleanups.callback(gateway.post, "/vector_store/delete", {"vector_store_id": knowledge_base_id})
+        response: Final = gateway.request(
+            "POST",
+            f"/v1/vector_stores/{knowledge_base_id}/search",
+            {"query": QUERY, "max_num_results": 3, "userContext": USER_CONTEXT},
+        )
+        assert response.status_code == 200, response.text
+        assert response.json()["data"] == [
+            {
+                "score": 0.87,
+                "content": [{"text": "permitted document text", "type": "text"}],
+                "file_id": "s3://synthetic-bucket/permitted.pdf",
+                "filename": "permitted.pdf",
+                "attributes": {
+                    "x-amz-bedrock-kb-source-uri": "s3://synthetic-bucket/permitted.pdf",
+                    "x-amz-bedrock-kb-chunk-id": "chunk-1",
+                },
+            }
+        ], response.text
+        assert len(wire.drain()) == 1
diff --git a/tests/integration/providers/test_bedrock_mantle_codex_input_wire.py b/tests/integration/providers/test_bedrock_mantle_codex_input_wire.py
index bb7961160dc2..aa66e82475b9 100644
--- a/tests/integration/providers/test_bedrock_mantle_codex_input_wire.py
+++ b/tests/integration/providers/test_bedrock_mantle_codex_input_wire.py
@@ -86,3 +86,56 @@ def mantle_peer(request: Request) -> Reply:
         forwarded: Final = wire.drain()
         assert len(forwarded) == 1, forwarded
         assert JSON_OBJECT.validate_json(forwarded[0].body)["input"] == expected_input, forwarded[0].body
+
+
+SHELL_TOOL: Final[JsonValue] = {
+    "type": "function",
+    "name": "shell",
+    "description": "run a shell command",
+    "parameters": {"type": "object", "properties": {"command": {"type": "string"}}, "required": ["command"]},
+}
+APPLY_PATCH_TOOL: Final[JsonValue] = {
+    "type": "function",
+    "name": "apply_patch",
+    "description": "apply a diff",
+    "parameters": {"type": "object", "properties": {"patch": {"type": "string"}}, "required": ["patch"]},
+}
+
+
+@pytest.mark.covers("providers.bedrock_mantle.codex_additional_tools_input_item_is_hoisted_to_top_level_tools")
+def test_codex_additional_tools_input_item_reaches_mantle_as_top_level_tools(gateway: Gateway) -> None:
+    marker: Final = uuid.uuid4().hex
+    expected_input: Final[list[JsonValue]] = [user_turn(f"hoist tools {marker}")]
+    expected_tools: Final[list[JsonValue]] = [SHELL_TOOL, APPLY_PATCH_TOOL]
+
+    def mantle_peer(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == "/openai/v1/responses", request.target
+        assert request.headers["authorization"] == f"Bearer {TOKEN}"
+        body: Final = JSON_OBJECT.validate_json(request.body)
+        assert body["model"] == "openai.gpt-5.6-sol", body
+        assert body["input"] == expected_input, body["input"]
+        assert body["tools"] == expected_tools, body
+        return Reply(body=RESPONSE)
+
+    with wire_server(mantle_peer) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model=MODEL, api_key=TOKEN, api_base=wire.url, aws_region_name="us-east-2")
+        response: Final = gateway.request(
+            "POST",
+            "/v1/responses",
+            {
+                "model": model,
+                "input": [
+                    {"type": "additional_tools", "role": "developer", "tools": [APPLY_PATCH_TOOL]},
+                    user_turn(f"hoist tools {marker}"),
+                ],
+                "tools": [SHELL_TOOL],
+                "store": False,
+            },
+        )
+        assert response.status_code == 200, response.text
+        assert response.json()["output"][0]["content"][0]["text"] == "mantle wire control", response.text
+        forwarded: Final = wire.drain()
+        assert len(forwarded) == 1, forwarded
+        forwarded_body: Final = JSON_OBJECT.validate_json(forwarded[0].body)
+        assert forwarded_body["input"] == expected_input, forwarded[0].body
+        assert forwarded_body["tools"] == expected_tools, forwarded[0].body
diff --git a/tests/integration/providers/test_bedrock_mantle_responses_wire.py b/tests/integration/providers/test_bedrock_mantle_responses_wire.py
index 9bc6f83f8e4d..3bd83b5019be 100644
--- a/tests/integration/providers/test_bedrock_mantle_responses_wire.py
+++ b/tests/integration/providers/test_bedrock_mantle_responses_wire.py
@@ -104,3 +104,43 @@ def test_codex_agent_message_compaction_and_local_shell_items_are_rewritten_for_
             }
         ], response.text
         assert [(request.method, request.target) for request in wire.drain()] == [("POST", "/openai/v1/responses")]
+
+
+_MANTLE_MIN_MAX_OUTPUT_TOKENS: Final = 16
+
+
+def _mantle_peer_expecting_max_output_tokens(marker: str, expected: int) -> Callable[[Request], Reply]:
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == "/openai/v1/responses", request.target
+        body: Final = _JSON_OBJECT.validate_json(request.body)
+        assert body["max_output_tokens"] == expected, request.body.decode()
+        assert body["input"] == f"clamp probe {marker}", request.body.decode()
+        return Reply(body=_RESPONSE)
+
+    return respond
+
+
+@pytest.mark.covers("providers.bedrock_mantle.max_output_tokens_below_minimum_is_clamped_to_16_on_the_wire")
+def test_max_output_tokens_below_mantle_minimum_is_raised_to_16_before_reaching_mantle(gateway: Gateway) -> None:
+    marker: Final = uuid4().hex
+    peer: Final = _mantle_peer_expecting_max_output_tokens(marker, _MANTLE_MIN_MAX_OUTPUT_TOKENS)
+    with wire_server(peer) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model=_MODEL, api_base=wire.url, api_key=_TOKEN, aws_region_name="us-east-1")
+        response: Final = gateway.request(
+            "POST",
+            "/v1/responses",
+            {"model": model, "input": f"clamp probe {marker}", "max_output_tokens": 5, "stream": False},
+        )
+        assert response.status_code == 200, response.text
+        payload: Final = _JSON_OBJECT.validate_json(response.content)
+        assert payload["status"] == "completed", response.text
+        assert payload["output"] == [
+            {
+                **_OUTPUT_MESSAGE,
+                "phase": None,
+                "content": [
+                    {"type": "output_text", "text": "mantle wire control", "annotations": [], "logprobs": None}
+                ],
+            }
+        ], response.text
+        assert [(request.method, request.target) for request in wire.drain()] == [("POST", "/openai/v1/responses")]
diff --git a/tests/integration/providers/test_bedrock_mantle_wire.py b/tests/integration/providers/test_bedrock_mantle_wire.py
index 48cd0d770aa5..ec32fe5a578d 100644
--- a/tests/integration/providers/test_bedrock_mantle_wire.py
+++ b/tests/integration/providers/test_bedrock_mantle_wire.py
@@ -1,5 +1,7 @@
 import json
+from collections.abc import Callable
 from typing import Final
+from uuid import uuid4
 
 import pytest
 from integration._support.client import Gateway
@@ -51,3 +53,142 @@ def test_bedrock_mantle_context_overflow_returns_400_saying_prompt_is_too_long(g
         assert isinstance(message, str), response.text
         assert f"prompt is too long: {_PROMPT_TOKENS} tokens > {_MODEL_MAXIMUM} maximum" in message, response.text
         assert [(request.method, request.target) for request in wire.drain()] == [("POST", _RESPONSES_PATH)]
+
+
+_ACCESS_KEY: Final = "AKIAINTEGRATION000003"
+_SIGV4_PROMPT: Final = "synthetic sigv4 bridge control"
+_SIGV4_RESPONSE: Final = json.dumps(
+    {
+        "id": "resp_synthetic_mantle_sigv4",
+        "object": "response",
+        "created_at": 1789788253,
+        "status": "completed",
+        "model": _BACKEND,
+        "output": [
+            {
+                "type": "message",
+                "id": "msg_synthetic_mantle_sigv4",
+                "status": "completed",
+                "role": "assistant",
+                "content": [{"type": "output_text", "text": "mantle sigv4 wire control", "annotations": []}],
+            }
+        ],
+        "usage": {"input_tokens": 21, "output_tokens": 4, "total_tokens": 25},
+    }
+).encode()
+
+
+def _sigv4_peer(request: Request) -> Reply:
+    assert request.method == "POST" and request.target == _RESPONSES_PATH, request.target
+    assert request.headers["authorization"].startswith(f"AWS4-HMAC-SHA256 Credential={_ACCESS_KEY}/"), dict(
+        request.headers
+    )
+    body: Final = _JSON_OBJECT.validate_json(request.body)
+    assert body["model"] == _BACKEND, body
+    assert _SIGV4_PROMPT in json.dumps(body["input"]), body
+    return Reply(body=_SIGV4_RESPONSE)
+
+
+@pytest.mark.covers("providers.bedrock_mantle.chat_bridge_keeps_deployment_aws_credentials_for_sigv4")
+def test_chat_completions_bridge_signs_mantle_responses_request_with_deployment_aws_keys(gateway: Gateway) -> None:
+    with wire_server(_sigv4_peer) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model=f"bedrock_mantle/{_BACKEND}",
+            api_base=wire.url,
+            api_key=None,
+            aws_access_key_id=_ACCESS_KEY,
+            aws_secret_access_key="synthetic-secret-key-for-testing",
+            aws_region_name="us-east-1",
+        )
+        response: Final = gateway.request(
+            "POST",
+            "/v1/chat/completions",
+            {"model": model, "messages": [{"role": "user", "content": _SIGV4_PROMPT}]},
+        )
+        assert response.status_code == 200, response.text
+        body: Final = _JSON_OBJECT.validate_json(response.content)
+        choices: Final = body["choices"]
+        assert isinstance(choices, list) and len(choices) == 1, response.text
+        choice: Final = choices[0]
+        assert isinstance(choice, dict), response.text
+        assert choice["message"] == {"role": "assistant", "content": "mantle sigv4 wire control"}, response.text
+        assert [(request.method, request.target) for request in wire.drain()] == [("POST", _RESPONSES_PATH)]
+
+
+_CLAUDE_BACKEND: Final = "anthropic.claude-sonnet-5-v1:0"
+_MESSAGES_PATH: Final = "/anthropic/v1/messages"
+_STREAM_EVENTS: Final = (
+    (
+        "message_start",
+        {
+            "message": {
+                "id": "msg_mantle_stream",
+                "type": "message",
+                "role": "assistant",
+                "model": _CLAUDE_BACKEND,
+                "content": [],
+                "stop_reason": None,
+                "stop_sequence": None,
+                "usage": {"input_tokens": 11, "output_tokens": 1},
+            }
+        },
+    ),
+    ("content_block_start", {"index": 0, "content_block": {"type": "text", "text": ""}}),
+    ("content_block_delta", {"index": 0, "delta": {"type": "text_delta", "text": "mantle "}}),
+    ("content_block_delta", {"index": 0, "delta": {"type": "text_delta", "text": "stream control"}}),
+    ("content_block_stop", {"index": 0}),
+    ("message_delta", {"delta": {"stop_reason": "end_turn", "stop_sequence": None}, "usage": {"output_tokens": 4}}),
+    ("message_stop", {}),
+)
+_STREAM_FRAMES: Final = tuple(
+    f"event: {kind}\ndata: {json.dumps({'type': kind, **payload})}\n\n".encode() for kind, payload in _STREAM_EVENTS
+)
+
+
+def _streaming_messages_peer(prompt: str) -> Callable[[Request], Reply]:
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST"
+        assert request.target == _MESSAGES_PATH
+        assert request.headers["authorization"] == f"Bearer {_API_KEY}"
+        body: Final = _JSON_OBJECT.validate_json(request.body)
+        assert body["model"] == _CLAUDE_BACKEND, body
+        assert body["stream"] is True, body
+        assert body["messages"] == [{"role": "user", "content": prompt}], body
+        return Reply(content_type="text/event-stream", chunks=_STREAM_FRAMES)
+
+    return respond
+
+
+@pytest.mark.covers("providers.bedrock_mantle.messages_stream_sends_stream_true_and_relays_sse_events")
+def test_bedrock_mantle_messages_stream_relays_anthropic_sse_instead_of_failing_on_event_stream_decode(
+    gateway: Gateway,
+) -> None:
+    prompt: Final = f"synthetic mantle stream control {uuid4().hex}"
+    with wire_server(_streaming_messages_peer(prompt)) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model=f"bedrock_mantle/{_CLAUDE_BACKEND}", api_base=wire.url, api_key=_API_KEY, aws_region_name="us-east-1"
+        )
+        with gateway.client.stream(
+            "POST",
+            "/v1/messages",
+            json={
+                "model": model,
+                "max_tokens": 64,
+                "stream": True,
+                "messages": [{"role": "user", "content": prompt}],
+            },
+            headers={"Authorization": f"Bearer {gateway.key}"},
+        ) as response:
+            assert response.status_code == 200, response.read().decode()
+            assert response.headers["content-type"].startswith("text/event-stream"), dict(response.headers)
+            events: Final = tuple(
+                _JSON_OBJECT.validate_json(line.removeprefix("data: "))
+                for line in response.iter_lines()
+                if line.startswith("data: ")
+            )
+        assert tuple(event["type"] for event in events) == tuple(kind for kind, _ in _STREAM_EVENTS), events
+        assert (
+            "".join(str(event["delta"]["text"]) for event in events if event["type"] == "content_block_delta")
+            == "mantle stream control"
+        ), events
+        assert [(request.method, request.target) for request in wire.drain()] == [("POST", _MESSAGES_PATH)]
diff --git a/tests/integration/providers/test_bedrock_marengo_embed_3_wire.py b/tests/integration/providers/test_bedrock_marengo_embed_3_wire.py
new file mode 100644
index 000000000000..9cdedef6ef66
--- /dev/null
+++ b/tests/integration/providers/test_bedrock_marengo_embed_3_wire.py
@@ -0,0 +1,35 @@
+import json
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+
+MODEL: Final = "bedrock/us.twelvelabs.marengo-embed-3-0-v1:0"
+TOKEN: Final = "synthetic-bedrock-bearer"
+INPUT: Final = "hello world"
+VECTOR: Final = [0.1, 0.2, 0.3]
+RESPONSE: Final = json.dumps({"data": [{"embedding": VECTOR}]}).encode()
+
+
+def marengo_3_peer(request: Request) -> Reply:
+    assert request.method == "POST", request.method
+    assert request.target == "/model/us.twelvelabs.marengo-embed-3-0-v1%3A0/invoke", request.target
+    assert request.headers["authorization"] == f"Bearer {TOKEN}"
+    assert json.loads(request.body) == {"inputType": "text", "text": {"inputText": INPUT}}, request.body
+    return Reply(body=RESPONSE)
+
+
+@pytest.mark.covers("providers.bedrock_embedding.marengo_3_text_input_reaches_bedrock_nested_under_input_type")
+def test_marengo_3_text_embedding_nests_input_text_under_input_type(gateway: Gateway) -> None:
+    with wire_server(marengo_3_peer) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model=MODEL,
+            api_key=TOKEN,
+            api_base=wire.url,
+            aws_region_name="us-east-1",
+        )
+        response: Final = gateway.request("POST", "/v1/embeddings", {"model": model, "input": INPUT})
+        assert response.status_code == 200, response.text
+        assert response.json()["data"] == [{"object": "embedding", "index": 0, "embedding": VECTOR}], response.text
+        assert len(wire.drain()) == 1, "the embedding request never reached Bedrock"
diff --git a/tests/integration/providers/test_bedrock_role_configuration.py b/tests/integration/providers/test_bedrock_role_configuration.py
index ac8edbdfde03..857535e5e352 100644
--- a/tests/integration/providers/test_bedrock_role_configuration.py
+++ b/tests/integration/providers/test_bedrock_role_configuration.py
@@ -7,7 +7,6 @@
 
 import pytest
 import yaml
-
 from integration._support.client import Gateway
 from integration._support.process import owned_proxy
 from integration._support.wire import Reply, Request, wire_server
@@ -30,7 +29,10 @@ def sts(request: Request) -> Reply:
             assert parameters["RoleArn"] == [role]
             assert parameters["RoleSessionName"][0] in {"integration-yaml-session", "integration-db-session"}
             result = f"<AssumeRoleResult><Credentials><AccessKeyId>{assumed_key}</AccessKeyId><SecretAccessKey>synthetic-assumed-secret-key-for-testing</SecretAccessKey><SessionToken>{assumed_token}</SessionToken><Expiration>2035-01-01T00:00:00Z</Expiration></Credentials><AssumedRoleUser><Arn>arn:aws:sts::123456789012:assumed-role/integration/session</Arn><AssumedRoleId>integration:session</AssumedRoleId></AssumedRoleUser><PackedPolicySize>0</PackedPolicySize></AssumeRoleResult>"
-        return Reply(content_type="text/xml", body=f'<{action}Response xmlns="https://sts.amazonaws.com/doc/2011-06-15/">{result}<ResponseMetadata><RequestId>synthetic-sts-request</RequestId></ResponseMetadata></{action}Response>'.encode())
+        return Reply(
+            content_type="text/xml",
+            body=f'<{action}Response xmlns="https://sts.amazonaws.com/doc/2011-06-15/">{result}<ResponseMetadata><RequestId>synthetic-sts-request</RequestId></ResponseMetadata></{action}Response>'.encode(),
+        )
 
     def bedrock(request: Request) -> Reply:
         assert request.method == "POST" and request.target == "/model/anthropic.claude-3-haiku-20240307-v1%3A0/converse"
@@ -41,8 +43,11 @@ def bedrock(request: Request) -> Reply:
 
     with wire_server(sts) as authority, wire_server(bedrock) as provider:
         parameters: Final = {
-            "model": MODEL, "aws_region_name": "us-east-1", "aws_role_name": "os.environ/INTEGRATION_ROLE_ARN",
-            "aws_session_name": "integration-yaml-session", "aws_bedrock_runtime_endpoint": provider.url,
+            "model": MODEL,
+            "aws_region_name": "us-east-1",
+            "aws_role_name": "os.environ/INTEGRATION_ROLE_ARN",
+            "aws_session_name": "integration-yaml-session",
+            "aws_bedrock_runtime_endpoint": provider.url,
             "aws_sts_endpoint": authority.url,
         }
         alias: Final = "integration-role-yaml-" + uuid.uuid4().hex
@@ -53,23 +58,144 @@ def bedrock(request: Request) -> Reply:
         empty: Final = tmp_path / "empty-aws-config"
         empty.write_text("")
         overrides: Final = {
-            "INTEGRATION_ROLE_ARN": role, "AWS_ACCESS_KEY_ID": "AKIAINTEGRATION000001", "AWS_SECRET_ACCESS_KEY": "synthetic-source-secret-key-for-testing",
-            "AWS_CONFIG_FILE": str(empty), "AWS_SHARED_CREDENTIALS_FILE": str(empty), "AWS_EC2_METADATA_DISABLED": "true",
-            "AWS_ENDPOINT_URL_STS": authority.url, "AWS_DEFAULT_REGION": "us-east-1", "LITELLM_RUST": "false",
+            "INTEGRATION_ROLE_ARN": role,
+            "AWS_ACCESS_KEY_ID": "AKIAINTEGRATION000001",
+            "AWS_SECRET_ACCESS_KEY": "synthetic-source-secret-key-for-testing",
+            "AWS_CONFIG_FILE": str(empty),
+            "AWS_SHARED_CREDENTIALS_FILE": str(empty),
+            "AWS_EC2_METADATA_DISABLED": "true",
+            "AWS_ENDPOINT_URL_STS": authority.url,
+            "AWS_DEFAULT_REGION": "us-east-1",
+            "LITELLM_RUST": "false",
         }
-        with owned_proxy(gateway, tmp_path, overrides, config=path, remove_environment=tuple(name for name in os.environ if name.startswith("AWS_"))) as candidate, candidate.scenario() as scenario:
-            database_model: Final = scenario.model(**{**parameters, "api_key": None, "aws_session_name": "integration-db-session"})
+        with (
+            owned_proxy(
+                gateway,
+                tmp_path,
+                overrides,
+                config=path,
+                remove_environment=tuple(name for name in os.environ if name.startswith("AWS_")),
+            ) as candidate,
+            candidate.scenario() as scenario,
+        ):
+            database_model: Final = scenario.model(
+                **{**parameters, "api_key": None, "aws_session_name": "integration-db-session"}
+            )
             for generation in range(2):
                 for model in (alias, database_model):
-                    response: Final = candidate.request("POST", "/v1/chat/completions", {"model": model, "messages": [{"role": "user", "content": "synthetic role request"}], "cache": {"no-cache": True}})
+                    response: Final = candidate.request(
+                        "POST",
+                        "/v1/chat/completions",
+                        {
+                            "model": model,
+                            "messages": [{"role": "user", "content": "synthetic role request"}],
+                            "cache": {"no-cache": True},
+                        },
+                    )
                     assert response.status_code == 200, response.text
                     assert response.json()["choices"][0]["message"]["content"] == "bedrock wire control"
                     assert response.json()["usage"]["total_tokens"] == 15
                     assert len(provider.drain()) == 1
                 if generation == 0:
-                    target: Final = next(entry for entry in candidate.get("/model/info")["data"] if entry["model_name"] == database_model)
-                    response: Final = candidate.request("PATCH", f"/model/{target['model_info']['id']}/update", {"model_info": {"description": "role reload"}})
+                    target: Final = next(
+                        entry for entry in candidate.get("/model/info")["data"] if entry["model_name"] == database_model
+                    )
+                    response: Final = candidate.request(
+                        "PATCH",
+                        f"/model/{target['model_info']['id']}/update",
+                        {"model_info": {"description": "role reload"}},
+                    )
                     assert response.status_code == 200, response.text
-            assumed: Final = tuple(parse_qs(request.body.decode()) for request in authority.drain() if parse_qs(request.body.decode())["Action"] == ["AssumeRole"])
-            assert {entry["RoleSessionName"][0] for entry in assumed} == {"integration-yaml-session", "integration-db-session"}
+            assumed: Final = tuple(
+                parse_qs(request.body.decode())
+                for request in authority.drain()
+                if parse_qs(request.body.decode())["Action"] == ["AssumeRole"]
+            )
+            assert {entry["RoleSessionName"][0] for entry in assumed} == {
+                "integration-yaml-session",
+                "integration-db-session",
+            }
             assert all(entry["RoleArn"] == [role] for entry in assumed)
+
+
+@pytest.mark.covers("providers.bedrock_assume_role.repeat_requests_reuse_cached_sts_session_per_session_name")
+def test_repeat_requests_under_one_session_name_assume_role_once_per_session_name(
+    gateway: Gateway, tmp_path: Path
+) -> None:
+    role: Final = "arn:aws:iam::123456789012:role/integration-" + uuid.uuid4().hex
+    assumed_key: Final = "ASIAINTEGRATION000002"
+    assumed_token: Final = "synthetic-cached-session-token"
+    first_session: Final = "integration-attributed-user-a-" + uuid.uuid4().hex[:8]
+    second_session: Final = "integration-attributed-user-b-" + uuid.uuid4().hex[:8]
+
+    def sts(request: Request) -> Reply:
+        parameters: Final = parse_qs(request.body.decode())
+        action: Final = parameters["Action"][0]
+        assert request.method == "POST" and action in {"GetCallerIdentity", "AssumeRole"}
+        if action == "GetCallerIdentity":
+            result = "<GetCallerIdentityResult><Arn>arn:aws:iam::123456789012:user/integration-source</Arn><UserId>integration-source</UserId><Account>123456789012</Account></GetCallerIdentityResult>"
+        else:
+            assert parameters["RoleArn"] == [role]
+            result = f"<AssumeRoleResult><Credentials><AccessKeyId>{assumed_key}</AccessKeyId><SecretAccessKey>synthetic-assumed-secret-key-for-testing</SecretAccessKey><SessionToken>{assumed_token}</SessionToken><Expiration>2035-01-01T00:00:00Z</Expiration></Credentials><AssumedRoleUser><Arn>arn:aws:sts::123456789012:assumed-role/integration/session</Arn><AssumedRoleId>integration:session</AssumedRoleId></AssumedRoleUser><PackedPolicySize>0</PackedPolicySize></AssumeRoleResult>"
+        return Reply(
+            content_type="text/xml",
+            body=f'<{action}Response xmlns="https://sts.amazonaws.com/doc/2011-06-15/">{result}<ResponseMetadata><RequestId>synthetic-sts-request</RequestId></ResponseMetadata></{action}Response>'.encode(),
+        )
+
+    def bedrock(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == "/model/anthropic.claude-3-haiku-20240307-v1%3A0/converse"
+        assert f"Credential={assumed_key}/" in request.headers["authorization"]
+        assert request.headers["x-amz-security-token"] == assumed_token
+        return Reply(body=RESPONSE)
+
+    with wire_server(sts) as authority, wire_server(bedrock) as provider:
+        empty: Final = tmp_path / "empty-aws-config"
+        empty.write_text("")
+        overrides: Final = {
+            "AWS_ACCESS_KEY_ID": "AKIAINTEGRATION000002",
+            "AWS_SECRET_ACCESS_KEY": "synthetic-source-secret-key-for-testing",
+            "AWS_CONFIG_FILE": str(empty),
+            "AWS_SHARED_CREDENTIALS_FILE": str(empty),
+            "AWS_EC2_METADATA_DISABLED": "true",
+            "AWS_ENDPOINT_URL_STS": authority.url,
+            "AWS_DEFAULT_REGION": "us-east-1",
+            "LITELLM_RUST": "false",
+        }
+        with (
+            owned_proxy(
+                gateway,
+                tmp_path,
+                overrides,
+                remove_environment=tuple(name for name in os.environ if name.startswith("AWS_")),
+            ) as candidate,
+            candidate.scenario() as scenario,
+        ):
+            parameters: Final = {
+                "model": MODEL,
+                "api_key": None,
+                "aws_region_name": "us-east-1",
+                "aws_role_name": role,
+                "aws_bedrock_runtime_endpoint": provider.url,
+                "aws_sts_endpoint": authority.url,
+            }
+            first_model: Final = scenario.model(**{**parameters, "aws_session_name": first_session})
+            second_model: Final = scenario.model(**{**parameters, "aws_session_name": second_session})
+            for model in (first_model, first_model, second_model, second_model):
+                response: Final = candidate.request(
+                    "POST",
+                    "/v1/chat/completions",
+                    {
+                        "model": model,
+                        "messages": [{"role": "user", "content": "synthetic cached role request"}],
+                        "cache": {"no-cache": True},
+                    },
+                )
+                assert response.status_code == 200, response.text
+                assert response.json()["choices"][0]["message"]["content"] == "bedrock wire control"
+                assert len(provider.drain()) == 1
+            assumed: Final = tuple(
+                parse_qs(request.body.decode())
+                for request in authority.drain()
+                if parse_qs(request.body.decode())["Action"] == ["AssumeRole"]
+            )
+            assert tuple(entry["RoleSessionName"][0] for entry in assumed) == (first_session, second_session), assumed
diff --git a/tests/integration/providers/test_bedrock_thinking_tokens_wire.py b/tests/integration/providers/test_bedrock_thinking_tokens_wire.py
index 074adeb41f64..19d7b1e291ce 100644
--- a/tests/integration/providers/test_bedrock_thinking_tokens_wire.py
+++ b/tests/integration/providers/test_bedrock_thinking_tokens_wire.py
@@ -1,4 +1,5 @@
 import json
+import uuid
 from typing import Final
 
 import pytest
@@ -34,13 +35,13 @@
 _JSON_LIST: Final = TypeAdapter(list[dict[str, JsonValue]])
 
 
-def redacted_thinking_peer(request: Request) -> Reply:
+def redacted_thinking_peer(request: Request, prompts: tuple[str, str]) -> Reply:
     assert request.method == "POST" and request.target == "/model/global.anthropic.claude-opus-4-8/converse"
     assert request.headers["authorization"] == f"Bearer {TOKEN}"
     body: Final = json.loads(request.body)
     assert body["messages"] in (
-        [{"role": "user", "content": [{"text": PROMPT}]}],
-        [{"role": "user", "content": [{"text": RESPONSES_PROMPT}]}],
+        [{"role": "user", "content": [{"text": prompts[0]}]}],
+        [{"role": "user", "content": [{"text": prompts[1]}]}],
     ), body
     assert body["additionalModelRequestFields"]["thinking"]["type"] == "adaptive", body
     return Reply(body=RESPONSE)
@@ -48,7 +49,9 @@ def redacted_thinking_peer(request: Request) -> Reply:
 
 @pytest.mark.covers("other.provider_wire.bedrock.hidden_thinking_tokens_are_not_reported_as_text")
 def test_bedrock_redacted_thinking_is_not_reported_as_zero_reasoning_tokens(gateway: Gateway) -> None:
-    with wire_server(redacted_thinking_peer) as wire, gateway.scenario() as scenario:
+    identity: Final = " " + uuid.uuid4().hex
+    prompts: Final = (PROMPT + identity, RESPONSES_PROMPT + identity)
+    with wire_server(lambda request: redacted_thinking_peer(request, prompts)) as wire, gateway.scenario() as scenario:
         model: Final = scenario.model(
             model=MODEL, api_key=TOKEN, aws_region_name="us-east-1", aws_bedrock_runtime_endpoint=wire.url
         )
@@ -57,7 +60,7 @@ def test_bedrock_redacted_thinking_is_not_reported_as_zero_reasoning_tokens(gate
             "/v1/chat/completions",
             {
                 "model": model,
-                "messages": [{"role": "user", "content": PROMPT}],
+                "messages": [{"role": "user", "content": prompts[0]}],
                 "max_tokens": 4000,
                 "reasoning_effort": "max",
             },
@@ -76,7 +79,7 @@ def test_bedrock_redacted_thinking_is_not_reported_as_zero_reasoning_tokens(gate
         responses: Final = gateway.request(
             "POST",
             "/v1/responses",
-            {"model": model, "input": RESPONSES_PROMPT, "max_output_tokens": 4000, "reasoning": {"effort": "max"}},
+            {"model": model, "input": prompts[1], "max_output_tokens": 4000, "reasoning": {"effort": "max"}},
         )
         assert responses.status_code == 200, responses.text
         responses_body: Final = _JSON_OBJECT.validate_json(responses.content)
diff --git a/tests/integration/providers/test_fireworks_ai_session_affinity_wire.py b/tests/integration/providers/test_fireworks_ai_session_affinity_wire.py
new file mode 100644
index 000000000000..9c8490a45914
--- /dev/null
+++ b/tests/integration/providers/test_fireworks_ai_session_affinity_wire.py
@@ -0,0 +1,69 @@
+import json
+import uuid
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway, eventually, object_value
+from integration._support.database import read_rows
+from integration._support.wire import Reply, Request, wire_server
+from pydantic import JsonValue, TypeAdapter
+
+_MODEL: Final = "accounts/fireworks/models/kimi-k3"
+_API_KEY: Final = "synthetic-fireworks-key"
+_PROMPT: Final = "keep this conversation on one replica"
+_SESSION_ID: Final = "conversation-affinity-6220"
+_CACHED_TOKENS: Final = 7
+_JSON_OBJECT: Final = TypeAdapter(dict[str, JsonValue])
+
+
+def _cached_reply(request: Request, identity: str) -> Reply:
+    assert request.method == "POST"
+    assert request.target == "/chat/completions"
+    assert request.headers["authorization"] == f"Bearer {_API_KEY}"
+    body: Final = _JSON_OBJECT.validate_json(request.body)
+    assert body["model"] == _MODEL, body
+    return Reply(
+        body=json.dumps(
+            {
+                "id": identity,
+                "object": "chat.completion",
+                "created": 1,
+                "model": _MODEL,
+                "choices": [
+                    {"index": 0, "message": {"role": "assistant", "content": "pinned"}, "finish_reason": "stop"}
+                ],
+                "usage": {
+                    "prompt_tokens": 12,
+                    "completion_tokens": 1,
+                    "total_tokens": 13,
+                    "prompt_tokens_details": {"cached_tokens": _CACHED_TOKENS},
+                },
+            }
+        ).encode()
+    )
+
+
+@pytest.mark.covers("other.provider_wire.fireworks_ai.session_id_sent_as_affinity_header_and_cached_tokens_logged")
+def test_fireworks_session_id_sends_affinity_header_and_logs_cache_read_tokens(gateway: Gateway) -> None:
+    identity: Final = f"fw-session-affinity-{uuid.uuid4().hex}"
+    with wire_server(lambda request: _cached_reply(request, identity)) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model=f"fireworks_ai/{_MODEL}", api_base=wire.url, api_key=_API_KEY)
+        response: Final = gateway.request(
+            "POST",
+            "/v1/chat/completions",
+            {"model": model, "messages": [{"role": "user", "content": _PROMPT}]},
+            headers={"x-litellm-session-id": _SESSION_ID},
+        )
+        assert response.status_code == 200, response.text
+        payload: Final = _JSON_OBJECT.validate_json(response.content)
+        assert payload["id"] == identity, response.text
+        requests: Final = wire.drain()
+        assert [(request.method, request.target) for request in requests] == [("POST", "/chat/completions")]
+        assert requests[0].headers.get("x-session-affinity") == _SESSION_ID, requests[0].headers
+        rows: Final = eventually(
+            lambda: read_rows('SELECT metadata FROM "LiteLLM_SpendLogs" WHERE request_id=%s', (identity,)),
+            lambda values: len(values) == 1,
+            seconds=70,
+        )
+        usage_values: Final = object_value(object_value(rows[0]["metadata"])["additional_usage_values"])
+        assert usage_values.get("cache_read_input_tokens") == _CACHED_TOKENS, rows[0]["metadata"]
diff --git a/tests/integration/providers/test_gemini_messages_cache_control_wire.py b/tests/integration/providers/test_gemini_messages_cache_control_wire.py
new file mode 100644
index 000000000000..71073b3dd5eb
--- /dev/null
+++ b/tests/integration/providers/test_gemini_messages_cache_control_wire.py
@@ -0,0 +1,86 @@
+import json
+import uuid
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+from pydantic import JsonValue, TypeAdapter
+
+_BACKEND: Final = "gemini-2.5-flash"
+_API_KEY: Final = "synthetic-gemini-key"
+_CACHE_NAME: Final = "cachedContents/synthetic-cache"
+_CACHED_POLICY: Final = " ".join(f"policy clause {index} applies" for index in range(600))
+_JSON_OBJECT: Final = TypeAdapter(dict[str, JsonValue])
+
+
+def _generate_content_reply(text: str) -> bytes:
+    return json.dumps(
+        {
+            "candidates": [
+                {"content": {"parts": [{"text": text}], "role": "model"}, "finishReason": "STOP", "index": 0}
+            ],
+            "usageMetadata": {
+                "promptTokenCount": 1300,
+                "candidatesTokenCount": 5,
+                "totalTokenCount": 1305,
+                "cachedContentTokenCount": 1290,
+            },
+            "modelVersion": _BACKEND,
+        }
+    ).encode()
+
+
+@pytest.mark.covers("other.provider_wire.gemini.messages_cache_control_creates_cached_content_with_anthropic_ttl")
+def test_gemini_messages_cache_control_creates_cached_content_and_generates_from_it(gateway: Gateway) -> None:
+    identity: Final = f"gemini-messages-cache-{uuid.uuid4().hex}"
+    user_prompt: Final = f"Summarize the policy. Request {identity}."
+
+    def respond(request: Request) -> Reply:
+        assert request.headers["x-goog-api-key"] == _API_KEY, request.headers
+        if request.method == "GET":
+            assert request.target == f"/models/{_BACKEND}:cachedContents", request.target
+            return Reply(body=b"{}")
+        assert request.method == "POST", request.method
+        body: Final = _JSON_OBJECT.validate_json(request.body)
+        if request.target == f"/models/{_BACKEND}:cachedContents":
+            assert isinstance(body["displayName"], str) and body["displayName"], body
+            assert body == {
+                "contents": [{"role": "user", "parts": [{"text": "."}]}],
+                "model": f"models/{_BACKEND}",
+                "displayName": body["displayName"],
+                "ttl": "300s",
+                "system_instruction": {"parts": [{"text": _CACHED_POLICY}]},
+                "tools": None,
+            }
+            return Reply(body=json.dumps({"name": _CACHE_NAME, "model": f"models/{_BACKEND}"}).encode())
+        assert request.target == f"/models/{_BACKEND}:generateContent", request.target
+        assert body == {
+            "contents": [{"role": "user", "parts": [{"text": user_prompt}]}],
+            "generationConfig": {"max_output_tokens": 32},
+            "cachedContent": _CACHE_NAME,
+        }
+        return Reply(body=_generate_content_reply("The policy applies."))
+
+    with wire_server(respond) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model=f"gemini/{_BACKEND}", api_base=wire.url, api_key=_API_KEY)
+        response: Final = gateway.request(
+            "POST",
+            "/v1/messages",
+            {
+                "model": model,
+                "max_tokens": 32,
+                "system": [
+                    {"type": "text", "text": _CACHED_POLICY, "cache_control": {"type": "ephemeral", "ttl": "5m"}}
+                ],
+                "messages": [{"role": "user", "content": user_prompt}],
+            },
+        )
+        assert response.status_code == 200, response.text
+        payload: Final = _JSON_OBJECT.validate_json(response.content)
+        assert payload["content"] == [{"type": "text", "text": "The policy applies."}], response.text
+        assert [(request.method, request.target) for request in wire.drain()] == [
+            ("GET", f"/models/{_BACKEND}:cachedContents"),
+            ("POST", f"/models/{_BACKEND}:cachedContents"),
+            ("POST", f"/models/{_BACKEND}:generateContent"),
+        ]
diff --git a/tests/integration/providers/test_nvidia_nim_ranking_wire.py b/tests/integration/providers/test_nvidia_nim_ranking_wire.py
new file mode 100644
index 000000000000..9ed7a4eb48e1
--- /dev/null
+++ b/tests/integration/providers/test_nvidia_nim_ranking_wire.py
@@ -0,0 +1,47 @@
+import json
+from typing import Final
+
+import pytest
+from integration._support.client import JSON_OBJECT, Gateway
+from integration._support.wire import Reply, Request, wire_server
+
+MODEL: Final = "nvidia_nim/ranking/nvidia/llama-3.2-nv-rerankqa-1b-v2"
+QUERY: Final = "which passage shows the gateway diagram"
+IMAGE_PASSAGE: Final = "data:image/png;base64,aW50ZWdyYXRpb24tc3ludGhldGljLWltYWdl"
+TEXT_PASSAGE: Final = "the gateway proxies rerank calls"
+RESPONSE: Final = json.dumps(
+    {"rankings": [{"index": 0, "logit": 0.82}, {"index": 1, "logit": -1.4}], "usage": {"total_tokens": 11}}
+).encode()
+
+
+def ranking_peer(request: Request) -> Reply:
+    assert request.method == "POST" and request.target == "/v1/ranking", request.target
+    assert request.headers["authorization"] == "Bearer integration-provider-key"
+    body: Final = JSON_OBJECT.validate_json(request.body)
+    assert body == {
+        "model": "nvidia/llama-3.2-nv-rerankqa-1b-v2",
+        "query": {"text": QUERY},
+        "passages": [{"image": IMAGE_PASSAGE}, {"text": TEXT_PASSAGE}],
+    }, body
+    return Reply(body=RESPONSE)
+
+
+@pytest.mark.covers(
+    "providers.nvidia_nim_ranking.image_passages_reach_ranking_without_top_k_and_top_n_is_applied_locally"
+)
+def test_nvidia_nim_ranking_keeps_image_passages_and_applies_top_n_without_sending_top_k(gateway: Gateway) -> None:
+    with wire_server(ranking_peer) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model=MODEL, api_base=wire.url, model_info={"mode": "rerank"})
+        response: Final = gateway.request(
+            "POST",
+            "/v1/rerank",
+            {
+                "model": model,
+                "query": QUERY,
+                "documents": [{"image": IMAGE_PASSAGE}, {"text": TEXT_PASSAGE}],
+                "top_n": 1,
+            },
+        )
+        assert response.status_code == 200, response.text
+        assert response.json()["results"] == [{"index": 0, "relevance_score": 0.82}], response.text
+        assert len(wire.drain()) == 1, "Expected exactly one provider ranking call"
diff --git a/tests/integration/providers/test_rerank_latency_headers_wire.py b/tests/integration/providers/test_rerank_latency_headers_wire.py
new file mode 100644
index 000000000000..62624e0480ae
--- /dev/null
+++ b/tests/integration/providers/test_rerank_latency_headers_wire.py
@@ -0,0 +1,50 @@
+import json
+import uuid
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+
+MODEL: Final = "cohere/synthetic-rerank-model-without-pricing"
+QUERY: Final = "which document mentions the gateway"
+DOCUMENTS: Final = ("the gateway proxies rerank calls", "unrelated synthetic text")
+RESPONSE: Final = json.dumps(
+    {
+        "id": "synthetic-rerank-id",
+        "results": [{"index": 0, "relevance_score": 0.91}, {"index": 1, "relevance_score": 0.03}],
+        "meta": {"api_version": {"version": "2"}, "billed_units": {"search_units": 1}},
+    }
+).encode()
+
+
+def rerank_peer(request: Request) -> Reply:
+    assert request.method == "POST" and request.target.endswith("/rerank"), request.target
+    body: Final = json.loads(request.body)
+    assert body["query"] == QUERY and body["documents"] == list(DOCUMENTS), request.body
+    return Reply(body=RESPONSE)
+
+
+@pytest.mark.covers("providers.rerank.response_carries_latency_and_cost_headers")
+def test_rerank_response_carries_call_id_latency_and_cost_headers_like_chat_completions(gateway: Gateway) -> None:
+    with wire_server(rerank_peer) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model=MODEL,
+            api_key="synthetic-cohere-key",
+            api_base=wire.url,
+            model_info={"mode": "rerank"},
+        )
+        response: Final = gateway.request(
+            "POST", "/v1/rerank", {"model": model, "query": QUERY, "documents": list(DOCUMENTS), "top_n": 2}
+        )
+        assert response.status_code == 200, response.text
+        assert [(result["index"], result["relevance_score"]) for result in response.json()["results"]] == [
+            (0, 0.91),
+            (1, 0.03),
+        ], response.text
+        assert len(wire.drain()) == 1, "Expected exactly one provider rerank call"
+        assert response.headers["x-litellm-model-group"] == model, response.text
+        assert uuid.UUID(response.headers["x-litellm-call-id"]).version == 4, response.headers
+        assert float(response.headers["x-litellm-response-cost"]) == 0.0, response.headers
+        assert float(response.headers["x-litellm-response-duration-ms"]) > 0, response.headers
+        assert float(response.headers["x-litellm-overhead-duration-ms"]) >= 0, response.headers
diff --git a/tests/integration/providers/test_responses_bridge_incomplete.py b/tests/integration/providers/test_responses_bridge_incomplete.py
index 3352ca5775e4..e700d17ea888 100644
--- a/tests/integration/providers/test_responses_bridge_incomplete.py
+++ b/tests/integration/providers/test_responses_bridge_incomplete.py
@@ -62,3 +62,129 @@ def respond(request: Request) -> Reply:
         assert body["choices"][0]["message"]["role"] == "assistant", response.text
         assert body["usage"]["prompt_tokens"] == 12 and body["usage"]["completion_tokens"] == 16, response.text
         assert body["usage"]["total_tokens"] == 28, response.text
+
+
+@pytest.mark.covers("other.provider_wire.responses_bridge.sub_minimum_max_tokens_clamped_to_provider_floor")
+def test_messages_over_responses_deployment_with_max_tokens_1_is_clamped_to_16_instead_of_400(gateway: Gateway) -> None:
+    identity: Final = "responses-clamp-" + uuid.uuid4().hex
+
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == "/responses", request.target
+        assert request.headers["authorization"] == "Bearer synthetic-openai-key"
+        body: Final = json.loads(request.body)
+        assert body["model"] == "gpt-5.4"
+        if body["max_output_tokens"] < 16:
+            return Reply(
+                status=400,
+                body=json.dumps(
+                    {
+                        "error": {
+                            "message": "Invalid 'max_output_tokens': integer below minimum value. Expected a value >= 16, but got 1 instead.",
+                            "type": "invalid_request_error",
+                            "param": "max_output_tokens",
+                            "code": "integer_below_min_value",
+                        }
+                    }
+                ).encode(),
+            )
+        assert body["max_output_tokens"] == 16
+        assert body["input"] == [
+            {
+                "type": "message",
+                "role": "user",
+                "content": [{"type": "input_text", "text": f"warmup probe {identity}"}],
+            }
+        ]
+        return Reply(
+            body=json.dumps(
+                {
+                    "id": f"resp_{identity}",
+                    "object": "response",
+                    "created_at": 1789788253,
+                    "status": "completed",
+                    "model": "gpt-5.4",
+                    "output": [
+                        {
+                            "type": "message",
+                            "id": f"msg_{identity}",
+                            "status": "completed",
+                            "role": "assistant",
+                            "content": [{"type": "output_text", "text": "ok", "annotations": []}],
+                        }
+                    ],
+                    "usage": {"input_tokens": 12, "output_tokens": 1, "total_tokens": 13},
+                }
+            ).encode()
+        )
+
+    with wire_server(respond) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model="openai/responses/gpt-5.4", api_base=wire.url, api_key="synthetic-openai-key"
+        )
+        response: Final = gateway.request(
+            "POST",
+            "/v1/messages",
+            {
+                "model": model,
+                "max_tokens": 1,
+                "messages": [{"role": "user", "content": f"warmup probe {identity}"}],
+            },
+        )
+        assert response.status_code == 200, response.text
+        body: Final = response.json()
+        assert len(wire.drain()) == 1
+        assert body["role"] == "assistant", response.text
+        assert body["content"] == [{"type": "text", "text": "ok"}], response.text
+        assert body["stop_reason"] == "end_turn", response.text
+
+
+@pytest.mark.covers("providers.responses_bridge.sub_minimum_max_tokens_is_raised_to_the_openai_floor")
+def test_messages_over_responses_deployment_with_max_tokens_one_reaches_openai_as_sixteen(gateway: Gateway) -> None:
+    identity: Final = "responses-min-tokens-" + uuid.uuid4().hex
+
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == "/responses", request.target
+        assert request.headers["authorization"] == "Bearer synthetic-openai-key"
+        body: Final = json.loads(request.body)
+        assert body["model"] == "gpt-5.6-sol"
+        assert body["max_output_tokens"] == 16, body
+        return Reply(
+            body=json.dumps(
+                {
+                    "id": f"resp_{identity}",
+                    "object": "response",
+                    "created_at": 1789788253,
+                    "status": "completed",
+                    "model": "gpt-5.6-sol",
+                    "output": [
+                        {
+                            "type": "message",
+                            "id": f"msg_{identity}",
+                            "status": "completed",
+                            "role": "assistant",
+                            "content": [{"type": "output_text", "text": "ok", "annotations": []}],
+                        }
+                    ],
+                    "usage": {"input_tokens": 9, "output_tokens": 1, "total_tokens": 10},
+                }
+            ).encode()
+        )
+
+    with wire_server(respond) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model="openai/responses/gpt-5.6-sol", api_base=wire.url, api_key="synthetic-openai-key"
+        )
+        response: Final = gateway.request(
+            "POST",
+            "/v1/messages",
+            {
+                "model": model,
+                "max_tokens": 1,
+                "messages": [{"role": "user", "content": f"warmup {identity}"}],
+            },
+        )
+        assert response.status_code == 200, response.text
+        body: Final = response.json()
+        assert len(wire.drain()) == 1
+        assert body["content"] == [{"type": "text", "text": "ok"}], response.text
+        assert body["usage"]["input_tokens"] == 9 and body["usage"]["output_tokens"] == 1, response.text
diff --git a/tests/integration/providers/test_responses_bridge_namespace_tools.py b/tests/integration/providers/test_responses_bridge_namespace_tools.py
new file mode 100644
index 000000000000..746dac03ced8
--- /dev/null
+++ b/tests/integration/providers/test_responses_bridge_namespace_tools.py
@@ -0,0 +1,159 @@
+import json
+import uuid
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+from pydantic import JsonValue, TypeAdapter
+
+JSON_OBJECT: Final = TypeAdapter(dict[str, JsonValue])
+JSON_LIST: Final = TypeAdapter(list[dict[str, JsonValue]])
+NAMESPACE: Final = "mcp__everything"
+TOOL_NAME: Final = "get_sum"
+FLATTENED_NAME: Final = f"{NAMESPACE}__{TOOL_NAME}"
+CALL_ID: Final = "call_synthetic_get_sum"
+ARGUMENTS: Final = json.dumps({"a": 2, "b": 3})
+PARAMETERS: Final[dict[str, JsonValue]] = {
+    "type": "object",
+    "required": ["a", "b"],
+    "properties": {"a": {"type": "number"}, "b": {"type": "number"}},
+}
+NAMESPACE_TOOL: Final[dict[str, JsonValue]] = {
+    "type": "namespace",
+    "name": NAMESPACE,
+    "description": "Tools exposed by the everything MCP server",
+    "tools": [
+        {
+            "type": "function",
+            "name": TOOL_NAME,
+            "description": "Adds two numbers",
+            "strict": False,
+            "parameters": PARAMETERS,
+        }
+    ],
+}
+EXPECTED_CHAT_TOOLS: Final[list[JsonValue]] = [
+    {
+        "type": "function",
+        "function": {
+            "name": FLATTENED_NAME,
+            "description": "Tools exposed by the everything MCP server\n\nAdds two numbers",
+            "parameters": PARAMETERS,
+            "strict": False,
+        },
+    }
+]
+
+
+def tool_call_completion(marker: str) -> bytes:
+    return json.dumps(
+        {
+            "id": f"chatcmpl-{marker}",
+            "object": "chat.completion",
+            "created": 1789788253,
+            "model": "gpt-4o-mini",
+            "choices": [
+                {
+                    "index": 0,
+                    "finish_reason": "tool_calls",
+                    "message": {
+                        "role": "assistant",
+                        "content": None,
+                        "tool_calls": [
+                            {
+                                "id": CALL_ID,
+                                "type": "function",
+                                "function": {"name": FLATTENED_NAME, "arguments": ARGUMENTS},
+                            }
+                        ],
+                    },
+                }
+            ],
+            "usage": {"prompt_tokens": 30, "completion_tokens": 12, "total_tokens": 42},
+        }
+    ).encode()
+
+
+def text_completion(marker: str) -> bytes:
+    return json.dumps(
+        {
+            "id": f"chatcmpl-{marker}-final",
+            "object": "chat.completion",
+            "created": 1789788254,
+            "model": "gpt-4o-mini",
+            "choices": [
+                {
+                    "index": 0,
+                    "finish_reason": "stop",
+                    "message": {"role": "assistant", "content": "The sum is 5"},
+                }
+            ],
+            "usage": {"prompt_tokens": 40, "completion_tokens": 5, "total_tokens": 45},
+        }
+    ).encode()
+
+
+@pytest.mark.covers("other.provider_wire.responses_bridge.codex_namespace_tools_reach_chat_upstream_and_round_trip")
+def test_codex_namespace_tool_is_flattened_for_chat_upstream_and_restored_in_responses_output(
+    gateway: Gateway,
+) -> None:
+    marker: Final = uuid.uuid4().hex
+    prompt: Final = f"add 2 and 3 {marker}"
+
+    def chat_peer(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == "/v1/chat/completions", request.target
+        body: Final = JSON_OBJECT.validate_json(request.body)
+        assert body["tools"] == EXPECTED_CHAT_TOOLS, body
+        messages: Final = JSON_LIST.validate_python(body["messages"])
+        if len(messages) == 1:
+            return Reply(body=tool_call_completion(marker))
+        assert messages[1]["role"] == "assistant", messages
+        history_calls: Final = JSON_LIST.validate_python(messages[1]["tool_calls"])
+        assert [(call["id"], call["function"]) for call in history_calls] == [
+            (CALL_ID, {"name": FLATTENED_NAME, "arguments": ARGUMENTS})
+        ], messages
+        assert messages[2] == {"role": "tool", "tool_call_id": CALL_ID, "content": "5"}, messages
+        return Reply(body=text_completion(marker))
+
+    with wire_server(chat_peer) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(model="deepseek/gpt-4o-mini", api_base=wire.url + "/v1")
+        first: Final = gateway.request(
+            "POST",
+            "/v1/responses",
+            {"model": model, "input": prompt, "tools": [NAMESPACE_TOOL], "store": False},
+        )
+        assert first.status_code == 200, first.text
+        first_output: Final = JSON_LIST.validate_python(JSON_OBJECT.validate_json(first.content)["output"])
+        calls: Final = tuple(item for item in first_output if item["type"] == "function_call")
+        assert len(calls) == 1, first.text
+        assert calls[0]["name"] == TOOL_NAME, first.text
+        assert calls[0]["namespace"] == NAMESPACE, first.text
+        assert calls[0]["call_id"] == CALL_ID, first.text
+        assert calls[0]["arguments"] == ARGUMENTS, first.text
+
+        second: Final = gateway.request(
+            "POST",
+            "/v1/responses",
+            {
+                "model": model,
+                "input": [
+                    {"type": "message", "role": "user", "content": [{"type": "input_text", "text": prompt}]},
+                    {
+                        "type": "function_call",
+                        "call_id": CALL_ID,
+                        "name": TOOL_NAME,
+                        "namespace": NAMESPACE,
+                        "arguments": ARGUMENTS,
+                    },
+                    {"type": "function_call_output", "call_id": CALL_ID, "output": "5"},
+                ],
+                "tools": [NAMESPACE_TOOL],
+                "store": False,
+            },
+        )
+        assert second.status_code == 200, second.text
+        second_output: Final = JSON_LIST.validate_python(JSON_OBJECT.validate_json(second.content)["output"])
+        assert [item["type"] for item in second_output] == ["message"], second.text
+        assert JSON_LIST.validate_python(second_output[0]["content"])[0]["text"] == "The sum is 5", second.text
+        assert len(wire.drain()) == 2
diff --git a/tests/integration/providers/test_responses_bridge_stream_options.py b/tests/integration/providers/test_responses_bridge_stream_options.py
new file mode 100644
index 000000000000..a0efc8d47d04
--- /dev/null
+++ b/tests/integration/providers/test_responses_bridge_stream_options.py
@@ -0,0 +1,98 @@
+import json
+import uuid
+from pathlib import Path
+from typing import Final
+
+import pytest
+import yaml
+from integration._support.client import Gateway
+from integration._support.process import owned_proxy
+from integration._support.wire import Reply, Request, wire_server
+
+
+def _responses_stream(identity: str, text: str) -> tuple[bytes, ...]:
+    completed: Final = {
+        "id": identity,
+        "object": "response",
+        "created_at": 1,
+        "status": "completed",
+        "model": "gpt-5.3-codex",
+        "output": [
+            {
+                "type": "message",
+                "id": f"msg_{identity}",
+                "status": "completed",
+                "role": "assistant",
+                "content": [{"type": "output_text", "text": text, "annotations": []}],
+            }
+        ],
+        "usage": {
+            "input_tokens": 11,
+            "output_tokens": 4,
+            "total_tokens": 15,
+            "input_tokens_details": {"cached_tokens": 0},
+            "output_tokens_details": {"reasoning_tokens": 0},
+        },
+    }
+    events: Final = (
+        {"type": "response.created", "response": {**completed, "status": "in_progress", "output": [], "usage": None}},
+        {
+            "type": "response.output_text.delta",
+            "item_id": f"msg_{identity}",
+            "output_index": 0,
+            "content_index": 0,
+            "delta": text,
+        },
+        {"type": "response.completed", "response": completed},
+    )
+    return tuple(f"event: {event['type']}\ndata: {json.dumps(event)}\n\n".encode() for event in events)
+
+
+@pytest.mark.covers("providers.responses_bridge.always_include_stream_usage_keeps_include_usage_off_the_responses_wire")
+def test_messages_stream_with_always_include_stream_usage_omits_include_usage_from_responses_request(
+    gateway: Gateway, tmp_path: Path
+) -> None:
+    identity: Final = "responses-stream-options-" + uuid.uuid4().hex
+
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == "/responses", request.target
+        assert request.headers["authorization"] == "Bearer synthetic-openai-key"
+        return Reply(content_type="text/event-stream", chunks=_responses_stream(identity, "usage control"))
+
+    config: Final = yaml.safe_load(Path("tests/integration/proxy_config.yaml").read_text())
+    config["general_settings"].update({"always_include_stream_usage": True})
+    path: Final = tmp_path / "always_include_stream_usage.yaml"
+    path.write_text(yaml.safe_dump(config))
+    with (
+        wire_server(respond) as wire,
+        owned_proxy(gateway, tmp_path, {}, config=path) as candidate,
+        candidate.scenario() as scenario,
+    ):
+        model: Final = scenario.model(model="openai/gpt-5.3-codex", api_base=wire.url, api_key="synthetic-openai-key")
+        response: Final = candidate.request(
+            "POST",
+            "/v1/messages",
+            {
+                "model": model,
+                "max_tokens": 64,
+                "stream": True,
+                "messages": [{"role": "user", "content": f"count the usage {identity}"}],
+            },
+        )
+        assert response.status_code == 200, response.text
+        assert "event: message_stop" in response.text, response.text
+        requests: Final = wire.drain()
+        assert len(requests) == 1, response.text
+        assert json.loads(requests[0].body) == {
+            "model": "gpt-5.3-codex",
+            "input": [
+                {
+                    "type": "message",
+                    "role": "user",
+                    "content": [{"type": "input_text", "text": f"count the usage {identity}"}],
+                }
+            ],
+            "include": ["reasoning.encrypted_content"],
+            "max_output_tokens": 64,
+            "stream": True,
+        }, response.text
diff --git a/tests/integration/providers/test_responses_client_header_forwarding_wire.py b/tests/integration/providers/test_responses_client_header_forwarding_wire.py
new file mode 100644
index 000000000000..50557cd17278
--- /dev/null
+++ b/tests/integration/providers/test_responses_client_header_forwarding_wire.py
@@ -0,0 +1,87 @@
+import json
+from pathlib import Path
+from typing import Final
+from uuid import uuid4
+
+import pytest
+import yaml
+from integration._support.client import Gateway
+from integration._support.process import owned_proxy
+from integration._support.wire import Reply, Request, wire_server
+from pydantic import JsonValue, TypeAdapter
+
+_BACKEND: Final = "gpt-5.4-mini"
+_API_KEY: Final = "synthetic-openai-key"
+_CLIENT_HEADER: Final = "x-my-new-header"
+_JSON_OBJECT: Final = TypeAdapter(dict[str, JsonValue])
+_OUTPUT_MESSAGE: Final[dict[str, JsonValue]] = {
+    "type": "message",
+    "id": "msg_forwarded",
+    "status": "completed",
+    "role": "assistant",
+    "content": [{"type": "output_text", "text": "header wire control", "annotations": []}],
+}
+_RESPONSE: Final = json.dumps(
+    {
+        "id": "resp_forwarded",
+        "object": "response",
+        "status": "completed",
+        "created_at": 1700000000,
+        "model": _BACKEND,
+        "output": [_OUTPUT_MESSAGE],
+        "usage": {
+            "input_tokens": 9,
+            "output_tokens": 3,
+            "total_tokens": 12,
+            "input_tokens_details": {"cached_tokens": 0},
+            "output_tokens_details": {"reasoning_tokens": 0},
+        },
+    }
+).encode()
+
+
+def _forwarding_config(directory: Path) -> Path:
+    configuration: Final = yaml.safe_load(Path("tests/integration/proxy_config.yaml").read_text())
+    configuration["general_settings"]["forward_client_headers_to_llm_api"] = True
+    path: Final = directory / "forwarding.yaml"
+    path.write_text(yaml.safe_dump(configuration))
+    return path
+
+
+@pytest.mark.covers("providers.responses_api.forwarded_client_headers_reach_the_provider")
+def test_client_x_header_is_forwarded_to_the_provider_on_responses(gateway: Gateway, tmp_path: Path) -> None:
+    marker: Final = f"hello-from-client-{uuid4().hex}"
+    prompt: Final = f"forward my header {marker}"
+
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == "/responses", request.target
+        assert request.headers["authorization"] == f"Bearer {_API_KEY}"
+        assert request.headers.get(_CLIENT_HEADER) == marker, dict(request.headers)
+        body: Final = _JSON_OBJECT.validate_json(request.body)
+        assert body["model"] == _BACKEND and body["input"] == prompt, request.body
+        return Reply(body=_RESPONSE)
+
+    with (
+        wire_server(respond) as wire,
+        owned_proxy(gateway, tmp_path, {}, config=_forwarding_config(tmp_path)) as candidate,
+        candidate.scenario() as scenario,
+    ):
+        model: Final = scenario.model(model=f"openai/{_BACKEND}", api_base=wire.url, api_key=_API_KEY)
+        response: Final = candidate.request(
+            "POST",
+            "/v1/responses",
+            {"model": model, "input": prompt, "stream": False},
+            headers={_CLIENT_HEADER: marker},
+        )
+        assert response.status_code == 200, response.text
+        payload: Final = _JSON_OBJECT.validate_json(response.content)
+        assert payload["output"] == [
+            {
+                **_OUTPUT_MESSAGE,
+                "phase": None,
+                "content": [
+                    {"type": "output_text", "text": "header wire control", "annotations": [], "logprobs": None}
+                ],
+            }
+        ], response.text
+        assert [(request.method, request.target) for request in wire.drain()] == [("POST", "/responses")]
diff --git a/tests/integration/providers/test_sagemaker_chat_wire.py b/tests/integration/providers/test_sagemaker_chat_wire.py
new file mode 100644
index 000000000000..346f4e59e0ff
--- /dev/null
+++ b/tests/integration/providers/test_sagemaker_chat_wire.py
@@ -0,0 +1,90 @@
+import json
+import uuid
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+from pydantic import JsonValue, TypeAdapter
+
+_ENDPOINT: Final = "integration-vllm-endpoint"
+_INFERENCE_COMPONENT: Final = "integration-vllm-component"
+_SERVED_MODEL: Final = "integration-org/served-chat-model"
+_ACCESS_KEY: Final = "AKIAINTEGRATION000003"
+_PROMPT: Final = "synthetic inference component request"
+_JSON_OBJECT: Final = TypeAdapter(dict[str, JsonValue])
+
+
+def _completion(identity: str) -> bytes:
+    return json.dumps(
+        {
+            "id": identity,
+            "object": "chat.completion",
+            "created": 1,
+            "model": _SERVED_MODEL,
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {"role": "assistant", "content": "sagemaker wire control"},
+                    "finish_reason": "stop",
+                }
+            ],
+            "usage": {"prompt_tokens": 11, "completion_tokens": 4, "total_tokens": 15},
+        }
+    ).encode()
+
+
+@pytest.mark.covers(
+    "providers.sagemaker_chat_wire.inference_component_header_is_signed_and_hf_model_name_is_the_body_model"
+)
+def test_sagemaker_chat_signs_the_inference_component_header_and_sends_hf_model_name_as_the_body_model(
+    gateway: Gateway,
+) -> None:
+    identity: Final = f"sagemaker-chat-{uuid.uuid4().hex}"
+
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST", request
+        assert request.target == "/", request
+        assert request.headers["x-amzn-sagemaker-inference-component"] == _INFERENCE_COMPONENT, dict(request.headers)
+        authorization: Final = request.headers["authorization"]
+        assert authorization.startswith(f"AWS4-HMAC-SHA256 Credential={_ACCESS_KEY}/"), authorization
+        signed_headers: Final = next(part for part in authorization.split(", ") if part.startswith("SignedHeaders="))
+        assert "x-amzn-sagemaker-inference-component" in signed_headers.removeprefix("SignedHeaders=").split(";"), (
+            authorization
+        )
+        body: Final = _JSON_OBJECT.validate_json(request.body)
+        assert body["model"] == _SERVED_MODEL, body
+        assert body["messages"] == [{"role": "user", "content": _PROMPT}], body
+        assert body["max_tokens"] == 16, body
+        assert "hf_model_name" not in body, body
+        return Reply(body=_completion(identity))
+
+    with wire_server(respond) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model=f"sagemaker_chat/{_ENDPOINT}",
+            api_key=None,
+            api_base=None,
+            model_id=_INFERENCE_COMPONENT,
+            hf_model_name=_SERVED_MODEL,
+            aws_access_key_id=_ACCESS_KEY,
+            aws_secret_access_key="synthetic-secret-key-for-testing",
+            aws_region_name="us-east-1",
+            sagemaker_base_url=wire.url,
+        )
+        response: Final = gateway.request(
+            "POST",
+            "/v1/chat/completions",
+            {"model": model, "messages": [{"role": "user", "content": _PROMPT}], "max_tokens": 16},
+        )
+        assert response.status_code == 200, response.text
+        payload: Final = _JSON_OBJECT.validate_json(response.content)
+        assert payload["id"] == identity, response.text
+        assert payload["choices"] == [
+            {
+                "finish_reason": "stop",
+                "index": 0,
+                "message": {"role": "assistant", "content": "sagemaker wire control"},
+                "provider_specific_fields": {},
+            }
+        ], response.text
+        assert [(request.method, request.target) for request in wire.drain()] == [("POST", "/")], response.text
diff --git a/tests/integration/providers/test_stream_chunk_size_wire.py b/tests/integration/providers/test_stream_chunk_size_wire.py
new file mode 100644
index 000000000000..3681da0e3d4a
--- /dev/null
+++ b/tests/integration/providers/test_stream_chunk_size_wire.py
@@ -0,0 +1,316 @@
+import asyncio
+import base64
+import json
+import os
+import struct
+import zlib
+from collections.abc import Callable, Mapping
+from pathlib import Path
+from typing import Final
+
+import litellm
+import pytest
+from integration._support.upstream import INTERNAL_FIELDS
+from integration._support.wire import Reply, Request, wire_server
+from tests._support.stream_chunk_size import keys_at_every_depth, record_litellm_params
+
+TEXT: Final = "wire control"
+OPENAI_RESPONSE: Final = {
+    "id": "chatcmpl-wire",
+    "object": "chat.completion",
+    "created": 1,
+    "model": "gpt-4.1-mini",
+    "choices": [{"index": 0, "message": {"role": "assistant", "content": TEXT}, "finish_reason": "stop"}],
+    "usage": {"prompt_tokens": 10, "completion_tokens": 4, "total_tokens": 14},
+}
+ANTHROPIC_RESPONSE: Final = {
+    "id": "msg_wire",
+    "type": "message",
+    "role": "assistant",
+    "model": "claude-sonnet-4-5",
+    "content": [{"type": "text", "text": TEXT}],
+    "stop_reason": "end_turn",
+    "stop_sequence": None,
+    "usage": {"input_tokens": 10, "output_tokens": 4},
+}
+GEMINI_RESPONSE: Final = {
+    "candidates": [{"content": {"role": "model", "parts": [{"text": TEXT}]}, "finishReason": "STOP", "index": 0}],
+    "usageMetadata": {"promptTokenCount": 10, "candidatesTokenCount": 4, "totalTokenCount": 14},
+}
+CONVERSE_RESPONSE: Final = {
+    "output": {"message": {"role": "assistant", "content": [{"text": TEXT}]}},
+    "stopReason": "end_turn",
+    "usage": {"inputTokens": 10, "outputTokens": 4, "totalTokens": 14},
+    "metrics": {"latencyMs": 1},
+}
+OPENAI_STREAM_CHUNKS: Final = (
+    {
+        "id": "chatcmpl-wire",
+        "object": "chat.completion.chunk",
+        "created": 1,
+        "model": "gpt-4.1-mini",
+        "choices": [{"index": 0, "delta": {"role": "assistant", "content": TEXT}, "finish_reason": None}],
+    },
+    {
+        "id": "chatcmpl-wire",
+        "object": "chat.completion.chunk",
+        "created": 1,
+        "model": "gpt-4.1-mini",
+        "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}],
+    },
+)
+ANTHROPIC_STREAM_EVENTS: Final = (
+    {
+        "type": "message_start",
+        "message": {
+            "id": "msg_wire",
+            "type": "message",
+            "role": "assistant",
+            "model": "claude-sonnet-4-5",
+            "content": [],
+            "stop_reason": None,
+            "usage": {"input_tokens": 10, "output_tokens": 1},
+        },
+    },
+    {"type": "content_block_start", "index": 0, "content_block": {"type": "text", "text": ""}},
+    {"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": TEXT}},
+    {"type": "content_block_stop", "index": 0},
+    {"type": "message_delta", "delta": {"stop_reason": "end_turn"}, "usage": {"output_tokens": 4}},
+    {"type": "message_stop"},
+)
+GEMINI_STREAM_CHUNKS: Final = (
+    {"candidates": [{"content": {"role": "model", "parts": [{"text": TEXT}]}, "index": 0}]},
+    {
+        "candidates": [{"content": {"role": "model", "parts": [{"text": ""}]}, "finishReason": "STOP", "index": 0}],
+        "usageMetadata": {"promptTokenCount": 10, "candidatesTokenCount": 4, "totalTokenCount": 14},
+    },
+)
+CONVERSE_STREAM_EVENTS: Final = (
+    ("contentBlockDelta", {"delta": {"text": TEXT}, "contentBlockIndex": 0}),
+    ("messageStop", {"stopReason": "end_turn"}),
+    ("metadata", {"usage": {"inputTokens": 10, "outputTokens": 4, "totalTokens": 14}, "metrics": {"latencyMs": 1}}),
+)
+NON_STREAM_BODIES: Final = {
+    "openai": OPENAI_RESPONSE,
+    "azure": OPENAI_RESPONSE,
+    "anthropic": ANTHROPIC_RESPONSE,
+    "gemini": GEMINI_RESPONSE,
+    "converse": CONVERSE_RESPONSE,
+    "invoke": ANTHROPIC_RESPONSE,
+}
+PROVIDERS: Final = ("openai", "azure", "anthropic", "gemini", "converse", "invoke")
+
+
+def _aws_string_header(name: str, value: str) -> bytes:
+    name_bytes: Final = name.encode()
+    value_bytes: Final = value.encode()
+    return struct.pack("!B", len(name_bytes)) + name_bytes + b"\x07" + struct.pack("!H", len(value_bytes)) + value_bytes
+
+
+def _aws_event_frame(event_type: str, payload: Mapping[str, object]) -> bytes:
+    body: Final = json.dumps(payload, separators=(",", ":")).encode()
+    headers: Final = (
+        _aws_string_header(":event-type", event_type)
+        + _aws_string_header(":content-type", "application/json")
+        + _aws_string_header(":message-type", "event")
+    )
+    prelude: Final = struct.pack("!II", 12 + len(headers) + len(body) + 4, len(headers))
+    message: Final = prelude + struct.pack("!I", zlib.crc32(prelude) & 0xFFFFFFFF) + headers + body
+    return message + struct.pack("!I", zlib.crc32(message) & 0xFFFFFFFF)
+
+
+def _sse_reply(frames: tuple[bytes, ...]) -> Reply:
+    return Reply(chunks=frames, content_type="text/event-stream")
+
+
+def _stream_reply(provider: str) -> Reply:
+    match provider:
+        case "openai" | "azure":
+            return _sse_reply(
+                tuple(
+                    f"data: {json.dumps(chunk, separators=(',', ':'))}\n\n".encode() for chunk in OPENAI_STREAM_CHUNKS
+                )
+                + (b"data: [DONE]\n\n",)
+            )
+        case "anthropic":
+            return _sse_reply(
+                tuple(
+                    f"event: {event['type']}\ndata: {json.dumps(event, separators=(',', ':'))}\n\n".encode()
+                    for event in ANTHROPIC_STREAM_EVENTS
+                )
+            )
+        case "gemini":
+            return _sse_reply(
+                tuple(
+                    f"data: {json.dumps(chunk, separators=(',', ':'))}\r\n\r\n".encode()
+                    for chunk in GEMINI_STREAM_CHUNKS
+                )
+            )
+        case "converse":
+            return Reply(
+                chunks=tuple(_aws_event_frame(event_type, payload) for event_type, payload in CONVERSE_STREAM_EVENTS),
+                content_type="application/vnd.amazon.eventstream",
+            )
+        case "invoke":
+            return Reply(
+                chunks=tuple(
+                    _aws_event_frame(
+                        "chunk", {"bytes": base64.b64encode(json.dumps(event, separators=(",", ":")).encode()).decode()}
+                    )
+                    for event in ANTHROPIC_STREAM_EVENTS
+                ),
+                content_type="application/vnd.amazon.eventstream",
+            )
+
+
+def _request_parameters(provider: str, wire_url: str) -> dict[str, object]:
+    common: Final = {"messages": [{"role": "user", "content": "synthetic chunk control"}]}
+    match provider:
+        case "openai":
+            return {**common, "model": "openai/gpt-4.1-mini", "api_key": "synthetic-openai-key", "api_base": wire_url}
+        case "azure":
+            return {
+                **common,
+                "model": "azure/gpt-4.1-mini",
+                "api_key": "synthetic-azure-key",
+                "api_base": wire_url,
+                "api_version": "2025-01-01-preview",
+            }
+        case "anthropic":
+            return {
+                **common,
+                "model": "anthropic/claude-sonnet-4-5",
+                "api_key": "synthetic-anthropic-key",
+                "api_base": wire_url,
+            }
+        case "gemini":
+            return {
+                **common,
+                "model": "gemini/gemini-2.5-flash",
+                "api_key": "synthetic-gemini-key",
+                "api_base": wire_url,
+            }
+        case "converse":
+            return {
+                **common,
+                "model": "bedrock/converse/anthropic.claude-haiku-4-5-20251001-v1:0",
+                "aws_access_key_id": "fake",
+                "aws_secret_access_key": "fake",
+                "aws_region_name": "us-east-1",
+                "aws_bedrock_runtime_endpoint": wire_url,
+            }
+        case "invoke":
+            return {
+                **common,
+                "model": "bedrock/invoke/anthropic.claude-haiku-4-5-20251001-v1:0",
+                "aws_access_key_id": "fake",
+                "aws_secret_access_key": "fake",
+                "aws_region_name": "us-east-1",
+                "aws_bedrock_runtime_endpoint": wire_url,
+            }
+
+
+def _expected_target(provider: str, streaming: bool) -> str:
+    match provider:
+        case "openai":
+            return "/chat/completions"
+        case "azure":
+            return "/openai/deployments/gpt-4.1-mini/chat/completions?api-version=2025-01-01-preview"
+        case "anthropic":
+            return "/v1/messages"
+        case "gemini":
+            return ":streamGenerateContent" if streaming else ":generateContent"
+        case "converse":
+            return "/converse-stream" if streaming else "/converse"
+        case "invoke":
+            return "/invoke-with-response-stream" if streaming else "/invoke"
+
+
+def _at(value: object, *path: str) -> object:
+    if not path:
+        return value
+    assert isinstance(value, Mapping)
+    return _at(value[path[0]], *path[1:])
+
+
+def _custom_key(body: Mapping[str, object], provider: str) -> object:
+    match provider:
+        case "anthropic":
+            return _at(body, "extra_body", "custom_provider_key")
+        case "converse":
+            return _at(body, "additionalModelRequestFields", "extra_body", "custom_provider_key")
+    return _at(body, "custom_provider_key")
+
+
+def _peer(provider: str) -> Callable[[Request], Reply]:
+    def respond(request: Request) -> Reply:
+        body: Final = json.loads(request.body) if request.body else {}
+        streaming: Final = (
+            (isinstance(body, dict) and body.get("stream") is True)
+            or "streamGenerateContent" in request.target
+            or request.target.endswith(("-stream",))
+        )
+        expected: Final = _expected_target(provider, streaming)
+        assert expected in request.target, f"{provider}: expected {expected} in {request.target}"
+        return _stream_reply(provider) if streaming else Reply(body=json.dumps(NON_STREAM_BODIES[provider]).encode())
+
+    return respond
+
+
+@pytest.fixture
+def provider_wire_environment(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    empty: Final = tmp_path / "empty-aws-config"
+    empty.write_text("")
+    for name in tuple(name for name in os.environ if name.startswith("AWS_")):
+        monkeypatch.delenv(name, raising=False)
+    for name, value in {
+        "AWS_CONFIG_FILE": str(empty),
+        "AWS_SHARED_CREDENTIALS_FILE": str(empty),
+        "AWS_EC2_METADATA_DISABLED": "true",
+        "LITELLM_RUST": "false",
+    }.items():
+        monkeypatch.setenv(name, value)
+    monkeypatch.setattr(litellm, "disable_aiohttp_transport", True)
+
+
+@pytest.mark.parametrize("provider", PROVIDERS)
+@pytest.mark.parametrize("asynchronous", [False, True])
+@pytest.mark.parametrize("stream", [False, True])
+async def test_stream_chunk_size_never_reaches_provider_body(
+    monkeypatch: pytest.MonkeyPatch,
+    provider_wire_environment: None,
+    provider: str,
+    asynchronous: bool,
+    stream: bool,
+) -> None:
+    recorder: Final = record_litellm_params(monkeypatch)
+    with wire_server(_peer(provider)) as wire:
+        parameters: Final = {
+            **_request_parameters(provider, wire.url),
+            "stream": stream,
+            "stream_chunk_size": 64,
+            "extra_body": {"custom_provider_key": 1},
+            "max_tokens": 16,
+            "timeout": 5,
+            "num_retries": 0,
+        }
+        result: Final = (
+            await litellm.acompletion(**parameters)
+            if asynchronous
+            else await asyncio.to_thread(litellm.completion, **parameters)
+        )
+        if stream:
+            chunks: Final = [chunk async for chunk in result] if asynchronous else [chunk for chunk in result]
+            text: Final = "".join(chunk.choices[0].delta.content or "" for chunk in chunks if chunk.choices)
+            assert text == TEXT
+        else:
+            assert result.choices[0].message.content == TEXT
+        requests: Final = wire.drain()
+        assert len(requests) == 1
+        assert len(recorder.seen) == 1
+        assert recorder.seen[0]["stream_chunk_size"] == 64
+        body: Final = json.loads(requests[0].body)
+        keys: Final = keys_at_every_depth(body)
+        assert "stream_chunk_size" not in keys
+        assert not INTERNAL_FIELDS.intersection(keys)
+        assert _custom_key(body, provider) == 1
diff --git a/tests/integration/providers/test_vertex_batch_output_info_wire.py b/tests/integration/providers/test_vertex_batch_output_info_wire.py
new file mode 100644
index 000000000000..a7ac896076cb
--- /dev/null
+++ b/tests/integration/providers/test_vertex_batch_output_info_wire.py
@@ -0,0 +1,124 @@
+import base64
+import functools
+import json
+from typing import Final
+
+import pytest
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+
+PROJECT: Final = "cc-scripted-project"
+LOCATION: Final = "us-central1"
+MODEL: Final = "vertex_ai/gemini-2.5-flash"
+VERTEX_MODEL_RESOURCE: Final = "publishers/google/models/gemini-2.5-flash"
+BUCKET: Final = "integration-batch-bucket"
+INPUT_FILE_ID: Final = f"gs://{BUCKET}/litellm-vertex-files/{VERTEX_MODEL_RESOURCE}/input.jsonl"
+OUTPUT_PREFIX: Final = INPUT_FILE_ID.rsplit("/", 1)[0]
+JOB_NAME: Final = f"projects/{PROJECT}/locations/{LOCATION}/batchPredictionJobs/7412345678901234567"
+JOB_ID: Final = JOB_NAME.rsplit("/", 1)[-1]
+EXPECTED_VERTEX_BODY: Final = {
+    "inputConfig": {"gcsSource": {"uris": [INPUT_FILE_ID]}, "instancesFormat": "jsonl"},
+    "outputConfig": {"predictionsFormat": "jsonl", "gcsDestination": {"outputUriPrefix": OUTPUT_PREFIX}},
+    "model": VERTEX_MODEL_RESOURCE,
+}
+VERTEX_REPLY: Final = {
+    "name": JOB_NAME,
+    "displayName": "litellm-vertex-batch-scripted",
+    "model": VERTEX_MODEL_RESOURCE,
+    "inputConfig": {"gcsSource": {"uris": [INPUT_FILE_ID]}, "instancesFormat": "jsonl"},
+    "outputConfig": {"predictionsFormat": "jsonl", "gcsDestination": {"outputUriPrefix": OUTPUT_PREFIX}},
+    "outputInfo": None,
+    "state": "JOB_STATE_PENDING",
+    "createTime": "2026-07-24T20:00:00.000000Z",
+    "updateTime": "2026-07-24T20:00:00.000000Z",
+}
+
+
+@functools.cache
+def _vertex_private_key_pem() -> str:
+    return (
+        rsa.generate_private_key(public_exponent=65537, key_size=2048)
+        .private_bytes(
+            serialization.Encoding.PEM,
+            serialization.PrivateFormat.PKCS8,
+            serialization.NoEncryption(),
+        )
+        .decode()
+    )
+
+
+def _vertex_service_account_json(url: str) -> str:
+    return json.dumps(
+        {
+            "type": "service_account",
+            "project_id": PROJECT,
+            "private_key_id": "scripted",
+            "private_key": _vertex_private_key_pem(),
+            "client_email": f"scripted@{PROJECT}.iam.gserviceaccount.com",
+            "client_id": "0",
+            "auth_uri": f"{url}/_oauth/authorize",
+            "token_uri": f"{url}/_oauth/token",
+        }
+    )
+
+
+def _encoded(raw: str, model: str, prefix: str) -> str:
+    return prefix + base64.urlsafe_b64encode(f"litellm:{raw};model,{model}".encode()).decode().rstrip("=")
+
+
+def vertex_peer(request: Request) -> Reply:
+    assert request.method == "POST", request.method
+    assert request.target == f"/v1/projects/{PROJECT}/locations/{LOCATION}/batchPredictionJobs", request.target
+    assert request.headers["authorization"] == "Bearer scripted-token"
+    assert request.headers["content-type"] == "application/json; charset=utf-8"
+    body: Final = json.loads(request.body)
+    display_name: Final = body.pop("displayName")
+    assert isinstance(display_name, str) and display_name.startswith("litellm-vertex-batch-"), display_name
+    assert body == EXPECTED_VERTEX_BODY, body
+    return Reply(body=json.dumps(VERTEX_REPLY).encode())
+
+
+@pytest.mark.covers("other.provider_wire.vertex_ai.batch_create_with_null_output_info_returns_batch_instead_of_500")
+def test_vertex_batch_create_survives_explicit_null_output_info(gateway: Gateway) -> None:
+    with wire_server(vertex_peer) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model=MODEL,
+            api_key=None,
+            api_base=wire.url,
+            vertex_project=PROJECT,
+            vertex_location=LOCATION,
+            vertex_credentials=_vertex_service_account_json(gateway.upstream_url),
+        )
+        response: Final = gateway.request(
+            "POST",
+            "/v1/batches",
+            {
+                "input_file_id": INPUT_FILE_ID,
+                "endpoint": "/v1/chat/completions",
+                "completion_window": "24h",
+                "model": model,
+            },
+        )
+        assert response.status_code == 200, response.text
+        body: Final = response.json()
+        assert (
+            body["id"],
+            body["object"],
+            body["status"],
+            body["input_file_id"],
+            body["output_file_id"],
+            body["error_file_id"],
+            body["completion_window"],
+        ) == (
+            _encoded(JOB_ID, model, "batch_"),
+            "batch",
+            "validating",
+            _encoded(INPUT_FILE_ID, model, "file-"),
+            _encoded(f"{OUTPUT_PREFIX}/predictions.jsonl", model, "file-"),
+            None,
+            "24h",
+        ), response.text
+        requests: Final = wire.drain()
+        assert len(requests) == 1, f"Expected exactly one Vertex POST, saw {[request.target for request in requests]}"
diff --git a/tests/integration/providers/test_vertex_gemini_fragmented_stream_wire.py b/tests/integration/providers/test_vertex_gemini_fragmented_stream_wire.py
new file mode 100644
index 000000000000..449c5c9c105a
--- /dev/null
+++ b/tests/integration/providers/test_vertex_gemini_fragmented_stream_wire.py
@@ -0,0 +1,138 @@
+import json
+import time
+from typing import Final
+
+import pytest
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+from pydantic import BaseModel, ConfigDict, JsonValue, TypeAdapter
+
+_BACKEND: Final = "gemini-3.7-flash"
+_PROJECT: Final = "scripted-project"
+_LOCATION: Final = "us-central1"
+_MODEL_PATH: Final = f"/v1/projects/{_PROJECT}/locations/{_LOCATION}/publishers/google/models/{_BACKEND}"
+_PROMPT: Final = "Write a very long numbered list."
+_PART_COUNT: Final = 8000
+_LINES_PER_FRAGMENT: Final = 64
+_STREAM_BUDGET_SECONDS: Final = 10.0
+_JSON_OBJECT: Final = TypeAdapter(dict[str, JsonValue])
+
+
+class _Delta(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    content: str | None = None
+
+
+class _Choice(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    delta: _Delta
+    finish_reason: str | None = None
+
+
+class _Chunk(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    choices: tuple[_Choice, ...]
+
+
+def _service_account_json(token_url: str) -> str:
+    private_key: Final = (
+        rsa.generate_private_key(public_exponent=65537, key_size=2048)
+        .private_bytes(
+            serialization.Encoding.PEM,
+            serialization.PrivateFormat.PKCS8,
+            serialization.NoEncryption(),
+        )
+        .decode()
+    )
+    return json.dumps(
+        {
+            "type": "service_account",
+            "project_id": _PROJECT,
+            "private_key_id": "scripted",
+            "private_key": private_key,
+            "client_email": f"scripted@{_PROJECT}.iam.gserviceaccount.com",
+            "client_id": "0",
+            "auth_uri": f"{token_url}/_oauth/authorize",
+            "token_uri": f"{token_url}/_oauth/token",
+        }
+    )
+
+
+def _expected_text() -> str:
+    return "".join(f"{index}. item\n" for index in range(_PART_COUNT))
+
+
+def _gemini_response_fragments() -> tuple[bytes, ...]:
+    document: Final = json.dumps(
+        {
+            "candidates": [
+                {
+                    "content": {
+                        "role": "model",
+                        "parts": [{"text": f"{index}. item\n"} for index in range(_PART_COUNT)],
+                    },
+                    "finishReason": "STOP",
+                }
+            ],
+            "usageMetadata": {"promptTokenCount": 9, "candidatesTokenCount": 40000, "totalTokenCount": 40009},
+            "modelVersion": _BACKEND,
+        },
+        indent=2,
+    )
+    lines: Final = document.split("\n")
+    fragments: Final = tuple(
+        "\n".join(lines[start : start + _LINES_PER_FRAGMENT]).encode() + b"\n"
+        for start in range(0, len(lines), _LINES_PER_FRAGMENT)
+    )
+    return (b"data: " + fragments[0], *fragments[1:], b"\n")
+
+
+@pytest.mark.covers("providers.vertex_gemini.fragmented_stream_json_is_parsed_once_and_stays_live")
+def test_vertex_gemini_stream_split_across_many_fragments_completes_without_stalling(gateway: Gateway) -> None:
+    fragments: Final = _gemini_response_fragments()
+
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST"
+        assert request.target == f"{_MODEL_PATH}:streamGenerateContent?alt=sse"
+        assert request.headers["authorization"] == "Bearer scripted-token"
+        body: Final = _JSON_OBJECT.validate_json(request.body)
+        assert body["contents"] == [{"role": "user", "parts": [{"text": _PROMPT}]}]
+        assert body["generationConfig"] == {"temperature": 0.0}
+        return Reply(content_type="text/event-stream", chunks=fragments)
+
+    with wire_server(respond) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model=f"vertex_ai/{_BACKEND}",
+            api_base=f"{wire.url}{_MODEL_PATH}",
+            api_key=None,
+            vertex_project=_PROJECT,
+            vertex_location=_LOCATION,
+            vertex_credentials=_service_account_json(gateway.upstream_url.rstrip("/")),
+        )
+        started: Final = time.monotonic()
+        with gateway.client.stream(
+            "POST",
+            "/v1/chat/completions",
+            json={
+                "model": model,
+                "messages": [{"role": "user", "content": _PROMPT}],
+                "stream": True,
+                "temperature": 0.0,
+            },
+            headers={"Authorization": f"Bearer {gateway.key}"},
+            timeout=_STREAM_BUDGET_SECONDS,
+        ) as response:
+            assert response.status_code == 200, response.read()
+            lines: Final = tuple(line for line in response.iter_lines() if line.startswith("data: "))
+        elapsed: Final = time.monotonic() - started
+        assert elapsed < _STREAM_BUDGET_SECONDS, f"stream took {elapsed:.1f}s for {len(fragments)} fragments"
+        assert lines[-1] == "data: [DONE]", lines[-3:]
+        chunks: Final = tuple(_Chunk.model_validate_json(line.removeprefix("data: ")) for line in lines[:-1])
+        choices: Final = tuple(choice for chunk in chunks for choice in chunk.choices)
+        assert "".join(choice.delta.content or "" for choice in choices) == _expected_text()
+        assert tuple(choice.finish_reason for choice in choices if choice.finish_reason) == ("stop",)
+        assert [(request.method, request.target) for request in wire.drain()] == [
+            ("POST", f"{_MODEL_PATH}:streamGenerateContent?alt=sse")
+        ]
diff --git a/tests/integration/providers/test_websearch_interception_wire.py b/tests/integration/providers/test_websearch_interception_wire.py
index cba4f174233e..a6f098cf64fd 100644
--- a/tests/integration/providers/test_websearch_interception_wire.py
+++ b/tests/integration/providers/test_websearch_interception_wire.py
@@ -183,6 +183,8 @@ def respond(request: Request) -> Reply:
 _QUERY: Final = "integration capped search"
 _TEXT_BLOCK: Final = {"type": "text", "text": "searching once more"}
 _NOT_INTERCEPTED: Final = "native tool reached the provider"
+_FINAL_BLOCK: Final = {"type": "text", "text": "answered from the stored backend"}
+_OWNED_RESULT_TEXT: Final = "Title: Owned result\nURL: https://owned.invalid/a\nSnippet: owned snippet"
 _SEARCH_RESULT_BLOCK: Final = {
     "type": "web_search_result",
     "url": "https://owned.invalid/a",
@@ -297,3 +299,111 @@ def searched_through_proxy(response: httpx.Response) -> bool:
         assert content[2] == _TEXT_BLOCK, response.text
         targets: Final = tuple((request.method, urlsplit(request.target).path) for request in wire.drain())
         assert targets[-3:] == (("POST", "/v1/messages"), ("GET", "/search"), ("POST", "/v1/messages")), targets
+
+
+@pytest.mark.covers("other.provider_wire.anthropic.websearch_interception_uses_database_search_tool_backend")
+def test_database_created_search_tool_backend_receives_the_intercepted_query_over_a_same_named_config_tool(
+    gateway: Gateway, tmp_path: Path
+) -> None:
+    identity: Final = "websearch-db-" + uuid.uuid4().hex
+    tool_name: Final = "integration-db-searxng-" + uuid.uuid4().hex
+    searched: Final = threading.Event()
+
+    def respond(request: Request) -> Reply:
+        parts: Final = urlsplit(request.target)
+        if request.method == "GET" and parts.path == "/database/search":
+            assert parse_qs(parts.query)["q"] == [_QUERY], request.target
+            searched.set()
+            return Reply(
+                body=json.dumps(
+                    {
+                        "results": [
+                            {"title": "Owned result", "url": "https://owned.invalid/a", "content": "owned snippet"}
+                        ]
+                    }
+                ).encode()
+            )
+        assert request.method == "POST" and parts.path == "/v1/messages", request.target
+        body: Final = json.loads(request.body)
+        if any(tool.get("type") == "web_search_20250305" for tool in body["tools"]):
+            return _anthropic_reply(identity, [{"type": "text", "text": _NOT_INTERCEPTED}], "end_turn")
+        assert [tool["name"] for tool in body["tools"]] == ["litellm_web_search"], body["tools"]
+        results: Final = [
+            block
+            for message in body["messages"]
+            if isinstance(message["content"], list)
+            for block in message["content"]
+            if block["type"] == "tool_result"
+        ]
+        if not results:
+            return _anthropic_reply(identity, [_TEXT_BLOCK, _search_tool_use(identity)], "tool_use")
+        assert results == [{"type": "tool_result", "tool_use_id": identity, "content": _OWNED_RESULT_TEXT}], results
+        return _anthropic_reply(identity, [_FINAL_BLOCK], "end_turn")
+
+    def send(candidate: Gateway, model: str) -> httpx.Response:
+        return candidate.request(
+            "POST",
+            "/v1/messages",
+            {
+                "model": model,
+                "max_tokens": 64,
+                "messages": [{"role": "user", "content": identity + " attempt " + uuid.uuid4().hex}],
+                "tools": [{"type": "web_search_20250305", "name": "web_search", "max_uses": 3}],
+            },
+        )
+
+    def searched_through_proxy(response: httpx.Response) -> bool:
+        return searched.is_set() and _NOT_INTERCEPTED not in response.text
+
+    with wire_server(respond) as wire, gateway.scenario() as scenario:
+        created: Final = gateway.post(
+            "/search_tools",
+            {
+                "search_tool": {
+                    "search_tool_name": tool_name,
+                    "litellm_params": {"search_provider": "searxng", "api_base": wire.url + "/database"},
+                }
+            },
+        )
+        scenario.cleanups.callback(gateway.request, "DELETE", f"/search_tools/{created['search_tool_id']}")
+        config: Final = yaml.safe_load(Path("tests/integration/proxy_config.yaml").read_text())
+        config["search_tools"] = [
+            {
+                "search_tool_name": tool_name,
+                "litellm_params": {"search_provider": "searxng", "api_base": wire.url + "/config"},
+            }
+        ]
+        config["litellm_settings"].update(
+            {
+                "callbacks": ["websearch_interception"],
+                "websearch_interception_params": {
+                    "enabled": True,
+                    "enabled_providers": ["anthropic"],
+                    "search_tool_name": tool_name,
+                },
+            }
+        )
+        path: Final = tmp_path / "websearch-db.yaml"
+        path.write_text(yaml.safe_dump(config))
+        environment: Final = {"ANTHROPIC_API_BASE": wire.url}
+        with owned_proxy(gateway, tmp_path, environment, config=path) as candidate, candidate.scenario() as models:
+            model: Final = models.model(
+                model="anthropic/claude-sonnet-4-5-20250929", api_base=wire.url, api_key="synthetic-anthropic-key"
+            )
+            response: Final = eventually(lambda: send(candidate, model), searched_through_proxy, seconds=40)
+        assert response.status_code == 200, response.text
+        body: Final = response.json()
+        assert body["stop_reason"] == "end_turn", response.text
+        assert body["content"][-1] == _FINAL_BLOCK, response.text
+        found: Final = [
+            (result["url"], result["title"])
+            for block in body["content"]
+            if block["type"] == "web_search_tool_result"
+            for result in block["content"]
+        ]
+        assert found == [("https://owned.invalid/a", "Owned result")], response.text
+        assert "litellm_web_search" not in response.text, response.text
+        targets: Final = tuple((request.method, urlsplit(request.target).path) for request in wire.drain())
+        assert targets[-3:] == (("POST", "/v1/messages"), ("GET", "/database/search"), ("POST", "/v1/messages")), (
+            targets
+        )
diff --git a/tests/integration/routing/test_advisor_failure_cooldown.py b/tests/integration/routing/test_advisor_failure_cooldown.py
new file mode 100644
index 000000000000..41618e291095
--- /dev/null
+++ b/tests/integration/routing/test_advisor_failure_cooldown.py
@@ -0,0 +1,101 @@
+import json
+import uuid
+from pathlib import Path
+from typing import Final
+
+import pytest
+import yaml
+from integration._support.client import Gateway
+from integration._support.process import owned_proxy
+from integration._support.wire import Reply, Request, wire_server
+
+_ADVISOR_KEY: Final = "synthetic-advisor-key"
+_QUESTION: Final = "which index should this query use"
+_PROXY_CONFIG: Final = Path(__file__).resolve().parents[1] / "proxy_config.yaml"
+
+
+def _executor_reply(body: dict[str, object], identity: str) -> Reply:
+    tools: Final = body.get("tools")
+    message: Final = (
+        {
+            "role": "assistant",
+            "content": None,
+            "tool_calls": [
+                {
+                    "id": "advisor-call",
+                    "type": "function",
+                    "function": {"name": "advisor", "arguments": json.dumps({"question": _QUESTION})},
+                }
+            ],
+        }
+        if isinstance(tools, list)
+        else {"role": "assistant", "content": "served without an advisor"}
+    )
+    return Reply(
+        body=json.dumps(
+            {
+                "id": f"chatcmpl-{identity}-{uuid.uuid4().hex[:8]}",
+                "object": "chat.completion",
+                "created": 1,
+                "model": "llama-3.3-70b-versatile",
+                "choices": [{"index": 0, "message": message, "finish_reason": "tool_calls" if tools else "stop"}],
+                "usage": {"prompt_tokens": 10, "completion_tokens": 4, "total_tokens": 14},
+            }
+        ).encode()
+    )
+
+
+def _cooldowns_enabled_config(directory: Path) -> Path:
+    loaded: Final = yaml.safe_load(_PROXY_CONFIG.read_text())
+    path: Final = directory / "cooldowns_enabled.yaml"
+    path.write_text(yaml.safe_dump({**loaded, "router_settings": {"num_retries": 0}}))
+    return path
+
+
+@pytest.mark.covers("routing.cooldown.advisor_sub_call_failure_does_not_cool_down_the_executor_deployment")
+def test_advisor_sub_call_401_leaves_the_executor_deployment_serving_the_next_request(
+    gateway: Gateway, tmp_path: Path
+) -> None:
+    identity: Final = "advisor-cooldown-" + uuid.uuid4().hex
+
+    def respond(request: Request) -> Reply:
+        if request.target == "/v1/chat/completions":
+            return _executor_reply(json.loads(request.body), identity)
+        assert request.target == "/v1/messages"
+        assert request.headers["x-api-key"] == _ADVISOR_KEY
+        return Reply(
+            status=401,
+            body=json.dumps(
+                {"type": "error", "error": {"type": "authentication_error", "message": "invalid x-api-key"}}
+            ).encode(),
+        )
+
+    with (
+        wire_server(respond) as wire,
+        owned_proxy(gateway, tmp_path, {}, config=_cooldowns_enabled_config(tmp_path)) as candidate,
+        candidate.scenario() as scenario,
+    ):
+        executor: Final = scenario.model(model="hosted_vllm/gpt-4o-mini", api_base=wire.url + "/v1")
+        advisor: Final = scenario.model(
+            model="anthropic/claude-opus-4-1-20250805", api_base=wire.url, api_key=_ADVISOR_KEY
+        )
+        advised: Final = candidate.request(
+            "POST",
+            "/v1/messages",
+            {
+                "model": executor,
+                "max_tokens": 64,
+                "messages": [{"role": "user", "content": identity}],
+                "tools": [{"type": "advisor_20260301", "name": "advisor", "model": advisor}],
+            },
+        )
+        assert advised.status_code == 401, advised.text
+        assert [request.target for request in wire.drain()] == ["/v1/chat/completions", "/v1/messages"]
+        unrelated: Final = candidate.request(
+            "POST",
+            "/v1/chat/completions",
+            {"model": executor, "messages": [{"role": "user", "content": identity + " unrelated"}]},
+        )
+        assert unrelated.status_code == 200, unrelated.text
+        assert unrelated.json()["choices"][0]["message"]["content"] == "served without an advisor", unrelated.text
+        assert [request.target for request in wire.drain()] == ["/v1/chat/completions"]
diff --git a/tests/integration/routing/test_key_tpm_reservation.py b/tests/integration/routing/test_key_tpm_reservation.py
new file mode 100644
index 000000000000..8d0e06679cd5
--- /dev/null
+++ b/tests/integration/routing/test_key_tpm_reservation.py
@@ -0,0 +1,59 @@
+import json
+import time
+import uuid
+from collections import Counter
+from concurrent.futures import ThreadPoolExecutor
+from typing import Final
+
+import httpx
+import pytest
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+from pydantic import JsonValue
+
+KEY_TPM_LIMIT: Final = 100
+MAX_TOKENS: Final = 80
+CONCURRENT_REQUESTS: Final = 10
+PROVIDER_HOLD_SECONDS: Final = 2.0
+UPSTREAM_REPLY: Final = json.dumps(
+    {
+        "id": "chatcmpl_tpm_reservation",
+        "object": "chat.completion",
+        "created": 1,
+        "model": "gpt-4o-mini",
+        "choices": [{"index": 0, "message": {"role": "assistant", "content": "reserved"}, "finish_reason": "stop"}],
+        "usage": {"prompt_tokens": 20, "completion_tokens": 20, "total_tokens": 40},
+    }
+).encode()
+
+
+@pytest.mark.covers("quota_management.key_tpm_limit.concurrent_requests_reserve_tokens_before_provider_call")
+def test_concurrent_requests_over_key_tpm_are_rejected_before_reaching_provider(gateway: Gateway) -> None:
+    probe: Final = "tpm reservation probe " + uuid.uuid4().hex[:8]
+    messages: Final[list[JsonValue]] = [{"role": "user", "content": probe}]
+
+    def respond(request: Request) -> Reply:
+        assert (request.method, request.target) == ("POST", "/v1/chat/completions")
+        assert json.loads(request.body) == {"model": "gpt-4o-mini", "max_tokens": MAX_TOKENS, "messages": messages}
+        time.sleep(PROVIDER_HOLD_SECONDS)
+        return Reply(body=UPSTREAM_REPLY)
+
+    with wire_server(respond) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(api_base=f"{wire.url}/v1")
+        key: Final = scenario.key(tpm_limit=KEY_TPM_LIMIT)
+        body: Final[dict[str, JsonValue]] = {
+            "model": model,
+            "max_tokens": MAX_TOKENS,
+            "messages": messages,
+        }
+
+        def send(_: int) -> httpx.Response:
+            return gateway.request("POST", "/v1/chat/completions", body, key=key)
+
+        with ThreadPoolExecutor(max_workers=CONCURRENT_REQUESTS) as pool:
+            responses: Final = tuple(pool.map(send, range(CONCURRENT_REQUESTS)))
+        statuses: Final = Counter(response.status_code for response in responses)
+        assert statuses == Counter({200: 1, 429: CONCURRENT_REQUESTS - 1}), tuple(
+            response.text for response in responses
+        )
+        assert tuple(json.loads(request.body)["messages"] for request in wire.drain()) == (messages,)
diff --git a/tests/integration/routing/test_priority_model_tpm_enforcement.py b/tests/integration/routing/test_priority_model_tpm_enforcement.py
new file mode 100644
index 000000000000..c3d0446c1e1f
--- /dev/null
+++ b/tests/integration/routing/test_priority_model_tpm_enforcement.py
@@ -0,0 +1,116 @@
+import json
+import uuid
+from pathlib import Path
+from queue import SimpleQueue
+from typing import Final
+
+import httpx
+import pytest
+import yaml
+from integration._support.client import Gateway, eventually
+from integration._support.process import owned_proxy
+from integration._support.wire import Reply, Request, wire_server
+
+OPENAI_MODEL: Final = "gpt-4.1-mini"
+PROMPT_TOKENS: Final = 30
+COMPLETION_TOKENS: Final = 10
+MODEL_TPM: Final = PROMPT_TOKENS + COMPLETION_TOKENS
+PREMIUM_SHARE: Final = 0.5
+UPSTREAM_REPLY: Final = json.dumps(
+    {
+        "id": "chatcmpl_model_tpm_enforcement",
+        "object": "chat.completion",
+        "created": 1700000000,
+        "model": OPENAI_MODEL,
+        "choices": [
+            {
+                "index": 0,
+                "message": {"role": "assistant", "content": "model tpm control"},
+                "finish_reason": "stop",
+            }
+        ],
+        "usage": {
+            "prompt_tokens": PROMPT_TOKENS,
+            "completion_tokens": COMPLETION_TOKENS,
+            "total_tokens": PROMPT_TOKENS + COMPLETION_TOKENS,
+        },
+    }
+).encode()
+
+
+@pytest.mark.covers("other.routing.priority_rate_limits.tpm_only_model_rejects_priority_traffic_at_capacity")
+def test_tpm_only_model_returns_429_to_priority_key_once_recorded_tokens_reach_model_tpm(
+    gateway: Gateway, tmp_path: Path
+) -> None:
+    probe: Final = "model tpm probe " + uuid.uuid4().hex
+
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == "/v1/chat/completions"
+        assert request.headers["authorization"] == "Bearer synthetic-openai-key"
+        body: Final = json.loads(request.body)
+        assert body["messages"][0]["content"].startswith(probe), body
+        assert body == {
+            "model": OPENAI_MODEL,
+            "messages": [{"role": "user", "content": body["messages"][0]["content"]}],
+            "max_tokens": 16,
+        }
+        return Reply(body=UPSTREAM_REPLY)
+
+    configuration: Final = yaml.safe_load(Path("tests/integration/proxy_config.yaml").read_text())
+    configuration["litellm_settings"] = {
+        **configuration["litellm_settings"],
+        "callbacks": ["dynamic_rate_limiter_v3"],
+        "priority_reservation": {"premium": PREMIUM_SHARE},
+    }
+    path: Final = tmp_path / "priority.yaml"
+    path.write_text(yaml.safe_dump(configuration))
+    with (
+        wire_server(respond) as wire,
+        owned_proxy(gateway, tmp_path, {}, config=path) as candidate,
+        candidate.scenario() as scenario,
+    ):
+        model: Final = scenario.model(
+            model=f"openai/{OPENAI_MODEL}",
+            api_base=f"{wire.url}/v1",
+            api_key="synthetic-openai-key",
+            tpm=MODEL_TPM,
+        )
+        key: Final = scenario.key(metadata={"priority": "premium"})
+        responses: Final[SimpleQueue[httpx.Response]] = SimpleQueue()
+
+        def attempt() -> httpx.Response:
+            response: Final = candidate.request(
+                "POST",
+                "/v1/chat/completions",
+                {
+                    "model": model,
+                    "max_tokens": 16,
+                    "messages": [{"role": "user", "content": f"{probe} {uuid.uuid4().hex}"}],
+                },
+                key=key,
+            )
+            responses.put(response)
+            return response
+
+        first: Final = attempt()
+        assert first.status_code == 200, first.text
+        assert first.json()["usage"]["total_tokens"] == MODEL_TPM, first.text
+        blocked: Final = eventually(attempt, lambda response: response.status_code == 429, seconds=30)
+        served: Final = tuple(responses.get_nowait() for _ in range(responses.qsize()))
+        assert all(response.status_code == 200 for response in served[:-1]), [r.status_code for r in served]
+        assert len(wire.drain()) == len(served) - 1
+        assert blocked.headers["x-litellm-priority"] == "premium", blocked.headers
+        assert blocked.headers["rate_limit_type"] == "tokens", blocked.headers
+        detail: Final = (
+            f"Model capacity reached for {model}. Priority: premium, Rate limit type: tokens, "
+            f"Model TPM: {MODEL_TPM}, Model RPM: not configured, Remaining: 0"
+        )
+        assert blocked.json() == {
+            "error": {
+                "message": detail,
+                "type": "throttling_error",
+                "param": None,
+                "code": "429",
+                "provider_specific_fields": {"error": detail},
+            }
+        }, blocked.text
diff --git a/tests/integration/routing/test_priority_rate_limit_headers.py b/tests/integration/routing/test_priority_rate_limit_headers.py
index 2d21f3ba8b2a..bd92a362885a 100644
--- a/tests/integration/routing/test_priority_rate_limit_headers.py
+++ b/tests/integration/routing/test_priority_rate_limit_headers.py
@@ -5,7 +5,7 @@
 
 import pytest
 import yaml
-from integration._support.client import Gateway
+from integration._support.client import Gateway, eventually
 from integration._support.process import owned_proxy
 from integration._support.wire import Reply, Request, wire_server
 
@@ -27,6 +27,27 @@
 ).encode()
 
 
+CHAT_MODEL: Final = "gpt-5.6"
+MAX_COMPLETION_TOKENS: Final = 64
+
+
+def _chat_frames(identity: str, text: str) -> tuple[bytes, ...]:
+    events: Final = (
+        {"choices": [{"index": 0, "delta": {"role": "assistant", "content": text}, "finish_reason": None}]},
+        {"choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}]},
+        {"choices": [], "usage": {"prompt_tokens": 10, "completion_tokens": 4, "total_tokens": 14}},
+    )
+    frames: Final = tuple(
+        b"data: "
+        + json.dumps(
+            {"id": identity, "object": "chat.completion.chunk", "created": 1, "model": CHAT_MODEL, **event}
+        ).encode()
+        + b"\n\n"
+        for event in events
+    )
+    return (*frames, b"data: [DONE]\n\n")
+
+
 @pytest.mark.covers("other.routing.priority_rate_limits.v1_messages_success_exposes_v3_priority_headers")
 def test_non_streaming_v1_messages_success_carries_v3_priority_rate_limit_headers(
     gateway: Gateway, tmp_path: Path
@@ -86,3 +107,89 @@ def respond(request: Request) -> Reply:
         }
         observed: Final = {name: response.headers.get(name) for name in expected}
         assert observed == expected, response.headers
+
+
+@pytest.mark.covers("other.routing.priority_rate_limits.streaming_success_logs_v3_remaining_values_for_callbacks")
+def test_streaming_chat_completion_success_logs_v3_rate_limit_remaining_values_for_callbacks(
+    gateway: Gateway, tmp_path: Path
+) -> None:
+    probe: Final = "streaming remaining probe " + uuid.uuid4().hex
+    sink_secret: Final = "synthetic-sink-secret-" + uuid.uuid4().hex
+
+    def provider(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == "/v1/chat/completions", request.target
+        assert request.headers["authorization"] == "Bearer synthetic-openai-key"
+        assert json.loads(request.body) == {
+            "model": CHAT_MODEL,
+            "messages": [{"role": "user", "content": probe}],
+            "max_completion_tokens": MAX_COMPLETION_TOKENS,
+            "stream": True,
+            "stream_options": {"include_usage": True},
+        }, request.body
+        return Reply(content_type="text/event-stream", chunks=_chat_frames("chatcmpl_" + probe[-8:], "streamed"))
+
+    def sink(request: Request) -> Reply:
+        assert request.headers["authorization"] == f"Bearer {sink_secret}"
+        return Reply()
+
+    configuration: Final = yaml.safe_load(Path("tests/integration/proxy_config.yaml").read_text())
+    configuration["litellm_settings"] = {
+        **configuration["litellm_settings"],
+        "callbacks": ["generic_api"],
+        "DEFAULT_FLUSH_INTERVAL_SECONDS": 1,
+    }
+    path: Final = tmp_path / "per_key_streaming.yaml"
+    path.write_text(yaml.safe_dump(configuration))
+    with (
+        wire_server(provider) as wire,
+        wire_server(sink) as endpoint,
+        owned_proxy(
+            gateway,
+            tmp_path,
+            {"GENERIC_LOGGER_ENDPOINT": endpoint.url, "GENERIC_LOGGER_HEADERS": f"Authorization=Bearer {sink_secret}"},
+            config=path,
+        ) as candidate,
+        candidate.scenario() as scenario,
+    ):
+        model: Final = scenario.model(
+            model=f"openai/{CHAT_MODEL}",
+            api_base=wire.url + "/v1",
+            api_key="synthetic-openai-key",
+        )
+        key: Final = scenario.key(model_rpm_limit={model: MODEL_RPM}, model_tpm_limit={model: MODEL_TPM})
+        response: Final = candidate.request(
+            "POST",
+            "/v1/chat/completions",
+            {
+                "model": model,
+                "messages": [{"role": "user", "content": probe}],
+                "max_completion_tokens": MAX_COMPLETION_TOKENS,
+                "stream": True,
+                "stream_options": {"include_usage": True},
+            },
+            key=key,
+        )
+        assert response.status_code == 200, response.text
+        assert '"content":"streamed"' in response.text, response.text
+        assert len(wire.drain()) == 1
+        batches: Final[
+            list[Request]
+        ] = []  # mutable-ok: drain() consumes the queue, later polls must keep earlier batches
+
+        def delivered() -> tuple[dict, ...]:
+            batches.extend(endpoint.drain())
+            return tuple(
+                event for batch in batches for event in json.loads(batch.body) if event.get("model_group") == model
+            )
+
+        events: Final = eventually(delivered, lambda values: len(values) == 1, seconds=10)
+        assert (events[0]["status"], events[0]["stream"]) == ("success", True), json.dumps(events[0])
+        additional_headers: Final = events[0]["hidden_params"]["additional_headers"] or {}
+        observed: Final = {name: value for name, value in additional_headers.items() if name.startswith("x-ratelimit-")}
+        remaining_tokens: Final = observed.get("x-ratelimit-model_per_key-remaining-tokens")
+        assert isinstance(remaining_tokens, int) and 0 < remaining_tokens <= MODEL_TPM, json.dumps(observed)
+        assert {name: value for name, value in observed.items() if not name.endswith("-remaining-tokens")} == {
+            "x-ratelimit-model_per_key-limit-requests": MODEL_RPM,
+            "x-ratelimit-model_per_key-remaining-requests": MODEL_RPM - 1,
+            "x-ratelimit-model_per_key-limit-tokens": MODEL_TPM,
+        }, json.dumps(events[0]["hidden_params"])
diff --git a/tests/integration/routing/test_team_model_tpm_limit.py b/tests/integration/routing/test_team_model_tpm_limit.py
new file mode 100644
index 000000000000..741c41c92852
--- /dev/null
+++ b/tests/integration/routing/test_team_model_tpm_limit.py
@@ -0,0 +1,89 @@
+import json
+import threading
+import uuid
+from concurrent.futures import Future, ThreadPoolExecutor
+from typing import Final
+
+import httpx
+import pytest
+from integration._support.client import Gateway, eventually
+from integration._support.wire import Reply, Request, wire_server
+
+PROVIDER_MODEL: Final = "gpt-4o-mini"
+TEAM_MODEL_TPM: Final = 100
+MAX_TOKENS: Final = 60
+CONCURRENT_REQUESTS: Final = 3
+UPSTREAM_REPLY: Final = json.dumps(
+    {
+        "id": "chatcmpl-team-tpm-control",
+        "object": "chat.completion",
+        "created": 1,
+        "model": PROVIDER_MODEL,
+        "choices": [
+            {"index": 0, "message": {"role": "assistant", "content": "team tpm control"}, "finish_reason": "stop"}
+        ],
+        "usage": {"prompt_tokens": 10, "completion_tokens": 4, "total_tokens": 14},
+    }
+).encode()
+
+
+@pytest.mark.covers("routing.team_model_tpm.concurrent_requests_over_the_limit_are_rejected_before_the_provider_call")
+def test_concurrent_team_model_tpm_requests_reserve_tokens_before_reaching_the_provider(gateway: Gateway) -> None:
+    probe: Final = "team tpm probe " + uuid.uuid4().hex
+    release: Final = threading.Event()
+
+    def respond(request: Request) -> Reply:
+        assert request.method == "POST" and request.target == "/v1/chat/completions"
+        assert request.headers["authorization"] == "Bearer synthetic-team-tpm-key"
+        body: Final = json.loads(request.body)
+        content: Final = body["messages"][0]["content"]
+        assert body == {
+            "model": PROVIDER_MODEL,
+            "messages": [{"role": "user", "content": content}],
+            "max_tokens": MAX_TOKENS,
+        }
+        assert content.startswith(probe), content
+        release.wait(timeout=10)
+        return Reply(body=UPSTREAM_REPLY)
+
+    with wire_server(respond) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model=f"openai/{PROVIDER_MODEL}",
+            api_base=wire.url + "/v1",
+            api_key="synthetic-team-tpm-key",
+        )
+        team: Final = scenario.team(metadata={"model_tpm_limit": {model: TEAM_MODEL_TPM}})
+        key: Final = scenario.key(team_id=team)
+
+        def send(index: int) -> httpx.Response:
+            return gateway.request(
+                "POST",
+                "/v1/chat/completions",
+                {
+                    "model": model,
+                    "max_tokens": MAX_TOKENS,
+                    "messages": [{"role": "user", "content": f"{probe} {index}"}],
+                },
+                key=key,
+            )
+
+        with ThreadPoolExecutor(max_workers=CONCURRENT_REQUESTS) as pool:
+            futures: Final[tuple[Future[httpx.Response], ...]] = tuple(
+                pool.submit(send, index) for index in range(CONCURRENT_REQUESTS)
+            )
+            eventually(
+                lambda: sum(future.done() for future in futures) + wire.received.qsize(),
+                lambda settled: settled >= CONCURRENT_REQUESTS,
+                seconds=10,
+            )
+            release.set()
+            responses: Final = tuple(future.result(timeout=15) for future in futures)
+        statuses: Final = tuple(sorted(response.status_code for response in responses))
+        assert statuses == (200, 429, 429), tuple(response.text for response in responses)
+        assert len(wire.drain()) == 1, statuses
+        served: Final = next(response for response in responses if response.status_code == 200)
+        assert served.json()["usage"] == {"prompt_tokens": 10, "completion_tokens": 4, "total_tokens": 14}, served.text
+        for rejected in (response for response in responses if response.status_code == 429):
+            error: Final = rejected.json()["error"]
+            assert (error["type"], error["code"], error["param"]) == ("throttling_error", "429", None), rejected.text
+            assert f"Limit type: tokens. Current limit: {TEAM_MODEL_TPM}," in error["message"], rejected.text
diff --git a/tests/integration/run.py b/tests/integration/run.py
index 0f9aa75b5490..9ef585def3d8 100644
--- a/tests/integration/run.py
+++ b/tests/integration/run.py
@@ -9,7 +9,18 @@
 from types import MappingProxyType
 from typing import Final
 
-GROUPS: Final = MappingProxyType(json.loads(Path(__file__).with_name("contracts.json").read_text())["groups"])
+GROUPS: Final = MappingProxyType(
+    {
+        "management": ("management", "authorization", "configuration"),
+        "accounting": ("pricing", "spend"),
+        "database": ("database",),
+        "providers": ("providers", "routing", "streaming"),
+        "extensions": ("observability", "compatibility"),
+        "mcp": ("mcp",),
+        "sdk": ("sdk",),
+        "cost": ("cost_calculation",),
+    }
+)
 
 
 def main() -> int:
@@ -27,13 +38,9 @@ def main() -> int:
         for path in sorted((root / "tests/integration" / folder).glob("test_*.py"))
     )
     if not selected:
-        parser.error(f"No integration contracts selected for {options.group}")
+        parser.error(f"No integration test files selected for {options.group}")
     output: Final = options.results.resolve()
     output.mkdir(parents=True, exist_ok=True)
-    manifest: Final = json.loads((root / "tests/integration/contracts.json").read_text())["tests"]
-    expected: Final = sorted(node for node in manifest if node.split("::", 1)[0] in selected)
-    if not expected or set(selected) != {node.split("::", 1)[0] for node in expected}:
-        parser.error("Every selected file must have canonical manifest nodes")
     environment: Final = {
         **os.environ,
         "PYTHONPATH": os.pathsep.join((str(root), str(root / "tests"), str(root / "tests/e2e"))),
@@ -58,11 +65,7 @@ def main() -> int:
             f"--hypothesis-seed={options.seed}",
             f"--integration-order-seed={options.order_seed}",
             f"--junitxml={output / 'junit.xml'}",
-            *(
-                ("-n", str(options.workers))
-                if options.workers > 1
-                else ()
-            ),
+            *(("-n", str(options.workers)) if options.workers > 1 else ()),
         ],
         cwd=root,
         env=environment,
@@ -70,9 +73,13 @@ def main() -> int:
     if result != 0:
         return result
     evidence: Final = json.loads((output / "execution.json").read_text())
-    executed: Final = sorted(evidence["passed"] + evidence["skipped"])
-    if not evidence["complete"] or executed != expected or sorted(evidence["collected"]) != expected:
-        print("Executed integration nodes differ from the canonical manifest", file=sys.stderr)
+    collected_files: Final = {node.split("::", 1)[0] for node in evidence["collected"]}
+    empty: Final = tuple(path for path in selected if path not in collected_files)
+    if empty:
+        sys.stderr.write(f"Selected integration files collected zero tests: {', '.join(empty)}\n")
+        return 1
+    if not evidence["complete"]:
+        sys.stderr.write("Integration run did not complete: a collected node neither passed nor skipped\n")
         return 1
     return 0
 
diff --git a/tests/integration/sdk/test_aiohttp_session_rebuild_wire.py b/tests/integration/sdk/test_aiohttp_session_rebuild_wire.py
new file mode 100644
index 000000000000..1ec1f486bed8
--- /dev/null
+++ b/tests/integration/sdk/test_aiohttp_session_rebuild_wire.py
@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import textwrap
+import threading
+from collections.abc import Iterator
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Final
+
+import pytest
+from pydantic import JsonValue, TypeAdapter
+
+CONFIGURED_KEEPALIVE_SECONDS: Final = 1
+IDLE_SECONDS: Final = 2
+RESPONSES: Final = TypeAdapter(list[dict[str, JsonValue]])
+
+REBUILT_SESSION_EXCHANGE: Final = textwrap.dedent(
+    """
+    import asyncio, json, sys
+    from aiohttp import ClientSession
+    from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
+
+    async def main(base_url: str, idle_seconds: float) -> None:
+        shared = ClientSession()
+        handler = AsyncHTTPHandler(shared_session=shared)
+        await shared.close()
+        first = await handler.post(f"{base_url}/embeddings", json={"input": "warm-up"})
+        await asyncio.sleep(idle_seconds)
+        second = await handler.post(f"{base_url}/embeddings", json={"input": "warm-up"})
+        print(json.dumps([first.json(), second.json()]))
+        await handler.close()
+
+    asyncio.run(main(sys.argv[1], float(sys.argv[2])))
+    """
+)
+
+
+class _ConnectionCountingPeer(ThreadingHTTPServer):
+    daemon_threads = True
+
+    def __init__(self, address: tuple[str, int]) -> None:
+        super().__init__(address, _ConnectionHandler)
+        self.lock = threading.Lock()
+        self.connections = 0
+
+    def next_connection(self) -> int:
+        with self.lock:
+            self.connections += 1
+            return self.connections
+
+
+class _ConnectionHandler(BaseHTTPRequestHandler):
+    protocol_version = "HTTP/1.1"
+    server: _ConnectionCountingPeer
+
+    def setup(self) -> None:
+        super().setup()
+        self.connection_number = self.server.next_connection()
+
+    def do_POST(self) -> None:
+        self.rfile.read(int(self.headers["Content-Length"]))
+        body: Final = json.dumps({"connection": self.connection_number}).encode()
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def log_message(self, format: str, *args: object) -> None:
+        return
+
+
+@pytest.fixture
+def connection_counting_peer() -> Iterator[str]:
+    server: Final = _ConnectionCountingPeer(("127.0.0.1", 0))
+    thread: Final = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    yield f"http://127.0.0.1:{server.server_address[1]}"
+    server.shutdown()
+    server.server_close()
+    thread.join(timeout=10)
+
+
+def _rebuilt_session_exchange(base_url: str) -> list[dict[str, JsonValue]]:
+    completed: Final = subprocess.run(
+        [sys.executable, "-P", "-c", REBUILT_SESSION_EXCHANGE, base_url, str(IDLE_SECONDS)],
+        env={
+            **os.environ,
+            "AIOHTTP_KEEPALIVE_TIMEOUT": str(CONFIGURED_KEEPALIVE_SECONDS),
+            "AIOHTTP_SO_KEEPALIVE": "true",
+        },
+        capture_output=True,
+        text=True,
+        timeout=60,
+        check=False,
+    )
+    assert completed.returncode == 0, completed.stderr
+    return RESPONSES.validate_json(completed.stdout)
+
+
+@pytest.mark.covers("sdk.aiohttp_transport.rebuilt_shared_session_keeps_configured_keepalive_timeout")
+def test_rebuilt_shared_session_drops_idle_connection_after_configured_keepalive_timeout(
+    connection_counting_peer: str,
+) -> None:
+    observed: Final = _rebuilt_session_exchange(connection_counting_peer)
+    assert observed == [{"connection": 1}, {"connection": 2}], observed
diff --git a/tests/integration/spend/test_cache_and_quota.py b/tests/integration/spend/test_cache_and_quota.py
index 97ef785aa15e..1c2b5551855f 100644
--- a/tests/integration/spend/test_cache_and_quota.py
+++ b/tests/integration/spend/test_cache_and_quota.py
@@ -1,19 +1,27 @@
 import json
+import os
 import threading
 import uuid
+from collections.abc import Generator
 from concurrent.futures import ThreadPoolExecutor
-from contextlib import ExitStack
+from contextlib import ExitStack, contextmanager
 from hashlib import sha256
+from pathlib import Path
 from typing import Final
+from urllib.parse import urlsplit, urlunsplit
 
 import httpx
+import psycopg
 import pytest
 from hypothesis import strategies as st
 from hypothesis.stateful import RuleBasedStateMachine, rule, run_state_machine_as_test
-from integration._support.client import Gateway, eventually
+from integration._support.client import Gateway, eventually, string_value
 from integration._support.database import read_rows
+from integration._support.database_relay import database_relay
 from integration._support.generation import LIFECYCLE_SETTINGS, bounded_http_requests
+from integration._support.process import owned_proxy
 from integration._support.wire import Reply, Request, wire_server
+from psycopg import sql
 
 
 @pytest.mark.covers("quota_management.response_cache.generated_sequences_preserve_content_and_accounting")
@@ -214,6 +222,99 @@ def test_key_budget_at_boundary_blocks_provider_then_explicit_reset_restores(gat
         assert upstream.get("/__observations").json()["requests"] == []
 
 
+RESET_SWEEP_QUERY: Final = b'"LiteLLM_VerificationToken"."budget_reset_at" < $'
+
+
+@contextmanager
+def scratch_database() -> Generator[str]:
+    name: Final = f"integration_{uuid.uuid4().hex}"
+    with psycopg.connect(os.environ["DATABASE_URL"], autocommit=True) as admin:
+        admin.execute(sql.SQL("CREATE DATABASE {}").format(sql.Identifier(name)))
+        try:
+            yield urlunsplit(urlsplit(os.environ["DATABASE_URL"])._replace(path=f"/{name}"))
+        finally:
+            admin.execute(sql.SQL("DROP DATABASE {} WITH (FORCE)").format(sql.Identifier(name)))
+
+
+@pytest.mark.covers("quota_management.budget.key.scheduled_reset_survives_transient_db_outage")
+@pytest.mark.timeout(300)
+def test_scheduled_budget_reset_reconnects_after_db_transport_failure_and_unblocks_key(
+    gateway: Gateway, tmp_path: Path
+) -> None:
+    with (
+        scratch_database() as scratch_url,
+        database_relay(scratch_url, RESET_SWEEP_QUERY) as (relay, relayed_url),
+        httpx.Client(base_url=gateway.upstream_url, timeout=5, trust_env=False) as upstream,
+        owned_proxy(
+            gateway,
+            tmp_path,
+            {
+                "DATABASE_URL": relayed_url,
+                "PROXY_BUDGET_RESCHEDULER_MIN_TIME": "30",
+                "PROXY_BUDGET_RESCHEDULER_MAX_TIME": "30",
+                "PRISMA_HEALTH_WATCHDOG_ENABLED": "false",
+            },
+        ) as candidate,
+    ):
+        model: Final = f"integration-{uuid.uuid4().hex}"
+        candidate.post(
+            "/model/new",
+            {
+                "model_name": 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,
+                },
+                "model_info": {},
+            },
+        )
+        key: Final = string_value(
+            candidate.post("/key/generate", {"models": [model], "max_budget": 0.06, "budget_duration": "5s"})["key"]
+        )
+        digest: Final = sha256(key.encode()).hexdigest()
+        row_query: Final = (
+            'SELECT spend, budget_reset_at::text AS budget_reset_at FROM "LiteLLM_VerificationToken" WHERE token=%s'
+        )
+        assert candidate.chat(model, key=key, text=f"spend it {uuid.uuid4().hex}")["usage"]["total_tokens"] == 40
+        exhausted: Final = eventually(
+            lambda: read_rows(row_query, (digest,), database_url=scratch_url),
+            lambda rows: len(rows) == 1 and float(rows[0]["spend"]) >= 0.06,
+            seconds=70,
+        )
+        assert float(exhausted[0]["spend"]) == pytest.approx(0.06)
+        upstream.get("/__observations").raise_for_status()
+        denied: Final = candidate.request(
+            "POST",
+            "/v1/chat/completions",
+            {"model": model, "messages": [{"role": "user", "content": f"over budget {uuid.uuid4().hex}"}]},
+            key=key,
+        )
+        assert denied.status_code == 422 and denied.json()["error"]["type"] == "budget_exceeded", denied.text
+        assert upstream.get("/__observations").json()["requests"] == []
+        relay.arm()
+        assert relay.tripped.wait(90), "Scheduled reset sweep never reached the database"
+        eventually(lambda: relay.refused, lambda count: count >= 1, seconds=30)
+        reset: Final = eventually(
+            lambda: read_rows(row_query, (digest,), database_url=scratch_url),
+            lambda rows: len(rows) == 1 and float(rows[0]["spend"]) == 0,
+            seconds=80,
+            return_last_on_timeout=True,
+        )
+        assert len(reset) == 1 and reset[0]["spend"] == 0.0, (exhausted, reset)
+        assert str(reset[0]["budget_reset_at"]) > str(exhausted[0]["budget_reset_at"]), (exhausted, reset)
+        prompt: Final = f"after reset {uuid.uuid4().hex}"
+        recovered: Final = candidate.request(
+            "POST", "/v1/chat/completions", {"model": model, "messages": [{"role": "user", "content": prompt}]}, key=key
+        )
+        assert recovered.status_code == 200, recovered.text
+        assert recovered.json()["usage"]["total_tokens"] == 40, recovered.text
+        reached: Final = upstream.get("/__observations").json()["requests"]
+        assert len(reached) == 1 and reached[0]["body"]["messages"] == [{"role": "user", "content": prompt}], reached
+
+
 @pytest.mark.covers("quota_management.budget.key.count_tokens_reserves_nothing_so_completion_within_budget_succeeds")
 def test_repeated_count_tokens_on_budgeted_key_does_not_reserve_budget_or_block_later_completion(
     gateway: Gateway,
@@ -333,6 +434,7 @@ def test_different_system_messages_do_not_share_a_cached_response(gateway: Gatew
     ):
         model: Final = scenario.model()
         prompt: Final = uuid.uuid4().hex
+
         def completion_id(system: str, expected_calls: int) -> str:
             upstream.get("/__observations").raise_for_status()
             response: Final = gateway.request(
diff --git a/tests/integration/spend/test_end_user_spend_without_proxy_user.py b/tests/integration/spend/test_end_user_spend_without_proxy_user.py
new file mode 100644
index 000000000000..15d77f16db4b
--- /dev/null
+++ b/tests/integration/spend/test_end_user_spend_without_proxy_user.py
@@ -0,0 +1,29 @@
+import uuid
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway, eventually
+from integration._support.database import read_rows
+
+
+@pytest.mark.covers("spend.end_user.charged_when_key_has_no_user_id_and_auth_cache_is_redis")
+def test_end_user_spend_lands_for_key_without_user_id_when_auth_cache_is_redis(gateway: Gateway) -> None:
+    with gateway.scenario() as scenario:
+        model: Final = scenario.model(input_cost_per_token=0.001, output_cost_per_token=0.002)
+        key: Final = scenario.key(models=[model])
+        end_user: Final = f"integration-end-user-{uuid.uuid4().hex}"
+        scenario.cleanups.callback(gateway.request, "POST", "/customer/delete", {"user_ids": [end_user]})
+        response: Final = gateway.request(
+            "POST",
+            "/v1/chat/completions",
+            {"model": model, "messages": [{"role": "user", "content": f"end user spend {end_user}"}], "user": end_user},
+            key=key,
+        )
+        assert response.status_code == 200, response.text
+        assert response.json()["usage"]["total_tokens"] == 40, response.text
+        charged: Final = eventually(
+            lambda: read_rows('SELECT spend FROM "LiteLLM_EndUserTable" WHERE user_id=%s', (end_user,)),
+            lambda values: len(values) == 1 and float(values[0]["spend"]) >= 0.06,
+            seconds=70,
+        )
+        assert float(charged[0]["spend"]) == pytest.approx(20 * 0.001 + 20 * 0.002)
diff --git a/tests/integration/spend/test_legacy_spend_logs_row_cap.py b/tests/integration/spend/test_legacy_spend_logs_row_cap.py
new file mode 100644
index 000000000000..3a7ac8a83bd3
--- /dev/null
+++ b/tests/integration/spend/test_legacy_spend_logs_row_cap.py
@@ -0,0 +1,46 @@
+import os
+import uuid
+from datetime import datetime, timedelta, timezone
+from typing import Final
+
+import psycopg
+import pytest
+from integration._support.client import Gateway
+from integration._support.database import read_rows
+
+LEGACY_SPEND_LOGS_ROW_CAP: Final = 10000
+
+
+def _seed_spend_rows(user_id: str, count: int) -> tuple[str, ...]:
+    started: Final = datetime.now(timezone.utc) - timedelta(days=1)
+    with psycopg.connect(os.environ["DATABASE_URL"], autocommit=True) as connection:
+        connection.execute(
+            'INSERT INTO "LiteLLM_SpendLogs" '
+            '(request_id, call_type, "startTime", "endTime", "user", status) '
+            "SELECT %s || '-' || n, 'acompletion', %s + n * interval '1 second', %s + n * interval '1 second', %s, "
+            "'success' FROM generate_series(1, %s) AS n",
+            (user_id, started, started, user_id, count),
+        )
+    return tuple(f"{user_id}-{n}" for n in range(1, count + 1))
+
+
+def _delete_spend_rows(user_id: str) -> None:
+    with psycopg.connect(os.environ["DATABASE_URL"], autocommit=True) as connection:
+        connection.execute('DELETE FROM "LiteLLM_SpendLogs" WHERE "user" = %s', (user_id,))
+
+
+@pytest.mark.covers("spend.legacy_spend_logs.row_count_is_capped_at_the_most_recent_rows_and_flagged_truncated")
+def test_legacy_spend_logs_returns_only_the_cap_of_most_recent_rows_and_flags_truncation(gateway: Gateway) -> None:
+    user_id: Final = f"integration-cap-{uuid.uuid4().hex}"
+    with gateway.scenario() as scenario:
+        scenario.cleanups.callback(_delete_spend_rows, user_id)
+        seeded: Final = _seed_spend_rows(user_id, LEGACY_SPEND_LOGS_ROW_CAP + 1)
+        assert read_rows('SELECT count(*)::text AS total FROM "LiteLLM_SpendLogs" WHERE "user" = %s', (user_id,)) == [
+            {"total": str(LEGACY_SPEND_LOGS_ROW_CAP + 1)}
+        ]
+        response: Final = gateway.request("GET", "/spend/logs", params={"user_id": user_id})
+        assert response.status_code == 200, response.text
+        returned: Final = tuple(row["request_id"] for row in response.json())
+        assert len(returned) == LEGACY_SPEND_LOGS_ROW_CAP, f"{len(returned)} rows: {response.text[:300]}"
+        assert returned == tuple(reversed(seeded[1:])), response.text[:300]
+        assert response.headers.get("x-litellm-spend-logs-truncated") == "true", dict(response.headers)
diff --git a/tests/integration/spend/test_messages_stream_usage_cost.py b/tests/integration/spend/test_messages_stream_usage_cost.py
new file mode 100644
index 000000000000..692dd01e0b0d
--- /dev/null
+++ b/tests/integration/spend/test_messages_stream_usage_cost.py
@@ -0,0 +1,176 @@
+import base64
+import json
+import uuid
+from pathlib import Path
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway, eventually
+from integration._support.database import read_rows
+from integration._support.process import owned_proxy
+from integration._support.upstream import _aws_event_frame
+from integration._support.wire import Reply, Request, wire_server
+from pydantic import JsonValue, TypeAdapter
+
+BEDROCK_MODEL: Final = "anthropic.claude-haiku-4-5-20251001-v1:0"
+INPUT_TOKENS: Final = 30
+CACHE_READ_TOKENS: Final = 900
+CACHE_CREATION_TOKENS: Final = 400
+OUTPUT_TOKENS: Final = 57
+INPUT_RATE: Final = 0.001
+OUTPUT_RATE: Final = 0.002
+CACHE_READ_RATE: Final = 0.0001
+CACHE_CREATION_RATE: Final = 0.00125
+STREAMED_USAGE: Final = TypeAdapter(dict[str, float])
+EXPECTED_SPEND: Final = (
+    INPUT_TOKENS * INPUT_RATE
+    + CACHE_READ_TOKENS * CACHE_READ_RATE
+    + CACHE_CREATION_TOKENS * CACHE_CREATION_RATE
+    + OUTPUT_TOKENS * OUTPUT_RATE
+)
+
+
+def _invoke_chunk(payload: dict[str, JsonValue]) -> bytes:
+    encoded: Final = base64.b64encode(json.dumps(payload, separators=(",", ":")).encode()).decode()
+    return _aws_event_frame("chunk", {"bytes": encoded}, "", "")
+
+
+def _stream(message_id: str) -> bytes:
+    return (
+        _invoke_chunk(
+            {
+                "type": "message_start",
+                "message": {
+                    "id": message_id,
+                    "type": "message",
+                    "role": "assistant",
+                    "model": BEDROCK_MODEL,
+                    "content": [],
+                    "stop_reason": None,
+                    "stop_sequence": None,
+                    "usage": {
+                        "input_tokens": INPUT_TOKENS,
+                        "cache_read_input_tokens": CACHE_READ_TOKENS,
+                        "cache_creation_input_tokens": CACHE_CREATION_TOKENS,
+                        "output_tokens": 0,
+                    },
+                },
+            }
+        )
+        + _invoke_chunk({"type": "content_block_start", "index": 0, "content_block": {"type": "text", "text": ""}})
+        + _invoke_chunk(
+            {"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": "cached answer"}}
+        )
+        + _invoke_chunk({"type": "content_block_stop", "index": 0})
+        + _invoke_chunk(
+            {
+                "type": "message_delta",
+                "delta": {"stop_reason": "end_turn"},
+                "usage": {
+                    "input_tokens": INPUT_TOKENS,
+                    "cache_read_input_tokens": CACHE_READ_TOKENS,
+                    "cache_creation_input_tokens": CACHE_CREATION_TOKENS,
+                    "output_tokens": OUTPUT_TOKENS,
+                },
+            }
+        )
+        + _invoke_chunk({"type": "message_stop"})
+    )
+
+
+def _proxy_config(directory: Path, model: str, upstream_url: str) -> Path:
+    config: Final = directory / "streamed_usage_cost_config.yaml"
+    config.write_text(
+        json.dumps(
+            {
+                "model_list": [
+                    {
+                        "model_name": model,
+                        "litellm_params": {
+                            "model": f"bedrock/invoke/{BEDROCK_MODEL}",
+                            "api_base": upstream_url,
+                            "aws_access_key_id": "AKIASCRIPTEDPROVIDER",
+                            "aws_secret_access_key": "scripted-secret",
+                            "aws_region_name": "us-east-1",
+                            "input_cost_per_token": INPUT_RATE,
+                            "output_cost_per_token": OUTPUT_RATE,
+                            "cache_read_input_token_cost": CACHE_READ_RATE,
+                            "cache_creation_input_token_cost": CACHE_CREATION_RATE,
+                        },
+                    }
+                ],
+                "general_settings": {
+                    "master_key": "os.environ/LITELLM_MASTER_KEY",
+                    "database_url": "os.environ/DATABASE_URL",
+                    "store_model_in_db": True,
+                    "disable_spend_logs": False,
+                    "proxy_batch_write_at": 1,
+                    "proxy_batch_polling_interval": 1,
+                },
+                "litellm_settings": {"include_cost_in_streaming_usage": True},
+                "router_settings": {"disable_cooldowns": True},
+            }
+        )
+    )
+    return config
+
+
+def _data_events(body: str) -> tuple[dict[str, JsonValue], ...]:
+    return tuple(json.loads(line.removeprefix("data:")) for line in body.splitlines() if line.startswith("data:"))
+
+
+@pytest.mark.covers("spend.anthropic_messages_stream.streamed_usage_cost_equals_recorded_spend")
+@pytest.mark.timeout(180)
+def test_bedrock_messages_stream_usage_cost_matches_recorded_spend_with_custom_cache_rates(
+    gateway: Gateway, tmp_path: Path
+) -> None:
+    message_id: Final = f"msg_{uuid.uuid4().hex}"
+    model: Final = f"{BEDROCK_MODEL}-{uuid.uuid4().hex}"
+
+    def respond(request: Request) -> Reply:
+        assert request.target == f"/model/{BEDROCK_MODEL}/invoke-with-response-stream", request.target
+        assert json.loads(request.body)["messages"] == [{"role": "user", "content": "cached cost control"}], (
+            request.body
+        )
+        return Reply(content_type="application/vnd.amazon.eventstream", chunks=(_stream(message_id),))
+
+    with wire_server(respond) as wire:
+        config: Final = _proxy_config(tmp_path, model, wire.url)
+        with owned_proxy(gateway, tmp_path, {}, config=config) as candidate:
+            response: Final = candidate.request(
+                "POST",
+                "/v1/messages",
+                {
+                    "model": model,
+                    "messages": [{"role": "user", "content": "cached cost control"}],
+                    "max_tokens": OUTPUT_TOKENS,
+                    "stream": True,
+                },
+            )
+            assert response.status_code == 200, response.text
+            message_delta: Final = next(
+                event for event in _data_events(response.text) if event["type"] == "message_delta"
+            )
+            streamed_usage: Final = STREAMED_USAGE.validate_python(message_delta["usage"])
+            rows: Final = eventually(
+                lambda: read_rows(
+                    'SELECT status, prompt_tokens, completion_tokens, spend FROM "LiteLLM_SpendLogs" '
+                    "WHERE request_id=%s",
+                    (message_id,),
+                ),
+                lambda values: len(values) == 1,
+                seconds=70,
+            )
+        assert rows[0]["status"] == "success", rows
+        assert rows[0]["prompt_tokens"] == INPUT_TOKENS + CACHE_READ_TOKENS + CACHE_CREATION_TOKENS, rows
+        assert rows[0]["completion_tokens"] == OUTPUT_TOKENS, rows
+        recorded_spend: Final = float(str(rows[0]["spend"]))
+        assert recorded_spend == pytest.approx(EXPECTED_SPEND), rows
+        assert streamed_usage == {
+            "input_tokens": INPUT_TOKENS,
+            "cache_read_input_tokens": CACHE_READ_TOKENS,
+            "cache_creation_input_tokens": CACHE_CREATION_TOKENS,
+            "output_tokens": OUTPUT_TOKENS,
+            "cost": pytest.approx(recorded_spend),
+        }, (streamed_usage, rows, response.text)
+        assert len(wire.drain()) == 1
diff --git a/tests/integration/spend/test_reset_budget_leader_election.py b/tests/integration/spend/test_reset_budget_leader_election.py
new file mode 100644
index 000000000000..f9c165a0be04
--- /dev/null
+++ b/tests/integration/spend/test_reset_budget_leader_election.py
@@ -0,0 +1,75 @@
+import json
+import os
+from pathlib import Path
+from types import MappingProxyType
+from typing import Final
+
+import psycopg
+import pytest
+from integration._support.client import Gateway, eventually
+from integration._support.database import read_rows
+from integration._support.process import owned_proxy
+from redis import Redis
+
+RESET_LEASE_KEY: Final = "cronjob_lock:reset_budget_job"
+PEER_POD_LEASE: Final = json.dumps("integration-peer-pod-holding-the-reset-lease")
+FAST_RESET_TICK: Final = MappingProxyType(
+    {"PROXY_BUDGET_RESCHEDULER_MIN_TIME": "2", "PROXY_BUDGET_RESCHEDULER_MAX_TIME": "2"}
+)
+
+
+def _team_spend(team: str) -> float:
+    rows: Final = read_rows('SELECT spend FROM "LiteLLM_TeamTable" WHERE team_id = %s', (team,))
+    assert len(rows) == 1, rows
+    spend: Final = rows[0]["spend"]
+    assert isinstance(spend, (int, float)), rows
+    return float(spend)
+
+
+def _make_team_budget_due(team: str, spend: float) -> None:
+    with psycopg.connect(os.environ["DATABASE_URL"]) as connection:
+        connection.execute(
+            "UPDATE \"LiteLLM_TeamTable\" SET spend = %s, budget_reset_at = now() - interval '1 day' "
+            "WHERE team_id = %s",
+            (spend, team),
+        )
+
+
+@pytest.mark.covers("spend.budget_reset.one_pod_sweeps_per_tick")
+def test_reset_sweep_skips_ticks_while_another_pod_holds_the_lease_and_resumes_after_release(
+    gateway: Gateway, tmp_path: Path
+) -> None:
+    with (
+        gateway.scenario() as scenario,
+        Redis(host=os.environ["REDIS_HOST"], port=int(os.environ["REDIS_PORT"])) as cache,
+    ):
+        model: Final = scenario.model(input_cost_per_token=0.0, output_cost_per_token=0.0)
+        team: Final = scenario.team(max_budget=1.0, budget_duration="30d")
+        key: Final = scenario.key(team_id=team)
+        _make_team_budget_due(team, spend=0.5)
+        assert _team_spend(team) == 0.5
+        eventually(
+            lambda: cache.set(RESET_LEASE_KEY, PEER_POD_LEASE, ex=120, nx=True),
+            lambda claimed: claimed is True,
+            seconds=60,
+        )
+        try:
+            with owned_proxy(gateway, tmp_path, FAST_RESET_TICK) as replica:
+                response: Final = replica.request(
+                    "POST",
+                    "/v1/chat/completions",
+                    {"model": model, "messages": [{"role": "user", "content": "classification request"}]},
+                    key=key,
+                )
+                assert response.status_code == 200, response.text
+                held: Final = eventually(
+                    lambda: _team_spend(team), lambda spend: spend != 0.5, seconds=8, return_last_on_timeout=True
+                )
+                assert held == 0.5, f"team {team} was swept while another pod held the reset lease: spend={held}"
+                assert cache.get(RESET_LEASE_KEY) == PEER_POD_LEASE.encode()
+                cache.delete(RESET_LEASE_KEY)
+                swept: Final = eventually(lambda: _team_spend(team), lambda spend: spend == 0.0, seconds=15)
+                assert swept == 0.0
+                eventually(lambda: cache.get(RESET_LEASE_KEY), lambda value: value is None, seconds=15)
+        finally:
+            cache.delete(RESET_LEASE_KEY)
diff --git a/tests/integration/spend/test_responses_cache_write_itemization.py b/tests/integration/spend/test_responses_cache_write_itemization.py
new file mode 100644
index 000000000000..19d73b0aacf2
--- /dev/null
+++ b/tests/integration/spend/test_responses_cache_write_itemization.py
@@ -0,0 +1,98 @@
+import json
+import uuid
+from typing import Final
+
+import pytest
+
+from tests.integration._support.client import Gateway, eventually, object_value, string_value
+from tests.integration._support.database import read_rows
+from tests.integration._support.upstream import delete_scenario, register_scenario
+from tests.integration.cost_calculation.cost_tracking_case import JsonResponse
+
+INPUT_RATE: Final = 0.001
+OUTPUT_RATE: Final = 0.002
+CACHE_CREATION_RATE: Final = 0.004
+CACHE_READ_RATE: Final = 0.0001
+UNCACHED_INPUT_TOKENS: Final = 1000
+CACHE_WRITE_TOKENS: Final = 2000
+CACHED_TOKENS: Final = 8000
+INPUT_TOKENS: Final = UNCACHED_INPUT_TOKENS + CACHE_WRITE_TOKENS + CACHED_TOKENS
+OUTPUT_TOKENS: Final = 500
+
+
+def responses_cache_write_response() -> JsonResponse:
+    return JsonResponse(
+        content_type="application/json",
+        body={
+            "id": "resp_$REQUEST_ID",
+            "object": "response",
+            "created_at": 1700000000,
+            "status": "completed",
+            "model": "gpt-5.6",
+            "output": [
+                {
+                    "type": "message",
+                    "id": "msg_$REQUEST_ID",
+                    "status": "completed",
+                    "role": "assistant",
+                    "content": [{"type": "output_text", "text": "scripted response", "annotations": []}],
+                }
+            ],
+            "usage": {
+                "input_tokens": INPUT_TOKENS,
+                "output_tokens": OUTPUT_TOKENS,
+                "total_tokens": INPUT_TOKENS + OUTPUT_TOKENS,
+                "input_tokens_details": {
+                    "cached_tokens": CACHED_TOKENS,
+                    "cache_write_tokens": CACHE_WRITE_TOKENS,
+                },
+                "output_tokens_details": {"reasoning_tokens": 0},
+            },
+        },
+    )
+
+
+@pytest.mark.covers("spend.responses_api.cache_write_tokens_itemized_as_cache_creation_cost")
+def test_responses_cache_write_tokens_are_itemized_as_cache_creation_cost(gateway: Gateway) -> None:
+    with gateway.scenario() as scenario:
+        scenario_id: Final = f"responses-cache-write-{uuid.uuid4().hex[:12]}"
+        handle: Final = register_scenario(scenario_id, responses_cache_write_response())
+        scenario.cleanups.callback(delete_scenario, handle)
+        model: Final = scenario.model(
+            model="openai/gpt-5.6",
+            api_base=handle.api_base(),
+            input_cost_per_token=INPUT_RATE,
+            output_cost_per_token=OUTPUT_RATE,
+            cache_creation_input_token_cost=CACHE_CREATION_RATE,
+            cache_read_input_token_cost=CACHE_READ_RATE,
+        )
+        response: Final = gateway.request("POST", "/v1/responses", {"model": model, "input": "cache write control"})
+        assert response.status_code == 200, response.text
+        expected_cache_creation_cost: Final = CACHE_WRITE_TOKENS * CACHE_CREATION_RATE
+        expected_cache_read_cost: Final = CACHED_TOKENS * CACHE_READ_RATE
+        expected_input_cost: Final = (
+            UNCACHED_INPUT_TOKENS * INPUT_RATE + expected_cache_creation_cost + expected_cache_read_cost
+        )
+        expected_output_cost: Final = OUTPUT_TOKENS * OUTPUT_RATE
+        request_id: Final = string_value(object_value(response.json())["id"])
+        rows: Final = eventually(
+            lambda: read_rows(
+                'SELECT spend, metadata, prompt_tokens, completion_tokens FROM "LiteLLM_SpendLogs" '
+                "WHERE request_id = %s",
+                (request_id,),
+            ),
+            lambda values: len(values) == 1,
+            seconds=70,
+        )
+        assert rows[0]["prompt_tokens"] == INPUT_TOKENS, response.text
+        assert rows[0]["completion_tokens"] == OUTPUT_TOKENS, response.text
+        assert float(rows[0]["spend"]) == pytest.approx(expected_input_cost + expected_output_cost, rel=1e-6), (
+            response.text
+        )
+        metadata: Final = rows[0]["metadata"]
+        parsed: Final = json.loads(metadata) if isinstance(metadata, str) else object_value(metadata)
+        breakdown: Final = object_value(parsed["cost_breakdown"])
+        assert breakdown.get("cache_creation_cost") == pytest.approx(expected_cache_creation_cost, rel=1e-6), breakdown
+        assert breakdown.get("cache_read_cost") == pytest.approx(expected_cache_read_cost, rel=1e-6), breakdown
+        assert float(breakdown["input_cost"]) == pytest.approx(expected_input_cost, rel=1e-6), breakdown
+        assert float(breakdown["output_cost"]) == pytest.approx(expected_output_cost, rel=1e-6), breakdown
diff --git a/tests/integration/spend/test_session_total_spend.py b/tests/integration/spend/test_session_total_spend.py
new file mode 100644
index 000000000000..54df0c03d816
--- /dev/null
+++ b/tests/integration/spend/test_session_total_spend.py
@@ -0,0 +1,98 @@
+import json
+import uuid
+from datetime import datetime, timedelta, timezone
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway, eventually
+from integration._support.database import read_rows
+from integration._support.wire import Reply, Request, wire_server
+
+INPUT_COST_PER_TOKEN: Final = 0.001
+OUTPUT_COST_PER_TOKEN: Final = 0.002
+ROUND_USAGE: Final = ((10, 5), (20, 10), (30, 15))
+ROUND_SPEND: Final = tuple(
+    prompt * INPUT_COST_PER_TOKEN + completion * OUTPUT_COST_PER_TOKEN for prompt, completion in ROUND_USAGE
+)
+SESSION_SPEND: Final = sum(ROUND_SPEND)
+
+
+def _round_reply(request: Request, prompt: str, usage: tuple[int, int]) -> Reply:
+    assert request.method == "POST" and request.target == "/chat/completions", request.target
+    assert json.loads(request.body) == {
+        "model": "gpt-4o-mini",
+        "messages": [{"role": "user", "content": prompt}],
+    }, request.body
+    return Reply(
+        body=json.dumps(
+            {
+                "id": "chatcmpl-" + uuid.uuid4().hex,
+                "object": "chat.completion",
+                "created": 1,
+                "model": "gpt-4o-mini",
+                "choices": [
+                    {"index": 0, "message": {"role": "assistant", "content": "round answer"}, "finish_reason": "stop"}
+                ],
+                "usage": {"prompt_tokens": usage[0], "completion_tokens": usage[1], "total_tokens": sum(usage)},
+            }
+        ).encode()
+    )
+
+
+@pytest.mark.covers("spend.logs_ui.multi_round_session_total_spend_sums_every_round")
+def test_logs_ui_session_total_spend_sums_every_round_of_a_multi_round_session(gateway: Gateway) -> None:
+    session_id: Final = f"session-{uuid.uuid4().hex}"
+    prompts: Final = tuple(f"round-{index}-{uuid.uuid4().hex}" for index in range(len(ROUND_USAGE)))
+    usage_by_prompt: Final = dict(zip(prompts, ROUND_USAGE, strict=True))
+
+    def provider(request: Request) -> Reply:
+        prompt: Final = str(json.loads(request.body)["messages"][0]["content"])
+        return _round_reply(request, prompt, usage_by_prompt[prompt])
+
+    with wire_server(provider) as wire, gateway.scenario() as scenario:
+        alias: Final = scenario.model(
+            api_base=wire.url,
+            input_cost_per_token=INPUT_COST_PER_TOKEN,
+            output_cost_per_token=OUTPUT_COST_PER_TOKEN,
+            num_retries=0,
+        )
+        request_ids: Final = tuple(_completed_round(gateway, alias, session_id, prompt) for prompt in prompts)
+        assert len(wire.drain()) == len(ROUND_USAGE)
+        rows: Final = eventually(
+            lambda: read_rows(
+                'SELECT request_id, spend FROM "LiteLLM_SpendLogs" WHERE session_id=%s ORDER BY "startTime"',
+                (session_id,),
+            ),
+            lambda values: len(values) == len(ROUND_USAGE),
+            seconds=70,
+        )
+        assert [row["request_id"] for row in rows] == list(request_ids), rows
+        assert [float(row["spend"]) for row in rows] == pytest.approx(list(ROUND_SPEND)), rows
+        now: Final = datetime.now(timezone.utc)
+        logs: Final = gateway.request(
+            "GET",
+            "/spend/logs/ui",
+            params={
+                "session_id": session_id,
+                "start_date": (now - timedelta(days=1)).strftime("%Y-%m-%d %H:%M:%S"),
+                "end_date": (now + timedelta(days=1)).strftime("%Y-%m-%d %H:%M:%S"),
+            },
+        )
+        assert logs.status_code == 200, logs.text
+        page: Final = logs.json()
+        assert page["total"] == len(ROUND_USAGE), logs.text
+        assert sorted(row["request_id"] for row in page["data"]) == sorted(request_ids), logs.text
+        assert [row["session_total_count"] for row in page["data"]] == [len(ROUND_USAGE)] * len(ROUND_USAGE), logs.text
+        assert [row["session_total_spend"] for row in page["data"]] == pytest.approx(
+            [SESSION_SPEND] * len(ROUND_USAGE)
+        ), logs.text
+
+
+def _completed_round(gateway: Gateway, alias: str, session_id: str, prompt: str) -> str:
+    response: Final = gateway.request(
+        "POST",
+        "/v1/chat/completions",
+        {"model": alias, "messages": [{"role": "user", "content": prompt}], "litellm_trace_id": session_id},
+    )
+    assert response.status_code == 200, response.text
+    return str(response.json()["id"])
diff --git a/tests/integration/spend/test_spend_log_write_batching.py b/tests/integration/spend/test_spend_log_write_batching.py
new file mode 100644
index 000000000000..386f99b1d075
--- /dev/null
+++ b/tests/integration/spend/test_spend_log_write_batching.py
@@ -0,0 +1,75 @@
+import uuid
+from pathlib import Path
+from typing import Final
+
+import pytest
+import yaml
+from integration._support.client import Gateway, eventually, string_value
+from integration._support.database import read_rows
+from integration._support.process import owned_proxy
+from pydantic import JsonValue
+
+WRITE_STATEMENT_MAX_BYTES: Final = 200_000
+MESSAGES_PER_REQUEST: Final = 60
+MESSAGE_CHARACTERS: Final = 2_000
+REQUESTS: Final = 4
+
+
+def _config_storing_prompts(tmp_path: Path) -> Path:
+    config: Final = yaml.safe_load(Path("tests/integration/proxy_config.yaml").read_text())
+    config["general_settings"]["store_prompts_in_spend_logs"] = True
+    path: Final = tmp_path / "store-prompts.yaml"
+    path.write_text(yaml.safe_dump(config))
+    return path
+
+
+def _prompt_messages(marker: str) -> list[JsonValue]:
+    return [
+        {"role": "user", "content": f"{marker}-{index}-".ljust(MESSAGE_CHARACTERS, "x")}
+        for index in range(MESSAGES_PER_REQUEST)
+    ]
+
+
+def _persisted(request_ids: tuple[str, ...]) -> list[dict[str, JsonValue]]:
+    placeholders: Final = ", ".join("%s" for _ in request_ids)
+    return read_rows(
+        "SELECT request_id, xmin::text AS statement, octet_length(proxy_server_request::text) AS stored_bytes "
+        f'FROM "LiteLLM_SpendLogs" WHERE request_id IN ({placeholders}) ORDER BY request_id',
+        request_ids,
+    )
+
+
+@pytest.mark.covers("quota_management.spend_tracking.prompt_rows_are_written_in_byte_bounded_statements")
+def test_prompt_carrying_spend_rows_flushed_together_are_written_in_byte_bounded_statements(
+    gateway: Gateway, tmp_path: Path
+) -> None:
+    with (
+        gateway.scenario() as scenario,
+        owned_proxy(
+            gateway,
+            tmp_path,
+            {
+                "SPEND_LOG_WRITE_BATCH_MAX_BYTES": str(WRITE_STATEMENT_MAX_BYTES),
+                "SPEND_LOG_QUEUE_POLL_INTERVAL": "15",
+            },
+            config=_config_storing_prompts(tmp_path),
+        ) as owned,
+    ):
+        model: Final = scenario.model()
+        request_ids: Final = tuple(
+            string_value(
+                owned.post(
+                    "/v1/chat/completions",
+                    {"model": model, "messages": _prompt_messages(f"integration-prompt-{uuid.uuid4().hex}")},
+                )["id"]
+            )
+            for _ in range(REQUESTS)
+        )
+        assert len(set(request_ids)) == REQUESTS, request_ids
+        rows: Final = eventually(lambda: _persisted(request_ids), lambda values: len(values) == REQUESTS, seconds=70)
+    stored_bytes: Final = tuple(row["stored_bytes"] for row in rows)
+    assert all(
+        isinstance(size, int) and WRITE_STATEMENT_MAX_BYTES // 2 < size < WRITE_STATEMENT_MAX_BYTES
+        for size in stored_bytes
+    ), rows
+    assert len({row["statement"] for row in rows}) == REQUESTS, rows
diff --git a/tests/integration/spend/test_team_member_spend.py b/tests/integration/spend/test_team_member_spend.py
index 89eb2a24bcf1..cf1dac25793f 100644
--- a/tests/integration/spend/test_team_member_spend.py
+++ b/tests/integration/spend/test_team_member_spend.py
@@ -1,9 +1,12 @@
+import os
 import uuid
 from typing import Final
 
+import httpx
 import pytest
 from integration._support.client import Gateway, eventually, object_value
 from integration._support.database import read_rows
+from redis import Redis
 
 
 @pytest.mark.covers("spend.team_member.member_without_budget_gets_membership_row_and_spend")
@@ -52,3 +55,45 @@ def test_member_added_without_any_budget_is_charged_on_its_membership_row(gatewa
             if object_value(row)["user_id"] == user
         ]
         assert len(exposed) == 1 and exposed[0][1] == pytest.approx(0.06), info
+
+
+@pytest.mark.covers("spend.team_member.stale_low_redis_counter_still_blocks_member_over_budget")
+def test_member_over_budget_is_blocked_when_redis_counter_reads_stale_low(gateway: Gateway) -> None:
+    with (
+        gateway.scenario() as scenario,
+        httpx.Client(base_url=gateway.upstream_url, timeout=5, trust_env=False) as upstream,
+        Redis(host=os.environ["REDIS_HOST"], port=int(os.environ["REDIS_PORT"])) as cache,
+    ):
+        model: Final = scenario.model(input_cost_per_token=0.001, output_cost_per_token=0.002)
+        team: Final = scenario.team(models=[model])
+        user: Final = scenario.user()
+        added: Final = gateway.request(
+            "POST",
+            "/team/member_add",
+            {"team_id": team, "member": {"user_id": user, "role": "user"}, "max_budget_in_team": 0.05},
+        )
+        assert added.status_code == 200, added.text
+        key: Final = scenario.key(team_id=team, user_id=user, models=[model])
+        assert gateway.chat(model, key=key, text=f"member budget {uuid.uuid4().hex}")["usage"]["total_tokens"] == 40
+        charged: Final = eventually(
+            lambda: read_rows(
+                'SELECT spend FROM "LiteLLM_TeamMembership" WHERE team_id=%s AND user_id=%s', (team, user)
+            ),
+            lambda values: len(values) == 1 and float(values[0]["spend"]) >= 0.06,
+            seconds=70,
+        )
+        assert float(charged[0]["spend"]) == pytest.approx(0.06)
+        counter_key: Final = f"spend:team_member:{user}:{team}"
+        counted: Final = eventually(lambda: cache.get(counter_key), lambda value: value is not None, seconds=10)
+        assert float(counted) == pytest.approx(0.06), counted
+        cache.set(counter_key, "0.01")
+        upstream.get("/__observations").raise_for_status()
+        denied: Final = gateway.request(
+            "POST",
+            "/v1/chat/completions",
+            {"model": model, "messages": [{"role": "user", "content": f"stale counter {uuid.uuid4().hex}"}]},
+            key=key,
+        )
+        assert denied.status_code == 422 and denied.json()["error"]["type"] == "budget_exceeded", denied.text
+        assert upstream.get("/__observations").json()["requests"] == []
+        assert float(cache.get(counter_key)) == pytest.approx(0.06), denied.text
diff --git a/tests/integration/spend/test_user_budget_on_team_keys.py b/tests/integration/spend/test_user_budget_on_team_keys.py
new file mode 100644
index 000000000000..f8e0eea34549
--- /dev/null
+++ b/tests/integration/spend/test_user_budget_on_team_keys.py
@@ -0,0 +1,54 @@
+import uuid
+from hashlib import sha256
+from pathlib import Path
+from typing import Final
+
+import httpx
+import pytest
+import yaml
+from integration._support.client import Gateway, eventually
+from integration._support.database import read_rows
+from integration._support.process import owned_proxy
+
+
+@pytest.mark.covers("spend.user_budget.opted_in_team_key_is_denied_once_owner_budget_is_exhausted")
+def test_team_key_is_denied_before_provider_once_owner_personal_budget_is_exhausted_when_opted_in(
+    gateway: Gateway, tmp_path: Path
+) -> None:
+    configuration: Final = yaml.safe_load(Path("tests/integration/proxy_config.yaml").read_text())
+    configuration["general_settings"]["apply_user_budget_to_team_keys"] = True
+    path: Final = tmp_path / "apply-user-budget-to-team-keys.yaml"
+    path.write_text(yaml.safe_dump(configuration))
+    with (
+        owned_proxy(gateway, tmp_path, {}, config=path) as candidate,
+        candidate.scenario() as scenario,
+        httpx.Client(base_url=candidate.upstream_url, timeout=5, trust_env=False) as upstream,
+    ):
+        model: Final = scenario.model(input_cost_per_token=0.001, output_cost_per_token=0.002)
+        user: Final = scenario.user(max_budget=0.06)
+        team: Final = scenario.team(models=[model])
+        added: Final = candidate.request(
+            "POST", "/team/member_add", {"team_id": team, "member": {"user_id": user, "role": "user"}}
+        )
+        assert added.status_code == 200, added.text
+        key: Final = scenario.key(team_id=team, user_id=user, models=[model])
+        first: Final = candidate.chat(model, key=key, text=f"owner budget {uuid.uuid4().hex}")
+        assert first["usage"]["total_tokens"] == 40
+        spent: Final = eventually(
+            lambda: read_rows('SELECT spend FROM "LiteLLM_UserTable" WHERE user_id=%s', (user,)),
+            lambda values: len(values) == 1 and float(values[0]["spend"]) >= 0.06,
+            seconds=70,
+        )
+        assert float(spent[0]["spend"]) == pytest.approx(0.06)
+        assert read_rows(
+            'SELECT max_budget FROM "LiteLLM_VerificationToken" WHERE token=%s', (sha256(key.encode()).hexdigest(),)
+        ) == [{"max_budget": None}]
+        upstream.get("/__observations").raise_for_status()
+        denied: Final = candidate.request(
+            "POST",
+            "/v1/chat/completions",
+            {"model": model, "messages": [{"role": "user", "content": f"over owner budget {uuid.uuid4().hex}"}]},
+            key=key,
+        )
+        assert denied.status_code == 422 and denied.json()["error"]["type"] == "budget_exceeded", denied.text
+        assert upstream.get("/__observations").json()["requests"] == []
diff --git a/tests/integration/streaming/test_file_content_streaming.py b/tests/integration/streaming/test_file_content_streaming.py
new file mode 100644
index 000000000000..9ec7665307ba
--- /dev/null
+++ b/tests/integration/streaming/test_file_content_streaming.py
@@ -0,0 +1,48 @@
+import threading
+import uuid
+from collections.abc import Callable
+from typing import Final
+
+import pytest
+from integration._support.client import Gateway
+from integration._support.wire import Reply, Request, wire_server
+
+STREAM_CHUNK_BYTES: Final = 1024 * 1024
+HEAD: Final = b"h" * STREAM_CHUNK_BYTES
+TAIL: Final = b'{"custom_id": "tail", "response": {"status_code": 200}}\n'
+
+
+def _file_content_gated_after_head(gate: threading.Event) -> Callable[[Request], Reply]:
+    def respond(_request: Request) -> Reply:
+        return Reply(content_type="application/octet-stream", chunks=(HEAD, TAIL), gate_after_first=gate)
+
+    return respond
+
+
+@pytest.mark.covers("streaming.file_content.body_reaches_client_before_upstream_finishes_sending")
+def test_file_content_streams_the_first_megabyte_to_the_client_before_the_upstream_sends_the_rest(
+    gateway: Gateway,
+) -> None:
+    file_id: Final = "file-" + uuid.uuid4().hex
+    gate: Final = threading.Event()
+    with gateway.scenario() as scenario, wire_server(_file_content_gated_after_head(gate)) as wire:
+        model: Final = scenario.model(api_base=wire.url + "/v1")
+        with gateway.client.stream(
+            "GET",
+            f"/v1/files/{file_id}/content",
+            params={"model": model},
+            headers={"Authorization": f"Bearer {gateway.key}"},
+        ) as response:
+            assert response.status_code == 200, response.read().decode()
+            chunks: Final = response.iter_bytes(chunk_size=STREAM_CHUNK_BYTES)
+            head: Final = next(chunks)
+            assert head == HEAD, f"First {len(head)} bytes differ from the upstream head before the gate was released"
+            gate.set()
+            rest: Final = b"".join(chunks)
+        assert rest == TAIL, rest
+        requests: Final = wire.drain()
+        assert len(requests) == 1, requests
+        assert requests[0].method == "GET", requests[0]
+        assert requests[0].target == f"/v1/files/{file_id}/content", requests[0].target
+        assert requests[0].headers["authorization"] == "Bearer integration-provider-key", requests[0].headers
+        assert requests[0].body == b"", requests[0].body
diff --git a/tests/integration/streaming/test_stream_contracts.py b/tests/integration/streaming/test_stream_contracts.py
index 7466a9454b85..bd89b869ef29 100644
--- a/tests/integration/streaming/test_stream_contracts.py
+++ b/tests/integration/streaming/test_stream_contracts.py
@@ -261,6 +261,87 @@ def test_messages_stream_completes_through_trailing_empty_choices_usage_chunk(ga
     )
 
 
+def reasoning_first_stream(identity: str) -> tuple[bytes, ...]:
+    usage: Final = {
+        "id": identity,
+        "object": "chat.completion.chunk",
+        "created": 1,
+        "model": "gpt-4o-mini",
+        "choices": [],
+        "usage": {"prompt_tokens": 11, "completion_tokens": 6, "total_tokens": 17},
+    }
+    return (
+        frame(identity, {"role": "assistant", "content": None, "reasoning_content": "Let me "}),
+        frame(identity, {"content": None, "reasoning_content": "think."}),
+        frame(identity, {"content": "Hello "}),
+        frame(identity, {"content": "there"}),
+        frame(identity, {}, finish="stop"),
+        b"data: " + json.dumps(usage).encode() + b"\n\n",
+        b"data: [DONE]\n\n",
+    )
+
+
+@pytest.mark.covers("streaming.messages_bridge.reasoning_content_only_chunks_open_a_thinking_block_first")
+def test_messages_stream_opens_thinking_block_at_index_zero_for_reasoning_content_only_chunks(
+    gateway: Gateway,
+) -> None:
+    identity: Final = "messages-reasoning-first-" + uuid.uuid4().hex
+    with (
+        wire_server(
+            lambda request: Reply(content_type="text/event-stream", chunks=reasoning_first_stream(identity))
+        ) as wire,
+        gateway.scenario() as scenario,
+    ):
+        model: Final = scenario.model(model="hosted_vllm/reasoning-model", api_base=wire.url + "/v1")
+        with gateway.client.stream(
+            "POST",
+            "/v1/messages",
+            json={
+                "model": model,
+                "max_tokens": 64,
+                "stream": True,
+                "messages": [{"role": "user", "content": identity}],
+            },
+            headers={"Authorization": f"Bearer {gateway.key}"},
+        ) as response:
+            text: Final = response.read().decode()
+    assert response.status_code == 200, text
+    assert response.headers["content-type"].startswith("text/event-stream"), text
+    events: Final = tuple(json.loads(line) for line in sse_data_lines(text))
+    blocks: Final = tuple(
+        (event["index"], event.get("content_block") or event["delta"])
+        for event in events
+        if event["type"] in ("content_block_start", "content_block_delta")
+    )
+    assert blocks == (
+        (0, {"type": "thinking", "thinking": "", "signature": ""}),
+        (0, {"type": "thinking_delta", "thinking": "Let me "}),
+        (0, {"type": "thinking_delta", "thinking": "think."}),
+        (1, {"type": "text", "text": ""}),
+        (1, {"type": "text_delta", "text": "Hello "}),
+        (1, {"type": "text_delta", "text": "there"}),
+    ), text
+    assert tuple(event["type"] for event in events) == (
+        "message_start",
+        "content_block_start",
+        "content_block_delta",
+        "content_block_delta",
+        "content_block_stop",
+        "content_block_start",
+        "content_block_delta",
+        "content_block_delta",
+        "content_block_stop",
+        "message_delta",
+        "message_stop",
+    ), text
+    message_delta: Final = next(event for event in events if event["type"] == "message_delta")
+    assert message_delta["usage"] == {"input_tokens": 11, "output_tokens": 6}, text
+    requests: Final = wire.drain()
+    assert len(requests) == 1
+    outbound: Final = json.loads(requests[0].body)
+    assert outbound["stream"] is True and outbound["messages"] == [{"role": "user", "content": identity}], outbound
+
+
 @pytest.mark.covers("other.streaming.responses_bridge.empty_choices_chunks_complete_stream")
 def test_responses_stream_completes_through_empty_choices_metadata_and_usage_chunks(gateway: Gateway) -> None:
     identity: Final = "responses-empty-choices-" + uuid.uuid4().hex
@@ -445,9 +526,7 @@ def test_primary_stream_with_empty_first_chunk_then_disconnect_falls_back_and_bi
                 abort_after=2,
             )
         ) as primary,
-        wire_server(
-            lambda request: Reply(content_type="text/event-stream", chunks=text_stream(identity))
-        ) as fallback,
+        wire_server(lambda request: Reply(content_type="text/event-stream", chunks=text_stream(identity))) as fallback,
     ):
         config: Final = yaml.safe_load(Path("tests/integration/proxy_config.yaml").read_text())
         config["model_list"] = [
diff --git a/tests/test_litellm/experimental_mcp_client/test_mcp_client.py b/tests/test_litellm/experimental_mcp_client/test_mcp_client.py
index b260d240f291..ae30b086c6e5 100644
--- a/tests/test_litellm/experimental_mcp_client/test_mcp_client.py
+++ b/tests/test_litellm/experimental_mcp_client/test_mcp_client.py
@@ -1890,8 +1890,9 @@ async def test_transport_completion_and_normal_messages(transport: MCPTransport,
     from litellm.proxy._experimental.mcp_server.rest_endpoints import _connection_error_message
 
     logging_callback: Final = AsyncMock()
+    read_timeout: Final = 0.2 if mode == "silent" else 30
     client: Final = MCPClient(
-        server_url="https://example.com/sse", transport_type=transport, timeout=0.2, logging_callback=logging_callback
+        server_url="https://example.com/sse", transport_type=transport, timeout=read_timeout, logging_callback=logging_callback
     )
 
     async def operation(session: ClientSession) -> CallToolResult:
@@ -1909,7 +1910,7 @@ async def operation(session: ClientSession) -> CallToolResult:
         with pytest.raises(MCPError) as caught:
             await asyncio.wait_for(pending, timeout=3)
         if mode == "closed":
-            assert "connection was closed" in _connection_error_message(caught.value, client.server_url, 0.2)
+            assert "connection was closed" in _connection_error_message(caught.value, client.server_url, read_timeout)
         else:
             assert isinstance(as_mcp_read_timeout(caught.value), TimeoutError)
 
diff --git a/tests/test_litellm/litellm_core_utils/llm_cost_calc/test_llm_cost_calc_utils.py b/tests/test_litellm/litellm_core_utils/llm_cost_calc/test_llm_cost_calc_utils.py
index 76ccdec25d05..781a3a7c4ed9 100644
--- a/tests/test_litellm/litellm_core_utils/llm_cost_calc/test_llm_cost_calc_utils.py
+++ b/tests/test_litellm/litellm_core_utils/llm_cost_calc/test_llm_cost_calc_utils.py
@@ -3761,3 +3761,31 @@ def test_get_batch_cost_rates_has_no_cache_write_rate_without_a_cache_write_batc
     )
 
     assert rates.cache_creation is None
+
+
+@pytest.mark.parametrize("model_base", ["gpt-6-sol", "gpt-6-luna"])
+def test_azure_gpt_6_foundry_price_sheet(_local_model_cost_map, model_base):
+    """Azure Foundry hosts gpt-6-sol and gpt-6-luna at OpenAI's Global rates, with the
+    US and EU data zones charging fixed uplifts on top of them."""
+    price_fields = (
+        "input_cost_per_token",
+        "cache_read_input_token_cost",
+        "cache_creation_input_token_cost",
+        "output_cost_per_token",
+        "input_cost_per_token_above_272k_tokens",
+        "cache_read_input_token_cost_above_272k_tokens",
+        "cache_creation_input_token_cost_above_272k_tokens",
+        "output_cost_per_token_above_272k_tokens",
+    )
+    openai_info = litellm.get_model_info(model=model_base, custom_llm_provider="openai")
+    azure_info = litellm.get_model_info(model=f"azure/{model_base}", custom_llm_provider="azure")
+    azure_us_info = litellm.get_model_info(model=f"azure/us/{model_base}", custom_llm_provider="azure")
+    azure_eu_info = litellm.get_model_info(model=f"azure/eu/{model_base}", custom_llm_provider="azure")
+    azure_ai_info = litellm.get_model_info(model=f"azure_ai/{model_base}", custom_llm_provider="azure_ai")
+
+    for field in price_fields:
+        base = openai_info[field]
+        assert azure_info[field] == base
+        assert azure_ai_info[field] == base
+        assert azure_us_info[field] == pytest.approx(1.1 * base)
+        assert azure_eu_info[field] == pytest.approx(1.2 * base)
diff --git a/tests/test_litellm/litellm_core_utils/test_get_litellm_params.py b/tests/test_litellm/litellm_core_utils/test_get_litellm_params.py
index 7fb45e1b092f..39bc2688ae02 100644
--- a/tests/test_litellm/litellm_core_utils/test_get_litellm_params.py
+++ b/tests/test_litellm/litellm_core_utils/test_get_litellm_params.py
@@ -90,6 +90,10 @@ def test_s3_endpoint_kwargs_are_extracted_when_provided(self):
         assert "s3_endpoint_url" not in result_without_s3_kwargs
         assert "s3_region_name" not in result_without_s3_kwargs
 
+    def test_stream_chunk_size_is_carried_as_a_litellm_param(self) -> None:
+        assert get_litellm_params(stream_chunk_size=64)["stream_chunk_size"] == 64
+        assert get_litellm_params()["stream_chunk_size"] is None
+
     def test_s3_credential_kwargs_are_forwarded_for_s3_signing(self):
         result = get_litellm_params(s3_access_key_id="s3-key", s3_secret_access_key="s3-secret")
         assert result["s3_access_key_id"] == "s3-key"
@@ -265,5 +269,7 @@ def test_litellm_metadata_fallback_is_copied_not_aliased(self):
     "value, expected",
     [("true", True), ("false", False), (" TRUE ", True), (True, True), (None, None), ("os.environ/DROP_PARAMS", None)],
 )
-def test_drop_params_strings_reach_litellm_params_as_flags(value, expected):
+def test_drop_params_strings_reach_litellm_params_as_flags(
+    value: str | bool | None, expected: bool | None
+) -> None:
     assert get_litellm_params(drop_params=value)["drop_params"] is expected
diff --git a/tests/test_litellm/proxy/client/cli/autoroute/test_wizard.py b/tests/test_litellm/proxy/client/cli/autoroute/test_wizard.py
index fc6de53cb9ee..c0e5377b1708 100644
--- a/tests/test_litellm/proxy/client/cli/autoroute/test_wizard.py
+++ b/tests/test_litellm/proxy/client/cli/autoroute/test_wizard.py
@@ -1,4 +1,6 @@
 import asyncio
+import contextlib
+import contextvars
 from typing import Any, Dict, List, Optional, Tuple
 from unittest.mock import patch
 
@@ -288,9 +290,12 @@ def _highlighted_choice(session: AppSession) -> Optional[str]:
     if session.app is None:
         return None
     controls = [c for c in session.app.layout.find_all_controls() if isinstance(c, InquirerPyFuzzyControl)]
-    if not controls or controls[0].choice_count == 0:
+    if not controls:
+        return None
+    try:
+        return controls[0].selection["name"]
+    except IndexError:
         return None
-    return controls[0].selection["name"]
 
 
 async def _wait_until_highlighted(session: AppSession, name: str) -> None:
@@ -309,21 +314,35 @@ def _drive_fuzzy_pick(
 ) -> List[str]:
     """Drives the real InquirerPy fuzzy prompt through prompt_toolkit's own test input/output,
     exercising the actual widget (filtering, tab-to-toggle, enter-to-confirm) rather than mocking
-    it away. asyncio.to_thread propagates the create_app_session context into the worker thread
-    running _fuzzy_pick's synchronous .execute() call. Each key event names the choice the widget
-    must highlight before the next key is sent (None sends the next key immediately)."""
+    it away. The worker thread running _fuzzy_pick's synchronous .execute() call inherits the
+    create_app_session context. Each key event names the choice the widget must highlight before
+    the next key is sent (None sends the next key immediately). The widget swaps its filtered list
+    before it clamps the highlight index on the next redraw, so the poller only reads a name once
+    the index is in range. If driving the widget fails, ctrl-c ends the prompt so the worker thread
+    exits and the failure surfaces instead of hanging the event loop shutdown."""
 
     async def _run() -> List[str]:
         with create_pipe_input() as pipe_input:
             with create_app_session(input=pipe_input, output=DummyOutput()) as session:
-                task = asyncio.ensure_future(
-                    asyncio.to_thread(wizard_module._fuzzy_pick, models, prompt_label, multiselect)
+                prompt = asyncio.get_running_loop().run_in_executor(
+                    None,
+                    contextvars.copy_context().run,
+                    wizard_module._fuzzy_pick,
+                    models,
+                    prompt_label,
+                    multiselect,
                 )
-                for text, highlighted in key_events:
-                    pipe_input.send_text(text)
-                    if highlighted is not None:
-                        await _wait_until_highlighted(session, highlighted)
-                return await task
+                try:
+                    for text, highlighted in key_events:
+                        pipe_input.send_text(text)
+                        if highlighted is not None:
+                            await _wait_until_highlighted(session, highlighted)
+                except BaseException:
+                    pipe_input.send_text("\x03")
+                    with contextlib.suppress(BaseException):
+                        await prompt
+                    raise
+                return await prompt
 
     return asyncio.run(_run())
 
diff --git a/tests/test_litellm/proxy/management_endpoints/test_model_management_endpoints.py b/tests/test_litellm/proxy/management_endpoints/test_model_management_endpoints.py
index 8d618f4699b7..5f7807650e16 100644
--- a/tests/test_litellm/proxy/management_endpoints/test_model_management_endpoints.py
+++ b/tests/test_litellm/proxy/management_endpoints/test_model_management_endpoints.py
@@ -4796,6 +4796,30 @@ async def test_patch_model_rejects_unknown_credential_name(self, monkeypatch):
         assert "not found" in exc_info.value.message.lower()
         credentials_repository.find_by_name.assert_awaited_once_with("ghost-credential")
 
+    @pytest.mark.asyncio
+    async def test_patch_model_resending_unchanged_dangling_credential_name_is_not_validated(self, monkeypatch):
+        credentials_repository = MagicMock()
+        db_model: Final = Deployment(
+            model_name="gpt-4",
+            litellm_params=LiteLLM_Params(
+                model="openai/gpt-4o",
+                api_base="https://api.openai.com/v1",
+                litellm_credential_name="ghost-credential",
+            ),
+            model_info=ModelInfo(id="dep-cred-1"),
+        )
+
+        persisted: Final = await self._patch_model(
+            monkeypatch,
+            db_model,
+            self._admin_user(),
+            "ghost-credential",
+            credentials_repository=credentials_repository,
+        )
+        params: Final = json.loads(persisted[0]["litellm_params"])
+        assert params["litellm_credential_name"] == "ghost-credential"
+        credentials_repository.find_by_name.assert_not_awaited()
+
     @pytest.mark.asyncio
     async def test_patch_model_accepts_credential_known_only_in_db(self, monkeypatch):
         db_model: Final = Deployment(
diff --git a/tests/test_litellm/proxy/management_endpoints/test_password_endpoints.py b/tests/test_litellm/proxy/management_endpoints/test_password_endpoints.py
index 984c95321b55..adff4eda47cc 100644
--- a/tests/test_litellm/proxy/management_endpoints/test_password_endpoints.py
+++ b/tests/test_litellm/proxy/management_endpoints/test_password_endpoints.py
@@ -1,17 +1,19 @@
 """
 Tests for POST /user/password/change (litellm/proxy/management_endpoints/password_endpoints.py).
 
-HIBP traffic is intercepted with respx; no test here touches the network.
+HIBP is served by an AsyncHTTPHandler wrapping an httpx.MockTransport that is
+injected straight into change_password; no test here touches the network.
 """
 
 import hashlib
+from typing import Final
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import httpx
 import pytest
-import respx
 from fastapi import HTTPException
 
+from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
 from litellm.proxy._types import UI_TEAM_ID, LitellmTableNames, ProxyErrorTypes, ProxyException, UserAPIKeyAuth
 from litellm.proxy.auth.login_utils import PASSWORD_SESSION_METADATA
 from litellm.proxy.management_endpoints.password_endpoints import change_password
@@ -49,15 +51,29 @@ def _virtual_key_caller() -> UserAPIKeyAuth:
     return UserAPIKeyAuth(user_id="user-123", team_id="team-abc", metadata=dict(PASSWORD_SESSION_METADATA))
 
 
-def _hibp_url_for(password: str) -> str:
-    sha1 = hashlib.sha1(password.encode(), usedforsecurity=False).hexdigest().upper()
-    return f"https://api.pwnedpasswords.com/range/{sha1[:5]}"
-
-
 def _hibp_suffix_for(password: str) -> str:
     return hashlib.sha1(password.encode(), usedforsecurity=False).hexdigest().upper()[5:]
 
 
+def _hibp_client_returning(body: str) -> AsyncHTTPHandler:
+    return AsyncHTTPHandler(transport=httpx.MockTransport(lambda request: httpx.Response(200, text=body)))
+
+
+def _hibp_client_never_called() -> AsyncHTTPHandler:
+    def handler(request: httpx.Request) -> httpx.Response:
+        raise AssertionError(f"unexpected HIBP call to {request.url}")
+
+    return AsyncHTTPHandler(transport=httpx.MockTransport(handler))
+
+
+def _hibp_client_recording(calls: list[httpx.Request]) -> AsyncHTTPHandler:
+    def handler(request: httpx.Request) -> httpx.Response:
+        calls.append(request)
+        return httpx.Response(200, text="")
+
+    return AsyncHTTPHandler(transport=httpx.MockTransport(handler))
+
+
 @pytest.mark.asyncio
 async def test_change_password_success_writes_new_scrypt_hash():
     from litellm.proxy._types import ChangePasswordRequest
@@ -75,6 +91,7 @@ async def test_change_password_success_writes_new_scrypt_hash():
         response = await change_password(
             data=ChangePasswordRequest(current_password=CURRENT_PASSWORD, new_password=NEW_PASSWORD),
             user_api_key_dict=_caller(),
+            hibp_client=_hibp_client_never_called(),
         )
 
     assert response.user_id == "user-123"
@@ -107,6 +124,7 @@ async def test_change_password_rejects_wrong_current_password():
             await change_password(
                 data=ChangePasswordRequest(current_password="not-the-password", new_password=NEW_PASSWORD),
                 user_api_key_dict=_caller(),
+                hibp_client=_hibp_client_never_called(),
             )
 
     assert exc_info.value.status_code == 400
@@ -132,6 +150,7 @@ async def test_change_password_rejects_unchanged_password():
             await change_password(
                 data=ChangePasswordRequest(current_password=CURRENT_PASSWORD, new_password=CURRENT_PASSWORD),
                 user_api_key_dict=_caller(),
+                hibp_client=_hibp_client_never_called(),
             )
 
     assert exc_info.value.status_code == 400
@@ -167,6 +186,7 @@ async def test_change_password_rejects_non_password_login_session(caller: UserAP
             await change_password(
                 data=ChangePasswordRequest(current_password=CURRENT_PASSWORD, new_password=NEW_PASSWORD),
                 user_api_key_dict=caller,
+                hibp_client=_hibp_client_never_called(),
             )
 
     assert exc_info.value.status_code == 403
@@ -193,6 +213,7 @@ async def test_change_password_rejects_session_without_user():
             await change_password(
                 data=ChangePasswordRequest(current_password=CURRENT_PASSWORD, new_password=NEW_PASSWORD),
                 user_api_key_dict=_caller(user_id=None),
+                hibp_client=_hibp_client_never_called(),
             )
 
     assert exc_info.value.status_code == 400
@@ -219,6 +240,7 @@ async def test_change_password_rejects_account_without_password():
             await change_password(
                 data=ChangePasswordRequest(current_password=CURRENT_PASSWORD, new_password=NEW_PASSWORD),
                 user_api_key_dict=_caller(),
+                hibp_client=_hibp_client_never_called(),
             )
 
     assert exc_info.value.status_code == 400
@@ -244,6 +266,7 @@ async def test_change_password_enforces_min_length():
             await change_password(
                 data=ChangePasswordRequest(current_password=CURRENT_PASSWORD, new_password="Short1!"),
                 user_api_key_dict=_caller(),
+                hibp_client=_hibp_client_never_called(),
             )
 
     assert exc_info.value.code == "400"
@@ -254,15 +277,11 @@ async def test_change_password_enforces_min_length():
 
 
 @pytest.mark.asyncio
-@respx.mock
 async def test_change_password_rejects_breached_password():
     """With the default policy, the new password is screened against HIBP."""
     from litellm.proxy._types import ChangePasswordRequest
 
     breached_password = "Password123!"
-    respx.get(_hibp_url_for(breached_password)).mock(
-        return_value=httpx.Response(200, text=f"{_hibp_suffix_for(breached_password)}:1")
-    )
     prisma = _make_prisma(_make_user_row(hash_password(CURRENT_PASSWORD)))
 
     with (
@@ -277,6 +296,7 @@ async def test_change_password_rejects_breached_password():
             await change_password(
                 data=ChangePasswordRequest(current_password=CURRENT_PASSWORD, new_password=breached_password),
                 user_api_key_dict=_caller(),
+                hibp_client=_hibp_client_returning(f"{_hibp_suffix_for(breached_password)}:1"),
             )
 
     assert exc_info.value.code == "400"
@@ -287,16 +307,14 @@ async def test_change_password_rejects_breached_password():
 
 
 @pytest.mark.asyncio
-@respx.mock
 async def test_change_password_verifies_current_password_before_hibp_lookup():
     """A caller who fails current-password verification must not trigger any
-    HIBP traffic. The HIBP check fails open on errors, so an unmocked lookup
-    could not prove ordering; instead the route is registered and asserted
-    uncalled."""
+    HIBP traffic: the injected client records each request it serves and the
+    test asserts none were made."""
     from litellm.proxy._types import ChangePasswordRequest
 
-    hibp_route = respx.get(_hibp_url_for(NEW_PASSWORD)).mock(return_value=httpx.Response(200, text=""))
     prisma = _make_prisma(_make_user_row(hash_password(CURRENT_PASSWORD)))
+    hibp_calls: Final[list[httpx.Request]] = []
 
     with (
         patch(  # test-quality-ok: change_password reads proxy_server module globals; no injection seam
@@ -310,11 +328,12 @@ async def test_change_password_verifies_current_password_before_hibp_lookup():
             await change_password(
                 data=ChangePasswordRequest(current_password="not-the-password", new_password=NEW_PASSWORD),
                 user_api_key_dict=_caller(),
+                hibp_client=_hibp_client_recording(hibp_calls),
             )
 
     assert exc_info.value.status_code == 400
     assert "Current password is incorrect" in exc_info.value.detail["error"]
-    assert not hibp_route.called
+    assert hibp_calls == []
     prisma.db.litellm_usertable.update.assert_not_called()
 
 
@@ -341,6 +360,7 @@ async def test_change_password_success_emits_redacted_audit_log():
         await change_password(
             data=ChangePasswordRequest(current_password=CURRENT_PASSWORD, new_password=NEW_PASSWORD),
             user_api_key_dict=_caller(),
+            hibp_client=_hibp_client_never_called(),
         )
 
     audit_mock.assert_awaited_once()
@@ -375,6 +395,7 @@ async def test_change_password_failure_emits_no_audit_log():
             await change_password(
                 data=ChangePasswordRequest(current_password="not-the-password", new_password=NEW_PASSWORD),
                 user_api_key_dict=_caller(),
+                hibp_client=_hibp_client_never_called(),
             )
 
     audit_mock.assert_not_awaited()
@@ -411,6 +432,7 @@ async def test_change_password_revokes_other_sessions_keeping_callers():
         await change_password(
             data=ChangePasswordRequest(current_password=CURRENT_PASSWORD, new_password=NEW_PASSWORD),
             user_api_key_dict=caller,
+            hibp_client=_hibp_client_never_called(),
         )
 
     revoke_mock.assert_awaited_once()
@@ -442,6 +464,7 @@ async def test_change_password_failure_revokes_no_sessions():
             await change_password(
                 data=ChangePasswordRequest(current_password="not-the-password", new_password=NEW_PASSWORD),
                 user_api_key_dict=_caller(),
+                hibp_client=_hibp_client_never_called(),
             )
 
     revoke_mock.assert_not_awaited()
@@ -463,6 +486,7 @@ async def test_change_password_requires_db():
             await change_password(
                 data=ChangePasswordRequest(current_password=CURRENT_PASSWORD, new_password=NEW_PASSWORD),
                 user_api_key_dict=_caller(),
+                hibp_client=_hibp_client_never_called(),
             )
 
     assert exc_info.value.status_code == 500
diff --git a/tests/test_litellm/proxy/proxy_server/test_proxy_config.py b/tests/test_litellm/proxy/proxy_server/test_proxy_config.py
index 89cb8356289c..7e198bc91312 100644
--- a/tests/test_litellm/proxy/proxy_server/test_proxy_config.py
+++ b/tests/test_litellm/proxy/proxy_server/test_proxy_config.py
@@ -16,6 +16,7 @@
 from collections.abc import Mapping
 from dataclasses import dataclass
 from datetime import datetime
+from pathlib import Path
 from types import MappingProxyType, SimpleNamespace
 from typing import Any, Dict, Final
 from unittest.mock import AsyncMock, MagicMock
@@ -2072,6 +2073,88 @@ def test_ProxyConfig__load_environment_variables_blocks_dangerous_keys(monkeypat
 # ---------------------------------------------------------------------------
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("flag", "system"), (("use_google_kms", "google_kms"), ("use_azure_key_vault", "azure_key_vault"))
+)
+async def test_load_config_legacy_secret_manager_flags_capture_the_initialized_client(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, flag: str, system: str
+) -> None:
+    if system == "azure_key_vault":
+        client_type: Final = pytest.importorskip("azure.keyvault.secrets").SecretClient
+    else:
+        client_type: Final = pytest.importorskip("google.cloud.kms_v1").KeyManagementServiceClient
+
+    from litellm.rust_bridge.secret_manager import native_secret_manager_config
+
+    credentials_file: Final = tmp_path / "credentials.json"
+    credentials_file.write_text(
+        json.dumps(
+            {
+                "type": "authorized_user",
+                "client_id": "test-client",
+                "client_secret": "test-secret",
+                "refresh_token": "test",
+            }
+        )
+    )
+    config_file: Final = tmp_path / "legacy-secret-manager.yaml"
+    config_file.write_text(
+        f"model_list: []\ngeneral_settings:\n  {flag}: true\n  key_management_settings:\n    access_mode: write_only\n"
+    )
+    monkeypatch.setenv("GOOGLE_APPLICATION_CREDENTIALS", str(credentials_file))
+    monkeypatch.setenv("GOOGLE_KMS_RESOURCE_NAME", "projects/test/locations/global/keyRings/test/cryptoKeys/test")
+    monkeypatch.setenv("AZURE_KEY_VAULT_URI", "https://test.vault.azure.net")
+    monkeypatch.setattr(litellm, "secret_manager_client", None)
+    monkeypatch.setattr(litellm, "_key_management_system", None)
+    monkeypatch.setattr(litellm, "_google_kms_resource_name", None)
+    monkeypatch.setattr(litellm, "_key_management_settings", litellm._key_management_settings)
+    monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", None)
+    monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", False)
+    monkeypatch.delenv("LITELLM_CONFIG_BUCKET_NAME", raising=False)
+
+    await ProxyConfig().load_config(router=None, config_file_path=str(config_file))
+
+    client: Final = litellm.secret_manager_client
+    assert isinstance(client, client_type)
+    try:
+        captured: Final = native_secret_manager_config(client)
+        assert captured is not None
+        assert captured.system == system
+        assert dict(captured.environment)["GOOGLE_APPLICATION_CREDENTIALS"] == str(credentials_file)
+        assert litellm._key_management_system is not None
+        assert litellm._key_management_system.value == system
+    finally:
+        if system == "azure_key_vault":
+            client.close()
+        else:
+            client.transport.close()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("flag", ("null", "false"))
+async def test_load_config_disabled_google_kms_does_not_initialize_a_manager(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, flag: str
+) -> None:
+    config_file: Final = tmp_path / "disabled-kms.yaml"
+    config_file.write_text(f"model_list: []\ngeneral_settings:\n  use_google_kms: {flag}\n")
+    monkeypatch.setattr(litellm, "secret_manager_client", None)
+    monkeypatch.setattr(litellm, "_key_management_system", None)
+    monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", None)
+    monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", False)
+    monkeypatch.delenv("LITELLM_CONFIG_BUCKET_NAME", raising=False)
+    monkeypatch.delenv("GOOGLE_APPLICATION_CREDENTIALS", raising=False)
+
+    _router, model_list, general_settings = await ProxyConfig().load_config(
+        router=None, config_file_path=str(config_file)
+    )
+
+    assert model_list == []
+    assert general_settings["use_google_kms"] is (None if flag == "null" else False)
+    assert litellm.secret_manager_client is None
+    assert litellm._key_management_system is None
+
+
 @pytest.mark.asyncio
 async def test_ProxyConfig_load_config_minimal_yaml(tmp_path, monkeypatch):
     f = tmp_path / "c.yaml"
diff --git a/tests/test_litellm/router_utils/test_reasoning_effort_capability.py b/tests/test_litellm/router_utils/test_reasoning_effort_capability.py
index 4617839c5e33..2f23320a8adf 100644
--- a/tests/test_litellm/router_utils/test_reasoning_effort_capability.py
+++ b/tests/test_litellm/router_utils/test_reasoning_effort_capability.py
@@ -458,3 +458,30 @@ def test_a_level_above_the_ceiling_takes_the_strongest_declared_one(self):
     def test_a_level_outside_the_strength_order_is_left_for_upstream(self):
         assert nearest_declared_reasoning_effort("turbo", ("none", "high")) == "turbo"
         assert nearest_declared_reasoning_effort("medium", ()) == "medium"
+
+
+class TestAzureGpt6SolAndLunaAdvertiseTheOpenAiLevels:
+    @pytest.mark.parametrize(
+        "model,custom_llm_provider",
+        [
+            ("azure/gpt-6-sol", "azure"),
+            ("azure/gpt-6-luna", "azure"),
+            ("azure/eu/gpt-6-sol", "azure"),
+            ("azure/eu/gpt-6-luna", "azure"),
+            ("azure_ai/gpt-6-sol", "azure_ai"),
+            ("azure_ai/gpt-6-luna", "azure_ai"),
+        ],
+    )
+    def test_the_azure_entry_advertises_the_same_levels_as_openai(
+        self, local_model_cost_map, model, custom_llm_provider
+    ):
+        """The Foundry deployments of sol and luna take the same effort set OpenAI documents for
+        the direct API, so the resolved levels must match the OpenAI-direct entry."""
+        from litellm.utils import _get_model_info_helper
+
+        azure_info = dict(_get_model_info_helper(model=model, custom_llm_provider=custom_llm_provider))
+        openai_info = dict(_get_model_info_helper(model=model.rsplit("/", 1)[1], custom_llm_provider="openai"))
+
+        assert resolve_supported_reasoning_efforts(
+            azure_info, deployment_is_mapped=True
+        ) == resolve_supported_reasoning_efforts(openai_info, deployment_is_mapped=True)
diff --git a/tests/test_litellm/rust_bridge/AGENTS.md b/tests/test_litellm/rust_bridge/AGENTS.md
new file mode 100644
index 000000000000..351bd582ce78
--- /dev/null
+++ b/tests/test_litellm/rust_bridge/AGENTS.md
@@ -0,0 +1,7 @@
+# Rust bridge tests
+
+Test what each side of the bridge does, not the rollout policy that picks a side. `LITELLM_RUST` and `catalog.RULES` change every time a route or backend rolls forward, so a test that sets the env var or patches the catalog to reach a path goes red on a policy change even when the code under test is fine
+
+Call each path directly with an explicit decision instead. The Python path is the implementation the dispatcher falls back to, e.g. `litellm.ocr.main.ocr`. The Rust path is the native binding, e.g. `NATIVE_OCR.load()` from `litellm/rust_bridge/ocr/entrypoints.py`, called with the request, args and kwargs that dispatch would hand it. When the native side reads a policy-derived setting such as `settings.secret_manager().native`, pin that field in the test instead of deriving it from the catalog. `ocr/test_secrets.py` shows the pattern
+
+Rollout policy itself, meaning which rule matches and what `LITELLM_RUST` changes, belongs in `test_catalog.py`, `test_configuration.py` and `test_dispatch.py`, tested against rules the test builds rather than the shipped `catalog.RULES`
diff --git a/tests/test_litellm/rust_bridge/ocr/test_secrets.py b/tests/test_litellm/rust_bridge/ocr/test_secrets.py
index 085a42dd3730..a91c0ff5bc85 100644
--- a/tests/test_litellm/rust_bridge/ocr/test_secrets.py
+++ b/tests/test_litellm/rust_bridge/ocr/test_secrets.py
@@ -1,6 +1,11 @@
 from __future__ import annotations
 
-from typing import Final
+import asyncio
+from collections.abc import Awaitable, Generator, Mapping
+from contextlib import contextmanager
+from dataclasses import replace
+from types import MappingProxyType
+from typing import Final, Literal, Protocol, TypeAlias, cast
 
 import httpx
 import pytest
@@ -8,14 +13,27 @@
 import litellm
 from litellm.integrations.custom_secret_manager import CustomSecretManager
 from litellm.llms.base_llm.ocr.transformation import OCRResponse
-from litellm.rust_bridge import configuration
+from litellm.ocr import main
+from litellm.rust_bridge import settings
+from litellm.rust_bridge.ocr.entrypoints import NATIVE_AOCR, NATIVE_OCR, LiteLLMOcrRequest
 from litellm.types.secret_managers.main import KeyManagementSettings, KeyManagementSystem
-from tests.test_litellm_rust.support.recording_server import ResponseSpec, recording_service
+from tests.test_litellm_rust.support.recording_server import RecordingServer, ResponseSpec, recording_service
+from tests.test_litellm_rust.support.requests import OCR_DOCUMENT, OCR_MODEL, OCR_RESPONSE
+
+native: Final = pytest.importorskip("litellm.rust_bridge._native")
+
+AccessMode: TypeAlias = Literal["read_only", "write_only", "read_and_write"]
+
+
+class Ocr(Protocol):
+    def __call__(self, api_base: str, /) -> Awaitable[OCRResponse]: ...
 
 
 class _VaultSecrets(CustomSecretManager):
-    def __init__(self) -> None:
+    def __init__(self, failure: BaseException | None = None) -> None:
         super().__init__(secret_manager_name="rust_bridge_ocr_test")
+        self.failure: Final = failure
+        self.reads: tuple[tuple[str, Mapping[str, object] | None], ...] = ()
 
     async def async_read_secret(
         self,
@@ -23,7 +41,7 @@ async def async_read_secret(
         optional_params: dict[str, object] | None = None,
         timeout: float | httpx.Timeout | None = None,
     ) -> str | None:
-        return "vault-key" if secret_name == "MISTRAL_API_KEY" else None
+        raise AssertionError("get_secret reads custom managers synchronously")
 
     def sync_read_secret(
         self,
@@ -31,82 +49,393 @@ def sync_read_secret(
         optional_params: dict[str, object] | None = None,
         timeout: float | httpx.Timeout | None = None,
     ) -> str | None:
-        return "vault-key" if secret_name == "MISTRAL_API_KEY" else None
-
-
-async def _call(asynchronous: bool, api_base: str) -> OCRResponse:
-    if asynchronous:
-        return await litellm.aocr(
-            model="mistral/mistral-ocr-latest",
-            document={"type": "document_url", "document_url": "https://example.com/document.pdf"},
-            api_base=api_base,
-        )
-    return litellm.ocr(
-        model="mistral/mistral-ocr-latest",
-        document={"type": "document_url", "document_url": "https://example.com/document.pdf"},
+        self.reads = (*self.reads, (secret_name, optional_params))
+        if secret_name != "MISTRAL_API_KEY":
+            return None
+        if self.failure is not None:
+            raise self.failure
+        return "vault-key"
+
+    def key_reads(self) -> tuple[Mapping[str, object] | None, ...]:
+        return tuple(params for name, params in self.reads if name == "MISTRAL_API_KEY")
+
+
+def _native_request(api_base: str) -> LiteLLMOcrRequest:
+    return LiteLLMOcrRequest(
+        model=OCR_MODEL,
+        document=OCR_DOCUMENT,
+        api_key=None,
         api_base=api_base,
+        timeout=None,
+        custom_llm_provider=None,
+        extra_headers=None,
+        kwargs=MappingProxyType({}),
     )
 
 
-_RESPONSE: Final = {
-    "pages": [{"index": 0, "markdown": "parsed document", "images": []}],
-    "model": "mistral-ocr-latest",
-    "usage_info": {"pages_processed": 1},
-}
+def _public_kwargs(api_base: str) -> dict[str, object]:
+    return {"model": OCR_MODEL, "document": OCR_DOCUMENT, "api_base": api_base}
+
+
+async def _python_ocr(api_base: str) -> OCRResponse:
+    response: Final = main.ocr(model=OCR_MODEL, document=OCR_DOCUMENT, api_base=api_base)
+    assert isinstance(response, OCRResponse)
+    return response
+
+
+async def _python_aocr(api_base: str) -> OCRResponse:
+    return await main.aocr(model=OCR_MODEL, document=OCR_DOCUMENT, api_base=api_base)
+
+
+async def _rust_ocr(api_base: str) -> OCRResponse:
+    route: Final = NATIVE_OCR.load()
+    assert route is not None
+    return route(_native_request(api_base), (), _public_kwargs(api_base))
+
+
+async def _rust_aocr(api_base: str) -> OCRResponse:
+    route: Final = NATIVE_AOCR.load()
+    assert route is not None
+    return await route(_native_request(api_base), (), _public_kwargs(api_base))
+
+
+_RUST_PATHS: Final = (_rust_ocr, _rust_aocr)
+_RUST_IDS: Final = ("rust-sync", "rust-async")
+
 
+@pytest.fixture(params=(_python_ocr, _python_aocr, *_RUST_PATHS), ids=("python-sync", "python-async", *_RUST_IDS))
+def ocr(request: pytest.FixtureRequest) -> Ocr:
+    return cast(Ocr, request.param)
 
-@pytest.mark.asyncio
-@pytest.mark.parametrize("asynchronous", (False, True))
-@pytest.mark.parametrize("rust_enabled", ("0", "1"))
-@pytest.mark.parametrize("access_mode", ("read_only", "read_and_write"))
-@pytest.mark.parametrize("system", (None, KeyManagementSystem.CUSTOM))
-async def test_readable_secret_managers_keep_python_ocr_fallback(
+
+@pytest.fixture(params=_RUST_PATHS, ids=_RUST_IDS)
+def rust_ocr(request: pytest.FixtureRequest) -> Ocr:
+    return cast(Ocr, request.param)
+
+
+@contextmanager
+def _mistral_service(expected_requests: int = 1) -> Generator[RecordingServer]:
+    with recording_service() as server:
+        server.default_response = ResponseSpec(body=OCR_RESPONSE)
+        server.expected_requests = expected_requests
+        yield server
+
+
+def _configure(
     monkeypatch: pytest.MonkeyPatch,
-    asynchronous: bool,
-    rust_enabled: str,
-    access_mode: str,
-    system: KeyManagementSystem | None,
+    *,
+    manager: _VaultSecrets,
+    key_management: KeyManagementSettings,
+    native_secret_manager: bool = True,
+    environment_key: str | None = "environment-key",
 ) -> None:
-    pytest.importorskip("litellm.rust_bridge._native")
-    monkeypatch.setenv("LITELLM_RUST", rust_enabled)
-    monkeypatch.setenv("MISTRAL_API_KEY", "environment-key")
-    monkeypatch.setattr(litellm, "secret_manager_client", _VaultSecrets())
-    monkeypatch.setattr(litellm, "_key_management_system", system)
-    monkeypatch.setattr(
-        litellm,
-        "_key_management_settings",
-        KeyManagementSettings(access_mode=access_mode, hosted_keys=["MISTRAL_API_KEY"]),
+    if environment_key is None:
+        monkeypatch.delenv("MISTRAL_API_KEY", raising=False)
+    else:
+        monkeypatch.setenv("MISTRAL_API_KEY", environment_key)
+    monkeypatch.setattr(litellm, "secret_manager_client", manager)
+    monkeypatch.setattr(litellm, "_key_management_system", KeyManagementSystem.CUSTOM)
+    monkeypatch.setattr(litellm, "_key_management_settings", key_management)
+    configured: Final = settings.secret_manager
+    monkeypatch.setattr(settings, "secret_manager", lambda: replace(configured(), native=native_secret_manager))
+
+
+@pytest.mark.parametrize(
+    ("access_mode", "hosted_keys"),
+    (("read_only", None), ("read_and_write", None), ("read_only", ["MISTRAL_API_KEY"])),
+)
+async def test_custom_secret_manager_supplies_the_ocr_key(
+    monkeypatch: pytest.MonkeyPatch, ocr: Ocr, access_mode: AccessMode, hosted_keys: list[str] | None
+) -> None:
+    manager: Final = _VaultSecrets()
+    key_management: Final = KeyManagementSettings(access_mode=access_mode, hosted_keys=hosted_keys)
+    _configure(monkeypatch, manager=manager, key_management=key_management)
+
+    with _mistral_service() as server:
+        await ocr(server.base_url)
+
+    assert server.requests[0].headers["authorization"] == "Bearer vault-key"
+    assert manager.key_reads(), "the custom manager was never asked for MISTRAL_API_KEY"
+    assert all(params == key_management.model_dump() for params in manager.key_reads()), manager.key_reads()
+
+
+@pytest.mark.parametrize(("access_mode", "hosted_keys"), (("read_only", ["OTHER"]), ("write_only", None)))
+async def test_custom_secret_manager_is_not_read_when_settings_exclude_the_key(
+    monkeypatch: pytest.MonkeyPatch, ocr: Ocr, access_mode: AccessMode, hosted_keys: list[str] | None
+) -> None:
+    manager: Final = _VaultSecrets()
+    _configure(
+        monkeypatch,
+        manager=manager,
+        key_management=KeyManagementSettings(access_mode=access_mode, hosted_keys=hosted_keys),
     )
-    configuration.reset_rust_configuration()
 
-    with recording_service() as server:
-        server.default_response = ResponseSpec(body=_RESPONSE)
-        result: Final = await _call(asynchronous, server.base_url)
+    with _mistral_service() as server:
+        await ocr(server.base_url)
 
-    assert result.pages[0].markdown == "parsed document"
-    assert len(server.requests) == 1
-    expected_key: Final = "vault-key" if system is KeyManagementSystem.CUSTOM else "environment-key"
-    assert server.requests[0].headers["authorization"] == f"Bearer {expected_key}"
-    assert "x-litellm-rust" not in result._hidden_params.get("additional_headers", {})
+    assert server.requests[0].headers["authorization"] == "Bearer environment-key"
+    assert manager.key_reads() == ()
+
+
+async def test_custom_secret_manager_exceptions_fall_back_to_the_environment_key(
+    monkeypatch: pytest.MonkeyPatch, ocr: Ocr
+) -> None:
+    _configure(
+        monkeypatch,
+        manager=_VaultSecrets(ValueError("secret manager failed")),
+        key_management=KeyManagementSettings(access_mode="read_only"),
+    )
+
+    with _mistral_service() as server:
+        await ocr(server.base_url)
+
+    assert server.requests[0].headers["authorization"] == "Bearer environment-key"
+
+
+async def test_custom_secret_manager_exceptions_without_environment_key_raise_missing_key(
+    monkeypatch: pytest.MonkeyPatch, ocr: Ocr
+) -> None:
+    _configure(
+        monkeypatch,
+        manager=_VaultSecrets(ValueError("secret manager failed")),
+        key_management=KeyManagementSettings(access_mode="read_only"),
+        environment_key=None,
+    )
+
+    with _mistral_service(expected_requests=0) as server:
+        with pytest.raises(litellm.APIConnectionError, match="Missing Mistral API Key"):
+            await ocr(server.base_url)
+
+
+async def test_custom_secret_manager_cancellation_propagates_without_provider_io(
+    monkeypatch: pytest.MonkeyPatch, ocr: Ocr
+) -> None:
+    failure: Final = asyncio.CancelledError("secret manager cancelled")
+    _configure(
+        monkeypatch, manager=_VaultSecrets(failure), key_management=KeyManagementSettings(access_mode="read_only")
+    )
+
+    with _mistral_service(expected_requests=0) as server:
+        with pytest.raises(asyncio.CancelledError) as raised:
+            await ocr(server.base_url)
+
+    assert raised.value is failure
+
+
+async def test_rust_declines_a_readable_secret_manager_it_cannot_resolve(
+    monkeypatch: pytest.MonkeyPatch, rust_ocr: Ocr
+) -> None:
+    manager: Final = _VaultSecrets()
+    _configure(
+        monkeypatch,
+        manager=manager,
+        key_management=KeyManagementSettings(access_mode="read_only"),
+        native_secret_manager=False,
+    )
+
+    with _mistral_service(expected_requests=0) as server:
+        with pytest.raises(native.RustBridgeDeclined):
+            await rust_ocr(server.base_url)
+
+    assert manager.key_reads() == ()
 
 
-@pytest.mark.asyncio
-@pytest.mark.parametrize("asynchronous", (False, True))
 async def test_no_secret_client_leaves_dormant_binding_settings_unread(
-    monkeypatch: pytest.MonkeyPatch, asynchronous: bool
+    monkeypatch: pytest.MonkeyPatch, rust_ocr: Ocr
 ) -> None:
-    pytest.importorskip("litellm.rust_bridge._native")
-    monkeypatch.setenv("LITELLM_RUST", "1")
     monkeypatch.setenv("MISTRAL_API_KEY", "environment-key")
     monkeypatch.setattr(litellm, "secret_manager_client", None)
     monkeypatch.setattr(litellm, "_key_management_settings", object())
-    configuration.reset_rust_configuration()
 
-    with recording_service() as server:
-        server.default_response = ResponseSpec(body=_RESPONSE)
-        result: Final = await _call(asynchronous, server.base_url)
+    with _mistral_service() as server:
+        await rust_ocr(server.base_url)
+
+    assert server.requests[0].headers["authorization"] == "Bearer environment-key"
+
+
+class _FixedSecrets(CustomSecretManager):
+    def __init__(self, value: str) -> None:
+        super().__init__(secret_manager_name="rust_bridge_ocr_fixed")
+        self.value: Final = value
+
+    async def async_read_secret(
+        self,
+        secret_name: str,
+        optional_params: dict[str, object] | None = None,
+        timeout: float | httpx.Timeout | None = None,
+    ) -> str | None:
+        raise AssertionError("get_secret reads custom managers synchronously")
+
+    def sync_read_secret(
+        self,
+        secret_name: str,
+        optional_params: dict[str, object] | None = None,
+        timeout: float | httpx.Timeout | None = None,
+    ) -> str | None:
+        return self.value if secret_name == "MISTRAL_API_KEY" else None
+
+
+class _PlainSecretReader:
+    def sync_read_secret(
+        self,
+        secret_name: str,
+        optional_params: dict[str, object] | None = None,
+        timeout: float | httpx.Timeout | None = None,
+    ) -> str | None:
+        return "vault-key"
+
+
+class _AzureSecret:
+    def __init__(self, value: str | None) -> None:
+        self.value: Final = value
+
+
+def _azure_sdk_client(value: str | None) -> object:
+    class SecretClient:
+        def get_secret(self, name: str) -> _AzureSecret:
+            return _AzureSecret(value if name == "MISTRAL_API_KEY" else None)
+
+    SecretClient.__module__ = "azure.keyvault.secrets._client"
+    return SecretClient()
+
+
+def _configure_client(
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    client: object,
+    system: KeyManagementSystem,
+    key_management: KeyManagementSettings,
+    environment_key: str = "environment-key",
+) -> None:
+    monkeypatch.setenv("MISTRAL_API_KEY", environment_key)
+    monkeypatch.setattr(litellm, "secret_manager_client", client)
+    monkeypatch.setattr(litellm, "_key_management_system", system)
+    monkeypatch.setattr(litellm, "_key_management_settings", key_management)
+    configured: Final = settings.secret_manager
+    monkeypatch.setattr(settings, "secret_manager", lambda: replace(configured(), native=True))
+
+
+async def _assert_missing_key(ocr: Ocr) -> None:
+    with _mistral_service(expected_requests=0) as server:
+        with pytest.raises(litellm.APIConnectionError, match="Missing Mistral API Key"):
+            await ocr(server.base_url)
+
+
+@pytest.mark.parametrize("environment_key", ("true", " FALSE ", "True"))
+async def test_boolean_environment_keys_count_as_missing(
+    monkeypatch: pytest.MonkeyPatch, ocr: Ocr, environment_key: str
+) -> None:
+    monkeypatch.setenv("MISTRAL_API_KEY", environment_key)
+    monkeypatch.setattr(litellm, "secret_manager_client", None)
+
+    await _assert_missing_key(ocr)
+
+
+@pytest.mark.parametrize("manager_key", ("True", "(False)"))
+async def test_boolean_manager_keys_count_as_missing(
+    monkeypatch: pytest.MonkeyPatch, ocr: Ocr, manager_key: str
+) -> None:
+    _configure_client(
+        monkeypatch,
+        client=_FixedSecrets(manager_key),
+        system=KeyManagementSystem.CUSTOM,
+        key_management=KeyManagementSettings(access_mode="read_only"),
+    )
+
+    await _assert_missing_key(ocr)
+
+
+async def test_boolean_environment_fallback_after_a_manager_exception_counts_as_missing(
+    monkeypatch: pytest.MonkeyPatch, ocr: Ocr
+) -> None:
+    _configure(
+        monkeypatch,
+        manager=_VaultSecrets(ValueError("secret manager failed")),
+        key_management=KeyManagementSettings(access_mode="read_only"),
+        environment_key="True",
+    )
+
+    await _assert_missing_key(ocr)
+
+
+async def test_manager_without_the_key_does_not_fall_back_to_the_environment(
+    monkeypatch: pytest.MonkeyPatch, ocr: Ocr
+) -> None:
+    _configure_client(
+        monkeypatch,
+        client=_azure_sdk_client(None),
+        system=KeyManagementSystem.AZURE_KEY_VAULT,
+        key_management=KeyManagementSettings(access_mode="read_only"),
+    )
+
+    await _assert_missing_key(ocr)
+
+
+async def test_rust_hosted_keys_exclude_azure_sdk_clients_too(monkeypatch: pytest.MonkeyPatch, rust_ocr: Ocr) -> None:
+    _configure_client(
+        monkeypatch,
+        client=_azure_sdk_client("vault-key"),
+        system=KeyManagementSystem.AZURE_KEY_VAULT,
+        key_management=KeyManagementSettings(access_mode="read_only", hosted_keys=["OTHER"]),
+    )
+
+    with _mistral_service() as server:
+        await rust_ocr(server.base_url)
+
+    assert server.requests[0].headers["authorization"] == "Bearer environment-key", (
+        "recorded divergence: Python's get_secret_from_manager recognizes Azure SDK clients by type and ignores hosted_keys"
+    )
+
+
+async def test_custom_system_with_a_foreign_client_falls_back_to_the_environment(
+    monkeypatch: pytest.MonkeyPatch, ocr: Ocr
+) -> None:
+    _configure_client(
+        monkeypatch,
+        client=_PlainSecretReader(),
+        system=KeyManagementSystem.CUSTOM,
+        key_management=KeyManagementSettings(access_mode="read_only"),
+    )
+
+    with _mistral_service() as server:
+        await ocr(server.base_url)
 
-    assert result.pages[0].markdown == "parsed document"
-    assert len(server.requests) == 1
     assert server.requests[0].headers["authorization"] == "Bearer environment-key"
-    assert result._hidden_params["additional_headers"]["x-litellm-rust"] == "true"
+
+
+async def test_native_backend_supplies_ocr_credentials_without_a_python_reader(
+    monkeypatch: pytest.MonkeyPatch, rust_ocr: Ocr
+) -> None:
+    from litellm.secret_managers import main as secret_manager_main
+    from litellm.secret_managers import secret_manager_handler
+    from litellm.secret_managers.aws_secret_manager_v2 import AWSSecretsManagerV2
+
+    def reject_python_read(
+        client: object,
+        key_manager: str,
+        secret_name: str,
+        key_management_settings: KeyManagementSettings | None = None,
+    ) -> str | None:
+        raise AssertionError("Rust must read the native backend directly")
+
+    monkeypatch.setattr(secret_manager_handler, "get_secret_from_manager", reject_python_read)
+    monkeypatch.setattr(secret_manager_main, "get_secret_from_manager", reject_python_read)
+    with recording_service() as secrets, _mistral_service(expected_requests=2) as provider:
+        secrets.default_response = ResponseSpec(body={"SecretString": "native-key"})
+        secrets.expected_requests = None
+        monkeypatch.setenv("AWS_ACCESS_KEY_ID", "native-access")
+        monkeypatch.setenv("AWS_SECRET_ACCESS_KEY", "native-secret")
+        monkeypatch.setenv("AWS_BEDROCK_RUNTIME_ENDPOINT", secrets.base_url)
+        monkeypatch.delenv("MISTRAL_API_KEY", raising=False)
+        manager: Final = AWSSecretsManagerV2(aws_region_name="us-east-1")
+        monkeypatch.setattr(litellm, "secret_manager_client", manager)
+        monkeypatch.setattr(litellm, "_key_management_system", KeyManagementSystem.AWS_SECRET_MANAGER)
+        monkeypatch.setattr(litellm, "_key_management_settings", KeyManagementSettings(hosted_keys=["MISTRAL_API_KEY"]))
+        monkeypatch.setattr(settings, "secret_manager", lambda: settings.SecretManager(readable=True, native=True))
+        await rust_ocr(provider.base_url)
+        await rust_ocr(provider.base_url)
+
+        assert len(secrets.requests) == 2, [(request.path, request.body) for request in secrets.requests]
+        assert all(request.headers["authorization"] == "Bearer native-key" for request in provider.requests)
+        assert all("Credential=native-access/" in request.headers["authorization"] for request in secrets.requests)
+        assert native._SecretManagerRuntime.from_client(manager) is getattr(manager, "_litellm_native_secret_manager")
diff --git a/tests/test_litellm/rust_bridge/test_secret_manager.py b/tests/test_litellm/rust_bridge/test_secret_manager.py
new file mode 100644
index 000000000000..e3e65a4e2bbc
--- /dev/null
+++ b/tests/test_litellm/rust_bridge/test_secret_manager.py
@@ -0,0 +1,1571 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import json
+import re
+from collections.abc import Mapping
+from dataclasses import dataclass
+from functools import partial
+from importlib import import_module
+from types import SimpleNamespace
+from typing import Final, Never
+from urllib.parse import urlsplit
+
+import httpx
+import pytest
+from botocore.auth import SigV4Auth
+from botocore.awsrequest import AWSRequest
+from botocore.credentials import Credentials
+from pydantic import JsonValue
+
+import litellm
+from litellm.rust_bridge import bindings
+from litellm.rust_bridge.bindings import NativeBinding
+from litellm.rust_bridge.catalog import Rules, SecretManagerRule
+from litellm.rust_bridge.configuration import Rollout
+from litellm.rust_bridge.secret_manager import (
+    NativeSecretManagerFactory,
+    NativeSecretManagerRuntime,
+    capture_secret_manager,
+    native_secret_manager_config,
+    resolve_native_provider_reader,
+    resolve_native_provider_writer,
+    resolve_native_secret_manager,
+)
+from litellm.secret_managers.aws_secret_manager_v2 import AWSSecretsManagerV2
+from litellm.secret_managers.cyberark_secret_manager import CyberArkSecretManager
+from litellm.secret_managers.dispatch import get_secret_from_manager
+from litellm.secret_managers.hashicorp_secret_manager import HashicorpSecretManager
+from litellm.types.secret_managers.main import KeyManagementSettings, KeyManagementSystem
+from tests.test_litellm_rust.support.recording_server import ResponseSpec, recording_service
+
+
+@pytest.fixture(autouse=True)
+def preserve_manager_globals(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(litellm, "secret_manager_client", litellm.secret_manager_client)
+    monkeypatch.setattr(litellm, "_key_management_system", litellm._key_management_system)
+    monkeypatch.setattr(litellm, "_key_management_settings", litellm._key_management_settings)
+
+
+def _vault(monkeypatch: pytest.MonkeyPatch, address: str) -> HashicorpSecretManager:
+    from litellm.proxy import proxy_server
+
+    monkeypatch.setattr(proxy_server, "premium_user", True)
+    monkeypatch.setenv("HCP_VAULT_ADDR", address)
+    monkeypatch.setenv("HCP_VAULT_TOKEN", "token")
+    return HashicorpSecretManager()
+
+
+def _vault_body(value: str) -> dict[str, object]:
+    return {
+        "data": {
+            "data": {"key": value},
+            "metadata": {
+                "created_time": "",
+                "deletion_time": "",
+                "custom_metadata": None,
+                "destroyed": False,
+                "version": 1,
+            },
+        },
+        "lease_id": "",
+        "lease_duration": 0,
+        "renewable": False,
+        "request_id": "",
+        "warnings": None,
+        "wrap_info": None,
+    }
+
+
+@pytest.mark.parametrize("system", ("aws_secret_manager", "hashicorp_vault", "cyberark"))
+async def test_python_native_handle_reuses_backend_across_sync_and_async_reads(system: str) -> None:
+    native: Final = pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        environment: Final = {
+            "AWS_REGION_NAME": "us-east-1",
+            "AWS_ACCESS_KEY_ID": "captured-access",
+            "AWS_SECRET_ACCESS_KEY": "captured-secret",
+            "AWS_BEDROCK_RUNTIME_ENDPOINT": server.base_url,
+            "AZURE_KEY_VAULT_URI": server.base_url,
+            "AZURE_AD_TOKEN": "azure-token",
+            "HCP_VAULT_ADDR": server.base_url,
+            "HCP_VAULT_TOKEN": "vault-token",
+            "CYBERARK_API_BASE": server.base_url,
+            "CYBERARK_API_KEY": "cyberark-key",
+            "CYBERARK_ACCOUNT": "account",
+            "CYBERARK_USERNAME": "reader",
+        }
+        responses: Final = {
+            "aws_secret_manager": {"SecretString": "native-value"},
+            "azure_key_vault": {"value": "native-value"},
+            "hashicorp_vault": _vault_body("native-value"),
+            "cyberark": "native-value",
+        }
+        server.default_response = ResponseSpec(body=responses[system])
+        server.expected_requests = 2 if system == "cyberark" else 1 if system == "hashicorp_vault" else 3
+        if system == "cyberark":
+            server.enqueue(ResponseSpec(body="authentication-token"))
+        handle: Final = native._SecretManagerRuntime.from_config(system, environment, enterprise_enabled=True)
+        expected: Final = '"native-value"' if system == "cyberark" else "native-value"
+        assert handle.read_secret("KEY") == expected
+        assert await handle.async_read_secret("KEY") == expected
+        assert handle.read_secret("KEY") == expected
+
+
+def test_shared_initializer_captures_credentials_and_tracks_instance_settings(monkeypatch: pytest.MonkeyPatch) -> None:
+    native: Final = pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.default_response = ResponseSpec(body={"SecretString": "native-value"})
+        server.expected_requests = 2
+        monkeypatch.setenv("AWS_ACCESS_KEY_ID", "captured-access")
+        monkeypatch.setenv("AWS_SECRET_ACCESS_KEY", "captured-secret")
+        monkeypatch.setenv("AWS_BEDROCK_RUNTIME_ENDPOINT", server.base_url)
+        from litellm.proxy.proxy_server import ProxyConfig
+
+        monkeypatch.setattr(litellm, "_key_management_settings", KeyManagementSettings(aws_region_name="us-east-1"))
+        ProxyConfig().initialize_secret_manager(KeyManagementSystem.AWS_SECRET_MANAGER.value)
+        manager: Final = litellm.secret_manager_client
+        assert isinstance(manager, AWSSecretsManagerV2)
+        monkeypatch.setenv("AWS_ACCESS_KEY_ID", "changed-access")
+        monkeypatch.setenv("AWS_BEDROCK_RUNTIME_ENDPOINT", "http://127.0.0.1:1")
+        first: Final = native._SecretManagerRuntime.from_client(manager)
+        assert first is not None
+        assert native._SecretManagerRuntime.from_client(manager) is first
+        assert first.read_secret("KEY") == "native-value"
+        manager.aws_region_name = "us-west-2"
+        second: Final = native._SecretManagerRuntime.from_client(manager)
+        assert second is not None
+        assert second is not first
+        assert second.read_secret("KEY") == "native-value"
+        assert "Credential=captured-access/" in server.requests[0].headers["authorization"]
+        assert "/us-east-1/" in server.requests[0].headers["authorization"]
+        assert "/us-west-2/" in server.requests[1].headers["authorization"]
+
+
+def test_configuration_replacement_rebuilds_without_invalidating_existing_handles(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    native: Final = pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as first_server, recording_service() as second_server:
+        first_server.default_response = ResponseSpec(body=_vault_body("first"))
+        second_server.default_response = ResponseSpec(body=_vault_body("second"))
+        manager: Final = _vault(monkeypatch, first_server.base_url)
+        first: Final = native._SecretManagerRuntime.from_client(manager)
+        assert first is not None
+        assert first.read_secret("KEY") == "first"
+        manager.vault_addr = second_server.base_url
+        second: Final = native._SecretManagerRuntime.from_client(manager)
+        assert second is not None
+        assert second is not first
+        assert second.read_secret("KEY") == "second"
+        assert first.read_secret("KEY") == "first"
+
+
+def test_custom_subclass_keeps_its_python_reader_under_native_selection() -> None:
+    class CustomManager(AWSSecretsManagerV2):
+        def sync_read_secret(self, secret_name: str, primary_secret_name: str | None = None) -> str:
+            return f"custom:{secret_name}"
+
+    class DecliningFactory:
+        @staticmethod
+        def from_client(client: object) -> NativeSecretManagerRuntime | None:
+            assert native_secret_manager_config(client) is None
+            return None
+
+    binding: Final[NativeBinding[NativeSecretManagerFactory]] = NativeBinding("unused", validate=lambda value: None)
+    binding.override(DecliningFactory)
+    rules: Final[Rules] = (SecretManagerRule(Rollout.RUST_REQUIRED, systems=frozenset({"aws_secret_manager"})),)
+    assert (
+        get_secret_from_manager(
+            CustomManager(aws_region_name="us-east-1"), "aws_secret_manager", "KEY", rules=rules, binding=binding
+        )
+        == "custom:KEY"
+    )
+
+
+def test_read_dispatch_uses_native_backend_with_explicit_rules(monkeypatch: pytest.MonkeyPatch) -> None:
+    native: Final = pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.default_response = ResponseSpec(body=_vault_body("native-value"))
+        manager: Final = _vault(monkeypatch, server.base_url)
+        rules: Final[Rules] = (SecretManagerRule(Rollout.RUST_REQUIRED, systems=frozenset({"hashicorp_vault"})),)
+        assert get_secret_from_manager(manager, "hashicorp_vault", "KEY", rules=rules) == "native-value"
+        runtime: Final = native._SecretManagerRuntime.from_client(manager)
+        assert runtime is not None
+        assert runtime.read_secret("KEY") == "native-value"
+        assert len(server.requests) == 1
+
+
+@pytest.mark.parametrize("system", ("google_secret_manager", "hashicorp_vault", "cyberark"))
+def test_enterprise_backends_cannot_initialize_without_entitlement(system: str) -> None:
+    native: Final = pytest.importorskip("litellm.rust_bridge._native")
+    with pytest.raises(ValueError, match=r"[Ee]nterprise|[Pp]remium"):
+        native._SecretManagerRuntime.from_config(system, {"CYBERARK_API_KEY": "key"})
+
+
+def test_azure_factory_rejects_unencrypted_vault_endpoints() -> None:
+    native: Final = pytest.importorskip("litellm.rust_bridge._native")
+    with pytest.raises(ValueError, match="https"):
+        native._SecretManagerRuntime.from_config("azure_key_vault", {"AZURE_KEY_VAULT_URI": "http://127.0.0.1:1"})
+
+
+def test_direct_builtin_constructor_can_use_native_without_registration(monkeypatch: pytest.MonkeyPatch) -> None:
+    native: Final = pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.default_response = ResponseSpec(body=_vault_body("native-value"))
+        manager: Final = _vault(monkeypatch, server.base_url)
+        handle: Final = native._SecretManagerRuntime.from_client(manager)
+        assert handle is not None
+        assert handle.read_secret("KEY") == "native-value"
+
+
+def test_binding_rejects_a_different_backend_before_reading() -> None:
+    native: Final = pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.expected_requests = 0
+        handle: Final = native._SecretManagerRuntime.from_config(
+            "hashicorp_vault",
+            {"HCP_VAULT_ADDR": server.base_url, "HCP_VAULT_TOKEN": "token"},
+            enterprise_enabled=True,
+        )
+        rules: Final[Rules] = (SecretManagerRule(Rollout.RUST_REQUIRED, systems=frozenset({"aws_secret_manager"})),)
+        with pytest.raises(ValueError, match="system does not match"):
+            resolve_native_secret_manager(handle, "aws_secret_manager", rules)
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_OPT_OUT))
+def test_python_selection_and_missing_extension_preserve_python_reader(
+    monkeypatch: pytest.MonkeyPatch, rollout: Rollout
+) -> None:
+    binding: Final[NativeBinding[NativeSecretManagerFactory]] = NativeBinding("unused", validate=lambda value: None)
+    binding.override(None)
+    with recording_service() as server:
+        server.default_response = ResponseSpec(body=_vault_body("python-value"))
+        manager: Final = _vault(monkeypatch, server.base_url)
+        rules: Final[Rules] = (SecretManagerRule(rollout, systems=frozenset({"hashicorp_vault"})),)
+        assert (
+            get_secret_from_manager(manager, "hashicorp_vault", "KEY", rules=rules, binding=binding) == "python-value"
+        )
+        assert server.requests[0].headers["x-vault-token"] == "token"
+
+
+def test_required_native_missing_extension_does_not_read_python(monkeypatch: pytest.MonkeyPatch) -> None:
+    binding: Final[NativeBinding[NativeSecretManagerFactory]] = NativeBinding("unused", validate=lambda value: None)
+    binding.override(None)
+    with recording_service() as server:
+        server.expected_requests = 0
+        manager: Final = _vault(monkeypatch, server.base_url)
+        rules: Final[Rules] = (SecretManagerRule(Rollout.RUST_REQUIRED, systems=frozenset({"hashicorp_vault"})),)
+        with pytest.raises(RuntimeError, match="unavailable"):
+            get_secret_from_manager(manager, "hashicorp_vault", "KEY", rules=rules, binding=binding)
+
+
+def test_native_failure_is_not_replayed_in_python(monkeypatch: pytest.MonkeyPatch) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.default_response = ResponseSpec(status=403, body={"errors": ["denied"]})
+        manager: Final = _vault(monkeypatch, server.base_url)
+        rules: Final[Rules] = (SecretManagerRule(Rollout.RUST_OPT_OUT, systems=frozenset({"hashicorp_vault"})),)
+        with pytest.raises(ValueError, match="HashiCorp Vault"):
+            get_secret_from_manager(manager, "hashicorp_vault", "KEY", rules=rules)
+        assert len(server.requests) == 1
+
+
+@pytest.mark.parametrize("explicit_capture", (False, True))
+def test_config_capture_preserves_credentials_and_excludes_unrelated_environment(
+    monkeypatch: pytest.MonkeyPatch, explicit_capture: bool
+) -> None:
+    monkeypatch.setenv("AWS_ACCESS_KEY_ID", "initial-access")
+    monkeypatch.setenv("SECRET_MANAGER_REFRESH_INTERVAL", "45")
+    monkeypatch.setenv("UNRELATED_PRIVATE_TOKEN", "unrelated-secret")
+    manager: Final = AWSSecretsManagerV2(aws_region_name="us-east-1")
+    if explicit_capture:
+        capture_secret_manager(manager, "aws_secret_manager")
+        monkeypatch.setenv("AWS_ACCESS_KEY_ID", "replacement-access")
+    captured: Final = native_secret_manager_config(manager)
+    assert captured is not None
+    monkeypatch.setenv("AWS_ACCESS_KEY_ID", "replacement-access")
+
+    retained: Final = native_secret_manager_config(manager)
+
+    assert retained is captured
+    assert retained.system == "aws_secret_manager"
+    assert dict(retained.environment)["AWS_ACCESS_KEY_ID"] == "initial-access"
+    assert dict(retained.environment)["SECRET_MANAGER_REFRESH_INTERVAL"] == "45"
+    assert "UNRELATED_PRIVATE_TOKEN" not in dict(retained.environment)
+    assert "initial-access" not in repr(retained)
+    assert retained.settings == KeyManagementSettings().model_dump(mode="json")
+
+
+def test_kms_sdk_client_capture_preserves_environment(monkeypatch: pytest.MonkeyPatch) -> None:
+    import boto3
+
+    monkeypatch.setenv("AWS_REGION_NAME", "captured-region")
+    client: Final = boto3.client(
+        "kms", region_name="us-east-1", aws_access_key_id="access", aws_secret_access_key="secret"
+    )
+    try:
+        capture_secret_manager(client, "aws_kms")
+        monkeypatch.setenv("AWS_REGION_NAME", "replacement-region")
+
+        captured: Final = native_secret_manager_config(client)
+
+        assert captured is not None
+        assert captured.system == "aws_kms"
+        assert dict(captured.environment)["AWS_REGION_NAME"] == "captured-region"
+    finally:
+        client.close()
+
+
+def test_same_named_custom_client_is_not_captured() -> None:
+    class AWSSecretsManagerV2:
+        pass
+
+    client: Final = AWSSecretsManagerV2()
+    capture_secret_manager(client, "aws_secret_manager")
+
+    assert native_secret_manager_config(client) is None
+
+
+@dataclass(slots=True)
+class _RecordingRuntime:
+    system: str
+    result: str | None
+    calls: tuple[tuple[str, Mapping[str, object] | None], ...] = ()
+
+    def read_secret(self, name: str, settings: Mapping[str, object] | None = None) -> str | None:
+        self.calls = (*self.calls, (name, settings))
+        return self.result
+
+
+@pytest.mark.parametrize("value", (None, " value\n"))
+@pytest.mark.parametrize("settings", (None, KeyManagementSettings(primary_secret_name="primary")))
+def test_native_dispatch_forwards_settings_and_preserves_missing_or_unmodified_values(
+    value: str | None, settings: KeyManagementSettings | None
+) -> None:
+    client: Final = object()
+    runtime: Final = _RecordingRuntime("aws_secret_manager", value)
+
+    class Factory:
+        @staticmethod
+        def from_client(candidate: object) -> NativeSecretManagerRuntime:
+            assert candidate is client
+            return runtime
+
+    binding: Final[NativeBinding[NativeSecretManagerFactory]] = NativeBinding("unused", validate=lambda value: None)
+    binding.override(Factory)
+    rules: Final[Rules] = (SecretManagerRule(Rollout.RUST_REQUIRED, systems=frozenset({runtime.system})),)
+
+    result: Final = get_secret_from_manager(client, runtime.system, "KEY", settings, rules=rules, binding=binding)
+
+    assert result == value
+    assert runtime.calls == (("KEY", settings.model_dump(mode="json") if settings is not None else None),)
+
+
+def test_native_system_mismatch_is_rejected_before_reading() -> None:
+    runtime: Final = _RecordingRuntime("hashicorp_vault", "wrong-provider")
+
+    class Factory:
+        @staticmethod
+        def from_client(client: object) -> NativeSecretManagerRuntime:
+            return runtime
+
+    binding: Final[NativeBinding[NativeSecretManagerFactory]] = NativeBinding("unused", validate=lambda value: None)
+    binding.override(Factory)
+    rules: Final[Rules] = (SecretManagerRule(Rollout.RUST_REQUIRED, systems=frozenset({"aws_secret_manager"})),)
+
+    with pytest.raises(ValueError, match="system does not match"):
+        get_secret_from_manager(object(), "aws_secret_manager", "KEY", rules=rules, binding=binding)
+
+    assert runtime.calls == ()
+
+
+@pytest.mark.parametrize("system", ("custom", "local"))
+def test_python_only_manager_types_never_construct_a_native_backend(system: str) -> None:
+    class ForbiddenFactory:
+        @staticmethod
+        def from_client(client: object) -> NativeSecretManagerRuntime:
+            raise AssertionError("custom and local clients cannot use native backends")
+
+    binding: Final[NativeBinding[NativeSecretManagerFactory]] = NativeBinding("unused", validate=lambda value: None)
+    binding.override(ForbiddenFactory)
+    rules: Final[Rules] = (SecretManagerRule(Rollout.RUST_REQUIRED, systems=frozenset({system})),)
+
+    assert resolve_native_secret_manager(object(), system, rules, binding=binding) is None
+
+
+@pytest.mark.parametrize("factory", (None, SimpleNamespace(from_client="not callable")))
+def test_invalid_native_factories_are_reported_as_unavailable(monkeypatch: pytest.MonkeyPatch, factory: object) -> None:
+    monkeypatch.setattr(bindings, "get_native_bridge", lambda: SimpleNamespace(_SecretManagerRuntime=factory))
+    rules: Final[Rules] = (SecretManagerRule(Rollout.RUST_REQUIRED, systems=frozenset({"aws_secret_manager"})),)
+
+    with pytest.raises(RuntimeError, match="runtime is unavailable"):
+        resolve_native_secret_manager(object(), "aws_secret_manager", rules)
+
+
+def test_native_binding_accepts_a_callable_factory(monkeypatch: pytest.MonkeyPatch) -> None:
+    runtime: Final = _RecordingRuntime("aws_secret_manager", "value")
+
+    class Factory:
+        @staticmethod
+        def from_client(client: object) -> NativeSecretManagerRuntime:
+            return runtime
+
+    monkeypatch.setattr(bindings, "get_native_bridge", lambda: SimpleNamespace(_SecretManagerRuntime=Factory))
+    rules: Final[Rules] = (SecretManagerRule(Rollout.RUST_REQUIRED, systems=frozenset({runtime.system})),)
+
+    assert resolve_native_secret_manager(object(), runtime.system, rules) is runtime
+
+
+@pytest.mark.parametrize("value", ("text", "", True, False, 42, 2**100, [1, "two"], {"nested": True}, None))
+async def test_aws_primary_values_match_python_handler(monkeypatch: pytest.MonkeyPatch, value: JsonValue) -> None:
+    native: Final = pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.default_response = ResponseSpec(body={"SecretString": json.dumps({"KEY": value})})
+        server.expected_requests = 3
+        monkeypatch.setenv("AWS_ACCESS_KEY_ID", "test-access")
+        monkeypatch.setenv("AWS_SECRET_ACCESS_KEY", "test-secret")
+        monkeypatch.setenv("AWS_BEDROCK_RUNTIME_ENDPOINT", server.base_url)
+        manager: Final = AWSSecretsManagerV2(aws_region_name="us-east-1")
+        settings: Final = KeyManagementSettings(primary_secret_name="primary")
+        reference: Final = get_secret_from_manager(
+            manager, "aws_secret_manager", "KEY", settings, rules=(SecretManagerRule(Rollout.PYTHON_ONLY),)
+        )
+        actual: Final = get_secret_from_manager(
+            manager, "aws_secret_manager", "KEY", settings, rules=(SecretManagerRule(Rollout.RUST_REQUIRED),)
+        )
+        handle: Final = native._SecretManagerRuntime.from_client(manager)
+        assert handle is not None
+        asynchronous: Final = await handle.read_secret_async("KEY", settings.model_dump(mode="json"))
+        assert type(actual) is type(reference) is type(value)
+        assert actual == reference == value
+        assert type(asynchronous) is type(reference)
+        assert asynchronous == reference
+        assert tuple(json.loads(request.raw_body) for request in server.requests) == ({"SecretId": "primary"},) * 3
+
+
+@pytest.mark.parametrize("primary", (None, "primary"))
+@pytest.mark.parametrize(
+    ("status", "body"),
+    (
+        (400, {"__type": "ResourceNotFoundException"}),
+        (403, {"__type": "AccessDeniedException"}),
+        (500, {"__type": "InternalServiceError"}),
+        (200, {"Name": "without-string"}),
+        (200, {"SecretString": ""}),
+    ),
+)
+def test_aws_absence_and_failed_reads_match_python_without_environment_fallback(
+    monkeypatch: pytest.MonkeyPatch, primary: str | None, status: int, body: dict[str, str]
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.default_response = ResponseSpec(status=status, body=body)
+        server.expected_requests = 2
+        monkeypatch.setenv("AWS_ACCESS_KEY_ID", "test-access")
+        monkeypatch.setenv("AWS_SECRET_ACCESS_KEY", "test-secret")
+        monkeypatch.setenv("AWS_BEDROCK_RUNTIME_ENDPOINT", server.base_url)
+        monkeypatch.setenv("KEY", "must-not-fall-back")
+        manager: Final = AWSSecretsManagerV2(aws_region_name="us-east-1")
+        settings: Final = KeyManagementSettings(primary_secret_name=primary)
+        monkeypatch.setattr(litellm, "secret_manager_client", manager)
+        monkeypatch.setattr(litellm, "_key_management_system", KeyManagementSystem.AWS_SECRET_MANAGER)
+        monkeypatch.setattr(litellm, "_key_management_settings", settings)
+        main: Final = import_module("litellm.secret_managers.main")
+        monkeypatch.setattr(
+            main,
+            "get_secret_from_manager",
+            partial(get_secret_from_manager, rules=(SecretManagerRule(Rollout.PYTHON_ONLY),)),
+        )
+        reference: Final = litellm.get_secret("KEY", "must-not-default")
+        monkeypatch.setattr(
+            main,
+            "get_secret_from_manager",
+            partial(get_secret_from_manager, rules=(SecretManagerRule(Rollout.RUST_REQUIRED),)),
+        )
+        actual: Final = litellm.get_secret("KEY", "must-not-default")
+        assert actual == reference
+        assert actual == ("" if primary is None and body.get("SecretString") == "" else None)
+
+
+@pytest.mark.parametrize("document", ("{", "not-json", "[1]", "null", "true", "42", '"text"'))
+async def test_aws_primary_json_errors_preserve_python_exception_details(
+    monkeypatch: pytest.MonkeyPatch, document: str
+) -> None:
+    native: Final = pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.default_response = ResponseSpec(body={"SecretString": document})
+        server.expected_requests = 3
+        monkeypatch.setenv("AWS_ACCESS_KEY_ID", "test-access")
+        monkeypatch.setenv("AWS_SECRET_ACCESS_KEY", "test-secret")
+        monkeypatch.setenv("AWS_BEDROCK_RUNTIME_ENDPOINT", server.base_url)
+        manager: Final = AWSSecretsManagerV2(aws_region_name="us-east-1")
+        settings: Final = KeyManagementSettings(primary_secret_name="primary")
+        with pytest.raises((json.JSONDecodeError, AttributeError)) as reference:
+            get_secret_from_manager(
+                manager, "aws_secret_manager", "KEY", settings, rules=(SecretManagerRule(Rollout.PYTHON_ONLY),)
+            )
+        with pytest.raises(type(reference.value)) as actual:
+            get_secret_from_manager(
+                manager, "aws_secret_manager", "KEY", settings, rules=(SecretManagerRule(Rollout.RUST_REQUIRED),)
+            )
+        assert actual.value.args == reference.value.args
+        if isinstance(reference.value, json.JSONDecodeError):
+            assert isinstance(actual.value, json.JSONDecodeError)
+            assert (actual.value.doc, actual.value.pos) == (reference.value.doc, reference.value.pos)
+        handle: Final = native._SecretManagerRuntime.from_client(manager)
+        assert handle is not None
+        with pytest.raises(type(reference.value)) as asynchronous:
+            await handle.read_secret_async("KEY", settings.model_dump(mode="json"))
+        assert asynchronous.value.args == reference.value.args
+
+
+def _select_provider_reads(monkeypatch: pytest.MonkeyPatch, module_name: str, rollout: Rollout) -> None:
+    module: Final = import_module(module_name)
+    monkeypatch.setattr(
+        module,
+        "resolve_native_provider_reader",
+        partial(resolve_native_provider_reader, rules=(SecretManagerRule(rollout),)),
+    )
+    if rollout is Rollout.RUST_REQUIRED:
+        monkeypatch.setattr(module, "_get_httpx_client", _forbid_python_http)
+        monkeypatch.setattr(module, "get_async_httpx_client", _forbid_python_http)
+
+
+def _forbid_python_http(*args: object, **kwargs: object) -> Never:
+    raise AssertionError("native reads must not construct a Python HTTP client")
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+async def test_public_aws_reads_preserve_coroutines_and_per_call_credentials(
+    monkeypatch: pytest.MonkeyPatch, rollout: Rollout
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as initial, recording_service() as selected:
+        initial.expected_requests = 0
+        selected.expected_requests = 2
+        selected.default_response = ResponseSpec(body={"SecretString": "value"})
+        monkeypatch.setenv("AWS_ACCESS_KEY_ID", "environment-access")
+        monkeypatch.setenv("AWS_SECRET_ACCESS_KEY", "environment-secret")
+        monkeypatch.setenv("AWS_BEDROCK_RUNTIME_ENDPOINT", initial.base_url)
+        manager: Final = AWSSecretsManagerV2(aws_region_name="us-east-1")
+        _select_provider_reads(monkeypatch, "litellm.secret_managers.aws_secret_manager_v2", rollout)
+        options: Final = {
+            "aws_region_name": "us-west-2",
+            "aws_bedrock_runtime_endpoint": selected.base_url,
+            "aws_access_key_id": "operation-access",
+            "aws_secret_access_key": "operation-secret",
+            "aws_session_token": "operation-session",
+        }
+        pending: Final = manager.async_read_secret(secret_name="KEY", optional_params=dict(options), timeout=2)
+        assert inspect.iscoroutine(pending)
+        assert selected.requests == []
+        assert await asyncio.create_task(pending) == "value"
+        assert manager.sync_read_secret("KEY", dict(options), 2) == "value"
+        assert tuple(json.loads(request.raw_body) for request in selected.requests) == ({"SecretId": "KEY"},) * 2
+        assert all(
+            "Credential=operation-access/" in request.headers["authorization"]
+            and "/us-west-2/" in request.headers["authorization"]
+            and request.headers["x-amz-security-token"] == "operation-session"
+            for request in selected.requests
+        )
+        for request in selected.requests:
+            signed_headers: Final = request.headers["authorization"].split("SignedHeaders=")[1].split(",")[0].split(";")
+            signed_request: Final = AWSRequest(
+                method=request.method,
+                url=selected.base_url + request.path,
+                data=request.raw_body,
+                headers={name: request.headers[name] for name in signed_headers},
+            )
+            signed_request.context["timestamp"] = request.headers["x-amz-date"]
+            signer: Final = SigV4Auth(
+                Credentials(
+                    options["aws_access_key_id"], options["aws_secret_access_key"], options["aws_session_token"]
+                ),
+                "secretsmanager",
+                options["aws_region_name"],
+            )
+            string_to_sign: Final = signer.string_to_sign(signed_request, signer.canonical_request(signed_request))
+            assert request.headers["authorization"].split("Signature=")[1] == signer.signature(
+                string_to_sign, signed_request
+            )
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+async def test_public_aws_primary_reads_ignore_operation_overrides_like_python(
+    monkeypatch: pytest.MonkeyPatch, rollout: Rollout
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server, recording_service() as unused:
+        server.default_response = ResponseSpec(body={"SecretString": '{"KEY":true}'})
+        server.expected_requests = 2
+        unused.expected_requests = 0
+        monkeypatch.setenv("AWS_ACCESS_KEY_ID", "test-access")
+        monkeypatch.setenv("AWS_SECRET_ACCESS_KEY", "test-secret")
+        monkeypatch.setenv("AWS_BEDROCK_RUNTIME_ENDPOINT", server.base_url)
+        manager: Final = AWSSecretsManagerV2(aws_region_name="us-east-1")
+        _select_provider_reads(monkeypatch, "litellm.secret_managers.aws_secret_manager_v2", rollout)
+        options: Final = {"aws_bedrock_runtime_endpoint": unused.base_url}
+        assert manager.sync_read_secret("KEY", options, 0, "primary") is True
+        assert (
+            await manager.async_read_secret("KEY", optional_params=options, timeout=0, primary_secret_name="primary")
+            is True
+        )
+        assert tuple(json.loads(request.raw_body) for request in server.requests) == ({"SecretId": "primary"},) * 2
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+async def test_public_aws_bootstrap_names_only_bypass_sync_reads(
+    monkeypatch: pytest.MonkeyPatch, rollout: Rollout
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.default_response = ResponseSpec(body={"SecretString": "remote-access"})
+        server.expected_requests = 1
+        monkeypatch.setenv("AWS_ACCESS_KEY_ID", "environment-access")
+        monkeypatch.setenv("AWS_SECRET_ACCESS_KEY", "environment-secret")
+        monkeypatch.setenv("AWS_BEDROCK_RUNTIME_ENDPOINT", server.base_url)
+        manager: Final = AWSSecretsManagerV2(aws_region_name="us-east-1")
+        _select_provider_reads(monkeypatch, "litellm.secret_managers.aws_secret_manager_v2", rollout)
+        assert manager.sync_read_secret("AWS_ACCESS_KEY_ID") == "environment-access"
+        assert server.requests == []
+        assert await manager.async_read_secret("AWS_ACCESS_KEY_ID") == "remote-access"
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+@pytest.mark.parametrize("timeout", (0.05, httpx.Timeout(1, read=0.05)))
+async def test_public_aws_read_timeouts_follow_the_python_http_handler(
+    monkeypatch: pytest.MonkeyPatch, rollout: Rollout, timeout: float | httpx.Timeout
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.default_response = ResponseSpec(body={"SecretString": "too-late"}, delay=0.25)
+        server.expected_requests = 2
+        monkeypatch.setenv("AWS_ACCESS_KEY_ID", "test-access")
+        monkeypatch.setenv("AWS_SECRET_ACCESS_KEY", "test-secret")
+        monkeypatch.setenv("AWS_BEDROCK_RUNTIME_ENDPOINT", server.base_url)
+        manager: Final = AWSSecretsManagerV2(aws_region_name="us-east-1")
+        _select_provider_reads(monkeypatch, "litellm.secret_managers.aws_secret_manager_v2", rollout)
+        assert manager.sync_read_secret("KEY", timeout=timeout) is None
+        assert await manager.async_read_secret("KEY", timeout=timeout) is None
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+async def test_public_vault_reads_keep_overrides_cache_and_coroutines(
+    monkeypatch: pytest.MonkeyPatch, rollout: Rollout
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.default_response = ResponseSpec(body=_vault_body("value"))
+        server.expected_requests = 2
+        manager: Final = _vault(monkeypatch, server.base_url)
+        _select_provider_reads(monkeypatch, "litellm.secret_managers.hashicorp_secret_manager", rollout)
+        options: Final = {"secret_manager_settings": {"mount": "team", "path_prefix": "keys", "data": "key"}}
+        pending: Final = manager.async_read_secret("KEY", options)
+        assert inspect.iscoroutine(pending)
+        assert server.requests == []
+        assert await asyncio.create_task(pending) == "value"
+        assert manager.sync_read_secret(secret_name="KEY", optional_params=options) == "value"
+        assert manager.sync_read_secret("KEY") == "value"
+        assert urlsplit(server.requests[0].path).path == "/v1/team/data/keys/KEY"
+        assert urlsplit(server.requests[1].path).path == "/v1/secret/data/KEY"
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+@pytest.mark.parametrize("status", (404, 403))
+async def test_public_vault_failed_reads_return_none_without_replay(
+    monkeypatch: pytest.MonkeyPatch, rollout: Rollout, status: int
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.default_response = ResponseSpec(status=status, body={"errors": ["unavailable"]})
+        server.expected_requests = 2
+        manager: Final = _vault(monkeypatch, server.base_url)
+        _select_provider_reads(monkeypatch, "litellm.secret_managers.hashicorp_secret_manager", rollout)
+        assert manager.sync_read_secret("KEY") is None
+        assert await manager.async_read_secret("KEY") is None
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+async def test_public_cyberark_reads_reuse_authentication_and_cached_values(
+    monkeypatch: pytest.MonkeyPatch, rollout: Rollout
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    from litellm.proxy import proxy_server
+    from litellm.secret_managers.cyberark_secret_manager import CyberArkSecretManager
+
+    monkeypatch.setattr(proxy_server, "premium_user", True)
+    with recording_service() as server:
+        server.enqueue(ResponseSpec(body="authentication-token"))
+        server.default_response = ResponseSpec(body="secret-value")
+        server.expected_requests = 2
+        monkeypatch.setenv("CYBERARK_API_BASE", server.base_url)
+        monkeypatch.setenv("CYBERARK_API_KEY", "api-key")
+        monkeypatch.setenv("CYBERARK_ACCOUNT", "account")
+        monkeypatch.setenv("CYBERARK_USERNAME", "reader")
+        manager: Final = CyberArkSecretManager()
+        _select_provider_reads(monkeypatch, "litellm.secret_managers.cyberark_secret_manager", rollout)
+        pending: Final = manager.async_read_secret(secret_name="KEY", timeout=0)
+        assert inspect.iscoroutine(pending)
+        assert server.requests == []
+        assert await asyncio.create_task(pending) == '"secret-value"'
+        assert manager.sync_read_secret("KEY", timeout=0) == (
+            '"secret-value"' if rollout is Rollout.RUST_REQUIRED else "secret-value"
+        )
+        assert tuple(request.path for request in server.requests) == (
+            "/authn/account/reader/authenticate",
+            "/secrets/account/variable/KEY",
+        )
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+async def test_public_native_selection_and_missing_extension_keep_the_python_method(
+    monkeypatch: pytest.MonkeyPatch, rollout: Rollout
+) -> None:
+    binding: Final[NativeBinding[NativeSecretManagerFactory]] = NativeBinding("unused", validate=lambda value: None)
+    binding.override(None)
+    module: Final = import_module("litellm.secret_managers.aws_secret_manager_v2")
+    monkeypatch.setattr(
+        module,
+        "resolve_native_provider_reader",
+        partial(resolve_native_provider_reader, rules=(SecretManagerRule(rollout),), binding=binding),
+    )
+    with recording_service() as server:
+        server.default_response = ResponseSpec(body={"SecretString": "python-value"})
+        server.expected_requests = 0 if rollout is Rollout.RUST_REQUIRED else 1
+        monkeypatch.setenv("AWS_ACCESS_KEY_ID", "test-access")
+        monkeypatch.setenv("AWS_SECRET_ACCESS_KEY", "test-secret")
+        monkeypatch.setenv("AWS_BEDROCK_RUNTIME_ENDPOINT", server.base_url)
+        manager: Final = AWSSecretsManagerV2(aws_region_name="us-east-1")
+        pending: Final = manager.async_read_secret("KEY")
+        if rollout is Rollout.RUST_REQUIRED:
+            with pytest.raises(RuntimeError, match="runtime is unavailable"):
+                await pending
+        else:
+            assert await pending == "python-value"
+
+
+def test_public_aws_bootstrap_read_does_not_initialize_a_backend(monkeypatch: pytest.MonkeyPatch) -> None:
+    module: Final = import_module("litellm.secret_managers.aws_secret_manager_v2")
+    monkeypatch.setattr(module, "resolve_native_provider_reader", _forbid_python_http)
+    monkeypatch.setenv("AWS_ACCESS_KEY_ID", "bootstrap-value")
+    assert AWSSecretsManagerV2().sync_read_secret("AWS_ACCESS_KEY_ID") == "bootstrap-value"
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+@pytest.mark.parametrize("override", ("", 42))
+def test_public_vault_prefix_overrides_match_python_string_conversion(
+    monkeypatch: pytest.MonkeyPatch, rollout: Rollout, override: str | int
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    monkeypatch.setenv("HCP_VAULT_PATH_PREFIX", "default-prefix")
+    with recording_service() as server:
+        server.default_response = ResponseSpec(body=_vault_body("value"))
+        server.expected_requests = 1
+        manager: Final = _vault(monkeypatch, server.base_url)
+        _select_provider_reads(monkeypatch, "litellm.secret_managers.hashicorp_secret_manager", rollout)
+        assert manager.sync_read_secret("KEY", {"path_prefix": override}) == "value"
+        assert urlsplit(server.requests[0].path).path == (
+            f"/v1/secret/data/{override}/KEY" if override else "/v1/secret/data/KEY"
+        )
+
+
+@pytest.mark.parametrize("value", ("native-value", None))
+def test_public_google_reader_uses_the_selected_binding_without_replaying_python(
+    monkeypatch: pytest.MonkeyPatch, value: str | None
+) -> None:
+    from litellm.proxy import proxy_server
+    from litellm.secret_managers.google_secret_manager import GoogleSecretManager
+
+    class Manager(GoogleSecretManager):
+        def sync_construct_request_headers(self) -> dict[str, str]:
+            raise AssertionError("selected native reads must not construct Python auth headers")
+
+    class Reader(_RecordingRuntime):
+        def sync_read_secret(
+            self,
+            secret_name: str,
+            optional_params: Mapping[str, object] | None = None,
+            timeout: float | httpx.Timeout | None = None,
+        ) -> str | None:
+            return self.read_secret(secret_name)
+
+        async def async_read_secret(
+            self,
+            secret_name: str,
+            optional_params: Mapping[str, object] | None = None,
+            timeout: float | httpx.Timeout | None = None,
+        ) -> str | None:
+            return self.sync_read_secret(secret_name)
+
+    monkeypatch.setattr(proxy_server, "premium_user", True)
+    monkeypatch.setenv("GOOGLE_SECRET_MANAGER_PROJECT_ID", "project")
+    manager: Final = Manager()
+    runtime: Final = Reader("google_secret_manager", value)
+
+    class Factory:
+        @staticmethod
+        def from_client(candidate: object) -> NativeSecretManagerRuntime:
+            assert candidate is manager
+            return runtime
+
+    binding: Final[NativeBinding[NativeSecretManagerFactory]] = NativeBinding("unused", validate=lambda value: None)
+    binding.override(Factory)
+    module: Final = import_module("litellm.secret_managers.google_secret_manager")
+    monkeypatch.setattr(
+        module,
+        "resolve_native_provider_reader",
+        partial(resolve_native_provider_reader, rules=(SecretManagerRule(Rollout.RUST_REQUIRED),), binding=binding),
+    )
+    assert manager.get_secret_from_google_secret_manager(secret_name="KEY") == value
+    assert runtime.calls == (("KEY", None),)
+
+
+def _cyberark(monkeypatch: pytest.MonkeyPatch, address: str) -> CyberArkSecretManager:
+    from litellm.proxy import proxy_server
+
+    monkeypatch.setattr(proxy_server, "premium_user", True)
+    monkeypatch.setenv("CYBERARK_API_BASE", address)
+    monkeypatch.setenv("CYBERARK_API_KEY", "api-key")
+    monkeypatch.setenv("CYBERARK_ACCOUNT", "account")
+    monkeypatch.setenv("CYBERARK_USERNAME", "reader")
+    return CyberArkSecretManager()
+
+
+def _select_cyberark_mutations(monkeypatch: pytest.MonkeyPatch, rollout: Rollout) -> None:
+    module: Final = import_module("litellm.secret_managers.cyberark_secret_manager")
+    _select_provider_reads(monkeypatch, module.__name__, rollout)
+    monkeypatch.setattr(
+        module,
+        "resolve_native_provider_writer",
+        partial(resolve_native_provider_writer, rules=(SecretManagerRule(rollout),)),
+    )
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+async def test_public_cyberark_writes_and_deletes_share_the_read_cache(
+    monkeypatch: pytest.MonkeyPatch,
+    rollout: Rollout,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        for body in (b"token", b"old", {}, {}, b"provider-after-delete"):
+            server.enqueue(ResponseSpec(body=body))
+        server.expected_requests = 5
+        manager: Final = _cyberark(monkeypatch, server.base_url)
+        _select_cyberark_mutations(monkeypatch, rollout)
+        assert manager.sync_read_secret("KEY") == "old"
+        pending: Final = manager.async_write_secret(
+            "KEY",
+            "new-value",
+            "ignored",
+            {"ignored": object()},
+            0,
+            {"ignored": object()},
+        )
+        assert inspect.iscoroutine(pending)
+        assert len(server.requests) == 2
+        assert await asyncio.create_task(pending) == {
+            "status": "success",
+            "message": "Secret KEY written successfully",
+        }
+        assert manager.sync_read_secret("KEY") == "new-value"
+        assert await manager.async_read_secret("KEY") == "new-value"
+        assert len(server.requests) == 4
+        assert await manager.async_delete_secret(secret_name="KEY", recovery_window_in_days=None, timeout=0) == {
+            "status": "not_supported",
+            "message": "CyberArk Conjur does not support direct secret deletion. Use policy updates to remove variables.",
+        }
+        assert len(server.requests) == 4
+        assert manager.sync_read_secret("KEY") == "provider-after-delete"
+        assert tuple(request.path for request in server.requests) == (
+            "/authn/account/reader/authenticate",
+            "/secrets/account/variable/KEY",
+            "/policies/account/policy/root",
+            "/secrets/account/variable/KEY",
+            "/secrets/account/variable/KEY",
+        )
+        assert server.requests[3].raw_body == b"new-value"
+
+
+@pytest.mark.parametrize("status", (401, 403, 500))
+@pytest.mark.parametrize("authentication", (False, True))
+async def test_public_cyberark_write_errors_match_python_without_http_retries(
+    monkeypatch: pytest.MonkeyPatch,
+    status: int,
+    authentication: bool,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        responses: Final = (
+            (ResponseSpec(status=status, body={}),) * 2
+            if authentication
+            else (
+                ResponseSpec(body=b"token"),
+                ResponseSpec(body={}),
+                ResponseSpec(status=status, body={}),
+            )
+        )
+        for response in responses * 2:
+            server.enqueue(response)
+        server.expected_requests = len(responses) * 2
+        reference_manager: Final = _cyberark(monkeypatch, server.base_url)
+        _select_cyberark_mutations(monkeypatch, Rollout.PYTHON_ONLY)
+        reference: Final = await reference_manager.async_write_secret("KEY", "value")
+        native_manager: Final = _cyberark(monkeypatch, server.base_url)
+        _select_cyberark_mutations(monkeypatch, Rollout.RUST_REQUIRED)
+        actual: Final = await native_manager.async_write_secret("KEY", "value")
+        assert actual == reference
+        assert tuple(actual) == tuple(reference)
+        assert actual["status"] == "error"
+        assert str(status) in actual["message"]
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+async def test_public_cyberark_write_recovers_from_initial_policy_authentication_failure(
+    monkeypatch: pytest.MonkeyPatch,
+    rollout: Rollout,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.enqueue(ResponseSpec(status=401, body={}))
+        server.enqueue(ResponseSpec(body=b"token"))
+        server.enqueue(ResponseSpec(body={}))
+        server.expected_requests = 3
+        manager: Final = _cyberark(monkeypatch, server.base_url)
+        _select_cyberark_mutations(monkeypatch, rollout)
+        assert await manager.async_write_secret("KEY", "value") == {
+            "status": "success",
+            "message": "Secret KEY written successfully",
+        }
+        assert tuple(request.path for request in server.requests) == (
+            "/authn/account/reader/authenticate",
+            "/authn/account/reader/authenticate",
+            "/secrets/account/variable/KEY",
+        )
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+@pytest.mark.parametrize("name", ("../KEY", "line\nKEY", "a\u2028b"))
+async def test_public_cyberark_write_rejects_unsafe_names_before_authentication(
+    monkeypatch: pytest.MonkeyPatch,
+    rollout: Rollout,
+    name: str,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.expected_requests = 0
+        manager: Final = _cyberark(monkeypatch, server.base_url)
+        _select_cyberark_mutations(monkeypatch, rollout)
+        assert await manager.async_write_secret(name, "value") == {
+            "status": "error",
+            "message": f"Invalid secret_name {name!r}",
+        }
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+@pytest.mark.parametrize("same_name", (False, True))
+async def test_public_cyberark_rotation_returns_the_write_response_and_retains_old_alias(
+    monkeypatch: pytest.MonkeyPatch,
+    rollout: Rollout,
+    same_name: bool,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        for body in (b"token", b"old-value", {}, {}):
+            server.enqueue(ResponseSpec(body=body))
+        if rollout is Rollout.RUST_REQUIRED:
+            server.enqueue(ResponseSpec(body=b"new-value"))
+        server.expected_requests = 5 if rollout is Rollout.RUST_REQUIRED else 4
+        manager: Final = _cyberark(monkeypatch, server.base_url)
+        _select_cyberark_mutations(monkeypatch, rollout)
+        new_name: Final = "OLD" if same_name else "NEW"
+        pending: Final = manager.async_rotate_secret("OLD", new_name, "new-value", {"ignored": object()}, 0)
+        assert inspect.iscoroutine(pending)
+        assert server.requests == []
+        assert await asyncio.create_task(pending) == {
+            "status": "success",
+            "message": f"Secret {new_name} written successfully",
+        }
+        assert tuple(request.method for request in server.requests) == (
+            ("POST", "GET", "POST", "POST", "GET")
+            if rollout is Rollout.RUST_REQUIRED
+            else ("POST", "GET", "POST", "POST")
+        )
+        assert server.requests[3].raw_body == b"new-value"
+
+
+@pytest.mark.parametrize("replacement", (None, b"wrong-value"))
+async def test_public_cyberark_rotation_requires_a_fresh_matching_replacement(
+    monkeypatch: pytest.MonkeyPatch,
+    replacement: bytes | None,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        for body in (b"token", b"old-value", {}, {}):
+            server.enqueue(ResponseSpec(body=body))
+        server.enqueue(ResponseSpec(status=404 if replacement is None else 200, body=replacement))
+        server.expected_requests = 5
+        manager: Final = _cyberark(monkeypatch, server.base_url)
+        _select_cyberark_mutations(monkeypatch, Rollout.RUST_REQUIRED)
+        message: Final = "Failed to verify new secret NEW" if replacement is None else "New secret value mismatch"
+        with pytest.raises(ValueError, match=message):
+            await manager.async_rotate_secret("OLD", "NEW", "new-value")
+        assert manager.sync_read_secret("OLD") == "old-value"
+        assert tuple(request.path for request in server.requests) == (
+            "/authn/account/reader/authenticate",
+            "/secrets/account/variable/OLD",
+            "/policies/account/policy/root",
+            "/secrets/account/variable/NEW",
+            "/secrets/account/variable/NEW",
+        )
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+async def test_public_cyberark_cached_authentication_does_not_retry_denied_reads(
+    monkeypatch: pytest.MonkeyPatch,
+    rollout: Rollout,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.enqueue(ResponseSpec(body=b"token"))
+        server.enqueue(ResponseSpec(body=b"value"))
+        server.enqueue(ResponseSpec(status=401, body={}))
+        server.expected_requests = 3
+        manager: Final = _cyberark(monkeypatch, server.base_url)
+        _select_cyberark_mutations(monkeypatch, rollout)
+        assert manager.sync_read_secret("OLD") == "value"
+        assert await manager.async_read_secret("NEW") is None
+
+
+async def test_cyberark_handler_errors_match_python_after_cached_authentication_is_denied(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        for response in (
+            ResponseSpec(body=b"token"),
+            ResponseSpec(body=b"value"),
+            ResponseSpec(status=401, body={}),
+        ) * 2:
+            server.enqueue(response)
+        server.expected_requests = 6
+        reference_manager: Final = _cyberark(monkeypatch, server.base_url)
+        python_rules: Final = (SecretManagerRule(Rollout.PYTHON_ONLY),)
+        native_rules: Final = (SecretManagerRule(Rollout.RUST_REQUIRED),)
+        assert get_secret_from_manager(reference_manager, "cyberark", "OLD", rules=python_rules) == "value"
+        with pytest.raises(ValueError, match="No secret found in CyberArk Secret Manager for NEW") as reference:
+            get_secret_from_manager(reference_manager, "cyberark", "NEW", rules=python_rules)
+        native_manager: Final = _cyberark(monkeypatch, server.base_url)
+        _select_cyberark_mutations(monkeypatch, Rollout.RUST_REQUIRED)
+        assert get_secret_from_manager(native_manager, "cyberark", "OLD", rules=native_rules) == "value"
+        with pytest.raises(ValueError, match="No secret found in CyberArk Secret Manager for NEW") as actual:
+            get_secret_from_manager(native_manager, "cyberark", "NEW", rules=native_rules)
+        assert actual.value.args == reference.value.args
+
+
+async def test_public_cyberark_connection_errors_match_python(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.expected_requests = 0
+        address: Final = server.base_url
+    reference_manager: Final = _cyberark(monkeypatch, address)
+    _select_cyberark_mutations(monkeypatch, Rollout.PYTHON_ONLY)
+    reference: Final = await reference_manager.async_write_secret("KEY", "value")
+    native_manager: Final = _cyberark(monkeypatch, address)
+    _select_cyberark_mutations(monkeypatch, Rollout.RUST_REQUIRED)
+    actual: Final = await native_manager.async_write_secret("KEY", "value")
+    assert actual == reference
+    assert actual["status"] == "error"
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+@pytest.mark.parametrize("operation", ("write", "delete", "rotate"))
+async def test_public_cyberark_mutations_preserve_missing_extension_selection(
+    monkeypatch: pytest.MonkeyPatch,
+    rollout: Rollout,
+    operation: str,
+) -> None:
+    binding: Final[NativeBinding[NativeSecretManagerFactory]] = NativeBinding("unused", validate=lambda value: None)
+    binding.override(None)
+    module: Final = import_module("litellm.secret_managers.cyberark_secret_manager")
+    _select_provider_reads(monkeypatch, module.__name__, Rollout.PYTHON_ONLY)
+    monkeypatch.setattr(
+        module,
+        "resolve_native_provider_writer",
+        partial(resolve_native_provider_writer, rules=(SecretManagerRule(rollout),), binding=binding),
+    )
+    with recording_service() as server:
+        bodies: Final = (
+            ()
+            if rollout is Rollout.RUST_REQUIRED or operation == "delete"
+            else ((b"token", b"old", {}, {}) if operation == "rotate" else (b"token", {}, {}))
+        )
+        for body in bodies:
+            server.enqueue(ResponseSpec(body=body))
+        server.expected_requests = len(bodies)
+        manager: Final = _cyberark(monkeypatch, server.base_url)
+        call: Final = {
+            "write": partial(manager.async_write_secret, "KEY", "value"),
+            "delete": partial(manager.async_delete_secret, "KEY"),
+            "rotate": partial(manager.async_rotate_secret, "OLD", "NEW", "value"),
+        }[operation]
+        pending: Final = call()
+        assert inspect.iscoroutine(pending)
+        assert server.requests == []
+        if rollout is Rollout.RUST_REQUIRED:
+            with pytest.raises(RuntimeError, match="runtime is unavailable"):
+                await pending
+        else:
+            result: Final = await pending
+            assert result["status"] == ("not_supported" if operation == "delete" else "success")
+
+
+async def test_public_cyberark_rotation_stops_after_a_failed_write(monkeypatch: pytest.MonkeyPatch) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        for body in (b"token", b"old-value", {}):
+            server.enqueue(ResponseSpec(body=body))
+        server.enqueue(ResponseSpec(status=401, body={}))
+        server.expected_requests = 4
+        manager: Final = _cyberark(monkeypatch, server.base_url)
+        _select_cyberark_mutations(monkeypatch, Rollout.RUST_REQUIRED)
+        response: Final = await manager.async_rotate_secret("OLD", "NEW", "new-value")
+        assert response["status"] == "error"
+        assert "401" in response["message"]
+        assert manager.sync_read_secret("OLD") == "old-value"
+        assert tuple(request.method for request in server.requests) == ("POST", "GET", "POST", "POST")
+
+
+def _select_vault_mutations(monkeypatch: pytest.MonkeyPatch, rollout: Rollout) -> None:
+    module: Final = import_module("litellm.secret_managers.hashicorp_secret_manager")
+    _select_provider_reads(monkeypatch, module.__name__, rollout)
+    monkeypatch.setattr(
+        module,
+        "resolve_native_provider_writer",
+        partial(resolve_native_provider_writer, rules=(SecretManagerRule(rollout),)),
+    )
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+@pytest.mark.parametrize("description", (None, "", "purpose"))
+async def test_public_vault_writes_preserve_complete_responses_and_request_fields(
+    monkeypatch: pytest.MonkeyPatch,
+    rollout: Rollout,
+    description: str | None,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        response: Final = {
+            "request_id": "test-request",
+            "data": {"version": 2, "custom_metadata": {"large": 2**100}},
+            "warnings": ["test-warning"],
+            "unknown_field": {"nested": [None, True, ""]},
+        }
+        server.enqueue(ResponseSpec(body=response))
+        server.expected_requests = 1
+        manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, rollout)
+        options: Final = {
+            "secret_manager_settings": {"namespace": "team", "mount": "kv", "path_prefix": "app", "data": "token"}
+        }
+        pending: Final = manager.async_write_secret("KEY", "value", description, options, 2, {"ignored": object()})
+        assert inspect.iscoroutine(pending)
+        assert server.requests == []
+        result: Final = await asyncio.create_task(pending)
+        assert result == response
+        assert tuple(result) == tuple(response)
+        request: Final = server.requests[0]
+        assert request.method == "POST"
+        assert request.headers["x-vault-token"] == "token"
+        namespace: Final = request.headers.get("x-vault-namespace")
+        assert request.path == ("/v1/kv/data/app/KEY" if namespace else "/v1/team/kv/data/app/KEY")
+        assert namespace in (None, "team")
+        assert json.loads(request.raw_body) == {
+            "data": {"token": "value", **({"description": description} if description else {})},
+        }
+        assert options == {
+            "secret_manager_settings": {"namespace": "team", "mount": "kv", "path_prefix": "app", "data": "token"}
+        }
+
+
+@pytest.mark.parametrize("operation", ("write", "delete"))
+@pytest.mark.parametrize("status", (400, 403, 500))
+async def test_public_vault_mutation_http_errors_match_python_without_retry(
+    monkeypatch: pytest.MonkeyPatch,
+    operation: str,
+    status: int,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.default_response = ResponseSpec(status=status, body={"errors": ["denied"]})
+        server.expected_requests = 2
+        options: Final = {"namespace": "team", "mount": "kv", "path_prefix": "prefix"}
+        reference_manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.PYTHON_ONLY)
+        reference: Final = (
+            await reference_manager.async_write_secret("KEY", "value", optional_params=options)
+            if operation == "write"
+            else await reference_manager.async_delete_secret("KEY", optional_params=options)
+        )
+        native_manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.RUST_REQUIRED)
+        actual: Final = (
+            await native_manager.async_write_secret("KEY", "value", optional_params=options)
+            if operation == "write"
+            else await native_manager.async_delete_secret("KEY", optional_params=options)
+        )
+        assert actual == reference
+        assert tuple(actual) == tuple(reference)
+        assert actual["status"] == "error"
+        assert str(status) in actual["message"]
+
+
+@pytest.mark.parametrize("body", (b"{", b"", b"null", b"[1,2]", b'{"large":1267650600228229401496703205376}'))
+async def test_public_vault_write_response_conversion_matches_python(
+    monkeypatch: pytest.MonkeyPatch,
+    body: bytes,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.default_response = ResponseSpec(body=body)
+        server.expected_requests = 2
+        reference_manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.PYTHON_ONLY)
+        reference: Final = await reference_manager.async_write_secret("KEY", "value")
+        native_manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.RUST_REQUIRED)
+        actual: Final = await native_manager.async_write_secret("KEY", "value")
+        assert type(actual) is type(reference)
+        assert actual == reference
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+async def test_public_vault_deletion_invalidates_cached_fields(
+    monkeypatch: pytest.MonkeyPatch,
+    rollout: Rollout,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.enqueue(ResponseSpec(body=_vault_body("old")))
+        server.enqueue(ResponseSpec(status=204, body=b""))
+        server.enqueue(ResponseSpec(body=_vault_body("after-delete")))
+        server.expected_requests = 3
+        manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, rollout)
+        assert manager.sync_read_secret("KEY") == "old"
+        pending: Final = manager.async_delete_secret("KEY", None, {"ignored": object()}, 2)
+        assert inspect.iscoroutine(pending)
+        assert len(server.requests) == 1
+        assert await asyncio.create_task(pending) == {"status": "success", "message": "Secret KEY deleted successfully"}
+        assert await manager.async_read_secret("KEY") == "after-delete"
+        assert tuple(request.method for request in server.requests) == ("GET", "DELETE", "GET")
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+@pytest.mark.parametrize("same_name", (False, True))
+@pytest.mark.parametrize("delete_status", (204, 403))
+async def test_public_vault_rotation_preserves_response_and_best_effort_deletion(
+    monkeypatch: pytest.MonkeyPatch,
+    rollout: Rollout,
+    same_name: bool,
+    delete_status: int,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        response: Final = {"request_id": "write-id", "data": {"version": 3}, "extra": [1, 2]}
+        server.enqueue(ResponseSpec(body=b"current-existence-is-status-only"))
+        server.enqueue(ResponseSpec(body=response))
+        server.enqueue(ResponseSpec(body=_vault_body("replacement")))
+        if not same_name:
+            server.enqueue(ResponseSpec(status=delete_status, body=b""))
+        server.expected_requests = 3 if same_name else 4
+        manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, rollout)
+        new_name: Final = "OLD" if same_name else "NEW"
+        pending: Final = manager.async_rotate_secret("OLD", new_name, "replacement", timeout=2)
+        assert inspect.iscoroutine(pending)
+        assert server.requests == []
+        assert await asyncio.create_task(pending) == response
+        assert tuple(request.method for request in server.requests) == (
+            ("GET", "POST", "GET") if same_name else ("GET", "POST", "GET", "DELETE")
+        )
+        assert json.loads(server.requests[1].raw_body) == {
+            "data": {"key": "replacement", "description": "Rotated from OLD"},
+        }
+        assert urlsplit(server.requests[2].path).path == f"/v1/secret/data/{new_name}"
+
+
+@pytest.mark.parametrize("stage", ("current", "write", "verify"))
+@pytest.mark.parametrize("status", (404, 403, 500))
+async def test_public_vault_rotation_failure_messages_and_request_counts_match_python(
+    monkeypatch: pytest.MonkeyPatch,
+    stage: str,
+    status: int,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        before: Final = (
+            ()
+            if stage == "current"
+            else (
+                (ResponseSpec(body=_vault_body("old")),)
+                if stage == "write"
+                else (
+                    ResponseSpec(body=_vault_body("old")),
+                    ResponseSpec(body={"data": {"version": 2}}),
+                )
+            )
+        )
+        responses: Final = (*before, ResponseSpec(status=status, body={"errors": ["denied"]}))
+        for response in responses * 2:
+            server.enqueue(response)
+        server.expected_requests = len(responses) * 2
+        reference_manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.PYTHON_ONLY)
+        reference: Final = await reference_manager.async_rotate_secret("OLD", "NEW", "value")
+        native_manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.RUST_REQUIRED)
+        actual: Final = await native_manager.async_rotate_secret("OLD", "NEW", "value")
+        assert actual == reference
+        assert actual["status"] == "error"
+        expected_paths: Final = (
+            ("/v1/secret/data/OLD",)
+            + (("/v1/secret/data/NEW",) if stage != "current" else ())
+            + (("/v1/secret/data/NEW",) if stage == "verify" else ())
+        )
+        assert tuple(urlsplit(request.path).path for request in server.requests) == expected_paths * 2
+
+
+@pytest.mark.parametrize("value", (None, "different", True, 42, 2**100, [1, "two"], [2**100], {"nested": 2**100}))
+async def test_public_vault_rotation_mismatches_do_not_delete_the_old_alias(
+    monkeypatch: pytest.MonkeyPatch,
+    value: JsonValue,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        responses: Final = (
+            ResponseSpec(body=_vault_body("old")),
+            ResponseSpec(body={"data": {"version": 2}}),
+            ResponseSpec(body={"data": {"data": {"key": value}}}),
+        )
+        for response in responses * 2:
+            server.enqueue(response)
+        server.expected_requests = 6
+        reference_manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.PYTHON_ONLY)
+        reference: Final = await reference_manager.async_rotate_secret("OLD", "NEW", "value")
+        native_manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.RUST_REQUIRED)
+        actual: Final = await native_manager.async_rotate_secret("OLD", "NEW", "value")
+        assert actual == reference
+        assert actual["status"] == "error"
+        assert all(request.method != "DELETE" for request in server.requests)
+
+
+@pytest.mark.parametrize("operation", ("write", "delete", "rotate"))
+async def test_public_vault_mutation_timeouts_match_python(
+    monkeypatch: pytest.MonkeyPatch,
+    operation: str,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.default_response = ResponseSpec(body=_vault_body("value"), delay=0.25)
+        server.expected_requests = 2
+        reference_manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.PYTHON_ONLY)
+        reference: Final = await {
+            "write": partial(reference_manager.async_write_secret, "KEY", "value"),
+            "delete": partial(reference_manager.async_delete_secret, "KEY"),
+            "rotate": partial(reference_manager.async_rotate_secret, "OLD", "NEW", "value"),
+        }[operation](timeout=0.05)
+        native_manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.RUST_REQUIRED)
+        actual: Final = await {
+            "write": partial(native_manager.async_write_secret, "KEY", "value"),
+            "delete": partial(native_manager.async_delete_secret, "KEY"),
+            "rotate": partial(native_manager.async_rotate_secret, "OLD", "NEW", "value"),
+        }[operation](timeout=0.05)
+        if operation == "write":
+            assert isinstance(actual["message"], str)
+            assert isinstance(reference["message"], str)
+            pattern: Final = r"time taken=(\d+(?:\.\d+)?) seconds"
+            assert re.sub(pattern, "time taken=<elapsed> seconds", actual["message"]) == re.sub(
+                pattern,
+                "time taken=<elapsed> seconds",
+                reference["message"],
+            )
+            elapsed: Final = re.search(pattern, actual["message"])
+            assert elapsed is not None
+            assert float(elapsed[1]) >= 0.05
+        else:
+            assert actual == reference
+        assert actual["status"] == "error"
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+@pytest.mark.parametrize("operation", ("write", "delete", "rotate"))
+async def test_public_vault_unsafe_names_fail_before_authentication(
+    monkeypatch: pytest.MonkeyPatch,
+    rollout: Rollout,
+    operation: str,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.expected_requests = 0
+        manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, rollout)
+        result: Final = await {
+            "write": partial(manager.async_write_secret, "../KEY", "value"),
+            "delete": partial(manager.async_delete_secret, "../KEY"),
+            "rotate": partial(manager.async_rotate_secret, "../KEY", "NEW", "value"),
+        }[operation]()
+        assert result == {"status": "error", "message": "Invalid secret_name '../KEY'"}
+
+
+@pytest.mark.parametrize("operation", ("write", "delete", "rotate"))
+async def test_public_vault_authentication_errors_match_python(
+    monkeypatch: pytest.MonkeyPatch,
+    operation: str,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    monkeypatch.setenv("HCP_VAULT_APPROLE_ROLE_ID", "role")
+    monkeypatch.setenv("HCP_VAULT_APPROLE_SECRET_ID", "secret-id")
+    with recording_service() as server:
+        server.default_response = ResponseSpec(status=403, body={"errors": ["denied"]})
+        server.expected_requests = 2
+        reference_manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.PYTHON_ONLY)
+        reference: Final = await {
+            "write": partial(reference_manager.async_write_secret, "KEY", "value"),
+            "delete": partial(reference_manager.async_delete_secret, "KEY"),
+            "rotate": partial(reference_manager.async_rotate_secret, "OLD", "NEW", "value"),
+        }[operation]()
+        native_manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.RUST_REQUIRED)
+        actual: Final = await {
+            "write": partial(native_manager.async_write_secret, "KEY", "value"),
+            "delete": partial(native_manager.async_delete_secret, "KEY"),
+            "rotate": partial(native_manager.async_rotate_secret, "OLD", "NEW", "value"),
+        }[operation]()
+        assert actual == reference
+        assert actual["status"] == "error"
+        assert tuple(request.path for request in server.requests) == ("/v1/auth/approle/login",) * 2
+
+
+async def test_public_vault_rotation_stops_on_a_success_response_containing_an_error(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        result: Final = {"status": "error", "message": "write rejected", "extra": 2**100}
+        for response in (ResponseSpec(body=_vault_body("old")), ResponseSpec(body=result)) * 2:
+            server.enqueue(response)
+        server.expected_requests = 4
+        reference_manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.PYTHON_ONLY)
+        reference: Final = await reference_manager.async_rotate_secret("OLD", "NEW", "value")
+        native_manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.RUST_REQUIRED)
+        actual: Final = await native_manager.async_rotate_secret("OLD", "NEW", "value")
+        assert actual == reference == result
+        assert tuple(request.method for request in server.requests) == ("GET", "POST", "GET", "POST")
+
+
+async def test_public_native_vault_write_invalidates_stale_cached_values(monkeypatch: pytest.MonkeyPatch) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.enqueue(ResponseSpec(body=_vault_body("old")))
+        server.enqueue(ResponseSpec(body={"data": {"version": 2}}))
+        server.enqueue(ResponseSpec(body=_vault_body("new")))
+        server.expected_requests = 3
+        manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.RUST_REQUIRED)
+        assert manager.sync_read_secret("KEY") == "old"
+        assert await manager.async_write_secret("KEY", "new") == {"data": {"version": 2}}
+        assert manager.sync_read_secret("KEY") == "new"
+        assert tuple(request.method for request in server.requests) == ("GET", "POST", "GET")
+
+
+async def test_public_native_vault_write_rejects_description_overwriting_the_secret(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        server.expected_requests = 0
+        manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.RUST_REQUIRED)
+        assert await manager.async_write_secret("KEY", "value", "description", {"data": "description"}) == {
+            "status": "error",
+            "message": "HashiCorp Vault data key conflicts with description",
+        }
+
+
+@pytest.mark.parametrize("rollout", (Rollout.PYTHON_ONLY, Rollout.RUST_REQUIRED))
+@pytest.mark.parametrize("operation", ("write", "delete", "rotate"))
+async def test_public_vault_mutations_preserve_missing_extension_selection(
+    monkeypatch: pytest.MonkeyPatch,
+    rollout: Rollout,
+    operation: str,
+) -> None:
+    binding: Final[NativeBinding[NativeSecretManagerFactory]] = NativeBinding("unused", validate=lambda value: None)
+    binding.override(None)
+    module: Final = import_module("litellm.secret_managers.hashicorp_secret_manager")
+    _select_provider_reads(monkeypatch, module.__name__, Rollout.PYTHON_ONLY)
+    monkeypatch.setattr(
+        module,
+        "resolve_native_provider_writer",
+        partial(resolve_native_provider_writer, rules=(SecretManagerRule(rollout),), binding=binding),
+    )
+    with recording_service() as server:
+        server.default_response = ResponseSpec(body=_vault_body("value"))
+        server.expected_requests = 0 if rollout is Rollout.RUST_REQUIRED else (4 if operation == "rotate" else 1)
+        manager: Final = _vault(monkeypatch, server.base_url)
+        pending: Final = {
+            "write": partial(manager.async_write_secret, "KEY", "value"),
+            "delete": partial(manager.async_delete_secret, "KEY"),
+            "rotate": partial(manager.async_rotate_secret, "OLD", "NEW", "value"),
+        }[operation]()
+        assert inspect.iscoroutine(pending)
+        assert server.requests == []
+        if rollout is Rollout.RUST_REQUIRED:
+            with pytest.raises(RuntimeError, match="runtime is unavailable"):
+                await pending
+        else:
+            result: Final = await pending
+            assert result == (
+                {"status": "success", "message": "Secret KEY deleted successfully"}
+                if operation == "delete"
+                else _vault_body("value")
+            )
+
+
+@pytest.mark.parametrize(
+    "body", (None, [], 42, 2**100, {"data": 2**100}, {"data": None}, {"data": {"data": []}}, {}, {"data": {}})
+)
+async def test_public_vault_rotation_preserves_malformed_verification_errors(
+    monkeypatch: pytest.MonkeyPatch,
+    body: JsonValue,
+) -> None:
+    pytest.importorskip("litellm.rust_bridge._native")
+    with recording_service() as server:
+        responses: Final = (
+            ResponseSpec(body=_vault_body("old")),
+            ResponseSpec(body={"data": {"version": 2}}),
+            ResponseSpec(body=body),
+        )
+        for response in responses * 2:
+            server.enqueue(response)
+        server.expected_requests = 6
+        reference_manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.PYTHON_ONLY)
+        reference: Final = await reference_manager.async_rotate_secret("OLD", "NEW", "value")
+        native_manager: Final = _vault(monkeypatch, server.base_url)
+        _select_vault_mutations(monkeypatch, Rollout.RUST_REQUIRED)
+        actual: Final = await native_manager.async_rotate_secret("OLD", "NEW", "value")
+        assert actual == reference
+        assert actual["status"] == "error"
+        assert all(request.method != "DELETE" for request in server.requests)
diff --git a/tests/test_litellm/rust_bridge/test_settings.py b/tests/test_litellm/rust_bridge/test_settings.py
index 216961ab6403..7650195b3c52 100644
--- a/tests/test_litellm/rust_bridge/test_settings.py
+++ b/tests/test_litellm/rust_bridge/test_settings.py
@@ -6,7 +6,9 @@
 import litellm
 from litellm.integrations.custom_secret_manager import CustomSecretManager
 from litellm.llms.custom_httpx.http_handler import default_user_agent
-from litellm.rust_bridge import settings
+from litellm.rust_bridge import catalog, settings
+from litellm.rust_bridge.catalog import SecretManagerRule
+from litellm.rust_bridge.configuration import Rollout
 from litellm.secret_managers.main import get_secret_str
 from litellm.types.secret_managers.main import KeyManagementSettings, KeyManagementSystem
 
@@ -79,6 +81,11 @@ def sync_read_secret(
         return self.secrets.get(secret_name)
 
 
+_RUST_FOR_CUSTOM: Final = (
+    SecretManagerRule(Rollout.RUST_REQUIRED, systems=frozenset({KeyManagementSystem.CUSTOM.value})),
+)
+
+
 @pytest.mark.parametrize(
     ("access_mode", "readable"),
     [("read_only", True), ("read_and_write", True), ("write_only", False)],
@@ -91,14 +98,46 @@ def test_secret_manager_is_readable_only_when_litellm_would_read_secrets_from_it
     monkeypatch.setattr(litellm, "_key_management_system", KeyManagementSystem.CUSTOM)
     monkeypatch.setattr(litellm, "_key_management_settings", KeyManagementSettings(access_mode=access_mode))
 
-    assert settings.secret_manager() == settings.SecretManager(readable=readable)
+    assert settings.secret_manager(rules=()) == settings.SecretManager(readable=readable, native=False)
     assert (get_secret_str("MISTRAL_API_KEY") == "vault-key") is readable
 
 
+@pytest.mark.parametrize(
+    ("system", "access_mode", "rules", "native"),
+    [
+        (KeyManagementSystem.CUSTOM, "read_only", _RUST_FOR_CUSTOM, True),
+        (KeyManagementSystem.CUSTOM, "read_only", (), False),
+        (
+            KeyManagementSystem.CUSTOM,
+            "read_only",
+            (SecretManagerRule(Rollout.PYTHON_ONLY, systems=frozenset({KeyManagementSystem.CUSTOM.value})),),
+            False,
+        ),
+        (KeyManagementSystem.CUSTOM, "write_only", _RUST_FOR_CUSTOM, False),
+        (None, "read_only", _RUST_FOR_CUSTOM, False),
+        (KeyManagementSystem.AWS_SECRET_MANAGER, "read_only", _RUST_FOR_CUSTOM, False),
+    ],
+)
+def test_secret_manager_is_native_only_when_the_rules_select_rust_for_its_system(
+    monkeypatch: pytest.MonkeyPatch,
+    system: KeyManagementSystem | None,
+    access_mode: str,
+    rules: catalog.Rules,
+    native: bool,
+) -> None:
+    monkeypatch.setattr(litellm, "secret_manager_client", _VaultSecrets({}))
+    monkeypatch.setattr(litellm, "_key_management_system", system)
+    monkeypatch.setattr(litellm, "_key_management_settings", KeyManagementSettings(access_mode=access_mode))
+
+    assert settings.secret_manager(rules=rules) == settings.SecretManager(
+        readable=access_mode != "write_only", native=native
+    )
+
+
 def test_secret_manager_is_not_readable_without_a_client(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr(litellm, "secret_manager_client", None)
 
-    assert settings.secret_manager() == settings.SecretManager(readable=False)
+    assert settings.secret_manager(rules=_RUST_FOR_CUSTOM) == settings.SecretManager(readable=False, native=False)
 
 
 def test_secret_manager_projects_custom_settings(monkeypatch: pytest.MonkeyPatch) -> None:
diff --git a/tests/test_litellm/test_assert_ci_coverage.py b/tests/test_litellm/test_assert_ci_coverage.py
index 69db24117425..c931fe48df7b 100644
--- a/tests/test_litellm/test_assert_ci_coverage.py
+++ b/tests/test_litellm/test_assert_ci_coverage.py
@@ -9,7 +9,6 @@
 """
 
 import importlib.util
-import json
 import sys
 from pathlib import Path
 from typing import Final
@@ -24,13 +23,14 @@
 _spec.loader.exec_module(coverage)
 
 
-def test_integration_manifest_requires_exclusive_scheduled_circleci_owner(tmp_path: Path) -> None:
+def test_integration_groups_require_exclusive_scheduled_circleci_owner(tmp_path: Path) -> None:
     test_path: Final = "tests/integration/management/test_contract.py"
     test_file: Final = tmp_path / test_path
     test_file.parent.mkdir(parents=True)
     test_file.write_text("def test_contract(): pass\n")
-    (tmp_path / "tests/integration/contracts.json").write_text(
-        json.dumps({"groups": {"management": ["management"]}, "tests": {f"{test_path}::test_contract": ["mgmt.test"]}})
+    (tmp_path / "tests/integration/run.py").write_text(
+        "from types import MappingProxyType\nfrom typing import Final\n"
+        'GROUPS: Final = MappingProxyType({"management": ("management",)})\n'
     )
     paths, findings = coverage._integration_ownership(tmp_path)
     assert not paths
@@ -144,9 +144,7 @@ def test_the_parent_token_alone_does_not_satisfy_any_child(tmp_path):
     (root / "billing").mkdir(parents=True)
     (root / "billing" / "test_a.py").write_text("def test_a(): assert True\n")
 
-    findings = coverage._unassigned_shard_children(
-        frozenset({"tests/tree"}), roots=("tests/tree",), repo_root=tmp_path
-    )
+    findings = coverage._unassigned_shard_children(frozenset({"tests/tree"}), roots=("tests/tree",), repo_root=tmp_path)
 
     assert tuple(f.subject for f in findings) == ("tests/tree/billing",)
 
@@ -181,8 +179,12 @@ def test_the_repo_as_it_stands_has_every_shard_child_assigned():
 
 def _slice(**overrides):
     defaults = dict(
-        job="a_job", globs=("tests/x/**/test_*.py",), named=frozenset(),
-        required=(), excluded=(), understood=True,
+        job="a_job",
+        globs=("tests/x/**/test_*.py",),
+        named=frozenset(),
+        required=(),
+        excluded=(),
+        understood=True,
     )
     return coverage.Slice(**{**defaults, **overrides})
 
@@ -224,9 +226,7 @@ def test_an_explicitly_named_file_is_claimed_whatever_the_keywords_say():
 def test_an_unparsed_keyword_expression_claims_everything_it_globs():
     # Staying silent beats guessing: an expression this parser cannot model must never
     # be the reason a file is reported as unrun.
-    assert _slice(understood=False, excluded=("cache",)).claims(
-        "tests/x/test_caching.py", frozenset()
-    ) is True
+    assert _slice(understood=False, excluded=("cache",)).claims("tests/x/test_caching.py", frozenset()) is True
 
 
 def test_keyword_terms_splits_an_and_chain_into_required_and_excluded():
@@ -339,10 +339,7 @@ def test_a_dockerfile_directory_entry_is_stale_because_only_an_exact_path_exempt
 def test_a_workflow_that_names_a_file_clears_it_from_the_slice_check():
     named = coverage._workflow_named_tokens()
     assert named, "the workflows must name some test paths or the check proves nothing"
-    assert any(
-        coverage._token_covers(token, "tests/local_testing/test_caching_handler.py")
-        for token in named
-    )
+    assert any(coverage._token_covers(token, "tests/local_testing/test_caching_handler.py") for token in named)
 
 
 def test_the_slice_check_credits_only_workflows_never_the_circleci_config():
@@ -355,6 +352,6 @@ def test_the_slice_check_credits_only_workflows_never_the_circleci_config():
 
 def test_a_file_no_workflow_names_is_still_reported_when_every_slice_drops_it():
     named = coverage._workflow_named_tokens()
-    assert not any(
-        coverage._token_covers(token, "tests/local_testing/test_caching.py") for token in named
-    ), "test_caching.py is allowlisted, not run; crediting it would hide a real gap"
+    assert not any(coverage._token_covers(token, "tests/local_testing/test_caching.py") for token in named), (
+        "test_caching.py is allowlisted, not run; crediting it would hide a real gap"
+    )
diff --git a/tests/test_litellm/test_default_branch.py b/tests/test_litellm/test_default_branch.py
index a1b2a8c5c913..0401bec324fc 100644
--- a/tests/test_litellm/test_default_branch.py
+++ b/tests/test_litellm/test_default_branch.py
@@ -24,7 +24,7 @@ def _commit(repo: Path, message: str) -> None:
 def remote_and_clone(tmp_path: Path) -> tuple[Path, Path]:
     seed: Final = tmp_path / "seed"
     seed.mkdir()
-    _git(seed, "init", "-q", "-b", "litellm_internal_staging")
+    _git(seed, "init", "-q", "-b", "release_branch")
     (seed / "scripts").mkdir()
     for name in (
         "default_branch.py",
@@ -47,7 +47,7 @@ def remote_and_clone(tmp_path: Path) -> tuple[Path, Path]:
     _commit(seed, "main base")
     remote: Final = tmp_path / "remote.git"
     _git(tmp_path, "clone", "-q", "--bare", str(seed), str(remote))
-    _git(remote, "symbolic-ref", "HEAD", "refs/heads/litellm_internal_staging")
+    _git(remote, "symbolic-ref", "HEAD", "refs/heads/release_branch")
     repo: Final = tmp_path / "clone"
     _git(tmp_path, "clone", "-q", "--single-branch", str(remote), str(repo))
     return remote, repo
@@ -78,13 +78,13 @@ def test_existing_single_branch_clone_follows_remote_switch(remote_and_clone: tu
     remote, repo = remote_and_clone
     before: Final = _resolve(repo)
     assert before.returncode == 0, before.stderr
-    assert before.stdout.strip() == "origin/litellm_internal_staging"
+    assert before.stdout.strip() == "origin/release_branch"
     _git(remote, "symbolic-ref", "HEAD", "refs/heads/main")
     after: Final = _resolve(repo)
     assert after.returncode == 0, after.stderr
     assert after.stdout.strip() == "origin/main"
     assert _git(repo, "rev-parse", "origin/main") == _git(remote, "rev-parse", "main")
-    assert _git(repo, "symbolic-ref", "refs/remotes/origin/HEAD").endswith("/litellm_internal_staging")
+    assert _git(repo, "symbolic-ref", "refs/remotes/origin/HEAD").endswith("/release_branch")
 
 
 @pytest.mark.parametrize("missing_head", [False, True])
@@ -106,7 +106,7 @@ def test_unverifiable_default_never_uses_cached_head(
     assert "No changed" not in checked.stdout
 
 
-@pytest.mark.parametrize("base_ref", ["HEAD", "origin/litellm_internal_staging"])
+@pytest.mark.parametrize("base_ref", ["HEAD", "origin/release_branch"])
 def test_explicit_base_works_without_remote_access(
     remote_and_clone: tuple[Path, Path],
     base_ref: str,
@@ -134,7 +134,7 @@ def test_budget_ratchet_compares_against_new_default(remote_and_clone: tuple[Pat
     assert "limit raised 0 -> 1" in checked.stdout
     assert "base origin/main" in checked.stdout
     overridden: Final = subprocess.run(
-        [*command, "--base", "origin/litellm_internal_staging"],
+        [*command, "--base", "origin/release_branch"],
         cwd=repo,
         capture_output=True,
         text=True,
@@ -170,7 +170,7 @@ def test_migration_freshness_refuses_stale_branch_after_switch(remote_and_clone:
     after: Final = _freshness(repo)
     assert after.returncode == 3
     assert "1 commit(s) behind origin/main" in after.stderr
-    overridden: Final = _freshness(repo, "litellm_internal_staging")
+    overridden: Final = _freshness(repo, "release_branch")
     assert overridden.returncode == 0, overridden.stderr
     _git(repo, "merge", "--ff-only", "origin/main")
     updated: Final = _freshness(repo)
@@ -184,9 +184,9 @@ def test_migration_freshness_refuses_unavailable_remote(remote_and_clone: tuple[
     result: Final = _freshness(repo)
     assert result.returncode == 3
     assert "Could not discover origin's default branch" in result.stderr
-    explicit: Final = _freshness(repo, "litellm_internal_staging")
+    explicit: Final = _freshness(repo, "release_branch")
     assert explicit.returncode == 3
-    assert "git fetch origin litellm_internal_staging" in explicit.stderr
+    assert "git fetch origin release_branch" in explicit.stderr
 
 
 @pytest.mark.parametrize(
diff --git a/tests/test_litellm/test_git_hooks.py b/tests/test_litellm/test_git_hooks.py
index c6980d1f44a1..2ecf0da6ed62 100644
--- a/tests/test_litellm/test_git_hooks.py
+++ b/tests/test_litellm/test_git_hooks.py
@@ -246,7 +246,6 @@ def test_pre_push_rejects_non_conventional_branches(branch):
     "branch",
     [
         "main",
-        "litellm_internal_staging",
         "dependabot/github_actions/foo",
         "gh-readonly-queue/main/abc123",
     ],
diff --git a/tests/test_litellm/test_pre_commit_lint.py b/tests/test_litellm/test_pre_commit_lint.py
index 2d7fa8975368..56f98d0e05e3 100644
--- a/tests/test_litellm/test_pre_commit_lint.py
+++ b/tests/test_litellm/test_pre_commit_lint.py
@@ -161,7 +161,7 @@ def _commit_all(repo: Path, message: str) -> None:
     )
 
 
-def _set_base_ref(repo: Path, branch: str = "litellm_internal_staging") -> None:
+def _set_base_ref(repo: Path, branch: str = "release_branch") -> None:
     remote = repo.parent / "remote.git"
     subprocess.run(["git", "clone", "-q", "--bare", str(repo), str(remote)], check=True)
     subprocess.run(["git", "update-ref", f"refs/heads/{branch}", "HEAD"], cwd=remote, check=True)
@@ -176,7 +176,7 @@ def _stage_file(repo: Path, relative: str, body: str) -> None:
     subprocess.run(["git", "add", relative], cwd=repo, check=True)
 
 
-@pytest.mark.parametrize("branch", ["litellm_internal_staging", "main"])
+@pytest.mark.parametrize("branch", ["release_branch", "main"])
 def test_nothing_staged_scopes_to_working_tree_diff_and_runs_checks(tmp_path: Path, branch: str) -> None:
     repo, bin_dir = _sandbox(tmp_path)
     _commit_all(repo, "base")
diff --git a/tests/test_litellm/test_select_ui_test_scope.py b/tests/test_litellm/test_select_ui_test_scope.py
index bc11fb495aa6..ebfb7701e6aa 100644
--- a/tests/test_litellm/test_select_ui_test_scope.py
+++ b/tests/test_litellm/test_select_ui_test_scope.py
@@ -108,7 +108,7 @@ def _run_step(tmp_path: Path, changed: list[str], base_sha: str = "basesha") ->
     env["BASE_SHA"] = base_sha
     env["HEAD_SHA"] = "headsha"
     env["GITHUB_WORKSPACE"] = str(REPO_ROOT)
-    env["GITHUB_REF_NAME"] = "litellm_internal_staging"
+    env["GITHUB_REF_NAME"] = "release_branch"
     env["CHANGED_FILES"] = str(changed_file)
     env["NPM_LOG"] = str(npm_log)
 
diff --git a/tests/test_litellm/test_utils.py b/tests/test_litellm/test_utils.py
index ce280cc3513a..2a8b31c12cc6 100644
--- a/tests/test_litellm/test_utils.py
+++ b/tests/test_litellm/test_utils.py
@@ -6142,6 +6142,8 @@ def test_get_model_info_gemini(monkeypatch):
             and "veo" not in model
             and "lyria" not in model
             and "robotics" not in model
+            and "3.8-flash-tts" not in model
+            and "3.8-flash-lite-tts" not in model
         ):
             assert info.get("tpm") is not None, f"{model} does not have tpm"
             assert info.get("rpm") is not None, f"{model} does not have rpm"
diff --git a/tests/test_litellm_rust/support/recording_server.py b/tests/test_litellm_rust/support/recording_server.py
index 3eea47751d3d..74ca2cda1c51 100644
--- a/tests/test_litellm_rust/support/recording_server.py
+++ b/tests/test_litellm_rust/support/recording_server.py
@@ -28,6 +28,8 @@ class ResponseSpec:
     events: tuple[tuple[str, object], ...] = ()
 
     def payloads(self) -> tuple[bytes, ...]:
+        if isinstance(self.body, bytes):
+            return (self.body,)
         if not self.events:
             return (json.dumps(self.body).encode(),)
         return tuple(f"event: {event}\ndata: {json.dumps(data)}\n\n".encode() for event, data in self.events)
@@ -95,6 +97,7 @@ def _handle(self) -> None:
 
         do_POST = _handle
         do_GET = _handle
+        do_DELETE = _handle
 
         def log_message(self, format: str, *args: object) -> None:
             pass
diff --git a/tests/unit/llms/chat/test_converse_handler.py b/tests/unit/llms/chat/test_converse_handler.py
index 05debee06028..c342a7e18063 100644
--- a/tests/unit/llms/chat/test_converse_handler.py
+++ b/tests/unit/llms/chat/test_converse_handler.py
@@ -1,4 +1,6 @@
 import json
+from collections.abc import AsyncIterator
+from typing import Final
 from unittest.mock import AsyncMock, MagicMock
 
 import httpx
@@ -9,6 +11,11 @@
 from litellm.llms.bedrock.chat.converse_handler import make_sync_call
 from litellm.llms.bedrock.common_utils import _get_all_bedrock_regions
 from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler, HTTPHandler
+from tests._support.stream_chunk_size import (
+    LitellmParamsRecorder,
+    keys_at_every_depth,
+    record_litellm_params,
+)
 
 
 
@@ -68,8 +75,8 @@ class TestBedrockRegionInModelPath:
         ],
     )
     def test_region_and_model_id_extraction(
-        self, model, expected_model_id, expected_region
-    ):
+        self, model: str, expected_model_id: str, expected_region: str | None
+    ) -> None:
         """
         Verify that completion() correctly extracts both modelId and aws_region_name
         from the bedrock/{region}/{model} path format.
@@ -139,11 +146,11 @@ def test_explicit_aws_region_name_not_overridden(self):
         assert optional_params["aws_region_name"] == "eu-west-1"
 
 
-def _stream_completion_with_spied_iter_bytes(model: str, **kwargs) -> MagicMock:
-    mock_response = MagicMock()
+def _stream_completion_with_spied_iter_bytes(model: str, stream_chunk_size: int | None = None) -> MagicMock:
+    mock_response: Final = MagicMock()
     mock_response.status_code = 200
     mock_response.iter_bytes = MagicMock(return_value=iter([]))
-    client = HTTPHandler()
+    client: Final = HTTPHandler()
     client.post = MagicMock(return_value=mock_response)
 
     litellm.completion(
@@ -154,7 +161,7 @@ def _stream_completion_with_spied_iter_bytes(model: str, **kwargs) -> MagicMock:
         aws_access_key_id="fake",
         aws_secret_access_key="fake",
         aws_region_name="us-east-1",
-        **kwargs,
+        stream_chunk_size=stream_chunk_size,
     )
     return mock_response.iter_bytes
 
@@ -276,7 +283,7 @@ async def test_async_converse_completion_forwards_bedrock_response_headers():
 
 @pytest.mark.asyncio
 async def test_async_converse_streaming_forwards_bedrock_response_headers():
-    async def _no_bytes(chunk_size=None):
+    async def _no_bytes(chunk_size: int | None = None) -> AsyncIterator[bytes]:
         return
         yield b""
 
@@ -300,7 +307,7 @@ async def _no_bytes(chunk_size=None):
     assert response._hidden_params["additional_headers"]["llm_provider-x-amzn-requestid"] == "req-def"
 
 
-def test_completion_plumbs_stream_chunk_size_through_converse():
+def test_completion_plumbs_stream_chunk_size_through_converse() -> None:
     iter_bytes_spy = _stream_completion_with_spied_iter_bytes(
         model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0"
     )
@@ -313,6 +320,145 @@ def test_completion_plumbs_stream_chunk_size_through_converse():
     iter_bytes_spy.assert_called_once_with(chunk_size=2048)
 
 
+def _stream_converse_completion_with_spied_client(
+    monkeypatch: pytest.MonkeyPatch, stream_chunk_size: int | None = None
+) -> tuple[MagicMock, MagicMock, LitellmParamsRecorder]:
+    recorder: Final = record_litellm_params(monkeypatch)
+    mock_response: Final = MagicMock()
+    mock_response.status_code = 200
+    mock_response.iter_bytes = MagicMock(return_value=iter([]))
+    client: Final = HTTPHandler()
+    client.post = MagicMock(return_value=mock_response)
+
+    litellm.completion(
+        model="bedrock/converse/anthropic.claude-haiku-4-5-20251001-v1:0",
+        messages=[{"role": "user", "content": "hi"}],
+        stream=True,
+        client=client,
+        aws_access_key_id="fake",
+        aws_secret_access_key="fake",
+        aws_region_name="us-east-1",
+        stream_chunk_size=stream_chunk_size,
+    )
+    return mock_response.iter_bytes, client.post, recorder
+
+
+def test_completion_stream_chunk_size_reaches_iter_bytes_but_not_converse_body(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    iter_bytes_spy, post_spy, recorder = _stream_converse_completion_with_spied_client(
+        monkeypatch, stream_chunk_size=64
+    )
+
+    iter_bytes_spy.assert_called_once_with(chunk_size=64)
+    data: Final = post_spy.call_args.kwargs["data"]
+    assert "stream_chunk_size" not in keys_at_every_depth(json.loads(data)), data
+    assert len(recorder.seen) == 1
+    assert recorder.seen[0]["stream_chunk_size"] == 64
+
+
+def test_completion_without_stream_chunk_size_uses_default_chunking(monkeypatch: pytest.MonkeyPatch) -> None:
+    iter_bytes_spy, _, recorder = _stream_converse_completion_with_spied_client(monkeypatch)
+
+    iter_bytes_spy.assert_called_once_with(chunk_size=None)
+    assert len(recorder.seen) == 1
+    assert recorder.seen[0]["stream_chunk_size"] is None
+
+
+async def _astream_converse_completion_with_spied_client(
+    monkeypatch: pytest.MonkeyPatch, stream_chunk_size: int | None = None
+) -> tuple[MagicMock, AsyncMock, LitellmParamsRecorder]:
+    async def _no_bytes(chunk_size: int | None = None) -> AsyncIterator[bytes]:
+        return
+        yield b""
+
+    mock_response: Final = MagicMock()
+    mock_response.status_code = 200
+    recorder: Final = record_litellm_params(monkeypatch)
+    mock_response.aiter_bytes = MagicMock(return_value=_no_bytes())
+    aiter_bytes_spy: Final = mock_response.aiter_bytes
+    client: Final = AsyncHTTPHandler()
+    client.post = AsyncMock(return_value=mock_response)
+
+    await litellm.acompletion(
+        model="bedrock/converse/anthropic.claude-haiku-4-5-20251001-v1:0",
+        messages=[{"role": "user", "content": "hi"}],
+        stream=True,
+        client=client,
+        aws_access_key_id="fake",
+        aws_secret_access_key="fake",
+        aws_region_name="us-east-1",
+        stream_chunk_size=stream_chunk_size,
+    )
+    return aiter_bytes_spy, client.post, recorder
+
+
+@pytest.mark.asyncio
+async def test_acompletion_stream_chunk_size_reaches_aiter_bytes_but_not_converse_body(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    aiter_bytes_spy, post_spy, recorder = await _astream_converse_completion_with_spied_client(
+        monkeypatch, stream_chunk_size=64
+    )
+
+    aiter_bytes_spy.assert_called_once_with(chunk_size=64)
+    data: Final = post_spy.call_args.kwargs["data"]
+    assert "stream_chunk_size" not in keys_at_every_depth(json.loads(data)), data
+    assert len(recorder.seen) == 1
+    assert recorder.seen[0]["stream_chunk_size"] == 64
+
+
+@pytest.mark.asyncio
+async def test_acompletion_without_stream_chunk_size_uses_default_chunking(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    aiter_bytes_spy, _, recorder = await _astream_converse_completion_with_spied_client(monkeypatch)
+
+    aiter_bytes_spy.assert_called_once_with(chunk_size=None)
+    assert len(recorder.seen) == 1
+    assert recorder.seen[0]["stream_chunk_size"] is None
+
+
+@pytest.mark.parametrize("stream_chunk_size,expected_chunk_size", [(64, 64), (None, None)])
+def test_router_deployment_stream_chunk_size_reaches_iter_bytes(
+    monkeypatch: pytest.MonkeyPatch, stream_chunk_size: int | None, expected_chunk_size: int | None
+) -> None:
+    recorder: Final = record_litellm_params(monkeypatch)
+    mock_response: Final = MagicMock()
+    mock_response.status_code = 200
+    mock_response.iter_bytes = MagicMock(return_value=iter([]))
+    client: Final = HTTPHandler()
+    client.post = MagicMock(return_value=mock_response)
+    deployment_params: Final = {
+        "model": "bedrock/converse/anthropic.claude-haiku-4-5-20251001-v1:0",
+        "aws_access_key_id": "fake",
+        "aws_secret_access_key": "fake",
+        "aws_region_name": "us-east-1",
+    }
+    router: Final = litellm.Router(
+        model_list=[
+            {
+                "model_name": "converse-chunked",
+                "litellm_params": deployment_params
+                | ({} if stream_chunk_size is None else {"stream_chunk_size": stream_chunk_size}),
+            }
+        ]
+    )
+
+    router.completion(
+        model="converse-chunked",
+        messages=[{"role": "user", "content": "hi"}],
+        stream=True,
+        client=client,
+    )
+
+    mock_response.iter_bytes.assert_called_once_with(chunk_size=expected_chunk_size)
+    data: Final = client.post.call_args.kwargs["data"]
+    assert "stream_chunk_size" not in keys_at_every_depth(json.loads(data)), data
+    assert len(recorder.seen) == 1
+    assert recorder.seen[0]["stream_chunk_size"] == stream_chunk_size
+
+
 def _bedrock_error_response(status_code: int, request_id: str) -> httpx.Response:
     return httpx.Response(
         status_code=status_code,
diff --git a/ui/litellm-dashboard/src/components/edit_auto_router/build_updated_complexity_router_config.test.ts b/ui/litellm-dashboard/src/components/edit_auto_router/build_updated_complexity_router_config.test.ts
index 162414b7814b..4b8e298191db 100644
--- a/ui/litellm-dashboard/src/components/edit_auto_router/build_updated_complexity_router_config.test.ts
+++ b/ui/litellm-dashboard/src/components/edit_auto_router/build_updated_complexity_router_config.test.ts
@@ -1115,3 +1115,105 @@ describe("LLM V2 configuration preservation", () => {
     expect(saved).not.toHaveProperty("classifier_llm_config");
   });
 });
+
+describe("untouched save round trip", () => {
+  const STORED_PRE_MANAGED_BOOLEANS: Record<string, unknown> = {
+    tiers: { SIMPLE: ["gpt-4o-mini"], MEDIUM: ["gpt-4o"], COMPLEX: ["opus"], REASONING: ["o1"] },
+    tier_model_configs: { REASONING: [{ model_name: "o1", litellm_params: { reasoning_effort: "high" } }] },
+    default_model: "gpt-4o",
+    plan_mode_min_tier: "COMPLEX",
+    tier_labels: { SIMPLE: "Cheap" },
+    classifier_type: "heuristic_first",
+    heuristic_v2_success_threshold: 0.89,
+    heuristic_first_max_tier: "SIMPLE",
+    classifier_llm_config: { model: "gpt-4o-mini", timeout_ms: 3000, reasoning_effort: "low" },
+    classifier_context_window_size: 5,
+    classifier_context_budget_chars: 4000,
+    classifier_context_include_assistant_turns: true,
+    classifier_fallback: "default_model",
+    classification_prompt: "Route for a payments team.",
+    classification_examples: "- refund status -> SIMPLE",
+    classification_mode: "user_turn",
+    session_affinity: true,
+    session_affinity_ttl_seconds: 300,
+    modality_routing: true,
+    modality_pin_override: true,
+    deployment_affinity: false,
+    adaptive: true,
+    adaptive_weights: { quality: 0.4, cost: 0.6 },
+    tier_distance_penalty: 0.25,
+    adaptive_eligible: "all",
+    return_raw_model_name: true,
+    tier_boundaries: { simple_medium: 0.2, medium_complex: 0.4, complex_reasoning: 0.7 },
+    token_thresholds: { simple: 20, complex: 500 },
+    dimension_weights: { tokenCount: 0.1 },
+    custom_dimensions: [{ name: "domain", weight: 0.9, keywords: ["orbitmesh"] }],
+    reasoning_override_min_score: 0.3,
+    enable_context_window_escalation: false,
+    context_window_escalation_buffer: 0.9,
+    code_keywords: ["async", "await"],
+    reasoning_keywords: ["prove"],
+    technical_keywords: ["api"],
+    simple_keywords: ["hello"],
+    plan_mode_patterns: ["plan now"],
+    route_housekeeping_to_cheapest_tier: true,
+    housekeeping_patterns: ["conversation title"],
+    reminder_markers: [{ open: "<System-Reminder>", close: "</System-Reminder>" }],
+    max_tokens_from_tier_model: true,
+  };
+
+  it("returns the stored config unchanged when nothing was edited", () => {
+    const hydrated = hydrateComplexityRouterConfig(STORED_PRE_MANAGED_BOOLEANS, undefined);
+    expect(buildUpdatedComplexityRouterConfig(STORED_PRE_MANAGED_BOOLEANS, hydrated)).toEqual(
+      STORED_PRE_MANAGED_BOOLEANS,
+    );
+  });
+
+  it("keeps both housekeeping and max-token booleans stored as true", () => {
+    const hydrated = hydrateComplexityRouterConfig(STORED_PRE_MANAGED_BOOLEANS, undefined);
+    const saved = buildUpdatedComplexityRouterConfig(STORED_PRE_MANAGED_BOOLEANS, hydrated);
+    expect(saved.route_housekeeping_to_cheapest_tier).toBe(true);
+    expect(saved.max_tokens_from_tier_model).toBe(true);
+  });
+
+  it("keeps the stored reminder marker casing", () => {
+    const hydrated = hydrateComplexityRouterConfig(STORED_PRE_MANAGED_BOOLEANS, undefined);
+    const saved = buildUpdatedComplexityRouterConfig(STORED_PRE_MANAGED_BOOLEANS, hydrated);
+    expect(saved.reminder_markers).toEqual(STORED_PRE_MANAGED_BOOLEANS.reminder_markers);
+  });
+
+  it("lets an edited toggle win over the stored value", () => {
+    const hydrated = hydrateComplexityRouterConfig(STORED_PRE_MANAGED_BOOLEANS, undefined);
+    const edited = {
+      ...hydrated,
+      route_housekeeping_to_cheapest_tier: false,
+      max_tokens_from_tier_model: false,
+    };
+    const saved = buildUpdatedComplexityRouterConfig(STORED_PRE_MANAGED_BOOLEANS, edited);
+    expect(saved.route_housekeeping_to_cheapest_tier).toBe(false);
+    expect(saved.max_tokens_from_tier_model).toBe(false);
+
+    const storedDisabled: Record<string, unknown> = {
+      ...STORED_PRE_MANAGED_BOOLEANS,
+      route_housekeeping_to_cheapest_tier: false,
+      max_tokens_from_tier_model: false,
+    };
+    const enabled = {
+      ...hydrateComplexityRouterConfig(storedDisabled, undefined),
+      route_housekeeping_to_cheapest_tier: true,
+      max_tokens_from_tier_model: true,
+    };
+    const resaved = buildUpdatedComplexityRouterConfig(storedDisabled, enabled);
+    expect(resaved).not.toHaveProperty("route_housekeeping_to_cheapest_tier");
+    expect(resaved).not.toHaveProperty("max_tokens_from_tier_model");
+  });
+
+  it("lowercases reminder markers the user edited", () => {
+    const hydrated = hydrateComplexityRouterConfig(STORED_PRE_MANAGED_BOOLEANS, undefined);
+    const saved = buildUpdatedComplexityRouterConfig(STORED_PRE_MANAGED_BOOLEANS, {
+      ...hydrated,
+      reminder_markers: [{ open: "<Other>", close: "</Other>" }],
+    });
+    expect(saved.reminder_markers).toEqual([{ open: "<other>", close: "</other>" }]);
+  });
+});
diff --git a/ui/litellm-dashboard/src/components/edit_auto_router/edit_auto_router_modal.tsx b/ui/litellm-dashboard/src/components/edit_auto_router/edit_auto_router_modal.tsx
index 0429e7d4ad1e..2fd4fba2b311 100644
--- a/ui/litellm-dashboard/src/components/edit_auto_router/edit_auto_router_modal.tsx
+++ b/ui/litellm-dashboard/src/components/edit_auto_router/edit_auto_router_modal.tsx
@@ -33,6 +33,7 @@ import {
 import { isComplexityRouter } from "../add_model/auto_router_strategies";
 import {
   type BuildComplexityRouterConfigParams,
+  type StoredComplexityRouterConfig,
   buildComplexityRouterConfig,
   getClassifierModelError,
   getHeuristicV2SuccessThresholdError,
@@ -152,6 +153,12 @@ const KEYWORD_MATCHING_KEYS = new Set([
   "match_threshold",
 ]);
 
+const UNEDITED_STORED_VALUE_KEYS: readonly (keyof ComplexityRouterConfigValue)[] = [
+  "route_housekeeping_to_cheapest_tier",
+  "reminder_markers",
+  "max_tokens_from_tier_model",
+];
+
 const toRecord = (value: unknown): Record<string, unknown> => {
   const parsed: unknown = typeof value === "string" ? JSON.parse(value) : value;
   return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
@@ -179,7 +186,15 @@ export const buildUpdatedComplexityRouterConfig = (
   customTechnicalKeywords?: string[],
   keywordMatching?: KeywordMatchingState,
 ): Record<string, unknown> => {
+  const stored = toRecord(storedConfig);
+  const hydratedFromStored = hydrateComplexityRouterConfig(stored as StoredComplexityRouterConfig, undefined);
+  const unedited = new Set<string>(
+    UNEDITED_STORED_VALUE_KEYS.filter(
+      (key) => key in stored && JSON.stringify(value[key]) === JSON.stringify(hydratedFromStored[key]),
+    ),
+  );
   const isManaged = (key: string): boolean => {
+    if (unedited.has(key)) return false;
     if (key === "classifier_context_per_turn_chars") {
       return !usesClassifierContext(effectiveClassifierType(value)) || Object.prototype.hasOwnProperty.call(value, key);
     }
@@ -190,7 +205,7 @@ export const buildUpdatedComplexityRouterConfig = (
   };
   const dropped = customTierDroppedKeys(value);
   const preservedConfig = Object.fromEntries(
-    Object.entries(toRecord(storedConfig)).filter(([key]) => !isManaged(key) && !dropped.includes(key)),
+    Object.entries(stored).filter(([key]) => !isManaged(key) && !dropped.includes(key)),
   );
 
   const builderParams: BuildComplexityRouterConfigParams = {
@@ -208,6 +223,7 @@ export const buildUpdatedComplexityRouterConfig = (
   const unowned: readonly string[] = [
     ...(keywordMatching === undefined ? [...KEYWORD_MATCHING_KEYS].filter((key) => !isManaged(key)) : []),
     ...(customTechnicalKeywords === undefined ? ["custom_technical_keywords"] : []),
+    ...unedited,
   ];
   return {
     ...preservedConfig,