Merge remote-tracking branch 'origin' into litellm_ui_unset_values

2026-08-18 08:25:10 +00:00 · 2025-12-22 11:44:41 -08:00
parent ffcac2eebc a27db9f52d
commit 81dc70673a
357 changed files with 6179 additions and 1628 deletions
@@ -178,6 +178,7 @@ jobs:
            pip install "Pillow==10.3.0"
            pip install "jsonschema==4.22.0"
            pip install "pytest-xdist==3.6.1"
+            pip install "pytest-timeout==2.2.0"
            pip install "websockets==13.1.0"
            pip install semantic_router --no-deps
            pip install aurelio_sdk --no-deps
@@ -208,7 +209,10 @@ jobs:
          command: |
            pwd
            ls
-            python -m pytest -vv tests/local_testing --cov=litellm --cov-report=xml --junitxml=test-results/junit.xml --durations=5 -k "not test_python_38.py and not test_basic_python_version.py and not router and not assistants and not langfuse and not caching and not cache" -n 4
+            # Add --timeout to kill hanging tests after 300s (5 min)
+            # Add -v to show test names as they run for debugging
+            # Add --tb=short for shorter tracebacks
+            python -m pytest -vv tests/local_testing --cov=litellm --cov-report=xml --junitxml=test-results/junit.xml --durations=20 -k "not test_python_38.py and not test_basic_python_version.py and not router and not assistants and not langfuse and not caching and not cache" -n 4 --timeout=300 --timeout_method=thread
          no_output_timeout: 120m
      - run:
          name: Rename the coverage files
@@ -614,6 +618,12 @@ jobs:
      - run:
          name: Install Dependencies
          command: |
+            export PATH="$HOME/miniconda/bin:$PATH"
+            source $HOME/miniconda/etc/profile.d/conda.sh
+            conda activate myenv
+            python --version
+            which python
+            pip install --upgrade typing-extensions>=4.12.0
            pip install "pytest==7.3.1"
            pip install "pytest-asyncio==0.21.1"
            pip install aiohttp
@@ -657,7 +667,7 @@ jobs:
            docker run -d \
              --name postgres-db \
              -e POSTGRES_USER=postgres \
-              -e POSTGRES_PASSWORD=test-postgres \
+              -e POSTGRES_PASSWORD=postgres \
              -e POSTGRES_DB=circle_test \
              -p 5432:5432 \
              postgres:14
@@ -677,6 +687,9 @@ jobs:
      - run:
          name: Run prisma ./docker/entrypoint.sh
          command: |
+            export PATH="$HOME/miniconda/bin:$PATH"
+            source $HOME/miniconda/etc/profile.d/conda.sh
+            conda activate myenv
            set +e
            chmod +x docker/entrypoint.sh
            ./docker/entrypoint.sh
@@ -685,6 +698,9 @@ jobs:
      - run:
          name: Run tests
          command: |
+            export PATH="$HOME/miniconda/bin:$PATH"
+            source $HOME/miniconda/etc/profile.d/conda.sh
+            conda activate myenv
            pwd
            ls
            python -m pytest tests/proxy_security_tests --cov=litellm --cov-report=xml -vv -x -v --junitxml=test-results/junit.xml --durations=5
@@ -1090,13 +1106,16 @@ jobs:
            pip install "pytest-asyncio==0.21.1"
            pip install "respx==0.22.0"
            pip install "pytest-xdist==3.6.1"
+            pip install "pytest-timeout==2.2.0"
      # Run pytest and generate JUnit XML report
      - run:
          name: Run tests
          command: |
            pwd
            ls
-            python -m pytest -vv tests/llm_translation --cov=litellm --cov-report=xml -v --junitxml=test-results/junit.xml --durations=5 -n 4
+            # Add --timeout to kill hanging tests after 120s (2 min)
+            # Add --durations=20 to show 20 slowest tests for debugging
+            python -m pytest -vv tests/llm_translation --cov=litellm --cov-report=xml -v --junitxml=test-results/junit.xml --durations=20 -n 4 --timeout=120 --timeout_method=thread
          no_output_timeout: 120m
      - run:
          name: Rename the coverage files
@@ -2108,7 +2127,7 @@ jobs:
            docker run -d \
              --name postgres-db \
              -e POSTGRES_USER=postgres \
-              -e POSTGRES_PASSWORD=test-postgres \
+              -e POSTGRES_PASSWORD=postgres \
              -e POSTGRES_DB=circle_test \
              -p 5432:5432 \
              postgres:14
@@ -2250,7 +2269,7 @@ jobs:
            docker run -d \
              --name postgres-db \
              -e POSTGRES_USER=postgres \
-              -e POSTGRES_PASSWORD=test-postgres \
+              -e POSTGRES_PASSWORD=postgres \
              -e POSTGRES_DB=circle_test \
              -p 5432:5432 \
              postgres:14
@@ -2390,7 +2409,7 @@ jobs:
            docker run -d \
              --name postgres-db \
              -e POSTGRES_USER=postgres \
-              -e POSTGRES_PASSWORD=test-postgres \
+              -e POSTGRES_PASSWORD=postgres \
              -e POSTGRES_DB=circle_test \
              -p 5432:5432 \
              postgres:14
@@ -2551,7 +2570,7 @@ jobs:
            docker run -d \
              --name postgres-db \
              -e POSTGRES_USER=postgres \
-              -e POSTGRES_PASSWORD=test-postgres \
+              -e POSTGRES_PASSWORD=postgres \
              -e POSTGRES_DB=circle_test \
              -p 5432:5432 \
              postgres:14
@@ -2664,7 +2683,7 @@ jobs:
            docker run -d \
              --name postgres-db \
              -e POSTGRES_USER=postgres \
-              -e POSTGRES_PASSWORD=test-postgres \
+              -e POSTGRES_PASSWORD=postgres \
              -e POSTGRES_DB=circle_test \
              -p 5432:5432 \
              postgres:14
@@ -2800,7 +2819,7 @@ jobs:
            docker run -d \
              --name postgres-db \
              -e POSTGRES_USER=postgres \
-              -e POSTGRES_PASSWORD=test-postgres \
+              -e POSTGRES_PASSWORD=postgres \
              -e POSTGRES_DB=circle_test \
              -p 5432:5432 \
              postgres:14
@@ -3032,7 +3051,7 @@ jobs:
            docker run -d \
              --name postgres-db \
              -e POSTGRES_USER=postgres \
-              -e POSTGRES_PASSWORD=test-postgres \
+              -e POSTGRES_PASSWORD=postgres \
              -e POSTGRES_DB=circle_test \
              -p 5432:5432 \
              postgres:14
@@ -3549,7 +3568,7 @@ jobs:
            docker run -d \
              --name postgres-db \
              -e POSTGRES_USER=postgres \
-              -e POSTGRES_PASSWORD=test-postgres \
+              -e POSTGRES_PASSWORD=postgres \
              -e POSTGRES_DB=circle_test \
              -p 5432:5432 \
              postgres:14
@@ -3954,4 +3973,4 @@ workflows:
            - proxy_pass_through_endpoint_tests
            - check_code_and_doc_quality
            - publish_proxy_extras
-            - guardrails_testing
+            - guardrails_testing
@@ -1,84 +0,0 @@
-version: 2
-
-secret:
-  # Exclude files and paths by globbing
-  ignored_paths:
-    - "**/*.whl"
-    - "**/*.pyc"
-    - "**/__pycache__/**"
-    - "**/node_modules/**"
-    - "**/dist/**"
-    - "**/build/**"
-    - "**/.git/**"
-    - "**/venv/**"
-    - "**/.venv/**"
-    
-    # Large data/metadata files that don't need scanning
-    - "**/model_prices_and_context_window*.json"
-    - "**/*_metadata/*.txt"
-    - "**/tokenizers/*.json"
-    - "**/tokenizers/*"
-    - "miniconda.sh"
-    
-    # Build outputs and static assets
-    - "litellm/proxy/_experimental/out/**"
-    - "ui/litellm-dashboard/public/**"
-    - "**/swagger/*.js"
-    - "**/*.woff"
-    - "**/*.woff2"
-    - "**/*.avif"
-    - "**/*.webp"
-    
-    # Test data files
-    - "**/tests/**/data_map.txt"
-    - "tests/**/*.txt"
-    
-    # Documentation and other non-code files
-    - "docs/**"
-    - "**/*.md"
-    - "**/*.lock"
-    - "poetry.lock"
-    - "package-lock.json"
-
-  # Ignore security incidents with the SHA256 of the occurrence (false positives)
-  ignored_matches:
-    # === Current detected false positives (SHA-based) ===
-    
-    # gcs_pub_sub_body - folder name, not a password
-    - name: GCS pub/sub test folder name
-      match: 75f377c456eede69e5f6e47399ccee6016a2a93cc5dd11db09cc5b1359ae569a
-    
-    # os.environ/APORIA_API_KEY_1 - environment variable reference
-    - name: Environment variable reference APORIA_API_KEY_1
-      match: e2ddeb8b88eca97a402559a2be2117764e11c074d86159ef9ad2375dea188094
-    
-    # os.environ/APORIA_API_KEY_2 - environment variable reference
-    - name: Environment variable reference APORIA_API_KEY_2
-      match: 09aa39a29e050b86603aa55138af1ff08fb86a4582aa965c1bd0672e1575e052
-    
-    # oidc/circleci_v2/ - test authentication path, not a secret
-    - name: OIDC CircleCI test path
-      match: feb3475e1f89a65b7b7815ac4ec597e18a9ec1847742ad445c36ca617b536e15
-    
-    # text-davinci-003 - OpenAI model identifier, not a secret
-    - name: OpenAI model identifier text-davinci-003
-      match: c489000cf6c7600cee0eefb80ad0965f82921cfb47ece880930eb7e7635cf1f1
-    
-    # === Preventive patterns for test keys (pattern-based) ===
-    
-    # Test API keys (124 instances across 45 files)
-    - name: Test API keys with sk-test prefix
-      match: sk-test-
-    
-    # Mock API keys
-    - name: Mock API keys with sk-mock prefix
-      match: sk-mock-
-    
-    # Fake API keys
-    - name: Fake API keys with sk-fake prefix
-      match: sk-fake-
-    
-    # Generic test API key patterns
-    - name: Test API key patterns
-      match: test-api-key
-
@@ -8,7 +8,7 @@ class MyUser(HttpUser):
    def chat_completion(self):
        headers = {
            "Content-Type": "application/json",
-            "Authorization": "Bearer sk-test-load-test-key-123",
+            "Authorization": "Bearer sk-8N1tLOOyH8TIxwOLahhIVg",
            # Include any additional headers you may need for authentication, etc.
        }

@@ -20,7 +20,7 @@ jobs:
        env:
          POSTGRES_DB: temp_db
          POSTGRES_USER: postgres
-          POSTGRES_PASSWORD: test-postgres
+          POSTGRES_PASSWORD: postgres
        ports:
          - 5432:5432
        options: >-
@@ -35,7 +35,7 @@ jobs:
        env:
          POSTGRES_DB: shadow_db
          POSTGRES_USER: postgres
-          POSTGRES_PASSWORD: test-postgres
+          POSTGRES_PASSWORD: postgres
        ports:
          - 5433:5432
        options: >-
@@ -49,6 +49,27 @@ LiteLLM is a unified interface for 100+ LLMs that:
   - Test provider-specific functionality thoroughly
   - Consider adding load tests for performance-critical changes

+### MAKING CODE CHANGES FOR THE UI (IGNORE FOR BACKEND)
+
+1. **Use Common Components as much as possible**:
+   - These are usually defined in the `common_components` directory
+   - Use these components as much as possible and avoid building new components unless needed
+   - Tremor components are deprecated; prefer using Ant Design (AntD) as much as possible
+
+2. **Testing**:
+   - The codebase uses **Vitest** and **React Testing Library**
+   - **Query Priority Order**: Use query methods in this order: `getByRole`, `getByLabelText`, `getByPlaceholderText`, `getByText`, `getByTestId`
+   - **Always use `screen`** instead of destructuring from `render()` (e.g., use `screen.getByText()` not `getByText`)
+   - **Wrap user interactions in `act()`**: Always wrap `fireEvent` calls with `act()` to ensure React state updates are properly handled
+   - **Use `query` methods for absence checks**: Use `queryBy*` methods (not `getBy*`) when expecting an element to NOT be present
+   - **Test names must start with "should"**: All test names should follow the pattern `it("should ...")`
+   - **Mock external dependencies**: Check `setupTests.ts` for global mocks and mock child components/networking calls as needed
+   - **Structure tests properly**:
+     - First test should verify the component renders successfully
+     - Subsequent tests should focus on functionality and user interactions
+     - Use `waitFor` for async operations that aren't already awaited
+   - **Avoid using `querySelector`**: Prefer React Testing Library queries over direct DOM manipulation
+
 ### IMPORTANT PATTERNS

 1. **Function/Tool Calling**:
@@ -1,40 +0,0 @@
-# Test Key Patterns Standard
-
-Standard patterns for test/mock keys and credentials in the LiteLLM codebase to avoid triggering secret detection.
-
-## How GitGuardian Works
-
-GitGuardian uses **machine learning and entropy analysis**, not just pattern matching:
- **Low entropy** values (like `sk-1234`, `postgres`) are automatically ignored
- **High entropy** values (realistic-looking secrets) trigger detection
- **Context-aware** detection understands code syntax like `os.environ["KEY"]`
-
-## Recommended Test Key Patterns
-
-### Option 1: Low Entropy Values (Simplest)
-These won't trigger GitGuardian's ML detector:
-
-```python
-api_key = "sk-1234"
-api_key = "sk-12345"
-database_password = "postgres"
-token = "test123"
-```
-
-### Option 2: High Entropy with Test Prefixes
-If you need realistic-looking test keys with high entropy, use these prefixes:
-
-```python
-api_key = "sk-test-abc123def456ghi789..."  # OpenAI-style test key
-api_key = "sk-mock-1234567890abcdef1234..."  # Mock key
-api_key = "sk-fake-xyz789uvw456rst123..."  # Fake key
-token = "test-api-key-with-high-entropy"
-```
-
-## Configured Ignore Patterns
-
-These patterns are in `.gitguardian.yaml` for high-entropy test keys:
- `sk-test-*` - OpenAI-style test keys
- `sk-mock-*` - Mock API keys  
- `sk-fake-*` - Fake API keys
- `test-api-key` - Generic test tokens
@@ -58,20 +58,20 @@ run_secret_detection() {
    # Use --recursive for directory scanning and auto-confirm if prompted
    # .gitguardian.yaml will automatically exclude binary files, wheel files, etc.
    # GITGUARDIAN_API_KEY environment variable will be used for authentication
-    echo y | ggshield secret scan path . --recursive || {
-        echo ""
-        echo "=========================================="
-        echo "ERROR: Secret Detection Failed"
-        echo "=========================================="
-        echo "ggshield has detected secrets in the codebase."
-        echo "Please review discovered secrets above, revoke any actively used secrets"
-        echo "from underlying systems and make changes to inject secrets dynamically at runtime."
-        echo ""
-        echo "For more information, see: https://docs.gitguardian.com/secrets-detection/"
-        echo "=========================================="
-        echo ""
-        exit 1
-    }
+    # echo y | ggshield secret scan path . --recursive || {
+    #     echo ""
+    #     echo "=========================================="
+    #     echo "ERROR: Secret Detection Failed"
+    #     echo "=========================================="
+    #     echo "ggshield has detected secrets in the codebase."
+    #     echo "Please review discovered secrets above, revoke any actively used secrets"
+    #     echo "from underlying systems and make changes to inject secrets dynamically at runtime."
+    #     echo ""
+    #     echo "For more information, see: https://docs.gitguardian.com/secrets-detection/"
+    #     echo "=========================================="
+    #     echo ""
+    #     exit 1
+    # }
    
    echo "Secret detection scans completed successfully"
 }
@@ -39,7 +39,7 @@
        "import os\n",
        "os.environ['OPENAI_API_KEY'] = \"\"\n",
        "os.environ['REPLICATE_API_TOKEN'] = \"\"\n",
-        "os.environ['PROMPTLAYER_API_KEY'] = \"test-promptlayer-key-123\"\n",
+        "os.environ['PROMPTLAYER_API_KEY'] = \"pl_4ea2bb00a4dca1b8a70cebf2e9e11564\"\n",
        "\n",
        "# Set Promptlayer as a success callback\n",
        "litellm.success_callback =['promptlayer']\n",
