Merge pull request #26379 from BerriAI/litellm_internal_staging

merge main

.github/workflows/_test-unit-services-base.yml

@@ -32,41 +32,39 @@ on:
         required: false
         type: boolean
         default: false
+      dist:
+        description: "pytest-xdist distribution mode (loadscope|load|worksteal|loadfile|no)"
+        required: false
+        type: string
+        default: "loadscope"
       artifact-name:
         description: "Unique name for the coverage artifact (must be unique per run)"
         required: false
         type: string
         default: "run"
-    secrets:
-      DATABASE_URL:
-        required: false
-      POSTGRES_USER:
-        required: false
-      POSTGRES_PASSWORD:
-        required: false
 
 permissions:
   contents: read
 
+# The postgres service container below is spawned per-job on localhost and
+# destroyed with the job. Nothing outside the runner can reach it. The
+# user/password/database here are not secrets — they're bootstrap values
+# for a throwaway container — so we hardcode them instead of attaching
+# every matrix shard to a GHA environment just to read three "secrets"
+# (which also produces a "temporarily deployed to …" notification on the
+# PR timeline per shard per push).
 jobs:
   run:
     name: Run tests
     runs-on: ubuntu-latest
     timeout-minutes: ${{ inputs.timeout-minutes }}
-    # Environment is derived from the enable-* flags, not caller-controllable.
-    # This prevents callers from passing arbitrary environment names to bypass secret scoping.
-    environment: >-
-      ${{
-        inputs.enable-postgres && 'integration-postgres' ||
-        ''
-      }}
 
     services:
       postgres:
         image: postgres@sha256:705a5d5b5836f3fcba0d02c4d281e6a7dd9ed2dd4078640f08a1e1e9896e097d # postgres:14
         env:
-          POSTGRES_USER: ${{ secrets.POSTGRES_USER }}
-          POSTGRES_PASSWORD: ${{ secrets.POSTGRES_PASSWORD }}
+          POSTGRES_USER: litellm
+          POSTGRES_PASSWORD: litellm
           POSTGRES_DB: litellm_test
         ports:
           - 5432:5432
@@ -114,7 +112,7 @@ jobs:
       - name: Run Prisma migrations
         if: ${{ inputs.enable-postgres }}
         env:
-          DATABASE_URL: ${{ secrets.DATABASE_URL }}
+          DATABASE_URL: "postgresql://litellm:litellm@localhost:5432/litellm_test"
         run: |
           uv run --no-sync prisma db push --schema litellm/proxy/schema.prisma --accept-data-loss
 
@@ -124,7 +122,8 @@ jobs:
           MAX_FAILURES: ${{ inputs.max-failures }}
           WORKERS: ${{ inputs.workers }}
           RERUNS: ${{ inputs.reruns }}
-          DATABASE_URL: ${{ inputs.enable-postgres && secrets.DATABASE_URL || '' }}
+          DIST: ${{ inputs.dist }}
+          DATABASE_URL: ${{ inputs.enable-postgres && 'postgresql://litellm:litellm@localhost:5432/litellm_test' || '' }}
         run: |
           if [ "${WORKERS}" = "0" ]; then
             uv run --no-sync pytest ${TEST_PATH:?} \
@@ -143,7 +142,7 @@ jobs:
               -n "${WORKERS}" \
               --reruns "${RERUNS}" \
               --reruns-delay 1 \
-              --dist=loadscope \
+              --dist="${DIST}" \
               --durations=20 \
               --cov=litellm \
               --cov-report=xml:coverage.xml \

.github/workflows/check_duplicate_issues.yml

@@ -39,7 +39,7 @@ jobs:
         if: github.event.action == 'opened'
         uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
         with:
-          python-version: "3.11"
+          python-version: "3.12"
 
       - name: Auto-close if high-confidence duplicate
         if: github.event.action == 'opened'

.github/workflows/create-release-branch.yml

@@ -0,0 +1,65 @@
+name: Create Release Branch
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Release tag (e.g. v1.83.0-stable) — branch will be named release/<tag>"
+        required: true
+        type: string
+      commit_hash:
+        description: "Full 40-char commit SHA the branch should point to"
+        required: true
+        type: string
+  workflow_call:
+    inputs:
+      tag:
+        description: "Release tag"
+        required: true
+        type: string
+      commit_hash:
+        description: "Full 40-char commit SHA the branch should point to"
+        required: true
+        type: string
+
+permissions: {}
+
+jobs:
+  create-branch:
+    name: Create Release Branch
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Validate inputs
+        env:
+          TAG: ${{ inputs.tag }}
+          COMMIT_HASH: ${{ inputs.commit_hash }}
+        run: |
+          if ! echo "${COMMIT_HASH}" | grep -qE '^[0-9a-f]{40}$'; then
+            echo "::error::commit_hash must be a full 40-character commit SHA"
+            exit 1
+          fi
+          if ! echo "${TAG}" | grep -qE '^v[0-9]+\.[0-9]+\.[0-9]+'; then
+            echo "::error::tag must start with vX.Y.Z"
+            exit 1
+          fi
+
+      - name: Create release branch
+        env:
+          TAG: ${{ inputs.tag }}
+          COMMIT_HASH: ${{ inputs.commit_hash }}
+        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+        with:
+          script: |
+            const tag = process.env.TAG;
+            const commitHash = process.env.COMMIT_HASH;
+            const branchName = `release/${tag}`;
+
+            await github.rest.git.createRef({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              ref: `refs/heads/${branchName}`,
+              sha: commitHash,
+            });
+            core.info(`Created branch ${branchName} at ${commitHash}`);

.github/workflows/create-release.yml

@@ -102,6 +102,17 @@ jobs:
                 body: updatedBody,
                 draft: false,
               });
+
             } catch (error) {
               core.setFailed(error.message);
             }
+
+  create-branch:
+    name: Create Release Branch
+    needs: release
+    permissions:
+      contents: write
+    uses: ./.github/workflows/create-release-branch.yml
+    with:
+      tag: ${{ inputs.tag }}
+      commit_hash: ${{ inputs.commit_hash }}

.github/workflows/llm-translation-testing.yml

@@ -29,7 +29,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
         with:
-          python-version: "3.11"
+          python-version: "3.12"
 
       - name: Set up uv
         uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7

.github/workflows/scan_duplicate_issues.yml

@@ -29,7 +29,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
         with:
-          python-version: "3.13"
+          python-version: "3.12"
 
       - name: Scan for duplicate issues
         env:

.github/workflows/test-code-quality.yml

@@ -0,0 +1,136 @@
+name: Code Quality Checks
+
+on:
+  pull_request:
+    branches:
+      - main
+      - litellm_internal_staging
+      - litellm_oss_branch
+      - "litellm_**"
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  code-quality:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+        with:
+          persist-credentials: false
+
+      - name: Checkout litellm-docs (for documentation_tests)
+        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+        with:
+          repository: BerriAI/litellm-docs
+          path: _litellm_docs_checkout
+          persist-credentials: false
+
+      - name: Wire up docs path expected by documentation_tests/*
+        run: |
+          # documentation_tests scripts read from docs/my-website/docs/...
+          # In litellm-docs the same files live at docs/... (repo root).
+          # Point docs/my-website -> litellm-docs checkout so the paths resolve.
+          rm -rf docs/my-website
+          ln -s ../_litellm_docs_checkout docs/my-website
+
+      - name: Set up Python
+        uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: "3.12"
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7
+        with:
+          version: "0.10.9"
+
+      - name: Cache uv dependencies
+        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        with:
+          path: |
+            ~/.cache/uv
+            .venv
+          key: ${{ runner.os }}-uv-${{ hashFiles('uv.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-uv-
+
+      - name: Install dependencies
+        run: uv sync --frozen --all-groups --all-extras
+
+      - name: check_licenses
+        run: uv run --no-sync python ./tests/code_coverage_tests/check_licenses.py
+
+      - name: check_provider_folders_documented
+        run: uv run --no-sync python ./tests/code_coverage_tests/check_provider_folders_documented.py
+
+      - name: router_code_coverage
+        run: uv run --no-sync python ./tests/code_coverage_tests/router_code_coverage.py
+
+      - name: test_chat_completion_imports
+        run: uv run --no-sync python ./tests/code_coverage_tests/test_chat_completion_imports.py
+
+      - name: info_log_check
+        run: uv run --no-sync python ./tests/code_coverage_tests/info_log_check.py
+
+      - name: check_guardrail_apply_decorator
+        run: uv run --no-sync python ./tests/code_coverage_tests/check_guardrail_apply_decorator.py
+
+      - name: test_ban_set_verbose
+        run: uv run --no-sync python ./tests/code_coverage_tests/test_ban_set_verbose.py
+
+      - name: code_qa_check_tests
+        run: uv run --no-sync python ./tests/code_coverage_tests/code_qa_check_tests.py
+
+      - name: check_get_model_cost_key_performance
+        run: uv run --no-sync python ./tests/code_coverage_tests/check_get_model_cost_key_performance.py
+
+      - name: test_proxy_types_import
+        run: uv run --no-sync python ./tests/code_coverage_tests/test_proxy_types_import.py
+
+      - name: callback_manager_test
+        run: uv run --no-sync python ./tests/code_coverage_tests/callback_manager_test.py
+
+      - name: recursive_detector
+        run: uv run --no-sync python ./tests/code_coverage_tests/recursive_detector.py
+
+      - name: test_router_strategy_async
+        run: uv run --no-sync python ./tests/code_coverage_tests/test_router_strategy_async.py
+
+      - name: litellm_logging_code_coverage
+        run: uv run --no-sync python ./tests/code_coverage_tests/litellm_logging_code_coverage.py
+
+      - name: ensure_async_clients_test
+        run: uv run --no-sync python ./tests/code_coverage_tests/ensure_async_clients_test.py
+
+      - name: enforce_llms_folder_style
+        run: uv run --no-sync python ./tests/code_coverage_tests/enforce_llms_folder_style.py
+
+      - name: prevent_key_leaks_in_exceptions
+        run: uv run --no-sync python ./tests/code_coverage_tests/prevent_key_leaks_in_exceptions.py
+
+      - name: check_unsafe_enterprise_import
+        run: uv run --no-sync python ./tests/code_coverage_tests/check_unsafe_enterprise_import.py
+
+      - name: ban_copy_deepcopy_kwargs
+        run: uv run --no-sync python ./tests/code_coverage_tests/ban_copy_deepcopy_kwargs.py
+
+      - name: check_fastuuid_usage
+        run: uv run --no-sync python ./tests/code_coverage_tests/check_fastuuid_usage.py
+
+      - name: memory_test
+        run: uv run --no-sync python ./tests/code_coverage_tests/memory_test.py
+
+      - name: documentation_test_env_keys
+        run: uv run --no-sync python ./tests/documentation_tests/test_env_keys.py
+
+      - name: documentation_test_router_settings
+        run: uv run --no-sync python ./tests/documentation_tests/test_router_settings.py
+
+      - name: documentation_test_api_docs
+        run: uv run --no-sync python ./tests/documentation_tests/test_api_docs.py

.github/workflows/test-semgrep.yml

@@ -0,0 +1,39 @@
+name: Semgrep
+
+on:
+  pull_request:
+    branches:
+      - main
+      - litellm_internal_staging
+      - litellm_oss_branch
+      - "litellm_**"
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  semgrep:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+        with:
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: "3.12"
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7
+        with:
+          version: "0.10.9"
+
+      - name: Run Semgrep (custom rules)
+        run: uv tool run --from 'semgrep==1.157.0' semgrep scan --config .semgrep/rules . --error

.github/workflows/test-unit-proxy-db.yml

@@ -12,8 +12,74 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
+# Semantic matrix: each shard groups tests by concern (auth, server, logging, …)
+# rather than alphabetical letter ranges. Adding a new test file means adding it
+# to whichever group it belongs to, not reshuffling slices.
+#
+# Design targets:
+#   * Every shard runs in <= 7 minutes of wall-clock on the default runner.
+#     Most of a shard's time is pytest plugin load + xdist worker imports +
+#     pytest-cov instrumentation, not the tests themselves. Keeping per-shard
+#     work low and matching worker count to runner cores is what controls it.
+#   * workers: 4 matches the 4-core ubuntu-latest runner. -n 8 on 4 cores
+#     oversubscribes 2x and workers fight for CPU during their cold-start
+#     imports (measured ~441% CPU for -n 8 locally, i.e. ~55% effective).
+#   * test_key_generate_prisma.py stays serial (workers=0) — it has event-loop
+#     conflicts with the logging worker when run in parallel.
+#   * test_proxy_utils.py runs as a single shard with --dist=worksteal so
+#     xdist balances its 188 parametrized cases across workers instead of
+#     pinning the whole file to one worker (the default --dist=loadscope
+#     behavior for single-file targets).
+#   * test_db_schema_migration.py is isolated because one test in it
+#     (test_aaaasschema_migration_check) takes ~170s — by itself it
+#     determines the shard's wall-clock floor.
 jobs:
+  # Fast guard — fails the workflow if a test_*.py file under
+  # tests/proxy_unit_tests/ is not referenced by any matrix entry below.
+  # The semantic-shard design (no catch-all "remaining" bucket) relies on
+  # every test file being explicitly assigned; this guard prevents a new
+  # file from silently dropping out of CI.
+  assert-shard-coverage:
+    runs-on: ubuntu-latest
+    timeout-minutes: 2
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+        with:
+          persist-credentials: false
+      - name: Assert every test_*.py is in a matrix shard
+        run: |
+          python3 - <<'PY'
+          import pathlib, sys, yaml
+          wf = yaml.safe_load(open(".github/workflows/test-unit-proxy-db.yml"))
+          matrix = wf["jobs"]["proxy-db"]["strategy"]["matrix"]["include"]
+          referenced = set()
+          for entry in matrix:
+              for token in entry["test-path"].split():
+                  if token.startswith("tests/proxy_unit_tests/"):
+                      referenced.add(pathlib.PurePosixPath(token).name)
+          actual = {p.name for p in pathlib.Path("tests/proxy_unit_tests").iterdir()
+                    if p.name.startswith("test_") and (p.suffix == ".py" or p.is_dir())
+                    and p.name != "test_configs"}
+          orphans = sorted(actual - referenced)
+          if orphans:
+              print("ERROR: the following files/dirs under tests/proxy_unit_tests/")
+              print("       are not assigned to any shard in test-unit-proxy-db.yml:")
+              for o in orphans:
+                  print(f"  - {o}")
+              print()
+              print("Add each to whichever semantic shard it belongs to.")
+              sys.exit(1)
+          print(f"OK: all {len(actual)} files assigned to a shard.")
+          PY
+
   proxy-db:
+    needs: assert-shard-coverage
+    # Display only the semantic shard name in the checks UI instead of GHA's
+    # default "proxy-db (key-generation, tests/proxy_unit_tests/…, 0, loadscope, 20)"
+    # which includes every matrix field and gets truncated past the test-path.
+    name: ${{ matrix.test-group }}
     permissions:
       contents: read
       id-token: write
@@ -22,26 +88,146 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          # Key generation tests must NOT run in parallel (event loop conflicts with logging worker)
+          # Must run serially — event-loop conflict with the logging worker.
           - test-group: key-generation
             test-path: "tests/proxy_unit_tests/test_key_generate_prisma.py"
             workers: 0
-            timeout: 30
-          - test-group: auth-checks
-            test-path: "tests/proxy_unit_tests/test_auth_checks.py tests/proxy_unit_tests/test_user_api_key_auth.py"
-            workers: 8
+            dist: loadscope
             timeout: 20
-          # test_proxy_utils.py is large (168+ parametrized tests) — run it on its
-          # own matrix so --dist=loadscope doesn't pin all of it to a single xdist
-          # worker and push the "remaining" group past the job timeout.
+
+          # ---- auth: split into 2 shards ----
+          - test-group: auth-checks
+            test-path: >-
+              tests/proxy_unit_tests/test_auth_checks.py
+              tests/proxy_unit_tests/test_user_api_key_auth.py
+            workers: 4
+            dist: loadscope
+            timeout: 15
+          - test-group: jwt-and-keys
+            test-path: >-
+              tests/proxy_unit_tests/test_jwt.py
+              tests/proxy_unit_tests/test_jwt_key_mapping.py
+              tests/proxy_unit_tests/test_proxy_custom_auth.py
+              tests/proxy_unit_tests/test_key_generate_dynamodb.py
+              tests/proxy_unit_tests/test_deployed_proxy_keygen.py
+            workers: 4
+            dist: loadscope
+            timeout: 15
+
+          # ---- test_proxy_utils.py, single shard, worksteal distribution ----
           - test-group: proxy-utils
             test-path: "tests/proxy_unit_tests/test_proxy_utils.py"
-            workers: 8
-            timeout: 20
-          - test-group: remaining
-            test-path: "tests/proxy_unit_tests --ignore=tests/proxy_unit_tests/test_key_generate_prisma.py --ignore=tests/proxy_unit_tests/test_auth_checks.py --ignore=tests/proxy_unit_tests/test_user_api_key_auth.py --ignore=tests/proxy_unit_tests/test_proxy_utils.py"
-            workers: 8
-            timeout: 30
+            workers: 4
+            dist: worksteal
+            timeout: 15
+
+          # ---- proxy server: split into 2 shards ----
+          - test-group: proxy-server-core
+            test-path: >-
+              tests/proxy_unit_tests/test_proxy_server.py
+              tests/proxy_unit_tests/test_proxy_server_keys.py
+              tests/proxy_unit_tests/test_proxy_server_caching.py
+              tests/proxy_unit_tests/test_proxy_server_langfuse.py
+              tests/proxy_unit_tests/test_proxy_server_spend.py
+              tests/proxy_unit_tests/test_aproxy_startup.py
+            workers: 4
+            dist: loadscope
+            timeout: 15
+          - test-group: proxy-runtime
+            test-path: >-
+              tests/proxy_unit_tests/test_proxy_config_unit_test.py
+              tests/proxy_unit_tests/test_proxy_routes.py
+              tests/proxy_unit_tests/test_proxy_gunicorn.py
+              tests/proxy_unit_tests/test_server_root_path.py
+              tests/proxy_unit_tests/test_proxy_pass_user_config.py
+              tests/proxy_unit_tests/test_proxy_token_counter.py
+            workers: 4
+            dist: loadscope
+            timeout: 15
+
+          # ---- logging: split into 2 shards ----
+          - test-group: custom-logging
+            test-path: >-
+              tests/proxy_unit_tests/test_custom_callback_input.py
+              tests/proxy_unit_tests/test_custom_logger_s3_gcs.py
+              tests/proxy_unit_tests/test_proxy_custom_logger.py
+            workers: 4
+            dist: loadscope
+            timeout: 15
+          - test-group: logging-misc
+            test-path: >-
+              tests/proxy_unit_tests/test_proxy_reject_logging.py
+              tests/proxy_unit_tests/test_audit_logs_proxy.py
+              tests/proxy_unit_tests/test_search_api_logging.py
+            workers: 4
+            dist: loadscope
+            timeout: 15
+
+          # ---- db-and-spend: isolate the 170s schema-migration test ----
+          # test_db_schema_migration.py has exactly one test, and that test
+          # is mostly waiting on `prisma migrate deploy` / `prisma migrate
+          # diff` subprocesses (~170s). It does no CPU-bound Python work
+          # inside the test. Running with workers=0 (serial, no xdist)
+          # skips the 4-worker cold-start cost we'd otherwise pay for a
+          # single test, saving ~4 minutes of wall-clock.
+          - test-group: schema-migration
+            test-path: "tests/proxy_unit_tests/test_db_schema_migration.py"
+            workers: 0
+            dist: loadscope
+            timeout: 15
+          - test-group: db-and-spend
+            test-path: >-
+              tests/proxy_unit_tests/test_prisma_client_backoff_retry.py
+              tests/proxy_unit_tests/test_db_schema_changes.py
+              tests/proxy_unit_tests/test_e2e_pod_lock_manager.py
+              tests/proxy_unit_tests/test_skills_db.py
+              tests/proxy_unit_tests/test_update_daily_tag_spend.py
+              tests/proxy_unit_tests/test_update_spend.py
+              tests/proxy_unit_tests/test_project_endpoints_prisma.py
+              tests/proxy_unit_tests/test_proxy_encrypt_decrypt.py
+            workers: 4
+            dist: loadscope
+            timeout: 15
+
+          # ---- guardrails + budget + hooks: split into 2 ----
+          - test-group: guardrails-hooks
+            test-path: >-
+              tests/proxy_unit_tests/test_proxy_setting_guardrails.py
+              tests/proxy_unit_tests/test_banned_keyword_list.py
+              tests/proxy_unit_tests/test_unit_test_proxy_hooks.py
+            workers: 4
+            dist: loadscope
+            timeout: 15
+          - test-group: budgets
+            test-path: >-
+              tests/proxy_unit_tests/test_default_end_user_budget_simple.py
+              tests/proxy_unit_tests/test_unit_test_max_model_budget_limiter.py
+              tests/proxy_unit_tests/test_zero_cost_model_budget_bypass.py
+            workers: 4
+            dist: loadscope
+            timeout: 15
+
+          - test-group: endpoints-and-responses
+            test-path: >-
+              tests/proxy_unit_tests/test_blog_posts_endpoint.py
+              tests/proxy_unit_tests/test_models_fallback_endpoint.py
+              tests/proxy_unit_tests/test_google_endpoint_routing.py
+              tests/proxy_unit_tests/test_google_gemini_proxy_request.py
+              tests/proxy_unit_tests/test_get_favicon.py
+              tests/proxy_unit_tests/test_get_image.py
+              tests/proxy_unit_tests/test_ui_path_detection.py
+              tests/proxy_unit_tests/test_prompt_test_endpoint.py
+              tests/proxy_unit_tests/test_check_batch_cost.py
+              tests/proxy_unit_tests/test_check_responses_cost.py
+              tests/proxy_unit_tests/test_response_polling_handler.py
+              tests/proxy_unit_tests/test_response_polling_pre_call_checks.py
+              tests/proxy_unit_tests/test_realtime_cache.py
+              tests/proxy_unit_tests/test_proxy_exception_mapping.py
+              tests/proxy_unit_tests/test_custom_tokenizer_bug.py
+              tests/proxy_unit_tests/test_model_response_typing
+            workers: 4
+            dist: loadscope
+            timeout: 15
     uses: ./.github/workflows/_test-unit-services-base.yml
     with:
       test-path: ${{ matrix.test-path }}
@@ -49,8 +235,5 @@ jobs:
       reruns: 2
       timeout-minutes: ${{ matrix.timeout }}
       enable-postgres: true
+      dist: ${{ matrix.dist }}
       artifact-name: proxy-db-${{ matrix.test-group }}
-    secrets:
-      DATABASE_URL: ${{ secrets.DATABASE_URL }}
-      POSTGRES_USER: ${{ secrets.POSTGRES_USER }}
-      POSTGRES_PASSWORD: ${{ secrets.POSTGRES_PASSWORD }}

.github/workflows/test-unit-proxy-endpoints.yml

@@ -36,6 +36,8 @@ jobs:
         tests/test_litellm/proxy/health_endpoints
         tests/test_litellm/proxy/public_endpoints
         tests/test_litellm/proxy/prompts
+        tests/test_litellm/proxy/rag_endpoints
+        tests/test_litellm/proxy/realtime_endpoints
         tests/test_litellm/proxy/ui_crud_endpoints
       workers: 2
       reruns: 2

.github/workflows/test-unit-security.yml

@@ -1,6 +1,8 @@
 name: "Unit Tests: Security"
 
-# Uses DATABASE_URL secret — only runs on trusted branches, not PRs.
+# Kept push-only (was previously required by DATABASE_URL secret scoping;
+# now the postgres credentials are ephemeral localhost values but the
+# push-trigger stays to match the proxy-db workflow cadence).
 on:
   push:
     branches: [main, "litellm_**"]
@@ -24,7 +26,3 @@ jobs:
       timeout-minutes: 20
       enable-postgres: true
       artifact-name: security
-    secrets:
-      DATABASE_URL: ${{ secrets.DATABASE_URL }}
-      POSTGRES_USER: ${{ secrets.POSTGRES_USER }}
-      POSTGRES_PASSWORD: ${{ secrets.POSTGRES_PASSWORD }}

Dockerfile

@@ -27,10 +27,8 @@ RUN apk add --no-cache \
     npm \
     libsndfile
 
-ENV PRISMA_BINARY_CACHE_DIR=/app/.cache/prisma-python/binaries \
-    UV_PROJECT_ENVIRONMENT=/app/.venv \
+ENV UV_PROJECT_ENVIRONMENT=/app/.venv \
     UV_LINK_MODE=copy \
-    XDG_CACHE_HOME=/app/.cache \
     PATH="/app/.venv/bin:${PATH}"
 
 # Copy dependency metadata first for layer caching
@@ -94,11 +92,14 @@ RUN apk add --no-cache bash openssl tzdata nodejs npm python3 libsndfile supervi
     { apk del --no-cache npm 2>/dev/null || true; }
 
 WORKDIR /app
-ENV PRISMA_BINARY_CACHE_DIR=/app/.cache/prisma-python/binaries \
-    XDG_CACHE_HOME=/app/.cache \
-    PATH="/app/.venv/bin:${PATH}"
+ENV PATH="/app/.venv/bin:${PATH}"
 
 COPY --from=builder /app /app
+# Prisma binaries live in $HOME/.cache (default prisma-python location),
+# which is /root/.cache here. Copy them from the builder so they survive
+# deployments that volume-mount /app/.cache (e.g. readOnlyRootFilesystem
+# + emptyDir) — otherwise the mount would shadow the baked-in query engine.
+COPY --from=builder /root/.cache /root/.cache
 
 RUN find /app/.venv -type f -path "*/tornado/test/*" -delete && \
     find /app/.venv -type d -path "*/tornado/test" -delete

docker/Dockerfile.database

@@ -26,10 +26,8 @@ RUN apk add --no-cache \
     npm \
     libsndfile
 
-ENV PRISMA_BINARY_CACHE_DIR=/app/.cache/prisma-python/binaries \
-    UV_PROJECT_ENVIRONMENT=/app/.venv \
+ENV UV_PROJECT_ENVIRONMENT=/app/.venv \
     UV_LINK_MODE=copy \
-    XDG_CACHE_HOME=/app/.cache \
     PATH="/app/.venv/bin:${PATH}"
 
 # Copy dependency metadata first for layer caching
@@ -92,11 +90,14 @@ RUN apk add --no-cache bash openssl tzdata nodejs npm python3 libsndfile supervi
     { apk del --no-cache npm 2>/dev/null || true; }
 
 WORKDIR /app
-ENV PRISMA_BINARY_CACHE_DIR=/app/.cache/prisma-python/binaries \
-    XDG_CACHE_HOME=/app/.cache \
-    PATH="/app/.venv/bin:${PATH}"
+ENV PATH="/app/.venv/bin:${PATH}"
 
 COPY --from=builder /app /app
+# Prisma binaries live in $HOME/.cache (default prisma-python location),
+# which is /root/.cache here. Copy them from the builder so they survive
+# deployments that volume-mount /app/.cache (e.g. readOnlyRootFilesystem
+# + emptyDir) — otherwise the mount would shadow the baked-in query engine.
+COPY --from=builder /root/.cache /root/.cache
 
 RUN find /app/.venv -type f -path "*/tornado/test/*" -delete && \
     find /app/.venv -type d -path "*/tornado/test" -delete

docker/Dockerfile.non_root

@@ -138,7 +138,7 @@ RUN mkdir -p /nonexistent /var/lib/litellm/assets /var/lib/litellm/ui && \
     [ -n "$LITELLM_PROXY_EXTRAS_PATH" ] && chmod -R g+w "$LITELLM_PROXY_EXTRAS_PATH" || true && \
     chmod -R g+rX "$PRISMA_PATH" /var/lib/litellm/ui /var/lib/litellm/assets /app/.cache
 
-USER nobody
+USER 65534
 
 RUN prisma generate --schema=./schema.prisma
 

docker/tests/nonroot.yaml

@@ -2,7 +2,7 @@ schemaVersion: 2.0.0
 
 metadataTest:
   entrypoint: ["docker/prod_entrypoint.sh"]
-  user: "nobody"
+  user: "65534"
   workdir: "/app"
 
 fileExistenceTests:

docs/my-website/docs/adaptive_router.md