@@ -1,10 +1,21 @@
 {
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
  "cells": [
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "kccfk0mHZ4Ad"
-      },
      "source": [
        "# Migrating to LiteLLM Proxy from OpenAI/Azure OpenAI\n",
        "\n",
@@ -21,26 +32,29 @@
        "To pass provider-specific args, [go here](https://docs.litellm.ai/docs/completion/provider_specific_params#proxy-usage)\n",
        "\n",
        "To drop unsupported params (E.g. frequency_penalty for bedrock with librechat), [go here](https://docs.litellm.ai/docs/completion/drop_params#openai-proxy-usage)\n"
-      ]
+      ],
+      "metadata": {
+        "id": "kccfk0mHZ4Ad"
+      }
    },
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "nmSClzCPaGH6"
-      },
      "source": [
        "## /chat/completion\n",
        "\n"
-      ]
+      ],
+      "metadata": {
+        "id": "nmSClzCPaGH6"
+      }
    },
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "_vqcjwOVaKpO"
-      },
      "source": [
        "### OpenAI Python SDK"
-      ]
+      ],
+      "metadata": {
+        "id": "_vqcjwOVaKpO"
+      }
    },
    {
      "cell_type": "code",
@@ -80,20 +94,15 @@
    },
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "AqkyKk9Scxgj"
-      },
      "source": [
        "## Function Calling"
-      ]
+      ],
+      "metadata": {
+        "id": "AqkyKk9Scxgj"
+      }
    },
    {
      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "wDg10VqLczE1"
-      },
-      "outputs": [],
      "source": [
        "from openai import OpenAI\n",
        "client = OpenAI(\n",
@@ -130,24 +139,24 @@
        ")\n",
        "\n",
        "print(completion)\n"
-      ]
+      ],
+      "metadata": {
+        "id": "wDg10VqLczE1"
+      },
+      "execution_count": null,
+      "outputs": []
    },
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "YYoxLloSaNWW"
-      },
      "source": [
        "### Azure OpenAI Python SDK"
-      ]
+      ],
+      "metadata": {
+        "id": "YYoxLloSaNWW"
+      }
    },
    {
      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "yA1XcgowaSRy"
-      },
-      "outputs": [],
      "source": [
        "import openai\n",
        "client = openai.AzureOpenAI(\n",
@@ -175,24 +184,24 @@
        ")\n",
        "\n",
        "print(response)"
-      ]
+      ],
+      "metadata": {
+        "id": "yA1XcgowaSRy"
+      },
+      "execution_count": null,
+      "outputs": []
    },
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "yl9qhDvnaTpL"
-      },
      "source": [
        "### Langchain Python"
-      ]
+      ],
+      "metadata": {
+        "id": "yl9qhDvnaTpL"
+      }
    },
    {
      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "5MUZgSquaW5t"
-      },
-      "outputs": [],
      "source": [
        "from langchain.chat_models import ChatOpenAI\n",
        "from langchain.prompts.chat import (\n",
@@ -230,22 +239,24 @@
        "response = chat(messages)\n",
        "\n",
        "print(response)"
-      ]
+      ],
+      "metadata": {
+        "id": "5MUZgSquaW5t"
+      },
+      "execution_count": null,
+      "outputs": []
    },
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "B9eMgnULbRaz"
-      },
      "source": [
        "### Curl"
-      ]
+      ],
+      "metadata": {
+        "id": "B9eMgnULbRaz"
+      }
    },
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "VWCCk5PFcmhS"
-      },
      "source": [
        "\n",
        "\n",
@@ -269,24 +280,22 @@
        "}'\n",
        "```\n",
        "\n"
-      ]
+      ],
+      "metadata": {
+        "id": "VWCCk5PFcmhS"
+      }
    },
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "drBAm2e1b6xe"
-      },
      "source": [
        "### LlamaIndex"
-      ]
+      ],
+      "metadata": {
+        "id": "drBAm2e1b6xe"
+      }
    },
    {
      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "d0bZcv8fb9mL"
-      },
-      "outputs": [],
      "source": [
        "import os, dotenv\n",
        "\n",
@@ -317,24 +326,24 @@
        "query_engine = index.as_query_engine()\n",
        "response = query_engine.query(\"What did the author do growing up?\")\n",
        "print(response)\n"
-      ]
+      ],
+      "metadata": {
+        "id": "d0bZcv8fb9mL"
+      },
+      "execution_count": null,
+      "outputs": []
    },
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "xypvNdHnb-Yy"
-      },
      "source": [
        "### Langchain JS"
-      ]
+      ],
+      "metadata": {
+        "id": "xypvNdHnb-Yy"
+      }
    },
    {
      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "R55mK2vCcBN2"
-      },
-      "outputs": [],
      "source": [
        "import { ChatOpenAI } from \"@langchain/openai\";\n",
        "\n",
@@ -350,24 +359,24 @@
        "const message = await model.invoke(\"Hi there!\");\n",
        "\n",
        "console.log(message);\n"
-      ]
+      ],
+      "metadata": {
+        "id": "R55mK2vCcBN2"
+      },
+      "execution_count": null,
+      "outputs": []
    },
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "nC4bLifCcCiW"
-      },
      "source": [
        "### OpenAI JS"
-      ]
+      ],
+      "metadata": {
+        "id": "nC4bLifCcCiW"
+      }
    },
    {
      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "MICH8kIMcFpg"
-      },
-      "outputs": [],
      "source": [
        "const { OpenAI } = require('openai');\n",
        "\n",
@@ -389,24 +398,24 @@
        "}\n",
        "\n",
        "main();\n"
-      ]
+      ],
+      "metadata": {
+        "id": "MICH8kIMcFpg"
+      },
+      "execution_count": null,
+      "outputs": []
    },
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "D1Q07pEAcGTb"
-      },
      "source": [
        "### Anthropic SDK"
-      ]
+      ],
+      "metadata": {
+        "id": "D1Q07pEAcGTb"
+      }
    },
    {
      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "qBjFcAvgcI3t"
-      },
-      "outputs": [],
      "source": [
        "import os\n",
        "\n",
@@ -414,7 +423,7 @@
        "\n",
        "client = Anthropic(\n",
        "    base_url=\"http://localhost:4000\", # proxy endpoint\n",
-        "    api_key=\"sk-test-proxy-key-123\", # litellm proxy virtual key (example)\n",
+        "    api_key=\"sk-s4xN1IiLTCytwtZFJaYQrA\", # litellm proxy virtual key\n",
        ")\n",
        "\n",
        "message = client.messages.create(\n",
@@ -428,33 +437,33 @@
        "    model=\"claude-3-opus-20240229\",\n",
        ")\n",
        "print(message.content)"
-      ]
+      ],
+      "metadata": {
+        "id": "qBjFcAvgcI3t"
+      },
+      "execution_count": null,
+      "outputs": []
    },
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "dFAR4AJGcONI"
-      },
      "source": [
        "## /embeddings"
-      ]
+      ],
+      "metadata": {
+        "id": "dFAR4AJGcONI"
+      }
    },
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "lgNoM281cRzR"
-      },
      "source": [
        "### OpenAI Python SDK"
-      ]
+      ],
+      "metadata": {
+        "id": "lgNoM281cRzR"
+      }
    },
    {
      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "NY3DJhPfcQhA"
-      },
-      "outputs": [],
      "source": [
        "import openai\n",
        "from openai import OpenAI\n",
@@ -469,24 +478,24 @@
        ")\n",
        "\n",
        "print(response)\n"
-      ]
+      ],
+      "metadata": {
+        "id": "NY3DJhPfcQhA"
+      },
+      "execution_count": null,
+      "outputs": []
    },
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "hmbg-DW6cUZs"
-      },
      "source": [
        "### Langchain Embeddings"
-      ]
+      ],
+      "metadata": {
+        "id": "hmbg-DW6cUZs"
+      }
    },
    {
      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "lX2S8Nl1cWVP"
-      },
-      "outputs": [],
      "source": [
        "from langchain.embeddings import OpenAIEmbeddings\n",
        "\n",
@@ -517,22 +526,24 @@
        "\n",
        "print(f\"TITAN EMBEDDINGS\")\n",
        "print(query_result[:5])"
-      ]
+      ],
+      "metadata": {
+        "id": "lX2S8Nl1cWVP"
+      },
+      "execution_count": null,
+      "outputs": []
    },
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "oqGbWBCQcYfd"
-      },
      "source": [
        "### Curl Request"
-      ]
+      ],
+      "metadata": {
+        "id": "oqGbWBCQcYfd"
+      }
    },
    {
      "cell_type": "markdown",
-      "metadata": {
-        "id": "7rkIMV9LcdwQ"
-      },
      "source": [
        "\n",
        "\n",
@@ -545,21 +556,10 @@
        "  }'\n",
        "```\n",
        "\n"
-      ]
+      ],
+      "metadata": {
+        "id": "7rkIMV9LcdwQ"
+      }
    }
-  ],
-  "metadata": {
-    "colab": {
-      "provenance": []
-    },
-    "kernelspec": {
-      "display_name": "Python 3",
-      "name": "python3"
-    },
-    "language_info": {
-      "name": "python"
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 0
-}
+  ]
+}
@@ -79,7 +79,7 @@ ENV PRISMA_BINARY_CACHE_DIR=/app/.cache/prisma-python/binaries \
    XDG_CACHE_HOME=/app/.cache \
    PATH="/usr/lib/python3.13/site-packages/nodejs/bin:${PATH}"

-RUN pip install --no-cache-dir prisma==0.11.0 nodejs-bin==18.4.0a4 \
+RUN pip install --no-cache-dir prisma==0.11.0 nodejs-wheel-binaries==24.12.0 \
    && mkdir -p /app/.cache/npm

 RUN NPM_CONFIG_CACHE=/app/.cache/npm \
@@ -106,7 +106,7 @@ model_list:
      aws_region_name: us-west-2
      aws_session_name: "my-test-session"
      aws_role_name: "arn:aws:iam::335785316107:role/litellm-github-unit-tests-circleci"
-      aws_web_identity_token: "oidc/example-provider/"
+      aws_web_identity_token: "oidc/circleci_v2/"
 ```

 #### Amazon IAM Role Configuration for CircleCI v2 -> Bedrock
@@ -0,0 +1,364 @@
+# AWS Polly Text to Speech (tts)
+
+## Overview
+
+| Property | Details |
+|-------|-------|
+| Description | Convert text to natural-sounding speech using AWS Polly's neural and standard TTS engines |
+| Provider Route on LiteLLM | `aws_polly/` |
+| Supported Operations | `/audio/speech` |
+| Link to Provider Doc | [AWS Polly SynthesizeSpeech ↗](https://docs.aws.amazon.com/polly/latest/dg/API_SynthesizeSpeech.html) |
+
+## Quick Start
+
+### **LiteLLM SDK**
+
+```python showLineNumbers title="SDK Usage"
+import litellm
+from pathlib import Path
+import os
+
+# Set environment variables
+os.environ["AWS_ACCESS_KEY_ID"] = ""
+os.environ["AWS_SECRET_ACCESS_KEY"] = ""
+os.environ["AWS_REGION_NAME"] = "us-east-1"
+
+# AWS Polly call
+speech_file_path = Path(__file__).parent / "speech.mp3"
+response = litellm.speech(
+    model="aws_polly/neural",
+    voice="Joanna",
+    input="the quick brown fox jumped over the lazy dogs",
+)
+response.stream_to_file(speech_file_path)
+```
+
+### **LiteLLM PROXY**
+
+```yaml showLineNumbers title="proxy_config.yaml"
+model_list:
+  - model_name: polly-neural
+    litellm_params:
+      model: aws_polly/neural
+      aws_access_key_id: "os.environ/AWS_ACCESS_KEY_ID"
+      aws_secret_access_key: "os.environ/AWS_SECRET_ACCESS_KEY"
+      aws_region_name: "us-east-1"
+```
+
+## Polly Engines
+
+AWS Polly supports different speech synthesis engines. Specify the engine in the model name:
+
+| Model | Engine | Cost (per 1M chars) | Description |
+|-------|--------|---------------------|-------------|
+| `aws_polly/standard` | Standard | $4.00 | Original Polly voices, faster and lowest cost |
+| `aws_polly/neural` | Neural | $16.00 | More natural, human-like speech (recommended) |
+| `aws_polly/generative` | Generative | $30.00 | Most expressive, highest quality (limited voices) |
+| `aws_polly/long-form` | Long-form | $100.00 | Optimized for long content like articles |
+
+### **LiteLLM SDK**
+
+```python showLineNumbers title="Using Different Engines"
+import litellm
+
+# Neural engine (recommended)
+response = litellm.speech(
+    model="aws_polly/neural",
+    voice="Joanna",
+    input="Hello world",
+)
+
+# Standard engine (lower cost)
+response = litellm.speech(
+    model="aws_polly/standard",
+    voice="Joanna",
+    input="Hello world",
+)
+
+# Generative engine (highest quality)
+response = litellm.speech(
+    model="aws_polly/generative",
+    voice="Matthew",
+    input="Hello world",
+)
+```
+
+### **LiteLLM PROXY**
+
+```yaml showLineNumbers title="proxy_config.yaml"
+model_list:
+  - model_name: polly-neural
+    litellm_params:
+      model: aws_polly/neural
+      aws_region_name: "us-east-1"
+  - model_name: polly-standard
+    litellm_params:
+      model: aws_polly/standard
+      aws_region_name: "us-east-1"
+  - model_name: polly-generative
+    litellm_params:
+      model: aws_polly/generative
+      aws_region_name: "us-east-1"
+```
+
+## Available Voices
+
+### Native Polly Voices
+
+AWS Polly has many voices across different languages. Here are popular US English voices:
+
+| Voice | Gender | Engine Support |
+|-------|--------|----------------|
+| `Joanna` | Female | Neural, Standard |
+| `Matthew` | Male | Neural, Standard, Generative |
+| `Ivy` | Female (child) | Neural, Standard |
+| `Kendra` | Female | Neural, Standard |
+| `Amy` | Female (British) | Neural, Standard |
+| `Brian` | Male (British) | Neural, Standard |
+
+### **LiteLLM SDK**
+
+```python showLineNumbers title="Using Native Polly Voices"
+import litellm
+
+# US English female
+response = litellm.speech(
+    model="aws_polly/neural",
+    voice="Joanna",
+    input="Hello from Joanna",
+)
+
+# US English male
+response = litellm.speech(
+    model="aws_polly/neural",
+    voice="Matthew",
+    input="Hello from Matthew",
+)
+
+# British English female
+response = litellm.speech(
+    model="aws_polly/neural",
+    voice="Amy",
+    input="Hello from Amy",
+)
+```
+
+### **LiteLLM PROXY**
+
+```yaml showLineNumbers title="proxy_config.yaml"
+model_list:
+  - model_name: polly-joanna
+    litellm_params:
+      model: aws_polly/neural
+      voice: "Joanna"
+      aws_region_name: "us-east-1"
+  - model_name: polly-matthew
+    litellm_params:
+      model: aws_polly/neural
+      voice: "Matthew"
+      aws_region_name: "us-east-1"
+```
+
+### OpenAI Voice Mappings
+
+LiteLLM also supports OpenAI voice names, which are automatically mapped to Polly voices:
+
+| OpenAI Voice | Maps to Polly Voice |
+|--------------|---------------------|
+| `alloy` | Joanna |
+| `echo` | Matthew |
+| `fable` | Amy |
+| `onyx` | Brian |
+| `nova` | Ivy |
+| `shimmer` | Kendra |
+
+### **LiteLLM SDK**
+
+```python showLineNumbers title="Using OpenAI Voice Names"
+import litellm
+
+# These are equivalent
+response = litellm.speech(
+    model="aws_polly/neural",
+    voice="alloy",  # Maps to Joanna
+    input="Hello world",
+)
+
+response = litellm.speech(
+    model="aws_polly/neural",
+    voice="Joanna",  # Native Polly voice
+    input="Hello world",
+)
+```
+
+## SSML Support
+
+AWS Polly supports SSML (Speech Synthesis Markup Language) for advanced control over speech output. LiteLLM automatically detects SSML input.
+
+### **LiteLLM SDK**
+
+```python showLineNumbers title="SSML Example"
+import litellm
+
+ssml_input = """
+<speak>
+    Hello, <break time="500ms"/> 
+    this is a test with <emphasis level="strong">emphasis</emphasis> 
+    and <prosody rate="slow">slower speech</prosody>.
+</speak>
+"""
+
+response = litellm.speech(
+    model="aws_polly/neural",
+    voice="Joanna",
+    input=ssml_input,
+)
+```
+
+### **LiteLLM PROXY**
+
+```bash showLineNumbers title="cURL Request with SSML"
+curl -X POST http://localhost:4000/v1/audio/speech \
+  -H "Authorization: Bearer sk-1234" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "polly-neural",
+    "voice": "Joanna",
+    "input": "<speak>Hello <break time=\"500ms\"/> world</speak>"
+  }' \
+  --output speech.mp3
+```
+
+## Supported Parameters
+
+```python showLineNumbers title="All Parameters"
+response = litellm.speech(
+    model="aws_polly/neural",
+    voice="Joanna",                    # Required: Voice selection
+    input="text to convert",           # Required: Input text (or SSML)
+    response_format="mp3",             # Optional: mp3, ogg_vorbis, pcm
+    
+    # AWS-specific parameters
+    language_code="en-US",             # Optional: Language code
+    sample_rate="22050",               # Optional: Sample rate in Hz
+)
+```
+
+## Response Formats
+
+| Format | Description |
+|--------|-------------|
+| `mp3` | MP3 audio (default) |
+| `ogg_vorbis` | Ogg Vorbis audio |
+| `pcm` | Raw PCM audio |
+
+### **LiteLLM SDK**
+
+```python showLineNumbers title="Different Response Formats"
+import litellm
+
+# MP3 (default)
+response = litellm.speech(
+    model="aws_polly/neural",
+    voice="Joanna",
+    input="Hello",
+    response_format="mp3",
+)
+
+# Ogg Vorbis
+response = litellm.speech(
+    model="aws_polly/neural",
+    voice="Joanna",
+    input="Hello",
+    response_format="ogg_vorbis",
+)
+```
+
+## AWS Authentication
+
+LiteLLM supports multiple AWS authentication methods.
+
+### **LiteLLM SDK**
+
+```python showLineNumbers title="Authentication Options"
+import litellm
+import os
+
+# Option 1: Environment variables (recommended)
+os.environ["AWS_ACCESS_KEY_ID"] = "your-access-key"
+os.environ["AWS_SECRET_ACCESS_KEY"] = "your-secret-key"
+os.environ["AWS_REGION_NAME"] = "us-east-1"
+
+response = litellm.speech(model="aws_polly/neural", voice="Joanna", input="Hello")
+
+# Option 2: Pass credentials directly
+response = litellm.speech(
+    model="aws_polly/neural",
+    voice="Joanna",
+    input="Hello",
+    aws_access_key_id="your-access-key",
+    aws_secret_access_key="your-secret-key",
+    aws_region_name="us-east-1",
+)
+
+# Option 3: IAM Role (when running on AWS)
+response = litellm.speech(
+    model="aws_polly/neural",
+    voice="Joanna",
+    input="Hello",
+    aws_region_name="us-east-1",
+)
+
+# Option 4: AWS Profile
+response = litellm.speech(
+    model="aws_polly/neural",
+    voice="Joanna",
+    input="Hello",
+    aws_profile_name="my-profile",
+)
+```
+
+### **LiteLLM PROXY**
+
+```yaml showLineNumbers title="proxy_config.yaml"
+model_list:
+  # Using environment variables
+  - model_name: polly-neural
+    litellm_params:
+      model: aws_polly/neural
+      aws_access_key_id: "os.environ/AWS_ACCESS_KEY_ID"
+      aws_secret_access_key: "os.environ/AWS_SECRET_ACCESS_KEY"
+      aws_region_name: "us-east-1"
+  
+  # Using IAM Role (when proxy runs on AWS)
+  - model_name: polly-neural-iam
+    litellm_params:
+      model: aws_polly/neural
+      aws_region_name: "us-east-1"
+  
+  # Using AWS Profile
+  - model_name: polly-neural-profile
+    litellm_params:
+      model: aws_polly/neural
+      aws_profile_name: "my-profile"
+```
+
+## Async Support
+
+```python showLineNumbers title="Async Usage"
+import litellm
+import asyncio
+
+async def main():
+    response = await litellm.aspeech(
+        model="aws_polly/neural",
+        voice="Joanna",
+        input="Hello from async AWS Polly",
+        aws_region_name="us-east-1",
+    )
+    
+    with open("output.mp3", "wb") as f:
+        f.write(response.content)
+
+asyncio.run(main())
+```
@@ -172,6 +172,125 @@ print(f"Results available at: {output_s3_uri}")

 **Note:** The actual embedding results are stored in S3. When the job is completed, download the results from the S3 location specified in `status.metadata['output_file_id']`. The results will be in JSON/JSONL format containing the embedding vectors.

+## Amazon Nova Multimodal Embeddings
+
+Amazon Nova supports multimodal embeddings for text, images, video, and audio. It offers flexible embedding dimensions and purposes optimized for different use cases.
+
+### Supported Features
+
+- **Modalities**: Text, Image, Video, Audio
+- **Dimensions**: 256, 384, 1024, 3072 (default: 3072)
+- **Embedding Purposes**: 
+  - `GENERIC_INDEX` (default)
+  - `GENERIC_RETRIEVAL`
+  - `TEXT_RETRIEVAL`
+  - `IMAGE_RETRIEVAL`
+  - `VIDEO_RETRIEVAL`
+  - `AUDIO_RETRIEVAL`
+  - `CLASSIFICATION`
+  - `CLUSTERING`
+
+### Text Embedding
+
+```python
+from litellm import embedding
+
+response = embedding(
+    model="bedrock/amazon.nova-2-multimodal-embeddings-v1:0",
+    input=["Hello, world!"],
+    aws_region_name="us-east-1",
+    dimensions=1024,  # Optional: 256, 384, 1024, or 3072
+)
+
+print(response.data[0].embedding)
+```
+
+### Image Embedding with Base64
+
+Amazon Nova accepts images in base64 format using the standard data URL format:
+
+```python
+import base64
+from litellm import embedding
+
+# Method 1: Load image from file
+with open("image.jpg", "rb") as image_file:
+    image_data = base64.b64encode(image_file.read()).decode('utf-8')
+    # Create data URL with proper format
+    image_base64 = f"data:image/jpeg;base64,{image_data}"
+
+response = embedding(
+    model="bedrock/amazon.nova-2-multimodal-embeddings-v1:0",
+    input=[image_base64],
+    aws_region_name="us-east-1",
+    dimensions=1024,
+)
+
+print(f"Image embedding: {response.data[0].embedding[:10]}...")  # First 10 dimensions
+```
+
+#### Supported Image Formats
+
+Nova supports the following image formats:
+- JPEG: `data:image/jpeg;base64,...`
+- PNG: `data:image/png;base64,...`
+- GIF: `data:image/gif;base64,...`
+- WebP: `data:image/webp;base64,...`
+
+#### Complete Example with Error Handling
+
+```python
+import base64
+from litellm import embedding
+
+def get_image_embedding(image_path, dimensions=1024):
+    """
+    Get embedding for an image file.
+    
+    Args:
+        image_path: Path to the image file
+        dimensions: Embedding dimension (256, 384, 1024, or 3072)
+    
+    Returns:
+        List of embedding values
+    """
+    try:
+        # Determine image format from file extension
+        if image_path.lower().endswith('.png'):
+            mime_type = "image/png"
+        elif image_path.lower().endswith(('.jpg', '.jpeg')):
+            mime_type = "image/jpeg"
+        elif image_path.lower().endswith('.gif'):
+            mime_type = "image/gif"
+        elif image_path.lower().endswith('.webp'):
+            mime_type = "image/webp"
+        else:
+            raise ValueError(f"Unsupported image format: {image_path}")
+        
+        # Read and encode image
+        with open(image_path, "rb") as image_file:
+            image_data = base64.b64encode(image_file.read()).decode('utf-8')
+            image_base64 = f"data:{mime_type};base64,{image_data}"
+        
+        # Get embedding
+        response = embedding(
+            model="bedrock/amazon.nova-2-multimodal-embeddings-v1:0",
+            input=[image_base64],
+            aws_region_name="us-east-1",
+            dimensions=dimensions,
+        )
+        
+        return response.data[0].embedding
+        
+    except Exception as e:
+        print(f"Error getting image embedding: {e}")
+        raise
+
+# Example usage
+image_embedding = get_image_embedding("photo.jpg", dimensions=1024)
+print(f"Got embedding with {len(image_embedding)} dimensions")
+```
+
 ### Error Handling

 #### Common Errors
@@ -0,0 +1,137 @@
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Xiaomi MiMo
+https://platform.xiaomimimo.com/#/docs
+
+:::tip
+
+**We support ALL Xiaomi MiMo models, just set `model=xiaomi_mimo/<any-model-on-xiaomi-mimo>` as a prefix when sending litellm requests**
+
+:::
+
+## API Key
+```python
+# env variable
+os.environ['XIAOMI_MIMO_API_KEY']
+```
+
+## Sample Usage
+```python
+from litellm import completion
+import os
+
+os.environ['XIAOMI_MIMO_API_KEY'] = ""
+response = completion(
+    model="xiaomi_mimo/mimo-v2-flash",
+    messages=[
+        {
+            "role": "user",
+            "content": "What's the weather like in Boston today in Fahrenheit?",
+        }
+    ],
+    max_tokens=1024,
+    temperature=0.3,
+    top_p=0.95,
+)
+print(response)
+```
+
+## Sample Usage - Streaming
+```python
+from litellm import completion
+import os
+
+os.environ['XIAOMI_MIMO_API_KEY'] = ""
+response = completion(
+    model="xiaomi_mimo/mimo-v2-flash",
+    messages=[
+        {
+            "role": "user",
+            "content": "What's the weather like in Boston today in Fahrenheit?",
+        }
+    ],
+    stream=True,
+    max_tokens=1024,
+    temperature=0.3,
+    top_p=0.95,
+)
+
+for chunk in response:
+    print(chunk)
+```
+
+
+## Usage with LiteLLM Proxy Server
+
+Here's how to call a Xiaomi MiMo model with the LiteLLM Proxy Server
+
+1. Modify the config.yaml 
+
+  ```yaml
+  model_list:
+    - model_name: my-model
+      litellm_params:
+        model: xiaomi_mimo/<your-model-name>  # add xiaomi_mimo/ prefix to route as Xiaomi MiMo provider
+        api_key: api-key                      # api key to send your model
+  ```
+
+
+2. Start the proxy 
+
+  ```bash
+  $ litellm --config /path/to/config.yaml
+  ```
+
+3. Send Request to LiteLLM Proxy Server
+
+  <Tabs>
+
+  <TabItem value="openai" label="OpenAI Python v1.0.0+">
+
+  ```python
+  import openai
+  client = openai.OpenAI(
+      api_key="sk-1234",             # pass litellm proxy key, if you're using virtual keys
+      base_url="http://0.0.0.0:4000" # litellm-proxy-base url
+  )
+
+  response = client.chat.completions.create(
+      model="my-model",
+      messages = [
+          {
+              "role": "user",
+              "content": "what llm are you"
+          }
+      ],
+  )
+
+  print(response)
+  ```
+  </TabItem>
+
+  <TabItem value="curl" label="curl">
+
+  ```shell
+  curl --location 'http://0.0.0.0:4000/chat/completions' \
+      --header 'Authorization: Bearer sk-1234' \
+      --header 'Content-Type: application/json' \
+      --data '{
+      "model": "my-model",
+      "messages": [
+          {
+          "role": "user",
+          "content": "what llm are you"
+          }
+      ],
+  }'
+  ```
+  </TabItem>
+
+  </Tabs>
+
+## Supported Models
+
+| Model Name | Usage |
+|------------|-------|
+| mimo-v2-flash | `completion(model="xiaomi_mimo/mimo-v2-flash", messages)` |
@@ -51,7 +51,7 @@ LiteLLM has two types of roles:
 | Role Name | Permissions |
 |-----------|-------------|
 | `org_admin` | Admin over a specific organization. Can create teams and users within their organization ✨ **Premium Feature** |
-| `team_admin` | Admin over a specific team. Can manage team members, update team settings, and create keys for their team. ✨ **Premium Feature** |
+| `team_admin` | Admin over a specific team. Can manage team members, update team member permissions, and create keys for their team. ✨ **Premium Feature** |

 ## What Can Each Role Do?

@@ -215,16 +215,16 @@ general_settings:
  alerting: ["slack"]
  alerting_threshold: 0.0001 # (Seconds) set an artificially low threshold for testing alerting
  alert_to_webhook_url: {
-    "llm_exceptions": "example-slack-webhook-url",
-    "llm_too_slow": "example-slack-webhook-url",
-    "llm_requests_hanging": "example-slack-webhook-url",
-    "budget_alerts": "example-slack-webhook-url",
-    "db_exceptions": "example-slack-webhook-url",
-    "daily_reports": "example-slack-webhook-url",
-    "spend_reports": "example-slack-webhook-url",
-    "cooldown_deployment": "example-slack-webhook-url",
-    "new_model_added": "example-slack-webhook-url",
-    "outage_alerts": "example-slack-webhook-url",
+    "llm_exceptions": "https://hooks.slack.com/services/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",
+    "llm_too_slow": "https://hooks.slack.com/services/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",
+    "llm_requests_hanging": "https://hooks.slack.com/services/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",
+    "budget_alerts": "https://hooks.slack.com/services/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",
+    "db_exceptions": "https://hooks.slack.com/services/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",
+    "daily_reports": "https://hooks.slack.com/services/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",
+    "spend_reports": "https://hooks.slack.com/services/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",
+    "cooldown_deployment": "https://hooks.slack.com/services/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",
+    "new_model_added": "https://hooks.slack.com/services/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",
+    "outage_alerts": "https://hooks.slack.com/services/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",
  }

 litellm_settings:
@@ -399,7 +399,7 @@ curl -X GET --location 'http://0.0.0.0:4000/health/services?service=webhook' \
 {
  "spend": 1, # the spend for the 'event_group'
  "max_budget": 0, # the 'max_budget' set for the 'event_group'
-  "token": "example-api-key-123",
+  "token": "88dc28d0f030c55ed4ab77ed8faf098196cb1c05df778539800c9f1243fe6b4b",
  "user_id": "default_user_id",
  "team_id": null,
  "user_email": null,
@@ -17,6 +17,7 @@ import Image from '@theme/IdealImage';
 | `async_pre_call_hook` | Modify incoming request before it's sent to model | Before the LLM API call is made |
 | `async_moderation_hook` | Run checks on input in parallel to LLM API call | In parallel with the LLM API call |
 | `async_post_call_success_hook` | Modify outgoing response (non-streaming) | After successful LLM API call, for non-streaming responses |
+| `async_post_call_failure_hook` | Transform error responses sent to clients | After failed LLM API call |
 | `async_post_call_streaming_hook` | Modify outgoing response (streaming) | After successful LLM API call, for streaming responses |

 See a complete example with our [parallel request rate limiter](https://github.com/BerriAI/litellm/blob/main/litellm/proxy/hooks/parallel_request_limiter.py)
@@ -60,7 +61,21 @@ class MyCustomHandler(CustomLogger): # https://docs.litellm.ai/docs/observabilit
        original_exception: Exception, 
        user_api_key_dict: UserAPIKeyAuth,
        traceback_str: Optional[str] = None,
-    ):
+    ) -> Optional[HTTPException]:
+        """
+        Transform error responses sent to clients.
+        
+        Return an HTTPException to replace the original error with a user-friendly message.
+        Return None to use the original exception.
+        
+        Example:
+            if isinstance(original_exception, litellm.ContextWindowExceededError):
+                return HTTPException(
+                    status_code=400,
+                    detail="Your prompt is too long. Please reduce the length and try again."
+                )
+            return None  # Use original exception
+        """
        pass

    async def async_post_call_success_hook(
@@ -339,3 +354,38 @@ curl --location 'http://0.0.0.0:4000/chat/completions' \
    "usage": {}
 }
 ```
+
+## Advanced - Transform Error Responses
+
+Transform technical API errors into user-friendly messages using `async_post_call_failure_hook`. Return an `HTTPException` to replace the original error, or `None` to use the original exception.
+
+```python
+from litellm.integrations.custom_logger import CustomLogger
+from fastapi import HTTPException
+from typing import Optional
+import litellm
+
+class MyErrorTransformer(CustomLogger):
+    async def async_post_call_failure_hook(
+        self,
+        request_data: dict,
+        original_exception: Exception,
+        user_api_key_dict: UserAPIKeyAuth,
+        traceback_str: Optional[str] = None,
+    ) -> Optional[HTTPException]:
+        if isinstance(original_exception, litellm.ContextWindowExceededError):
+            return HTTPException(
+                status_code=400,
+                detail="Your prompt is too long. Please reduce the length and try again."
+            )
+        if isinstance(original_exception, litellm.RateLimitError):
+            return HTTPException(
+                status_code=429,
+                detail="Rate limit exceeded. Please try again in a moment."
+            )
+        return None  # Use original exception
+
+proxy_handler_instance = MyErrorTransformer()
+```
+
+**Result:** Clients receive `"Your prompt is too long..."` instead of `"ContextWindowExceededError: Prompt exceeds context window"`.
@@ -554,6 +554,8 @@ router_settings:
 | EMAIL_SIGNATURE | Custom HTML footer/signature for all emails. Can include HTML tags for formatting and links.
 | EMAIL_SUBJECT_INVITATION | Custom subject template for invitation emails. 
 | EMAIL_SUBJECT_KEY_CREATED | Custom subject template for key creation emails. 
+| EMAIL_BUDGET_ALERT_MAX_SPEND_ALERT_PERCENTAGE | Percentage of max budget that triggers alerts (as decimal: 0.8 = 80%). Default is 0.8
+| EMAIL_BUDGET_ALERT_TTL | Time-to-live for budget alert deduplication in seconds. Default is 86400 (24 hours)
 | ENKRYPTAI_API_BASE | Base URL for EnkryptAI Guardrails API. **Default is https://api.enkryptai.com**
 | ENKRYPTAI_API_KEY | API key for EnkryptAI Guardrails service
 | EXPERIMENTAL_MULTI_INSTANCE_RATE_LIMITING | Flag to enable new multi-instance rate limiting. **Default is False**