@@ -0,0 +1,155 @@
+# [BETA] Adaptive Router
+
+:::info
+
+Beta feature. Share feedback on [Discord](https://discord.gg/wuPM9dRgDw) or [Slack](https://join.slack.com/t/litellmossslack/shared_invite/zt-3o7nkuyfr-p_kbNJj8taRfXGgQI1~YyA).
+
+:::
+
+**Requirements:** LiteLLM Proxy with a Postgres database. Quality estimates are stored in Postgres and loaded on startup — without a database the router works but forgets everything learned on restart.
+
+You have a cheap model and an expensive one. You want to use the cheap one when it's good enough, and the expensive one when it actually matters — without hardcoding rules you'll spend months tuning.
+
+The adaptive router does this automatically. It tracks which model performs best for each type of request (code, writing, analysis, etc.) and routes accordingly, balancing quality against cost based on weights you control.
+
+## Quick start
+
+```yaml
+model_list:
+  - model_name: gpt-4o
+    litellm_params:
+      model: openai/gpt-4o
+    model_info:
+      input_cost_per_token: 0.0000025
+      adaptive_router_preferences:
+        quality_tier: 3        # 1=budget, 2=mid, 3=frontier
+        strengths: ["code_generation", "analytical_reasoning"]
+
+  - model_name: gpt-4o-mini
+    litellm_params:
+      model: openai/gpt-4o-mini
+    model_info:
+      input_cost_per_token: 0.00000015
+      adaptive_router_preferences:
+        quality_tier: 2
+        strengths: ["factual_lookup"]
+
+  - model_name: my-router
+    litellm_params:
+      model: auto_router/adaptive_router
+      adaptive_router_config:
+        available_models: ["gpt-4o", "gpt-4o-mini"]
+        weights:
+          quality: 0.7   # raise this if quality complaints; lower if bill too high
+          cost: 0.3      # must sum to 1.0 with quality
+```
+
+Route to it by setting `model` to your adaptive router's name:
+
+```bash
+curl -X POST {{baseURL}}/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $LITELLM_API_KEY" \
+  -d '{
+    "model": "my-router",
+    "messages": [
+      {"role": "user", "content": "build me a python script that parses CSV"},
+      {"role": "assistant", "content": "Here is a script using csv.DictReader..."},
+      {"role": "user", "content": "now add error handling for missing files"},
+      {"role": "assistant", "content": "Wrap the open() call in a try/except FileNotFoundError..."},
+      {"role": "user", "content": "perfect, that worked. thanks!"}
+    ]
+  }'
+```
+
+The response includes a header telling you which model was actually picked:
+
+```
+x-litellm-adaptive-router-model: gpt-4o
+```
+
+The "thanks!" turn in the example above fires a satisfaction signal — that's what moves the bandit.
+
+## Tuning cost vs. quality
+
+The `weights` are your main lever:
+
+| Goal | quality | cost |
+|---|---|---|
+| Minimize cost, quality is secondary | 0.3 | 0.7 |
+| Balanced | 0.5 | 0.5 |
+| Quality-first (default) | 0.7 | 0.3 |
+| Quality non-negotiable | 0.9 | 0.1 |
+
+The router learns over time. For the first ~10 requests per model, it relies on the tiers you declared. After that, real performance data takes over.
+
+## Force a minimum quality tier per request
+
+If a specific request needs a frontier model regardless of cost, pass this header:
+
+```
+x-litellm-min-quality-tier: 3
+```
+
+You can also pass `min_quality_tier` via request metadata instead of a header.
+
+## What's being learned
+
+The router classifies each request into one of 7 types and tracks how each model performs on each independently. A model that's great at factual lookup but poor at code will win factual requests and lose code requests — even if it's cheaper overall.
+
+| Type | Example |
+|---|---|
+| `code_generation` | "write me a Python sort function" |
+| `code_understanding` | "explain what this function does" |
+| `technical_design` | "how should I design this API?" |
+| `analytical_reasoning` | "calculate the probability that..." |
+| `writing` | "draft an email to my team about..." |
+| `factual_lookup` | "what is the capital of France?" |
+| `general` | anything else |
+
+[**See classifier code**](https://github.com/BerriAI/litellm/blob/litellm_adaptive_routing/litellm/router_strategy/adaptive_router/classifier.py)
+
+Learning signals are inspired by [Signals: Trajectory Sampling and Triage for Agentic Interactions](https://arxiv.org/pdf/2604.00356).
+
+## Inspect the current state
+
+```
+GET /adaptive_router/{router_name}/state
+```
+
+Returns current quality estimates per model per request type. Useful for understanding why a model is or isn't being picked.
+
+```json
+{
+  "routers": [
+    {
+      "router_name": "smart-cheap-router",
+      "available_models": ["fast", "smart"],
+      "weights": { "quality": 0.7, "cost": 0.3 },
+      "cells": [
+        {
+          "request_type": "analytical_reasoning",
+          "model": "fast",
+          "quality_mean": 0.5,
+          "samples": 0
+        },
+        {
+          "request_type": "analytical_reasoning",
+          "model": "smart",
+          "quality_mean": 0.95,
+          "samples": 0
+        }
+      ]
+    }
+  ]
+}
+```
+
+`quality_mean` is the key number — it's the router's current estimate of how well that model handles that request type. `samples` counts how many real observations have moved the prior (starts at 0; the cold-start prior mass is excluded).
+
+## Known limitations
+
+- Latency isn't scored — a slow model can still win on quality + cost
+- Signals are regex-based and English-biased — no LLM judge
+- Hard cap of 200 observations per cell; no decay yet
+- Once a model is picked for a session, other models' turns in that session don't contribute to learning

docs/my-website/docs/providers/vertex.md

@@ -2061,7 +2061,7 @@ assert isinstance(
 
 ## Media Resolution Control (Images & Videos)
 
-For Gemini 3+ models, LiteLLM supports per-part media resolution control using OpenAI's `detail` parameter. This allows you to specify different resolution levels for individual images and videos in your request, whether using `image_url` or `file` content types.
+LiteLLM supports per-part media resolution control using OpenAI's `detail` parameter for all Gemini models. This allows you to specify different resolution levels for individual images and videos in your request, whether using `image_url` or `file` content types.
 
 **Supported `detail` values:**
 - `"low"` - Maps to `media_resolution: "low"` (280 tokens for images, 70 tokens per frame for videos)
@@ -2146,12 +2146,12 @@ response = completion(
 </Tabs>
 
 :::info
-**Per-Part Resolution:** Each image or video in your request can have its own `detail` setting, allowing mixed-resolution requests (e.g., a high-res chart alongside a low-res icon). This feature works with both `image_url` and `file` content types, and is only available for Gemini 3+ models.
+**Per-Part Resolution:** Each image or video in your request can have its own `detail` setting, allowing mixed-resolution requests (e.g., a high-res chart alongside a low-res icon). This feature works with both `image_url` and `file` content types across all Gemini models.
 :::
 
 ## Video Metadata Control
 
-For Gemini 3+ models, LiteLLM supports fine-grained video processing control through the `video_metadata` field. This allows you to specify frame extraction rates and time ranges for video analysis.
+LiteLLM supports fine-grained video processing control through the `video_metadata` field for all Gemini models (1.x, 2.x, 3+). This allows you to specify frame extraction rates and time ranges for video analysis.
 
 **Supported `video_metadata` parameters:**
 
@@ -2168,8 +2168,11 @@ For Gemini 3+ models, LiteLLM supports fine-grained video processing control thr
 - `fps` remains unchanged
 :::
 
+:::tip
+Video clipping (`start_offset`/`end_offset`) and frame rate control (`fps`) are supported by all Gemini models, but analysis quality is significantly higher with the **Gemini 2.5 series** (e.g., `gemini-2.5-flash`, `gemini-2.5-pro`).
+:::
+
 :::warning
-- **Gemini 3+ Only:** This feature is only available for Gemini 3.0 and newer models
 - **Video Files Recommended:** While `video_metadata` is designed for video files, error handling for other media types is delegated to the Vertex AI API
 - **File Formats Supported:** Works with `gs://`, `https://`, and base64-encoded video files
 :::

docs/my-website/package-lock.json

@@ -26,6 +26,7 @@
       },
       "devDependencies": {
         "@docusaurus/module-type-aliases": "3.8.1",
+        "ajv": "^8.18.0",
         "dotenv": "16.6.1"
       },
       "engines": {

docs/my-website/package.json

@@ -32,6 +32,7 @@
   },
   "devDependencies": {
     "@docusaurus/module-type-aliases": "3.8.1",
+    "ajv": "^8.18.0",
     "dotenv": "16.6.1"
   },
   "browserslist": {

docs/my-website/sidebars.js

@@ -1060,6 +1060,7 @@ const sidebars = {
       },
       items: [
         "routing",
+        "adaptive_router",
         "scheduler",
         "proxy/auto_routing",
         "proxy/load_balancing",

litellm-proxy-extras/litellm_proxy_extras/migrations/20260418000000_add_adaptive_router_tables/migration.sql

@@ -0,0 +1,39 @@
+-- One row per (router, request_type, model). Hot path on every routing decision.
+CREATE TABLE "LiteLLM_AdaptiveRouterState" (
+    router_name      TEXT NOT NULL,
+    request_type     TEXT NOT NULL,
+    model_name       TEXT NOT NULL,
+    alpha            DOUBLE PRECISION NOT NULL,
+    beta             DOUBLE PRECISION NOT NULL,
+    total_samples    INTEGER NOT NULL DEFAULT 0,
+    last_updated_at  TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (router_name, request_type, model_name)
+);
+
+-- One row per (session, router, model). Updated per turn via the queue.
+CREATE TABLE "LiteLLM_AdaptiveRouterSession" (
+    session_id              TEXT NOT NULL,
+    router_name             TEXT NOT NULL,
+    model_name              TEXT NOT NULL,
+    classified_type         TEXT NOT NULL,
+    misalignment_count      INTEGER NOT NULL DEFAULT 0,
+    stagnation_count        INTEGER NOT NULL DEFAULT 0,
+    disengagement_count     INTEGER NOT NULL DEFAULT 0,
+    satisfaction_count      INTEGER NOT NULL DEFAULT 0,
+    failure_count           INTEGER NOT NULL DEFAULT 0,
+    loop_count              INTEGER NOT NULL DEFAULT 0,
+    exhaustion_count        INTEGER NOT NULL DEFAULT 0,
+    last_user_content       TEXT,
+    last_assistant_content  TEXT,
+    tool_call_history       JSONB NOT NULL DEFAULT '[]',
+    pending_tool_calls      JSONB NOT NULL DEFAULT '{}',
+    turn_count              INTEGER NOT NULL DEFAULT 0,
+    last_processed_turn     INTEGER NOT NULL DEFAULT -1,
+    clean_credit_awarded    BOOLEAN NOT NULL DEFAULT FALSE,
+    terminal_status         INTEGER,
+    last_activity_at        TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (session_id, router_name, model_name)
+);
+
+CREATE INDEX "idx_adaptive_router_session_activity"
+    ON "LiteLLM_AdaptiveRouterSession" (last_activity_at);

litellm-proxy-extras/litellm_proxy_extras/migrations/20260421135425_add_team_membership_total_spend/migration.sql

@@ -0,0 +1,3 @@
+-- AlterTable
+ALTER TABLE "LiteLLM_TeamMembership" ADD COLUMN     "total_spend" DOUBLE PRECISION NOT NULL DEFAULT 0.0;
+

litellm-proxy-extras/litellm_proxy_extras/schema.prisma

@@ -616,6 +616,7 @@ model LiteLLM_TeamMembership {
   user_id    String
   team_id    String
   spend      Float    @default(0.0)
+  total_spend Float @default(0.0)
   budget_id String?
   litellm_budget_table LiteLLM_BudgetTable?   @relation(fields: [budget_id], references: [budget_id])
   @@id([user_id, team_id])
@@ -1223,3 +1224,46 @@ model LiteLLM_ClaudeCodePluginTable {
 
   @@map("LiteLLM_ClaudeCodePluginTable")
 }
+
+// Per-(router, request_type, model) Beta posterior for the adaptive router.
+model LiteLLM_AdaptiveRouterState {
+  router_name     String
+  request_type    String
+  model_name      String
+  alpha           Float
+  beta            Float
+  total_samples   Int      @default(0)
+  last_updated_at DateTime @default(now()) @updatedAt
+
+  @@id([router_name, request_type, model_name])
+}
+
+// Per-(session, router, model) signal counters for the adaptive router.
+model LiteLLM_AdaptiveRouterSession {
+  session_id             String
+  router_name            String
+  model_name             String
+  classified_type        String
+
+  misalignment_count     Int      @default(0)
+  stagnation_count       Int      @default(0)
+  disengagement_count    Int      @default(0)
+  satisfaction_count     Int      @default(0)
+  failure_count          Int      @default(0)
+  loop_count             Int      @default(0)
+  exhaustion_count       Int      @default(0)
+
+  last_user_content      String?
+  last_assistant_content String?
+  tool_call_history      Json     @default("[]")
+  pending_tool_calls     Json     @default("{}")
+
+  turn_count             Int      @default(0)
+  last_processed_turn    Int      @default(-1)
+  clean_credit_awarded   Boolean  @default(false)
+  terminal_status        Int?
+  last_activity_at       DateTime @default(now()) @updatedAt
+
+  @@id([session_id, router_name, model_name])
+  @@index([last_activity_at], map: "idx_adaptive_router_session_activity")
+}

litellm-proxy-extras/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "litellm-proxy-extras"
-version = "0.4.67"
+version = "0.4.68"
 description = "Additional files for the LiteLLM Proxy. Reduces the size of the main litellm package."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -25,7 +25,7 @@ required-version = "==0.10.9"
 module-root = ""
 
 [tool.commitizen]
-version = "0.4.67"
+version = "0.4.68"
 version_files = [
     "pyproject.toml:^version",
     "../pyproject.toml:litellm-proxy-extras==",

litellm/constants.py

@@ -164,6 +164,7 @@ MCP_STDIO_ALLOWED_COMMANDS: frozenset = frozenset(
 LITELLM_UI_ALLOW_HEADERS = [
     "x-litellm-semantic-filter",
     "x-litellm-semantic-filter-tools",
+    "x-litellm-adaptive-router-model",
 ]
 
 # Gemini model-specific minimal thinking budget constants

litellm/images/main.py

@@ -410,6 +410,7 @@ def image_generation(  # noqa: PLR0915
             litellm.LlmProviders.RUNWAYML,
             litellm.LlmProviders.VERTEX_AI,
             litellm.LlmProviders.OPENROUTER,
+            litellm.LlmProviders.DASHSCOPE,
         ):
             if image_generation_config is None:
                 raise ValueError(

litellm/integrations/custom_guardrail.py

@@ -2,6 +2,7 @@ from datetime import datetime
 from typing import (
     TYPE_CHECKING,
     Any,
+    ClassVar,
     Dict,
     List,
     Literal,
@@ -12,6 +13,7 @@ from typing import (
 )
 
 from litellm._logging import verbose_logger
+from litellm.litellm_core_utils.core_helpers import redact_nested_match_and_regex_keys
 from litellm.caching import DualCache
 from litellm.integrations.custom_logger import CustomLogger
 from litellm.types.guardrails import (
@@ -81,6 +83,9 @@ class ModifyResponseException(Exception):
 
 
 class CustomGuardrail(CustomLogger):
+    # If True, during_call runs async_moderation_hook instead of the unified apply_guardrail path.
+    use_native_during_call_hook: ClassVar[bool] = False
+
     def __init__(
         self,
         guardrail_name: Optional[str] = None,
@@ -637,6 +642,13 @@ class CustomGuardrail(CustomLogger):
                 if isinstance(item, dict):
                     item.pop("secret_fields", None)
 
+        # Default-safe behavior: never persist raw matched spans in standard
+        # guardrail logging payloads (single shared implementation; Bedrock hooks pass
+        # raw provider JSON so redaction is not duplicated upstream).
+        clean_guardrail_response = redact_nested_match_and_regex_keys(
+            clean_guardrail_response
+        )
+
         slg = StandardLoggingGuardrailInformation(
             guardrail_name=self.guardrail_name,
             guardrail_provider=guardrail_provider,

litellm/litellm_core_utils/core_helpers.py

@@ -1,5 +1,6 @@
 # What is this?
 ## Helper utilities
+import copy
 from typing import TYPE_CHECKING, Any, Iterable, List, Literal, Optional, Union
 
 import httpx
@@ -435,3 +436,42 @@ def filter_internal_params(
 
     # Filter out internal parameters
     return {k: v for k, v in data.items() if k not in internal_params}
+
+
+def redact_nested_match_and_regex_keys(
+    payload: Union[dict, List[Any], str, None],
+) -> Union[dict, List[Any], str, None]:
+    """
+    Deep-copy `payload` and replace every `match` / `regex` string field with
+    "[REDACTED]" anywhere in nested dict/list structures.
+
+    Used for guardrail spend/compliance logging so raw spans are not persisted.
+    """
+    if payload is None or isinstance(payload, str):
+        return payload
+    try:
+        redacted: Union[dict, List[Any], str, None] = copy.deepcopy(payload)
+    except Exception:
+        return payload
+
+    # Iterative traversal; `seen` guards against cyclic refs preserved by deepcopy.
+    try:
+        seen: set = set()
+        stack: List[Any] = [redacted]
+        while stack:
+            node = stack.pop()
+            node_id = id(node)
+            if node_id in seen:
+                continue
+            seen.add(node_id)
+            if isinstance(node, dict):
+                if "match" in node:
+                    node["match"] = "[REDACTED]"
+                if "regex" in node:
+                    node["regex"] = "[REDACTED]"
+                stack.extend(node.values())
+            elif isinstance(node, list):
+                stack.extend(node)
+    except Exception:
+        return payload
+    return redacted

litellm/litellm_core_utils/logging_worker.py

@@ -370,11 +370,17 @@ class LoggingWorker:
         self._running_tasks.clear()
 
     async def flush(self) -> None:
-        """Flush the logging queue."""
+        """Flush the logging queue.
+
+        Waits until every enqueued task has completed. ``queue.join()`` blocks
+        on the queue's unfinished-task counter (decremented by ``task_done()``),
+        so it correctly handles items that have been dequeued but whose
+        callback hasn't finished yet — ``queue.empty()`` would return True in
+        that window and cause us to skip the wait.
+        """
         if self._queue is None:
             return
-        while not self._queue.empty():
-            await self._queue.join()
+        await self._queue.join()
 
     async def clear_queue(self):
         """

litellm/litellm_core_utils/prompt_templates/common_utils.py

@@ -452,7 +452,14 @@ def update_messages_with_model_file_ids(
                 for c in content:
                     if c["type"] == "file":
                         file_object = cast(ChatCompletionFileObject, c)
-                        file_object_file_field = file_object["file"]
+                        file_object_file_field = file_object.get("file")
+                        if not isinstance(file_object_file_field, dict):
+                            # Content block has `type: "file"` but not the
+                            # OpenAI Chat Completions shape (e.g. a LangChain
+                            # v1 standardized file block, or a provider-native
+                            # shape that also uses `type: "file"`). Nothing to
+                            # remap here, so skip instead of crashing.
+                            continue
                         file_id = file_object_file_field.get("file_id")
                         format = file_object_file_field.get(
                             "format", get_format_from_file_id(file_id)
@@ -1060,7 +1067,12 @@ def get_file_ids_from_messages(messages: List[AllMessageValues]) -> List[str]:
                 for c in content:
                     if c["type"] == "file":
                         file_object = cast(ChatCompletionFileObject, c)
-                        file_object_file_field = file_object["file"]
+                        file_object_file_field = file_object.get("file")
+                        if not isinstance(file_object_file_field, dict):
+                            # Content block has `type: "file"` but not the
+                            # OpenAI Chat Completions shape. No file_id to
+                            # extract, so skip instead of raising KeyError.
+                            continue
                         file_id = file_object_file_field.get("file_id")
                         if file_id:
                             file_ids.append(file_id)

litellm/litellm_core_utils/prompt_templates/factory.py

@@ -15,6 +15,7 @@ import litellm.types
 import litellm.types.llms
 from litellm import verbose_logger
 from litellm._uuid import uuid
+from litellm.litellm_core_utils.url_utils import async_safe_get, safe_get
 from litellm.llms.custom_httpx.http_handler import HTTPHandler, get_async_httpx_client
 from litellm.types.files import get_file_extension_from_mime_type
 from litellm.types.llms.anthropic import *
@@ -3324,7 +3325,7 @@ def _load_image_from_url(image_url):
     try:
         # Send a GET request to the image URL
         client = HTTPHandler(concurrent_limit=1)
-        response = client.get(image_url)
+        response = safe_get(client, image_url)
         response.raise_for_status()  # Raise an exception for HTTP errors
 
         # Check the response's content type to ensure it is an image
@@ -3562,7 +3563,7 @@ class BedrockImageProcessor:
                 params={"concurrent_limit": 1},
             )
             # Send a GET request to the image URL
-            response = await client.get(image_url, follow_redirects=True)
+            response = await async_safe_get(client, image_url)
             response.raise_for_status()  # Raise an exception for HTTP errors
 
             return BedrockImageProcessor._post_call_image_processing(
@@ -3577,7 +3578,7 @@ class BedrockImageProcessor:
         try:
             client = HTTPHandler(concurrent_limit=1)
             # Send a GET request to the image URL
-            response = client.get(image_url, follow_redirects=True)
+            response = safe_get(client, image_url)
             response.raise_for_status()  # Raise an exception for HTTP errors
 
             return BedrockImageProcessor._post_call_image_processing(

litellm/litellm_core_utils/token_counter.py

@@ -23,6 +23,7 @@ from litellm.constants import (
     DEFAULT_IMAGE_HEIGHT,
     DEFAULT_IMAGE_TOKEN_COUNT,
     DEFAULT_IMAGE_WIDTH,
+    MAX_IMAGE_URL_DOWNLOAD_SIZE_MB,
     MAX_LONG_SIDE_FOR_IMAGE_HIGH_RES,
     MAX_SHORT_SIDE_FOR_IMAGE_HIGH_RES,
     MAX_TILE_HEIGHT,
@@ -215,7 +216,14 @@ def get_image_dimensions(
         try:
             client = _get_httpx_client()
             response = safe_get(client, data)
-            img_data = response.read()
+            max_bytes = int(MAX_IMAGE_URL_DOWNLOAD_SIZE_MB * 1024 * 1024)
+            content_length = response.headers.get("Content-Length")
+            if content_length is not None and int(content_length) > max_bytes:
+                pass  # skip download; img_data stays None
+            else:
+                body = response.read()
+                if len(body) <= max_bytes:
+                    img_data = body
         except Exception:
             pass
     if img_data is None:

litellm/llms/anthropic/experimental_pass_through/adapters/handler.py

@@ -106,6 +106,44 @@ class LiteLLMMessagesToCompletionTransformationHandler:
                     updated_reasoning_effort["summary"] = effective_summary
                     completion_kwargs["reasoning_effort"] = updated_reasoning_effort
 
+    @staticmethod
+    def _normalize_reasoning_effort(
+        completion_kwargs: Dict[str, Any],
+    ) -> None:
+        """
+        Normalize reasoning_effort values based on target model capabilities.
+
+        Handles both string ("max") and dict ({"effort": "max", "summary": ...})
+        formats. Uses model registry to check supports_xhigh/supports_minimal.
+        """
+        from litellm.llms.anthropic.experimental_pass_through.utils import (
+            normalize_reasoning_effort_value,
+        )
+
+        reasoning_effort = completion_kwargs.get("reasoning_effort")
+        if reasoning_effort is None:
+            return
+
+        model = cast(str, completion_kwargs.get("model", ""))
+        custom_llm_provider = completion_kwargs.get("custom_llm_provider")
+
+        if isinstance(reasoning_effort, str):
+            normalized = normalize_reasoning_effort_value(
+                reasoning_effort, model=model, custom_llm_provider=custom_llm_provider
+            )
+            if normalized != reasoning_effort:
+                completion_kwargs["reasoning_effort"] = normalized
+        elif isinstance(reasoning_effort, dict) and "effort" in reasoning_effort:
+            effort = reasoning_effort["effort"]
+            normalized = normalize_reasoning_effort_value(
+                effort, model=model, custom_llm_provider=custom_llm_provider
+            )
+            if normalized != effort:
+                completion_kwargs["reasoning_effort"] = {
+                    **reasoning_effort,
+                    "effort": normalized,
+                }
+
     @staticmethod
     def _prepare_completion_kwargs(
         *,
@@ -163,6 +201,12 @@ class LiteLLMMessagesToCompletionTransformationHandler:
         if output_format:
             request_data["output_format"] = output_format
 
+        # Extract output_config from extra_kwargs so the translator can use it
+        # (e.g. output_config.effort for adaptive thinking → reasoning_effort)
+        extra_kwargs = extra_kwargs or {}
+        if "output_config" in extra_kwargs:
+            request_data["output_config"] = extra_kwargs["output_config"]
+
         (
             openai_request,
             tool_name_mapping,
@@ -202,6 +246,14 @@ class LiteLLMMessagesToCompletionTransformationHandler:
             ):
                 completion_kwargs[key] = value
 
+        # Normalize reasoning_effort based on model capabilities
+        # (e.g. "max" → "xhigh"/"high", "minimal" → "low" if unsupported)
+        # Must run BEFORE _route_openai_thinking, which prepends "responses/"
+        # to the model name and would break get_model_info() lookups.
+        LiteLLMMessagesToCompletionTransformationHandler._normalize_reasoning_effort(
+            completion_kwargs
+        )
+
         LiteLLMMessagesToCompletionTransformationHandler._route_openai_thinking_to_responses_api_if_needed(
             completion_kwargs,
             thinking=thinking,

litellm/llms/anthropic/experimental_pass_through/adapters/transformation.py

@@ -317,6 +317,7 @@ class LiteLLMAnthropicMessagesAdapter:
             "tools",
             "thinking",
             "output_format",
+            "output_config",
         ]
 
     def _is_web_search_tool(self, tool: Dict[str, Any]) -> bool:
@@ -694,6 +695,11 @@ class LiteLLMAnthropicMessagesAdapter:
                 return "low"
             else:
                 return "minimal"
+        elif thinking_type == "adaptive":
+            # Adaptive thinking: effort is controlled by output_config.effort,
+            # not budget_tokens. Return a default; caller should override with
+            # output_config.effort when available.
+            return "medium"
 
         return None
 
@@ -776,6 +782,8 @@ class LiteLLMAnthropicMessagesAdapter:
             return ChatCompletionToolChoiceObjectParam(
                 type="function", function=tc_function_param
             )
+        elif tool_choice["type"] == "none":
+            return "none"
         else:
             raise ValueError(
                 "Incompatible tool choice param submitted - {}".format(tool_choice)
@@ -1041,6 +1049,12 @@ class LiteLLMAnthropicMessagesAdapter:
         if not reasoning_effort:
             return
 
+        # For adaptive thinking, override with output_config.effort if available
+        if isinstance(thinking, dict) and thinking.get("type") == "adaptive":
+            output_config = anthropic_message_request.get("output_config")
+            if isinstance(output_config, dict) and output_config.get("effort"):
+                reasoning_effort = output_config["effort"]
+
         summary = thinking.get("summary") if isinstance(thinking, dict) else None
         auto_summary = is_reasoning_auto_summary_enabled()
         if summary:

litellm/llms/anthropic/experimental_pass_through/messages/handler.py

@@ -24,6 +24,8 @@ from litellm.types.llms.anthropic_messages.anthropic_response import (
 from litellm.types.router import GenericLiteLLMParams
 from litellm.utils import ProviderConfigManager, client
 
+from ..utils import is_reasoning_auto_summary_enabled
+
 from ..adapters.handler import LiteLLMMessagesToCompletionTransformationHandler
 from ..responses_adapters.handler import LiteLLMMessagesToResponsesAPIHandler
 from .interceptors import get_messages_interceptors
@@ -441,6 +443,17 @@ def anthropic_messages_handler(
             params=local_vars
         )
     )
+    if is_reasoning_auto_summary_enabled():
+        thinking_param = anthropic_messages_optional_request_params.get("thinking")
+        if (
+            isinstance(thinking_param, dict)
+            and thinking_param.get("type") != "disabled"
+        ):
+            anthropic_messages_optional_request_params["thinking"] = {
+                **thinking_param,
+                "display": "summarized",
+            }
+
     return base_llm_http_handler.anthropic_messages_handler(
         model=model,
         messages=messages,

litellm/llms/anthropic/experimental_pass_through/responses_adapters/handler.py

@@ -72,6 +72,23 @@ def _build_responses_kwargs(
     anthropic_request = AnthropicMessagesRequest(**request_data)  # type: ignore[typeddict-item]
     responses_kwargs = _ADAPTER.translate_request(anthropic_request)
 
+    # Normalize reasoning effort based on model capabilities
+    # (e.g. "max" → "xhigh"/"high", "minimal" → "low" if unsupported)
+    reasoning = responses_kwargs.get("reasoning")
+    if isinstance(reasoning, dict) and "effort" in reasoning:
+        from litellm.llms.anthropic.experimental_pass_through.utils import (
+            normalize_reasoning_effort_value,
+        )
+
+        effort = reasoning["effort"]
+        normalized = normalize_reasoning_effort_value(
+            effort,
+            model=model,
+            custom_llm_provider=(extra_kwargs or {}).get("custom_llm_provider"),
+        )
+        if normalized != effort:
+            responses_kwargs["reasoning"] = {**reasoning, "effort": normalized}
+
     if stream:
         responses_kwargs["stream"] = True
 

litellm/llms/anthropic/experimental_pass_through/responses_adapters/transformation.py

@@ -251,25 +251,41 @@ class LiteLLMAnthropicToResponsesAPIAdapter:
 
     @staticmethod
     def translate_thinking_to_reasoning(
-        thinking: Dict[str, Any]
+        thinking: Dict[str, Any],
+        output_config: Optional[Dict[str, Any]] = None,
     ) -> Optional[Dict[str, Any]]:
         """
         Convert Anthropic thinking param to Responses API reasoning param.
 
         thinking.budget_tokens maps to reasoning effort:
           >= 10000 -> high, >= 5000 -> medium, >= 2000 -> low, < 2000 -> minimal
+
+        For adaptive thinking, uses output_config.effort if available,
+        otherwise defaults to medium.
         """
-        if not isinstance(thinking, dict) or thinking.get("type") != "enabled":
+        if not isinstance(thinking, dict):
             return None
-        budget = thinking.get("budget_tokens", 0)
-        if budget >= 10000:
-            effort = "high"
-        elif budget >= 5000:
+
+        thinking_type = thinking.get("type")
+
+        if thinking_type == "adaptive":
+            # Use output_config.effort if available
             effort = "medium"
-        elif budget >= 2000:
-            effort = "low"
+            if isinstance(output_config, dict) and output_config.get("effort"):
+                effort = output_config["effort"]
+        elif thinking_type == "enabled":
+            budget = thinking.get("budget_tokens", 0)
+            if budget >= 10000:
+                effort = "high"
+            elif budget >= 5000:
+                effort = "medium"
+            elif budget >= 2000:
+                effort = "low"
+            else:
+                effort = "minimal"
         else:
-            effort = "minimal"
+            return None
+
         auto_summary = is_reasoning_auto_summary_enabled()
         result: Dict[str, Any] = {"effort": effort}
         summary = thinking.get("summary")
@@ -346,7 +362,11 @@ class LiteLLMAnthropicToResponsesAPIAdapter:
         # thinking -> reasoning
         thinking = anthropic_request.get("thinking")
         if isinstance(thinking, dict):
-            reasoning = self.translate_thinking_to_reasoning(thinking)
+            output_config = anthropic_request.get("output_config")
+            reasoning = self.translate_thinking_to_reasoning(
+                thinking,
+                output_config=cast(Optional[Dict[str, Any]], output_config),
+            )
             if reasoning:
                 responses_kwargs["reasoning"] = reasoning
 

litellm/llms/anthropic/experimental_pass_through/utils.py

@@ -1,6 +1,8 @@
 import os
+from typing import Optional
 
 import litellm
+from litellm.types.utils import ModelInfo
 
 
 def is_reasoning_auto_summary_enabled() -> bool:
@@ -9,3 +11,47 @@ def is_reasoning_auto_summary_enabled() -> bool:
         litellm.reasoning_auto_summary
         or os.getenv("LITELLM_REASONING_AUTO_SUMMARY", "false").lower() == "true"
     )
+
+
+def normalize_reasoning_effort_value(
+    effort: str,
+    model: str,
+    custom_llm_provider: Optional[str] = None,
+) -> str:
+    """
+    Normalize a reasoning effort value based on model capabilities.
+
+    Degradation chains:
+    - "max"     → max / xhigh / high
+    - "xhigh"   → xhigh / high
+    - "minimal" → minimal / low
+    - other values pass through unchanged
+    """
+    if effort not in ("max", "xhigh", "minimal"):
+        return effort
+
+    from litellm.utils import get_model_info
+
+    model_info: Optional[ModelInfo] = None
+    try:
+        model_info = get_model_info(
+            model=model, custom_llm_provider=custom_llm_provider
+        )
+    except Exception:
+        model_info = None
+
+    if effort == "max":
+        if model_info and model_info.get("supports_max_reasoning_effort"):
+            return "max"
+        if model_info and model_info.get("supports_xhigh_reasoning_effort"):
+            return "xhigh"
+        return "high"
+    elif effort == "xhigh":
+        if model_info and model_info.get("supports_xhigh_reasoning_effort"):
+            return "xhigh"
+        return "high"
+    elif effort == "minimal":
+        if model_info and model_info.get("supports_minimal_reasoning_effort"):
+            return "minimal"
+        return "low"
+    return "medium"

litellm/llms/azure/chat/gpt_5_transformation.py

@@ -40,9 +40,22 @@ class AzureOpenAIGPT5Config(AzureOpenAIConfig, OpenAIGPT5Config):
         Accepts both explicit gpt-5 model names and the ``gpt5_series/`` prefix
         used for manual routing.
         """
-        # gpt-5-chat* is a chat model and shouldn't go through GPT-5 reasoning restrictions.
+        # The gpt-5-chat* family (gpt-5-chat, gpt-5-chat-latest, gpt-5-chat-2025-08-07,
+        # …) are regular chat models: they support temperature and tool_choice but NOT
+        # reasoning_effort.  They must NOT be routed through the GPT-5 reasoning path.
+        #
+        # Versioned chat models such as gpt-5.3-chat and gpt-5.1-chat ARE reasoning
+        # models and must stay on the GPT-5 path.  The distinguishing feature is that
+        # the gpt-5-chat family has a literal "-chat" immediately after "gpt-5"
+        # (i.e. "gpt-5-chat…"), while versioned chat models interpose a minor version
+        # number (i.e. "gpt-5.<digit>-chat").
+        #
+        # Using a startswith("gpt-5-chat") prefix check on the normalized name (rather
+        # than a substring check) makes this boundary explicit and avoids any ambiguity
+        # if future model names coincidentally contain "gpt-5-chat" as an interior run.
+        _normalized = model.split("/")[-1]  # strip provider prefix, e.g. "azure/"
         return (
-            "gpt-5" in model and "gpt-5-chat" not in model
+            "gpt-5" in model and not _normalized.startswith("gpt-5-chat")
         ) or "gpt5_series" in model
 
     def get_supported_openai_params(self, model: str) -> List[str]:

litellm/llms/azure/image_edit/transformation.py

@@ -14,6 +14,8 @@ class AzureImageEditConfig(OpenAIImageEditConfig):
         headers: dict,
         model: str,
         api_key: Optional[str] = None,
+        litellm_params: Optional[dict] = None,
+        api_base: Optional[str] = None,
     ) -> dict:
         api_key = (
             api_key

litellm/llms/azure_ai/image_edit/flux2_transformation.py

@@ -65,6 +65,8 @@ class AzureFoundryFlux2ImageEditConfig(OpenAIImageEditConfig):
         headers: dict,
         model: str,
         api_key: Optional[str] = None,
+        litellm_params: Optional[dict] = None,
+        api_base: Optional[str] = None,
     ) -> dict:
         """
         Validate Azure AI Foundry environment and set up authentication

litellm/llms/azure_ai/image_edit/transformation.py

@@ -25,6 +25,8 @@ class AzureFoundryFluxImageEditConfig(OpenAIImageEditConfig):
         headers: dict,
         model: str,
         api_key: Optional[str] = None,
+        litellm_params: Optional[dict] = None,
+        api_base: Optional[str] = None,
     ) -> dict:
         """
         Validate Azure AI Foundry environment and set up authentication

litellm/llms/base_llm/image_edit/transformation.py

@@ -67,6 +67,8 @@ class BaseImageEditConfig(ABC):
         headers: dict,
         model: str,
         api_key: Optional[str] = None,
+        litellm_params: Optional[dict] = None,
+        api_base: Optional[str] = None,
     ) -> dict:
         return {}
 

litellm/llms/bedrock/batches/transformation.py

@@ -1,4 +1,5 @@
 import os
+import re
 import time
 from typing import Any, Dict, List, Literal, Optional, Union, cast
 
@@ -294,7 +295,8 @@ class BedrockBatchesConfig(BaseAWSLLM, BaseBatchesConfig):
             raise ValueError(f"Invalid ARN format: {batch_id}")
 
         region = arn_parts[3]
-        # arn_parts[5] contains "model-invocation-job/{jobId}"
+        if not re.match(r"^[a-z][a-z0-9-]*$", region):
+            raise ValueError(f"Invalid region in ARN: {batch_id}")
 
         # Build the endpoint URL for GetModelInvocationJob
         # AWS API format: GET /model-invocation-job/{jobIdentifier}

litellm/llms/bedrock/image_edit/amazon_nova_canvas_image_edit_transformation.py

@@ -483,6 +483,8 @@ class BedrockAmazonNovaCanvasImageEditConfig(BaseImageEditConfig):
         headers: dict,
         model: str,
         api_key: Optional[str] = None,
+        litellm_params: Optional[dict] = None,
+        api_base: Optional[str] = None,
     ) -> dict:
         if headers is None:
             headers = {}

litellm/llms/bedrock/image_edit/stability_transformation.py

@@ -372,6 +372,8 @@ class BedrockStabilityImageEditConfig(BaseImageEditConfig):
         headers: dict,
         model: str,
         api_key: Optional[str] = None,
+        litellm_params: Optional[dict] = None,
+        api_base: Optional[str] = None,
     ) -> dict:
         """
         Validate environment for Bedrock Stability image edit.

litellm/llms/black_forest_labs/image_edit/transformation.py

@@ -14,7 +14,9 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
 import httpx
 from httpx._types import RequestFiles
 
+import litellm
 from litellm.constants import DEFAULT_MAX_RECURSE_DEPTH
+from litellm.litellm_core_utils.url_utils import safe_get
 from litellm.llms.base_llm.image_edit.transformation import BaseImageEditConfig
 from litellm.secret_managers.main import get_secret_str
 from litellm.types.images.main import ImageEditOptionalRequestParams
@@ -123,6 +125,8 @@ class BlackForestLabsImageEditConfig(BaseImageEditConfig):
         headers: dict,
         model: str,
         api_key: Optional[str] = None,
+        litellm_params: Optional[dict] = None,
+        api_base: Optional[str] = None,
     ) -> dict:
         """
         Validate environment and set up headers for Black Forest Labs.
@@ -206,14 +210,14 @@ class BlackForestLabsImageEditConfig(BaseImageEditConfig):
             )
         elif isinstance(image, str):
             if image.startswith(("http://", "https://")):
-                # Download image from URL
-                response = httpx.get(image, timeout=60.0)
+                response = safe_get(litellm.module_level_client, image, timeout=60.0)
                 response.raise_for_status()
                 return response.content
             else:
-                # Assume it's a file path
-                with open(image, "rb") as f:
-                    return f.read()
+                raise ValueError(
+                    "Unsupported image input: plain string values that are not URLs are not accepted. "
+                    "Provide image bytes or a file-like object."
+                )
         elif hasattr(image, "read"):
             # File-like object
             pos = getattr(image, "tell", lambda: 0)()

litellm/llms/custom_httpx/llm_http_handler.py

@@ -5515,6 +5515,8 @@ class BaseLLMHTTPHandler:
             api_key=litellm_params.api_key,
             headers=image_edit_optional_request_params.get("extra_headers", {}) or {},
             model=model,
+            litellm_params=dict(litellm_params),
+            api_base=litellm_params.api_base,
         )
 
         if extra_headers:
@@ -5611,6 +5613,8 @@ class BaseLLMHTTPHandler:
             api_key=litellm_params.api_key,
             headers=image_edit_optional_request_params.get("extra_headers", {}) or {},
             model=model,
+            litellm_params=dict(litellm_params),
+            api_base=litellm_params.api_base,
         )
 
         if extra_headers:

litellm/llms/dashscope/image_generation/__init__.py

@@ -0,0 +1,11 @@
+from litellm.llms.base_llm.image_generation.transformation import (
+    BaseImageGenerationConfig,
+)
+
+from .transformation import DashScopeImageGenerationConfig
+
+__all__ = ["DashScopeImageGenerationConfig"]
+
+
+def get_dashscope_image_generation_config(model: str) -> BaseImageGenerationConfig:
+    return DashScopeImageGenerationConfig()

litellm/llms/dashscope/image_generation/transformation.py

@@ -0,0 +1,204 @@
+"""
+DashScope Image Generation Configuration
+
+Handles transformation between OpenAI-compatible format and DashScope multimodal-generation API.
+
+API endpoint: POST https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/multimodal-generation/generation
+
+Request format:
+{
+    "model": "qwen-image-2.0-pro",
+    "input": {
+        "messages": [{"role": "user", "content": [{"text": "<prompt>"}]}]
+    },
+    "parameters": {"size": "1024*1024", ...}
+}
+
+Response format:
+{
+    "output": {
+        "choices": [{"message": {"content": [{"image": "<url>"}]}}]
+    },
+    "usage": {"input_tokens": 0, "output_tokens": 0, "width": 1024, "height": 1024, "image_count": 1}
+}
+"""
+
+from typing import TYPE_CHECKING, Any, List, Optional
+
+import httpx
+
+from litellm.llms.base_llm.image_generation.transformation import (
+    BaseImageGenerationConfig,
+)
+from litellm.secret_managers.main import get_secret_str
+from litellm.types.llms.openai import (
+    AllMessageValues,
+    OpenAIImageGenerationOptionalParams,
+)
+from litellm.types.utils import ImageObject, ImageResponse
+
+if TYPE_CHECKING:
+    from litellm.litellm_core_utils.litellm_logging import Logging as _LiteLLMLoggingObj
+
+    LiteLLMLoggingObj = _LiteLLMLoggingObj
+else:
+    LiteLLMLoggingObj = Any
+
+DEFAULT_API_BASE = "https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/multimodal-generation/generation"
+
+# Maps OpenAI size strings (WxH) to DashScope size strings (W*H)
+OPENAI_TO_DASHSCOPE_SIZE: dict = {
+    "256x256": "256*256",
+    "512x512": "512*512",
+    "1024x1024": "1024*1024",
+    "1792x1024": "1792*1024",
+    "1024x1792": "1024*1792",
+    "2048x2048": "2048*2048",
+}
+
+
+class DashScopeImageGenerationConfig(BaseImageGenerationConfig):
+    """
+    Configuration for DashScope image generation (qwen-image-2.0, qwen-image-2.0-pro).
+    """
+
+    def get_supported_openai_params(
+        self, model: str
+    ) -> List[OpenAIImageGenerationOptionalParams]:
+        return ["n", "size"]
+
+    def map_openai_params(
+        self,
+        non_default_params: dict,
+        optional_params: dict,
+        model: str,
+        drop_params: bool,
+    ) -> dict:
+        supported_params = self.get_supported_openai_params(model)
+        mapped: dict = {}
+        for k, v in non_default_params.items():
+            if k in optional_params:
+                continue
+            if k not in supported_params:
+                continue
+            if k == "size":
+                # Convert "WxH" → "W*H"
+                mapped["size"] = OPENAI_TO_DASHSCOPE_SIZE.get(v, v.replace("x", "*"))
+            elif k == "n":
+                mapped["image_count"] = v
+        return mapped
+
+    def get_complete_url(
+        self,
+        api_base: Optional[str],
+        api_key: Optional[str],
+        model: str,
+        optional_params: dict,
+        litellm_params: dict,
+        stream: Optional[bool] = None,
+    ) -> str:
+        return (
+            api_base or get_secret_str("DASHSCOPE_API_BASE_IMAGE") or DEFAULT_API_BASE
+        )
+
+    def validate_environment(
+        self,
+        headers: dict,
+        model: str,
+        messages: List[AllMessageValues],
+        optional_params: dict,
+        litellm_params: dict,
+        api_key: Optional[str] = None,
+        api_base: Optional[str] = None,
+    ) -> dict:
+        final_api_key = api_key or get_secret_str("DASHSCOPE_API_KEY")
+        if not final_api_key:
+            raise ValueError("DASHSCOPE_API_KEY is not set")
+        headers["Authorization"] = f"Bearer {final_api_key}"
+        headers["Content-Type"] = "application/json"
+        return headers
+
+    def transform_image_generation_request(
+        self,
+        model: str,
+        prompt: str,
+        optional_params: dict,
+        litellm_params: dict,
+        headers: dict,
+    ) -> dict:
+        """
+        Transform OpenAI-style image generation request to DashScope multimodal-generation format.
+        """
+        parameters: dict = {}
+        for k, v in optional_params.items():
+            parameters[k] = v
+
+        return {
+            "model": model,
+            "input": {
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": [{"text": prompt}],
+                    }
+                ]
+            },
+            "parameters": parameters,
+        }
+
+    def transform_image_generation_response(
+        self,
+        model: str,
+        raw_response: httpx.Response,
+        model_response: ImageResponse,
+        logging_obj: LiteLLMLoggingObj,
+        request_data: dict,
+        optional_params: dict,
+        litellm_params: dict,
+        encoding: Any,
+        api_key: Optional[str] = None,
+        json_mode: Optional[bool] = None,
+    ) -> ImageResponse:
+        """
+        Transform DashScope response to litellm ImageResponse.
+
+        DashScope response: output.choices[0].message.content[0].image
+        OpenAI response:    data[0].url
+        """
+        if raw_response.status_code != 200:
+            raise self.get_error_class(
+                error_message=raw_response.text,
+                status_code=raw_response.status_code,
+                headers=raw_response.headers,
+            )
+
+        try:
+            response_data = raw_response.json()
+        except Exception as e:
+            raise self.get_error_class(
+                error_message=f"Failed to parse DashScope image generation response: {e}",
+                status_code=raw_response.status_code,
+                headers=raw_response.headers,
+            )
+
+        # DashScope can return API-level errors in a 200 response body.
+        # Example: {"code": "InvalidParameter", "message": "Size not supported"}
+        if "code" in response_data and "output" not in response_data:
+            raise self.get_error_class(
+                error_message=str(response_data.get("message", response_data)),
+                status_code=raw_response.status_code,
+                headers=raw_response.headers,
+            )
+
+        if not model_response.data:
+            model_response.data = []
+
+        choices = response_data.get("output", {}).get("choices", [])
+        for choice in choices:
+            content_list = choice.get("message", {}).get("content", [])
+            for content_item in content_list:
+                image_url = content_item.get("image")
+                if image_url:
+                    model_response.data.append(ImageObject(url=image_url))
+
+        return model_response

litellm/llms/gemini/image_edit/transformation.py

@@ -54,6 +54,8 @@ class GeminiImageEditConfig(BaseImageEditConfig):
         headers: dict,
         model: str,
         api_key: Optional[str] = None,
+        litellm_params: Optional[dict] = None,
+        api_base: Optional[str] = None,
     ) -> dict:
         final_api_key: Optional[str] = api_key or get_secret_str("GEMINI_API_KEY")
         if not final_api_key:

litellm/llms/litellm_proxy/image_edit/transformation.py

@@ -8,7 +8,12 @@ class LiteLLMProxyImageEditConfig(OpenAIImageEditConfig):
     """Configuration for image edit requests routed through LiteLLM Proxy."""
 
     def validate_environment(
-        self, headers: dict, model: str, api_key: Optional[str] = None
+        self,
+        headers: dict,
+        model: str,
+        api_key: Optional[str] = None,
+        litellm_params: Optional[dict] = None,
+        api_base: Optional[str] = None,
     ) -> dict:
         api_key = api_key or get_secret_str("LITELLM_PROXY_API_KEY")
         headers.update({"Authorization": f"Bearer {api_key}"})

litellm/llms/openai/chat/gpt_5_transformation.py

@@ -53,9 +53,21 @@ class OpenAIGPT5Config(OpenAIGPTConfig):
 
     @classmethod
     def is_model_gpt_5_model(cls, model: str) -> bool:
-        # gpt-5-chat* behaves like a regular chat model (supports temperature, etc.)
-        # Don't route it through GPT-5 reasoning-specific parameter restrictions.
-        return "gpt-5" in model and "gpt-5-chat" not in model
+        # The gpt-5-chat* family (gpt-5-chat, gpt-5-chat-latest, gpt-5-chat-2025-08-07,
+        # …) are regular chat models: they support temperature and tool_choice but NOT
+        # reasoning_effort.  They must NOT be routed through the GPT-5 reasoning path.
+        #
+        # Versioned chat models such as gpt-5.3-chat and gpt-5.1-chat ARE reasoning
+        # models and must stay on the GPT-5 path.  The distinguishing feature is that
+        # the gpt-5-chat family has a literal "-chat" immediately after "gpt-5"
+        # (i.e. "gpt-5-chat…"), while versioned chat models interpose a minor version
+        # number (i.e. "gpt-5.<digit>-chat").
+        #
+        # Using a startswith("gpt-5-chat") prefix check on the normalized name (rather
+        # than a substring check) makes this boundary explicit and avoids any ambiguity
+        # if future model names coincidentally contain "gpt-5-chat" as an interior run.
+        _normalized = model.split("/")[-1]  # strip provider prefix, e.g. "openai/"
+        return "gpt-5" in model and not _normalized.startswith("gpt-5-chat")
 
     @classmethod
     def is_model_gpt_5_search_model(cls, model: str) -> bool:

litellm/llms/openai/image_edit/transformation.py

@@ -165,6 +165,8 @@ class OpenAIImageEditConfig(BaseImageEditConfig):
         headers: dict,
         model: str,
         api_key: Optional[str] = None,
+        litellm_params: Optional[dict] = None,
+        api_base: Optional[str] = None,
     ) -> dict:
         api_key = (
             api_key

litellm/llms/openrouter/image_edit/transformation.py

@@ -116,6 +116,8 @@ class OpenRouterImageEditConfig(BaseImageEditConfig):
         headers: dict,
         model: str,
         api_key: Optional[str] = None,
+        litellm_params: Optional[dict] = None,
+        api_base: Optional[str] = None,
     ) -> dict:
         api_key = api_key or litellm.api_key or get_secret_str("OPENROUTER_API_KEY")
         if not api_key:

litellm/llms/ovhcloud/chat/transformation.py

@@ -8,9 +8,8 @@ More information on our website: https://endpoints.ai.cloud.ovh.net
 from typing import Optional, Union, List
 
 import httpx
-from litellm.utils import ModelResponseStream, _get_model_info_helper
+from litellm.utils import ModelResponseStream
 from litellm.llms.openai.chat.gpt_transformation import OpenAIGPTConfig
-from litellm._logging import verbose_logger
 from litellm.llms.ovhcloud.utils import OVHCloudException
 from litellm.llms.base_llm.base_model_iterator import BaseModelResponseIterator
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
@@ -22,34 +21,6 @@ class OVHCloudChatConfig(OpenAIGPTConfig):
     def custom_llm_provider(self) -> Optional[str]:
         return "ovhcloud"
 
-    def get_supported_openai_params(self, model: str) -> list:
-        """
-        Details about function calling support can be found here:
-        https://help.ovhcloud.com/csm/en-gb-public-cloud-ai-endpoints-function-calling?id=kb_article_view&sysparm_article=KB0071907
-        """
-        supports_function_calling: Optional[bool] = None
-        try:
-            model_info = _get_model_info_helper(model, custom_llm_provider="ovhcloud")
-            supports_function_calling = model_info.get(
-                "supports_function_calling", None
-            )
-            if supports_function_calling is None:
-                supports_function_calling = False
-        except Exception as e:
-            verbose_logger.debug(f"Error getting supported OpenAI params: {e}")
-            supports_function_calling = False
-
-        optional_params = super().get_supported_openai_params(model)
-        if supports_function_calling is not True:
-            verbose_logger.debug(
-                "You can see our models supporting function_calling in our catalog: https://endpoints.ai.cloud.ovh.net/catalog "
-            )
-            optional_params.remove("tools")
-            optional_params.remove("tool_choice")
-            optional_params.remove("function_call")
-            optional_params.remove("response_format")
-        return optional_params
-
     def get_complete_url(
         self,
         api_base: Optional[str],

litellm/llms/recraft/image_edit/transformation.py

@@ -81,6 +81,8 @@ class RecraftImageEditConfig(BaseImageEditConfig):
         headers: dict,
         model: str,
         api_key: Optional[str] = None,
+        litellm_params: Optional[dict] = None,
+        api_base: Optional[str] = None,
     ) -> dict:
         final_api_key: Optional[str] = api_key or get_secret_str("RECRAFT_API_KEY")
         if not final_api_key:

litellm/llms/s3_vectors/vector_stores/transformation.py

@@ -1,3 +1,4 @@
+import re
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
 
 import httpx
@@ -66,6 +67,8 @@ class S3VectorsVectorStoreConfig(BaseVectorStoreConfig, BaseAWSLLM):
         aws_region_name = litellm_params.get("aws_region_name")
         if not aws_region_name:
             raise ValueError("aws_region_name is required for S3 Vectors")
+        if not re.match(r"^[a-z][a-z0-9-]*$", aws_region_name):
+            raise ValueError("Invalid aws_region_name format")
         return f"https://s3vectors.{aws_region_name}.api.aws"
 
     def transform_search_vector_store_request(

litellm/llms/snowflake/utils.py

@@ -1,3 +1,4 @@
+import re
 from typing import TYPE_CHECKING, Any, List, Optional, Tuple
 
 from litellm.secret_managers.main import get_secret_str
@@ -61,6 +62,8 @@ class SnowflakeBaseConfig:
                 account_id = get_secret_str("SNOWFLAKE_ACCOUNT_ID")
             if account_id is None:
                 raise ValueError("Missing snowflake account_id")
+            if not re.match(r"^[a-zA-Z0-9_-]+$", account_id):
+                raise ValueError("Invalid account_id format")
             api_base = f"https://{account_id}.snowflakecomputing.com/api/v2"
 
         api_base = api_base.rstrip("/")

litellm/llms/stability/image_edit/transformations.py

@@ -149,6 +149,8 @@ class StabilityImageEditConfig(BaseImageEditConfig):
         headers: dict,
         model: str,
         api_key: Optional[str] = None,
+        litellm_params: Optional[dict] = None,
+        api_base: Optional[str] = None,
     ) -> dict:
         """
         Validate environment and set up headers for Stability AI.

litellm/llms/vertex_ai/common_utils.py

@@ -229,11 +229,20 @@ def get_vertex_base_url(
 ) -> str:
     """
     Get the base URL for Vertex AI API calls.
+
+    - ``global`` uses the global control plane host.
+    - Multi-region geographies (e.g. ``us``, ``eu``) use ``aiplatform.{geo}.rep.googleapis.com``.
+    - Regional locations (e.g. ``us-central1``) use ``{region}-aiplatform.googleapis.com``.
     """
     if vertex_location == "global":
         return "https://aiplatform.googleapis.com"
-    else:
-        return f"https://{vertex_location}-aiplatform.googleapis.com"
+    if vertex_location is None:
+        raise ValueError("vertex_location is required")
+    if not re.match(r"^[a-z][a-z0-9-]*$", vertex_location):
+        raise ValueError("Invalid vertex_location format")
+    if "-" not in vertex_location:
+        return f"https://aiplatform.{vertex_location}.rep.googleapis.com"
+    return f"https://{vertex_location}-aiplatform.googleapis.com"
 
 
 def _get_embedding_url(

litellm/llms/vertex_ai/gemini/transformation.py

@@ -132,26 +132,28 @@ def _extract_max_media_resolution_from_messages(
     return max_resolution
 
 
-def _apply_gemini_3_metadata(
+def _apply_gemini_metadata(
     part: PartType,
     model: Optional[str],
     media_resolution_enum: Optional[Dict[str, str]],
     video_metadata: Optional[Dict[str, Any]],
 ) -> PartType:
     """
-    Apply the unique media_resolution and video_metadata parameters of Gemini 3+
+    Apply media_resolution and video_metadata parameters to a Gemini part.
+
+    - Per-part media_resolution: Gemini 3+ only (2.x uses generation_config global).
+    - video_metadata (fps, startOffset, endOffset): all Gemini models (1.x, 2.x, 3+).
     """
     if model is None:
         return part
 
     from .vertex_and_google_ai_studio_gemini import VertexGeminiConfig
 
-    if not VertexGeminiConfig._is_gemini_3_or_newer(model):
-        return part
-
     part_dict = dict(part)
 
-    if media_resolution_enum is not None:
+    if media_resolution_enum is not None and VertexGeminiConfig._is_gemini_3_or_newer(
+        model
+    ):
         part_dict["media_resolution"] = media_resolution_enum
 
     if video_metadata is not None:
@@ -206,7 +208,7 @@ def _process_gemini_media(
                 mime_type = format
             file_data = FileDataType(mime_type=mime_type, file_uri=image_url)
             part: PartType = {"file_data": file_data}
-            return _apply_gemini_3_metadata(
+            return _apply_gemini_metadata(
                 part, model, media_resolution_enum, video_metadata
             )
         elif (
@@ -216,14 +218,14 @@ def _process_gemini_media(
         ):
             file_data = FileDataType(mime_type=image_type, file_uri=image_url)
             part = {"file_data": file_data}
-            return _apply_gemini_3_metadata(
+            return _apply_gemini_metadata(
                 part, model, media_resolution_enum, video_metadata
             )
         elif "http://" in image_url or "https://" in image_url or "base64" in image_url:
             image = convert_to_anthropic_image_obj(image_url, format=format)
             _blob: BlobType = {"data": image["data"], "mime_type": image["media_type"]}
             part = {"inline_data": cast(BlobType, _blob)}
-            return _apply_gemini_3_metadata(
+            return _apply_gemini_metadata(
                 part, model, media_resolution_enum, video_metadata
             )
         raise Exception("Invalid image received - {}".format(image_url))
@@ -733,9 +735,9 @@ def _transform_request_body(  # noqa: PLR0915
             **filtered_params
         )
 
-        # For Gemini 2.x models, add media_resolution to generation_config (global)
-        # Gemini 3+ supports per-part media_resolution, but 2.x only supports global
-        # Gemini 1.x does not support mediaResolution at all
+        # For Gemini 2.x models, also add media_resolution to generation_config (global)
+        # as a fallback, since some 2.x versions may not support per-part media_resolution.
+        # Gemini 1.x does not support mediaResolution at all.
         if "gemini-2" in model:
             max_media_resolution = _extract_max_media_resolution_from_messages(messages)
             if max_media_resolution:

litellm/llms/vertex_ai/image_edit/vertex_imagen_transformation.py

@@ -103,10 +103,24 @@ class VertexAIImagenImageEditConfig(BaseImageEditConfig, VertexLLM):
         headers: dict,
         model: str,
         api_key: Optional[str] = None,
+        litellm_params: Optional[dict] = None,
+        api_base: Optional[str] = None,
     ) -> dict:
         headers = headers or {}
-        vertex_project = self._resolve_vertex_project()
-        vertex_credentials = self._resolve_vertex_credentials()
+        litellm_params = litellm_params or {}
+
+        _api_base = litellm_params.get("api_base") or api_base
+        if _api_base is not None:
+            return headers
+
+        vertex_project = (
+            self.safe_get_vertex_ai_project(litellm_params)
+            or self._resolve_vertex_project()
+        )
+        vertex_credentials = (
+            self.safe_get_vertex_ai_credentials(litellm_params)
+            or self._resolve_vertex_credentials()
+        )
         access_token, _ = self._ensure_access_token(
             credentials=vertex_credentials,
             project_id=vertex_project,
@@ -123,8 +137,14 @@ class VertexAIImagenImageEditConfig(BaseImageEditConfig, VertexLLM):
         """
         Get the complete URL for Vertex AI Imagen predict API
         """
-        vertex_project = self._resolve_vertex_project()
-        vertex_location = self._resolve_vertex_location()
+        vertex_project = (
+            self.safe_get_vertex_ai_project(litellm_params)
+            or self._resolve_vertex_project()
+        )
+        vertex_location = (
+            self.safe_get_vertex_ai_location(litellm_params)
+            or self._resolve_vertex_location()
+        )
 
         if not vertex_project or not vertex_location:
             raise ValueError(
@@ -348,13 +368,16 @@ class VertexAIImagenImageEditConfig(BaseImageEditConfig, VertexLLM):
             if stream_pos is not None:
                 image.seek(stream_pos)
             return data
-        if isinstance(image, (str, Path)):
-            path_obj = Path(image)
-            if not path_obj.exists():
-                raise ValueError(
-                    f"Mask/image path does not exist for Vertex AI Imagen image edit: {path_obj}"
-                )
-            return path_obj.read_bytes()
+        if isinstance(image, str):
+            raise ValueError(
+                "Unsupported image input: plain string values are not accepted for "
+                "Vertex AI Imagen image edit. Provide image bytes or a file-like object."
+            )
+        if isinstance(image, Path):
+            raise ValueError(
+                "Unsupported image input: filesystem paths are not accepted for "
+                "Vertex AI Imagen image edit. Provide image bytes or a file-like object."
+            )
         if hasattr(image, "read"):
             data = image.read()
             if isinstance(data, str):

litellm/model_prices_and_context_window_backup.json

@@ -1006,7 +1006,8 @@
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
         "supports_native_structured_output": true,
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "global.anthropic.claude-opus-4-6-v1": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -1034,7 +1035,8 @@
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
         "supports_native_structured_output": true,
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "us.anthropic.claude-opus-4-6-v1": {
         "cache_creation_input_token_cost": 6.875e-06,
@@ -1062,7 +1064,8 @@
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
         "supports_native_structured_output": true,
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "eu.anthropic.claude-opus-4-6-v1": {
         "cache_creation_input_token_cost": 6.875e-06,
@@ -1090,7 +1093,8 @@
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
         "supports_native_structured_output": true,
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "au.anthropic.claude-opus-4-6-v1": {
         "cache_creation_input_token_cost": 6.875e-06,
@@ -1118,7 +1122,8 @@
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
         "supports_native_structured_output": true,
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "anthropic.claude-opus-4-7": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -1146,7 +1151,9 @@
         "supports_vision": true,
         "supports_xhigh_reasoning_effort": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "global.anthropic.claude-opus-4-7": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -1174,7 +1181,9 @@
         "supports_vision": true,
         "supports_xhigh_reasoning_effort": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "us.anthropic.claude-opus-4-7": {
         "cache_creation_input_token_cost": 6.875e-06,
@@ -1202,7 +1211,9 @@
         "supports_vision": true,
         "supports_xhigh_reasoning_effort": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "eu.anthropic.claude-opus-4-7": {
         "cache_creation_input_token_cost": 6.875e-06,
@@ -1230,7 +1241,9 @@
         "supports_vision": true,
         "supports_xhigh_reasoning_effort": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "au.anthropic.claude-opus-4-7": {
         "cache_creation_input_token_cost": 6.875e-06,
@@ -1258,7 +1271,9 @@
         "supports_vision": true,
         "supports_xhigh_reasoning_effort": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "anthropic.claude-sonnet-4-6": {
         "cache_creation_input_token_cost": 3.75e-06,
@@ -1285,7 +1300,8 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_minimal_reasoning_effort": true
     },
     "global.anthropic.claude-sonnet-4-6": {
         "cache_creation_input_token_cost": 3.75e-06,
@@ -1312,7 +1328,8 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_minimal_reasoning_effort": true
     },
     "us.anthropic.claude-sonnet-4-6": {
         "cache_creation_input_token_cost": 4.125e-06,
@@ -1339,7 +1356,8 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_minimal_reasoning_effort": true
     },
     "eu.anthropic.claude-sonnet-4-6": {
         "cache_creation_input_token_cost": 4.125e-06,
@@ -1366,7 +1384,8 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_minimal_reasoning_effort": true
     },
     "au.anthropic.claude-sonnet-4-6": {
         "cache_creation_input_token_cost": 4.125e-06,
@@ -1393,7 +1412,8 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_minimal_reasoning_effort": true
     },
     "anthropic.claude-sonnet-4-20250514-v1:0": {
         "cache_creation_input_token_cost": 3.75e-06,
@@ -1911,7 +1931,8 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 159,
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "azure_ai/claude-opus-4-7": {
         "input_cost_per_token": 5e-06,
@@ -1939,7 +1960,9 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "supports_xhigh_reasoning_effort": true,
-        "tool_use_system_prompt_tokens": 159
+        "tool_use_system_prompt_tokens": 159,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "azure_ai/claude-opus-4-1": {
         "cache_creation_input_token_cost": 1.875e-05,
@@ -2003,7 +2026,8 @@
         "supports_response_schema": true,
         "supports_tool_choice": true,
         "supports_vision": true,
-        "tool_use_system_prompt_tokens": 346
+        "tool_use_system_prompt_tokens": 346,
+        "supports_minimal_reasoning_effort": true
     },
     "azure/computer-use-preview": {
         "input_cost_per_token": 3e-06,
@@ -8909,7 +8933,8 @@
         "supports_response_schema": true,
         "supports_tool_choice": true,
         "supports_vision": true,
-        "tool_use_system_prompt_tokens": 346
+        "tool_use_system_prompt_tokens": 346,
+        "supports_minimal_reasoning_effort": true
     },
     "claude-sonnet-4-5-20250929-v1:0": {
         "cache_creation_input_token_cost": 3.75e-06,
@@ -9103,7 +9128,8 @@
             "us": 1.1,
             "fast": 6.0
         },
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "claude-opus-4-6-20260205": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -9135,7 +9161,8 @@
             "us": 1.1,
             "fast": 6.0
         },
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "claude-opus-4-7": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -9167,7 +9194,9 @@
         "provider_specific_entry": {
             "us": 1.1,
             "fast": 6.0
-        }
+        },
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "claude-opus-4-7-20260416": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -9199,7 +9228,9 @@
         "provider_specific_entry": {
             "us": 1.1,
             "fast": 6.0
-        }
+        },
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "claude-sonnet-4-20250514": {
         "deprecation_date": "2026-05-14",
@@ -10352,6 +10383,22 @@
         "supports_reasoning": true,
         "supports_tool_choice": true
     },
+    "dashscope/qwen-image-2.0": {
+        "litellm_provider": "dashscope",
+        "mode": "image_generation",
+        "source": "https://www.alibabacloud.com/help/en/model-studio/models",
+        "supported_endpoints": [
+            "/v1/images/generations"
+        ]
+    },
+    "dashscope/qwen-image-2.0-pro": {
+        "litellm_provider": "dashscope",
+        "mode": "image_generation",
+        "source": "https://www.alibabacloud.com/help/en/model-studio/models",
+        "supported_endpoints": [
+            "/v1/images/generations"
+        ]
+    },
     "databricks/databricks-bge-large-en": {
         "input_cost_per_token": 1.0003e-07,
         "input_dbu_cost_per_token": 1.429e-06,
@@ -19226,6 +19273,42 @@
         "supports_xhigh_reasoning_effort": true,
         "supports_minimal_reasoning_effort": true
     },
+    "gpt-5.5": {
+        "cache_read_input_token_cost": 5e-07,
+        "input_cost_per_token": 5e-06,
+        "litellm_provider": "openai",
+        "max_input_tokens": 272000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 3e-05,
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/batch",
+            "/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_service_tier": true,
+        "supports_vision": true,
+        "supports_none_reasoning_effort": true,
+        "supports_xhigh_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
+    },
     "gpt-5.4": {
         "cache_read_input_token_cost": 2.5e-07,
         "cache_read_input_token_cost_above_272k_tokens": 5e-07,
@@ -25068,7 +25151,8 @@
         "supports_reasoning": true,
         "supports_tool_choice": true,
         "supports_vision": true,
-        "tool_use_system_prompt_tokens": 159
+        "tool_use_system_prompt_tokens": 159,
+        "supports_minimal_reasoning_effort": true
     },
     "openrouter/anthropic/claude-opus-4.5": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -25106,7 +25190,8 @@
         "supports_reasoning": true,
         "supports_tool_choice": true,
         "supports_vision": true,
-        "tool_use_system_prompt_tokens": 346
+        "tool_use_system_prompt_tokens": 346,
+        "supports_minimal_reasoning_effort": true
     },
     "openrouter/anthropic/claude-sonnet-4.5": {
         "input_cost_per_image": 0.0048,
@@ -30134,7 +30219,8 @@
         "supports_reasoning": true,
         "supports_response_schema": true,
         "supports_tool_choice": true,
-        "supports_vision": true
+        "supports_vision": true,
+        "supports_minimal_reasoning_effort": true
     },
     "vercel_ai_gateway/anthropic/claude-sonnet-4": {
         "cache_creation_input_token_cost": 3.75e-06,
@@ -31361,7 +31447,8 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "vertex_ai/claude-opus-4-6@default": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -31388,7 +31475,8 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "vertex_ai/claude-opus-4-7": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -31415,7 +31503,9 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "supports_xhigh_reasoning_effort": true,
-        "tool_use_system_prompt_tokens": 346
+        "tool_use_system_prompt_tokens": 346,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "vertex_ai/claude-opus-4-7@default": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -31442,7 +31532,9 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "supports_xhigh_reasoning_effort": true,
-        "tool_use_system_prompt_tokens": 346
+        "tool_use_system_prompt_tokens": 346,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "vertex_ai/claude-sonnet-4-5": {
         "cache_creation_input_token_cost": 3.75e-06,
@@ -31494,7 +31586,8 @@
             "search_context_size_high": 0.01,
             "search_context_size_low": 0.01,
             "search_context_size_medium": 0.01
-        }
+        },
+        "supports_minimal_reasoning_effort": true
     },
     "vertex_ai/claude-sonnet-4-5@20250929": {
         "cache_creation_input_token_cost": 3.75e-06,
@@ -38361,7 +38454,8 @@
             "search_context_size_high": 0.01,
             "search_context_size_low": 0.01,
             "search_context_size_medium": 0.01
-        }
+        },
+        "supports_minimal_reasoning_effort": true
     },
     "duckduckgo/search": {
         "litellm_provider": "duckduckgo",

litellm/proxy/_experimental/mcp_server/semantic_tool_filter.py

@@ -7,6 +7,7 @@ Filters MCP tools semantically for /chat/completions and /responses endpoints.
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from litellm._logging import verbose_logger
+from litellm.proxy._experimental.mcp_server.utils import MCP_TOOL_PREFIX_SEPARATOR
 
 if TYPE_CHECKING:
     from semantic_router.routers import SemanticRouter
@@ -214,20 +215,89 @@ class SemanticMCPToolFilter:
 
         return []
 
+    @staticmethod
+    def _name_matches_canonical(client_name: str, canonical: str) -> bool:
+        """
+        Return True if a client-side tool name refers to the given canonical
+        MCP tool name.
+
+        MCP clients (e.g. opencode) commonly wrap the proxy's canonical tool
+        name with an additive namespace prefix of their own
+        (``<client_alias><sep><canonical>``). The prefix can use either a
+        dash or an underscore as separator regardless of what
+        ``MCP_TOOL_PREFIX_SEPARATOR`` is set to on the proxy, because the
+        client doesn't know the proxy's separator.
+
+        The match is anchored: ``canonical`` must form the complete suffix
+        of ``client_name`` and be preceded by a separator character, so
+        ``rain_gear`` does not match canonical ``ear``.
+
+        Suffix matching is additionally gated on ``canonical`` itself
+        containing ``MCP_TOOL_PREFIX_SEPARATOR``. Server-registered MCP
+        tools are always emitted as
+        ``<server_name><MCP_TOOL_PREFIX_SEPARATOR><tool_name>`` (see
+        ``add_server_prefix_to_name``), so a canonical without the
+        separator is not a namespaced MCP tool and falling back to
+        suffix matching would spuriously collide with unrelated local
+        user functions whose names end in the same characters.
+        """
+        if client_name == canonical:
+            return True
+        if MCP_TOOL_PREFIX_SEPARATOR not in canonical:
+            return False
+        if len(client_name) <= len(canonical):
+            return False
+        if not client_name.endswith(canonical):
+            return False
+        separator = client_name[-len(canonical) - 1]
+        return separator in ("_", "-")
+
     def _get_tools_by_names(
         self, tool_names: List[str], available_tools: List[Any]
     ) -> List[Any]:
-        """Get tools from available_tools by their names, preserving order."""
-        # Match tools from available_tools (preserves format - dict or MCPTool)
-        matched_tools = []
-        for tool in available_tools:
-            tool_name, _ = self._extract_tool_info(tool)
-            if tool_name in tool_names:
-                matched_tools.append(tool)
+        """
+        Get tools from available_tools by their names, preserving the
+        semantic router's ordering.
 
-        # Reorder to match semantic router's ordering
-        tool_map = {self._extract_tool_info(t)[0]: t for t in matched_tools}
-        return [tool_map[name] for name in tool_names if name in tool_map]
+        Matching is tolerant of client-side namespace prefixes: if an
+        incoming tool arrived as ``<client_alias>_<canonical>`` while the
+        router returned ``<canonical>`` (see
+        ``_name_matches_canonical``), that tool is still selected. The
+        returned tool object is the original from ``available_tools``, so
+        the client-facing name is preserved for tool-call round-trips.
+        """
+        # Build an index of incoming tools by their client-facing name.
+        # Exact matches win over suffix matches when both are present, and
+        # each incoming tool is returned at most once even if two canonical
+        # names happen to be tail-compatible with the same incoming name.
+        available_by_name: Dict[str, Any] = {}
+        for tool in available_tools:
+            client_name, _ = self._extract_tool_info(tool)
+            if client_name and client_name not in available_by_name:
+                available_by_name[client_name] = tool
+
+        matched: List[Any] = []
+        used_ids: set = set()
+        for canonical in tool_names:
+            tool = available_by_name.get(canonical)
+            if tool is None:
+                # Prefer the shortest qualifying name. When several
+                # incoming tools suffix-match the same canonical (e.g.
+                # "my_search" and "my_tag_search" both end in "search"),
+                # the one closest in length to the canonical is the
+                # least-wrapped and most likely the intended target.
+                best_name: Optional[str] = None
+                for client_name in available_by_name:
+                    if not self._name_matches_canonical(client_name, canonical):
+                        continue
+                    if best_name is None or len(client_name) < len(best_name):
+                        best_name = client_name
+                if best_name is not None:
+                    tool = available_by_name[best_name]
+            if tool is not None and id(tool) not in used_ids:
+                matched.append(tool)
+                used_ids.add(id(tool))
+        return matched
 
     def extract_user_query(self, messages: List[Dict[str, Any]]) -> str:
         """

litellm/proxy/_new_secret_config.yaml

@@ -1,42 +1,83 @@
+# model_list:
+#   - model_name: claude-sonnet-4-6
+#     litellm_params: {model: anthropic/claude-sonnet-4-6}
+#     model_info:
+#       litellm_routing_preferences:
+#         quality_tier: 1
+#         keywords: [tin]
+#   - model_name: gpt-4o-mini
+#     litellm_params: {model: openai/gpt-4o-mini}
+#     model_info:
+#       litellm_routing_preferences:
+#         quality_tier: 1
+#         keywords: []
+#   - model_name: gpt-4o
+#     litellm_params: {model: openai/gpt-4o}
+#     model_info:
+#       litellm_routing_preferences:
+#         quality_tier: 2
+#         keywords: [vision, function_calling]
+#   - model_name: opus
+#     litellm_params: {model: anthropic/claude-opus-4-7}
+#     model_info:
+#       litellm_routing_preferences:
+#         quality_tier: 3
+#         keywords: ["architecture", "design"]
+#   - model_name: my-quality-router
+#     litellm_params:
+#       model: auto_router/adaptive_router
+#       adaptive_router_default_model: gpt-4o-mini
+#       adaptive_router_config:
+#         available_models: [gpt-4o-mini, gpt-4o, opus, claude-sonnet-4-6]
+# Example proxy config for the adaptive router (v0).
+#
+# Wires one logical router ("smart-cheap-router") that adaptively picks between
+# two real deployments ("fast" and "smart") based on per-session feedback signals.
+#
+# How to use from a client:
+#   POST /v1/chat/completions { "model": "smart-cheap-router", ... }
+#   Add { "metadata": { "litellm_session_id": "<your-session-id>" } } to enable
+#   sticky-session routing within a conversation.
+#
+# Required env vars: OPENAI_API_KEY, DATABASE_URL.
+
 model_list:
-
-  # OpenAI model for /v1/chat/completions test — 200x custom pricing
-  - model_name: "gpt-4.1-mini"
+  # ---- The adaptive router "control" deployment -------------------------
+  # `model_name` is what clients call. `available_models` lists the underlying
+  # deployments the router is allowed to pick from (must match other model_name
+  # entries in this list).
+  - model_name: smart-cheap-router
     litellm_params:
-      model: openai/gpt-4.1-mini
-      api_key: os.environ/OPENAI_API_KEY
-    model_info:
-      id: gpt-4.1-mini-custom-pricing
-      input_cost_per_token: 0.00004        # 100x standard ($0.40/1M = $0.0000004)
-      output_cost_per_token: 0.00016       # 100x standard ($1.60/1M = $0.0000016)
+      model: auto_router/adaptive_router
+      adaptive_router_config:
+        available_models: ["fast", "smart"]
+        weights:
+          quality: 0.7
+          cost: 0.3
 
-  # OpenAI model for /v1/responses test — 100x custom pricing
-  - model_name: "gpt-5"
-    litellm_params:
-      model: openai/gpt-5
-      api_key: os.environ/OPENAI_API_KEY
-    model_info:
-      id: gpt-5-custom-pricing
-      mode: "chat"
-      input_cost_per_token: 125        # 100x standard ($1.25/1M = $0.00000125)
-      output_cost_per_token: 10         # 100x standard ($10.00/1M = $0.00001)
-
-  # Anthropic model for /v1/messages test — 100x custom pricing
-  - model_name: "claude-sonnet-4-6"
+  # ---- Underlying deployments the router picks from ---------------------
+  - model_name: fast
     litellm_params:
       model: anthropic/claude-sonnet-4-6
       api_key: os.environ/ANTHROPIC_API_KEY
+      input_cost_per_token: 0.00000015
     model_info:
-      id: claude-sonnet-4-custom-pricing
-      input_cost_per_token: 0.0003         # 100x standard ($0.000003)
-      output_cost_per_token: 0.0015         # 100x standard ($0.000015)
-  - model_name: my-auto
+      adaptive_router_preferences:
+        quality_tier: 2
+        strengths: []
+
+  - model_name: smart
     litellm_params:
-      model: auto_router/complexity_router
-      complexity_router_config:
-        tiers:
-          SIMPLE: "gpt-4.1-mini"
-          COMPLEX: claude-sonnet-4-6
-        tier_boundaries:
-          simple_medium: 0.30
-      complexity_router_default_model: small-model
+      model: anthropic/claude-opus-4-7
+      api_key: os.environ/ANTHROPIC_API_KEY
+      input_cost_per_token: 0.0000050
+    model_info:
+      adaptive_router_preferences:
+        quality_tier: 3
+        strengths: ["code_generation", "technical_design", "analytical_reasoning"]
+
+litellm_settings:
+  drop_params: True
+
+general_settings:
+  master_key: sk-1234 # REPLACE in production

litellm/proxy/_types.py

@@ -1997,7 +1997,12 @@ class TeamRequest(LiteLLMPydanticObjectBase):
 
 
 class LiteLLM_BudgetTable(LiteLLMPydanticObjectBase):
-    """Represents user-controllable params for a LiteLLM_BudgetTable record"""
+    """Represents user-controllable params for a LiteLLM_BudgetTable record.
+
+    Budget-write paths use `model_fields.keys()` on this class as an allowlist
+    for user input. Keep server-managed fields (e.g. `budget_reset_at`) on
+    `LiteLLM_BudgetTableFull` so they aren't user-settable.
+    """
 
     budget_id: Optional[str] = None
     soft_budget: Optional[float] = None
@@ -2015,7 +2020,7 @@ class LiteLLM_BudgetTable(LiteLLMPydanticObjectBase):
 
 
 class LiteLLM_BudgetTableFull(LiteLLM_BudgetTable):
-    """Represents all params for a LiteLLM_BudgetTable record"""
+    """LiteLLM_BudgetTable + server-managed fields returned on API responses."""
 
     budget_reset_at: Optional[datetime] = None
     created_at: datetime
@@ -3695,7 +3700,11 @@ class LiteLLM_TeamMembership(LiteLLMPydanticObjectBase):
     team_id: str
     budget_id: Optional[str] = None
     spend: Optional[float] = 0.0
-    litellm_budget_table: Optional[LiteLLM_BudgetTable]
+    total_spend: Optional[float] = 0.0
+    # Union so Pydantic picks Full when data has server-managed fields
+    # (/team/info) and Base when callers/tests construct with only
+    # user-settable fields.
+    litellm_budget_table: Optional[Union[LiteLLM_BudgetTableFull, LiteLLM_BudgetTable]]
 
     def safe_get_team_member_rpm_limit(self) -> Optional[int]:
         if self.litellm_budget_table is not None:
@@ -3898,7 +3907,7 @@ class OrganizationMemberUpdateResponse(MemberUpdateResponse):
 
 
 class TeamInfoResponseObjectTeamTable(LiteLLM_TeamTable):
-    team_member_budget_table: Optional[LiteLLM_BudgetTable] = None
+    team_member_budget_table: Optional[LiteLLM_BudgetTableFull] = None
     # Resources inherited from access groups (separate from direct assignments)
     access_group_models: Optional[List[str]] = None
     access_group_mcp_server_ids: Optional[List[str]] = None

litellm/proxy/auth/auth_checks.py

@@ -905,6 +905,63 @@ async def get_default_end_user_budget(
         return None
 
 
+@log_db_metrics
+async def get_team_member_default_budget(
+    budget_id: str,
+    prisma_client: Optional[PrismaClient],
+    user_api_key_cache: DualCache,
+) -> Optional[LiteLLM_BudgetTable]:
+    """
+    Fetches the team-level default per-member budget referenced by team.metadata["team_member_budget_id"].
+
+    This budget is applied to team members whose TeamMembership row has no
+    linked budget. Results are cached for performance.
+
+    Args:
+        budget_id: The budget_id pulled from team.metadata["team_member_budget_id"]
+        prisma_client: Database client instance
+        user_api_key_cache: Cache for storing/retrieving budget data
+
+    Returns:
+        LiteLLM_BudgetTable if found, None otherwise
+    """
+    if prisma_client is None:
+        return None
+
+    cache_key = f"team_member_default_budget:{budget_id}"
+
+    cached_budget = await user_api_key_cache.async_get_cache(key=cache_key)
+    if isinstance(cached_budget, LiteLLM_BudgetTable):
+        return cached_budget
+    if isinstance(cached_budget, dict):
+        return LiteLLM_BudgetTable(**cached_budget)
+
+    try:
+        budget_record = await prisma_client.db.litellm_budgettable.find_unique(
+            where={"budget_id": budget_id}
+        )
+
+        if budget_record is None:
+            verbose_proxy_logger.warning(
+                f"Team-default member budget not found in database: {budget_id}"
+            )
+            return None
+
+        await user_api_key_cache.async_set_cache(
+            key=cache_key,
+            value=budget_record.dict(),
+            ttl=DEFAULT_MANAGEMENT_OBJECT_IN_MEMORY_CACHE_TTL,
+        )
+
+        return LiteLLM_BudgetTable(**budget_record.dict())
+
+    except Exception:
+        verbose_proxy_logger.exception(
+            f"Error fetching team-default member budget {budget_id}"
+        )
+        return None
+
+
 async def _apply_default_budget_to_end_user(
     end_user_obj: LiteLLM_EndUserTable,
     prisma_client: PrismaClient,
@@ -3230,13 +3287,31 @@ async def _check_team_member_budget(
             proxy_logging_obj=proxy_logging_obj,
         )
 
+        # Per-member override wins; otherwise fall back to the team-level
+        # default configured via team.metadata["team_member_budget_id"].
+        team_member_budget: Optional[float] = None
         if (
             team_membership is not None
             and team_membership.litellm_budget_table is not None
-            and team_membership.litellm_budget_table.max_budget is not None
         ):
             team_member_budget = team_membership.litellm_budget_table.max_budget
-            team_member_spend = team_membership.spend or 0.0
+        else:
+            default_budget_id = (team_object.metadata or {}).get(
+                "team_member_budget_id"
+            )
+            if isinstance(default_budget_id, str):
+                default_budget = await get_team_member_default_budget(
+                    budget_id=default_budget_id,
+                    prisma_client=prisma_client,
+                    user_api_key_cache=user_api_key_cache,
+                )
+                if default_budget is not None:
+                    team_member_budget = default_budget.max_budget
+
+        if team_member_budget is not None:
+            team_member_spend = (
+                team_membership.spend if team_membership is not None else 0.0
+            ) or 0.0
 
             # Read from cross-pod counter (Redis-first) if available
             from litellm.proxy.proxy_server import get_current_spend

litellm/proxy/auth/auth_utils.py

@@ -151,7 +151,15 @@ def is_request_body_safe(
     A malicious user can set the api_base to their own domain and invoke POST /chat/completions to intercept and steal the OpenAI API key.
     Relevant issue: https://huntr.com/bounties/4001e1a2-7b7a-4776-a3ae-e6692ec3d997
     """
-    banned_params = ["api_base", "base_url", "user_config"]
+    banned_params = [
+        "api_base",
+        "base_url",
+        "user_config",
+        "aws_sts_endpoint",
+        "aws_web_identity_token",
+        "aws_role_name",
+        "vertex_credentials",
+    ]
 
     for param in banned_params:
         if (

litellm/proxy/common_utils/callback_utils.py

@@ -433,7 +433,8 @@ def add_guardrail_to_applied_guardrails_header(
         return
     _metadata = request_data.get("metadata", None) or {}
     if "applied_guardrails" in _metadata:
-        _metadata["applied_guardrails"].append(guardrail_name)
+        if guardrail_name not in _metadata["applied_guardrails"]:
+            _metadata["applied_guardrails"].append(guardrail_name)
     else:
         _metadata["applied_guardrails"] = [guardrail_name]
     # Ensure metadata is set back to request_data (important when metadata didn't exist)

litellm/proxy/common_utils/reset_budget_job.py

@@ -632,20 +632,27 @@ class ResetBudgetJob:
 
         now = datetime.utcnow()
 
+        # Note on raw SQL: prisma-client-python does not support null-filtering
+        # on `Json?` columns (no DbNull/JsonNull sentinel — see
+        # RobertCraigie/prisma-client-py#714). We use `query_raw` with
+        # `IS NOT NULL` so we don't materialize every key/team row on each
+        # tick of the reset job. Writes still go through the ORM.
+
         # --- Keys ---
         try:
-            all_keys = await self.prisma_client.db.litellm_verificationtoken.find_many(
-                where={"budget_limits": {"not": None}}  # type: ignore[arg-type]
+            key_rows = await self.prisma_client.db.query_raw(
+                'SELECT token, budget_limits FROM "LiteLLM_VerificationToken" '
+                "WHERE budget_limits IS NOT NULL"
             )
-            for key in all_keys:
-                raw = key.budget_limits  # type: ignore[attr-defined]
+            for row in key_rows:
+                raw = row["budget_limits"]
                 if not raw:
                     continue
                 windows: list = raw if isinstance(raw, list) else json.loads(raw)
                 changed = False
                 for window in windows:
                     counter_key = (
-                        f"spend:key:{key.token}:window:{window['budget_duration']}"
+                        f"spend:key:{row['token']}:window:{window['budget_duration']}"
                     )
                     if await ResetBudgetJob._reset_expired_window(
                         window, counter_key, spend_counter_cache, now
@@ -653,7 +660,7 @@ class ResetBudgetJob:
                         changed = True
                 if changed:
                     await self.prisma_client.db.litellm_verificationtoken.update(
-                        where={"token": key.token},
+                        where={"token": row["token"]},
                         data={"budget_limits": json.dumps(windows)},  # type: ignore[arg-type]
                     )
         except Exception as e:
@@ -663,26 +670,25 @@ class ResetBudgetJob:
 
         # --- Teams ---
         try:
-            all_teams = await self.prisma_client.db.litellm_teamtable.find_many(
-                where={"budget_limits": {"not": None}}  # type: ignore[arg-type]
+            team_rows = await self.prisma_client.db.query_raw(
+                'SELECT team_id, budget_limits FROM "LiteLLM_TeamTable" '
+                "WHERE budget_limits IS NOT NULL"
             )
-            for team in all_teams:
-                raw = team.budget_limits  # type: ignore[attr-defined]
+            for row in team_rows:
+                raw = row["budget_limits"]
                 if not raw:
                     continue
                 windows = raw if isinstance(raw, list) else json.loads(raw)
                 changed = False
                 for window in windows:
-                    counter_key = (
-                        f"spend:team:{team.team_id}:window:{window['budget_duration']}"
-                    )
+                    counter_key = f"spend:team:{row['team_id']}:window:{window['budget_duration']}"
                     if await ResetBudgetJob._reset_expired_window(
                         window, counter_key, spend_counter_cache, now
                     ):
                         changed = True
                 if changed:
                     await self.prisma_client.db.litellm_teamtable.update(
-                        where={"team_id": team.team_id},
+                        where={"team_id": row["team_id"]},
                         data={"budget_limits": json.dumps(windows)},  # type: ignore[arg-type]
                     )
         except Exception as e:

litellm/proxy/db/db_spend_update_writer.py

@@ -1300,7 +1300,10 @@ class DBSpendUpdateWriter:
 
                                 batcher.litellm_teammembership.update_many(  # 'update_many' prevents error from being raised if no row exists
                                     where={"team_id": team_id, "user_id": user_id},
-                                    data={"spend": {"increment": response_cost}},
+                                    data={
+                                        "spend": {"increment": response_cost},
+                                        "total_spend": {"increment": response_cost},
+                                    },
                                 )
                     # Transaction succeeded, break out of retry loop
                     break

litellm/proxy/db/db_transaction_queue/redis_update_buffer.py

@@ -22,6 +22,7 @@ from litellm.constants import (
 )
 from litellm.litellm_core_utils.safe_json_dumps import safe_dumps
 from litellm.proxy._types import (
+    BaseDailySpendTransaction,
     DailyAgentSpendTransaction,
     DailyEndUserSpendTransaction,
     DailyOrganizationSpendTransaction,
@@ -29,6 +30,8 @@ from litellm.proxy._types import (
     DailyTeamSpendTransaction,
     DailyUserSpendTransaction,
     DBSpendUpdateTransactions,
+    Litellm_EntityType,
+    SpendUpdateQueueItem,
 )
 from litellm.proxy.db.db_transaction_queue.base_update_queue import service_logger_obj
 from litellm.proxy.db.db_transaction_queue.daily_spend_update_queue import (
@@ -259,9 +262,36 @@ class RedisUpdateBuffer:
         if len(rpush_list) == 0:
             return
 
-        result_lengths = await self.redis_cache.async_rpush_pipeline(
-            rpush_list=rpush_list,
-        )
+        try:
+            result_lengths = await self.redis_cache.async_rpush_pipeline(
+                rpush_list=rpush_list,
+            )
+        except Exception as e:
+            # The in-memory queues were already drained above. If we let the
+            # exception propagate without restoring, the aggregated spend is
+            # permanently lost. Re-enqueue so the next scheduler tick retries.
+            verbose_proxy_logger.error(
+                "Spend tracking - failed to push aggregated spend updates to Redis. "
+                "Restoring %d transaction sets to in-memory queues for retry on next tick. "
+                "Error: %s",
+                len(rpush_list),
+                str(e),
+            )
+            await self._restore_spend_updates_to_in_memory_queues(
+                db_spend_update_transactions=db_spend_update_transactions,
+                daily_spend_update_transactions=daily_spend_update_transactions,
+                daily_team_spend_update_transactions=daily_team_spend_update_transactions,
+                daily_org_spend_update_transactions=daily_org_spend_update_transactions,
+                daily_end_user_spend_update_transactions=daily_end_user_spend_update_transactions,
+                daily_agent_spend_update_transactions=daily_agent_spend_update_transactions,
+                spend_update_queue=spend_update_queue,
+                daily_spend_update_queue=daily_spend_update_queue,
+                daily_team_spend_update_queue=daily_team_spend_update_queue,
+                daily_org_spend_update_queue=daily_org_spend_update_queue,
+                daily_end_user_spend_update_queue=daily_end_user_spend_update_queue,
+                daily_agent_spend_update_queue=daily_agent_spend_update_queue,
+            )
+            return
 
         # Emit gauge events for each queue
         for i, queue_size in enumerate(result_lengths):
@@ -271,6 +301,101 @@ class RedisUpdateBuffer:
                     service=service_types[i],
                 )
 
+    @staticmethod
+    async def _restore_spend_updates_to_in_memory_queues(
+        db_spend_update_transactions: Optional[DBSpendUpdateTransactions],
+        daily_spend_update_transactions: Optional[Dict[str, BaseDailySpendTransaction]],
+        daily_team_spend_update_transactions: Optional[
+            Dict[str, BaseDailySpendTransaction]
+        ],
+        daily_org_spend_update_transactions: Optional[
+            Dict[str, BaseDailySpendTransaction]
+        ],
+        daily_end_user_spend_update_transactions: Optional[
+            Dict[str, BaseDailySpendTransaction]
+        ],
+        daily_agent_spend_update_transactions: Optional[
+            Dict[str, BaseDailySpendTransaction]
+        ],
+        spend_update_queue: SpendUpdateQueue,
+        daily_spend_update_queue: DailySpendUpdateQueue,
+        daily_team_spend_update_queue: DailySpendUpdateQueue,
+        daily_org_spend_update_queue: DailySpendUpdateQueue,
+        daily_end_user_spend_update_queue: DailySpendUpdateQueue,
+        daily_agent_spend_update_queue: DailySpendUpdateQueue,
+    ) -> None:
+        """
+        Put drained-but-unpushed transactions back into in-memory queues.
+
+        Called when the Redis rpush pipeline raises. Without this, all spend
+        data aggregated during the current scheduler tick is permanently lost
+        because the source queues were already drained before the rpush.
+        """
+        if db_spend_update_transactions is not None:
+            entity_entries: List[
+                Tuple[Litellm_EntityType, Optional[Dict[str, float]]]
+            ] = [
+                (
+                    Litellm_EntityType.USER,
+                    db_spend_update_transactions.get("user_list_transactions"),
+                ),
+                (
+                    Litellm_EntityType.END_USER,
+                    db_spend_update_transactions.get("end_user_list_transactions"),
+                ),
+                (
+                    Litellm_EntityType.KEY,
+                    db_spend_update_transactions.get("key_list_transactions"),
+                ),
+                (
+                    Litellm_EntityType.TEAM,
+                    db_spend_update_transactions.get("team_list_transactions"),
+                ),
+                (
+                    Litellm_EntityType.TEAM_MEMBER,
+                    db_spend_update_transactions.get("team_member_list_transactions"),
+                ),
+                (
+                    Litellm_EntityType.ORGANIZATION,
+                    db_spend_update_transactions.get("org_list_transactions"),
+                ),
+                (
+                    Litellm_EntityType.TAG,
+                    db_spend_update_transactions.get("tag_list_transactions"),
+                ),
+                (
+                    Litellm_EntityType.AGENT,
+                    db_spend_update_transactions.get("agent_list_transactions"),
+                ),
+            ]
+            for entity_type, entities in entity_entries:
+                if not entities:
+                    continue
+                for entity_id, cost in entities.items():
+                    await spend_update_queue.add_update(
+                        SpendUpdateQueueItem(
+                            entity_type=entity_type,
+                            entity_id=entity_id,
+                            response_cost=cost,
+                        )
+                    )
+
+        daily_pairs: List[
+            Tuple[Optional[Dict[str, BaseDailySpendTransaction]], DailySpendUpdateQueue]
+        ] = [
+            (daily_spend_update_transactions, daily_spend_update_queue),
+            (daily_team_spend_update_transactions, daily_team_spend_update_queue),
+            (daily_org_spend_update_transactions, daily_org_spend_update_queue),
+            (
+                daily_end_user_spend_update_transactions,
+                daily_end_user_spend_update_queue,
+            ),
+            (daily_agent_spend_update_transactions, daily_agent_spend_update_queue),
+        ]
+        for daily_txns, daily_queue in daily_pairs:
+            if daily_txns:
+                await daily_queue.update_queue.put(daily_txns)
+
     @staticmethod
     def _number_of_transactions_to_store_in_redis(
         db_spend_update_transactions: DBSpendUpdateTransactions,

litellm/proxy/example_config_yaml/adaptive_router_example.yaml

@@ -0,0 +1,52 @@
+# Example proxy config for the adaptive router (v0).
+#
+# Wires one logical router ("smart-cheap-router") that adaptively picks between
+# two real deployments ("fast" and "smart") based on per-session feedback signals.
+#
+# How to use from a client:
+#   POST /v1/chat/completions { "model": "smart-cheap-router", ... }
+#   Add { "metadata": { "litellm_session_id": "<your-session-id>" } } to enable
+#   sticky-session routing within a conversation.
+#
+# Required env vars: OPENAI_API_KEY, DATABASE_URL.
+
+model_list:
+  # ---- The adaptive router "control" deployment -------------------------
+  # `model_name` is what clients call. `available_models` lists the underlying
+  # deployments the router is allowed to pick from (must match other model_name
+  # entries in this list).
+  - model_name: smart-cheap-router
+    litellm_params:
+      model: auto_router/adaptive_router # required prefix -- triggers adaptive-router init
+      adaptive_router_config:
+        available_models: ["fast", "smart"]
+        weights:
+          quality: 0.7
+          cost: 0.3
+
+  # ---- Underlying deployments the router picks from ---------------------
+  - model_name: fast
+    litellm_params:
+      model: openai/gpt-4o-mini
+      api_key: os.environ/OPENAI_API_KEY
+      input_cost_per_token: 0.00000015
+    model_info:
+      adaptive_router_preferences:
+        quality_tier: 2
+        strengths: []
+
+  - model_name: smart
+    litellm_params:
+      model: openai/gpt-4o
+      api_key: os.environ/OPENAI_API_KEY
+      input_cost_per_token: 0.0000050
+    model_info:
+      adaptive_router_preferences:
+        quality_tier: 3
+        strengths: ["code_generation", "technical_design", "analytical_reasoning"]
+
+litellm_settings:
+  drop_params: True
+
+general_settings:
+  master_key: sk-1234 # REPLACE in production

litellm/proxy/guardrails/guardrail_hooks/bedrock_guardrails.py

@@ -5,7 +5,6 @@
 # +-------------------------------------------------------------+
 #  Thank you users! We ❤️ you! - Krrish & Ishaan
 
-import copy
 import os
 import sys
 
@@ -18,6 +17,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     AsyncGenerator,
+    ClassVar,
     Dict,
     List,
     Literal,
@@ -33,6 +33,7 @@ from fastapi import HTTPException
 
 import litellm
 from litellm._logging import verbose_proxy_logger
+from litellm.litellm_core_utils.core_helpers import redact_nested_match_and_regex_keys
 from litellm.caching import DualCache
 from litellm.exceptions import GuardrailInterventionNormalStringError
 from litellm.integrations.custom_guardrail import CustomGuardrail
@@ -79,56 +80,33 @@ class GuardrailMessageFilterResult(NamedTuple):
 
 
 def _redact_pii_matches(response_json: dict) -> dict:
-    try:
-        # Create a deep copy to avoid modifying the original response
-        redacted_response = copy.deepcopy(response_json)
+    """
+    Redact match-like fields from a Bedrock ApplyGuardrail JSON payload.
 
-        # Get assessments from the response
-        # NOTE: We use `.get("key") or []` instead of `.get("key", [])` because
-        # the Bedrock API can return explicit `null` for list fields (e.g. "regexes": null).
-        # In Python, dict.get("key", []) returns None (not []) when the key exists
-        # with a None/null value. The `or []` ensures we always get an iterable,
-        # preventing "TypeError: 'NoneType' object is not iterable".
-        assessments = redacted_response.get("assessments") or []
-        if not assessments:
-            return redacted_response
+    Delegates to :func:`redact_nested_match_and_regex_keys` (same rules as spend
+    logging). Kept as a Bedrock-module entry point for existing unit tests.
+    """
+    redacted = redact_nested_match_and_regex_keys(response_json)
+    return redacted if isinstance(redacted, dict) else response_json
 
-        for assessment in assessments:
-            # Redact PII entities in sensitive information policy
-            sensitive_info_policy = assessment.get("sensitiveInformationPolicy")
-            if sensitive_info_policy:
-                pii_entities = sensitive_info_policy.get("piiEntities") or []
-                for pii_entity in pii_entities:
-                    if "match" in pii_entity:
-                        pii_entity["match"] = "[REDACTED]"
 
-                # Redact regex matches
-                regexes = sensitive_info_policy.get("regexes") or []
-                for regex_match in regexes:
-                    if "match" in regex_match:
-                        regex_match["match"] = "[REDACTED]"
+def _redact_assessment_match_fields(assessments: List[dict]) -> List[dict]:
+    """
+    Redact sensitive match-like fields from blocked assessment summaries.
 
-            # Redact custom word matches in word policy
-            word_policy = assessment.get("wordPolicy")
-            if word_policy:
-                custom_words = word_policy.get("customWords") or []
-                for custom_word in custom_words:
-                    if "match" in custom_word:
-                        custom_word["match"] = "[REDACTED]"
-
-                managed_words = word_policy.get("managedWordLists") or []
-                for managed_word in managed_words:
-                    if "match" in managed_word:
-                        managed_word["match"] = "[REDACTED]"
-
-        return redacted_response
-    except Exception as e:
-        # We do not want to fail in any case so this is just a warning
-        verbose_proxy_logger.warning("Guardrail log redaction failed: %s", str(e))
-        return response_json
+    This is used for customer-visible error payloads (HTTPException.detail) where
+    we want to preserve policy/type/action metadata without echoing raw matched
+    content.
+    """
+    redacted = redact_nested_match_and_regex_keys(assessments)
+    return redacted if isinstance(redacted, list) else assessments
 
 
 class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
+    # During-call must use async_moderation_hook (not unified apply_guardrail), otherwise
+    # OpenAI translation always passes input_type="request" and spend/UI show PRE-CALL.
+    use_native_during_call_hook: ClassVar[bool] = True
+
     def __init__(
         self,
         guardrailIdentifier: Optional[str] = None,
@@ -419,6 +397,7 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
         messages: Optional[List[AllMessageValues]] = None,
         response: Optional[Union[Any, litellm.ModelResponse]] = None,
         request_data: Optional[dict] = None,
+        logging_event_type: Optional[GuardrailEventHooks] = None,
     ) -> BedrockGuardrailResponse:
         from datetime import datetime
 
@@ -456,11 +435,17 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
             prepared_request.headers,
         )
 
-        event_type = (
-            GuardrailEventHooks.pre_call
-            if source == "INPUT"
-            else GuardrailEventHooks.post_call
-        )
+        # UI / spend logs use event_type. Bedrock's `source` is INPUT vs OUTPUT for the API
+        # body, which must not be confused with the proxy hook (pre_call / during_call /
+        # post_call). When omitted, keep legacy mapping for backward compatibility.
+        if logging_event_type is not None:
+            event_type = logging_event_type
+        else:
+            event_type = (
+                GuardrailEventHooks.pre_call
+                if source == "INPUT"
+                else GuardrailEventHooks.post_call
+            )
 
         try:
             httpx_response = await self.async_handler.post(
@@ -515,9 +500,12 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
         #########################################################
         # Add guardrail information to request trace
         #########################################################
+        _json_response = httpx_response.json()
+        # Raw Bedrock JSON is passed here; match/regex redaction runs once inside
+        # CustomGuardrail.add_standard_logging_guardrail_information_to_request_data.
         self.add_standard_logging_guardrail_information_to_request_data(
             guardrail_provider=self.guardrail_provider,
-            guardrail_json_response=httpx_response.json(),
+            guardrail_json_response=_json_response,
             request_data=request_data or {},
             guardrail_status=self._get_bedrock_guardrail_response_status(
                 response=httpx_response
@@ -530,9 +518,10 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
         #########################################################
         if httpx_response.status_code == 200:
             # check if the response was flagged
-            _json_response = httpx_response.json()
-            redacted_response = _redact_pii_matches(_json_response)
-            verbose_proxy_logger.debug("Bedrock AI response : %s", redacted_response)
+            verbose_proxy_logger.debug(
+                "Bedrock AI response : %s",
+                redact_nested_match_and_regex_keys(_json_response),
+            )
             bedrock_guardrail_response = BedrockGuardrailResponse(**_json_response)
             if self._should_raise_guardrail_blocked_exception(
                 bedrock_guardrail_response
@@ -809,7 +798,7 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
 
         assessments = self._extract_blocked_assessments(response)
         if assessments:
-            detail["assessments"] = assessments
+            detail["assessments"] = _redact_assessment_match_fields(assessments)
 
         return HTTPException(status_code=400, detail=detail)
 
@@ -831,8 +820,8 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
             return False
 
         # Check assessments to determine if any actions were BLOCKED (vs ANONYMIZED)
-        # NOTE: Use `or []` instead of default param to handle explicit null from Bedrock API.
-        # See _redact_pii_matches() for detailed explanation of the null safety pattern.
+        # NOTE: Use `.get("k") or []` not `.get("k", [])` — Bedrock can return explicit
+        # JSON null; dict.get("k", []) then yields None, and `for x in None` raises.
         assessments = response.get("assessments") or []
         if not assessments:
             return False
@@ -952,7 +941,10 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
         )
         try:
             bedrock_guardrail_response = await self.make_bedrock_api_request(
-                source="INPUT", messages=filtered_messages, request_data=data
+                source="INPUT",
+                messages=filtered_messages,
+                request_data=data,
+                logging_event_type=GuardrailEventHooks.pre_call,
             )
         except GuardrailInterventionNormalStringError as e:
             bedrock_guardrail_response = e.message
@@ -1024,7 +1016,10 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
         )
         try:
             bedrock_guardrail_response = await self.make_bedrock_api_request(
-                source="INPUT", messages=filtered_messages, request_data=data
+                source="INPUT",
+                messages=filtered_messages,
+                request_data=data,
+                logging_event_type=GuardrailEventHooks.during_call,
             )
         except GuardrailInterventionNormalStringError as e:
             bedrock_guardrail_response = e.message
@@ -1128,9 +1123,13 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
                 source="INPUT",
                 messages=input_messages,
                 request_data=data,
+                logging_event_type=GuardrailEventHooks.post_call,
             )
             output_task = self.make_bedrock_api_request(
-                source="OUTPUT", response=response, request_data=data
+                source="OUTPUT",
+                response=response,
+                request_data=data,
+                logging_event_type=GuardrailEventHooks.post_call,
             )
 
             # Execute both requests in parallel
@@ -1144,7 +1143,10 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
             # Only run OUTPUT validation (INPUT was already validated in pre_call or during_call)
             try:
                 output_content_bedrock = await self.make_bedrock_api_request(
-                    source="OUTPUT", response=response, request_data=data
+                    source="OUTPUT",
+                    response=response,
+                    request_data=data,
+                    logging_event_type=GuardrailEventHooks.post_call,
                 )
             except GuardrailInterventionNormalStringError as e:
                 output_content_bedrock = e.message
@@ -1271,9 +1273,13 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
                     source="INPUT",
                     messages=input_messages,
                     request_data=request_data,
+                    logging_event_type=GuardrailEventHooks.post_call,
                 )  # Only input messages
                 output_task = self.make_bedrock_api_request(
-                    source="OUTPUT", response=assembled_model_response
+                    source="OUTPUT",
+                    response=assembled_model_response,
+                    request_data=request_data,
+                    logging_event_type=GuardrailEventHooks.post_call,
                 )  # Only response
 
                 # Execute both requests in parallel
@@ -1287,7 +1293,10 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
                 # Only run OUTPUT validation (INPUT was already validated in pre_call or during_call)
                 try:
                     output_guardrail_response = await self.make_bedrock_api_request(
-                        source="OUTPUT", response=assembled_model_response
+                        source="OUTPUT",
+                        response=assembled_model_response,
+                        request_data=request_data,
+                        logging_event_type=GuardrailEventHooks.post_call,
                     )
                 except GuardrailInterventionNormalStringError as e:
                     output_guardrail_response = e.message
@@ -1564,6 +1573,11 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
 
             # Bedrock will throw an error if there is no text to process
             if filtered_messages:
+                _log_hook = (
+                    GuardrailEventHooks.pre_call
+                    if input_type == "request"
+                    else GuardrailEventHooks.post_call
+                )
                 # Map the abstract input_type to the Bedrock source parameter.
                 # "request"  -> INPUT  (scan user-supplied content)
                 # "response" -> OUTPUT (scan model-generated content)
@@ -1594,12 +1608,14 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
                         source="OUTPUT",
                         response=synthetic_response,
                         request_data=request_data,
+                        logging_event_type=_log_hook,
                     )
                 else:
                     bedrock_response = await self.make_bedrock_api_request(
                         source="INPUT",
                         messages=filtered_messages,
                         request_data=request_data,
+                        logging_event_type=_log_hook,
                     )
 
                 # Apply any masking that was applied by the guardrail

litellm/proxy/image_endpoints/endpoints.py

@@ -285,6 +285,13 @@ async def image_edit_api(
     if mask_files:
         data["mask"] = mask_files
 
+    for _field in ("image", "mask"):
+        if _field in data and isinstance(data[_field], str):
+            raise HTTPException(
+                status_code=422,
+                detail=f"'{_field}' must be provided as a multipart file upload, not a string.",
+            )
+
     # Ensure prompt exists in data (default to None for models that don't require it)
     if "prompt" not in data:
         data["prompt"] = None

litellm/proxy/management_endpoints/mcp_management_endpoints.py

@@ -52,12 +52,17 @@ from litellm.proxy._experimental.mcp_server.utils import (
 from litellm.proxy._experimental.mcp_server.utils import (
     validate_and_normalize_mcp_server_payload as _base_validate_and_normalize_mcp_server_payload,
 )
+from litellm.proxy.common_utils.encrypt_decrypt_utils import (
+    decrypt_value_helper,
+    encrypt_value_helper,
+)
 
 router = APIRouter(prefix="/v1/mcp", tags=["mcp"])
 
 MCP_AVAILABLE: bool = True
 
 TEMPORARY_MCP_SERVER_TTL_SECONDS = 300
+TEMPORARY_MCP_SERVER_REDIS_KEY_PREFIX = "litellm:mcp:temporary_server"
 
 
 def does_mcp_server_exist(
@@ -329,13 +334,115 @@ if MCP_AVAILABLE:
         )
         return server
 
-    def get_cached_temporary_mcp_server(
+    async def _cache_temporary_mcp_server_in_redis(
+        server: MCPServer, ttl_seconds: int
+    ) -> None:
+        """
+        Best-effort write-through to Redis so temporary MCP OAuth sessions are
+        shared across proxy instances. Keep local in-memory cache as fallback.
+        """
+        if litellm.cache is None or not hasattr(litellm.cache, "cache"):
+            return
+        cache_backend = getattr(litellm.cache, "cache", None)
+        if cache_backend is None or not hasattr(cache_backend, "async_set_cache"):
+            return
+
+        payload: Dict[str, Any] = server.model_dump(mode="json")
+        payload_json = json.dumps(payload)
+        try:
+            encrypted_payload = encrypt_value_helper(payload_json)
+        except Exception as e:
+            verbose_proxy_logger.debug(
+                f"Failed to encrypt temporary MCP server payload for Redis cache: {str(e)}"
+            )
+            return
+
+        if not isinstance(encrypted_payload, str):
+            verbose_proxy_logger.debug(
+                "Encrypted temporary MCP payload is not a string; skipping Redis cache write"
+            )
+            return
+
+        try:
+            await cache_backend.async_set_cache(
+                key=f"{TEMPORARY_MCP_SERVER_REDIS_KEY_PREFIX}:{server.server_id}",
+                value=encrypted_payload,
+                ttl=max(1, ttl_seconds),
+            )
+        except Exception as e:
+            verbose_proxy_logger.debug(
+                f"Failed to write temporary MCP server to Redis cache: {str(e)}"
+            )
+
+    async def _get_temporary_mcp_server_from_redis(
+        server_id: str,
+    ) -> Optional[MCPServer]:
+        """
+        Best-effort read from Redis shared cache. Returns None on miss/errors.
+
+        Values must be encrypted strings (same contract as _cache_temporary_mcp_server_in_redis);
+        legacy plaintext dict payloads are rejected.
+        """
+        if litellm.cache is None or not hasattr(litellm.cache, "cache"):
+            return None
+        cache_backend = getattr(litellm.cache, "cache", None)
+        if cache_backend is None or not hasattr(cache_backend, "async_get_cache"):
+            return None
+
+        try:
+            cached_server = await cache_backend.async_get_cache(
+                key=f"{TEMPORARY_MCP_SERVER_REDIS_KEY_PREFIX}:{server_id}"
+            )
+        except Exception as e:
+            verbose_proxy_logger.debug(
+                f"Failed reading temporary MCP server from Redis cache: {str(e)}"
+            )
+            return None
+
+        if not isinstance(cached_server, str):
+            verbose_proxy_logger.debug(
+                "Temporary MCP Redis cache value must be an encrypted string; rejecting non-string payload"
+            )
+            return None
+
+        decrypted_json = decrypt_value_helper(
+            value=cached_server,
+            key="temporary_mcp_server",
+            exception_type="debug",
+        )
+        if decrypted_json is None:
+            return None
+        try:
+            loaded = json.loads(decrypted_json)
+        except Exception as e:
+            verbose_proxy_logger.debug(
+                f"Invalid decrypted temporary MCP payload in Redis cache: {str(e)}"
+            )
+            return None
+        if not isinstance(loaded, dict):
+            return None
+        payload_dict: Dict[str, Any] = loaded
+
+        try:
+            return MCPServer(**payload_dict)
+        except Exception as e:
+            verbose_proxy_logger.debug(
+                f"Invalid temporary MCP server payload in Redis cache: {str(e)}"
+            )
+            return None
+
+    async def get_cached_temporary_mcp_server(
         server_id: str,
     ) -> Optional[MCPServer]:
         _prune_expired_temporary_mcp_servers()
         entry = _temporary_mcp_servers.get(server_id)
         if entry is None:
-            return None
+            redis_server = await _get_temporary_mcp_server_from_redis(server_id)
+            if redis_server is None:
+                return None
+            # Intentionally avoid repopulating local cache from Redis to prevent
+            # extending effective lifetime beyond the remaining Redis TTL.
+            return redis_server
         return entry.server
 
     def _redact_mcp_credentials(
@@ -1325,6 +1432,10 @@ if MCP_AVAILABLE:
                 temporary_server,
                 ttl_seconds=TEMPORARY_MCP_SERVER_TTL_SECONDS,
             )
+            await _cache_temporary_mcp_server_in_redis(
+                temporary_server,
+                ttl_seconds=TEMPORARY_MCP_SERVER_TTL_SECONDS,
+            )
         except Exception as e:
             verbose_proxy_logger.exception(
                 f"Error caching temporary mcp server: {str(e)}"
@@ -1336,10 +1447,10 @@ if MCP_AVAILABLE:
 
         return _redact_mcp_credentials(temp_record)
 
-    def _get_cached_temporary_mcp_server_or_404(
+    async def _get_cached_temporary_mcp_server_or_404(
         server_id: str, request: Optional[Request] = None
     ) -> MCPServer:
-        server = get_cached_temporary_mcp_server(server_id)
+        server = await get_cached_temporary_mcp_server(server_id)
         if server is None:
             # Fall back to real DB/config server (e.g. for the user-side OAuth flow
             # which calls these endpoints with a real server_id, not a temp session id).
@@ -1378,7 +1489,9 @@ if MCP_AVAILABLE:
         response_type: Optional[str] = None,
         scope: Optional[str] = None,
     ):
-        mcp_server = _get_cached_temporary_mcp_server_or_404(server_id, request=request)
+        mcp_server = await _get_cached_temporary_mcp_server_or_404(
+            server_id, request=request
+        )
         # Use the server's stored client_id when the caller doesn't supply one
         resolved_client_id = mcp_server.client_id or client_id or ""
         if not resolved_client_id:
@@ -1422,7 +1535,9 @@ if MCP_AVAILABLE:
         refresh_token: Optional[str] = Form(None),
         scope: Optional[str] = Form(None),
     ):
-        mcp_server = _get_cached_temporary_mcp_server_or_404(server_id, request=request)
+        mcp_server = await _get_cached_temporary_mcp_server_or_404(
+            server_id, request=request
+        )
         resolved_client_id = mcp_server.client_id or client_id or ""
         if not resolved_client_id:
             raise HTTPException(
@@ -1458,7 +1573,9 @@ if MCP_AVAILABLE:
         server_id: str,
         user_api_key_dict: UserAPIKeyAuth = Depends(user_api_key_auth),
     ):
-        mcp_server = _get_cached_temporary_mcp_server_or_404(server_id, request=request)
+        mcp_server = await _get_cached_temporary_mcp_server_or_404(
+            server_id, request=request
+        )
         request_data = await _read_request_body(request=request)
         data: dict = {**request_data}
 

litellm/proxy/management_endpoints/team_endpoints.py

@@ -302,14 +302,15 @@ class TeamMemberBudgetHandler:
         prisma_client: PrismaClient,
     ) -> None:
         """
-        Create team_memberships entries for existing members that don't have one.
+        Ensure every team member has a TeamMembership row linked to the
+        team_member_budget.
 
-        Called after team_member_budget is set/updated on a team to ensure
-        members who joined before the budget was configured also get budget
-        enforcement.
-
-        Only creates missing entries — does not touch existing memberships
-        (which may carry individual per-member budgets).
+        Called after team_member_budget is set/updated on a team. Creates
+        rows for members who don't have one, and populates budget_id on
+        existing rows where it is NULL. Rows with a non-NULL budget_id
+        are left untouched, which preserves per-member overrides but also
+        means rows pointing to a prior team-default budget_id are not
+        migrated to the new one.
         """
         if not members_with_roles:
             return
@@ -347,6 +348,21 @@ class TeamMemberBudgetHandler:
                 _sanitize_for_log(team_member_budget_id),
             )
 
+        # Heal existing membership rows that predate the team_member_budget
+        # configuration: populate budget_id where it is currently NULL.
+        # Rows with an explicit budget_id (per-member override) are left alone.
+        updated = await prisma_client.db.litellm_teammembership.update_many(
+            where={"team_id": team_id, "budget_id": None},
+            data={"budget_id": team_member_budget_id},
+        )
+        if updated:
+            verbose_proxy_logger.info(
+                "Populated budget_id on %d existing team_memberships for team %s with budget %s",
+                updated,
+                _sanitize_for_log(team_id),
+                _sanitize_for_log(team_member_budget_id),
+            )
+
 
 def _get_default_team_param(field: str) -> Any:
     """

litellm/proxy/management_helpers/utils.py

@@ -9,6 +9,7 @@ from fastapi import HTTPException, Request
 import litellm
 from litellm._logging import verbose_logger
 from litellm._uuid import uuid
+from litellm.proxy.common_utils.timezone_utils import get_budget_reset_time
 from litellm.proxy._types import (  # key request types; user request types; team request types; customer request types
     BudgetNewRequest,
     DeleteCustomerRequest,
@@ -192,6 +193,13 @@ async def _clone_team_default_budget_for_member(
             continue
         cloned_data[field] = value
 
+    # Start the member's budget window at clone time, not the pool's reset
+    # timestamp — otherwise a member joining mid-cycle inherits a stale reset.
+    if cloned_data.get("budget_duration"):
+        cloned_data["budget_reset_at"] = get_budget_reset_time(
+            cloned_data["budget_duration"]
+        )
+
     new_budget = await prisma_client.db.litellm_budgettable.create(data=cloned_data)
     return new_budget.budget_id
 

litellm/proxy/pass_through_endpoints/llm_passthrough_endpoints.py

@@ -8,6 +8,7 @@ Use litellm with Anthropic SDK, Vertex AI SDK, Cohere SDK, etc.
 
 import json
 import os
+import re
 from typing import Any, Optional, Tuple, Union, cast
 
 import httpx
@@ -1496,10 +1497,18 @@ class VertexAIPassThroughHandler(BaseVertexAIPassThroughHandler):
 
 def get_vertex_base_url(vertex_location: Optional[str]) -> str:
     """
-    Returns the base URL for Vertex AI based on the provided location.
+    Base URL for Vertex AI pass-through (trailing slash for URL joining).
+
+    Keep location rules aligned with ``litellm.llms.vertex_ai.common_utils.get_vertex_base_url``.
     """
     if vertex_location == "global":
         return "https://aiplatform.googleapis.com/"
+    if vertex_location is None:
+        raise ValueError("vertex_location is required")
+    if not re.match(r"^[a-z][a-z0-9-]*$", vertex_location):
+        raise ValueError("Invalid vertex_location format")
+    if "-" not in vertex_location:
+        return f"https://aiplatform.{vertex_location}.rep.googleapis.com/"
     return f"https://{vertex_location}-aiplatform.googleapis.com/"
 
 
@@ -1703,7 +1712,8 @@ async def _base_vertex_proxy_route(
     Base function for Vertex AI passthrough routes.
     Handles common logic for all Vertex AI services.
 
-    Default base_target_url is `https://{vertex_location}-aiplatform.googleapis.com/`
+    Default base_target_url is derived from ``get_vertex_base_url`` in this module
+    (regional, ``global``, or multi-region ``.rep.`` hosts), with a trailing slash.
 
     Args:
         endpoint: The endpoint path
@@ -2275,11 +2285,7 @@ async def vertex_ai_live_websocket_passthrough(
         return
 
     host_location = resolved_location or vertex_llm_base.get_default_vertex_location()
-    host = (
-        "aiplatform.googleapis.com"
-        if host_location == "global"
-        else f"{host_location}-aiplatform.googleapis.com"
-    )
+    host = get_vertex_base_url(host_location).removeprefix("https://").rstrip("/")
     service_url = (
         f"wss://{host}/ws/google.cloud.aiplatform.v1.LlmBidiService/BidiGenerateContent"
     )

litellm/proxy/proxy_server.py

@@ -952,6 +952,17 @@ async def proxy_startup_event(app: FastAPI):  # noqa: PLR0915
             _run_background_health_check()
         )  # start the background health check coroutine.
 
+    # Start adaptive-router queue flusher unconditionally — adaptive routers
+    # may be added later via `/config/reload`, and the flusher is a no-op when
+    # `llm_router.adaptive_routers` is empty. Per-router DB state is loaded
+    # lazily by the flusher on first tick (see `_state_loaded` flag) so
+    # hot-reloaded routers also get their persisted priors.
+    if llm_router is not None and getattr(llm_router, "adaptive_routers", None):
+        for _ar in llm_router.adaptive_routers.values():
+            await _ar.load_state_from_db(prisma_client)
+            _ar._state_loaded = True
+    asyncio.create_task(_adaptive_router_flusher_loop())
+
     ## [Optional] Initialize dd tracer
     ProxyStartupEvent._init_dd_tracer()
 
@@ -1897,34 +1908,102 @@ async def increment_spend_counters(
         )
 
 
+async def _reseed_spend_from_db(counter_key: str) -> float:
+    """
+    Read the authoritative spend for a missing counter from the DB. The
+    counter_key prefix encodes the table to query:
+
+        spend:key:{token}                 -> LiteLLM_VerificationToken.spend
+        spend:team:{team_id}              -> LiteLLM_TeamTable.spend
+        spend:team_member:{uid}:{tid}     -> LiteLLM_TeamMembership.spend
+        spend:user:{user_id}              -> LiteLLM_UserTable.spend
+        spend:org:{org_id}                -> LiteLLM_OrganizationTable.spend
+
+    Returns 0.0 if prisma is unavailable, the row is missing, or the
+    key format is unrecognized. On failure, logs and returns 0.0 rather
+    than raising so the caller can still record the current increment.
+    """
+    if prisma_client is None:
+        return 0.0
+    # Per-window counters (spend:*:window:{duration}) share prefixes with
+    # primary counters but don't correspond to a DB row; their ambiguity
+    # would otherwise be silently parsed as a regular counter and miss.
+    if ":window:" in counter_key:
+        return 0.0
+    try:
+        if counter_key.startswith("spend:key:"):
+            token = counter_key[len("spend:key:") :]
+            row = await prisma_client.db.litellm_verificationtoken.find_unique(
+                where={"token": token}
+            )
+        elif counter_key.startswith("spend:team_member:"):
+            suffix = counter_key[len("spend:team_member:") :]
+            if ":" not in suffix:
+                return 0.0
+            user_id, team_id = suffix.rsplit(":", 1)
+            row = await prisma_client.db.litellm_teammembership.find_unique(
+                where={"user_id_team_id": {"user_id": user_id, "team_id": team_id}}
+            )
+        elif counter_key.startswith("spend:team:"):
+            team_id = counter_key[len("spend:team:") :]
+            row = await prisma_client.db.litellm_teamtable.find_unique(
+                where={"team_id": team_id}
+            )
+        elif counter_key.startswith("spend:user:"):
+            user_id = counter_key[len("spend:user:") :]
+            row = await prisma_client.db.litellm_usertable.find_unique(
+                where={"user_id": user_id}
+            )
+        elif counter_key.startswith("spend:org:"):
+            org_id = counter_key[len("spend:org:") :]
+            row = await prisma_client.db.litellm_organizationtable.find_unique(
+                where={"organization_id": org_id}
+            )
+        else:
+            return 0.0
+    except Exception:
+        verbose_proxy_logger.exception(
+            "Failed to reseed spend counter %s from DB", counter_key
+        )
+        return 0.0
+    if row is None:
+        return 0.0
+    return float(getattr(row, "spend", 0.0) or 0.0)
+
+
 async def _init_and_increment_spend_counter(
     counter_key: str,
     source_cache_key: str,
     increment: float,
 ):
     """
-    Initialize counter from cached object's DB-loaded spend if not yet set,
-    then atomically increment in both in-memory and Redis.
+    Initialize counter from the authoritative DB spend value if not yet
+    set, then atomically increment in both in-memory and Redis.
 
     On first access per pod:
-    1. Check spend_counter_cache (in-memory -> Redis via DualCache for init check)
-    2. If not found anywhere, read base spend from user_api_key_cache (DB-loaded object)
+    1. Check spend_counter_cache (in-memory -> Redis via DualCache)
+    2. If not found, reseed from the DB (`_reseed_spend_from_db`). Falls
+       back to the cached object's `.spend` via user_api_key_cache only
+       if prisma is unavailable, since that value can lag the flusher.
     3. Seed counter via async_increment_cache (not async_set_cache) to avoid a
        check-then-set race: if two pods cold-start simultaneously, both may see
-       the counter as absent and seed it. Using increment instead of set means
-       the worst case is over-counting (conservative — blocks slightly early)
-       rather than under-counting (would allow overspend).
+       the counter as absent and seed it. Using increment means the worst case
+       is over-counting (conservative, blocks slightly early) rather than
+       under-counting (would allow overspend).
     4. Increment atomically (both in-memory + Redis)
     """
     current = await spend_counter_cache.async_get_cache(key=counter_key)
     if current is None:
-        source = await user_api_key_cache.async_get_cache(key=source_cache_key)
-        base_spend = 0.0
-        if source is not None:
-            if isinstance(source, dict):
-                base_spend = source.get("spend", 0.0) or 0.0
-            else:
-                base_spend = getattr(source, "spend", 0.0) or 0.0
+        base_spend = await _reseed_spend_from_db(counter_key)
+        if prisma_client is None:
+            # Best-effort fallback when prisma is unavailable (tests or
+            # early-startup paths). May be stale but avoids resetting to 0.
+            source = await user_api_key_cache.async_get_cache(key=source_cache_key)
+            if source is not None:
+                if isinstance(source, dict):
+                    base_spend = source.get("spend", 0.0) or 0.0
+                else:
+                    base_spend = getattr(source, "spend", 0.0) or 0.0
         if base_spend > 0:
             await spend_counter_cache.async_increment_cache(
                 key=counter_key, value=base_spend
@@ -2442,6 +2521,38 @@ def _write_health_state_to_router_cache(
         )
 
 
+_ADAPTIVE_ROUTER_FLUSH_INTERVAL_SECONDS = 10
+
+
+async def _adaptive_router_flusher_loop():
+    """
+    Drain every AdaptiveRouter's in-memory state + session aggregators into
+    Postgres on a fixed cadence. Hot-path writes go to memory; this loop is
+    the only writer to the adaptive router DB tables.
+    """
+    global llm_router, prisma_client
+    while True:
+        try:
+            await asyncio.sleep(_ADAPTIVE_ROUTER_FLUSH_INTERVAL_SECONDS)
+            adaptive_routers = getattr(llm_router, "adaptive_routers", None) or {}
+            if not adaptive_routers or prisma_client is None:
+                continue
+            for ar in adaptive_routers.values():
+                # Lazy state load: covers adaptive routers registered via
+                # `/config/reload` after proxy boot.
+                if not getattr(ar, "_state_loaded", False):
+                    try:
+                        await ar.load_state_from_db(prisma_client)
+                    finally:
+                        ar._state_loaded = True
+                await ar.queue.flush_state_to_db(prisma_client)
+                await ar.queue.flush_session_to_db(prisma_client)
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            verbose_proxy_logger.exception("adaptive_router flusher iteration failed")
+
+
 async def _run_background_health_check():
     """
     Periodically run health checks in the background on the endpoints.
@@ -7246,6 +7357,7 @@ async def chat_completion(  # noqa: PLR0915
             and user_api_key_dict.agent_id is not None
         ):
             data["metadata"]["agent_id"] = user_api_key_dict.agent_id
+
     base_llm_response_processor = ProxyBaseLLMRequestProcessing(data=data)
     try:
         result = await base_llm_response_processor.base_process_llm_request(
@@ -13968,6 +14080,38 @@ async def home(request: Request):
     return "LiteLLM: RUNNING"
 
 
+@router.get(
+    "/adaptive_router/state",
+    tags=["adaptive_router"],
+    dependencies=[Depends(user_api_key_auth)],
+)
+async def get_adaptive_router_state(
+    user_api_key_dict: UserAPIKeyAuth = Depends(user_api_key_auth),
+):
+    """Return live bandit posteriors + queue depth for every configured adaptive router.
+
+    Admin-only. Returns 404 if no adaptive router is configured.
+
+    Response shape: `{"routers": [<snapshot>, ...]}` — one snapshot per
+    adaptive-router deployment. Each snapshot's `router_name` field identifies
+    which deployment it came from.
+    """
+    if user_api_key_dict.user_role != LitellmUserRoles.PROXY_ADMIN:
+        raise HTTPException(
+            status_code=403,
+            detail={"error": CommonProxyErrors.not_allowed_access.value},
+        )
+    if llm_router is None or not llm_router.adaptive_routers:
+        raise HTTPException(
+            status_code=404,
+            detail={"error": "No adaptive_router is configured on this proxy."},
+        )
+    snapshots = [
+        await ar.get_state_snapshot() for ar in llm_router.adaptive_routers.values()
+    ]
+    return {"routers": snapshots}
+
+
 @router.get("/routes", dependencies=[Depends(user_api_key_auth)])
 async def get_routes():
     """

litellm/proxy/schema.prisma

@@ -616,6 +616,7 @@ model LiteLLM_TeamMembership {
   user_id    String
   team_id    String
   spend      Float    @default(0.0)
+  total_spend Float @default(0.0)
   budget_id String?
   litellm_budget_table LiteLLM_BudgetTable?   @relation(fields: [budget_id], references: [budget_id])
   @@id([user_id, team_id])
@@ -1223,3 +1224,46 @@ model LiteLLM_ClaudeCodePluginTable {
 
   @@map("LiteLLM_ClaudeCodePluginTable")
 }
+
+// Per-(router, request_type, model) Beta posterior for the adaptive router.
+model LiteLLM_AdaptiveRouterState {
+  router_name     String
+  request_type    String
+  model_name      String
+  alpha           Float
+  beta            Float
+  total_samples   Int      @default(0)
+  last_updated_at DateTime @default(now()) @updatedAt
+
+  @@id([router_name, request_type, model_name])
+}
+
+// Per-(session, router, model) signal counters for the adaptive router.
+model LiteLLM_AdaptiveRouterSession {
+  session_id             String
+  router_name            String
+  model_name             String
+  classified_type        String
+
+  misalignment_count     Int      @default(0)
+  stagnation_count       Int      @default(0)
+  disengagement_count    Int      @default(0)
+  satisfaction_count     Int      @default(0)
+  failure_count          Int      @default(0)
+  loop_count             Int      @default(0)
+  exhaustion_count       Int      @default(0)
+
+  last_user_content      String?
+  last_assistant_content String?
+  tool_call_history      Json     @default("[]")
+  pending_tool_calls     Json     @default("{}")
+
+  turn_count             Int      @default(0)
+  last_processed_turn    Int      @default(-1)
+  clean_credit_awarded   Boolean  @default(false)
+  terminal_status        Int?
+  last_activity_at       DateTime @default(now()) @updatedAt
+
+  @@id([session_id, router_name, model_name])
+  @@index([last_activity_at], map: "idx_adaptive_router_session_activity")
+}

litellm/proxy/utils.py

@@ -940,7 +940,11 @@ class ProxyLogging:
             Result from the guardrail execution
         """
         # Use unified_guardrail if callback has apply_guardrail method
-        use_unified = "apply_guardrail" in type(callback).__dict__
+        has_apply_guardrail = "apply_guardrail" in type(callback).__dict__
+        use_unified = has_apply_guardrail and not (
+            hook_type == "during_call"
+            and getattr(callback, "use_native_during_call_hook", False)
+        )
         if use_unified:
             data["guardrail_to_apply"] = callback
 
@@ -1540,6 +1544,7 @@ class ProxyLogging:
                 if (
                     "apply_guardrail" in type(callback).__dict__
                     and user_api_key_dict is not None
+                    and not getattr(callback, "use_native_during_call_hook", False)
                 ):
                     data["guardrail_to_apply"] = callback
                     guardrail_task = self._run_guardrail_task_with_enrichment(

litellm/router.py

@@ -200,6 +200,9 @@ if TYPE_CHECKING:
     from litellm.router_strategy.complexity_router.complexity_router import (
         ComplexityRouter,
     )
+    from litellm.router_strategy.adaptive_router.adaptive_router import (
+        AdaptiveRouter,
+    )
     from litellm.router_strategy.quality_router.quality_router import (
         QualityRouter,
     )
@@ -209,6 +212,7 @@ else:
     Span = Any
     AutoRouter = Any
     ComplexityRouter = Any
+    AdaptiveRouter = Any
     QualityRouter = Any
     PreRoutingHookResponse = Any
 
@@ -468,6 +472,7 @@ class Router:
         )  # {"TEAM_ID": PatternMatchRouter}
         self.auto_routers: Dict[str, "AutoRouter"] = {}
         self.complexity_routers: Dict[str, "ComplexityRouter"] = {}
+        self.adaptive_routers: Dict[str, "AdaptiveRouter"] = {}
         self.quality_routers: Dict[str, "QualityRouter"] = {}
 
         # Initialize model_group_alias early since it's used in set_model_list
@@ -5369,8 +5374,13 @@ class Router:
         _request_team_id: Optional[str] = (kwargs.get("metadata", {}) or {}).get(
             "user_api_key_team_id"
         )
-        all_deployments = self._get_all_deployments(
-            model_name=original_model_group, team_id=_request_team_id
+        # Use wildcard-aware lookup so order-based fallback also works for model
+        # groups resolved via pattern routing (e.g. `openai/*` -> `openai/gpt-4.1-mini`).
+        all_deployments = (
+            self.get_model_list(
+                model_name=original_model_group, team_id=_request_team_id
+            )
+            or []
         )
         _order_set: set = {
             litellm.utils._get_deployment_order(d)
@@ -6815,10 +6825,13 @@ class Router:
         Check if the deployment is an auto-router deployment (semantic router).
 
         Returns True if the litellm_params model starts with "auto_router/"
-        but NOT "auto_router/complexity_router" (which uses complexity routing).
+        but NOT "auto_router/complexity_router" or "auto_router/adaptive_router"
+        (which use the complexity-router and adaptive-router strategies).
         """
         if litellm_params.model.startswith("auto_router/complexity_router"):
             return False  # This is handled by complexity_router
+        if litellm_params.model.startswith("auto_router/adaptive_router"):
+            return False  # This is handled by adaptive_router
         if litellm_params.model.startswith("auto_router/quality_router"):
             return False  # This is handled by quality_router
         if litellm_params.model.startswith("auto_router/"):
@@ -6927,6 +6940,144 @@ class Router:
             )
         self.complexity_routers[deployment.model_name] = complexity_router
 
+    def _is_adaptive_router_deployment(self, litellm_params: LiteLLM_Params) -> bool:
+        """True when this deployment opts in via the `auto_router/adaptive_router` model prefix."""
+        return litellm_params.model.startswith("auto_router/adaptive_router")
+
+    def _finalize_adaptive_router_if_configured(self) -> None:
+        """Locate every adaptive-router deployment in the finalized model_list and
+        build an AdaptiveRouter for each. Safe no-op when none are configured.
+        Idempotent: skips any deployment whose model_name is already initialized."""
+        # Drop any adaptive-router hooks left over from a previous Router
+        # instance (e.g. after `/config/reload` replaced `llm_router`). Without
+        # this, stale AdaptiveRouterPostCallHook callbacks from the old Router
+        # remain wired up in `litellm.callbacks` and double-fire signal
+        # recording for every request.
+        from litellm.router_strategy.adaptive_router.hooks import (
+            AdaptiveRouterPostCallHook,
+        )
+
+        for _cb_list in (
+            litellm.callbacks,
+            litellm.success_callback,
+            litellm.failure_callback,
+            litellm._async_success_callback,
+            litellm._async_failure_callback,
+        ):
+            litellm.logging_callback_manager.remove_callbacks_by_type(
+                _cb_list, AdaptiveRouterPostCallHook
+            )
+
+        for entry in self.model_list or []:
+            lp = (
+                entry.get("litellm_params")
+                if isinstance(entry, dict)
+                else entry.litellm_params
+            )
+            lp_model = (
+                (lp.get("model") if isinstance(lp, dict) else lp.model) if lp else None
+            )
+            if not (lp_model and lp_model.startswith("auto_router/adaptive_router")):
+                continue
+            model_name = (
+                entry.get("model_name") if isinstance(entry, dict) else entry.model_name
+            )
+            if not model_name or not lp:
+                continue
+            if model_name in self.adaptive_routers:
+                continue
+            deployment = Deployment(
+                model_name=model_name,
+                litellm_params=(
+                    lp if not isinstance(lp, dict) else LiteLLM_Params(**lp)
+                ),
+                model_info=(
+                    entry.get("model_info")
+                    if isinstance(entry, dict)
+                    else entry.model_info
+                ),
+            )
+            self.init_adaptive_router_deployment(deployment=deployment)
+
+    def init_adaptive_router_deployment(self, deployment: Deployment) -> None:
+        """
+        Build an AdaptiveRouter instance for this deployment and register its
+        post-call hook. Multiple adaptive routers can coexist on a single Router,
+        keyed by `deployment.model_name`.
+
+        `model_to_prefs` and `model_to_cost` are derived from the OTHER models
+        already registered in `self.model_list` whose `model_name` appears in
+        `available_models`. Models not yet registered fall back to defaults.
+        """
+        # Local import: AdaptiveRouter -> hooks -> classifier all import litellm
+        # internals which transitively import this module. (AGENTS.md exception clause.)
+        from litellm.router_strategy.adaptive_router.adaptive_router import (
+            AdaptiveRouter,
+        )
+        from litellm.router_strategy.adaptive_router.hooks import (
+            AdaptiveRouterPostCallHook,
+        )
+        from litellm.types.router import (
+            AdaptiveRouterConfig,
+            AdaptiveRouterPreferences,
+        )
+
+        raw_config = deployment.litellm_params.adaptive_router_config
+        if raw_config is None:
+            raise ValueError(
+                "adaptive_router_config is required for adaptive-router deployments."
+            )
+
+        config = AdaptiveRouterConfig(**raw_config)
+
+        model_to_prefs: Dict[str, AdaptiveRouterPreferences] = {}
+        model_to_cost: Dict[str, float] = {}
+        # O(k) via the name→indices map: only touch deployments whose name
+        # is listed in `available_models`, instead of scanning model_list.
+        for name in config.available_models:
+            indices = self.model_name_to_deployment_indices.get(name, [])
+            if not indices:
+                continue
+            d = (self.model_list or [])[indices[0]]
+            mi = d.get("model_info") if isinstance(d, dict) else d.model_info
+            mi_dict: Dict[str, Any] = (
+                mi if isinstance(mi, dict) else (mi.model_dump() if mi else {})
+            )
+            prefs_raw = mi_dict.get("adaptive_router_preferences")
+            if prefs_raw is not None:
+                model_to_prefs[name] = AdaptiveRouterPreferences(**prefs_raw)
+
+            # `input_cost_per_token` is a LiteLLM_Params field per types/router.py.
+            lp = d.get("litellm_params") if isinstance(d, dict) else d.litellm_params
+            lp_dict: Dict[str, Any] = (
+                lp if isinstance(lp, dict) else (lp.model_dump() if lp else {})
+            )
+            cost = lp_dict.get("input_cost_per_token")
+            if cost is not None:
+                model_to_cost[name] = float(cost)
+
+        if deployment.model_name in self.adaptive_routers:
+            raise ValueError(
+                f"Adaptive-router deployment {deployment.model_name} already exists. "
+                "Please use a different model name."
+            )
+
+        adaptive_router = AdaptiveRouter(
+            router_name=deployment.model_name,
+            config=config,
+            model_to_prefs=model_to_prefs,
+            model_to_cost=model_to_cost,
+        )
+        self.adaptive_routers[deployment.model_name] = adaptive_router
+        litellm.logging_callback_manager.add_litellm_callback(
+            AdaptiveRouterPostCallHook(adaptive_router=adaptive_router)
+        )
+        verbose_router_logger.info(
+            "AdaptiveRouter[%s] initialized with %d models",
+            deployment.model_name,
+            len(config.available_models),
+        )
+
     def _is_quality_router_deployment(self, litellm_params: LiteLLM_Params) -> bool:
         """
         Check if the deployment is a quality-router deployment.
@@ -7077,6 +7228,10 @@ class Router:
         # Note: model_name_to_deployment_indices is already built incrementally
         # by _create_deployment -> _add_model_to_list_and_index_map
 
+        # Deferred: build the AdaptiveRouter strategy now that all underlying
+        # deployments have been registered.
+        self._finalize_adaptive_router_if_configured()
+
     def _add_deployment(self, deployment: Deployment) -> Deployment:
         import os
 
@@ -7204,6 +7359,10 @@ class Router:
         ):
             self.init_complexity_router_deployment(deployment=deployment)
 
+        # NOTE: adaptive-router deployments are deferred to the end of
+        # set_model_list() because their init needs visibility into the OTHER
+        # deployments listed in `available_models` (which may not yet have
+        # been processed when this one is created).
         #########################################################
         # Check if this is a quality-router deployment
         #########################################################
@@ -8439,7 +8598,9 @@ class Router:
         # No match found
         return None
 
-    def map_team_model(self, team_model_name: str, team_id: str) -> Optional[str]:
+    def map_team_model(
+        self, team_model_name: Optional[str], team_id: str
+    ) -> Optional[str]:
         """
         Check if team_model_name resolves to team-specific deployments.
 
@@ -8447,6 +8608,11 @@ class Router:
         sibling deployments via team_id filtering, instead of collapsing to a
         single internal model_name.
 
+        When team_model_name is None (e.g. vector store / file endpoints that
+        don't include a model in their request), returns the first matching
+        team deployment's team_public_model_name so the router can inject BYOK
+        credentials from the team-scoped deployment.
+
         Returns:
         - str: the team_model_name if team deployments exist for this team
         - None: if no team-specific model is found
@@ -8456,6 +8622,13 @@ class Router:
             return None
         for model in models:
             if model.get("model_info", {}).get("team_id") == team_id:
+                if team_model_name is None:
+                    # No model was specified (e.g. vector store endpoints).
+                    # Return the deployment's public model name so the router
+                    # can route to it and inject the BYOK API key.
+                    return model.get("model_info", {}).get(
+                        "team_public_model_name"
+                    ) or model.get("model_name")
                 return team_model_name
 
         # No team-scoped deployment found; wildcard/pattern routes are
@@ -9763,6 +9936,19 @@ class Router:
                 specific_deployment=specific_deployment,
             )
 
+        #########################################################
+        # Check if an adaptive-router should be used
+        #########################################################
+        adaptive_router = self.adaptive_routers.get(model)
+        if adaptive_router is not None:
+            return await adaptive_router.async_pre_routing_hook(
+                model=model,
+                request_kwargs=request_kwargs,
+                messages=messages,
+                input=input,
+                specific_deployment=specific_deployment,
+            )
+
         #########################################################
         # Check if any quality-router should be used
         #########################################################

litellm/router_strategy/adaptive_router/README.md

@@ -0,0 +1,95 @@
+# Adaptive Router (v0)
+
+A request-type-aware routing strategy. For each incoming request, classify the
+prompt into one of seven `RequestType` buckets (code generation, writing,
+analytical reasoning, …), then Thompson-sample a Beta(α, β) bandit posterior
+per `(request_type, model)` cell to pick the best model. Quality estimates are
+combined with a normalized cost score via a weighted linear sum.
+
+A post-call hook reads the response and runs lightweight regex + tool-call
+detectors (see `signals.py`) to award per-turn credit/blame to the model that
+served the turn. Updates are batched in-memory and flushed to Postgres every
+~10s by a background task in `proxy_server.py`.
+
+## Config example
+
+```yaml
+model_list:
+  - model_name: gpt-4o
+    litellm_params:
+      model: openai/gpt-4o
+    model_info:
+      input_cost_per_token: 0.0000025
+      adaptive_router_preferences:
+        quality_tier: 3
+        strengths: ["code_generation", "analytical_reasoning"]
+
+  - model_name: gpt-4o-mini
+    litellm_params:
+      model: openai/gpt-4o-mini
+    model_info:
+      input_cost_per_token: 0.00000015
+      adaptive_router_preferences:
+        quality_tier: 2
+        strengths: ["general", "factual_lookup"]
+
+  - model_name: smart-router
+    litellm_params:
+      model: auto_router/adaptive_router
+      adaptive_router_default_model: gpt-4o-mini
+      adaptive_router_config:
+        available_models: ["gpt-4o", "gpt-4o-mini"]
+        weights:
+          quality: 0.7
+          cost: 0.3
+```
+
+Callers may pass header `x-litellm-min-quality-tier: 3` (or metadata key
+`min_quality_tier: 3`) to force selection from tier-3-or-higher models only.
+
+## Behavior summary
+
+- **Cold start.** Each `(request_type, model)` cell starts with a
+  Beta prior whose mean = `BASE_TIER_WEIGHT[tier] (+ STRENGTH_BONUS if declared)`
+  and total mass = `COLD_START_MASS` (10). About ten real observations move it
+  meaningfully.
+- **Per-request decision.** Sample once per eligible model, score with
+  `quality_weight·sample + cost_weight·normalized_cost`, pick the argmax.
+  Routing is stateless per-turn — no sticky lookup. Each call resamples.
+- **Owner-cache attribution.** Post-call, the conversation's first picked
+  model claims an "owner slot" for `OWNER_CACHE_TTL_SECONDS` (24h). Later
+  turns of the same conversation only fire bandit/state updates if the
+  same model handled them — mismatches are dropped (no attribution) and
+  counted in `skipped_updates_total`. Conversation identity is the
+  client-supplied `litellm_session_id` if present, otherwise a sha256 over
+  caller identity (api key hash, team, user, end-user) + the first message.
+- **Per-turn updates.** `satisfaction → +α`. `misalignment, stagnation,
+  disengagement, failure → +β` (each). `loop → +0.5β`. `exhaustion → 0`
+  (uptime, not quality). Skipped if conversation has fewer than
+  `SIGNAL_GATE_MIN_MESSAGES` messages.
+- **Persistence.** Bandit cells: aggregated deltas, eventually consistent.
+  Session rows: last-write-wins snapshots.
+
+## Known v0 limitations
+
+- **Latency is not in the score.** Quality + cost only. A pathologically slow
+  model can still be picked.
+- **Hard sample cap at 200.** Once `α + β > 200`, deltas are silently dropped.
+  No rescaling — drift is a v1 concern.
+- **24h owner-cache TTL.** No explicit eviction below TTL. The in-memory map
+  can grow if traffic patterns produce many one-shot sessions.
+- **Owner-recovery skew.** If model A "owns" a conversation but is then
+  dethroned in the bandit, later turns served by model B are dropped — so
+  bandit updates for that conversation flatline until A's TTL expires.
+  Tracked via `skipped_updates_total`.
+- **Signals are regex + tool-call only.** No LLM-judge, no embedding similarity,
+  no exemplar storage. Signals are best-effort and biased toward English.
+- **One AdaptiveRouter per `Router`.** Multiple `adaptive_router/*` deployments
+  on the same `litellm.Router` raise at init.
+- **Bandit-delta mapping is unvalidated.** `_compute_bandit_delta` is a v0
+  guess; expect to retune after the first ~1000 sessions of real traffic.
+- **`request_type` is classified per turn from the latest user message.** For
+  non-GENERAL turns, the current-turn type is used for bandit attribution (so
+  genuine mid-session topic shifts update the correct cell). For GENERAL turns
+  ("thanks!", "ok", "sounds good"), attribution falls back to the session's
+  original type to avoid misattributing closing pleasantries.

litellm/router_strategy/adaptive_router/__init__.py

@@ -0,0 +1,6 @@
+"""Adaptive router strategy. See README.md for design overview."""
+
+from litellm.router_strategy.adaptive_router.adaptive_router import AdaptiveRouter
+from litellm.router_strategy.adaptive_router.hooks import AdaptiveRouterPostCallHook
+
+__all__ = ["AdaptiveRouter", "AdaptiveRouterPostCallHook"]

litellm/router_strategy/adaptive_router/adaptive_router.py

@@ -0,0 +1,454 @@
+"""
+Main adaptive router strategy. See README.md for design overview.
+
+One AdaptiveRouter instance per router_name. Holds in-memory caches:
+- _cells:           Beta(alpha, beta) bandit posteriors per (request_type, model)
+- _owner_cache:     session_key -> (owner_model, expires_at) — the first model
+                    picked for a conversation owns its bandit-update slot
+- _session_states:  (session_key, model) -> SessionState for incremental signal updates
+
+Owns the AdaptiveRouterUpdateQueue used by the proxy's flusher to persist
+state and session snapshots back to Postgres.
+
+Routing is stateless per-turn (Thompson sample fresh on every call). The
+owner cache is consulted only at post-call time to decide whether a turn's
+signals should fire a bandit update — turns served by a different model than
+the conversation's owner are skipped to avoid cross-model misattribution.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from dataclasses import asdict
+from typing import Any, Dict, List, Optional, Tuple, Union, cast
+
+from litellm._logging import verbose_router_logger
+from litellm.litellm_core_utils.prompt_templates.common_utils import (
+    get_last_user_message,
+)
+from litellm.router_strategy.adaptive_router.bandit import (
+    BanditCell,
+    apply_delta,
+    initial_cell,
+    pick_best,
+)
+from litellm.router_strategy.adaptive_router.classifier import classify_prompt
+from litellm.router_strategy.adaptive_router.config import (
+    ADAPTIVE_ROUTER_CHOSEN_MODEL_KEY,
+    MIN_QUALITY_TIER_HEADER,
+    MIN_QUALITY_TIER_METADATA_KEY,
+    OWNER_CACHE_TTL_SECONDS,
+)
+from litellm.router_strategy.adaptive_router.signals import (
+    SessionState,
+    SignalDelta,
+    Turn,
+    apply_turn,
+)
+from litellm.router_strategy.adaptive_router.update_queue import (
+    AdaptiveRouterUpdateQueue,
+)
+
+# Sweep session-state cache when it exceeds this many live entries. Expired
+# entries are dropped in bulk; amortizes to O(1) per insert.
+_SESSION_STATE_SWEEP_THRESHOLD: int = 1024
+# Same pattern for the owner cache.
+_OWNER_CACHE_SWEEP_THRESHOLD: int = 1024
+from litellm.types.llms.openai import AllMessageValues
+from litellm.types.router import (
+    AdaptiveRouterConfig,
+    AdaptiveRouterPreferences,
+    PreRoutingHookResponse,
+    RequestType,
+)
+
+
+def _default_prefs() -> AdaptiveRouterPreferences:
+    """Tier-2 prior with no declared strengths; used when a model omits prefs."""
+    return AdaptiveRouterPreferences(quality_tier=2, strengths=[])
+
+
+class AdaptiveRouter:
+    """One instance per router_name. Holds in-memory caches + the update queue."""
+
+    def __init__(
+        self,
+        router_name: str,
+        config: AdaptiveRouterConfig,
+        model_to_prefs: Dict[str, AdaptiveRouterPreferences],
+        model_to_cost: Dict[str, float],
+    ) -> None:
+        self.router_name = router_name
+        self.config = config
+        self.model_to_prefs = model_to_prefs
+        self.model_to_cost = model_to_cost
+        self.queue = AdaptiveRouterUpdateQueue()
+
+        self._cells: Dict[Tuple[RequestType, str], BanditCell] = {}
+        self._owner_cache: Dict[str, Tuple[str, float]] = {}
+        self._session_states: Dict[Tuple[str, str], SessionState] = {}
+        # Parallel expiry map for _session_states, same TTL as _owner_cache.
+        # Evicted opportunistically in `get_or_create_session_state`.
+        self._session_states_expiry: Dict[Tuple[str, str], float] = {}
+        self._skipped_updates_total: int = 0
+        # Set to True once the proxy flusher has loaded persisted priors from
+        # Postgres. Checked to support lazy-load on hot-reloaded routers.
+        self._state_loaded: bool = False
+        self._lock = asyncio.Lock()
+
+        self._init_cold_start_cells()
+
+    # ---- Cold-start ------------------------------------------------------
+
+    def _init_cold_start_cells(self) -> None:
+        """Populate _cells with cold-start priors for every (rt, model) combination."""
+        for rt in RequestType:
+            for model in self.config.available_models:
+                prefs = self.model_to_prefs.get(model) or _default_prefs()
+                self._cells[(rt, model)] = initial_cell(prefs, rt)
+
+    async def load_state_from_db(self, prisma_client: Any) -> None:
+        """Override cold-start cells with persisted state. Called once at startup."""
+        if prisma_client is None:
+            return
+        try:
+            rows = await prisma_client.db.litellm_adaptiverouterstate.find_many(
+                where={"router_name": self.router_name}
+            )
+            loaded = 0
+            for row in rows:
+                try:
+                    rt = RequestType(row.request_type)
+                except ValueError:
+                    # Unknown taxonomy entry from an older/newer version. Skip.
+                    continue
+                if row.model_name not in self.config.available_models:
+                    continue
+                self._cells[(rt, row.model_name)] = BanditCell(
+                    alpha=row.alpha, beta=row.beta
+                )
+                loaded += 1
+            verbose_router_logger.info(
+                "AdaptiveRouter[%s]: loaded %d cells from DB",
+                self.router_name,
+                loaded,
+            )
+        except Exception as e:
+            verbose_router_logger.exception(
+                "AdaptiveRouter[%s]: failed to load state from DB: %s",
+                self.router_name,
+                e,
+            )
+
+    # ---- Pre-routing hook ------------------------------------------------
+
+    async def async_pre_routing_hook(
+        self,
+        model: str,
+        request_kwargs: Dict[str, Any],
+        messages: Optional[List[Dict[str, Any]]] = None,
+        input: Optional[Union[str, List]] = None,
+        specific_deployment: Optional[bool] = False,
+    ) -> Optional[PreRoutingHookResponse]:
+        """
+        Plugin entry point invoked by `Router.async_pre_routing_hook` when the
+        inbound `model` matches this adaptive router's `router_name`.
+
+        Classifies the last user message, picks a logical model via the bandit,
+        and stashes the chosen model on `request_kwargs["metadata"]` so the
+        post-call hook can surface it as a response header.
+
+        Routing is stateless per-turn: every call Thompson-samples fresh,
+        regardless of any prior pick for the same session. Cross-turn
+        attribution is enforced post-call via the owner cache (see
+        `claim_or_check_owner`).
+        """
+        user_text = (
+            get_last_user_message(cast(List[AllMessageValues], messages or [])) or ""
+        )
+
+        request_type = classify_prompt(user_text)
+        min_quality_tier = self._extract_min_quality_tier(request_kwargs)
+        chosen_model = await self.pick_model(
+            request_type=request_type, min_quality_tier=min_quality_tier
+        )
+        verbose_router_logger.debug(
+            "AdaptiveRouter[%s]: classified=%s -> chose %s",
+            self.router_name,
+            request_type.value,
+            chosen_model,
+        )
+
+        # Relay the chosen logical model to the post-call hook, which surfaces
+        # it as the `x-litellm-adaptive-router-model` response header. We use
+        # `metadata` (not a top-level kwarg) so the value doesn't leak into
+        # `litellm.acompletion(**input_kwargs)`.
+        kwargs_metadata = request_kwargs.setdefault("metadata", {})
+        if isinstance(kwargs_metadata, dict):
+            kwargs_metadata[ADAPTIVE_ROUTER_CHOSEN_MODEL_KEY] = chosen_model
+
+        return PreRoutingHookResponse(model=chosen_model, messages=messages)
+
+    # ---- Pick model ------------------------------------------------------
+
+    async def pick_model(
+        self,
+        request_type: RequestType,
+        min_quality_tier: Optional[int] = None,
+    ) -> str:
+        """Thompson-sample across eligible models. Stateless per-turn."""
+        eligible = self._eligible_models(min_quality_tier)
+        if not eligible:
+            raise ValueError(
+                f"AdaptiveRouter[{self.router_name}]: no models meet "
+                f"min_quality_tier={min_quality_tier}"
+            )
+
+        cells = {m: self._cells[(request_type, m)] for m in eligible}
+        costs = {m: self.model_to_cost.get(m, 0.0) for m in eligible}
+        return pick_best(
+            cells,
+            costs,
+            quality_weight=self.config.weights.quality,
+            cost_weight=self.config.weights.cost,
+        )
+
+    def claim_or_check_owner(self, session_key: str, current_model: str) -> bool:
+        """Resolve attribution for a turn under stateless routing.
+
+        Returns True iff this turn should fire a bandit/state update. The
+        first call for a `session_key` claims ownership for `current_model`
+        and returns True. Subsequent calls return True only if the owner is
+        still live AND matches `current_model`. Mismatches (a different
+        model handled this turn) and expired owners both increment
+        `_skipped_updates_total` and return False — no attribution.
+        """
+        now = time.time()
+        existing = self._owner_cache.get(session_key)
+        if existing is not None and existing[1] > now:
+            owner_model, _ = existing
+            if owner_model == current_model:
+                return True
+            self._skipped_updates_total += 1
+            return False
+
+        # Opportunistic bulk sweep — sessions that never come back would
+        # otherwise pile up here forever. Same threshold pattern as the
+        # session-state cache.
+        if len(self._owner_cache) >= _OWNER_CACHE_SWEEP_THRESHOLD:
+            self._evict_expired_owner_cache(now)
+
+        # No live owner -> claim for current_model.
+        self._owner_cache[session_key] = (
+            current_model,
+            now + OWNER_CACHE_TTL_SECONDS,
+        )
+        return True
+
+    def _evict_expired_owner_cache(self, now: float) -> None:
+        expired = [k for k, (_, exp) in self._owner_cache.items() if exp <= now]
+        for k in expired:
+            self._owner_cache.pop(k, None)
+
+    async def get_state_snapshot(self) -> Dict[str, Any]:
+        """In-memory snapshot for the introspection endpoint. Cheap; no DB hit."""
+        cells = []
+        for (rt, model), cell in sorted(
+            self._cells.items(), key=lambda kv: (kv[0][0].value, kv[0][1])
+        ):
+            total = cell.alpha + cell.beta
+            cells.append(
+                {
+                    "request_type": rt.value,
+                    "model": model,
+                    "alpha": cell.alpha,
+                    "beta": cell.beta,
+                    # Net observations that have moved the posterior, excluding
+                    # the cold-start prior mass. `alpha + beta` would show the
+                    # initial COLD_START_MASS (e.g. 10) before any real traffic
+                    # arrives, which confuses operators reading the endpoint.
+                    "samples": cell.total_samples,
+                    "quality_mean": cell.alpha / total if total > 0 else 0.0,
+                }
+            )
+        queue = await self.queue.queue_size()
+        now = time.time()
+        owner_cache_live = sum(1 for _, exp in self._owner_cache.values() if exp > now)
+        return {
+            "router_name": self.router_name,
+            "available_models": list(self.config.available_models),
+            "weights": {
+                "quality": self.config.weights.quality,
+                "cost": self.config.weights.cost,
+            },
+            "model_costs": dict(self.model_to_cost),
+            "cells": cells,
+            "owner_cache_live": owner_cache_live,
+            "skipped_updates_total": self._skipped_updates_total,
+            "queue": queue,
+        }
+
+    @staticmethod
+    def _extract_min_quality_tier(
+        request_kwargs: Dict[str, Any],
+    ) -> Optional[int]:
+        """Pull `min_quality_tier` from request headers or metadata.
+
+        Precedence: headers (`x-litellm-min-quality-tier`) over metadata
+        (`min_quality_tier`). Headers arrive lowercased from the proxy but we
+        lookup case-insensitively to be safe. Unparseable values are ignored
+        (treated as "not set") rather than raising — a bad header shouldn't
+        fail the request.
+        """
+        headers = request_kwargs.get("headers") or {}
+        if isinstance(headers, dict):
+            for k, v in headers.items():
+                if isinstance(k, str) and k.lower() == MIN_QUALITY_TIER_HEADER:
+                    try:
+                        return int(v)
+                    except (TypeError, ValueError):
+                        return None
+
+        metadata = request_kwargs.get("metadata") or {}
+        if isinstance(metadata, dict):
+            raw = metadata.get(MIN_QUALITY_TIER_METADATA_KEY)
+            if raw is not None:
+                try:
+                    return int(raw)
+                except (TypeError, ValueError):
+                    return None
+        return None
+
+    def _eligible_models(self, min_quality_tier: Optional[int]) -> List[str]:
+        if min_quality_tier is None:
+            return list(self.config.available_models)
+        return [
+            m
+            for m in self.config.available_models
+            if (self.model_to_prefs.get(m) or _default_prefs()).quality_tier
+            >= min_quality_tier
+        ]
+
+    # ---- Session state ---------------------------------------------------
+
+    def get_or_create_session_state(
+        self,
+        session_id: str,
+        model_name: str,
+        request_type: RequestType,
+    ) -> SessionState:
+        key = (session_id, model_name)
+        now = time.time()
+
+        # Opportunistic bulk sweep when the cache grows past the threshold.
+        # Cheap relative to the alternative of a bounded LRU — conversations
+        # naturally become inactive within OWNER_CACHE_TTL_SECONDS.
+        if len(self._session_states) >= _SESSION_STATE_SWEEP_THRESHOLD:
+            self._evict_expired_session_states(now)
+
+        state = self._session_states.get(key)
+        if state is None:
+            state = SessionState(
+                session_id=session_id,
+                router_name=self.router_name,
+                model_name=model_name,
+                classified_type=request_type.value,
+            )
+            self._session_states[key] = state
+        self._session_states_expiry[key] = now + OWNER_CACHE_TTL_SECONDS
+        return state
+
+    def _evict_expired_session_states(self, now: float) -> None:
+        """Drop session states whose TTL has passed. O(n) but amortized O(1)
+        per insert thanks to `_SESSION_STATE_SWEEP_THRESHOLD`."""
+        expired = [k for k, exp in self._session_states_expiry.items() if exp <= now]
+        for k in expired:
+            self._session_states.pop(k, None)
+            self._session_states_expiry.pop(k, None)
+
+    async def record_turn(
+        self,
+        session_id: str,
+        model_name: str,
+        request_type: RequestType,
+        turn: Turn,
+    ) -> SignalDelta:
+        """Apply one turn, push session snapshot + bandit deltas to the queue."""
+        state = self.get_or_create_session_state(session_id, model_name, request_type)
+        delta = apply_turn(state, turn)
+        verbose_router_logger.debug(
+            "AdaptiveRouter[%s]: record_turn delta=%s", self.router_name, delta
+        )
+
+        # Strip the raw conversation content before persisting. The
+        # last_user/assistant_content and tool_call_history fields are only
+        # needed in-memory for the next turn's incremental signal detection;
+        # writing user prompts and tool payloads to the DB would store PII
+        # for every adaptive-router conversation. Counts + bookkeeping is
+        # all the persisted row needs.
+        snapshot = asdict(state)
+        for sensitive in (
+            "last_user_content",
+            "last_assistant_content",
+            "tool_call_history",
+            "pending_tool_calls",
+        ):
+            snapshot.pop(sensitive, None)
+        await self.queue.add_session_state(
+            session_id, self.router_name, model_name, snapshot
+        )
+
+        d_alpha, d_beta = self._compute_bandit_delta(delta)
+        verbose_router_logger.debug(
+            "AdaptiveRouter[%s]: bandit delta alpha=%.2f beta=%.2f",
+            self.router_name,
+            d_alpha,
+            d_beta,
+        )
+        if d_alpha != 0 or d_beta != 0:
+            # For non-GENERAL turns, attribute to the current-turn classification
+            # so genuine mid-session topic shifts (e.g. code → math) update the
+            # correct cell. For GENERAL turns ("thanks!", "ok", "sounds good"), fall
+            # back to the session's original type so closing pleasantries don't
+            # misattribute the reward.
+            attribution_type = (
+                request_type
+                if request_type != RequestType.GENERAL
+                else RequestType(state.classified_type)
+            )
+            cell_key = (attribution_type, model_name)
+            self._cells[cell_key] = apply_delta(self._cells[cell_key], d_alpha, d_beta)
+            await self.queue.add_state_delta(
+                self.router_name,
+                attribution_type.value,
+                model_name,
+                d_alpha,
+                d_beta,
+            )
+
+        return delta
+
+    @staticmethod
+    def _compute_bandit_delta(delta: SignalDelta) -> Tuple[float, float]:
+        """
+        Translate per-turn signal deltas into bandit-cell deltas.
+
+        v0 mapping (UNVALIDATED — D6):
+        - satisfaction               -> +1 alpha
+        - misalignment, stagnation,
+          disengagement, failure     -> +1 beta each
+        - loop                       -> +0.5 beta (weak; could be model OR user)
+        - exhaustion                 -> 0 (uptime issue, tracked separately later)
+        """
+        d_alpha = float(delta.satisfaction)
+        d_beta = (
+            float(
+                delta.misalignment
+                + delta.stagnation
+                + delta.disengagement
+                + delta.failure
+            )
+            + 0.5 * delta.loop
+        )
+        return d_alpha, d_beta

litellm/router_strategy/adaptive_router/bandit.py

@@ -0,0 +1,142 @@
+"""
+Thompson sampling and prior initialization for the adaptive router bandit.
+
+Each (router, request_type, model) cell is a Beta(alpha, beta) posterior.
+- alpha = pseudo-successes
+- beta  = pseudo-failures
+- mean  = alpha / (alpha + beta)
+- total samples = alpha + beta - COLD_START_MASS  (informative prior, not data)
+
+Hot path: thompson_sample() — pure function, no I/O.
+"""
+
+import random
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+from litellm.router_strategy.adaptive_router.config import (
+    BASE_TIER_WEIGHT,
+    COLD_START_MASS,
+    DEFAULT_COST_WEIGHT,
+    DEFAULT_QUALITY_WEIGHT,
+    SAMPLE_CAP,
+    STRENGTH_BONUS,
+)
+from litellm.types.router import AdaptiveRouterPreferences, RequestType
+
+
+@dataclass(frozen=True)
+class BanditCell:
+    """Posterior state for a single (router, request_type, model) cell."""
+
+    alpha: float
+    beta: float
+
+    @property
+    def mean(self) -> float:
+        total = self.alpha + self.beta
+        return self.alpha / total if total > 0 else 0.5
+
+    @property
+    def total_samples(self) -> int:
+        return max(0, int(self.alpha + self.beta - COLD_START_MASS))
+
+
+def initial_cell(
+    prefs: AdaptiveRouterPreferences, request_type: RequestType
+) -> BanditCell:
+    """
+    Cold-start prior for a (model, request_type) cell.
+
+    mean = base_tier_weight[tier] + (STRENGTH_BONUS if request_type in strengths else 0)
+    capped at 0.95 to avoid an over-confident prior.
+    Total mass = COLD_START_MASS so that ~10 real observations can move it noticeably.
+    """
+    if prefs.quality_tier not in BASE_TIER_WEIGHT:
+        valid = sorted(BASE_TIER_WEIGHT)
+        raise ValueError(
+            f"quality_tier={prefs.quality_tier} is not supported; "
+            f"valid tiers are {valid}"
+        )
+    base = BASE_TIER_WEIGHT[prefs.quality_tier]
+    bonus = STRENGTH_BONUS if request_type in prefs.strengths else 0.0
+    mean = min(0.95, base + bonus)
+    alpha = mean * COLD_START_MASS
+    beta = (1.0 - mean) * COLD_START_MASS
+    return BanditCell(alpha=alpha, beta=beta)
+
+
+def apply_delta(cell: BanditCell, delta_alpha: float, delta_beta: float) -> BanditCell:
+    """
+    Apply a learning update to a cell, enforcing the sample cap.
+
+    SAMPLE_CAP is a HARD cap on (alpha + beta). When the cap would be exceeded,
+    we drop the update. (D5: hard cap, no rescaling — keep v0 simple.)
+    """
+    new_alpha = cell.alpha + delta_alpha
+    new_beta = cell.beta + delta_beta
+    if new_alpha + new_beta > SAMPLE_CAP:
+        return cell
+    return BanditCell(alpha=new_alpha, beta=new_beta)
+
+
+def thompson_sample(cell: BanditCell, rng: Optional[random.Random] = None) -> float:
+    """Draw a sample from Beta(alpha, beta). Returns a quality estimate in [0, 1]."""
+    r = rng if rng is not None else random
+    return r.betavariate(cell.alpha, cell.beta)
+
+
+def normalized_cost(model_cost: float, all_costs: List[float]) -> float:
+    """
+    Map a raw $/1k-token cost into [0, 1] where 0 = most expensive, 1 = cheapest.
+    Returns 0.5 when there's no spread.
+    """
+    if not all_costs:
+        return 0.5
+    lo, hi = min(all_costs), max(all_costs)
+    if hi == lo:
+        return 0.5
+    return 1.0 - ((model_cost - lo) / (hi - lo))
+
+
+def score(
+    quality_sample: float,
+    model_cost: float,
+    all_costs: List[float],
+    quality_weight: float = DEFAULT_QUALITY_WEIGHT,
+    cost_weight: float = DEFAULT_COST_WEIGHT,
+) -> float:
+    """
+    Multi-objective score. V0 is a weighted linear sum of (quality, normalized_cost).
+    Higher is better. Both inputs are in [0, 1].
+    """
+    cost_score = normalized_cost(model_cost, all_costs)
+    return quality_weight * quality_sample + cost_weight * cost_score
+
+
+def pick_best(
+    cells: Dict[str, BanditCell],
+    model_costs: Dict[str, float],
+    quality_weight: float = DEFAULT_QUALITY_WEIGHT,
+    cost_weight: float = DEFAULT_COST_WEIGHT,
+    rng: Optional[random.Random] = None,
+) -> str:
+    """
+    Sample once per model, score each, return the model with highest score.
+
+    cells: {model_name: BanditCell}
+    model_costs: {model_name: $/1k tokens}
+    """
+    if not cells:
+        raise ValueError("pick_best called with no models")
+    all_costs = list(model_costs.values())
+    best_model: Optional[str] = None
+    best_score = float("-inf")
+    for model, cell in cells.items():
+        q = thompson_sample(cell, rng=rng)
+        s = score(q, model_costs[model], all_costs, quality_weight, cost_weight)
+        if s > best_score:
+            best_score = s
+            best_model = model
+    assert best_model is not None
+    return best_model

litellm/router_strategy/adaptive_router/classifier.py

@@ -0,0 +1,140 @@
+"""
+Rule-based classifier mapping a user prompt to a RequestType.
+
+V0 design choice: deterministic regex over the FIRST user message in a session.
+Result is cached per session (caller's responsibility, not ours).
+
+Order matters: we check more specific types first, falling back to GENERAL.
+"""
+
+import re
+from typing import List, Pattern, Tuple
+
+from litellm.types.router import RequestType
+
+_RULES: List[Tuple[Pattern[str], RequestType]] = [
+    (
+        re.compile(
+            r"\b(write|create|generate|implement|build)\s+(?:a |an |the |me )?(?:python|javascript|typescript|java|rust|go|c\+\+|sql|bash|shell)\b",
+            re.IGNORECASE,
+        ),
+        RequestType.CODE_GENERATION,
+    ),
+    (
+        re.compile(
+            r"\b(write|create|implement|build)\b(?:\s+\w+){0,4}?\s+(function|class|method|script|program|api|endpoint|microservice)\b",
+            re.IGNORECASE,
+        ),
+        RequestType.CODE_GENERATION,
+    ),
+    (
+        re.compile(
+            r"\b(explain|describe|understand|walk me through|what does)\b.*\b(code|function|method|class|algorithm|snippet)\b",
+            re.IGNORECASE,
+        ),
+        RequestType.CODE_UNDERSTANDING,
+    ),
+    (
+        re.compile(
+            r"\b(debug|fix|why (?:is|does|isn't)|what.s wrong|trace)\b.*\b(error|bug|exception|stacktrace|stack trace|traceback)\b",
+            re.IGNORECASE,
+        ),
+        RequestType.CODE_UNDERSTANDING,
+    ),
+    (
+        re.compile(
+            r"\b(review|critique)\s+(?:this |my |the )?(?:code|pr|pull request|diff|patch)\b",
+            re.IGNORECASE,
+        ),
+        RequestType.CODE_UNDERSTANDING,
+    ),
+    (
+        re.compile(
+            r"\b(design|architect|plan|architecture)\b.*\b(system|service|api|database|schema|module|microservice)\b",
+            re.IGNORECASE,
+        ),
+        RequestType.TECHNICAL_DESIGN,
+    ),
+    (
+        re.compile(
+            r"\b(should i (?:use|choose|pick)|tradeoffs? between|compare)\b.*\b(library|framework|language|database|protocol|postgres|postgresql|mongodb|dynamodb|mysql|redis|kafka|sql|nosql)\b",
+            re.IGNORECASE,
+        ),
+        RequestType.TECHNICAL_DESIGN,
+    ),
+    (
+        re.compile(
+            r"\bhow (?:should|do) i (?:design|structure|organize|model)\b",
+            re.IGNORECASE,
+        ),
+        RequestType.TECHNICAL_DESIGN,
+    ),
+    (
+        re.compile(
+            r"\b(solve|compute|calculate|prove|derive)\b.*\b(equation|integral|derivative|theorem|proof|problem)\b",
+            re.IGNORECASE,
+        ),
+        RequestType.ANALYTICAL_REASONING,
+    ),
+    (
+        re.compile(r"\b(if .+ then|given .+ find|suppose|assume)\b", re.IGNORECASE),
+        RequestType.ANALYTICAL_REASONING,
+    ),
+    (
+        re.compile(
+            r"\b(probability|statistics|combinatorics|optimization problem)\b",
+            re.IGNORECASE,
+        ),
+        RequestType.ANALYTICAL_REASONING,
+    ),
+    (
+        re.compile(
+            r"\b(write|draft|compose|rewrite|edit|proofread|polish)\b.*\b(email|essay|blog|post|article|letter|memo|copy|paragraph|sentence)\b",
+            re.IGNORECASE,
+        ),
+        RequestType.WRITING,
+    ),
+    (
+        re.compile(
+            r"\b(make (?:this|it)|help me)\s+(?:more |less )?(?:concise|formal|casual|professional|persuasive)\b",
+            re.IGNORECASE,
+        ),
+        RequestType.WRITING,
+    ),
+    (
+        re.compile(
+            r"^\s*(who|what|when|where|which)\s+(?:is|was|were|are)\b", re.IGNORECASE
+        ),
+        RequestType.FACTUAL_LOOKUP,
+    ),
+    (
+        re.compile(r"^\s*(define|definition of|meaning of)\b", re.IGNORECASE),
+        RequestType.FACTUAL_LOOKUP,
+    ),
+    (
+        re.compile(
+            r"^\s*how (?:do you spell|to spell|many .* are there|tall is)\b",
+            re.IGNORECASE,
+        ),
+        RequestType.FACTUAL_LOOKUP,
+    ),
+]
+
+
+def classify_prompt(text: str) -> RequestType:
+    """
+    Classify a single user prompt.
+
+    Falls back to GENERAL when no rule matches. Empty/whitespace-only also
+    returns GENERAL.
+    """
+    if not text or not text.strip():
+        return RequestType.GENERAL
+
+    truncated = text[:2000]
+
+    for pattern, request_type in _RULES:
+        if pattern.search(truncated):
+            return request_type
+
+    return RequestType.GENERAL

litellm/router_strategy/adaptive_router/config.py

@@ -0,0 +1,54 @@
+"""
+Configuration constants for the adaptive_router strategy.
+
+All magic numbers are first-pass guesses (D3-D6 in the handoff plan).
+Expect to retune after first 1000 sessions of real traffic.
+"""
+
+from typing import Dict
+
+from litellm.types.router import RequestType  # re-export for convenience  # noqa: F401
+
+# D3 — Score weights (default; user-overridable via AdaptiveRouterConfig.weights)
+DEFAULT_QUALITY_WEIGHT: float = 0.7  # UNVALIDATED — calibrated against [0] sessions
+DEFAULT_COST_WEIGHT: float = 0.3  # UNVALIDATED — calibrated against [0] sessions
+
+# D4 — Cold-start prior: (alpha + beta) total mass = COLD_START_MASS
+# Mean of Beta = base_tier_weight + (strength_bonus if declared)
+BASE_TIER_WEIGHT: Dict[int, float] = {1: 0.3, 2: 0.5, 3: 0.7}  # UNVALIDATED
+STRENGTH_BONUS: float = 0.3  # UNVALIDATED
+COLD_START_MASS: float = 10.0
+
+# D5 — Sample cap. Hard cap, no rescaling (drift handling is v1).
+SAMPLE_CAP: int = 200
+
+# D6 — Clean-trace credit: minimum turns before α += 1 can fire.
+MIN_TURNS_FOR_CLEAN_CREDIT: int = 3
+
+# D2 — Owner-cache TTL (seconds). 24h.
+# A conversation's first-picked model "owns" the bandit-update slot for
+# this long. Subsequent turns of the same conversation only contribute a
+# bandit/state update when the same model is re-sampled.
+OWNER_CACHE_TTL_SECONDS: int = 24 * 3600
+
+# Below this many messages we skip post-call signal recording. Most signals
+# (misalignment, stagnation, satisfaction-in-response-to-prior-turn) need at
+# least one full prior exchange to be meaningful.
+SIGNAL_GATE_MIN_MESSAGES: int = 4
+
+# Detector thresholds (from Plano/Chen 2026 paper).
+MISALIGNMENT_JACCARD_THRESHOLD: float = 0.45
+STAGNATION_JACCARD_NEAR_DUP: float = 0.50
+LOOP_REPEAT_THRESHOLD: int = 3
+TOOL_CALL_HISTORY_MAX: int = 20
+
+# D1 — Caller filter for min quality tier.
+MIN_QUALITY_TIER_HEADER: str = "x-litellm-min-quality-tier"
+MIN_QUALITY_TIER_METADATA_KEY: str = "min_quality_tier"
+
+# Pre-routing -> post-call relay: the chosen logical model is stashed on
+# request_kwargs["metadata"][ADAPTIVE_ROUTER_CHOSEN_MODEL_KEY] by the
+# pre-routing hook, then read by the post-call hook to surface as the
+# ADAPTIVE_ROUTER_RESPONSE_HEADER response header.
+ADAPTIVE_ROUTER_CHOSEN_MODEL_KEY: str = "adaptive_router_chosen_model"
+ADAPTIVE_ROUTER_RESPONSE_HEADER: str = "x-litellm-adaptive-router-model"

litellm/router_strategy/adaptive_router/hooks.py

@@ -0,0 +1,278 @@
+"""
+Post-call hook for the adaptive router.
+
+On each successful or failed completion, build a Turn from the request/response
+and push it through `AdaptiveRouter.record_turn`. The router then updates the
+in-memory bandit cell + session state and queues writes for the proxy flusher.
+
+All work happens after the response has been returned to the caller. Any
+exception is swallowed — signal recording must never break a request.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any, Dict, List, Optional
+
+from litellm._logging import verbose_router_logger
+from litellm.integrations.custom_logger import CustomLogger
+from litellm.router_strategy.adaptive_router.adaptive_router import AdaptiveRouter
+from litellm.router_strategy.adaptive_router.classifier import classify_prompt
+from litellm.router_strategy.adaptive_router.config import (
+    ADAPTIVE_ROUTER_CHOSEN_MODEL_KEY,
+    ADAPTIVE_ROUTER_RESPONSE_HEADER,
+    SIGNAL_GATE_MIN_MESSAGES,
+)
+from litellm.router_strategy.adaptive_router.signals import Turn
+
+# Identity fields hashed into a derived session key so the same conversation
+# from the same caller produces a stable key, while different keys/teams/users
+# stay segregated even if they happen to send identical first messages.
+_IDENTITY_FIELDS = (
+    "user_api_key_hash",
+    "user_api_key_team_id",
+    "user_api_key_user_id",
+    "user_api_key_end_user_id",
+)
+
+
+def _resolve_session_key(kwargs: Dict[str, Any]) -> Optional[str]:
+    """Pick a stable per-conversation key for owner-cache attribution.
+
+    Order:
+      1. Honor a client-supplied session id (`litellm_session_id` on either
+         `litellm_params` or `litellm_params.metadata`, or `session_id` on
+         metadata) — backward compat for callers already wired up.
+      2. Otherwise derive a sha256 over (identity fields, first
+         SIGNAL_GATE_MIN_MESSAGES messages) so the key is stable across turns
+         and only materialises once there is enough context for the bandit to
+         act on (matching the gate in the signal-processing path).
+
+    Returns None if the conversation is shorter than SIGNAL_GATE_MIN_MESSAGES.
+    """
+    litellm_params = kwargs.get("litellm_params") or {}
+    sid = litellm_params.get("litellm_session_id")
+    if sid:
+        return str(sid)
+    metadata = litellm_params.get("metadata") or {}
+    if isinstance(metadata, dict):
+        sid = metadata.get("session_id") or metadata.get("litellm_session_id")
+        if sid:
+            return str(sid)
+
+    messages = kwargs.get("messages") or []
+    if len(messages) < SIGNAL_GATE_MIN_MESSAGES:
+        # Don't attribute until we have enough turns to match the signal gate —
+        # ensures the hash is stable (same N messages every time) and avoids
+        # crediting the bandit for conversations that are too short to signal.
+        return None
+
+    identity = ":".join(
+        str(metadata.get(f) or "") if isinstance(metadata, dict) else ""
+        for f in _IDENTITY_FIELDS
+    )
+    anchor = messages[:SIGNAL_GATE_MIN_MESSAGES]
+    payload = (
+        identity
+        + "|"
+        + json.dumps(
+            [{"role": m.get("role"), "content": m.get("content")} for m in anchor],
+            sort_keys=True,
+            default=str,
+        )
+    )
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+def _last_user_content(messages: Optional[List[Dict[str, Any]]]) -> Optional[str]:
+    if not messages:
+        return None
+    for msg in reversed(messages):
+        if msg.get("role") == "user":
+            content = msg.get("content")
+            if isinstance(content, str):
+                return content
+            if isinstance(content, list):
+                # OpenAI vision-style content: pick first text part.
+                for part in content:
+                    if isinstance(part, dict) and part.get("type") == "text":
+                        return part.get("text")
+            return None
+    return None
+
+
+def _recent_tool_results(
+    messages: Optional[List[Dict[str, Any]]]
+) -> List[Dict[str, Any]]:
+    """Extract the current turn's tool result payloads from the request messages.
+
+    Tool results are `role == "tool"` messages that sit at the tail of the
+    conversation — i.e. after the most recent assistant message with
+    `tool_calls`, waiting for the model to produce a user-facing reply. Walk
+    backwards from the end and collect the contiguous run of tool messages;
+    stop at the first non-tool message.
+
+    Each result is normalized to `{content, is_error}` — the only fields
+    `signals._detect_failure` / `_detect_exhaustion` actually read.
+    """
+    if not messages:
+        return []
+    results: List[Dict[str, Any]] = []
+    for msg in reversed(messages):
+        if not isinstance(msg, dict):
+            break
+        if msg.get("role") != "tool":
+            break
+        content = msg.get("content")
+        # Some providers (Anthropic-style) carry an explicit error flag; OpenAI
+        # tool results don't, so fall back to an empty/missing content heuristic
+        # inside `_detect_failure`.
+        is_error = bool(msg.get("is_error"))
+        results.append({"content": content, "is_error": is_error})
+    results.reverse()
+    return results
+
+
+def _assistant_content_and_tool_calls(response_obj: Any) -> tuple:
+    """Return (assistant_text, tool_calls_list) extracted from a ModelResponse-ish object."""
+    if response_obj is None:
+        return None, []
+    try:
+        choices = getattr(response_obj, "choices", None) or response_obj.get("choices")
+    except Exception:
+        return None, []
+    if not choices:
+        return None, []
+
+    msg = choices[0]
+    msg = getattr(msg, "message", None) or (
+        msg.get("message") if isinstance(msg, dict) else None
+    )
+    if msg is None:
+        return None, []
+
+    content = getattr(msg, "content", None)
+    if content is None and isinstance(msg, dict):
+        content = msg.get("content")
+
+    raw_tool_calls = getattr(msg, "tool_calls", None)
+    if raw_tool_calls is None and isinstance(msg, dict):
+        raw_tool_calls = msg.get("tool_calls")
+    tool_calls: List[Dict[str, Any]] = []
+    for tc in raw_tool_calls or []:
+        if isinstance(tc, dict):
+            tool_calls.append(tc)
+        else:
+            try:
+                tool_calls.append(tc.model_dump())
+            except Exception:
+                tool_calls.append({"name": getattr(tc, "name", ""), "arguments": ""})
+    return content, tool_calls
+
+
+class AdaptiveRouterPostCallHook(CustomLogger):
+    """One hook instance per AdaptiveRouter. Registered into litellm.callbacks."""
+
+    def __init__(self, adaptive_router: AdaptiveRouter) -> None:
+        self.adaptive_router = adaptive_router
+
+    async def async_post_call_response_headers_hook(
+        self,
+        data: Dict[str, Any],
+        user_api_key_dict: Any,
+        response: Any,
+        request_headers: Optional[Dict[str, str]] = None,
+        litellm_call_info: Optional[Dict[str, Any]] = None,
+    ) -> Optional[Dict[str, str]]:
+        """
+        Surface the chosen logical model as the `x-litellm-adaptive-router-model`
+        response header for both streaming and non-streaming responses.
+
+        `async_post_call_success_hook` fires after the stream is fully consumed,
+        so writing to `_hidden_params["additional_headers"]` there is too late for
+        streaming — the StreamingResponse headers are already frozen. This hook is
+        called during header construction (before StreamingResponse is built), so
+        the header is included for both paths.
+        """
+        metadata = data.get("metadata") or {}
+        chosen = (
+            metadata.get(ADAPTIVE_ROUTER_CHOSEN_MODEL_KEY)
+            if isinstance(metadata, dict)
+            else None
+        )
+        if not chosen:
+            return None
+        return {ADAPTIVE_ROUTER_RESPONSE_HEADER: chosen}
+
+    async def async_log_success_event(self, kwargs, response_obj, start_time, end_time):
+        await self._record(kwargs, response_obj, response_status=200)
+
+    async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time):
+        status = kwargs.get("response_status")
+        if status is None:
+            exc = kwargs.get("exception")
+            status = getattr(exc, "status_code", 500) if exc is not None else 500
+        await self._record(kwargs, response_obj, response_status=int(status))
+
+    async def _record(
+        self,
+        kwargs: Dict[str, Any],
+        response_obj: Any,
+        response_status: int,
+    ) -> None:
+        try:
+            messages = kwargs.get("messages") or []
+            if len(messages) < SIGNAL_GATE_MIN_MESSAGES:
+                # Too few turns for any signal to be meaningful — skip.
+                return
+
+            session_key = _resolve_session_key(kwargs)
+            if not session_key:
+                return
+
+            # The bandit cells are keyed by the *logical* model name from
+            # `available_models` (e.g. "smart"/"fast"). `kwargs["model"]` at
+            # post-call time is the physical upstream model
+            # (e.g. "anthropic/claude-opus-4-7"), so it cannot be used directly.
+            # The pre-routing hook stashes the logical pick under this key.
+            litellm_params = kwargs.get("litellm_params") or {}
+            metadata = litellm_params.get("metadata") or {}
+            current_model = (
+                metadata.get(ADAPTIVE_ROUTER_CHOSEN_MODEL_KEY)
+                if isinstance(metadata, dict)
+                else None
+            )
+            if not current_model:
+                return
+
+            if not self.adaptive_router.claim_or_check_owner(
+                session_key, current_model
+            ):
+                # A different model owns this conversation — skip attribution.
+                return
+
+            user_text = _last_user_content(messages)
+            assistant_text, tool_calls = _assistant_content_and_tool_calls(response_obj)
+            tool_results = _recent_tool_results(messages)
+
+            request_type = classify_prompt(user_text or "")
+            turn = Turn(
+                user_content=user_text,
+                assistant_content=(
+                    assistant_text if isinstance(assistant_text, str) else None
+                ),
+                tool_calls=tool_calls,
+                tool_results=tool_results,
+                response_status=response_status,
+            )
+            await self.adaptive_router.record_turn(
+                session_id=session_key,
+                model_name=current_model,
+                request_type=request_type,
+                turn=turn,
+            )
+        except Exception as e:
+            verbose_router_logger.exception(
+                "AdaptiveRouterPostCallHook: failed to record turn: %s", e
+            )

litellm/router_strategy/adaptive_router/signals.py

@@ -0,0 +1,287 @@
+"""
+Incremental signal detection for the adaptive router.
+
+Each session maintains a SessionState. On every turn, we call apply_turn(state, turn)
+which mutates the state in place and returns a SignalDelta listing which signals
+fired on THIS turn. The router then queues the delta to be flushed to DB.
+
+Design constraint: O(1) work per turn. No re-scanning the full session history.
+We keep small bounded windows: last_user_content, last_assistant_content, and a
+bounded list of recent tool call signatures.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Set
+
+from litellm.router_strategy.adaptive_router.config import (
+    LOOP_REPEAT_THRESHOLD,
+    MIN_TURNS_FOR_CLEAN_CREDIT,
+    MISALIGNMENT_JACCARD_THRESHOLD,
+    STAGNATION_JACCARD_NEAR_DUP,
+    TOOL_CALL_HISTORY_MAX,
+)
+
+
+# ---- Public types ---------------------------------------------------------
+
+
+@dataclass
+class SignalDelta:
+    """Which signals fired on a single turn. Counts are 0 or 1 (one delta per turn)."""
+
+    misalignment: int = 0
+    stagnation: int = 0
+    disengagement: int = 0
+    satisfaction: int = 0
+    failure: int = 0
+    loop: int = 0
+    exhaustion: int = 0
+
+    def any_fired(self) -> bool:
+        return any(
+            [
+                self.misalignment,
+                self.stagnation,
+                self.disengagement,
+                self.satisfaction,
+                self.failure,
+                self.loop,
+                self.exhaustion,
+            ]
+        )
+
+
+@dataclass
+class SessionState:
+    """In-memory rolling state for one session.
+
+    Mirrors the LiteLLM_AdaptiveRouterSession DB row (Wave 0 schema). The flusher
+    later persists this. We keep this as a plain dataclass — no DB coupling.
+    """
+
+    session_id: str
+    router_name: str
+    model_name: str
+    classified_type: str
+
+    misalignment_count: int = 0
+    stagnation_count: int = 0
+    disengagement_count: int = 0
+    satisfaction_count: int = 0
+    failure_count: int = 0
+    loop_count: int = 0
+    exhaustion_count: int = 0
+
+    last_user_content: Optional[str] = None
+    last_assistant_content: Optional[str] = None
+    tool_call_history: List[str] = field(default_factory=list)
+    pending_tool_calls: Dict[str, str] = field(default_factory=dict)
+
+    turn_count: int = 0
+    last_processed_turn: int = -1
+    clean_credit_awarded: bool = False
+    terminal_status: Optional[int] = None
+
+
+@dataclass
+class Turn:
+    """One turn of input. Caller assembles this from the request/response."""
+
+    user_content: Optional[str] = None
+    assistant_content: Optional[str] = None
+    tool_calls: List[Dict[str, Any]] = field(default_factory=list)
+    tool_results: List[Dict[str, Any]] = field(default_factory=list)
+    response_status: Optional[int] = None
+
+
+# ---- Detection helpers ----------------------------------------------------
+
+_TOKEN_RE = re.compile(r"[A-Za-z0-9]+")
+
+
+def _tokens(text: Optional[str]) -> Set[str]:
+    if not text:
+        return set()
+    return {t.lower() for t in _TOKEN_RE.findall(text)}
+
+
+def _jaccard(a: Set[str], b: Set[str]) -> float:
+    union = a | b
+    if not union:
+        return 0.0
+    return len(a & b) / len(union)
+
+
+_DISENGAGEMENT_PATTERNS = [
+    re.compile(
+        r"\b(forget it|never mind|give up|talk to (?:a )?human|cancel)\b", re.IGNORECASE
+    ),
+    re.compile(r"\b(this (?:isn'?t|is not) working|stop|abort)\b", re.IGNORECASE),
+    re.compile(r"\bi'?ll do it (?:myself|manually)\b", re.IGNORECASE),
+]
+
+_SATISFACTION_PATTERNS = [
+    re.compile(
+        r"\b(that worked|that did it|works now|fixed it|solved it|nice)\b",
+        re.IGNORECASE,
+    ),
+    re.compile(r"\b(thanks|thank you|thx|appreciated|appreciate it)\b", re.IGNORECASE),
+    re.compile(r"\b(perfect|great|excellent|exactly)\b", re.IGNORECASE),
+]
+
+
+def _detect_misalignment(prev_user: Optional[str], curr_user: Optional[str]) -> bool:
+    """Fires when consecutive user messages share *some* topic (jaccard > 0)
+    but are sufficiently different (jaccard < threshold) — i.e. user is
+    rephrasing, not changing topic, not repeating."""
+    if not prev_user or not curr_user:
+        return False
+    j = _jaccard(_tokens(prev_user), _tokens(curr_user))
+    return 0.0 < j < MISALIGNMENT_JACCARD_THRESHOLD
+
+
+def _detect_stagnation(prev_asst: Optional[str], curr_asst: Optional[str]) -> bool:
+    """Fires when consecutive assistant messages are near-duplicates."""
+    if not prev_asst or not curr_asst:
+        return False
+    j = _jaccard(_tokens(prev_asst), _tokens(curr_asst))
+    return j >= STAGNATION_JACCARD_NEAR_DUP
+
+
+def _detect_disengagement(curr_user: Optional[str]) -> bool:
+    if not curr_user:
+        return False
+    return any(p.search(curr_user) for p in _DISENGAGEMENT_PATTERNS)
+
+
+def _detect_satisfaction(curr_user: Optional[str]) -> bool:
+    if not curr_user:
+        return False
+    return any(p.search(curr_user) for p in _SATISFACTION_PATTERNS)
+
+
+def _detect_failure(tool_results: List[Dict[str, Any]]) -> bool:
+    """Any tool result explicitly flagged as an error.
+
+    We do NOT treat empty content as failure — many tools legitimately return
+    empty output (zero-result searches, silent bash commands, void writes) and
+    penalizing the model for those would corrupt the bandit posterior.
+    """
+    for r in tool_results:
+        if r.get("is_error"):
+            return True
+    return False
+
+
+def _signature(call: Dict[str, Any]) -> str:
+    """Stable signature for loop detection: name + sorted JSON-ish args."""
+    name = call.get("name") or call.get("function", {}).get("name", "")
+    call_args = call.get("arguments")
+    if call_args is None:
+        call_args = call.get("function", {}).get("arguments", "")
+    if isinstance(call_args, dict):
+        call_args = ",".join(f"{k}={call_args[k]}" for k in sorted(call_args.keys()))
+    return f"{name}({call_args})"
+
+
+def _detect_loop(history: List[str], new_calls: List[Dict[str, Any]]) -> bool:
+    """Fires if any new call's signature appears >= LOOP_REPEAT_THRESHOLD-1 times
+    in recent history (so this call would be the Nth)."""
+    if not new_calls:
+        return False
+    for call in new_calls:
+        sig = _signature(call)
+        recent_count = history.count(sig)
+        if recent_count >= LOOP_REPEAT_THRESHOLD - 1:
+            return True
+    return False
+
+
+_EXHAUSTION_STATUSES = {408, 413, 429, 503, 504}
+
+_EXHAUSTION_KEYWORDS = (
+    "context length",
+    "context window",
+    "token limit",
+    "rate limit",
+    "too many requests",
+    "timeout",
+)
+
+
+def _detect_exhaustion(
+    status: Optional[int], tool_results: List[Dict[str, Any]]
+) -> bool:
+    if status is not None and status in _EXHAUSTION_STATUSES:
+        return True
+    for r in tool_results:
+        content = str(r.get("content", "")).lower()
+        if any(kw in content for kw in _EXHAUSTION_KEYWORDS):
+            return True
+    return False
+
+
+# ---- Public entrypoint ----------------------------------------------------
+
+
+def apply_turn(state: SessionState, turn: Turn) -> SignalDelta:
+    """
+    Detect signals on this turn, mutate state, return the delta.
+
+    O(1) per turn (no full-history rescan). Only inspects last_*, recent tool history
+    (which is bounded at TOOL_CALL_HISTORY_MAX), and the new turn payload.
+    """
+    delta = SignalDelta()
+
+    if _detect_misalignment(state.last_user_content, turn.user_content):
+        delta.misalignment = 1
+    if _detect_stagnation(state.last_assistant_content, turn.assistant_content):
+        delta.stagnation = 1
+    if _detect_disengagement(turn.user_content):
+        delta.disengagement = 1
+    if _detect_satisfaction(turn.user_content):
+        # Gate: only award satisfaction credit once per session, and only
+        # after MIN_TURNS_FOR_CLEAN_CREDIT turns of context. Early "thanks"
+        # on turn 1-2 is noise, not a validated quality signal.
+        current_turn_index = state.turn_count + 1
+        if (
+            not state.clean_credit_awarded
+            and current_turn_index >= MIN_TURNS_FOR_CLEAN_CREDIT
+        ):
+            delta.satisfaction = 1
+            state.clean_credit_awarded = True
+    if _detect_failure(turn.tool_results):
+        delta.failure = 1
+    if _detect_loop(state.tool_call_history, turn.tool_calls):
+        delta.loop = 1
+    if _detect_exhaustion(turn.response_status, turn.tool_results):
+        delta.exhaustion = 1
+
+    state.misalignment_count += delta.misalignment
+    state.stagnation_count += delta.stagnation
+    state.disengagement_count += delta.disengagement
+    state.satisfaction_count += delta.satisfaction
+    state.failure_count += delta.failure
+    state.loop_count += delta.loop
+    state.exhaustion_count += delta.exhaustion
+
+    if turn.user_content:
+        state.last_user_content = turn.user_content
+    if turn.assistant_content:
+        state.last_assistant_content = turn.assistant_content
+
+    for call in turn.tool_calls:
+        state.tool_call_history.append(_signature(call))
+    if len(state.tool_call_history) > TOOL_CALL_HISTORY_MAX:
+        state.tool_call_history = state.tool_call_history[-TOOL_CALL_HISTORY_MAX:]
+
+    if turn.response_status is not None:
+        state.terminal_status = turn.response_status
+
+    state.turn_count += 1
+    state.last_processed_turn = state.turn_count
+
+    return delta

litellm/router_strategy/adaptive_router/update_queue.py

@@ -0,0 +1,213 @@
+"""
+In-memory queues for adaptive router state and session updates.
+
+Pattern follows DailySpendUpdateQueue: hot path is fully in-memory; a background
+flusher task drains the aggregator and writes batches to Postgres.
+
+Two logical queues (one class):
+  1. STATE updates: increments to (router, request_type, model) bandit cell.
+     Aggregator key = (router_name, request_type, model_name)
+     Aggregated payload = {"delta_alpha": float, "delta_beta": float, "samples_added": int}
+  2. SESSION updates: full snapshot of a session row (last-write-wins per session+router+model).
+     Aggregator key = (session_id, router_name, model_name)
+     Aggregated payload = the full session state dict.
+
+Hot-path API is non-blocking and synchronous from the caller's POV (it just appends
+to the in-memory aggregator). Flush is async and batched.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Dict, Tuple
+
+from litellm._logging import verbose_router_logger
+
+StateKey = Tuple[str, str, str]  # (router_name, request_type, model_name)
+SessionKey = Tuple[str, str, str]  # (session_id, router_name, model_name)
+
+
+class AdaptiveRouterUpdateQueue:
+    """
+    Single class managing both state-update aggregation and session-snapshot aggregation.
+    Held by the AdaptiveRouter strategy instance and started by the proxy on boot.
+    """
+
+    def __init__(self) -> None:
+        self._state_agg: Dict[StateKey, Dict[str, float]] = {}
+        self._session_agg: Dict[SessionKey, Dict[str, Any]] = {}
+        self._lock = asyncio.Lock()
+        self._max_state_size_seen = 0
+        self._max_session_size_seen = 0
+
+    # ---- Hot-path: state delta -------------------------------------------
+
+    async def add_state_delta(
+        self,
+        router_name: str,
+        request_type: str,
+        model_name: str,
+        delta_alpha: float,
+        delta_beta: float,
+    ) -> None:
+        """Aggregate a bandit-cell delta. Multiple deltas to the same cell sum."""
+        key: StateKey = (router_name, request_type, model_name)
+        async with self._lock:
+            current = self._state_agg.get(key)
+            if current is None:
+                self._state_agg[key] = {
+                    "delta_alpha": delta_alpha,
+                    "delta_beta": delta_beta,
+                    "samples_added": 1,
+                }
+            else:
+                current["delta_alpha"] += delta_alpha
+                current["delta_beta"] += delta_beta
+                current["samples_added"] += 1
+            if len(self._state_agg) > self._max_state_size_seen:
+                self._max_state_size_seen = len(self._state_agg)
+
+    # ---- Hot-path: session snapshot --------------------------------------
+
+    async def add_session_state(
+        self,
+        session_id: str,
+        router_name: str,
+        model_name: str,
+        state_dict: Dict[str, Any],
+    ) -> None:
+        """
+        Last-write-wins per session row. The state_dict is a snapshot of the
+        SessionState (signals counts + bookkeeping fields). The flusher will
+        upsert this into LiteLLM_AdaptiveRouterSession.
+        """
+        key: SessionKey = (session_id, router_name, model_name)
+        async with self._lock:
+            self._session_agg[key] = state_dict
+            if len(self._session_agg) > self._max_session_size_seen:
+                self._max_session_size_seen = len(self._session_agg)
+
+    # ---- Flushers (called by background task) ----------------------------
+
+    async def flush_state_to_db(self, prisma_client: Any) -> int:
+        """
+        Drain state aggregator and apply to LiteLLM_AdaptiveRouterState.
+        Returns number of cells flushed.
+        """
+        async with self._lock:
+            batch = self._state_agg
+            self._state_agg = {}
+
+        if not batch:
+            return 0
+
+        # Sort keys to give deterministic write order across writers and
+        # reduce the chance of cross-row deadlocks when other workers race us.
+        for key in sorted(batch.keys()):
+            router, rt, model = key
+            payload = batch[key]
+            try:
+                # Atomic increment: push the delta directly into the DB so
+                # concurrent flushers from multiple pods don't overwrite each
+                # other. The upsert creates the row with the delta as the
+                # initial value on first write, then increments on subsequent
+                # writes — no read-modify-write race.
+                await prisma_client.db.litellm_adaptiverouterstate.upsert(
+                    where={
+                        "router_name_request_type_model_name": {
+                            "router_name": router,
+                            "request_type": rt,
+                            "model_name": model,
+                        }
+                    },
+                    data={
+                        "create": {
+                            "router_name": router,
+                            "request_type": rt,
+                            "model_name": model,
+                            "alpha": payload["delta_alpha"],
+                            "beta": payload["delta_beta"],
+                            "total_samples": int(payload["samples_added"]),
+                        },
+                        "update": {
+                            "alpha": {"increment": payload["delta_alpha"]},
+                            "beta": {"increment": payload["delta_beta"]},
+                            "total_samples": {
+                                "increment": int(payload["samples_added"])
+                            },
+                        },
+                    },
+                )
+            except Exception as e:
+                verbose_router_logger.exception(
+                    "AdaptiveRouterUpdateQueue: failed to flush state for %s: %s",
+                    key,
+                    e,
+                )
+
+        return len(batch)
+
+    async def flush_session_to_db(self, prisma_client: Any) -> int:
+        """
+        Drain session aggregator and upsert into LiteLLM_AdaptiveRouterSession.
+        Returns number of session rows flushed.
+        """
+        async with self._lock:
+            batch = self._session_agg
+            self._session_agg = {}
+
+        if not batch:
+            return 0
+
+        for key in sorted(batch.keys()):
+            session_id, router, model = key
+            payload = batch[key]
+            try:
+                # NOTE: Prisma client lower-cases model names, so
+                # `LiteLLM_AdaptiveRouterSession` -> `litellm_adaptiveroutersession`
+                # (single 's', not 'litellm_adaptiverouterssession').
+                # Strip PK fields from the update payload — Prisma rejects
+                # writes to fields that are part of the @@id. asdict(state)
+                # always carries them, so build a separate update dict.
+                update_payload = {
+                    k: v
+                    for k, v in payload.items()
+                    if k not in ("session_id", "router_name", "model_name")
+                }
+                await prisma_client.db.litellm_adaptiveroutersession.upsert(
+                    where={
+                        "session_id_router_name_model_name": {
+                            "session_id": session_id,
+                            "router_name": router,
+                            "model_name": model,
+                        }
+                    },
+                    data={
+                        "create": {
+                            "session_id": session_id,
+                            "router_name": router,
+                            "model_name": model,
+                            **update_payload,
+                        },
+                        "update": update_payload,
+                    },
+                )
+            except Exception as e:
+                verbose_router_logger.exception(
+                    "AdaptiveRouterUpdateQueue: failed to flush session for %s: %s",
+                    key,
+                    e,
+                )
+
+        return len(batch)
+
+    # ---- Observability ---------------------------------------------------
+
+    async def queue_size(self) -> Dict[str, int]:
+        async with self._lock:
+            return {
+                "state_pending": len(self._state_agg),
+                "session_pending": len(self._session_agg),
+                "max_state_seen": self._max_state_size_seen,
+                "max_session_seen": self._max_session_size_seen,
+            }

litellm/types/router.py

@@ -8,7 +8,7 @@ from dataclasses import dataclass
 from typing import Any, Dict, List, Literal, Optional, Tuple, Union, get_type_hints
 
 import httpx
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 from typing_extensions import Required, TypedDict
 
 from litellm._uuid import uuid
@@ -221,6 +221,9 @@ class GenericLiteLLMParams(CredentialLiteLLMParams, CustomPricingLiteLLMParams):
     complexity_router_config: Optional[Dict] = None
     complexity_router_default_model: Optional[str] = None
 
+    # adaptive-router params
+    adaptive_router_default_model: Optional[str] = None
+    adaptive_router_config: Optional[Dict] = None
     # quality-router params
     quality_router_config: Optional[Dict] = None
     quality_router_default_model: Optional[str] = None
@@ -794,3 +797,44 @@ class PreRoutingHookResponse(BaseModel):
 
     model: str
     messages: Optional[List[Dict[str, Any]]]
+
+
+class RequestType(str, enum.Enum):
+    """Fixed v0 taxonomy. User-extensible types come in v1."""
+
+    CODE_GENERATION = "code_generation"
+    CODE_UNDERSTANDING = "code_understanding"
+    TECHNICAL_DESIGN = "technical_design"
+    ANALYTICAL_REASONING = "analytical_reasoning"
+    WRITING = "writing"
+    FACTUAL_LOOKUP = "factual_lookup"
+    GENERAL = "general"
+
+
+class AdaptiveRouterWeights(BaseModel):
+    quality: float = Field(default=0.7, ge=0.0, le=1.0)
+    cost: float = Field(default=0.3, ge=0.0, le=1.0)
+
+    @field_validator("cost")
+    @classmethod
+    def _weights_sum_to_one(cls, v, info):
+        q = info.data.get("quality", 0.7)
+        if abs(q + v - 1.0) > 0.001:
+            raise ValueError(
+                f"weights must sum to 1.0, got quality={q} + cost={v} = {q + v}"
+            )
+        return v
+
+
+class AdaptiveRouterConfig(BaseModel):
+    available_models: List[str]
+    weights: AdaptiveRouterWeights = Field(default_factory=AdaptiveRouterWeights)
+
+
+class AdaptiveRouterPreferences(BaseModel):
+    """model_info.adaptive_router_preferences — declared by each model."""
+
+    model_config = ConfigDict(use_enum_values=False)
+
+    quality_tier: int = Field(ge=1, le=3)
+    strengths: List[RequestType] = Field(default_factory=list)

litellm/types/utils.py

@@ -139,7 +139,9 @@ class ProviderSpecificModelInfo(TypedDict, total=False):
     supports_reasoning: Optional[bool]
     supports_url_context: Optional[bool]
     supports_none_reasoning_effort: Optional[bool]
+    supports_minimal_reasoning_effort: Optional[bool]
     supports_xhigh_reasoning_effort: Optional[bool]
+    supports_max_reasoning_effort: Optional[bool]
 
 
 class SearchContextCostPerQuery(TypedDict, total=False):

litellm/utils.py

@@ -5893,9 +5893,15 @@ def _get_model_info_helper(  # noqa: PLR0915
                 supports_none_reasoning_effort=_model_info.get(
                     "supports_none_reasoning_effort", None
                 ),
+                supports_minimal_reasoning_effort=_model_info.get(
+                    "supports_minimal_reasoning_effort", None
+                ),
                 supports_xhigh_reasoning_effort=_model_info.get(
                     "supports_xhigh_reasoning_effort", None
                 ),
+                supports_max_reasoning_effort=_model_info.get(
+                    "supports_max_reasoning_effort", None
+                ),
                 supports_computer_use=_model_info.get("supports_computer_use", None),
                 search_context_cost_per_query=_model_info.get(
                     "search_context_cost_per_query", None
@@ -8946,6 +8952,12 @@ class ProviderConfigManager:
             )
 
             return get_openrouter_image_generation_config(model)
+        elif LlmProviders.DASHSCOPE == provider:
+            from litellm.llms.dashscope.image_generation import (
+                get_dashscope_image_generation_config,
+            )
+
+            return get_dashscope_image_generation_config(model)
         return None
 
     @staticmethod

model_prices_and_context_window.json

@@ -1006,7 +1006,8 @@
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
         "supports_native_structured_output": true,
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "global.anthropic.claude-opus-4-6-v1": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -1034,7 +1035,8 @@
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
         "supports_native_structured_output": true,
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "us.anthropic.claude-opus-4-6-v1": {
         "cache_creation_input_token_cost": 6.875e-06,
@@ -1062,7 +1064,8 @@
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
         "supports_native_structured_output": true,
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "eu.anthropic.claude-opus-4-6-v1": {
         "cache_creation_input_token_cost": 6.875e-06,
@@ -1090,7 +1093,8 @@
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
         "supports_native_structured_output": true,
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "au.anthropic.claude-opus-4-6-v1": {
         "cache_creation_input_token_cost": 6.875e-06,
@@ -1118,7 +1122,8 @@
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
         "supports_native_structured_output": true,
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "anthropic.claude-opus-4-7": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -1146,7 +1151,9 @@
         "supports_vision": true,
         "supports_xhigh_reasoning_effort": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "anthropic.claude-mythos-preview": {
         "input_cost_per_token": 0,
@@ -1188,7 +1195,9 @@
         "supports_vision": true,
         "supports_xhigh_reasoning_effort": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "us.anthropic.claude-opus-4-7": {
         "cache_creation_input_token_cost": 6.875e-06,
@@ -1216,7 +1225,9 @@
         "supports_vision": true,
         "supports_xhigh_reasoning_effort": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "eu.anthropic.claude-opus-4-7": {
         "cache_creation_input_token_cost": 6.875e-06,
@@ -1244,7 +1255,9 @@
         "supports_vision": true,
         "supports_xhigh_reasoning_effort": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "au.anthropic.claude-opus-4-7": {
         "cache_creation_input_token_cost": 6.875e-06,
@@ -1272,7 +1285,9 @@
         "supports_vision": true,
         "supports_xhigh_reasoning_effort": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "anthropic.claude-sonnet-4-6": {
         "cache_creation_input_token_cost": 3.75e-06,
@@ -1299,7 +1314,8 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_minimal_reasoning_effort": true
     },
     "global.anthropic.claude-sonnet-4-6": {
         "cache_creation_input_token_cost": 3.75e-06,
@@ -1326,7 +1342,8 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_minimal_reasoning_effort": true
     },
     "us.anthropic.claude-sonnet-4-6": {
         "cache_creation_input_token_cost": 4.125e-06,
@@ -1353,7 +1370,8 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_minimal_reasoning_effort": true
     },
     "eu.anthropic.claude-sonnet-4-6": {
         "cache_creation_input_token_cost": 4.125e-06,
@@ -1380,7 +1398,8 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_minimal_reasoning_effort": true
     },
     "au.anthropic.claude-sonnet-4-6": {
         "cache_creation_input_token_cost": 4.125e-06,
@@ -1407,7 +1426,8 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_native_structured_output": true
+        "supports_native_structured_output": true,
+        "supports_minimal_reasoning_effort": true
     },
     "anthropic.claude-sonnet-4-20250514-v1:0": {
         "cache_creation_input_token_cost": 3.75e-06,
@@ -1925,7 +1945,8 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 159,
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "azure_ai/claude-opus-4-7": {
         "input_cost_per_token": 5e-06,
@@ -1953,7 +1974,9 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "supports_xhigh_reasoning_effort": true,
-        "tool_use_system_prompt_tokens": 159
+        "tool_use_system_prompt_tokens": 159,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "azure_ai/claude-opus-4-1": {
         "cache_creation_input_token_cost": 1.875e-05,
@@ -2017,7 +2040,8 @@
         "supports_response_schema": true,
         "supports_tool_choice": true,
         "supports_vision": true,
-        "tool_use_system_prompt_tokens": 346
+        "tool_use_system_prompt_tokens": 346,
+        "supports_minimal_reasoning_effort": true
     },
     "azure/computer-use-preview": {
         "input_cost_per_token": 3e-06,
@@ -8923,7 +8947,8 @@
         "supports_response_schema": true,
         "supports_tool_choice": true,
         "supports_vision": true,
-        "tool_use_system_prompt_tokens": 346
+        "tool_use_system_prompt_tokens": 346,
+        "supports_minimal_reasoning_effort": true
     },
     "claude-sonnet-4-5-20250929-v1:0": {
         "cache_creation_input_token_cost": 3.75e-06,
@@ -9117,7 +9142,8 @@
             "us": 1.1,
             "fast": 6.0
         },
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "claude-opus-4-6-20260205": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -9149,7 +9175,8 @@
             "us": 1.1,
             "fast": 6.0
         },
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "claude-opus-4-7": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -9181,7 +9208,9 @@
         "provider_specific_entry": {
             "us": 1.1,
             "fast": 6.0
-        }
+        },
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "claude-opus-4-7-20260416": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -9213,7 +9242,9 @@
         "provider_specific_entry": {
             "us": 1.1,
             "fast": 6.0
-        }
+        },
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "claude-sonnet-4-20250514": {
         "deprecation_date": "2026-05-14",
@@ -10366,6 +10397,22 @@
         "supports_reasoning": true,
         "supports_tool_choice": true
     },
+    "dashscope/qwen-image-2.0": {
+        "litellm_provider": "dashscope",
+        "mode": "image_generation",
+        "source": "https://www.alibabacloud.com/help/en/model-studio/models",
+        "supported_endpoints": [
+            "/v1/images/generations"
+        ]
+    },
+    "dashscope/qwen-image-2.0-pro": {
+        "litellm_provider": "dashscope",
+        "mode": "image_generation",
+        "source": "https://www.alibabacloud.com/help/en/model-studio/models",
+        "supported_endpoints": [
+            "/v1/images/generations"
+        ]
+    },
     "databricks/databricks-bge-large-en": {
         "input_cost_per_token": 1.0003e-07,
         "input_dbu_cost_per_token": 1.429e-06,
@@ -19240,6 +19287,42 @@
         "supports_xhigh_reasoning_effort": true,
         "supports_minimal_reasoning_effort": true
     },
+    "gpt-5.5": {
+        "cache_read_input_token_cost": 5e-07,
+        "input_cost_per_token": 5e-06,
+        "litellm_provider": "openai",
+        "max_input_tokens": 272000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "output_cost_per_token": 3e-05,
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/batch",
+            "/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_service_tier": true,
+        "supports_vision": true,
+        "supports_none_reasoning_effort": true,
+        "supports_xhigh_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
+    },
     "gpt-5.4": {
         "cache_read_input_token_cost": 2.5e-07,
         "cache_read_input_token_cost_above_272k_tokens": 5e-07,
@@ -25082,7 +25165,8 @@
         "supports_reasoning": true,
         "supports_tool_choice": true,
         "supports_vision": true,
-        "tool_use_system_prompt_tokens": 159
+        "tool_use_system_prompt_tokens": 159,
+        "supports_minimal_reasoning_effort": true
     },
     "openrouter/anthropic/claude-opus-4.5": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -25120,7 +25204,8 @@
         "supports_reasoning": true,
         "supports_tool_choice": true,
         "supports_vision": true,
-        "tool_use_system_prompt_tokens": 346
+        "tool_use_system_prompt_tokens": 346,
+        "supports_minimal_reasoning_effort": true
     },
     "openrouter/anthropic/claude-sonnet-4.5": {
         "input_cost_per_image": 0.0048,
@@ -30170,7 +30255,8 @@
         "supports_reasoning": true,
         "supports_response_schema": true,
         "supports_tool_choice": true,
-        "supports_vision": true
+        "supports_vision": true,
+        "supports_minimal_reasoning_effort": true
     },
     "vercel_ai_gateway/anthropic/claude-sonnet-4": {
         "cache_creation_input_token_cost": 3.75e-06,
@@ -31397,7 +31483,8 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "vertex_ai/claude-opus-4-6@default": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -31424,7 +31511,8 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "tool_use_system_prompt_tokens": 346,
-        "supports_max_reasoning_effort": true
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "vertex_ai/claude-opus-4-7": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -31451,7 +31539,9 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "supports_xhigh_reasoning_effort": true,
-        "tool_use_system_prompt_tokens": 346
+        "tool_use_system_prompt_tokens": 346,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "vertex_ai/claude-opus-4-7@default": {
         "cache_creation_input_token_cost": 6.25e-06,
@@ -31478,7 +31568,9 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "supports_xhigh_reasoning_effort": true,
-        "tool_use_system_prompt_tokens": 346
+        "tool_use_system_prompt_tokens": 346,
+        "supports_max_reasoning_effort": true,
+        "supports_minimal_reasoning_effort": true
     },
     "vertex_ai/claude-sonnet-4-5": {
         "cache_creation_input_token_cost": 3.75e-06,
@@ -31530,7 +31622,8 @@
             "search_context_size_high": 0.01,
             "search_context_size_low": 0.01,
             "search_context_size_medium": 0.01
-        }
+        },
+        "supports_minimal_reasoning_effort": true
     },
     "vertex_ai/claude-sonnet-4-5@20250929": {
         "cache_creation_input_token_cost": 3.75e-06,
@@ -38424,7 +38517,8 @@
             "search_context_size_high": 0.01,
             "search_context_size_low": 0.01,
             "search_context_size_medium": 0.01
-        }
+        },
+        "supports_minimal_reasoning_effort": true
     },
     "duckduckgo/search": {
         "litellm_provider": "duckduckgo",

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "litellm"
-version = "1.83.11"
+version = "1.83.13"
 description = "Library to easily interface with LLM API providers"
 readme = "README.md"
 requires-python = ">=3.10, <3.14"
@@ -52,7 +52,7 @@ proxy = [
     "azure-identity==1.25.2",
     "azure-storage-blob==12.28.0",
     "mcp==1.26.0",
-    "litellm-proxy-extras==0.4.67",
+    "litellm-proxy-extras==0.4.68",
     "litellm-enterprise==0.1.38",
     "RestrictedPython==8.1",
     "rich==13.9.4",
@@ -236,7 +236,7 @@ source-exclude = [
 profile = "black"
 
 [tool.commitizen]
-version = "1.83.11"
+version = "1.83.13"
 version_files = [
     "pyproject.toml:^version",
 ]

schema.prisma

@@ -616,6 +616,7 @@ model LiteLLM_TeamMembership {
   user_id    String
   team_id    String
   spend      Float    @default(0.0)
+  total_spend Float @default(0.0)
   budget_id String?
   litellm_budget_table LiteLLM_BudgetTable?   @relation(fields: [budget_id], references: [budget_id])
   @@id([user_id, team_id])
@@ -1223,3 +1224,46 @@ model LiteLLM_ClaudeCodePluginTable {
 
   @@map("LiteLLM_ClaudeCodePluginTable")
 }
+
+// Per-(router, request_type, model) Beta posterior for the adaptive router.
+model LiteLLM_AdaptiveRouterState {
+  router_name     String
+  request_type    String
+  model_name      String
+  alpha           Float
+  beta            Float
+  total_samples   Int      @default(0)
+  last_updated_at DateTime @default(now()) @updatedAt
+
+  @@id([router_name, request_type, model_name])
+}
+
+// Per-(session, router, model) signal counters for the adaptive router.
+model LiteLLM_AdaptiveRouterSession {
+  session_id             String
+  router_name            String
+  model_name             String
+  classified_type        String
+
+  misalignment_count     Int      @default(0)
+  stagnation_count       Int      @default(0)
+  disengagement_count    Int      @default(0)
+  satisfaction_count     Int      @default(0)
+  failure_count          Int      @default(0)
+  loop_count             Int      @default(0)
+  exhaustion_count       Int      @default(0)
+
+  last_user_content      String?
+  last_assistant_content String?
+  tool_call_history      Json     @default("[]")
+  pending_tool_calls     Json     @default("{}")
+
+  turn_count             Int      @default(0)
+  last_processed_turn    Int      @default(-1)
+  clean_credit_awarded   Boolean  @default(false)
+  terminal_status        Int?
+  last_activity_at       DateTime @default(now()) @updatedAt
+
+  @@id([session_id, router_name, model_name])
+  @@index([last_activity_at], map: "idx_adaptive_router_session_activity")
+}