@@ -722,7 +722,7 @@ curl -X GET 'http://localhost:4000/global/spend/report?start_date=2024-04-01&end
 ```shell
 [
  {
-    "api_key": "example-api-key-123",
+    "api_key": "88dc28d0f030c55ed4ab77ed8faf098196cb1c05df778539800c9f1243fe6b4b",
    "total_cost": 0.3201286305151999,
    "total_input_tokens": 36.0,
    "total_output_tokens": 1593.0,
@@ -766,7 +766,7 @@ curl -X GET 'http://localhost:4000/global/spend/report?start_date=2024-04-01&end
 ```shell
 [
  {
-    "api_key": "example-api-key-123",
+    "api_key": "88dc28d0f030c55ed4ab77ed8faf098196cb1c05df778539800c9f1243fe6b4b",
    "total_cost": 0.00013132,
    "total_input_tokens": 105.0,
    "total_output_tokens": 872.0,
@@ -1151,7 +1151,7 @@ curl -X GET "http://0.0.0.0:4000/spend/logs?request_id=<your-call-id" \ # e.g.:
        "request_id": "chatcmpl-9ZKMURhVYSi9D6r6PJ9vLcayIK0Vm",
        "call_type": "acompletion",
        "metadata": {
-            "user_api_key": "example-api-key-123",
+            "user_api_key": "88dc28d0f030c55ed4ab77ed8faf098196cb1c05df778539800c9f1243fe6b4b",
            "user_api_key_alias": null,
            "spend_logs_metadata": { # 👈 LOGGED CUSTOM METADATA
                "hello": "world"
@@ -103,7 +103,7 @@ Expected Response
 {
  "spend": 0.0011120000000000001, # 👈 SPEND
  "max_budget": null,
-  "token": "example-api-key-123",
+  "token": "88dc28d0f030c55ed4ab77ed8faf098196cb1c05df778539800c9f1243fe6b4b",
  "customer_id": "krrish12",  # 👈 CUSTOMER ID
  "user_id": null,
  "team_id": null,
@@ -94,6 +94,35 @@ On the LiteLLM Proxy UI, go to users > create a new user.

 After creating a new user, they will receive an email invite a the email you specified when creating the user. 

+### 3. Configure Budget Alerts (Optional)
+
+Enable budget alert emails by adding "email" to the `alerts` list in your proxy configuration:
+
+```yaml showLineNumbers title="proxy_config.yaml"
+general_settings:
+  alerts: ["email"]
+```
+
+#### Budget Alert Types
+
+**Soft Budget Alerts**: Automatically triggered when a key exceeds its soft budget limit. These alerts help you monitor spending before reaching critical thresholds.
+
+**Max Budget Alerts**: Automatically triggered when a key reaches a specified percentage of its maximum budget (default: 80%). These alerts warn you when you're approaching budget exhaustion.
+
+Both alert types send a maximum of one email per 24-hour period to prevent spam.
+
+#### Configuration Options
+
+Customize budget alert behavior using these environment variables:
+
+```yaml showLineNumbers title=".env"
+# Percentage of max budget that triggers alerts (as decimal: 0.8 = 80%)
+EMAIL_BUDGET_ALERT_MAX_SPEND_ALERT_PERCENTAGE=0.8
+
+# Time-to-live for alert deduplication in seconds (default: 24 hours)
+EMAIL_BUDGET_ALERT_TTL=86400
+```
+
 ## Email Templates 


@@ -257,7 +257,7 @@ Contact me at [EMAIL_REDACTED]
 | `amex` | American Express cards | `3782-822463-10005` |
 | `aws_access_key` | AWS access keys | `AKIAIOSFODNN7EXAMPLE` |
 | `aws_secret_key` | AWS secret keys | `wJalrXUtnFEMI/K7MDENG/bPxRfi...` |
-| `github_token` | GitHub tokens | `example-github-token-123` |
+| `github_token` | GitHub tokens | `ghp_16C7e42F292c6912E7710c838347Ae178B4a` |

 ### Using Prebuilt Patterns

@@ -790,7 +790,7 @@ curl -X POST "http://localhost:4000/v1/chat/completions" \
    "messages": [
      {
        "role": "user", 
-        "content": "Generate python code that accesses my Github repo using this PAT: example-github-token-123"
+        "content": "Generate python code that accesses my Github repo using this PAT: ghp_A1b2C3d4E5f6G7h8I9j0K1l2M3n4O5p6Q7r8"
      }
    ],
    "max_tokens": 50
@@ -815,7 +815,7 @@ curl -X POST "http://localhost:4000/v1/chat/completions" \
            "type": "github_token",
            "start_idx": 66,
            "end_idx": 106,
-            "evidence": "example-github-token-123",
+            "evidence": "ghp_A1b2C3d4E5f6G7h8I9j0K1l2M3n4O5p6Q7r8",
          }
        ]
      }
@@ -89,7 +89,7 @@ curl -X POST 'http://0.0.0.0:4000/team/update' \
   "id": "bd136c28-edd0-4cb6-b963-f35464cf6f5a",
   "updated_at": "2024-06-08 23:41:14.793",
   "changed_by": "krrish@berri.ai", # 👈 CHANGED BY
-   "changed_by_api_key": "example-api-key-123",
+   "changed_by_api_key": "88dc28d0f030c55ed4ab77ed8faf098196cb1c05df778539800c9f1243fe6b4b",
   "action": "updated",
   "table_name": "LiteLLM_TeamTable",
   "object_id": "8bf18b11-7f52-4717-8e1f-7c65f9d01e52",
@@ -33,7 +33,7 @@ litellm_settings:

 Set slack webhook url in your env
 ```shell
-export SLACK_WEBHOOK_URL="example-slack-webhook-url"
+export SLACK_WEBHOOK_URL="https://hooks.slack.com/services/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"
 ```

 Turn off FASTAPI's default info logs
@@ -400,7 +400,7 @@ from anthropic import Anthropic

 client = Anthropic(
    base_url="http://localhost:4000", # proxy endpoint
-    api_key="sk-test-proxy-key-123", # litellm proxy virtual key (example)
+    api_key="sk-s4xN1IiLTCytwtZFJaYQrA", # litellm proxy virtual key
 )

 message = client.messages.create(
@@ -285,7 +285,7 @@ from anthropic import Anthropic

 client = Anthropic(
    base_url="http://localhost:4000", # proxy endpoint
-    api_key="sk-test-proxy-key-123", # litellm proxy virtual key (example)
+    api_key="sk-s4xN1IiLTCytwtZFJaYQrA", # litellm proxy virtual key
 )

 message = client.messages.create(
@@ -14,7 +14,7 @@ import TabItem from '@theme/TabItem';
 | Fallbacks | ✅ | Works between supported models |
 | Loadbalancing | ✅ | Works between supported models |
 | Guardrails | ✅ | Applies to input text (non-streaming only) |
-| Supported Providers | OpenAI, Azure OpenAI, Vertex AI | |
+| Supported Providers | OpenAI, Azure OpenAI, Vertex AI, AWS Polly, ElevenLabs | |

 ## **LiteLLM Python SDK Usage**
 ### Quick Start 
@@ -101,6 +101,7 @@ litellm --config /path/to/config.yaml
 | OpenAI      |   [Usage](#quick-start)                 |
 | Azure OpenAI|   [Usage](../docs/providers/azure#azure-text-to-speech-tts)                 |
 | Azure AI Speech Service (AVA)|   [Usage](../docs/providers/azure_ai_speech)                 |
+| AWS Polly   |   [Usage](#aws-polly-text-to-speech)                 |
 | Vertex AI   |   [Usage](../docs/providers/vertex#text-to-speech-apis)                 |
 | Gemini      |   [Usage](#gemini-text-to-speech)                 |
 | ElevenLabs  |   [Usage](../docs/providers/elevenlabs#text-to-speech-tts)                 |
@@ -246,6 +247,12 @@ curl http://0.0.0.0:4000/v1/audio/speech \
  --output vertex_speech.mp3
 ```

+### AWS Polly Text-to-Speech
+
+AWS Polly provides neural and standard text-to-speech engines with support for multiple voices and languages.
+
+See the [AWS Polly provider documentation](../docs/providers/aws_polly) for detailed usage examples.
+
 ## ✨ Enterprise LiteLLM Proxy - Set Max Request File Size 

 Use this when you want to limit the file size for requests sent to `audio/transcriptions`
@@ -8,7 +8,7 @@ const darkCodeTheme = require('prism-react-renderer/themes/dracula');

 const inkeepConfig = {
  baseSettings: {
-    apiKey: "test-inkeep-api-key-123",
+    apiKey: "0cb9c9916ec71bfe0e53c9d7f83ff046daee3fa9ef318f6a",
    organizationDisplayName: 'liteLLM',
    primaryBrandColor: '#4965f5',
    theme: {
@@ -180,6 +180,7 @@
      "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-5.44.0.tgz",
      "integrity": "sha512-/FRKUM1G4xn3vV8+9xH1WJ9XknU8rkBGlefruq9jDhYUAvYozKimhrmC2pRqw/RyHhPivmgZCRuC8jHP8piz4Q==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "@algolia/client-common": "5.44.0",
        "@algolia/requester-browser-xhr": "5.44.0",
@@ -327,6 +328,7 @@
      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.5.tgz",
      "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "@babel/code-frame": "^7.27.1",
        "@babel/generator": "^7.28.5",
@@ -2161,6 +2163,7 @@
        }
      ],
      "license": "MIT",
+      "peer": true,
      "engines": {
        "node": ">=18"
      },
@@ -2183,6 +2186,7 @@
        }
      ],
      "license": "MIT",
+      "peer": true,
      "engines": {
        "node": ">=18"
      }
@@ -2292,6 +2296,7 @@
      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz",
      "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "cssesc": "^3.0.0",
        "util-deprecate": "^1.0.2"
@@ -2713,6 +2718,7 @@
      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz",
      "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "cssesc": "^3.0.0",
        "util-deprecate": "^1.0.2"
@@ -3589,6 +3595,7 @@
      "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-docs/-/plugin-content-docs-3.8.1.tgz",
      "integrity": "sha512-oByRkSZzeGNQByCMaX+kif5Nl2vmtj2IHQI2fWjCfCootsdKZDPFLonhIp5s3IGJO7PLUfe0POyw0Xh/RrGXJA==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "@docusaurus/core": "3.8.1",
        "@docusaurus/logger": "3.8.1",
@@ -4627,6 +4634,7 @@
      "resolved": "https://registry.npmjs.org/@mdx-js/react/-/react-3.1.1.tgz",
      "integrity": "sha512-f++rKLQgUVYDAtECQ6fn/is15GkEH9+nZPM3MS0RcxVqoTfawHvDlSCH7JbMhAM6uJ32v3eXLvLmLvjGu7PTQw==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "@types/mdx": "^2.0.0"
      },
@@ -7183,6 +7191,7 @@
      "resolved": "https://registry.npmjs.org/@svgr/core/-/core-8.1.0.tgz",
      "integrity": "sha512-8QqtOQT5ACVlmsvKOJNEaWmRPmcojMOzCz4Hs2BGG/toAp/K38LcsMRyLp349glq5AzJbCEeimEoxaX6v/fLrA==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "@babel/core": "^7.21.3",
        "@svgr/babel-preset": "8.1.0",
@@ -7840,6 +7849,7 @@
      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.6.tgz",
      "integrity": "sha512-p/jUvulfgU7oKtj6Xpk8cA2Y1xKTtICGpJYeJXz2YVO2UcvjQgeRMLDGfDeqeRW2Ta+0QNFwcc8X3GH8SxZz6w==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "csstype": "^3.2.2"
      }
@@ -8264,6 +8274,7 @@
      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
      "license": "MIT",
+      "peer": true,
      "bin": {
        "acorn": "bin/acorn"
      },
@@ -8343,6 +8354,7 @@
      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
      "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "fast-deep-equal": "^3.1.3",
        "fast-uri": "^3.0.1",
@@ -8388,6 +8400,7 @@
      "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-5.44.0.tgz",
      "integrity": "sha512-f8IpsbdQjzTjr/4mJ/jv5UplrtyMnnciGax6/B0OnLCs2/GJTK13O4Y7Ff1AvJVAaztanH+m5nzPoUq6EAy+aA==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "@algolia/abtesting": "1.10.0",
        "@algolia/client-abtesting": "5.44.0",
@@ -8421,9 +8434,9 @@
      }
    },
    "node_modules/altcha-lib": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/altcha-lib/-/altcha-lib-1.3.0.tgz",
-      "integrity": "sha512-PpFg/JPuR+Jiud7Vs54XSDqDxvylcp+0oDa/i1ARxBA/iKDqLeNlO8PorQbfuDTMVLYRypAa/2VDK3nbBTAu5A==",
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/altcha-lib/-/altcha-lib-1.4.1.tgz",
+      "integrity": "sha512-MAXP9tkQOA2SE9Gwoe3LAcZbcDpp3XzYc5GDVej/y3eMNaFG/eVnRY1/7SGFW0RPsViEjPf+hi5eANjuZrH1xA==",
      "license": "MIT"
    },
    "node_modules/ansi-align": {
@@ -9029,6 +9042,7 @@
        }
      ],
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "baseline-browser-mapping": "^2.8.25",
        "caniuse-lite": "^1.0.30001754",
@@ -9364,6 +9378,7 @@
      "resolved": "https://registry.npmjs.org/chevrotain/-/chevrotain-11.0.3.tgz",
      "integrity": "sha512-ci2iJH6LeIkvP9eJW6gpueU8cnZhv85ELY8w8WiFtNjMHA5ad6pQLaJo9mEly/9qUyCpvqX8/POVUTf18/HFdw==",
      "license": "Apache-2.0",
+      "peer": true,
      "dependencies": {
        "@chevrotain/cst-dts-gen": "11.0.3",
        "@chevrotain/gast": "11.0.3",
@@ -10127,6 +10142,7 @@
      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz",
      "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "cssesc": "^3.0.0",
        "util-deprecate": "^1.0.2"
@@ -10446,6 +10462,7 @@
      "resolved": "https://registry.npmjs.org/cytoscape/-/cytoscape-3.33.1.tgz",
      "integrity": "sha512-iJc4TwyANnOGR1OmWhsS9ayRS3s+XQ185FmuHObThD+5AeJCakAAbWv8KimMTt08xCCLNgneQwFp+JRJOr9qGQ==",
      "license": "MIT",
+      "peer": true,
      "engines": {
        "node": ">=0.10"
      }
@@ -10855,6 +10872,7 @@
      "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz",
      "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==",
      "license": "ISC",
+      "peer": true,
      "engines": {
        "node": ">=12"
      }
@@ -12111,6 +12129,7 @@
      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "fast-deep-equal": "^3.1.1",
        "fast-json-stable-stringify": "^2.0.0",
@@ -16990,6 +17009,7 @@
      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "fast-deep-equal": "^3.1.1",
        "fast-json-stable-stringify": "^2.0.0",
@@ -17610,6 +17630,7 @@
        }
      ],
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "nanoid": "^3.3.11",
        "picocolors": "^1.1.1",
@@ -18513,6 +18534,7 @@
      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz",
      "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "cssesc": "^3.0.0",
        "util-deprecate": "^1.0.2"
@@ -19404,6 +19426,7 @@
      "resolved": "https://registry.npmjs.org/react/-/react-19.2.0.tgz",
      "integrity": "sha512-tmbWg6W31tQLeB5cdIBOicJDJRR2KzXsV7uSK9iNfLWQ5bIZfxuPEHp7M8wiHyHnn0DD1i7w3Zmin0FtkrwoCQ==",
      "license": "MIT",
+      "peer": true,
      "engines": {
        "node": ">=0.10.0"
      }
@@ -19413,6 +19436,7 @@
      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.0.tgz",
      "integrity": "sha512-UlbRu4cAiGaIewkPyiRGJk0imDN2T3JjieT6spoL2UeSf5od4n5LB/mQ4ejmxhCFT1tYe8IvaFulzynWovsEFQ==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "scheduler": "^0.27.0"
      },
@@ -19496,6 +19520,7 @@
      "resolved": "https://registry.npmjs.org/@docusaurus/react-loadable/-/react-loadable-6.0.0.tgz",
      "integrity": "sha512-YMMxTUQV/QFSnbgrP3tjDzLHRg7vsbMn8e9HAa8o/1iXoiomo48b7sk/kkmWEuWNDPJVlKSJRB6Y2fHqdJk+SQ==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "@types/react": "*"
      },
@@ -19597,6 +19622,7 @@
      "resolved": "https://registry.npmjs.org/react-router/-/react-router-5.3.4.tgz",
      "integrity": "sha512-Ys9K+ppnJah3QuaRiLxk+jDWOR1MekYQrlytiXxC1RyfbdsZkS5pvKAzCCr031xHixZwpnsYNT5xysdFHQaYsA==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "@babel/runtime": "^7.12.13",
        "history": "^4.9.0",
@@ -21615,7 +21641,8 @@
      "version": "2.8.1",
      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
-      "license": "0BSD"
+      "license": "0BSD",
+      "peer": true
    },
    "node_modules/tunnel-agent": {
      "version": "0.6.0",
@@ -22002,6 +22029,7 @@
      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "fast-deep-equal": "^3.1.1",
        "fast-json-stable-stringify": "^2.0.0",
@@ -22353,6 +22381,7 @@
      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.103.0.tgz",
      "integrity": "sha512-HU1JOuV1OavsZ+mfigY0j8d1TgQgbZ6M+J75zDkpEAwYeXjWSqrGJtgnPblJjd/mAyTNQ7ygw0MiKOn6etz8yw==",
      "license": "MIT",
+      "peer": true,
      "dependencies": {
        "@types/eslint-scope": "^3.7.7",
        "@types/estree": "^1.0.8",
@@ -0,0 +1,385 @@
+---
+title: "[Preview] v1.80.11 - Google Interactions API"
+slug: "v1-80-11"
+date: 2025-12-20T10:00:00
+authors:
+  - name: Krrish Dholakia
+    title: CEO, LiteLLM
+    url: https://www.linkedin.com/in/krish-d/
+    image_url: https://pbs.twimg.com/profile_images/1298587542745358340/DZv3Oj-h_400x400.jpg
+  - name: Ishaan Jaff
+    title: CTO, LiteLLM
+    url: https://www.linkedin.com/in/reffajnaahsi/
+    image_url: https://pbs.twimg.com/profile_images/1613813310264340481/lz54oEiB_400x400.jpg
+hide_table_of_contents: false
+---
+
+import Image from '@theme/IdealImage';
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+## Deploy this version
+
+<Tabs>
+<TabItem value="docker" label="Docker">
+
+``` showLineNumbers title="docker run litellm"
+docker run \
+-e STORE_MODEL_IN_DB=True \
+-p 4000:4000 \
+docker.litellm.ai/berriai/litellm:v1.80.11.rc.1
+```
+
+</TabItem>
+
+<TabItem value="pip" label="Pip">
+
+``` showLineNumbers title="pip install litellm"
+pip install litellm==1.80.11
+```
+
+</TabItem>
+</Tabs>
+
+---
+
+## Key Highlights
+
+- **Gemini 3 Flash Preview** - [Day 0 support for Google's Gemini 3 Flash Preview with reasoning capabilities](../../docs/providers/gemini)
+- **Stability AI Image Generation** - [New provider for Stability AI image generation and editing](../../docs/providers/stability)
+- **LiteLLM Content Filter** - [Built-in guardrails for harmful content, bias, and PII detection with image support](../../docs/proxy/guardrails/litellm_content_filter)
+- **New Provider: Venice.ai** - Support for Venice.ai API via providers.json
+- **Unified Skills API** - [Skills API works across Anthropic, Vertex, Azure, and Bedrock](../../docs/skills)
+- **Azure Sentinel Logging** - [New logging integration for Azure Sentinel](../../docs/observability/azure_sentinel)
+- **Guardrails Load Balancing** - [Load balance between multiple guardrail providers](../../docs/proxy/guardrails)
+- **Email Budget Alerts** - [Send email notifications when budgets are reached](../../docs/proxy/email)
+- **Cloudzero Integration on UI** - Setup your Cloudzero Integration Directly on the UI
+
+---
+
+### Cloudzero Integration on UI
+
+<Image
+img={require('../../img/ui_cloudzero.png')}
+style={{width: '100%', display: 'block', margin: '2rem auto'}}
+/>
+
+Users can now configure their Cloudzero Integration directly on the UI.
+
+---
+### Performance: 50% Reduction in Memory Usage and Import Latency for the LiteLLM SDK
+
+We've completely restructured `litellm.__init__.py` to defer heavy imports until they're actually needed, implementing lazy loading for **109 components**.
+
+This refactoring includes **41 provider config classes**, **40 utility functions**, cache implementations (Redis, DualCache, InMemoryCache), HTTP handlers, logging, types, and other heavy dependencies. Heavy libraries like tiktoken and boto3 are now loaded on-demand rather than eagerly at import time.
+
+This makes LiteLLM especially beneficial for serverless functions, Lambda deployments, and containerized environments where cold start times and memory footprint matter.
+
+---
+
+## New Providers and Endpoints
+
+### New Providers (5 new providers)
+
+| Provider | Supported LiteLLM Endpoints | Description |
+| -------- | ------------------- | ----------- |
+| [Stability AI](../../docs/providers/stability) | `/images/generations`, `/images/edits` | Stable Diffusion 3, SD3.5, image editing and generation |
+| Venice.ai | `/chat/completions`, `/messages`, `/responses` | Venice.ai API integration via providers.json |
+| [Pydantic AI Agents](../../docs/providers/pydantic_ai_agent) | `/a2a` | Pydantic AI agents for A2A protocol workflows |
+| [VertexAI Agent Engine](../../docs/providers/vertex_ai_agent_engine) | `/a2a` | Google Vertex AI Agent Engine for agentic workflows |
+| [LinkUp Search](../../docs/search/linkup) | `/search` | LinkUp web search API integration |
+
+### New LLM API Endpoints (2 new endpoints)
+
+| Endpoint | Method | Description | Documentation |
+| -------- | ------ | ----------- | ------------- |
+| `/interactions` | POST | Google Interactions API for conversational AI | [Docs](../../docs/interactions) |
+| `/search` | POST | RAG Search API with rerankers | [Docs](../../docs/search/index) |
+
+---
+
+## New Models / Updated Models
+
+#### New Model Support (55+ new models)
+
+| Provider | Model | Context Window | Input ($/1M tokens) | Output ($/1M tokens) | Features |
+| -------- | ----- | -------------- | ------------------- | -------------------- | -------- |
+| Gemini | `gemini/gemini-3-flash-preview` | 1M | $0.50 | $3.00 | Reasoning, vision, audio, video, PDF |
+| Vertex AI | `vertex_ai/gemini-3-flash-preview` | 1M | $0.50 | $3.00 | Reasoning, vision, audio, video, PDF |
+| Azure AI | `azure_ai/deepseek-v3.2` | 164K | $0.58 | $1.68 | Reasoning, function calling, caching |
+| Azure AI | `azure_ai/cohere-rerank-v4.0-pro` | 32K | $0.0025/query | - | Rerank |
+| Azure AI | `azure_ai/cohere-rerank-v4.0-fast` | 32K | $0.002/query | - | Rerank |
+| OpenRouter | `openrouter/openai/gpt-5.2` | 400K | $1.75 | $14.00 | Reasoning, vision, caching |
+| OpenRouter | `openrouter/openai/gpt-5.2-pro` | 400K | $21.00 | $168.00 | Reasoning, vision |
+| OpenRouter | `openrouter/mistralai/devstral-2512` | 262K | $0.15 | $0.60 | Function calling |
+| OpenRouter | `openrouter/mistralai/ministral-3b-2512` | 131K | $0.10 | $0.10 | Function calling, vision |
+| OpenRouter | `openrouter/mistralai/ministral-8b-2512` | 262K | $0.15 | $0.15 | Function calling, vision |
+| OpenRouter | `openrouter/mistralai/ministral-14b-2512` | 262K | $0.20 | $0.20 | Function calling, vision |
+| OpenRouter | `openrouter/mistralai/mistral-large-2512` | 262K | $0.50 | $1.50 | Function calling, vision |
+| OpenAI | `gpt-4o-transcribe-diarize` | 16K | $6.00/audio | - | Audio transcription with diarization |
+| OpenAI | `gpt-image-1.5-2025-12-16` | - | Various | Various | Image generation |
+| Stability | `stability/sd3-large` | - | - | $0.065/image | Image generation |
+| Stability | `stability/sd3.5-large` | - | - | $0.065/image | Image generation |
+| Stability | `stability/stable-image-ultra` | - | - | $0.08/image | Image generation |
+| Stability | `stability/inpaint` | - | - | $0.005/image | Image editing |
+| Stability | `stability/outpaint` | - | - | $0.004/image | Image editing |
+| Bedrock | `stability.stable-conservative-upscale-v1:0` | - | - | $0.40/image | Image upscaling |
+| Bedrock | `stability.stable-creative-upscale-v1:0` | - | - | $0.60/image | Image upscaling |
+| Vertex AI | `vertex_ai/deepseek-ai/deepseek-ocr-maas` | - | $0.30 | $1.20 | OCR |
+| LinkUp | `linkup/search` | - | $5.87/1K queries | - | Web search |
+| LinkUp | `linkup/search-deep` | - | $58.67/1K queries | - | Deep web search |
+| GitHub Copilot | 20+ models | Various | - | - | Chat completions |
+
+#### Features
+
+- **[Gemini](../../docs/providers/gemini)**
+    - Add Gemini 3 Flash Preview day 0 support with reasoning - [PR #18135](https://github.com/BerriAI/litellm/pull/18135)
+    - Support extra_headers in batch embeddings - [PR #18004](https://github.com/BerriAI/litellm/pull/18004)
+    - Propagate token usage when generating images - [PR #17987](https://github.com/BerriAI/litellm/pull/17987)
+    - Use JSON instead of form-data for image edit requests - [PR #18012](https://github.com/BerriAI/litellm/pull/18012)
+    - Fix web search requests count - [PR #17921](https://github.com/BerriAI/litellm/pull/17921)
+- **[Anthropic](../../docs/providers/anthropic)**
+    - Use dynamic max_tokens based on model - [PR #17900](https://github.com/BerriAI/litellm/pull/17900)
+    - Fix claude-3-7-sonnet max_tokens to 64K default - [PR #17979](https://github.com/BerriAI/litellm/pull/17979)
+    - Add OpenAI-compatible API with modify_params=True - [PR #17106](https://github.com/BerriAI/litellm/pull/17106)
+- **[Vertex AI](../../docs/providers/vertex)**
+    - Add Gemini 3 Flash Preview support - [PR #18164](https://github.com/BerriAI/litellm/pull/18164)
+    - Add reasoning support for gemini-3-flash-preview - [PR #18175](https://github.com/BerriAI/litellm/pull/18175)
+    - Fix image edit credential source - [PR #18121](https://github.com/BerriAI/litellm/pull/18121)
+    - Pass credentials to PredictionServiceClient for custom endpoints - [PR #17757](https://github.com/BerriAI/litellm/pull/17757)
+    - Fix multimodal embeddings for text + base64 image combinations - [PR #18172](https://github.com/BerriAI/litellm/pull/18172)
+    - Add OCR support for DeepSeek model - [PR #17971](https://github.com/BerriAI/litellm/pull/17971)
+- **[Azure AI](../../docs/providers/azure_ai)**
+    - Add Azure Cohere 4 reranking models - [PR #17961](https://github.com/BerriAI/litellm/pull/17961)
+    - Add Azure DeepSeek V3.2 versions - [PR #18019](https://github.com/BerriAI/litellm/pull/18019)
+    - Return AzureAnthropicConfig for Claude models in get_provider_chat_config - [PR #18086](https://github.com/BerriAI/litellm/pull/18086)
+- **[Fireworks AI](../../docs/providers/fireworks_ai)**
+    - Add reasoning param support for Fireworks AI models - [PR #17967](https://github.com/BerriAI/litellm/pull/17967)
+- **[Bedrock](../../docs/providers/bedrock)**
+    - Add Qwen 2 and Qwen 3 to get_bedrock_model_id - [PR #18100](https://github.com/BerriAI/litellm/pull/18100)
+    - Remove ttl field when routing to bedrock - [PR #18049](https://github.com/BerriAI/litellm/pull/18049)
+    - Add Bedrock Stability image edit models - [PR #18254](https://github.com/BerriAI/litellm/pull/18254)
+- **[Perplexity](../../docs/providers/perplexity)**
+    - Use API-provided cost instead of manual calculation - [PR #17887](https://github.com/BerriAI/litellm/pull/17887)
+- **[OpenAI](../../docs/providers/openai)**
+    - Add diarize model for audio transcription - [PR #18117](https://github.com/BerriAI/litellm/pull/18117)
+    - Add gpt-image-1.5-2025-12-16 in model cost map - [PR #18107](https://github.com/BerriAI/litellm/pull/18107)
+    - Fix cost calculation of gpt-image-1 model - [PR #17966](https://github.com/BerriAI/litellm/pull/17966)
+- **[GitHub Copilot](../../docs/providers/github_copilot)**
+    - Add github_copilot model info - [PR #17858](https://github.com/BerriAI/litellm/pull/17858)
+- **[Custom LLM](../../docs/providers/custom_llm_server)**
+    - Add image_edit and aimage_edit support - [PR #17999](https://github.com/BerriAI/litellm/pull/17999)
+
+### Bug Fixes
+
+- **[Gemini](../../docs/providers/gemini)**
+    - Fix pricing for Gemini 3 Flash on Vertex AI - [PR #18202](https://github.com/BerriAI/litellm/pull/18202)
+    - Add output_cost_per_image_token for gemini-2.5-flash-image models - [PR #18156](https://github.com/BerriAI/litellm/pull/18156)
+    - Fix properties should be non-empty for OBJECT type - [PR #18237](https://github.com/BerriAI/litellm/pull/18237)
+- **[Qwen](../../docs/providers/fireworks_ai)**
+    - Add qwen3-embedding-8b input per token price - [PR #18018](https://github.com/BerriAI/litellm/pull/18018)
+- **General**
+    - Fix image URL handling - [PR #18139](https://github.com/BerriAI/litellm/pull/18139)
+    - Support Signed URLs with Query Parameters in Image Processing - [PR #17976](https://github.com/BerriAI/litellm/pull/17976)
+    - Add none to encoding_format instead of omitting it - [PR #18042](https://github.com/BerriAI/litellm/pull/18042)
+
+---
+
+## LLM API Endpoints
+
+#### Features
+
+- **[Responses API](../../docs/response_api)**
+    - Add provider specific tools support - [PR #17980](https://github.com/BerriAI/litellm/pull/17980)
+    - Add custom headers support - [PR #18036](https://github.com/BerriAI/litellm/pull/18036)
+    - Fix tool calls transformation in completion bridge - [PR #18226](https://github.com/BerriAI/litellm/pull/18226)
+    - Use list format with input_text for tool results - [PR #18257](https://github.com/BerriAI/litellm/pull/18257)
+    - Add cost tracking in background mode - [PR #18236](https://github.com/BerriAI/litellm/pull/18236)
+    - Fix Claude code responses API bridge errors - [PR #18194](https://github.com/BerriAI/litellm/pull/18194)
+- **[Chat Completions API](../../docs/completion/input)**
+    - Add support for agent skills - [PR #18031](https://github.com/BerriAI/litellm/pull/18031)
+- **[Skills API](../../docs/skills)**
+    - Unified Skills API works across Anthropic, Vertex, Azure, Bedrock - [PR #18232](https://github.com/BerriAI/litellm/pull/18232)
+- **[Search API](../../docs/search/index)**
+    - Add new RAG Search API with rerankers - [PR #18217](https://github.com/BerriAI/litellm/pull/18217)
+- **[Interactions API](../../docs/interactions)**
+    - Add Google Interactions API on SDK and AI Gateway - [PR #18079](https://github.com/BerriAI/litellm/pull/18079), [PR #18081](https://github.com/BerriAI/litellm/pull/18081)
+- **[Image Edit API](../../docs/image_edits)**
+    - Add drop_params support and fix Vertex AI config - [PR #18077](https://github.com/BerriAI/litellm/pull/18077)
+- **General**
+    - Skip adding beta headers for Vertex AI as it is not supported - [PR #18037](https://github.com/BerriAI/litellm/pull/18037)
+    - Fix managed files endpoint - [PR #18046](https://github.com/BerriAI/litellm/pull/18046)
+    - Allow base_model for non-Azure providers in proxy - [PR #18038](https://github.com/BerriAI/litellm/pull/18038)
+
+#### Bugs
+
+- **General**
+    - Fix basemodel import in guardrail translation - [PR #17977](https://github.com/BerriAI/litellm/pull/17977)
+    - Fix No module named 'fastapi' error - [PR #18239](https://github.com/BerriAI/litellm/pull/18239)
+
+---
+
+## Management Endpoints / UI
+
+#### Features
+
+- **Virtual Keys**
+    - Add master key rotation for credentials table - [PR #17952](https://github.com/BerriAI/litellm/pull/17952)
+    - Fix tag management to preserve encrypted fields in litellm_params - [PR #17484](https://github.com/BerriAI/litellm/pull/17484)
+    - Fix key delete and regenerate permissions - [PR #18214](https://github.com/BerriAI/litellm/pull/18214)
+- **Models + Endpoints**
+    - Add Models Conditional Rendering in UI - [PR #18071](https://github.com/BerriAI/litellm/pull/18071)
+    - Add Health Check Model for Wildcard Model in UI - [PR #18269](https://github.com/BerriAI/litellm/pull/18269)
+    - Auto Resolve Vector Store Embedding Model Config - [PR #18167](https://github.com/BerriAI/litellm/pull/18167)
+- **Vector Stores**
+    - Add Milvus Vector Store UI support - [PR #18030](https://github.com/BerriAI/litellm/pull/18030)
+    - Persist Vector Store Settings in Team Update - [PR #18274](https://github.com/BerriAI/litellm/pull/18274)
+- **Logs & Spend**
+    - Add LiteLLM Overhead to Logs - [PR #18033](https://github.com/BerriAI/litellm/pull/18033)
+    - Show LiteLLM Overhead in Logs UI - [PR #18034](https://github.com/BerriAI/litellm/pull/18034)
+    - Resolve Team ID to Team Alias in Usage Page - [PR #18275](https://github.com/BerriAI/litellm/pull/18275)
+    - Fix Usage Page Top Key View Button Visibility - [PR #18203](https://github.com/BerriAI/litellm/pull/18203)
+- **SSO & Health**
+    - Add SSO Readiness Health Check - [PR #18078](https://github.com/BerriAI/litellm/pull/18078)
+    - Fix /health/test_connection to resolve env variables like /chat/completions - [PR #17752](https://github.com/BerriAI/litellm/pull/17752)
+- **CloudZero**
+    - Add CloudZero Cost Tracking UI - [PR #18163](https://github.com/BerriAI/litellm/pull/18163)
+    - Add Delete CloudZero Settings Route and UI - [PR #18168](https://github.com/BerriAI/litellm/pull/18168), [PR #18170](https://github.com/BerriAI/litellm/pull/18170)
+- **General**
+    - Update UI path handling for non-root Docker - [PR #17989](https://github.com/BerriAI/litellm/pull/17989)
+
+#### Bugs
+
+- **UI Fixes**
+    - Fix Login Page Failed To Parse JSON Error - [PR #18159](https://github.com/BerriAI/litellm/pull/18159)
+    - Fix new user route user_id collision handling - [PR #17559](https://github.com/BerriAI/litellm/pull/17559)
+    - Fix Callback Environment Variables Casing - [PR #17912](https://github.com/BerriAI/litellm/pull/17912)
+
+---
+
+## AI Integrations
+
+### Logging
+
+- **[Azure Sentinel](../../docs/observability/azure_sentinel)**
+    - Add new Azure Sentinel Logger integration - [PR #18146](https://github.com/BerriAI/litellm/pull/18146)
+- **[Prometheus](../../docs/proxy/logging#prometheus)**
+    - Add extraction of top level metadata for custom labels - [PR #18087](https://github.com/BerriAI/litellm/pull/18087)
+- **[Langfuse](../../docs/proxy/logging#langfuse)**
+    - Fix not working log_failure_event - [PR #18234](https://github.com/BerriAI/litellm/pull/18234)
+- **[Arize Phoenix](../../docs/observability/phoenix_integration)**
+    - Fix nested spans - [PR #18102](https://github.com/BerriAI/litellm/pull/18102)
+- **General**
+    - Change extra_headers to additional_headers - [PR #17950](https://github.com/BerriAI/litellm/pull/17950)
+
+### Guardrails
+
+- **[LiteLLM Content Filter](../../docs/proxy/guardrails/litellm_content_filter)**
+    - Add built-in guardrails for harmful content, bias, etc. - [PR #18029](https://github.com/BerriAI/litellm/pull/18029)
+    - Add support for running content filters on images - [PR #18044](https://github.com/BerriAI/litellm/pull/18044)
+    - Add support for Brazil PII field - [PR #18076](https://github.com/BerriAI/litellm/pull/18076)
+    - Add configurable guardrail options for content filtering - [PR #18007](https://github.com/BerriAI/litellm/pull/18007)
+- **[Guardrails API](../../docs/adding_provider/generic_guardrail_api)**
+    - Support LLM tool call response checks on `/chat/completions`, `/v1/responses`, `/v1/messages` - [PR #17619](https://github.com/BerriAI/litellm/pull/17619)
+    - Add guardrails load balancing - [PR #18181](https://github.com/BerriAI/litellm/pull/18181)
+    - Fix guardrails for passthrough endpoint - [PR #18109](https://github.com/BerriAI/litellm/pull/18109)
+    - Add headers to metadata for guardrails on pass-through endpoints - [PR #17992](https://github.com/BerriAI/litellm/pull/17992)
+    - Various fixes for guardrail on OpenRouter models - [PR #18085](https://github.com/BerriAI/litellm/pull/18085)
+- **[Lakera](../../docs/proxy/guardrails/lakera_ai)**
+    - Add monitor mode for Lakera - [PR #18084](https://github.com/BerriAI/litellm/pull/18084)
+- **[Pillar Security](../../docs/proxy/guardrails/pillar_security)**
+    - Add masking support and MCP call support - [PR #17959](https://github.com/BerriAI/litellm/pull/17959)
+- **[Bedrock Guardrails](../../docs/proxy/guardrails/bedrock)**
+    - Add support for Bedrock image guardrails - [PR #18115](https://github.com/BerriAI/litellm/pull/18115)
+    - Guardrails block action takes precedence over masking - [PR #17968](https://github.com/BerriAI/litellm/pull/17968)
+
+### Secret Managers
+
+- **[HashiCorp Vault](../../docs/secret_managers/hashicorp_vault)**
+    - Add documentation for configurable Vault mount - [PR #18082](https://github.com/BerriAI/litellm/pull/18082)
+    - Add per-team Vault configuration - [PR #18150](https://github.com/BerriAI/litellm/pull/18150)
+- **UI**
+    - Add secret manager settings controls to team management UI - [PR #18149](https://github.com/BerriAI/litellm/pull/18149)
+
+---
+
+## Spend Tracking, Budgets and Rate Limiting
+
+- **Email Budget Alerts** - Send email notifications when budgets are reached - [PR #17995](https://github.com/BerriAI/litellm/pull/17995)
+
+---
+
+## MCP Gateway
+
+- **Auth Header Propagation** - Add MCP auth header propagation - [PR #17963](https://github.com/BerriAI/litellm/pull/17963)
+- **Fix deepcopy error** - Fix MCP tool call deepcopy error when processing requests - [PR #18010](https://github.com/BerriAI/litellm/pull/18010)
+- **Fix list tool** - Fix MCP list_tools not working without database connection - [PR #18161](https://github.com/BerriAI/litellm/pull/18161)
+
+---
+
+## Agent Gateway (A2A)
+
+- **New Provider: Agent Gateway** - Add pydantic ai agents support - [PR #18013](https://github.com/BerriAI/litellm/pull/18013)
+- **VertexAI Agent Engine** - Add Vertex AI Agent Engine provider - [PR #18014](https://github.com/BerriAI/litellm/pull/18014)
+- **Fix model extraction** - Fix get_model_from_request() to extract model ID from Vertex AI passthrough URLs - [PR #18097](https://github.com/BerriAI/litellm/pull/18097)
+
+---
+
+## Performance / Loadbalancing / Reliability improvements
+
+- **Lazy Imports** - Use per-attribute lazy imports and extract shared constants - [PR #17994](https://github.com/BerriAI/litellm/pull/17994)
+- **Lazy Load HTTP Handlers** - Lazy load http handlers - [PR #17997](https://github.com/BerriAI/litellm/pull/17997)
+- **Lazy Load Caches** - Lazy load caches - [PR #18001](https://github.com/BerriAI/litellm/pull/18001)
+- **Lazy Load Types** - Lazy load bedrock types, .types.utils, GuardrailItem - [PR #18053](https://github.com/BerriAI/litellm/pull/18053), [PR #18054](https://github.com/BerriAI/litellm/pull/18054), [PR #18072](https://github.com/BerriAI/litellm/pull/18072)
+- **Lazy Load Configs** - Lazy load 41 configuration classes - [PR #18267](https://github.com/BerriAI/litellm/pull/18267)
+- **Lazy Load Client Decorators** - Lazy load heavy client decorator imports - [PR #18064](https://github.com/BerriAI/litellm/pull/18064)
+- **Prisma Build Time** - Download Prisma binaries at build time instead of runtime for security restricted environments - [PR #17695](https://github.com/BerriAI/litellm/pull/17695)
+- **Docker Alpine** - Add libsndfile to Alpine image for ARM64 audio processing - [PR #18092](https://github.com/BerriAI/litellm/pull/18092)
+- **Security** - Prevent LiteLLM API key leakage on /health endpoint failures - [PR #18133](https://github.com/BerriAI/litellm/pull/18133)
+
+---
+
+## Documentation Updates
+
+- **SAP Docs** - Update SAP documentation - [PR #17974](https://github.com/BerriAI/litellm/pull/17974)
+- **Pydantic AI Agents** - Add docs on using pydantic ai agents with LiteLLM A2A gateway - [PR #18026](https://github.com/BerriAI/litellm/pull/18026)
+- **Vertex AI Agent Engine** - Add Vertex AI Agent Engine documentation - [PR #18027](https://github.com/BerriAI/litellm/pull/18027)
+- **Router Order** - Add router order parameter documentation - [PR #18045](https://github.com/BerriAI/litellm/pull/18045)
+- **Secret Manager Settings** - Improve secret manager settings documentation - [PR #18235](https://github.com/BerriAI/litellm/pull/18235)
+- **Gemini 3 Flash** - Add version requirement in Gemini 3 Flash blog - [PR #18227](https://github.com/BerriAI/litellm/pull/18227)
+- **README** - Expand Responses API section and update endpoints - [PR #17354](https://github.com/BerriAI/litellm/pull/17354)
+- **Amazon Nova** - Add Amazon Nova to sidebar and supported models - [PR #18220](https://github.com/BerriAI/litellm/pull/18220)
+- **Benchmarks** - Add infrastructure recommendations to benchmarks documentation - [PR #18264](https://github.com/BerriAI/litellm/pull/18264)
+- **Broken Links** - Fix broken link corrections - [PR #18104](https://github.com/BerriAI/litellm/pull/18104)
+- **README Fixes** - Various README improvements - [PR #18206](https://github.com/BerriAI/litellm/pull/18206)
+
+---
+
+## Infrastructure / CI/CD
+
+- **PR Templates** - Add LiteLLM team PR template and CI/CD rules - [PR #17983](https://github.com/BerriAI/litellm/pull/17983), [PR #17985](https://github.com/BerriAI/litellm/pull/17985)
+- **Issue Labeling** - Improve issue labeling with component dropdown and more provider keywords - [PR #17957](https://github.com/BerriAI/litellm/pull/17957)
+- **PR Template Cleanup** - Remove redundant fields from PR template - [PR #17956](https://github.com/BerriAI/litellm/pull/17956)
+- **Dependencies** - Bump altcha-lib from 1.3.0 to 1.4.1 - [PR #18017](https://github.com/BerriAI/litellm/pull/18017)
+
+---
+
+## New Contributors
+
+* @dongbin-lunark made their first contribution in [PR #17757](https://github.com/BerriAI/litellm/pull/17757)
+* @qdrddr made their first contribution in [PR #18004](https://github.com/BerriAI/litellm/pull/18004)
+* @donicrosby made their first contribution in [PR #17962](https://github.com/BerriAI/litellm/pull/17962)
+* @NicolaivdSmagt made their first contribution in [PR #17992](https://github.com/BerriAI/litellm/pull/17992)
+* @Reapor-Yurnero made their first contribution in [PR #18085](https://github.com/BerriAI/litellm/pull/18085)
+* @jk-f5 made their first contribution in [PR #18086](https://github.com/BerriAI/litellm/pull/18086)
+* @castrapel made their first contribution in [PR #18077](https://github.com/BerriAI/litellm/pull/18077)
+* @dtikhonov made their first contribution in [PR #17484](https://github.com/BerriAI/litellm/pull/17484)
+* @opleonnn made their first contribution in [PR #18175](https://github.com/BerriAI/litellm/pull/18175)
+* @eurogig made their first contribution in [PR #18084](https://github.com/BerriAI/litellm/pull/18084)
+
+---
+
+## Full Changelog
+
+**[View complete changelog on GitHub](https://github.com/BerriAI/litellm/compare/v1.80.10-nightly...v1.80.11)**
+
@@ -289,7 +289,7 @@ const sidebars = {
          label: "All Endpoints (Swagger)",
          href: "https://litellm-api.up.railway.app/",
        },
-  "proxy/enterprise",
+        "proxy/enterprise",
        {
          type: "category",
          label: "Authentication",
@@ -470,10 +470,10 @@ const sidebars = {
            "proxy/managed_finetuning",
          ]
        },
-          "generateContent",
-          "apply_guardrail",
-          "bedrock_invoke",
-          "interactions",
+        "generateContent",
+        "apply_guardrail",
+        "bedrock_invoke",
+        "interactions",
        {
          type: "category",
          label: "/images",
@@ -664,6 +664,7 @@ const sidebars = {
            "providers/bedrock_agents",
            "providers/bedrock_writer",
            "providers/bedrock_batches",
+            "providers/aws_polly",
            "providers/bedrock_vector_store",
          ]
        },
@@ -783,6 +784,7 @@ const sidebars = {
          ]
        },
        "providers/xai",
+        "providers/xiaomi_mimo",
        "providers/xinference",
        "providers/zai",
      ],
@@ -0,0 +1,20 @@
+-- CreateTable
+CREATE TABLE "LiteLLM_SkillsTable" (
+    "skill_id" TEXT NOT NULL,
+    "display_title" TEXT,
+    "description" TEXT,
+    "instructions" TEXT,
+    "source" TEXT NOT NULL DEFAULT 'custom',
+    "latest_version" TEXT,
+    "file_content" BYTEA,
+    "file_name" TEXT,
+    "file_type" TEXT,
+    "metadata" JSONB DEFAULT '{}',
+    "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "created_by" TEXT,
+    "updated_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updated_by" TEXT,
+
+    CONSTRAINT "LiteLLM_SkillsTable_pkey" PRIMARY KEY ("skill_id")
+);
+
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "litellm-proxy-extras"
-version = "0.4.14"
+version = "0.4.16"
 description = "Additional files for the LiteLLM Proxy. Reduces the size of the main litellm package."
 authors = ["BerriAI"]
 readme = "README.md"
@@ -22,7 +22,7 @@ requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"

 [tool.commitizen]
-version = "0.4.14"
+version = "0.4.16"
 version_files = [
    "pyproject.toml:version",
    "../requirements.txt:litellm-proxy-extras==",
@@ -1516,7 +1516,6 @@ if TYPE_CHECKING:
    from .llms.voyage.rerank.transformation import VoyageRerankConfig as VoyageRerankConfig
    from .llms.clarifai.chat.transformation import ClarifaiConfig as ClarifaiConfig
    from .llms.ai21.chat.transformation import AI21ChatConfig as AI21ChatConfig
-    from .llms.ai21.chat.transformation import AI21Config as AI21Config
    from litellm.caching.llm_caching_handler import LLMClientCache
    from litellm.types.llms.bedrock import COHERE_EMBEDDING_INPUT_TYPES
    from litellm.types.utils import (
@@ -1570,9 +1569,7 @@ if TYPE_CHECKING:
    module_level_aclient: AsyncHTTPHandler
    module_level_client: HTTPHandler

-    # LLM config classes - lazy loaded only
-    AmazonConverseConfig: Type[Any]
-    OpenAILikeChatConfig: Type[Any]
+    # Note: AmazonConverseConfig and OpenAILikeChatConfig are imported above in TYPE_CHECKING block


 def __getattr__(name: str) -> Any:
@@ -1,5 +1,6 @@
-from typing import Any, Optional, cast
 import sys
+from typing import Any, Optional, cast
+

 def _get_litellm_globals() -> dict:
    """Helper to get the globals dictionary of the litellm module."""
@@ -262,7 +263,9 @@ def _lazy_import_utils(name: str) -> Any:  # noqa: PLR0915
        return _supports_response_schema
    
    if name == "supports_parallel_function_calling":
-        from .utils import supports_parallel_function_calling as _supports_parallel_function_calling
+        from .utils import (
+            supports_parallel_function_calling as _supports_parallel_function_calling,
+        )
        _globals["supports_parallel_function_calling"] = _supports_parallel_function_calling
        return _supports_parallel_function_calling
    
@@ -428,7 +431,9 @@ def _lazy_import_cost_calculator(name: str) -> Any:
        return _cost_per_token
    
    if name == "response_cost_calculator":
-        from .cost_calculator import response_cost_calculator as _response_cost_calculator
+        from .cost_calculator import (
+            response_cost_calculator as _response_cost_calculator,
+        )
        _globals["response_cost_calculator"] = _response_cost_calculator
        return _response_cost_calculator
    
@@ -500,9 +505,7 @@ def _lazy_import_types_utils(name: str) -> Any:
        return _CredentialItem

    if name == "PriorityReservationDict":
-        from .types.utils import (
-            PriorityReservationDict as _PriorityReservationDict,
-        )
+        from .types.utils import PriorityReservationDict as _PriorityReservationDict

        _globals["PriorityReservationDict"] = _PriorityReservationDict
        return _PriorityReservationDict
@@ -522,9 +525,7 @@ def _lazy_import_types_utils(name: str) -> Any:
        return _SearchProviders

    if name == "GenericStreamingChunk":
-        from .types.utils import (
-            GenericStreamingChunk as _GenericStreamingChunk,
-        )
+        from .types.utils import GenericStreamingChunk as _GenericStreamingChunk

        _globals["GenericStreamingChunk"] = _GenericStreamingChunk
        return _GenericStreamingChunk
@@ -568,13 +569,17 @@ def _lazy_import_llm_client_cache(name: str) -> Any:
    _globals = _get_litellm_globals()

    if name == "LLMClientCache":
-        from litellm.caching.llm_caching_handler import LLMClientCache as _LLMClientCache
+        from litellm.caching.llm_caching_handler import (
+            LLMClientCache as _LLMClientCache,
+        )

        _globals["LLMClientCache"] = _LLMClientCache
        return _LLMClientCache

    if name == "in_memory_llm_clients_cache":
-        from litellm.caching.llm_caching_handler import LLMClientCache as _LLMClientCache
+        from litellm.caching.llm_caching_handler import (
+            LLMClientCache as _LLMClientCache,
+        )

        instance = _LLMClientCache()
        # Only populate the requested singleton name to keep lazy-import
@@ -594,7 +599,9 @@ def _lazy_import_litellm_logging(name: str) -> Any:
        return _Logging
    
    if name == "modify_integration":
-        from litellm.litellm_core_utils.litellm_logging import modify_integration as _modify_integration
+        from litellm.litellm_core_utils.litellm_logging import (
+            modify_integration as _modify_integration,
+        )
        _globals["modify_integration"] = _modify_integration
        return _modify_integration
    
@@ -669,9 +676,7 @@ def _lazy_import_types(name: str) -> Any:
    _globals = _get_litellm_globals()

    if name == "GuardrailItem":
-        from litellm.types.guardrails import (
-            GuardrailItem as _GuardrailItem,
-        )
+        from litellm.types.guardrails import GuardrailItem as _GuardrailItem

        _globals["GuardrailItem"] = _GuardrailItem
        return _GuardrailItem
@@ -679,7 +684,7 @@ def _lazy_import_types(name: str) -> Any:
    raise AttributeError(f"Types lazy import: unknown attribute {name!r}")


-def _lazy_import_llm_configs(name: str) -> Any:
+def _lazy_import_llm_configs(name: str) -> Any:  # noqa: PLR0915
    """Lazy import for LLM config classes."""
    _globals = _get_litellm_globals()

@@ -724,9 +729,7 @@ def _lazy_import_llm_configs(name: str) -> Any:
        return _AzureAnthropicConfig

    if name == "BytezChatConfig":
-        from .llms.bytez.chat.transformation import (
-            BytezChatConfig as _BytezChatConfig,
-        )
+        from .llms.bytez.chat.transformation import BytezChatConfig as _BytezChatConfig

        _globals["BytezChatConfig"] = _BytezChatConfig
        return _BytezChatConfig
@@ -780,9 +783,7 @@ def _lazy_import_llm_configs(name: str) -> Any:
        return _OobaboogaConfig

    if name == "MaritalkConfig":
-        from .llms.maritalk import (
-            MaritalkConfig as _MaritalkConfig,
-        )
+        from .llms.maritalk import MaritalkConfig as _MaritalkConfig

        _globals["MaritalkConfig"] = _MaritalkConfig
        return _MaritalkConfig
@@ -820,17 +821,13 @@ def _lazy_import_llm_configs(name: str) -> Any:
        return _AnthropicTextConfig

    if name == "GroqSTTConfig":
-        from .llms.groq.stt.transformation import (
-            GroqSTTConfig as _GroqSTTConfig,
-        )
+        from .llms.groq.stt.transformation import GroqSTTConfig as _GroqSTTConfig

        _globals["GroqSTTConfig"] = _GroqSTTConfig
        return _GroqSTTConfig

    if name == "TritonConfig":
-        from .llms.triton.completion.transformation import (
-            TritonConfig as _TritonConfig,
-        )
+        from .llms.triton.completion.transformation import TritonConfig as _TritonConfig

        _globals["TritonConfig"] = _TritonConfig
        return _TritonConfig
@@ -1004,9 +1001,7 @@ def _lazy_import_llm_configs(name: str) -> Any:
        return _VoyageRerankConfig

    if name == "ClarifaiConfig":
-        from .llms.clarifai.chat.transformation import (
-            ClarifaiConfig as _ClarifaiConfig,
-        )
+        from .llms.clarifai.chat.transformation import ClarifaiConfig as _ClarifaiConfig

        _globals["ClarifaiConfig"] = _ClarifaiConfig
        return _ClarifaiConfig
@@ -167,28 +167,27 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge):
                    )
            elif role == "tool":
                # Convert tool message to function call output format
-                # The Responses API expects 'output' to be a string, not a list
+                # The Responses API expects 'output' to be a list with input_text/input_image types
+                # Using list format for consistency across text and multimodal content
+                tool_output: List[Dict[str, Any]]
                if content is None:
-                    output_str = ""
+                    tool_output = []
                elif isinstance(content, str):
-                    output_str = content
+                    # Convert string to list with input_text
+                    tool_output = [{"type": "input_text", "text": content}]
                elif isinstance(content, list):
-                    # If content is a list, extract text parts and join them
-                    text_parts = []
-                    for item in content:
-                        if isinstance(item, str):
-                            text_parts.append(item)
-                        elif isinstance(item, dict) and item.get("type") == "text":
-                            text_parts.append(item.get("text", ""))
-                    output_str = " ".join(text_parts) if text_parts else str(content)
+                    # Transform list content to Responses API format
+                    tool_output = self._convert_content_to_responses_format(
+                        content, "user"  # Use "user" role to get input_* types
+                    )
                else:
-                    # Fallback: convert unexpected types to string
-                    output_str = str(content)
+                    # Fallback: convert unexpected types to input_text
+                    tool_output = [{"type": "input_text", "text": str(content)}]
                input_items.append(
                    {
                        "type": "function_call_output",
                        "call_id": tool_call_id,
-                        "output": output_str,
+                        "output": tool_output,
                    }
                )
            elif role == "assistant" and tool_calls and isinstance(tool_calls, list):
@@ -32,6 +32,8 @@ from litellm.types.utils import (
 )

 if TYPE_CHECKING:
+    from fastapi import HTTPException
+
    from litellm.caching.caching import DualCache
    from opentelemetry.trace import Span as _Span

@@ -348,7 +350,20 @@ class CustomLogger:  # https://docs.litellm.ai/docs/observability/custom_callbac
        original_exception: Exception,
        user_api_key_dict: UserAPIKeyAuth,
        traceback_str: Optional[str] = None,
-    ):
+    ) -> Optional["HTTPException"]:
+        """
+        Called after an LLM API call fails. Can return or raise HTTPException to transform error responses.
+
+        Args:
+            - request_data: dict - The request data.
+            - original_exception: Exception - The original exception that occurred.
+            - user_api_key_dict: UserAPIKeyAuth - The user API key dictionary.
+            - traceback_str: Optional[str] - The traceback string.
+
+        Returns:
+            - Optional[HTTPException]: Return an HTTPException to transform the error response sent to the client.
+                                      Return None to use the original exception.
+        """
        pass

    async def async_post_call_success_hook(
@@ -27,6 +27,13 @@ import litellm
 from litellm._logging import verbose_logger
 from litellm._uuid import uuid
 from litellm.integrations.custom_batch_logger import CustomBatchLogger
+from litellm.integrations.datadog.datadog_handler import (
+    get_datadog_hostname,
+    get_datadog_service,
+    get_datadog_source,
+    get_datadog_tags,
+)
+from litellm.litellm_core_utils.dd_tracing import tracer
 from litellm.llms.custom_httpx.http_handler import (
    _get_httpx_client,
    get_async_httpx_client,
@@ -67,23 +74,23 @@ class DataDogLogger(
        Optional environment variables (DataDog Agent):
        `LITELLM_DD_AGENT_HOST` - hostname or IP of DataDog agent, example = `"localhost"`
        `LITELLM_DD_AGENT_PORT` - port of DataDog agent (default: 10518 for logs)
-        
+
        Note: We use LITELLM_DD_AGENT_HOST instead of DD_AGENT_HOST to avoid conflicts
        with ddtrace which automatically sets DD_AGENT_HOST for APM tracing.
        """
        try:
            verbose_logger.debug("Datadog: in init datadog logger")
-            
+
            #########################################################
            # Handle datadog_params set as litellm.datadog_params
            #########################################################
            dict_datadog_params = self._get_datadog_params()
            kwargs.update(dict_datadog_params)
-            
+
            self.async_client = get_async_httpx_client(
                llm_provider=httpxSpecialProvider.LoggingCallback
            )
-            
+
            # Configure DataDog endpoint (Agent or Direct API)
            # Use LITELLM_DD_AGENT_HOST to avoid conflicts with ddtrace's DD_AGENT_HOST
            dd_agent_host = os.getenv("LITELLM_DD_AGENT_HOST")
@@ -91,7 +98,7 @@ class DataDogLogger(
                self._configure_dd_agent(dd_agent_host=dd_agent_host)
            else:
                self._configure_dd_direct_api()
-            
+
            # Optional override for testing
            self._apply_dd_base_url_override()
            self.sync_client = _get_httpx_client()
@@ -118,17 +125,21 @@ class DataDogLogger(
                dict_datadog_params = litellm.datadog_params.model_dump()
            elif isinstance(litellm.datadog_params, Dict):
                # only allow params that are of DatadogInitParams
-                dict_datadog_params = DatadogInitParams(**litellm.datadog_params).model_dump()
+                dict_datadog_params = DatadogInitParams(
+                    **litellm.datadog_params
+                ).model_dump()
        return dict_datadog_params

    def _configure_dd_agent(self, dd_agent_host: str) -> None:
        """
        Configure DataDog Agent for log forwarding
-        
+
        Args:
            dd_agent_host: Hostname or IP of DataDog agent
        """
-        dd_agent_port = os.getenv("LITELLM_DD_AGENT_PORT", "10518")  # default port for logs
+        dd_agent_port = os.getenv(
+            "LITELLM_DD_AGENT_PORT", "10518"
+        )  # default port for logs
        self.intake_url = f"http://{dd_agent_host}:{dd_agent_port}/api/v2/logs"
        self.DD_API_KEY = os.getenv("DD_API_KEY")  # Optional when using agent
        verbose_logger.debug(f"Datadog: Using DD Agent at {self.intake_url}")
@@ -136,7 +147,7 @@ class DataDogLogger(
    def _configure_dd_direct_api(self) -> None:
        """
        Configure direct DataDog API connection
-        
+
        Raises:
            Exception: If required environment variables are not set
        """
@@ -144,11 +155,9 @@ class DataDogLogger(
            raise Exception("DD_API_KEY is not set, set 'DD_API_KEY=<>")
        if os.getenv("DD_SITE", None) is None:
            raise Exception("DD_SITE is not set in .env, set 'DD_SITE=<>")
-        
+
        self.DD_API_KEY = os.getenv("DD_API_KEY")
-        self.intake_url = (
-            f"https://http-intake.logs.{os.getenv('DD_SITE')}/api/v2/logs"
-        )
+        self.intake_url = f"https://http-intake.logs.{os.getenv('DD_SITE')}/api/v2/logs"

    def _apply_dd_base_url_override(self) -> None:
        """
@@ -270,7 +279,7 @@ class DataDogLogger(
            # Add API key if available (required for direct API, optional for agent)
            if self.DD_API_KEY:
                headers["DD-API-KEY"] = self.DD_API_KEY
-            
+
            response = self.sync_client.post(
                url=self.intake_url,
                json=dd_payload,  # type: ignore
@@ -318,18 +327,18 @@ class DataDogLogger(
        status: DataDogStatus,
    ) -> DatadogPayload:
        from litellm.litellm_core_utils.safe_json_dumps import safe_dumps
+
        json_payload = safe_dumps(standard_logging_object)
        verbose_logger.debug("Datadog: Logger - Logging payload = %s", json_payload)
        dd_payload = DatadogPayload(
-            ddsource=self._get_datadog_source(),
-            ddtags=self._get_datadog_tags(
-                standard_logging_object=standard_logging_object
-            ),
-            hostname=self._get_datadog_hostname(),
+            ddsource=get_datadog_source(),
+            ddtags=get_datadog_tags(standard_logging_object=standard_logging_object),
+            hostname=get_datadog_hostname(),
            message=json_payload,
-            service=self._get_datadog_service(),
+            service=get_datadog_service(),
            status=status,
        )
+        self._add_trace_context_to_payload(dd_payload=dd_payload)
        return dd_payload

    def create_datadog_logging_payload(
@@ -384,18 +393,19 @@ class DataDogLogger(
        import gzip

        from litellm.litellm_core_utils.safe_json_dumps import safe_dumps
+
        compressed_data = gzip.compress(safe_dumps(data).encode("utf-8"))
-        
+
        # Build headers
        headers = {
            "Content-Encoding": "gzip",
            "Content-Type": "application/json",
        }
-        
+
        # Add API key if available (required for direct API, optional for agent)
        if self.DD_API_KEY:
            headers["DD-API-KEY"] = self.DD_API_KEY
-        
+
        response = await self.async_client.post(
            url=self.intake_url,
            data=compressed_data,  # type: ignore
@@ -421,13 +431,14 @@ class DataDogLogger(
            _payload_dict = payload.model_dump()
            _payload_dict.update(event_metadata or {})
            from litellm.litellm_core_utils.safe_json_dumps import safe_dumps
+
            _dd_message_str = safe_dumps(_payload_dict)
            _dd_payload = DatadogPayload(
-                ddsource=self._get_datadog_source(),
-                ddtags=self._get_datadog_tags(),
-                hostname=self._get_datadog_hostname(),
+                ddsource=get_datadog_source(),
+                ddtags=get_datadog_tags(),
+                hostname=get_datadog_hostname(),
                message=_dd_message_str,
-                service=self._get_datadog_service(),
+                service=get_datadog_service(),
                status=DataDogStatus.WARN,
            )

@@ -462,13 +473,14 @@ class DataDogLogger(
            _payload_dict.update(event_metadata or {})

            from litellm.litellm_core_utils.safe_json_dumps import safe_dumps
+
            _dd_message_str = safe_dumps(_payload_dict)
            _dd_payload = DatadogPayload(
-                ddsource=self._get_datadog_source(),
-                ddtags=self._get_datadog_tags(),
-                hostname=self._get_datadog_hostname(),
+                ddsource=get_datadog_source(),
+                ddtags=get_datadog_tags(),
+                hostname=get_datadog_hostname(),
                message=_dd_message_str,
-                service=self._get_datadog_service(),
+                service=get_datadog_service(),
                status=DataDogStatus.INFO,
            )

@@ -530,7 +542,6 @@ class DataDogLogger(
                else:
                    clean_metadata[key] = value

-
        # Build the initial payload
        payload = {
            "id": id,
@@ -550,68 +561,70 @@ class DataDogLogger(
        }

        from litellm.litellm_core_utils.safe_json_dumps import safe_dumps
+
        json_payload = safe_dumps(payload)

        verbose_logger.debug("Datadog: Logger - Logging payload = %s", json_payload)

        dd_payload = DatadogPayload(
-            ddsource=self._get_datadog_source(),
-            ddtags=self._get_datadog_tags(),
-            hostname=self._get_datadog_hostname(),
+            ddsource=get_datadog_source(),
+            ddtags=get_datadog_tags(),
+            hostname=get_datadog_hostname(),
            message=json_payload,
-            service=self._get_datadog_service(),
+            service=get_datadog_service(),
            status=DataDogStatus.INFO,
        )
        return dd_payload

-    @staticmethod
-    def _get_datadog_tags(
-        standard_logging_object: Optional[StandardLoggingPayload] = None,
-    ) -> str:
-        """
-        Get the datadog tags for the request
+    def _add_trace_context_to_payload(
+        self,
+        dd_payload: DatadogPayload,
+    ) -> None:
+        """Attach Datadog APM trace context if one is active."""

-        DD tags need to be as follows:
-            - tags: ["user_handle:dog@gmail.com", "app_version:1.0.0"]
-        """
-        base_tags = {
-            "env": os.getenv("DD_ENV", "unknown"),
-            "service": os.getenv("DD_SERVICE", "litellm"),
-            "version": os.getenv("DD_VERSION", "unknown"),
-            "HOSTNAME": DataDogLogger._get_datadog_hostname(),
-            "POD_NAME": os.getenv("POD_NAME", "unknown"),
-        }
+        try:
+            trace_context = self._get_active_trace_context()
+            if trace_context is None:
+                return

-        tags = [f"{k}:{v}" for k, v in base_tags.items()]
-
-        if standard_logging_object:
-            _request_tags: List[str] = (
-                standard_logging_object.get("request_tags", []) or []
+            dd_payload["dd.trace_id"] = trace_context["trace_id"]
+            span_id = trace_context.get("span_id")
+            if span_id is not None:
+                dd_payload["dd.span_id"] = span_id
+        except Exception:
+            verbose_logger.exception(
+                "Datadog: Failed to attach trace context to payload"
            )
-            request_tags = [f"request_tag:{tag}" for tag in _request_tags]
-            tags.extend(request_tags)

-        return ",".join(tags)
+    def _get_active_trace_context(self) -> Optional[Dict[str, str]]:
+        try:
+            current_span = None
+            current_span_fn = getattr(tracer, "current_span", None)
+            if callable(current_span_fn):
+                current_span = current_span_fn()

-    @staticmethod
-    def _get_datadog_source():
-        return os.getenv("DD_SOURCE", "litellm")
+            if current_span is None:
+                current_root_span_fn = getattr(tracer, "current_root_span", None)
+                if callable(current_root_span_fn):
+                    current_span = current_root_span_fn()

-    @staticmethod
-    def _get_datadog_service():
-        return os.getenv("DD_SERVICE", "litellm-server")
+            if current_span is None:
+                return None

-    @staticmethod
-    def _get_datadog_hostname():
-        return os.getenv("HOSTNAME", "")
+            trace_id = getattr(current_span, "trace_id", None)
+            if trace_id is None:
+                return None

-    @staticmethod
-    def _get_datadog_env():
-        return os.getenv("DD_ENV", "unknown")
-
-    @staticmethod
-    def _get_datadog_pod_name():
-        return os.getenv("POD_NAME", "unknown")
+            span_id = getattr(current_span, "span_id", None)
+            trace_context: Dict[str, str] = {"trace_id": str(trace_id)}
+            if span_id is not None:
+                trace_context["span_id"] = str(span_id)
+            return trace_context
+        except Exception:
+            verbose_logger.exception(
+                "Datadog: Failed to retrieve active trace context from tracer"
+            )
+            return None

    async def async_health_check(self) -> IntegrationHealthCheckStatus:
        """
@@ -651,4 +664,4 @@ class DataDogLogger(
        start_time_utc: Optional[datetimeObj],
        end_time_utc: Optional[datetimeObj],
    ) -> Optional[dict]:
-        pass
+        pass
@@ -0,0 +1,50 @@
+"""Shared helpers for Datadog integrations."""
+
+from __future__ import annotations
+
+import os
+from typing import List, Optional
+
+from litellm.types.utils import StandardLoggingPayload
+
+
+def get_datadog_source() -> str:
+    return os.getenv("DD_SOURCE", "litellm")
+
+
+def get_datadog_service() -> str:
+    return os.getenv("DD_SERVICE", "litellm-server")
+
+
+def get_datadog_hostname() -> str:
+    return os.getenv("HOSTNAME", "")
+
+
+def get_datadog_env() -> str:
+    return os.getenv("DD_ENV", "unknown")
+
+
+def get_datadog_pod_name() -> str:
+    return os.getenv("POD_NAME", "unknown")
+
+
+def get_datadog_tags(
+    standard_logging_object: Optional[StandardLoggingPayload] = None,
+) -> str:
+    """Build Datadog tags string used by multiple integrations."""
+
+    base_tags = {
+        "env": get_datadog_env(),
+        "service": get_datadog_service(),
+        "version": os.getenv("DD_VERSION", "unknown"),
+        "HOSTNAME": get_datadog_hostname(),
+        "POD_NAME": get_datadog_pod_name(),
+    }
+
+    tags: List[str] = [f"{k}:{v}" for k, v in base_tags.items()]
+
+    if standard_logging_object:
+        request_tags = standard_logging_object.get("request_tags", []) or []
+        tags.extend(f"request_tag:{tag}" for tag in request_tags)
+
+    return ",".join(tags)
@@ -18,7 +18,10 @@ import httpx
 import litellm
 from litellm._logging import verbose_logger
 from litellm.integrations.custom_batch_logger import CustomBatchLogger
-from litellm.integrations.datadog.datadog import DataDogLogger
+from litellm.integrations.datadog.datadog_handler import (
+    get_datadog_service,
+    get_datadog_tags,
+)
 from litellm.litellm_core_utils.dd_tracing import tracer
 from litellm.litellm_core_utils.prompt_templates.common_utils import (
    handle_any_messages_to_chat_completion_str_messages_conversion,
@@ -36,7 +39,7 @@ from litellm.types.utils import (
 )


-class DataDogLLMObsLogger(DataDogLogger, CustomBatchLogger):
+class DataDogLLMObsLogger(CustomBatchLogger):
    def __init__(self, **kwargs):
        try:
            verbose_logger.debug("DataDogLLMObs: Initializing logger")
@@ -142,8 +145,8 @@ class DataDogLLMObsLogger(DataDogLogger, CustomBatchLogger):
                "data": DDIntakePayload(
                    type="span",
                    attributes=DDSpanAttributes(
-                        ml_app=self._get_datadog_service(),
-                        tags=[self._get_datadog_tags()],
+                        ml_app=get_datadog_service(),
+                        tags=[get_datadog_tags()],
                        spans=self.log_queue,
                    ),
                ),
@@ -243,9 +246,7 @@ class DataDogLLMObsLogger(DataDogLogger, CustomBatchLogger):
            duration=int((end_time - start_time).total_seconds() * 1e9),
            metrics=metrics,
            status="error" if error_info else "ok",
-            tags=[
-                self._get_datadog_tags(standard_logging_object=standard_logging_payload)
-            ],
+            tags=[get_datadog_tags(standard_logging_object=standard_logging_payload)],
        )

        apm_trace_id = self._get_apm_trace_id()
@@ -5,6 +5,7 @@ import httpx
 import litellm
 from litellm.constants import REPLICATE_MODEL_NAME_WITH_ID_LENGTH
 from litellm.secret_managers.main import get_secret, get_secret_str
+from litellm.llms.openai_like.json_loader import JSONProviderRegistry

 from ..types.router import LiteLLM_Params

@@ -155,6 +156,17 @@ def get_llm_provider(  # noqa: PLR0915

        if api_key and api_key.startswith("os.environ/"):
            dynamic_api_key = get_secret_str(api_key)
+
+        # Check JSON-configured providers FIRST (before enum-based provider_list)
+        provider_prefix = model.split("/", 1)[0]
+        if len(model.split("/")) > 1 and JSONProviderRegistry.exists(provider_prefix):
+            return _get_openai_compatible_provider_info(
+                model=model,
+                api_base=api_base,
+                api_key=api_key,
+                dynamic_api_key=dynamic_api_key,
+            )
+
        # check if llm provider part of model name

        if (
@@ -692,15 +692,15 @@ class ModelResponseIterator:
                    text = content_block_start["content_block"]["text"]
                elif content_block_start["content_block"]["type"] == "tool_use" or content_block_start["content_block"]["type"] == "server_tool_use":
                    self.tool_index += 1
-                    # Some server_tool_use blocks (e.g. web_search) may omit `input` at start;
-                    # default to {} to avoid KeyError and let deltas populate arguments.
-                    tool_input = content_block_start["content_block"].get("input", {})
+                    # Use empty string for arguments in content_block_start - actual arguments
+                    # come in subsequent content_block_delta chunks and get accumulated.
+                    # Using str(input) here would prepend '{}' causing invalid JSON accumulation.
                    tool_use = ChatCompletionToolCallChunk(
                        id=content_block_start["content_block"]["id"],
                        type="function",
                        function=ChatCompletionToolCallFunctionChunk(
                            name=content_block_start["content_block"]["name"],
-                            arguments=str(tool_input),
+                            arguments="",
                        ),
                        index=self.tool_index,
                    )
@@ -0,0 +1,391 @@
+"""
+AWS Polly Text-to-Speech transformation
+
+Maps OpenAI TTS spec to AWS Polly SynthesizeSpeech API
+Reference: https://docs.aws.amazon.com/polly/latest/dg/API_SynthesizeSpeech.html
+"""
+
+import json
+from typing import TYPE_CHECKING, Any, Coroutine, Dict, Optional, Tuple, Union
+
+import httpx
+
+from litellm.llms.base_llm.text_to_speech.transformation import (
+    BaseTextToSpeechConfig,
+    TextToSpeechRequestData,
+)
+from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM
+
+if TYPE_CHECKING:
+    from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+    from litellm.types.llms.openai import HttpxBinaryResponseContent
+else:
+    LiteLLMLoggingObj = Any
+    HttpxBinaryResponseContent = Any
+
+
+class AWSPollyTextToSpeechConfig(BaseTextToSpeechConfig, BaseAWSLLM):
+    """
+    Configuration for AWS Polly Text-to-Speech
+
+    Reference: https://docs.aws.amazon.com/polly/latest/dg/API_SynthesizeSpeech.html
+    """
+
+    def __init__(self):
+        BaseTextToSpeechConfig.__init__(self)
+        BaseAWSLLM.__init__(self)
+
+    # Default settings
+    DEFAULT_VOICE = "Joanna"
+    DEFAULT_ENGINE = "neural"
+    DEFAULT_OUTPUT_FORMAT = "mp3"
+    DEFAULT_REGION = "us-east-1"
+
+    # Voice name mappings from OpenAI voices to Polly voices
+    VOICE_MAPPINGS = {
+        "alloy": "Joanna",      # US English female
+        "echo": "Matthew",      # US English male
+        "fable": "Amy",         # British English female
+        "onyx": "Brian",        # British English male
+        "nova": "Ivy",          # US English female (child)
+        "shimmer": "Kendra",    # US English female
+    }
+
+    # Response format mappings from OpenAI to Polly
+    FORMAT_MAPPINGS = {
+        "mp3": "mp3",
+        "opus": "ogg_vorbis",
+        "aac": "mp3",           # Polly doesn't support AAC, use MP3
+        "flac": "mp3",          # Polly doesn't support FLAC, use MP3
+        "wav": "pcm",
+        "pcm": "pcm",
+    }
+
+    # Valid Polly engines
+    VALID_ENGINES = {"standard", "neural", "long-form", "generative"}
+
+    def dispatch_text_to_speech(
+        self,
+        model: str,
+        input: str,
+        voice: Optional[Union[str, Dict]],
+        optional_params: Dict,
+        litellm_params_dict: Dict,
+        logging_obj: "LiteLLMLoggingObj",
+        timeout: Union[float, httpx.Timeout],
+        extra_headers: Optional[Dict[str, Any]],
+        base_llm_http_handler: Any,
+        aspeech: bool,
+        api_base: Optional[str],
+        api_key: Optional[str],
+        **kwargs: Any,
+    ) -> Union[
+        "HttpxBinaryResponseContent",
+        Coroutine[Any, Any, "HttpxBinaryResponseContent"],
+    ]:
+        """
+        Dispatch method to handle AWS Polly TTS requests
+
+        This method encapsulates AWS-specific credential resolution and parameter handling
+
+        Args:
+            base_llm_http_handler: The BaseLLMHTTPHandler instance from main.py
+        """
+        # Get AWS region from kwargs or environment
+        aws_region_name = kwargs.get("aws_region_name") or self._get_aws_region_name_for_polly(
+            optional_params=optional_params
+        )
+
+        # Convert voice to string if it's a dict
+        voice_str: Optional[str] = None
+        if isinstance(voice, str):
+            voice_str = voice
+        elif isinstance(voice, dict):
+            voice_str = voice.get("name") if voice else None
+
+        # Update litellm_params with resolved values
+        # Note: AWS credentials (aws_access_key_id, aws_secret_access_key, etc.)
+        # are already in litellm_params_dict via get_litellm_params() in main.py
+        litellm_params_dict["aws_region_name"] = aws_region_name
+        litellm_params_dict["api_base"] = api_base
+        litellm_params_dict["api_key"] = api_key
+
+        # Call the text_to_speech_handler
+        response = base_llm_http_handler.text_to_speech_handler(
+            model=model,
+            input=input,
+            voice=voice_str,
+            text_to_speech_provider_config=self,
+            text_to_speech_optional_params=optional_params,
+            custom_llm_provider="aws_polly",
+            litellm_params=litellm_params_dict,
+            logging_obj=logging_obj,
+            timeout=timeout,
+            extra_headers=extra_headers,
+            client=None,
+            _is_async=aspeech,
+        )
+
+        return response
+
+    def _get_aws_region_name_for_polly(self, optional_params: Dict) -> str:
+        """Get AWS region name for Polly API calls."""
+        aws_region_name = optional_params.get("aws_region_name")
+        if aws_region_name is None:
+            aws_region_name = self.get_aws_region_name_for_non_llm_api_calls()
+        return aws_region_name
+
+    def get_supported_openai_params(self, model: str) -> list:
+        """
+        AWS Polly TTS supports these OpenAI parameters
+        """
+        return ["voice", "response_format", "speed"]
+
+    def map_openai_params(
+        self,
+        model: str,
+        optional_params: Dict,
+        voice: Optional[Union[str, Dict]] = None,
+        drop_params: bool = False,
+        kwargs: Dict = {},
+    ) -> Tuple[Optional[str], Dict]:
+        """
+        Map OpenAI parameters to AWS Polly parameters
+        """
+        mapped_params = {}
+
+        # Map voice - support both native Polly voices and OpenAI voice mappings
+        mapped_voice: Optional[str] = None
+        if isinstance(voice, str):
+            if voice in self.VOICE_MAPPINGS:
+                # OpenAI voice -> Polly voice
+                mapped_voice = self.VOICE_MAPPINGS[voice]
+            else:
+                # Assume it's already a Polly voice name
+                mapped_voice = voice
+
+        # Map response format
+        if "response_format" in optional_params:
+            format_name = optional_params["response_format"]
+            if format_name in self.FORMAT_MAPPINGS:
+                mapped_params["output_format"] = self.FORMAT_MAPPINGS[format_name]
+            else:
+                mapped_params["output_format"] = format_name
+        else:
+            mapped_params["output_format"] = self.DEFAULT_OUTPUT_FORMAT
+
+        # Extract engine from model name (e.g., "aws_polly/neural" -> "neural")
+        engine = self._extract_engine_from_model(model)
+        mapped_params["engine"] = engine
+
+        # Pass through Polly-specific parameters (use AWS API casing)
+        if "language_code" in kwargs:
+            mapped_params["LanguageCode"] = kwargs["language_code"]
+        if "lexicon_names" in kwargs:
+            mapped_params["LexiconNames"] = kwargs["lexicon_names"]
+        if "sample_rate" in kwargs:
+            mapped_params["SampleRate"] = kwargs["sample_rate"]
+
+        return mapped_voice, mapped_params
+
+    def _extract_engine_from_model(self, model: str) -> str:
+        """
+        Extract engine from model name.
+
+        Examples:
+            - aws_polly/neural -> neural
+            - aws_polly/standard -> standard
+            - aws_polly/long-form -> long-form
+            - aws_polly -> neural (default)
+        """
+        if "/" in model:
+            parts = model.split("/")
+            if len(parts) >= 2:
+                engine = parts[1].lower()
+                if engine in self.VALID_ENGINES:
+                    return engine
+        return self.DEFAULT_ENGINE
+
+    def validate_environment(
+        self,
+        headers: dict,
+        model: str,
+        api_key: Optional[str] = None,
+        api_base: Optional[str] = None,
+    ) -> dict:
+        """
+        Validate AWS environment and set up headers.
+        AWS SigV4 signing will be done in transform_text_to_speech_request.
+        """
+        validated_headers = headers.copy()
+        validated_headers["Content-Type"] = "application/json"
+        return validated_headers
+
+    def get_complete_url(
+        self,
+        model: str,
+        api_base: Optional[str],
+        litellm_params: dict,
+    ) -> str:
+        """
+        Get the complete URL for AWS Polly SynthesizeSpeech request
+
+        Polly endpoint format:
+        https://polly.{region}.amazonaws.com/v1/speech
+        """
+        if api_base is not None:
+            return api_base.rstrip("/") + "/v1/speech"
+
+        aws_region_name = litellm_params.get("aws_region_name", self.DEFAULT_REGION)
+        return f"https://polly.{aws_region_name}.amazonaws.com/v1/speech"
+
+    def is_ssml_input(self, input: str) -> bool:
+        """
+        Returns True if input is SSML, False otherwise.
+
+        Based on AWS Polly SSML requirements - must contain <speak> tag.
+        """
+        return "<speak>" in input or "<speak " in input
+
+    def _sign_polly_request(
+        self,
+        request_body: Dict[str, Any],
+        endpoint_url: str,
+        litellm_params: Dict,
+    ) -> Tuple[Dict[str, str], str]:
+        """
+        Sign the AWS Polly request using SigV4.
+
+        Returns:
+            Tuple of (signed_headers, json_body_string)
+        """
+        try:
+            from botocore.auth import SigV4Auth
+            from botocore.awsrequest import AWSRequest
+        except ImportError:
+            raise ImportError("Missing boto3 to call AWS Polly. Run 'pip install boto3'.")
+
+        # Get AWS region
+        aws_region_name = litellm_params.get("aws_region_name", self.DEFAULT_REGION)
+
+        # Get AWS credentials
+        credentials = self.get_credentials(
+            aws_access_key_id=litellm_params.get("aws_access_key_id"),
+            aws_secret_access_key=litellm_params.get("aws_secret_access_key"),
+            aws_session_token=litellm_params.get("aws_session_token"),
+            aws_region_name=aws_region_name,
+            aws_session_name=litellm_params.get("aws_session_name"),
+            aws_profile_name=litellm_params.get("aws_profile_name"),
+            aws_role_name=litellm_params.get("aws_role_name"),
+            aws_web_identity_token=litellm_params.get("aws_web_identity_token"),
+            aws_sts_endpoint=litellm_params.get("aws_sts_endpoint"),
+            aws_external_id=litellm_params.get("aws_external_id"),
+        )
+
+        # Serialize request body to JSON
+        json_body = json.dumps(request_body)
+
+        # Create headers for signing
+        headers = {
+            "Content-Type": "application/json",
+        }
+
+        # Create AWS request for signing
+        aws_request = AWSRequest(
+            method="POST",
+            url=endpoint_url,
+            data=json_body,
+            headers=headers,
+        )
+
+        # Sign the request
+        SigV4Auth(credentials, "polly", aws_region_name).add_auth(aws_request)
+
+        # Return signed headers and body
+        return dict(aws_request.headers), json_body
+
+    def transform_text_to_speech_request(
+        self,
+        model: str,
+        input: str,
+        voice: Optional[str],
+        optional_params: Dict,
+        litellm_params: Dict,
+        headers: dict,
+    ) -> TextToSpeechRequestData:
+        """
+        Transform OpenAI TTS request to AWS Polly SynthesizeSpeech format.
+
+        Supports:
+        - Native Polly voices (Joanna, Matthew, etc.)
+        - OpenAI voice mapping (alloy, echo, etc.)
+        - SSML input (auto-detected via <speak> tag)
+        - Multiple engines (neural, standard, long-form, generative)
+
+        Returns:
+            TextToSpeechRequestData: Contains signed request for Polly API
+        """
+        # Get voice (already mapped in main.py, or use default)
+        polly_voice = voice or self.DEFAULT_VOICE
+
+        # Get output format
+        output_format = optional_params.get("output_format", self.DEFAULT_OUTPUT_FORMAT)
+
+        # Get engine
+        engine = optional_params.get("engine", self.DEFAULT_ENGINE)
+
+        # Build request body
+        request_body: Dict[str, Any] = {
+            "Engine": engine,
+            "OutputFormat": output_format,
+            "Text": input,
+            "VoiceId": polly_voice,
+        }
+
+        # Auto-detect SSML
+        if self.is_ssml_input(input):
+            request_body["TextType"] = "ssml"
+        else:
+            request_body["TextType"] = "text"
+
+        # Add optional Polly parameters (already in AWS casing from map_openai_params)
+        for key in ["LanguageCode", "LexiconNames", "SampleRate"]:
+            if key in optional_params:
+                request_body[key] = optional_params[key]
+
+        # Get endpoint URL
+        endpoint_url = self.get_complete_url(
+            model=model,
+            api_base=litellm_params.get("api_base"),
+            litellm_params=litellm_params,
+        )
+
+        # Sign the request with AWS SigV4
+        signed_headers, json_body = self._sign_polly_request(
+            request_body=request_body,
+            endpoint_url=endpoint_url,
+            litellm_params=litellm_params,
+        )
+
+        # Return as ssml_body so the handler uses data= instead of json=
+        # This preserves the exact JSON string that was signed
+        return TextToSpeechRequestData(
+            ssml_body=json_body,
+            headers=signed_headers,
+        )
+
+    def transform_text_to_speech_response(
+        self,
+        model: str,
+        raw_response: httpx.Response,
+        logging_obj: "LiteLLMLoggingObj",
+    ) -> "HttpxBinaryResponseContent":
+        """
+        Transform AWS Polly response to standard format.
+
+        Polly returns the audio data directly in the response body.
+        """
+        from litellm.types.llms.openai import HttpxBinaryResponseContent
+
+        return HttpxBinaryResponseContent(raw_response)
+
@@ -46,6 +46,39 @@ class AmazonNovaEmbeddingConfig:
            elif k in self.get_supported_openai_params():
                optional_params[k] = v
        return optional_params
+    
+    def _parse_data_url(self, data_url: str) -> tuple:
+        """
+        Parse a data URL to extract the media type and base64 data.
+        
+        Args:
+            data_url: Data URL in format: data:image/jpeg;base64,/9j/4AAQ...
+        
+        Returns:
+            tuple: (media_type, base64_data)
+                media_type: e.g., "image/jpeg", "video/mp4", "audio/mpeg"
+                base64_data: The base64-encoded data without the prefix
+        """
+        if not data_url.startswith("data:"):
+            raise ValueError(f"Invalid data URL format: {data_url[:50]}...")
+        
+        # Split by comma to separate metadata from data
+        # Format: data:image/jpeg;base64,<base64_data>
+        if "," not in data_url:
+            raise ValueError(f"Invalid data URL format (missing comma): {data_url[:50]}...")
+        
+        metadata, base64_data = data_url.split(",", 1)
+        
+        # Extract media type from metadata
+        # Remove 'data:' prefix and ';base64' suffix
+        metadata = metadata[5:]  # Remove 'data:'
+        
+        if ";" in metadata:
+            media_type = metadata.split(";")[0]
+        else:
+            media_type = metadata
+        
+        return media_type, base64_data

    def _transform_request(
        self,
@@ -99,15 +132,58 @@ class AmazonNovaEmbeddingConfig:
        if "embeddingDimension" not in embedding_params:
            embedding_params["embeddingDimension"] = 3072
        
-        # For text input, add basic text structure if user hasn't provided text/image/video/audio
+        # For text/media input, add basic structure if user hasn't provided text/image/video/audio
        if "text" not in embedding_params and "image" not in embedding_params and "video" not in embedding_params and "audio" not in embedding_params:
-            # Default to text if no modality specified
-            if input.startswith("s3://"):
+            # Check if input is a data URL (e.g., data:image/jpeg;base64,...)
+            if input.startswith("data:"):
+                # Parse the data URL to extract media type and base64 data
+                media_type, base64_data = self._parse_data_url(input)
+                
+                if media_type.startswith("image/"):
+                    # Extract image format from MIME type (e.g., image/jpeg -> jpeg)
+                    image_format = media_type.split("/")[1].lower()
+                    # Nova API expects specific formats
+                    if image_format == "jpg":
+                        image_format = "jpeg"
+                    
+                    embedding_params["image"] = {
+                        "format": image_format,
+                        "source": {
+                            "bytes": base64_data
+                        }
+                    }
+                elif media_type.startswith("video/"):
+                    # Handle video data URLs
+                    video_format = media_type.split("/")[1].lower()
+                    embedding_params["video"] = {
+                        "format": video_format,
+                        "source": {
+                            "bytes": base64_data
+                        }
+                    }
+                elif media_type.startswith("audio/"):
+                    # Handle audio data URLs
+                    audio_format = media_type.split("/")[1].lower()
+                    embedding_params["audio"] = {
+                        "format": audio_format,
+                        "source": {
+                            "bytes": base64_data
+                        }
+                    }
+                else:
+                    # Fallback to text for unknown types
+                    embedding_params["text"] = {
+                        "value": input,
+                        "truncationMode": "END"
+                    }
+            elif input.startswith("s3://"):
+                # S3 URL - default to text for now, user should specify modality
                embedding_params["text"] = {
                    "source": {"s3Location": {"uri": input}},
                    "truncationMode": "END"  # Required by Nova API
                }
            else:
+                # Plain text input
                embedding_params["text"] = {
                    "value": input,
                    "truncationMode": "END"  # Required by Nova API
@@ -11,7 +11,12 @@ from litellm.types.llms.openai import (
    AllMessageValues,
    OpenAIImageGenerationOptionalParams,
 )
-from litellm.types.utils import ImageObject, ImageResponse
+from litellm.types.utils import (
+    ImageObject,
+    ImageResponse,
+    ImageUsage,
+    ImageUsageInputTokensDetails,
+)

 if TYPE_CHECKING:
    from litellm.litellm_core_utils.litellm_logging import Logging as _LiteLLMLoggingObj
@@ -73,6 +78,33 @@ class GoogleImageGenConfig(BaseImageGenerationConfig):
            "896x1280": "3:4",
        }
        return aspect_ratio_map.get(size, "1:1")
+    
+    def _transform_image_usage(self, usage_metadata: dict) -> ImageUsage:
+        """
+        Transform Gemini usageMetadata to ImageUsage format
+        """
+        input_tokens_details = ImageUsageInputTokensDetails(
+            image_tokens=0,
+            text_tokens=0,
+        )
+        
+        # Extract detailed token counts from promptTokensDetails
+        tokens_details = usage_metadata.get("promptTokensDetails", [])
+        for details in tokens_details:
+            if isinstance(details, dict):
+                modality = details.get("modality")
+                token_count = details.get("tokenCount", 0)
+                if modality == "TEXT":
+                    input_tokens_details.text_tokens = token_count
+                elif modality == "IMAGE":
+                    input_tokens_details.image_tokens = token_count
+        
+        return ImageUsage(
+            input_tokens=usage_metadata.get("promptTokenCount", 0),
+            input_tokens_details=input_tokens_details,
+            output_tokens=usage_metadata.get("candidatesTokenCount", 0),
+            total_tokens=usage_metadata.get("totalTokenCount", 0),
+        )

    def get_complete_url(
        self,
@@ -227,6 +259,10 @@ class GoogleImageGenConfig(BaseImageGenerationConfig):
                                b64_json=inline_data["data"],
                                url=None,
                            ))
+            
+            # Extract usage metadata for Gemini models
+            if "usageMetadata" in response_data:
+                model_response.usage = self._transform_image_usage(response_data["usageMetadata"])
        else:
            # Original Imagen format - predictions with generated images
            predictions = response_data.get("predictions", [])
@@ -555,9 +555,13 @@ class OpenAIChatCompletion(BaseLLM, BaseOpenAILLM):
            provider_config: Optional[BaseConfig] = None

            if custom_llm_provider is not None and model is not None:
-                provider_config = ProviderConfigManager.get_provider_chat_config(
-                    model=model, provider=LlmProviders(custom_llm_provider)
-                )
+                try:
+                    provider_config = ProviderConfigManager.get_provider_chat_config(
+                        model=model, provider=LlmProviders(custom_llm_provider)
+                    )
+                except ValueError:
+                    # JSON-configured providers may not be in LlmProviders enum
+                    provider_config = None

            if provider_config is None:
                provider_config = OpenAIConfig()
@@ -18,5 +18,12 @@
  "veniceai": {
    "base_url": "https://api.venice.ai/api/v1",
    "api_key_env": "VENICE_AI_API_KEY"
+  },
+  "xiaomi_mimo": {
+    "base_url": "https://api.xiaomimimo.com/v1",
+    "api_key_env": "XIAOMI_MIMO_API_KEY",
+    "param_mappings": {
+      "max_completion_tokens": "max_tokens"
+    }
  }
-}
+}
@@ -1476,6 +1476,7 @@ class VertexGeminiConfig(VertexAIBaseConfig, BaseConfig):
        cached_tokens: Optional[int] = None
        audio_tokens: Optional[int] = None
        text_tokens: Optional[int] = None
+        image_tokens: Optional[int] = None
        prompt_tokens_details: Optional[PromptTokensDetailsWrapper] = None
        reasoning_tokens: Optional[int] = None
        response_tokens: Optional[int] = None
@@ -1526,6 +1527,8 @@ class VertexGeminiConfig(VertexAIBaseConfig, BaseConfig):
                    audio_tokens = detail.get("tokenCount", 0)
                elif detail["modality"] == "TEXT":
                    text_tokens = detail.get("tokenCount", 0)
+                elif detail["modality"] == "IMAGE":
+                    image_tokens = detail.get("tokenCount", 0)
        if "thoughtsTokenCount" in usage_metadata:
            reasoning_tokens = usage_metadata["thoughtsTokenCount"]
            # Also add reasoning tokens to response_tokens_details
@@ -1546,6 +1549,7 @@ class VertexGeminiConfig(VertexAIBaseConfig, BaseConfig):
            cached_tokens=cached_tokens,
            audio_tokens=audio_tokens,
            text_tokens=text_tokens,
+            image_tokens=image_tokens,
        )

        completion_tokens = response_tokens or completion_response["usageMetadata"].get(
@@ -68,6 +68,7 @@ from litellm.constants import (
    DEFAULT_MOCK_RESPONSE_PROMPT_TOKEN_COUNT,
 )
 from litellm.exceptions import LiteLLMUnknownProvider
+from litellm.llms.openai_like.json_loader import JSONProviderRegistry
 from litellm.integrations.custom_logger import CustomLogger
 from litellm.litellm_core_utils.asyncify import run_async_function
 from litellm.litellm_core_utils.audio_utils.utils import (
@@ -104,10 +105,22 @@ from litellm.llms.vertex_ai.common_utils import (
 from litellm.realtime_api.main import _realtime_health_check
 from litellm.secret_managers.main import get_secret_bool, get_secret_str
 from litellm.types.router import GenericLiteLLMParams
-from litellm.types.utils import RawRequestTypedDict, StreamingChoices
+from litellm.types.utils import (
+    ModelResponseStream,
+    RawRequestTypedDict,
+    StreamingChoices,
+)
 from litellm.utils import (
+    Choices,
    CustomStreamWrapper,
+    EmbeddingResponse,
+    Message,
+    ModelResponse,
    ProviderConfigManager,
+    TextChoices,
+    TextCompletionResponse,
+    TextCompletionStreamWrapper,
+    TranscriptionResponse,
    Usage,
    _get_model_info_helper,
    add_provider_specific_params_to_optional_params,
@@ -165,8 +178,8 @@ from .llms.azure_ai.anthropic.handler import AzureAnthropicChatCompletion
 from .llms.azure_ai.embed import AzureAIEmbedding
 from .llms.bedrock.chat import BedrockConverseLLM, BedrockLLM
 from .llms.bedrock.embed.embedding import BedrockEmbedding
-from .llms.bedrock.image_generation.image_handler import BedrockImageGeneration
 from .llms.bedrock.image_edit.handler import BedrockImageEdit
+from .llms.bedrock.image_generation.image_handler import BedrockImageGeneration
 from .llms.bytez.chat.transformation import BytezChatConfig
 from .llms.clarifai.chat.transformation import ClarifaiConfig
 from .llms.codestral.completion.handler import CodestralTextCompletion
@@ -239,18 +252,6 @@ from .types.utils import (
    all_litellm_params,
 )

-from litellm.types.utils import ModelResponseStream
-from litellm.utils import (
-    Choices,
-    EmbeddingResponse,
-    Message,
-    ModelResponse,
-    TextChoices,
-    TextCompletionResponse,
-    TextCompletionStreamWrapper,
-    TranscriptionResponse,
-)
-
 ####### ENVIRONMENT VARIABLES ###################
 openai_chat_completions = OpenAIChatCompletion()
 openai_text_completions = OpenAITextCompletion()
@@ -2263,6 +2264,7 @@ def completion(  # type: ignore # noqa: PLR0915
            or custom_llm_provider == "wandb"
            or custom_llm_provider == "clarifai"
            or custom_llm_provider in litellm.openai_compatible_providers
+            or JSONProviderRegistry.exists(custom_llm_provider)  # JSON-configured providers
            or "ft:gpt-3.5-turbo" in model  # finetune gpt-3.5-turbo
        ):  # allow user to make an openai call with a custom base
            # note: if a user sets a custom base - we should ensure this works
@@ -6469,6 +6471,35 @@ def speech(  # noqa: PLR0915
            api_key=api_key,
            **kwargs,
        )
+    elif custom_llm_provider == "aws_polly":
+        from litellm.llms.aws_polly.text_to_speech.transformation import (
+            AWSPollyTextToSpeechConfig,
+        )
+
+        # AWS Polly Text-to-Speech
+        if text_to_speech_provider_config is None:
+            text_to_speech_provider_config = AWSPollyTextToSpeechConfig()
+
+        # Cast to specific AWS Polly config type to access dispatch method
+        aws_polly_config = cast(
+            AWSPollyTextToSpeechConfig, text_to_speech_provider_config
+        )
+
+        response = aws_polly_config.dispatch_text_to_speech(
+            model=model,
+            input=input,
+            voice=voice,
+            optional_params=optional_params,
+            litellm_params_dict=litellm_params_dict,
+            logging_obj=logging_obj,
+            timeout=timeout,
+            extra_headers=extra_headers,
+            base_llm_http_handler=base_llm_http_handler,
+            aspeech=aspeech or False,
+            api_base=api_base,
+            api_key=api_key,
+            **kwargs,
+        )

    if response is None:
        raise Exception(
@@ -6903,6 +6934,7 @@ def _get_encoding():
    global _encoding_cache
    if _encoding_cache is None:
        import sys
+
        # Access via module to trigger __getattr__ if not cached
        _encoding_cache = sys.modules[__name__].encoding
    return _encoding_cache
@@ -15364,6 +15364,34 @@
            "video"
        ]
    },
+    "gemini/veo-3.1-fast-generate-001": {
+        "litellm_provider": "gemini",
+        "max_input_tokens": 1024,
+        "max_tokens": 1024,
+        "mode": "video_generation",
+        "output_cost_per_second": 0.15,
+        "source": "https://ai.google.dev/gemini-api/docs/video",
+        "supported_modalities": [
+            "text"
+        ],
+        "supported_output_modalities": [
+            "video"
+        ]
+    },
+    "gemini/veo-3.1-generate-001": {
+        "litellm_provider": "gemini",
+        "max_input_tokens": 1024,
+        "max_tokens": 1024,
+        "mode": "video_generation",
+        "output_cost_per_second": 0.40,
+        "source": "https://ai.google.dev/gemini-api/docs/video",
+        "supported_modalities": [
+            "text"
+        ],
+        "supported_output_modalities": [
+            "video"
+        ]
+    },
    "github_copilot/claude-haiku-4.5": {
        "litellm_provider": "github_copilot",
        "max_input_tokens": 128000,
@@ -24594,27 +24622,6 @@
        "mode": "image_generation",
        "output_cost_per_image": 0.04
    },
-    "stability.stable-image-core-v1:1": {
-        "litellm_provider": "bedrock",
-        "max_input_tokens": 77,
-        "max_tokens": 77,
-        "mode": "image_generation",
-        "output_cost_per_image": 0.04
-    },
-    "stability.stable-image-ultra-v1:0": {
-        "litellm_provider": "bedrock",
-        "max_input_tokens": 77,
-        "max_tokens": 77,
-        "mode": "image_generation",
-        "output_cost_per_image": 0.14
-    },
-    "stability.stable-image-ultra-v1:1": {
-        "litellm_provider": "bedrock",
-        "max_input_tokens": 77,
-        "max_tokens": 77,
-        "mode": "image_generation",
-        "output_cost_per_image": 0.14
-    },
    "stability.stable-conservative-upscale-v1:0": {
        "litellm_provider": "bedrock",
        "max_input_tokens": 77,
@@ -24693,6 +24700,27 @@
        "mode": "image_edit",
        "output_cost_per_image": 0.08
    },
+    "stability.stable-image-core-v1:1": {
+        "litellm_provider": "bedrock",
+        "max_input_tokens": 77,
+        "max_tokens": 77,
+        "mode": "image_generation",
+        "output_cost_per_image": 0.04
+    },
+    "stability.stable-image-ultra-v1:0": {
+        "litellm_provider": "bedrock",
+        "max_input_tokens": 77,
+        "max_tokens": 77,
+        "mode": "image_generation",
+        "output_cost_per_image": 0.14
+    },
+    "stability.stable-image-ultra-v1:1": {
+        "litellm_provider": "bedrock",
+        "max_input_tokens": 77,
+        "max_tokens": 77,
+        "mode": "image_generation",
+        "output_cost_per_image": 0.14
+    },
    "standard/1024-x-1024/dall-e-3": {
        "input_cost_per_pixel": 3.81469e-08,
        "litellm_provider": "openai",
@@ -25395,6 +25423,42 @@
            "/v1/audio/speech"
        ]
    },
+    "aws_polly/standard": {
+        "input_cost_per_character": 4e-06,
+        "litellm_provider": "aws_polly",
+        "mode": "audio_speech",
+        "supported_endpoints": [
+            "/v1/audio/speech"
+        ],
+        "source": "https://aws.amazon.com/polly/pricing/"
+    },
+    "aws_polly/neural": {
+        "input_cost_per_character": 1.6e-05,
+        "litellm_provider": "aws_polly",
+        "mode": "audio_speech",
+        "supported_endpoints": [
+            "/v1/audio/speech"
+        ],
+        "source": "https://aws.amazon.com/polly/pricing/"
+    },
+    "aws_polly/long-form": {
+        "input_cost_per_character": 1e-04,
+        "litellm_provider": "aws_polly",
+        "mode": "audio_speech",
+        "supported_endpoints": [
+            "/v1/audio/speech"
+        ],
+        "source": "https://aws.amazon.com/polly/pricing/"
+    },
+    "aws_polly/generative": {
+        "input_cost_per_character": 3e-05,
+        "litellm_provider": "aws_polly",
+        "mode": "audio_speech",
+        "supported_endpoints": [
+            "/v1/audio/speech"
+        ],
+        "source": "https://aws.amazon.com/polly/pricing/"
+    },
    "us.amazon.nova-lite-v1:0": {
        "input_cost_per_token": 6e-08,
        "litellm_provider": "bedrock_converse",
@@ -28115,6 +28179,34 @@
            "video"
        ]
    },
+    "vertex_ai/veo-3.1-generate-001": {
+        "litellm_provider": "vertex_ai-video-models",
+        "max_input_tokens": 1024,
+        "max_tokens": 1024,
+        "mode": "video_generation",
+        "output_cost_per_second": 0.4,
+        "source": "https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/veo",
+        "supported_modalities": [
+            "text"
+        ],
+        "supported_output_modalities": [
+            "video"
+        ]
+    },
+    "vertex_ai/veo-3.1-fast-generate-001": {
+        "litellm_provider": "vertex_ai-video-models",
+        "max_input_tokens": 1024,
+        "max_tokens": 1024,
+        "mode": "video_generation",
+        "output_cost_per_second": 0.15,
+        "source": "https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/veo",
+        "supported_modalities": [
+            "text"
+        ],
+        "supported_output_modalities": [
+            "video"
+        ]
+    },
    "voyage/rerank-2": {
        "input_cost_per_token": 5e-08,
        "litellm_provider": "voyage",
--- a/Show More
+++ b/Show More