diff --git a/.github/workflows/ghcr_deploy.yml b/.github/workflows/ghcr_deploy.yml
index aa032972b80..f67538a4272 100644
--- a/.github/workflows/ghcr_deploy.yml
+++ b/.github/workflows/ghcr_deploy.yml
@@ -320,72 +320,36 @@ jobs:
         run: |
           echo "REPO_OWNER=`echo ${{github.repository_owner}} | tr '[:upper:]' '[:lower:]'`" >>${GITHUB_ENV}
     
-      - name: Get LiteLLM Latest Tag
-        id: current_app_tag
-        shell: bash
-        run: |
-          LATEST_TAG=$(git describe --tags --exclude "*dev*" --abbrev=0)
-          if [ -z "${LATEST_TAG}" ]; then
-            echo "latest_tag=latest" | tee -a $GITHUB_OUTPUT
-          else
-            echo "latest_tag=${LATEST_TAG}" | tee -a $GITHUB_OUTPUT
-          fi
-
-      - name: Get last published chart version
-        id: current_version
-        shell: bash
-        run: |
-          CHART_LIST=$(helm show chart oci://${{ env.REGISTRY }}/${{ env.REPO_OWNER }}/${{ env.CHART_NAME }} 2>/dev/null || true)
-          if [ -z "${CHART_LIST}" ]; then
-            echo "current-version=1.0.0" | tee -a $GITHUB_OUTPUT
-          else
-            # Extract version and strip any prerelease suffix (e.g., 1.0.5-latest -> 1.0.5)
-            VERSION=$(printf '%s' "${CHART_LIST}" | grep '^version:' | awk 'BEGIN{FS=":"}{print $2}' | tr -d " " | cut -d'-' -f1)
-            echo "current-version=${VERSION}" | tee -a $GITHUB_OUTPUT
-          fi
-        env:
-          HELM_EXPERIMENTAL_OCI: '1'
-
-      # Automatically update the helm chart version one "patch" level
-      - name: Bump release version
-        id: bump_version
-        uses: christian-draeger/increment-semantic-version@1.1.0
-        with:
-          current-version: ${{ steps.current_version.outputs.current-version || '1.0.0' }}
-          version-fragment: 'bug'
-
-      # Add suffix for non-stable releases (semantic versioning)
+      # Sync Helm chart version with LiteLLM release version (1-1 versioning)
+      # This allows users to easily map Helm chart versions to LiteLLM versions
+      # See: https://codefresh.io/docs/docs/ci-cd-guides/helm-best-practices/
       - name: Calculate chart and app versions
         id: chart_version
         shell: bash
         run: |
-          BASE_VERSION="${{ steps.bump_version.outputs.next-version || '1.0.0' }}"
-          RELEASE_TYPE="${{ github.event.inputs.release_type }}"
           INPUT_TAG="${{ github.event.inputs.tag }}"
+          RELEASE_TYPE="${{ github.event.inputs.release_type }}"
 
-          # Chart version (independent Helm chart versioning with release type suffix)
-          if [ "$RELEASE_TYPE" = "stable" ]; then
-            echo "version=${BASE_VERSION}" | tee -a $GITHUB_OUTPUT
-          else
-            echo "version=${BASE_VERSION}-${RELEASE_TYPE}" | tee -a $GITHUB_OUTPUT
+          # Chart version = LiteLLM version without 'v' prefix (Helm semver convention)
+          # v1.81.0 -> 1.81.0, v1.81.0.rc.1 -> 1.81.0.rc.1
+          CHART_VERSION="${INPUT_TAG#v}"
+
+          # Add suffix for 'latest' releases (rc already has suffix in tag)
+          if [ "$RELEASE_TYPE" = "latest" ]; then
+            CHART_VERSION="${CHART_VERSION}-latest"
           fi
 
-          # App version (must match Docker tags)
-          # stable/rc releases: Docker creates main-{tag}, so use the tag
-          # latest/dev releases: Docker only creates main-{release_type}, so use release_type
-          if [ "$RELEASE_TYPE" = "stable" ] || [ "$RELEASE_TYPE" = "rc" ]; then
-            APP_VERSION="${INPUT_TAG}"
-          else
-            APP_VERSION="${RELEASE_TYPE}"
-          fi
+          # App version = Docker tag (keeps 'v' prefix to match Docker image tags)
+          APP_VERSION="${INPUT_TAG}"
 
+          echo "version=${CHART_VERSION}" | tee -a $GITHUB_OUTPUT
           echo "app_version=${APP_VERSION}" | tee -a $GITHUB_OUTPUT
 
       - uses: ./.github/actions/helm-oci-chart-releaser
         with:
           name: ${{ env.CHART_NAME }}
           repository: ${{ env.REPO_OWNER }}
-          tag: ${{ github.event.inputs.chartVersion || steps.chart_version.outputs.version || '1.0.0' }}
+          tag: ${{ steps.chart_version.outputs.version }}
           app_version: ${{ steps.chart_version.outputs.app_version }}
           path: deploy/charts/${{ env.CHART_NAME }}
           registry: ${{ env.REGISTRY }}
diff --git a/.github/workflows/ghcr_helm_deploy.yml b/.github/workflows/ghcr_helm_deploy.yml
index f78dc6f0f3f..21b2eaafe19 100644
--- a/.github/workflows/ghcr_helm_deploy.yml
+++ b/.github/workflows/ghcr_helm_deploy.yml
@@ -1,10 +1,12 @@
-# this workflow is triggered by an API call when there is a new PyPI release of LiteLLM
+# Standalone workflow to publish LiteLLM Helm Chart
+# Note: The main ghcr_deploy.yml workflow also publishes the Helm chart as part of a full release
 name: Build, Publish LiteLLM Helm Chart. New Release
 on:
   workflow_dispatch:
     inputs:
-      chartVersion:
-        description: "Update the helm chart's version to this"
+      tag:
+        description: "LiteLLM version tag (e.g., v1.81.0)"
+        required: true
 
 # Defines two custom environment variables for the workflow. Used for the Container registry domain, and a name for the Docker image that this workflow builds.
 env:
@@ -31,24 +33,22 @@ jobs:
         run: |
           echo "REPO_OWNER=`echo ${{github.repository_owner}} | tr '[:upper:]' '[:lower:]'`" >>${GITHUB_ENV}
 
-      - name: Get LiteLLM Latest Tag
-        id: current_app_tag
-        uses: WyriHaximus/github-action-get-previous-tag@v1.3.0
-
-      - name: Get last published chart version
-        id: current_version
+      # Sync Helm chart version with LiteLLM release version (1-1 versioning)
+      - name: Calculate chart and app versions
+        id: chart_version
         shell: bash
-        run: helm show chart oci://${{ env.REGISTRY }}/${{ env.REPO_OWNER }}/litellm-helm | grep '^version:' | awk 'BEGIN{FS=":"}{print "current-version="$2}' | tr -d " " | tee -a $GITHUB_OUTPUT
-        env:
-          HELM_EXPERIMENTAL_OCI: '1'
+        run: |
+          INPUT_TAG="${{ github.event.inputs.tag }}"
 
-      # Automatically update the helm chart version one "patch" level
-      - name: Bump release version
-        id: bump_version
-        uses: christian-draeger/increment-semantic-version@1.1.0
-        with:
-          current-version: ${{ steps.current_version.outputs.current-version || '0.1.0' }}
-          version-fragment: 'bug'
+          # Chart version = LiteLLM version without 'v' prefix
+          # v1.81.0 -> 1.81.0
+          CHART_VERSION="${INPUT_TAG#v}"
+
+          # App version = Docker tag (keeps 'v' prefix)
+          APP_VERSION="${INPUT_TAG}"
+
+          echo "version=${CHART_VERSION}" | tee -a $GITHUB_OUTPUT
+          echo "app_version=${APP_VERSION}" | tee -a $GITHUB_OUTPUT
 
       - name: Lint helm chart
         run: helm lint deploy/charts/litellm-helm
@@ -57,8 +57,8 @@ jobs:
         with:
           name: litellm-helm
           repository: ${{ env.REPO_OWNER }}
-          tag: ${{ github.event.inputs.chartVersion || steps.bump_version.outputs.next-version || '0.1.0' }}
-          app_version: ${{ steps.current_app_tag.outputs.tag || 'latest' }}
+          tag: ${{ steps.chart_version.outputs.version }}
+          app_version: ${{ steps.chart_version.outputs.app_version }}
           path: deploy/charts/litellm-helm
           registry: ${{ env.REGISTRY }}
           registry_username: ${{ github.actor }}
diff --git a/docker/prod_entrypoint.sh b/docker/prod_entrypoint.sh
index 1fc09d2c864..28d1bdcc294 100644
--- a/docker/prod_entrypoint.sh
+++ b/docker/prod_entrypoint.sh
@@ -2,6 +2,7 @@
 
 if [ "$SEPARATE_HEALTH_APP" = "1" ]; then
     export LITELLM_ARGS="$@"
+    export SUPERVISORD_STOPWAITSECS="${SUPERVISORD_STOPWAITSECS:-3600}"
     exec supervisord -c /etc/supervisord.conf
 fi
 
diff --git a/docker/supervisord.conf b/docker/supervisord.conf
index 877335804fe..ba9d99d18a5 100644
--- a/docker/supervisord.conf
+++ b/docker/supervisord.conf
@@ -16,6 +16,7 @@ priority=1
 exitcodes=0
 stopasgroup=true
 killasgroup=true
+stopwaitsecs=%(ENV_SUPERVISORD_STOPWAITSECS)s
 stdout_logfile=/dev/stdout
 stderr_logfile=/dev/stderr
 stdout_logfile_maxbytes = 0
@@ -31,6 +32,7 @@ priority=2
 exitcodes=0
 stopasgroup=true
 killasgroup=true
+stopwaitsecs=%(ENV_SUPERVISORD_STOPWAITSECS)s
 stdout_logfile=/dev/stdout
 stderr_logfile=/dev/stderr
 stdout_logfile_maxbytes = 0
diff --git a/docs/my-website/docs/completion/json_mode.md b/docs/my-website/docs/completion/json_mode.md
index 0122e202610..14477f99153 100644
--- a/docs/my-website/docs/completion/json_mode.md
+++ b/docs/my-website/docs/completion/json_mode.md
@@ -341,4 +341,90 @@ curl http://0.0.0.0:4000/v1/chat/completions \
 ```
 
 </TabItem>
-</Tabs>
\ No newline at end of file
+</Tabs>
+
+## Gemini - Native JSON Schema Format (Gemini 2.0+)
+
+Gemini 2.0+ models automatically use the native `responseJsonSchema` parameter, which provides better compatibility with standard JSON Schema format.
+
+### Benefits (Gemini 2.0+):
+- Standard JSON Schema format (lowercase types like `string`, `object`)
+- Supports `additionalProperties: false` for stricter validation
+- Better compatibility with Pydantic's `model_json_schema()`
+- No `propertyOrdering` required
+
+### Usage
+
+<Tabs>
+<TabItem value="sdk" label="SDK">
+
+```python
+from litellm import completion
+from pydantic import BaseModel
+
+class UserInfo(BaseModel):
+    name: str
+    age: int
+
+response = completion(
+    model="gemini/gemini-2.0-flash",
+    messages=[{"role": "user", "content": "Extract: John is 25 years old"}],
+    response_format={
+        "type": "json_schema",
+        "json_schema": {
+            "name": "user_info",
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string"},
+                    "age": {"type": "integer"}
+                },
+                "required": ["name", "age"],
+                "additionalProperties": False  # Supported on Gemini 2.0+
+            }
+        }
+    }
+)
+```
+
+</TabItem>
+<TabItem value="proxy" label="PROXY">
+
+```bash
+curl http://0.0.0.0:4000/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $LITELLM_API_KEY" \
+  -d '{
+    "model": "gemini-2.0-flash",
+    "messages": [
+        {"role": "user", "content": "Extract: John is 25 years old"}
+    ],
+    "response_format": {
+        "type": "json_schema",
+        "json_schema": {
+            "name": "user_info",
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string"},
+                    "age": {"type": "integer"}
+                },
+                "required": ["name", "age"],
+                "additionalProperties": false
+            }
+        }
+    }
+  }'
+```
+
+</TabItem>
+</Tabs>
+
+### Model Behavior
+
+| Model | Format Used | `additionalProperties` Support |
+|-------|-------------|-------------------------------|
+| Gemini 2.0+ | `responseJsonSchema` (JSON Schema) | ✅ Yes |
+| Gemini 1.5 | `responseSchema` (OpenAPI) | ❌ No |
+
+LiteLLM automatically selects the appropriate format based on the model version.
\ No newline at end of file
diff --git a/docs/my-website/docs/providers/chatgpt.md b/docs/my-website/docs/providers/chatgpt.md
new file mode 100644
index 00000000000..156bbf99df6
--- /dev/null
+++ b/docs/my-website/docs/providers/chatgpt.md
@@ -0,0 +1,84 @@
+# ChatGPT Subscription
+
+Use ChatGPT Pro/Max subscription models through LiteLLM with OAuth device flow authentication.
+
+| Property | Details |
+|-------|-------|
+| Description | ChatGPT subscription access (Codex + GPT-5.2 family) via ChatGPT backend API |
+| Provider Route on LiteLLM | `chatgpt/` |
+| Supported Endpoints | `/responses`, `/chat/completions` (bridged to Responses for supported models) |
+| API Reference | https://chatgpt.com |
+
+ChatGPT subscription access is native to the Responses API. Chat Completions requests are bridged to Responses for supported models (for example `chatgpt/gpt-5.2`).
+
+Notes:
+- The ChatGPT subscription backend rejects token limit fields (`max_tokens`, `max_output_tokens`, `max_completion_tokens`) and `metadata`. LiteLLM strips these fields for this provider.
+- `/v1/chat/completions` honors `stream`. When `stream` is false (default), LiteLLM aggregates the Responses stream into a single JSON response.
+
+## Authentication
+
+ChatGPT subscription access uses an OAuth device code flow:
+
+1. LiteLLM prints a device code and verification URL
+2. Open the URL, sign in, and enter the code
+3. Tokens are stored locally for reuse
+
+## Usage - LiteLLM Python SDK
+
+### Responses (recommended for Codex models)
+
+```python showLineNumbers title="ChatGPT Responses"
+import litellm
+
+response = litellm.responses(
+    model="chatgpt/gpt-5.2-codex",
+    input="Write a Python hello world"
+)
+
+print(response)
+```
+
+### Chat Completions (bridged to Responses)
+
+```python showLineNumbers title="ChatGPT Chat Completions"
+import litellm
+
+response = litellm.completion(
+    model="chatgpt/gpt-5.2",
+    messages=[{"role": "user", "content": "Write a Python hello world"}]
+)
+
+print(response)
+```
+
+## Usage - LiteLLM Proxy
+
+```yaml showLineNumbers title="config.yaml"
+model_list:
+  - model_name: chatgpt/gpt-5.2
+    model_info:
+      mode: responses
+    litellm_params:
+      model: chatgpt/gpt-5.2
+  - model_name: chatgpt/gpt-5.2-codex
+    model_info:
+      mode: responses
+    litellm_params:
+      model: chatgpt/gpt-5.2-codex
+```
+
+```bash showLineNumbers title="Start LiteLLM Proxy"
+litellm --config config.yaml
+```
+
+## Configuration
+
+### Environment Variables
+
+- `CHATGPT_TOKEN_DIR`: Custom token storage directory
+- `CHATGPT_AUTH_FILE`: Auth file name (default: `auth.json`)
+- `CHATGPT_API_BASE`: Override API base (default: `https://chatgpt.com/backend-api/codex`)
+- `OPENAI_CHATGPT_API_BASE`: Alias for `CHATGPT_API_BASE`
+- `CHATGPT_ORIGINATOR`: Override the `originator` header value
+- `CHATGPT_USER_AGENT`: Override the `User-Agent` header value
+- `CHATGPT_USER_AGENT_SUFFIX`: Optional suffix appended to the `User-Agent` header
diff --git a/docs/my-website/docs/providers/gemini.md b/docs/my-website/docs/providers/gemini.md
index 11866e68d15..23a02f7365c 100644
--- a/docs/my-website/docs/providers/gemini.md
+++ b/docs/my-website/docs/providers/gemini.md
@@ -15,6 +15,17 @@ import TabItem from '@theme/TabItem';
 
 <br />
 
+:::tip Gemini API vs Vertex AI
+| Model Format | Provider | Auth Required |
+|-------------|----------|---------------|
+| `gemini/gemini-2.0-flash` | Gemini API | `GEMINI_API_KEY` (simple API key) |
+| `vertex_ai/gemini-2.0-flash` | Vertex AI | GCP credentials + project |
+| `gemini-2.0-flash` (no prefix) | Vertex AI | GCP credentials + project |
+
+**If you just want to use an API key** (like OpenAI), use the `gemini/` prefix.
+
+Models without a prefix default to Vertex AI which requires full GCP authentication.
+:::
 
 ## API Keys
 
diff --git a/docs/my-website/docs/providers/vertex.md b/docs/my-website/docs/providers/vertex.md
index c47d7d914a8..63e4dceec00 100644
--- a/docs/my-website/docs/providers/vertex.md
+++ b/docs/my-website/docs/providers/vertex.md
@@ -14,6 +14,17 @@ import TabItem from '@theme/TabItem';
 | Base URL | 1. Regional endpoints<br/>`https://{vertex_location}-aiplatform.googleapis.com/`<br/>2. Global endpoints (limited availability)<br/>`https://aiplatform.googleapis.com/`|
 | Supported Operations | [`/chat/completions`](#sample-usage), `/completions`, [`/embeddings`](#embedding-models), [`/audio/speech`](#text-to-speech-apis), [`/fine_tuning`](#fine-tuning-apis), [`/batches`](#batch-apis), [`/files`](#batch-apis), [`/images`](#image-generation-models), [`/rerank`](#rerank-api) |
 
+:::tip Vertex AI vs Gemini API
+| Model Format | Provider | Auth Required |
+|-------------|----------|---------------|
+| `vertex_ai/gemini-2.0-flash` | Vertex AI | GCP credentials + project |
+| `gemini-2.0-flash` (no prefix) | Vertex AI | GCP credentials + project |
+| `gemini/gemini-2.0-flash` | Gemini API | `GEMINI_API_KEY` (simple API key) |
+
+**If you just want to use an API key** (like OpenAI), use the `gemini/` prefix instead. See [Gemini - Google AI Studio](./gemini.md).
+
+Models without a prefix default to Vertex AI which requires GCP authentication.
+:::
 
 <br />
 <br />
diff --git a/docs/my-website/docs/proxy/config_settings.md b/docs/my-website/docs/proxy/config_settings.md
index 8b4514f5688..67fffc13e4b 100644
--- a/docs/my-website/docs/proxy/config_settings.md
+++ b/docs/my-website/docs/proxy/config_settings.md
@@ -397,6 +397,7 @@ router_settings:
 | AUDIO_SPEECH_CHUNK_SIZE | Chunk size for audio speech processing. Default is 1024
 | ANTHROPIC_API_KEY | API key for Anthropic service
 | ANTHROPIC_API_BASE | Base URL for Anthropic API. Default is https://api.anthropic.com
+| ANTHROPIC_TOKEN_COUNTING_BETA_VERSION | Beta version header for Anthropic token counting API. Default is `token-counting-2024-11-01`
 | AWS_ACCESS_KEY_ID | Access Key ID for AWS services
 | AWS_BATCH_ROLE_ARN | ARN of the AWS IAM role for batch operations
 | AWS_DEFAULT_REGION | Default AWS region for service interactions when AWS_REGION is not set
@@ -412,6 +413,8 @@ router_settings:
 | AWS_WEB_IDENTITY_TOKEN | Web identity token for AWS
 | AWS_WEB_IDENTITY_TOKEN_FILE | Path to file containing web identity token for AWS
 | AZURE_API_VERSION | Version of the Azure API being used
+| AZURE_AI_API_BASE | Base URL for Azure AI services (e.g., Azure AI Anthropic)
+| AZURE_AI_API_KEY | API key for Azure AI services (e.g., Azure AI Anthropic)
 | AZURE_AUTHORITY_HOST | Azure authority host URL
 | AZURE_CERTIFICATE_PASSWORD | Password for Azure OpenAI certificate
 | AZURE_CLIENT_ID | Client ID for Azure services
@@ -449,6 +452,13 @@ router_settings:
 | BRAINTRUST_API_KEY | API key for Braintrust integration
 | BRAINTRUST_API_BASE | Base URL for Braintrust API. Default is https://api.braintrustdata.com/v1
 | CACHED_STREAMING_CHUNK_DELAY | Delay in seconds for cached streaming chunks. Default is 0.02
+| CHATGPT_API_BASE | Base URL for ChatGPT API. Default is https://chatgpt.com/backend-api/codex
+| CHATGPT_AUTH_FILE | Filename for ChatGPT authentication data. Default is "auth.json"
+| CHATGPT_DEFAULT_INSTRUCTIONS | Default system instructions for ChatGPT provider
+| CHATGPT_ORIGINATOR | Originator identifier for ChatGPT API requests. Default is "codex_cli_rs"
+| CHATGPT_TOKEN_DIR | Directory to store ChatGPT authentication tokens. Default is "~/.config/litellm/chatgpt"
+| CHATGPT_USER_AGENT | Custom user agent string for ChatGPT API requests
+| CHATGPT_USER_AGENT_SUFFIX | Suffix to append to the ChatGPT user agent string
 | CIRCLE_OIDC_TOKEN | OpenID Connect token for CircleCI
 | CIRCLE_OIDC_TOKEN_V2 | Version 2 of the OpenID Connect token for CircleCI
 | CLOUDZERO_API_KEY | CloudZero API key for authentication
@@ -794,6 +804,7 @@ router_settings:
 | OPENAI_BASE_URL | Base URL for OpenAI API
 | OPENAI_API_BASE | Base URL for OpenAI API. Default is https://api.openai.com/
 | OPENAI_API_KEY | API key for OpenAI services
+| OPENAI_CHATGPT_API_BASE | Alternative to CHATGPT_API_BASE. Base URL for ChatGPT API
 | OPENAI_FILE_SEARCH_COST_PER_1K_CALLS | Cost per 1000 calls for OpenAI file search. Default is 0.0025
 | OPENAI_ORGANIZATION | Organization identifier for OpenAI
 | OPENID_BASE_URL | Base URL for OpenID Connect services
@@ -867,6 +878,7 @@ router_settings:
 | SECRET_MANAGER_REFRESH_INTERVAL | Refresh interval in seconds for secret manager. Default is 86400 (24 hours)
 | SEPARATE_HEALTH_APP | If set to '1', runs health endpoints on a separate ASGI app and port. Default: '0'.
 | SEPARATE_HEALTH_PORT | Port for the separate health endpoints app. Only used if SEPARATE_HEALTH_APP=1. Default: 4001.
+| SUPERVISORD_STOPWAITSECS | Upper bound timeout in seconds for graceful shutdown when SEPARATE_HEALTH_APP=1. Default: 3600 (1 hour).
 | SERVER_ROOT_PATH | Root path for the server application
 | SEND_USER_API_KEY_ALIAS | Flag to send user API key alias to Zscaler AI Guard. Default is False
 | SEND_USER_API_KEY_TEAM_ID | Flag to send user API key team ID to Zscaler AI Guard. Default is False
diff --git a/docs/my-website/docs/proxy/prod.md b/docs/my-website/docs/proxy/prod.md
index 9216b0fbf30..a42d91a7d5f 100644
--- a/docs/my-website/docs/proxy/prod.md
+++ b/docs/my-website/docs/proxy/prod.md
@@ -277,8 +277,13 @@ Set the following environment variable(s):
 ```bash
 SEPARATE_HEALTH_APP="1" # Default "0" 
 SEPARATE_HEALTH_PORT="8001" # Default "4001", Works only if `SEPARATE_HEALTH_APP` is "1"
+SUPERVISORD_STOPWAITSECS="3600" # Optional: Upper bound timeout in seconds for graceful shutdown. Default: 3600 (1 hour). Only used when SEPARATE_HEALTH_APP=1.
 ```
 
+**Graceful Shutdown:**
+
+Previously, `stopwaitsecs` was not set, defaulting to 10 seconds and causing in-flight requests to fail. `SUPERVISORD_STOPWAITSECS` (default: 3600) provides an upper bound for graceful shutdown, allowing uvicorn to wait for all in-flight requests to complete.
+
 <video controls width="100%" style={{ borderRadius: '8px', marginBottom: '1em' }}>
   <source src="https://cdn.loom.com/sessions/thumbnails/b08be303331246b88fdc053940d03281-1718990992822.mp4" type="video/mp4" />
   Your browser does not support the video tag.
diff --git a/docs/my-website/docs/proxy/users.md b/docs/my-website/docs/proxy/users.md
index 3e0e00dfa52..a389f0bd443 100644
--- a/docs/my-website/docs/proxy/users.md
+++ b/docs/my-website/docs/proxy/users.md
@@ -545,6 +545,26 @@ You can set:
 - max parallel requests
 - rpm / tpm limits per model for a given key
 
+### TPM Rate Limit Type (Input/Output/Total)
+
+By default, TPM (tokens per minute) rate limits count **total tokens** (input + output). You can configure this to count only input tokens or only output tokens instead.
+
+Set `token_rate_limit_type` in your `config.yaml`:
+
+```yaml
+general_settings:
+  master_key: sk-1234
+  token_rate_limit_type: "output"  # Options: "input", "output", "total" (default)
+```
+
+| Value | Description |
+|-------|-------------|
+| `total` | Count total tokens (prompt + completion). **Default behavior.** |
+| `input` | Count only prompt/input tokens |
+| `output` | Count only completion/output tokens |
+
+This setting applies globally to all TPM rate limit checks (keys, users, teams, etc.).
+
 
 <Tabs>
 <TabItem value="per-team" label="Per Team">
diff --git a/docs/my-website/docs/tutorials/claude_code_max_subscription.md b/docs/my-website/docs/tutorials/claude_code_max_subscription.md
new file mode 100644
index 00000000000..399051d41ea
--- /dev/null
+++ b/docs/my-website/docs/tutorials/claude_code_max_subscription.md
@@ -0,0 +1,357 @@
+import Image from '@theme/IdealImage';
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Using Claude Code Max Subscription
+
+<div style={{ textAlign: 'center' }}>
+<Image img={require('../../img/claude_code_max.png')} style={{ width: '100%', maxWidth: '800px', height: 'auto' }} />
+
+Route Claude Code Max subscription traffic through LiteLLM AI Gateway.
+</div>
+
+**Why Claude Code Max over direct API?**
+- **Lower costs** — Claude Code Max subscriptions are cheaper for Claude Code power users than per-token API pricing
+
+**Why route through LiteLLM?**
+- **Cost attribution** — Track spend per user, team, or key
+- **Budgets & rate limits** — Set spending caps and request limits
+- **Guardrails** — Apply content filtering and safety controls to all requests
+
+
+
+## Quick Start Video
+
+Watch the end-to-end walkthrough of setting up Claude Code with LiteLLM Gateway:
+
+<iframe width="840" height="500" src="https://www.loom.com/embed/2d069b9e3bcc4cecaa5eb27a72ba7b3c" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe>
+
+## Prerequisites
+
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) installed
+- Claude Max subscription
+- LiteLLM Gateway running
+
+## Step 1: Configure LiteLLM Proxy
+
+Create a `config.yaml` with the critical `forward_client_headers_to_llm_api: true` setting:
+
+```yaml showLineNumbers title="config.yaml"
+model_list:
+  - model_name: anthropic-claude
+    litellm_params:
+      model: anthropic/claude-sonnet-4-20250514
+
+  - model_name: claude-3-5-sonnet-20241022
+    litellm_params:
+      model: anthropic/claude-3-5-sonnet-20241022
+
+  - model_name: claude-3-5-haiku-20241022
+    litellm_params:
+      model: anthropic/claude-3-5-haiku-20241022
+
+general_settings:
+  forward_client_headers_to_llm_api: true  # Required: forwards OAuth token to Anthropic
+
+litellm_settings:
+  master_key: os.environ/LITELLM_MASTER_KEY
+```
+
+:::info Why `forward_client_headers_to_llm_api`?
+
+This setting forwards the user's OAuth token (in the `Authorization` header) through LiteLLM to the Anthropic API, enabling per-user authentication with their Max subscription while LiteLLM handles tracking and controls.
+
+:::
+
+## Step 2: Start LiteLLM Proxy
+
+```bash showLineNumbers title="Start LiteLLM Proxy"
+litellm --config /path/to/config.yaml
+
+# RUNNING on http://0.0.0.0:4000
+```
+
+## Walkthrough
+
+### Part 1: Create a Virtual Key in LiteLLM
+
+Navigate to the LiteLLM Dashboard and create a new virtual key for Claude Code usage.
+
+#### 1.1 Open Virtual Keys Page
+
+Navigate to the Virtual Keys section in the LiteLLM Dashboard.
+
+<Image img={require('../../img/claude_code_max/step1.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+#### 1.2 Click "Create New Key"
+
+<Image img={require('../../img/claude_code_max/step2.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+#### 1.3 Configure Key Details
+
+Enter a key name (e.g., `claude-code-test`) and select the models you want to allow access to.
+
+<Image img={require('../../img/claude_code_max/step3.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+#### 1.4 Select Models
+
+Choose the Anthropic models that should be accessible via this key (e.g., `anthropic-claude`, `claude-4.5-haiku`).
+
+<Image img={require('../../img/claude_code_max/step5.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+#### 1.5 Confirm Model Selection
+
+<Image img={require('../../img/claude_code_max/step7.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+#### 1.6 Create the Key
+
+Click "Create Key" to generate your virtual key. Copy the generated key value (e.g., `sk-otsclFlEblQ-6D60ua2IZg`).
+
+<Image img={require('../../img/claude_code_max/step8.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+---
+
+### Part 2: Sign into Claude Code Max Plan (Client Side)
+
+Set up Claude Code environment variables and authenticate with your Max subscription.
+
+#### 2.1 Set Environment Variables
+
+Configure Claude Code to use LiteLLM Gateway with your virtual key:
+
+```bash showLineNumbers title="Configure Claude Code Environment Variables"
+export ANTHROPIC_BASE_URL=http://localhost:4000
+export ANTHROPIC_MODEL="anthropic-claude"
+export ANTHROPIC_CUSTOM_HEADERS="x-litellm-api-key: Bearer sk-otsclFlEblQ-6D60ua2IZg"
+```
+
+<Image img={require('../../img/claude_code_max/step15.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+#### Environment Variables Explained
+
+| Variable | Description |
+|----------|-------------|
+| `ANTHROPIC_BASE_URL` | Points Claude Code to your LiteLLM Gateway endpoint |
+| `ANTHROPIC_MODEL` | The model name configured in your LiteLLM `config.yaml` |
+| `ANTHROPIC_CUSTOM_HEADERS` | The `x-litellm-api-key` header for LiteLLM authentication |
+
+#### 2.2 Launch Claude Code
+
+Start Claude Code:
+
+```bash showLineNumbers title="Launch Claude Code"
+claude
+```
+
+<Image img={require('../../img/claude_code_max/step16.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+#### 2.3 Select Login Method
+
+Choose "Claude account with subscription" (Pro, Max, Team, or Enterprise).
+
+<Image img={require('../../img/claude_code_max/step17.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+#### 2.4 Authorize in Browser
+
+Claude Code opens your browser to authenticate. Click "Authorize" to connect your Claude Max account.
+
+<Image img={require('../../img/claude_code_max/step19.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+#### 2.5 Login Successful
+
+After authorization, you'll see the login success confirmation.
+
+<Image img={require('../../img/claude_code_max/step20.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+#### 2.6 Complete Setup
+
+Press Enter to continue past the security notes and complete the setup.
+
+<Image img={require('../../img/claude_code_max/step21.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+---
+
+### Part 3: Use Claude Code with LiteLLM
+
+Now you can use Claude Code normally, and all requests will be tracked in LiteLLM.
+
+#### 3.1 Make a Request in Claude Code
+
+Start using Claude Code - requests will flow through LiteLLM Gateway.
+
+<Image img={require('../../img/claude_code_max/step24.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+#### 3.2 View Logs in LiteLLM Dashboard
+
+Navigate to the Logs page in LiteLLM Dashboard to see all Claude Code requests.
+
+<Image img={require('../../img/claude_code_max/step25.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+#### 3.3 View Request Details
+
+Click on a request to see detailed information including tokens, cost, duration, and model used.
+
+<Image img={require('../../img/claude_code_max/step27.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+The logs show:
+- **Key Name**: `claude-code-test` (the virtual key you created)
+- **Model**: `anthropic/claude-sonnet-4-20250514`
+- **Tokens**: 65012 (64679 prompt + 333 completion)
+- **Cost**: $0.249754
+- **Status**: Success
+
+<Image img={require('../../img/claude_code_max/step28.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+---
+
+## How It Works
+
+LiteLLM Gateway handles two types of authentication:
+1. **`x-litellm-api-key`**: Authenticates the request with LiteLLM (usage tracking, budgets, rate limits)
+2. **OAuth Token (via `Authorization` header)**: Forwarded to Anthropic API for Claude Max authentication
+
+```mermaid
+sequenceDiagram
+    participant User as Claude Code User
+    participant LiteLLM as LiteLLM AI Gateway
+    participant Anthropic as Anthropic API
+
+    User->>LiteLLM: Request with:<br/>- x-litellm-api-key (LiteLLM auth)<br/>- Authorization: Bearer {oauth_token}
+
+    Note over LiteLLM: 1. Validate x-litellm-api-key<br/>2. Check budgets/rate limits<br/>3. Log request for tracking
+
+    LiteLLM->>Anthropic: Forward request with:<br/>- Authorization: Bearer {oauth_token}<br/>(User's Claude Max OAuth token)
+
+    Note over Anthropic: Authenticate user via<br/>OAuth token from Max plan
+
+    Anthropic-->>LiteLLM: Response
+
+    Note over LiteLLM: Log usage, tokens, cost
+
+    LiteLLM-->>User: Response
+```
+
+### Header Flow
+
+| Header | Purpose | Handled By |
+|--------|---------|------------|
+| `x-litellm-api-key` | LiteLLM Gateway authentication, budget tracking, rate limits | LiteLLM |
+| `Authorization: Bearer {oauth_token}` | Claude Max subscription authentication | Anthropic API |
+
+### Complete Request Flow Example
+
+Here's what a typical request looks like when Claude Code makes a call through LiteLLM:
+
+```bash showLineNumbers title="Example Request from Claude Code to LiteLLM"
+curl -X POST "http://localhost:4000/v1/messages" \
+  -H "x-litellm-api-key: Bearer sk-otsclFlEblQ-6D60ua2IZg" \
+  -H "Authorization: Bearer oauth_token_from_max_plan" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "anthropic-claude",
+    "max_tokens": 1024,
+    "messages": [{"role": "user", "content": "Hello, Claude!"}]
+  }'
+```
+
+LiteLLM then:
+1. Validates `x-litellm-api-key` for gateway access
+2. Logs the request for usage tracking
+3. Forwards the request to Anthropic with the OAuth `Authorization` header (because of `forward_client_headers_to_llm_api: true`)
+
+## Advanced Configuration
+
+### Per-Model Header Forwarding
+
+For more granular control, you can enable header forwarding only for specific models:
+
+```yaml showLineNumbers title="config.yaml - Per-Model Header Forwarding"
+model_list:
+  - model_name: anthropic-claude
+    litellm_params:
+      model: anthropic/claude-sonnet-4-20250514
+
+  - model_name: claude-3-5-haiku-20241022
+    litellm_params:
+      model: anthropic/claude-3-5-haiku-20241022
+
+litellm_settings:
+  master_key: os.environ/LITELLM_MASTER_KEY
+  model_group_settings:
+    forward_client_headers_to_llm_api:
+      - anthropic-claude
+      - claude-3-5-haiku-20241022
+```
+
+### Budget Controls
+
+Set up per-user budgets while using Max subscriptions:
+
+```yaml showLineNumbers title="config.yaml - With Database for Budget Tracking"
+model_list:
+  - model_name: anthropic-claude
+    litellm_params:
+      model: anthropic/claude-sonnet-4-20250514
+
+general_settings:
+  forward_client_headers_to_llm_api: true
+  database_url: "postgresql://..."
+
+litellm_settings:
+  master_key: os.environ/LITELLM_MASTER_KEY
+```
+
+Then create virtual keys with budgets:
+
+```bash showLineNumbers title="Create Virtual Key with Budget"
+curl -X POST "http://localhost:4000/key/generate" \
+  -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "key_alias": "developer-1",
+    "max_budget": 100.00,
+    "budget_duration": "monthly"
+  }'
+```
+
+## Troubleshooting
+
+### OAuth Token Not Being Forwarded
+
+**Symptom**: Authentication errors from Anthropic API
+
+**Solution**: Ensure `forward_client_headers_to_llm_api: true` is set in your config:
+
+```yaml showLineNumbers title="config.yaml - Enable Header Forwarding"
+general_settings:
+  forward_client_headers_to_llm_api: true
+```
+
+### LiteLLM Authentication Failing
+
+**Symptom**: 401 errors from LiteLLM Gateway
+
+**Solution**: Verify `x-litellm-api-key` header is set correctly in `ANTHROPIC_CUSTOM_HEADERS`:
+
+```bash showLineNumbers title="Verify Key Info"
+curl -X GET "http://localhost:4000/key/info" \
+  -H "Authorization: Bearer sk-otsclFlEblQ-6D60ua2IZg"
+```
+
+### Model Not Found
+
+**Symptom**: Model not found errors
+
+**Solution**: Ensure the `ANTHROPIC_MODEL` matches a model name in your config:
+
+```bash showLineNumbers title="List Available Models"
+curl "http://localhost:4000/v1/models" \
+  -H "Authorization: Bearer sk-otsclFlEblQ-6D60ua2IZg"
+```
+
+## Related Documentation
+
+- [Forward Client Headers](/docs/proxy/forward_client_headers) - Detailed header forwarding configuration
+- [Claude Code Quickstart](/docs/tutorials/claude_responses_api) - Basic Claude Code + LiteLLM setup
+- [Virtual Keys](/docs/proxy/virtual_keys) - Creating and managing API keys
+- [Budgets & Rate Limits](/docs/proxy/users) - Setting up usage controls
diff --git a/docs/my-website/img/claude_code_max.png b/docs/my-website/img/claude_code_max.png
new file mode 100644
index 00000000000..65c9578a450
Binary files /dev/null and b/docs/my-website/img/claude_code_max.png differ
diff --git a/docs/my-website/img/claude_code_max/step1.jpeg b/docs/my-website/img/claude_code_max/step1.jpeg
new file mode 100644
index 00000000000..6b65d598d3c
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step1.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step10.jpeg b/docs/my-website/img/claude_code_max/step10.jpeg
new file mode 100644
index 00000000000..326f9b12d1d
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step10.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step12.jpeg b/docs/my-website/img/claude_code_max/step12.jpeg
new file mode 100644
index 00000000000..97199e9eadb
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step12.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step13.jpeg b/docs/my-website/img/claude_code_max/step13.jpeg
new file mode 100644
index 00000000000..53fd1c9bd53
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step13.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step14.jpeg b/docs/my-website/img/claude_code_max/step14.jpeg
new file mode 100644
index 00000000000..5c3e4b05e24
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step14.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step15.jpeg b/docs/my-website/img/claude_code_max/step15.jpeg
new file mode 100644
index 00000000000..2c63ba6e75d
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step15.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step16.jpeg b/docs/my-website/img/claude_code_max/step16.jpeg
new file mode 100644
index 00000000000..7abb53edb81
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step16.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step17.jpeg b/docs/my-website/img/claude_code_max/step17.jpeg
new file mode 100644
index 00000000000..a9c352f85e6
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step17.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step18.jpeg b/docs/my-website/img/claude_code_max/step18.jpeg
new file mode 100644
index 00000000000..0177537fef2
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step18.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step19.jpeg b/docs/my-website/img/claude_code_max/step19.jpeg
new file mode 100644
index 00000000000..d84eec24dde
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step19.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step2.jpeg b/docs/my-website/img/claude_code_max/step2.jpeg
new file mode 100644
index 00000000000..2d7255c73a3
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step2.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step20.jpeg b/docs/my-website/img/claude_code_max/step20.jpeg
new file mode 100644
index 00000000000..3e97cba38c0
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step20.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step21.jpeg b/docs/my-website/img/claude_code_max/step21.jpeg
new file mode 100644
index 00000000000..02387c76660
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step21.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step22.jpeg b/docs/my-website/img/claude_code_max/step22.jpeg
new file mode 100644
index 00000000000..7aa920221d2
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step22.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step23.jpeg b/docs/my-website/img/claude_code_max/step23.jpeg
new file mode 100644
index 00000000000..4eb9c62c726
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step23.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step24.jpeg b/docs/my-website/img/claude_code_max/step24.jpeg
new file mode 100644
index 00000000000..bb38c2e19a2
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step24.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step25.jpeg b/docs/my-website/img/claude_code_max/step25.jpeg
new file mode 100644
index 00000000000..fb1e0950669
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step25.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step26.jpeg b/docs/my-website/img/claude_code_max/step26.jpeg
new file mode 100644
index 00000000000..9eb418b9be4
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step26.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step27.jpeg b/docs/my-website/img/claude_code_max/step27.jpeg
new file mode 100644
index 00000000000..b8efb3aeb14
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step27.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step28.jpeg b/docs/my-website/img/claude_code_max/step28.jpeg
new file mode 100644
index 00000000000..a2ce52441ee
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step28.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step3.jpeg b/docs/my-website/img/claude_code_max/step3.jpeg
new file mode 100644
index 00000000000..a5f28c80497
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step3.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step4.jpeg b/docs/my-website/img/claude_code_max/step4.jpeg
new file mode 100644
index 00000000000..ec9ffa4deb8
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step4.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step5.jpeg b/docs/my-website/img/claude_code_max/step5.jpeg
new file mode 100644
index 00000000000..25d33f27a03
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step5.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step6.jpeg b/docs/my-website/img/claude_code_max/step6.jpeg
new file mode 100644
index 00000000000..116f792eacd
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step6.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step7.jpeg b/docs/my-website/img/claude_code_max/step7.jpeg
new file mode 100644
index 00000000000..1a3b232d2b5
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step7.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step8.jpeg b/docs/my-website/img/claude_code_max/step8.jpeg
new file mode 100644
index 00000000000..1a67a135c34
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step8.jpeg differ
diff --git a/docs/my-website/img/claude_code_max/step9.jpeg b/docs/my-website/img/claude_code_max/step9.jpeg
new file mode 100644
index 00000000000..b95594e617e
Binary files /dev/null and b/docs/my-website/img/claude_code_max/step9.jpeg differ
diff --git a/docs/my-website/release_notes/v1.81.0/index.md b/docs/my-website/release_notes/v1.81.0/index.md
index edd720f6bfd..88ac240c614 100644
--- a/docs/my-website/release_notes/v1.81.0/index.md
+++ b/docs/my-website/release_notes/v1.81.0/index.md
@@ -27,7 +27,7 @@ import TabItem from '@theme/TabItem';
 docker run \
 -e STORE_MODEL_IN_DB=True \
 -p 4000:4000 \
-docker.litellm.ai/berriai/litellm:v1.81.0
+docker.litellm.ai/berriai/litellm:v1.81.0.rc.1
 ```
 
 </TabItem>
diff --git a/docs/my-website/sidebars.js b/docs/my-website/sidebars.js
index 9f31cdcb367..9572fc9774f 100644
--- a/docs/my-website/sidebars.js
+++ b/docs/my-website/sidebars.js
@@ -121,6 +121,7 @@ const sidebars = {
           label: "Claude Code",
           items: [
             "tutorials/claude_responses_api",
+            "tutorials/claude_code_max_subscription",
             "tutorials/claude_code_customer_tracking",
             "tutorials/claude_code_websearch",
             "tutorials/claude_mcp",
@@ -718,6 +719,7 @@ const sidebars = {
         "providers/galadriel",
         "providers/github",
         "providers/github_copilot",
+        "providers/chatgpt",
         "providers/gradient_ai",
         "providers/groq",
         "providers/helicone",
diff --git a/litellm-proxy-extras/dist/litellm_proxy_extras-0.4.25-py3-none-any.whl b/litellm-proxy-extras/dist/litellm_proxy_extras-0.4.25-py3-none-any.whl
new file mode 100644
index 00000000000..bfe7433f671
Binary files /dev/null and b/litellm-proxy-extras/dist/litellm_proxy_extras-0.4.25-py3-none-any.whl differ
diff --git a/litellm-proxy-extras/dist/litellm_proxy_extras-0.4.25.tar.gz b/litellm-proxy-extras/dist/litellm_proxy_extras-0.4.25.tar.gz
new file mode 100644
index 00000000000..12a55d441a5
Binary files /dev/null and b/litellm-proxy-extras/dist/litellm_proxy_extras-0.4.25.tar.gz differ
diff --git a/litellm-proxy-extras/pyproject.toml b/litellm-proxy-extras/pyproject.toml
index 52258ebe2e4..eddb563d55a 100644
--- a/litellm-proxy-extras/pyproject.toml
+++ b/litellm-proxy-extras/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "litellm-proxy-extras"
-version = "0.4.23"
+version = "0.4.25"
 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.23"
+version = "0.4.25"
 version_files = [
     "pyproject.toml:version",
     "../requirements.txt:litellm-proxy-extras==",
diff --git a/litellm/__init__.py b/litellm/__init__.py
index 134f8206d37..4c59c335ce1 100644
--- a/litellm/__init__.py
+++ b/litellm/__init__.py
@@ -557,6 +557,7 @@ docker_model_runner_models: Set = set()
 amazon_nova_models: Set = set()
 stability_models: Set = set()
 github_copilot_models: Set = set()
+chatgpt_models: Set = set()
 minimax_models: Set = set()
 aws_polly_models: Set = set()
 gigachat_models: Set = set()
@@ -812,6 +813,8 @@ def add_known_models():
             stability_models.add(key)
         elif value.get("litellm_provider") == "github_copilot":
             github_copilot_models.add(key)
+        elif value.get("litellm_provider") == "chatgpt":
+            chatgpt_models.add(key)
         elif value.get("litellm_provider") == "minimax":
             minimax_models.add(key)
         elif value.get("litellm_provider") == "aws_polly":
@@ -1025,6 +1028,7 @@ models_by_provider: dict = {
     "amazon_nova": amazon_nova_models,
     "stability": stability_models,
     "github_copilot": github_copilot_models,
+    "chatgpt": chatgpt_models,
     "minimax": minimax_models,
     "aws_polly": aws_polly_models,
     "gigachat": gigachat_models,
@@ -1459,6 +1463,8 @@ if TYPE_CHECKING:
     from .llms.github_copilot.chat.transformation import GithubCopilotConfig as GithubCopilotConfig
     from .llms.github_copilot.responses.transformation import GithubCopilotResponsesAPIConfig as GithubCopilotResponsesAPIConfig
     from .llms.github_copilot.embedding.transformation import GithubCopilotEmbeddingConfig as GithubCopilotEmbeddingConfig
+    from .llms.chatgpt.chat.transformation import ChatGPTConfig as ChatGPTConfig
+    from .llms.chatgpt.responses.transformation import ChatGPTResponsesAPIConfig as ChatGPTResponsesAPIConfig
     from .llms.gigachat.chat.transformation import GigaChatConfig as GigaChatConfig
     from .llms.gigachat.embedding.transformation import GigaChatEmbeddingConfig as GigaChatEmbeddingConfig
     from .llms.nebius.chat.transformation import NebiusConfig as NebiusConfig
diff --git a/litellm/_lazy_imports_registry.py b/litellm/_lazy_imports_registry.py
index 3025f1b0c51..a92c6f95b0e 100644
--- a/litellm/_lazy_imports_registry.py
+++ b/litellm/_lazy_imports_registry.py
@@ -254,6 +254,8 @@ LLM_CONFIG_NAMES = (
     "IBMWatsonXAudioTranscriptionConfig",
     "GithubCopilotConfig",
     "GithubCopilotResponsesAPIConfig",
+    "ChatGPTConfig",
+    "ChatGPTResponsesAPIConfig",
     "ManusResponsesAPIConfig",
     "GithubCopilotEmbeddingConfig",
     "NebiusConfig",
@@ -650,6 +652,8 @@ _LLM_CONFIGS_IMPORT_MAP = {
     "GithubCopilotConfig": (".llms.github_copilot.chat.transformation", "GithubCopilotConfig"),
     "GithubCopilotResponsesAPIConfig": (".llms.github_copilot.responses.transformation", "GithubCopilotResponsesAPIConfig"),
     "GithubCopilotEmbeddingConfig": (".llms.github_copilot.embedding.transformation", "GithubCopilotEmbeddingConfig"),
+    "ChatGPTConfig": (".llms.chatgpt.chat.transformation", "ChatGPTConfig"),
+    "ChatGPTResponsesAPIConfig": (".llms.chatgpt.responses.transformation", "ChatGPTResponsesAPIConfig"),
     "NebiusConfig": (".llms.nebius.chat.transformation", "NebiusConfig"),
     "WandbConfig": (".llms.wandb.chat.transformation", "WandbConfig"),
     "GigaChatConfig": (".llms.gigachat.chat.transformation", "GigaChatConfig"),
diff --git a/litellm/_service_logger.py b/litellm/_service_logger.py
index 3128f02f409..b67d0d86063 100644
--- a/litellm/_service_logger.py
+++ b/litellm/_service_logger.py
@@ -145,16 +145,19 @@ class ServiceLogging(CustomLogger):
                     event_metadata=event_metadata,
                 )
             elif callback == "otel" or isinstance(callback, OpenTelemetry):
-                from litellm.proxy.proxy_server import open_telemetry_logger
+                _otel_logger_to_use: Optional[OpenTelemetry] = None
+                if isinstance(callback, OpenTelemetry):
+                    _otel_logger_to_use = callback
+                else:
+                    from litellm.proxy.proxy_server import open_telemetry_logger
 
-                await self.init_otel_logger_if_none()
+                    if open_telemetry_logger is not None and isinstance(
+                        open_telemetry_logger, OpenTelemetry
+                    ):
+                        _otel_logger_to_use = open_telemetry_logger
 
-                if (
-                    parent_otel_span is not None
-                    and open_telemetry_logger is not None
-                    and isinstance(open_telemetry_logger, OpenTelemetry)
-                ):
-                    await self.otel_logger.async_service_success_hook(
+                if _otel_logger_to_use is not None and parent_otel_span is not None:
+                    await _otel_logger_to_use.async_service_success_hook(
                         payload=payload,
                         parent_otel_span=parent_otel_span,
                         start_time=start_time,
@@ -253,20 +256,24 @@ class ServiceLogging(CustomLogger):
                     event_metadata=event_metadata,
                 )
             elif callback == "otel" or isinstance(callback, OpenTelemetry):
-                from litellm.proxy.proxy_server import open_telemetry_logger
+                _otel_logger_to_use: Optional[OpenTelemetry] = None
+                if isinstance(callback, OpenTelemetry):
+                    _otel_logger_to_use = callback
+                else:
+                    from litellm.proxy.proxy_server import open_telemetry_logger
 
-                await self.init_otel_logger_if_none()
+                    if open_telemetry_logger is not None and isinstance(
+                        open_telemetry_logger, OpenTelemetry
+                    ):
+                        _otel_logger_to_use = open_telemetry_logger
 
                 if not isinstance(error, str):
                     error = str(error)
 
-                if (
-                    parent_otel_span is not None
-                    and open_telemetry_logger is not None
-                    and isinstance(open_telemetry_logger, OpenTelemetry)
-                ):
-                    await self.otel_logger.async_service_success_hook(
+                if _otel_logger_to_use is not None and parent_otel_span is not None:
+                    await _otel_logger_to_use.async_service_failure_hook(
                         payload=payload,
+                        error=error,
                         parent_otel_span=parent_otel_span,
                         start_time=start_time,
                         end_time=end_time,
diff --git a/litellm/completion_extras/litellm_responses_transformation/handler.py b/litellm/completion_extras/litellm_responses_transformation/handler.py
index 6ec49ce0620..5c051797e8b 100644
--- a/litellm/completion_extras/litellm_responses_transformation/handler.py
+++ b/litellm/completion_extras/litellm_responses_transformation/handler.py
@@ -2,10 +2,12 @@
 Handler for transforming /chat/completions api requests to litellm.responses requests
 """
 
-from typing import TYPE_CHECKING, Any, Coroutine, Union
+from typing import TYPE_CHECKING, Any, Coroutine, Optional, Union
 
 from typing_extensions import TypedDict
 
+from litellm.types.llms.openai import ResponsesAPIResponse
+
 if TYPE_CHECKING:
     from litellm import CustomStreamWrapper, LiteLLMLoggingObj, ModelResponse
 
@@ -28,6 +30,71 @@ class ResponsesToCompletionBridgeHandler:
         super().__init__()
         self.transformation_handler = LiteLLMResponsesTransformationHandler()
 
+    @staticmethod
+    def _resolve_stream_flag(optional_params: dict, litellm_params: dict) -> bool:
+        stream = optional_params.get("stream")
+        if stream is None:
+            stream = litellm_params.get("stream", False)
+        return bool(stream)
+
+    @staticmethod
+    def _coerce_response_object(
+        response_obj: Any,
+        hidden_params: Optional[dict],
+    ) -> "ResponsesAPIResponse":
+        if isinstance(response_obj, ResponsesAPIResponse):
+            response = response_obj
+        elif isinstance(response_obj, dict):
+            try:
+                response = ResponsesAPIResponse(**response_obj)
+            except Exception:
+                response = ResponsesAPIResponse.model_construct(**response_obj)
+        else:
+            raise ValueError("Unexpected responses stream payload")
+
+        if hidden_params:
+            existing = getattr(response, "_hidden_params", None)
+            if not isinstance(existing, dict) or not existing:
+                setattr(response, "_hidden_params", dict(hidden_params))
+            else:
+                for key, value in hidden_params.items():
+                    existing.setdefault(key, value)
+        return response
+
+    def _collect_response_from_stream(
+        self, stream_iter: Any
+    ) -> "ResponsesAPIResponse":
+        for _ in stream_iter:
+            pass
+
+        completed = getattr(stream_iter, "completed_response", None)
+        response_obj = getattr(completed, "response", None) if completed else None
+        if response_obj is None:
+            raise ValueError("Stream ended without a completed response")
+
+        hidden_params = getattr(stream_iter, "_hidden_params", None)
+        response = self._coerce_response_object(response_obj, hidden_params)
+        if not isinstance(response, ResponsesAPIResponse):
+            raise ValueError("Stream completed response is invalid")
+        return response
+
+    async def _collect_response_from_stream_async(
+        self, stream_iter: Any
+    ) -> "ResponsesAPIResponse":
+        async for _ in stream_iter:
+            pass
+
+        completed = getattr(stream_iter, "completed_response", None)
+        response_obj = getattr(completed, "response", None) if completed else None
+        if response_obj is None:
+            raise ValueError("Stream ended without a completed response")
+
+        hidden_params = getattr(stream_iter, "_hidden_params", None)
+        response = self._coerce_response_object(response_obj, hidden_params)
+        if not isinstance(response, ResponsesAPIResponse):
+            raise ValueError("Stream completed response is invalid")
+        return response
+
     def validate_input_kwargs(
         self, kwargs: dict
     ) -> ResponsesToCompletionBridgeHandlerInputKwargs:
@@ -87,7 +154,6 @@ class ResponsesToCompletionBridgeHandler:
 
         from litellm import responses
         from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper
-        from litellm.types.llms.openai import ResponsesAPIResponse
 
         validated_kwargs = self.validate_input_kwargs(kwargs)
         model = validated_kwargs["model"]
@@ -113,6 +179,7 @@ class ResponsesToCompletionBridgeHandler:
             **request_data,
         )
 
+        stream = self._resolve_stream_flag(optional_params, litellm_params)
         if isinstance(result, ResponsesAPIResponse):
             return self.transformation_handler.transform_response(
                 model=model,
@@ -127,6 +194,21 @@ class ResponsesToCompletionBridgeHandler:
                 api_key=kwargs.get("api_key"),
                 json_mode=kwargs.get("json_mode"),
             )
+        elif not stream:
+            responses_api_response = self._collect_response_from_stream(result)
+            return self.transformation_handler.transform_response(
+                model=model,
+                raw_response=responses_api_response,
+                model_response=model_response,
+                logging_obj=logging_obj,
+                request_data=request_data,
+                messages=messages,
+                optional_params=optional_params,
+                litellm_params=litellm_params,
+                encoding=kwargs.get("encoding"),
+                api_key=kwargs.get("api_key"),
+                json_mode=kwargs.get("json_mode"),
+            )
         else:
             completion_stream = self.transformation_handler.get_model_response_iterator(
                 streaming_response=result,  # type: ignore
@@ -146,7 +228,6 @@ class ResponsesToCompletionBridgeHandler:
     ) -> Union["ModelResponse", "CustomStreamWrapper"]:
         from litellm import aresponses
         from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper
-        from litellm.types.llms.openai import ResponsesAPIResponse
 
         validated_kwargs = self.validate_input_kwargs(kwargs)
         model = validated_kwargs["model"]
@@ -175,6 +256,7 @@ class ResponsesToCompletionBridgeHandler:
             aresponses=True,
         )
 
+        stream = self._resolve_stream_flag(optional_params, litellm_params)
         if isinstance(result, ResponsesAPIResponse):
             return self.transformation_handler.transform_response(
                 model=model,
@@ -189,6 +271,23 @@ class ResponsesToCompletionBridgeHandler:
                 api_key=kwargs.get("api_key"),
                 json_mode=kwargs.get("json_mode"),
             )
+        elif not stream:
+            responses_api_response = await self._collect_response_from_stream_async(
+                result
+            )
+            return self.transformation_handler.transform_response(
+                model=model,
+                raw_response=responses_api_response,
+                model_response=model_response,
+                logging_obj=logging_obj,
+                request_data=request_data,
+                messages=messages,
+                optional_params=optional_params,
+                litellm_params=litellm_params,
+                encoding=kwargs.get("encoding"),
+                api_key=kwargs.get("api_key"),
+                json_mode=kwargs.get("json_mode"),
+            )
         else:
             completion_stream = self.transformation_handler.get_model_response_iterator(
                 streaming_response=result,  # type: ignore
diff --git a/litellm/completion_extras/litellm_responses_transformation/transformation.py b/litellm/completion_extras/litellm_responses_transformation/transformation.py
index af8185aa215..c98799d2542 100644
--- a/litellm/completion_extras/litellm_responses_transformation/transformation.py
+++ b/litellm/completion_extras/litellm_responses_transformation/transformation.py
@@ -779,10 +779,10 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge):
     @staticmethod
     def _convert_annotations_to_chat_format(
         annotations: Optional[List[Any]],
-    ) -> Optional[List["ChatCompletionAnnotation"]]:
+    ) -> Optional[List[ChatCompletionAnnotation]]:
         """
         Convert annotations from Responses API to Chat Completions format.
-        
+
         Annotations are already in compatible format between both APIs,
         so we just need to convert Pydantic models to dicts.
         """
diff --git a/litellm/constants.py b/litellm/constants.py
index 8d92595e0c7..e142c7d6304 100644
--- a/litellm/constants.py
+++ b/litellm/constants.py
@@ -323,6 +323,9 @@ EMAIL_BUDGET_ALERT_TTL = int(os.getenv("EMAIL_BUDGET_ALERT_TTL", 24 * 60 * 60))
 EMAIL_BUDGET_ALERT_MAX_SPEND_ALERT_PERCENTAGE = float(os.getenv("EMAIL_BUDGET_ALERT_MAX_SPEND_ALERT_PERCENTAGE", 0.8))  # 80% of max budget
 ############### LLM Provider Constants ###############
 ### ANTHROPIC CONSTANTS ###
+ANTHROPIC_TOKEN_COUNTING_BETA_VERSION = os.getenv(
+    "ANTHROPIC_TOKEN_COUNTING_BETA_VERSION", "token-counting-2024-11-01"
+)
 ANTHROPIC_SKILLS_API_BETA_VERSION = "skills-2025-10-02"
 ANTHROPIC_WEB_SEARCH_TOOL_MAX_USES = {
     "low": 1,
@@ -415,6 +418,7 @@ LITELLM_CHAT_PROVIDERS = [
     "galadriel",
     "gradient_ai",
     "github_copilot",  # GitHub Copilot Chat API
+    "chatgpt",  # ChatGPT subscription API
     "novita",
     "meta_llama",
     "featherless_ai",
@@ -617,6 +621,7 @@ openai_compatible_providers: List = [
     "lm_studio",
     "galadriel",
     "github_copilot",  # GitHub Copilot Chat API
+    "chatgpt",  # ChatGPT subscription API
     "novita",
     "meta_llama",
     "publicai",  # PublicAI - JSON-configured provider
diff --git a/litellm/integrations/langfuse/langfuse_otel.py b/litellm/integrations/langfuse/langfuse_otel.py
index 6992ea17cc8..08493a0e8ec 100644
--- a/litellm/integrations/langfuse/langfuse_otel.py
+++ b/litellm/integrations/langfuse/langfuse_otel.py
@@ -156,7 +156,11 @@ class LangfuseOtelLogger(OpenTelemetry):
                         "arguments": arguments_obj,
                     }
                     transformed_tool_calls.append(langfuse_tool_call)
-                safe_set_attribute(span, LangfuseSpanAttributes.OBSERVATION_OUTPUT.value, safe_dumps(transformed_tool_calls))
+                safe_set_attribute(
+                    span,
+                    LangfuseSpanAttributes.OBSERVATION_OUTPUT.value,
+                    safe_dumps(transformed_tool_calls),
+                )
             else:
                 output_data = {}
                 if message.get("role"):
@@ -164,7 +168,11 @@ class LangfuseOtelLogger(OpenTelemetry):
                 if message.get("content") is not None:
                     output_data["content"] = message.get("content")
                 if output_data:
-                    safe_set_attribute(span, LangfuseSpanAttributes.OBSERVATION_OUTPUT.value, safe_dumps(output_data))
+                    safe_set_attribute(
+                        span,
+                        LangfuseSpanAttributes.OBSERVATION_OUTPUT.value,
+                        safe_dumps(output_data),
+                    )
 
         output = response_obj.get("output", [])
         if output:
@@ -175,15 +183,28 @@ class LangfuseOtelLogger(OpenTelemetry):
                     if item_type == "reasoning" and hasattr(item, "summary"):
                         for summary in item.summary:
                             if hasattr(summary, "text"):
-                                output_items_data.append({"role": "reasoning_summary", "content": summary.text})
+                                output_items_data.append(
+                                    {
+                                        "role": "reasoning_summary",
+                                        "content": summary.text,
+                                    }
+                                )
                     elif item_type == "message":
-                        output_items_data.append({
-                            "role": getattr(item, "role", "assistant"),
-                            "content": getattr(getattr(item, "content", [{}])[0], "text", "")
-                        })
+                        output_items_data.append(
+                            {
+                                "role": getattr(item, "role", "assistant"),
+                                "content": getattr(
+                                    getattr(item, "content", [{}])[0], "text", ""
+                                ),
+                            }
+                        )
                     elif item_type == "function_call":
                         arguments_str = getattr(item, "arguments", "{}")
-                        arguments_obj = json.loads(arguments_str) if isinstance(arguments_str, str) else arguments_str
+                        arguments_obj = (
+                            json.loads(arguments_str)
+                            if isinstance(arguments_str, str)
+                            else arguments_str
+                        )
                         langfuse_tool_call = {
                             "id": getattr(item, "id", ""),
                             "name": getattr(item, "name", ""),
@@ -193,7 +214,11 @@ class LangfuseOtelLogger(OpenTelemetry):
                         }
                         output_items_data.append(langfuse_tool_call)
             if output_items_data:
-                safe_set_attribute(span, LangfuseSpanAttributes.OBSERVATION_OUTPUT.value, safe_dumps(output_items_data))
+                safe_set_attribute(
+                    span,
+                    LangfuseSpanAttributes.OBSERVATION_OUTPUT.value,
+                    safe_dumps(output_items_data),
+                )
 
     @staticmethod
     def _set_langfuse_specific_attributes(span: Span, kwargs, response_obj):
@@ -210,14 +235,22 @@ class LangfuseOtelLogger(OpenTelemetry):
 
         langfuse_environment = os.environ.get("LANGFUSE_TRACING_ENVIRONMENT")
         if langfuse_environment:
-            safe_set_attribute(span, LangfuseSpanAttributes.LANGFUSE_ENVIRONMENT.value, langfuse_environment)
+            safe_set_attribute(
+                span,
+                LangfuseSpanAttributes.LANGFUSE_ENVIRONMENT.value,
+                langfuse_environment,
+            )
 
         metadata = LangfuseOtelLogger._extract_langfuse_metadata(kwargs)
         LangfuseOtelLogger._set_metadata_attributes(span=span, metadata=metadata)
 
         messages = kwargs.get("messages")
         if messages:
-            safe_set_attribute(span, LangfuseSpanAttributes.OBSERVATION_INPUT.value, safe_dumps(messages))
+            safe_set_attribute(
+                span,
+                LangfuseSpanAttributes.OBSERVATION_INPUT.value,
+                safe_dumps(messages),
+            )
 
         LangfuseOtelLogger._set_observation_output(span=span, response_obj=response_obj)
 
@@ -319,3 +352,15 @@ class LangfuseOtelLogger(OpenTelemetry):
             dynamic_headers["Authorization"] = auth_header
 
         return dynamic_headers
+
+    async def async_service_success_hook(self, *args, **kwargs):
+        """
+        Langfuse should not receive service success logs.
+        """
+        pass
+
+    async def async_service_failure_hook(self, *args, **kwargs):
+        """
+        Langfuse should not receive service failure logs.
+        """
+        pass
diff --git a/litellm/litellm_core_utils/get_llm_provider_logic.py b/litellm/litellm_core_utils/get_llm_provider_logic.py
index 21d69177336..807b66faec1 100644
--- a/litellm/litellm_core_utils/get_llm_provider_logic.py
+++ b/litellm/litellm_core_utils/get_llm_provider_logic.py
@@ -768,6 +768,14 @@ def _get_openai_compatible_provider_info(  # noqa: PLR0915
         ) = litellm.GithubCopilotConfig()._get_openai_compatible_provider_info(
             model, api_base, api_key, custom_llm_provider
         )
+    elif custom_llm_provider == "chatgpt":
+        (
+            api_base,
+            dynamic_api_key,
+            custom_llm_provider,
+        ) = litellm.ChatGPTConfig()._get_openai_compatible_provider_info(
+            model, api_base, api_key, custom_llm_provider
+        )
     elif custom_llm_provider == "novita":
         api_base = (
             api_base
diff --git a/litellm/litellm_core_utils/litellm_logging.py b/litellm/litellm_core_utils/litellm_logging.py
index bc5faf962c2..9cef21bfdf6 100644
--- a/litellm/litellm_core_utils/litellm_logging.py
+++ b/litellm/litellm_core_utils/litellm_logging.py
@@ -1897,6 +1897,14 @@ class Logging(LiteLLMLoggingBaseClass):
                     status="success",
                     standard_built_in_tools_params=self.standard_built_in_tools_params,
                 )
+                if (
+                    standard_logging_payload := self.model_call_details.get(
+                        "standard_logging_object"
+                    )
+                ) is not None:
+                    # Only emit for sync requests (async_success_handler handles async)
+                    if is_sync_request:
+                        emit_standard_logging_payload(standard_logging_payload)
             callbacks = self.get_combined_callback_list(
                 dynamic_success_callbacks=self.dynamic_success_callbacks,
                 global_callbacks=litellm.success_callback,
@@ -2190,10 +2198,7 @@ class Logging(LiteLLMLoggingBaseClass):
                                 print_verbose=print_verbose,
                             )
 
-                    if (
-                        callback == "openmeter"
-                        and is_sync_request
-                    ):
+                    if callback == "openmeter" and is_sync_request:
                         global openMeterLogger
                         if openMeterLogger is None:
                             print_verbose("Instantiates openmeter client")
@@ -2405,6 +2410,14 @@ class Logging(LiteLLMLoggingBaseClass):
                 status="success",
                 standard_built_in_tools_params=self.standard_built_in_tools_params,
             )
+
+            # print standard logging payload
+            if (
+                standard_logging_payload := self.model_call_details.get(
+                    "standard_logging_object"
+                )
+            ) is not None:
+                emit_standard_logging_payload(standard_logging_payload)
         callbacks = self.get_combined_callback_list(
             dynamic_success_callbacks=self.dynamic_async_success_callbacks,
             global_callbacks=litellm._async_success_callback,
@@ -2799,8 +2812,7 @@ class Logging(LiteLLMLoggingBaseClass):
                             callback_func=callback,
                         )
                     if (
-                        isinstance(callback, CustomLogger)
-                        and is_sync_request
+                        isinstance(callback, CustomLogger) and is_sync_request
                     ):  # custom logger class
                         callback.log_failure_event(
                             start_time=start_time,
@@ -3743,10 +3755,13 @@ def _init_custom_logger_compatible_class(  # noqa: PLR0915
                 OpenTelemetry,
                 OpenTelemetryConfig,
             )
-            logfire_base_url = os.getenv("LOGFIRE_BASE_URL", "https://logfire-api.pydantic.dev")
+
+            logfire_base_url = os.getenv(
+                "LOGFIRE_BASE_URL", "https://logfire-api.pydantic.dev"
+            )
             otel_config = OpenTelemetryConfig(
                 exporter="otlp_http",
-                endpoint = f"{logfire_base_url.rstrip('/')}/v1/traces",
+                endpoint=f"{logfire_base_url.rstrip('/')}/v1/traces",
                 headers=f"Authorization={os.getenv('LOGFIRE_TOKEN')}",
             )
             for callback in _in_memory_loggers:
@@ -4342,32 +4357,38 @@ class StandardLoggingPayloadSetup:
     def merge_litellm_metadata(litellm_params: dict) -> dict:
         """
         Merge both litellm_metadata and metadata from litellm_params.
-        
+
         litellm_metadata contains model-related fields, metadata contains user API key fields.
         We need both for complete standard logging payload.
-        
+
         Args:
             litellm_params: Dictionary containing metadata and litellm_metadata
-            
+
         Returns:
             dict: Merged metadata with user API key fields taking precedence
         """
         merged_metadata: dict = {}
-        
+
         # Start with metadata (user API key fields) - but skip non-serializable objects
-        if litellm_params.get("metadata") and isinstance(litellm_params.get("metadata"), dict):
+        if litellm_params.get("metadata") and isinstance(
+            litellm_params.get("metadata"), dict
+        ):
             for key, value in litellm_params["metadata"].items():
                 # Skip non-serializable objects like UserAPIKeyAuth
                 if key == "user_api_key_auth":
                     continue
                 merged_metadata[key] = value
-        
+
         # Then merge litellm_metadata (model-related fields) - this will NOT overwrite existing keys
-        if litellm_params.get("litellm_metadata") and isinstance(litellm_params.get("litellm_metadata"), dict):
+        if litellm_params.get("litellm_metadata") and isinstance(
+            litellm_params.get("litellm_metadata"), dict
+        ):
             for key, value in litellm_params["litellm_metadata"].items():
-                if key not in merged_metadata:  # Don't overwrite existing keys from metadata
+                if (
+                    key not in merged_metadata
+                ):  # Don't overwrite existing keys from metadata
                     merged_metadata[key] = value
-        
+
         return merged_metadata
 
     @staticmethod
@@ -4810,7 +4831,9 @@ class StandardLoggingPayloadSetup:
         """
         Extract additional header tags for spend tracking based on config.
         """
-        extra_headers: List[str] = getattr(litellm, "extra_spend_tag_headers", None) or []
+        extra_headers: List[str] = (
+            getattr(litellm, "extra_spend_tag_headers", None) or []
+        )
         if not extra_headers:
             return None
 
@@ -4959,7 +4982,9 @@ def get_standard_logging_object_payload(
         proxy_server_request = litellm_params.get("proxy_server_request") or {}
 
         # Merge both litellm_metadata and metadata to get complete metadata
-        metadata: dict = StandardLoggingPayloadSetup.merge_litellm_metadata(litellm_params)
+        metadata: dict = StandardLoggingPayloadSetup.merge_litellm_metadata(
+            litellm_params
+        )
 
         completion_start_time = kwargs.get("completion_start_time", end_time)
         call_type = kwargs.get("call_type")
@@ -5129,7 +5154,8 @@ def get_standard_logging_object_payload(
             standard_built_in_tools_params=standard_built_in_tools_params,
         )
 
-        emit_standard_logging_payload(payload)
+        # emit_standard_logging_payload(payload) - Moved to success_handler to prevent double emitting
+
         return payload
     except Exception as e:
         verbose_logger.exception(
diff --git a/litellm/litellm_core_utils/llm_cost_calc/utils.py b/litellm/litellm_core_utils/llm_cost_calc/utils.py
index 65e77f014a3..785976ed319 100644
--- a/litellm/litellm_core_utils/llm_cost_calc/utils.py
+++ b/litellm/litellm_core_utils/llm_cost_calc/utils.py
@@ -354,7 +354,7 @@ class PromptTokensDetailsResult(TypedDict):
     image_tokens: int
     character_count: int
     image_count: int
-    video_length_seconds: int
+    video_length_seconds: float
 
 
 def _parse_prompt_tokens_details(usage: Usage) -> PromptTokensDetailsResult:
@@ -400,10 +400,10 @@ def _parse_prompt_tokens_details(usage: Usage) -> PromptTokensDetailsResult:
     )
     video_length_seconds = (
         cast(
-            Optional[int],
+            Optional[float],
             getattr(usage.prompt_tokens_details, "video_length_seconds", 0),
         )
-        or 0
+        or 0.0
     )
 
     return PromptTokensDetailsResult(
@@ -415,7 +415,7 @@ def _parse_prompt_tokens_details(usage: Usage) -> PromptTokensDetailsResult:
         image_tokens=image_tokens,
         character_count=character_count,
         image_count=image_count,
-        video_length_seconds=video_length_seconds,
+        video_length_seconds=float(video_length_seconds),
     )
 
 
@@ -561,7 +561,7 @@ def generic_cost_per_token(  # noqa: PLR0915
         image_tokens=0,
         character_count=0,
         image_count=0,
-        video_length_seconds=0,
+        video_length_seconds=0.0,
     )
     if usage.prompt_tokens_details:
         prompt_tokens_details = _parse_prompt_tokens_details(usage)
diff --git a/litellm/litellm_core_utils/prompt_templates/factory.py b/litellm/litellm_core_utils/prompt_templates/factory.py
index 21a79af2bd4..26f5eb7e73b 100644
--- a/litellm/litellm_core_utils/prompt_templates/factory.py
+++ b/litellm/litellm_core_utils/prompt_templates/factory.py
@@ -6,7 +6,7 @@ import mimetypes
 import re
 import xml.etree.ElementTree as ET
 from enum import Enum
-from typing import Any, Dict, List, Optional, Tuple, Union, cast, overload
+from typing import Any, Dict, List, Optional, Set, Tuple, Union, cast, overload
 
 from jinja2.sandbox import ImmutableSandboxedEnvironment
 
@@ -2143,6 +2143,9 @@ def anthropic_messages_pt(  # noqa: PLR0915
         if user_content:
             new_messages.append({"role": "user", "content": user_content})
 
+        # Track unique tool IDs in this merge block to avoid duplication
+        unique_tool_ids: Set[str] = set()
+
         assistant_content: List[AnthropicMessagesAssistantMessageValues] = []
         ## MERGE CONSECUTIVE ASSISTANT CONTENT ##
         while msg_i < len(messages) and messages[msg_i]["role"] == "assistant":
@@ -2236,13 +2239,25 @@ def anthropic_messages_pt(  # noqa: PLR0915
                     assistant_tool_calls,
                     web_search_results=_web_search_results,
                 )
-                # AnthropicMessagesAssistantMessageValues includes AnthropicMessagesToolUseParam
-                assistant_content.extend(
-                    cast(
-                        List[AnthropicMessagesAssistantMessageValues],
-                        tool_invoke_results,
+
+                # Prevent "tool_use ids must be unique" errors by filtering duplicates
+                # This can happen when merging history that already contains the tool calls
+                for item in tool_invoke_results:
+                    # tool_use items are typically dicts, but handle objects just in case
+                    item_id = (
+                        item.get("id")
+                        if isinstance(item, dict)
+                        else getattr(item, "id", None)
+                    )
+
+                    if item_id:
+                        if item_id in unique_tool_ids:
+                            continue
+                        unique_tool_ids.add(item_id)
+
+                    assistant_content.append(
+                        cast(AnthropicMessagesAssistantMessageValues, item)
                     )
-                )
 
             assistant_function_call = assistant_content_block.get("function_call")
 
diff --git a/litellm/llms/anthropic/chat/handler.py b/litellm/llms/anthropic/chat/handler.py
index 9cc8c24ed13..6a9aafd076b 100644
--- a/litellm/llms/anthropic/chat/handler.py
+++ b/litellm/llms/anthropic/chat/handler.py
@@ -317,6 +317,7 @@ class AnthropicChatCompletion(BaseLLM):
         stream = optional_params.pop("stream", None)
         json_mode: bool = optional_params.pop("json_mode", False)
         is_vertex_request: bool = optional_params.pop("is_vertex_request", False)
+        optional_params.pop("vertex_count_tokens_location", None)
         _is_function_call = False
         messages = copy.deepcopy(messages)
         headers = AnthropicConfig().validate_environment(
diff --git a/litellm/llms/anthropic/common_utils.py b/litellm/llms/anthropic/common_utils.py
index fcbe9823ed4..cb23d21fbc9 100644
--- a/litellm/llms/anthropic/common_utils.py
+++ b/litellm/llms/anthropic/common_utils.py
@@ -2,7 +2,7 @@
 This file contains common utils for anthropic calls.
 """
 
-from typing import Any, Dict, List, Optional, Union
+from typing import Dict, List, Optional, Union
 
 import httpx
 
@@ -14,11 +14,36 @@ from litellm.llms.base_llm.base_utils import BaseLLMModelInfo, BaseTokenCounter
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.types.llms.anthropic import (
     ANTHROPIC_HOSTED_TOOLS,
+    ANTHROPIC_OAUTH_BETA_HEADER,
+    ANTHROPIC_OAUTH_TOKEN_PREFIX,
     AllAnthropicToolsValues,
     AnthropicMcpServerTool,
 )
 from litellm.types.llms.openai import AllMessageValues
-from litellm.types.utils import TokenCountResponse
+
+
+def optionally_handle_anthropic_oauth(
+    headers: dict, api_key: Optional[str]
+) -> tuple[dict, Optional[str]]:
+    """
+    Handle Anthropic OAuth token detection and header setup.
+
+    If an OAuth token is detected in the Authorization header, extracts it
+    and sets the required OAuth headers.
+
+    Args:
+        headers: Request headers dict
+        api_key: Current API key (may be None)
+
+    Returns:
+        Tuple of (updated headers, api_key)
+    """
+    auth_header = headers.get("authorization", "")
+    if auth_header and auth_header.startswith(f"Bearer {ANTHROPIC_OAUTH_TOKEN_PREFIX}"):
+        api_key = auth_header.replace("Bearer ", "")
+        headers["anthropic-beta"] = ANTHROPIC_OAUTH_BETA_HEADER
+        headers["anthropic-dangerous-direct-browser-access"] = "true"
+    return headers, api_key
 
 
 class AnthropicError(BaseLLMException):
@@ -372,6 +397,8 @@ class AnthropicModelInfo(BaseLLMModelInfo):
         api_key: Optional[str] = None,
         api_base: Optional[str] = None,
     ) -> Dict:
+        # Check for Anthropic OAuth token in headers
+        headers, api_key = optionally_handle_anthropic_oauth(headers=headers, api_key=api_key)
         if api_key is None:
             raise litellm.AuthenticationError(
                 message="Missing Anthropic API Key - A call is being made to anthropic but no key is set either in the environment variables or via params. Please set `ANTHROPIC_API_KEY` in your environment vars",
@@ -476,45 +503,11 @@ class AnthropicModelInfo(BaseLLMModelInfo):
         Returns:
             AnthropicTokenCounter instance for this provider.
         """
-        return AnthropicTokenCounter()
-
-
-class AnthropicTokenCounter(BaseTokenCounter):
-    """Token counter implementation for Anthropic provider."""
-
-    def should_use_token_counting_api(
-        self, 
-        custom_llm_provider: Optional[str] = None,
-    ) -> bool:
-        from litellm.types.utils import LlmProviders
-        return custom_llm_provider == LlmProviders.ANTHROPIC.value
-    
-    async def count_tokens(
-        self,
-        model_to_use: str,
-        messages: Optional[List[Dict[str, Any]]],
-        contents: Optional[List[Dict[str, Any]]],
-        deployment: Optional[Dict[str, Any]] = None,
-        request_model: str = "",
-    ) -> Optional[TokenCountResponse]:
-        from litellm.proxy.utils import count_tokens_with_anthropic_api
-        
-        result = await count_tokens_with_anthropic_api(
-            model_to_use=model_to_use,
-            messages=messages,
-            deployment=deployment,
+        from litellm.llms.anthropic.count_tokens.token_counter import (
+            AnthropicTokenCounter,
         )
-        
-        if result is not None:
-            return TokenCountResponse(
-                total_tokens=result.get("total_tokens", 0),
-                request_model=request_model,
-                model_used=model_to_use,
-                tokenizer_type=result.get("tokenizer_used", ""),
-                original_response=result,
-            )
-        
-        return None
+
+        return AnthropicTokenCounter()
 
 
 def process_anthropic_headers(headers: Union[httpx.Headers, dict]) -> dict:
diff --git a/litellm/llms/anthropic/count_tokens/__init__.py b/litellm/llms/anthropic/count_tokens/__init__.py
new file mode 100644
index 00000000000..ef46862bda6
--- /dev/null
+++ b/litellm/llms/anthropic/count_tokens/__init__.py
@@ -0,0 +1,15 @@
+"""
+Anthropic CountTokens API implementation.
+"""
+
+from litellm.llms.anthropic.count_tokens.handler import AnthropicCountTokensHandler
+from litellm.llms.anthropic.count_tokens.token_counter import AnthropicTokenCounter
+from litellm.llms.anthropic.count_tokens.transformation import (
+    AnthropicCountTokensConfig,
+)
+
+__all__ = [
+    "AnthropicCountTokensHandler",
+    "AnthropicCountTokensConfig",
+    "AnthropicTokenCounter",
+]
diff --git a/litellm/llms/anthropic/count_tokens/handler.py b/litellm/llms/anthropic/count_tokens/handler.py
new file mode 100644
index 00000000000..5b5354228f9
--- /dev/null
+++ b/litellm/llms/anthropic/count_tokens/handler.py
@@ -0,0 +1,122 @@
+"""
+Anthropic CountTokens API handler.
+
+Uses httpx for HTTP requests instead of the Anthropic SDK.
+"""
+
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+import litellm
+from litellm._logging import verbose_logger
+from litellm.llms.anthropic.common_utils import AnthropicError
+from litellm.llms.anthropic.count_tokens.transformation import (
+    AnthropicCountTokensConfig,
+)
+from litellm.llms.custom_httpx.http_handler import get_async_httpx_client
+
+
+class AnthropicCountTokensHandler(AnthropicCountTokensConfig):
+    """
+    Handler for Anthropic CountTokens API requests.
+
+    Uses httpx for HTTP requests, following the same pattern as BedrockCountTokensHandler.
+    """
+
+    async def handle_count_tokens_request(
+        self,
+        model: str,
+        messages: List[Dict[str, Any]],
+        api_key: str,
+        api_base: Optional[str] = None,
+        timeout: Optional[Union[float, httpx.Timeout]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Handle a CountTokens request using httpx.
+
+        Args:
+            model: The model identifier (e.g., "claude-3-5-sonnet-20241022")
+            messages: The messages to count tokens for
+            api_key: The Anthropic API key
+            api_base: Optional custom API base URL
+            timeout: Optional timeout for the request (defaults to litellm.request_timeout)
+
+        Returns:
+            Dictionary containing token count response
+
+        Raises:
+            AnthropicError: If the API request fails
+        """
+        try:
+            # Validate the request
+            self.validate_request(model, messages)
+
+            verbose_logger.debug(
+                f"Processing Anthropic CountTokens request for model: {model}"
+            )
+
+            # Transform request to Anthropic format
+            request_body = self.transform_request_to_count_tokens(
+                model=model,
+                messages=messages,
+            )
+
+            verbose_logger.debug(f"Transformed request: {request_body}")
+
+            # Get endpoint URL
+            endpoint_url = api_base or self.get_anthropic_count_tokens_endpoint()
+
+            verbose_logger.debug(f"Making request to: {endpoint_url}")
+
+            # Get required headers
+            headers = self.get_required_headers(api_key)
+
+            # Use LiteLLM's async httpx client
+            async_client = get_async_httpx_client(
+                llm_provider=litellm.LlmProviders.ANTHROPIC
+            )
+
+            # Use provided timeout or fall back to litellm.request_timeout
+            request_timeout = timeout if timeout is not None else litellm.request_timeout
+
+            response = await async_client.post(
+                endpoint_url,
+                headers=headers,
+                json=request_body,
+                timeout=request_timeout,
+            )
+
+            verbose_logger.debug(f"Response status: {response.status_code}")
+
+            if response.status_code != 200:
+                error_text = response.text
+                verbose_logger.error(f"Anthropic API error: {error_text}")
+                raise AnthropicError(
+                    status_code=response.status_code,
+                    message=error_text,
+                )
+
+            anthropic_response = response.json()
+
+            verbose_logger.debug(f"Anthropic response: {anthropic_response}")
+
+            # Return Anthropic response directly - no transformation needed
+            return anthropic_response
+
+        except AnthropicError:
+            # Re-raise Anthropic exceptions as-is
+            raise
+        except httpx.HTTPStatusError as e:
+            # HTTP errors - preserve the actual status code
+            verbose_logger.error(f"HTTP error in CountTokens handler: {str(e)}")
+            raise AnthropicError(
+                status_code=e.response.status_code,
+                message=e.response.text,
+            )
+        except Exception as e:
+            verbose_logger.error(f"Error in CountTokens handler: {str(e)}")
+            raise AnthropicError(
+                status_code=500,
+                message=f"CountTokens processing error: {str(e)}",
+            )
diff --git a/litellm/llms/anthropic/count_tokens/token_counter.py b/litellm/llms/anthropic/count_tokens/token_counter.py
new file mode 100644
index 00000000000..266b2794fc3
--- /dev/null
+++ b/litellm/llms/anthropic/count_tokens/token_counter.py
@@ -0,0 +1,104 @@
+"""
+Anthropic Token Counter implementation using the CountTokens API.
+"""
+
+import os
+from typing import Any, Dict, List, Optional
+
+from litellm._logging import verbose_logger
+from litellm.llms.anthropic.count_tokens.handler import AnthropicCountTokensHandler
+from litellm.llms.base_llm.base_utils import BaseTokenCounter
+from litellm.types.utils import LlmProviders, TokenCountResponse
+
+# Global handler instance - reuse across all token counting requests
+anthropic_count_tokens_handler = AnthropicCountTokensHandler()
+
+
+class AnthropicTokenCounter(BaseTokenCounter):
+    """Token counter implementation for Anthropic provider using the CountTokens API."""
+
+    def should_use_token_counting_api(
+        self,
+        custom_llm_provider: Optional[str] = None,
+    ) -> bool:
+        return custom_llm_provider == LlmProviders.ANTHROPIC.value
+
+    async def count_tokens(
+        self,
+        model_to_use: str,
+        messages: Optional[List[Dict[str, Any]]],
+        contents: Optional[List[Dict[str, Any]]],
+        deployment: Optional[Dict[str, Any]] = None,
+        request_model: str = "",
+    ) -> Optional[TokenCountResponse]:
+        """
+        Count tokens using Anthropic's CountTokens API.
+
+        Args:
+            model_to_use: The model identifier
+            messages: The messages to count tokens for
+            contents: Alternative content format (not used for Anthropic)
+            deployment: Deployment configuration containing litellm_params
+            request_model: The original request model name
+
+        Returns:
+            TokenCountResponse with token count, or None if counting fails
+        """
+        from litellm.llms.anthropic.common_utils import AnthropicError
+
+        if not messages:
+            return None
+
+        deployment = deployment or {}
+        litellm_params = deployment.get("litellm_params", {})
+
+        # Get Anthropic API key from deployment config or environment
+        api_key = litellm_params.get("api_key")
+        if not api_key:
+            api_key = os.getenv("ANTHROPIC_API_KEY")
+
+        if not api_key:
+            verbose_logger.warning("No Anthropic API key found for token counting")
+            return None
+
+        try:
+            result = await anthropic_count_tokens_handler.handle_count_tokens_request(
+                model=model_to_use,
+                messages=messages,
+                api_key=api_key,
+            )
+
+            if result is not None:
+                return TokenCountResponse(
+                    total_tokens=result.get("input_tokens", 0),
+                    request_model=request_model,
+                    model_used=model_to_use,
+                    tokenizer_type="anthropic_api",
+                    original_response=result,
+                )
+        except AnthropicError as e:
+            verbose_logger.warning(
+                f"Anthropic CountTokens API error: status={e.status_code}, message={e.message}"
+            )
+            return TokenCountResponse(
+                total_tokens=0,
+                request_model=request_model,
+                model_used=model_to_use,
+                tokenizer_type="anthropic_api",
+                error=True,
+                error_message=e.message,
+                status_code=e.status_code,
+            )
+        except Exception as e:
+            verbose_logger.warning(f"Error calling Anthropic CountTokens API: {e}")
+            return TokenCountResponse(
+                total_tokens=0,
+                request_model=request_model,
+                model_used=model_to_use,
+                tokenizer_type="anthropic_api",
+                error=True,
+                error_message=str(e),
+                status_code=500,
+            )
+
+        return None
diff --git a/litellm/llms/anthropic/count_tokens/transformation.py b/litellm/llms/anthropic/count_tokens/transformation.py
new file mode 100644
index 00000000000..c3ad72436b4
--- /dev/null
+++ b/litellm/llms/anthropic/count_tokens/transformation.py
@@ -0,0 +1,103 @@
+"""
+Anthropic CountTokens API transformation logic.
+
+This module handles the transformation of requests to Anthropic's CountTokens API format.
+"""
+
+from typing import Any, Dict, List
+
+from litellm.constants import ANTHROPIC_TOKEN_COUNTING_BETA_VERSION
+
+
+class AnthropicCountTokensConfig:
+    """
+    Configuration and transformation logic for Anthropic CountTokens API.
+
+    Anthropic CountTokens API Specification:
+    - Endpoint: POST https://api.anthropic.com/v1/messages/count_tokens
+    - Beta header required: anthropic-beta: token-counting-2024-11-01
+    - Response: {"input_tokens": <number>}
+    """
+
+    def get_anthropic_count_tokens_endpoint(self) -> str:
+        """
+        Get the Anthropic CountTokens API endpoint.
+
+        Returns:
+            The endpoint URL for the CountTokens API
+        """
+        return "https://api.anthropic.com/v1/messages/count_tokens"
+
+    def transform_request_to_count_tokens(
+        self,
+        model: str,
+        messages: List[Dict[str, Any]],
+    ) -> Dict[str, Any]:
+        """
+        Transform request to Anthropic CountTokens format.
+
+        Input:
+        {
+            "model": "claude-3-5-sonnet-20241022",
+            "messages": [{"role": "user", "content": "Hello!"}]
+        }
+
+        Output (Anthropic CountTokens format):
+        {
+            "model": "claude-3-5-sonnet-20241022",
+            "messages": [{"role": "user", "content": "Hello!"}]
+        }
+        """
+        return {
+            "model": model,
+            "messages": messages,
+        }
+
+    def get_required_headers(self, api_key: str) -> Dict[str, str]:
+        """
+        Get the required headers for the CountTokens API.
+
+        Args:
+            api_key: The Anthropic API key
+
+        Returns:
+            Dictionary of required headers
+        """
+        return {
+            "Content-Type": "application/json",
+            "x-api-key": api_key,
+            "anthropic-version": "2023-06-01",
+            "anthropic-beta": ANTHROPIC_TOKEN_COUNTING_BETA_VERSION,
+        }
+
+    def validate_request(
+        self, model: str, messages: List[Dict[str, Any]]
+    ) -> None:
+        """
+        Validate the incoming count tokens request.
+
+        Args:
+            model: The model name
+            messages: The messages to count tokens for
+
+        Raises:
+            ValueError: If the request is invalid
+        """
+        if not model:
+            raise ValueError("model parameter is required")
+
+        if not messages:
+            raise ValueError("messages parameter is required")
+
+        if not isinstance(messages, list):
+            raise ValueError("messages must be a list")
+
+        for i, message in enumerate(messages):
+            if not isinstance(message, dict):
+                raise ValueError(f"Message {i} must be a dictionary")
+
+            if "role" not in message:
+                raise ValueError(f"Message {i} must have a 'role' field")
+
+            if "content" not in message:
+                raise ValueError(f"Message {i} must have a 'content' field")
diff --git a/litellm/llms/anthropic/experimental_pass_through/messages/transformation.py b/litellm/llms/anthropic/experimental_pass_through/messages/transformation.py
index f67e4c8382c..7135102db01 100644
--- a/litellm/llms/anthropic/experimental_pass_through/messages/transformation.py
+++ b/litellm/llms/anthropic/experimental_pass_through/messages/transformation.py
@@ -17,7 +17,11 @@ from litellm.types.llms.anthropic_messages.anthropic_response import (
 from litellm.types.llms.anthropic_tool_search import get_tool_search_beta_header
 from litellm.types.router import GenericLiteLLMParams
 
-from ...common_utils import AnthropicError, AnthropicModelInfo
+from ...common_utils import (
+    AnthropicError,
+    AnthropicModelInfo,
+    optionally_handle_anthropic_oauth,
+)
 
 DEFAULT_ANTHROPIC_API_BASE = "https://api.anthropic.com"
 DEFAULT_ANTHROPIC_API_VERSION = "2023-06-01"
@@ -68,8 +72,11 @@ class AnthropicMessagesConfig(BaseAnthropicMessagesConfig):
     ) -> Tuple[dict, Optional[str]]:
         import os
 
+        # Check for Anthropic OAuth token in Authorization header
+        headers, api_key = optionally_handle_anthropic_oauth(headers=headers, api_key=api_key)
         if api_key is None:
             api_key = os.getenv("ANTHROPIC_API_KEY")
+
         if "x-api-key" not in headers and api_key:
             headers["x-api-key"] = api_key
         if "anthropic-version" not in headers:
diff --git a/litellm/llms/azure/azure.py b/litellm/llms/azure/azure.py
index 7250d6fc94c..cb9fe0aeb30 100644
--- a/litellm/llms/azure/azure.py
+++ b/litellm/llms/azure/azure.py
@@ -4,7 +4,13 @@ import time
 from typing import Any, Callable, Coroutine, Dict, List, Optional, Union
 
 import httpx  # type: ignore
-from openai import APITimeoutError, AsyncAzureOpenAI, AzureOpenAI
+from openai import (
+    APITimeoutError,
+    AsyncAzureOpenAI,
+    AsyncOpenAI,
+    AzureOpenAI,
+    OpenAI,
+)
 
 import litellm
 from litellm.constants import AZURE_OPERATION_POLLING_TIMEOUT, DEFAULT_MAX_RETRIES
@@ -128,7 +134,7 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
 
     def make_sync_azure_openai_chat_completion_request(
         self,
-        azure_client: AzureOpenAI,
+        azure_client: Union[AzureOpenAI, OpenAI],
         data: dict,
         timeout: Union[float, httpx.Timeout],
     ):
@@ -151,7 +157,7 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
     @track_llm_api_timing()
     async def make_azure_openai_chat_completion_request(
         self,
-        azure_client: AsyncAzureOpenAI,
+        azure_client: Union[AsyncAzureOpenAI, AsyncOpenAI],
         data: dict,
         timeout: Union[float, httpx.Timeout],
         logging_obj: LiteLLMLoggingObj,
@@ -328,10 +334,10 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
                     _is_async=False,
                     litellm_params=litellm_params,
                 )
-                if not isinstance(azure_client, AzureOpenAI):
+                if not isinstance(azure_client, (AzureOpenAI, OpenAI)):
                     raise AzureOpenAIError(
                         status_code=500,
-                        message="azure_client is not an instance of AzureOpenAI",
+                        message="azure_client is not an instance of AzureOpenAI or OpenAI",
                     )
 
                 headers, response = self.make_sync_azure_openai_chat_completion_request(
@@ -401,8 +407,8 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
                 _is_async=True,
                 litellm_params=litellm_params,
             )
-            if not isinstance(azure_client, AsyncAzureOpenAI):
-                raise ValueError("Azure client is not an instance of AsyncAzureOpenAI")
+            if not isinstance(azure_client, (AsyncAzureOpenAI, AsyncOpenAI)):
+                raise ValueError("Azure client is not an instance of AsyncAzureOpenAI or AsyncOpenAI")
             ## LOGGING
             logging_obj.pre_call(
                 input=data["messages"],
@@ -412,7 +418,7 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
                         "api_key": api_key,
                         "azure_ad_token": azure_ad_token,
                     },
-                    "api_base": azure_client._base_url._uri_reference,
+                    "api_base": api_base,
                     "acompletion": True,
                     "complete_input_dict": data,
                 },
@@ -520,10 +526,10 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
             _is_async=False,
             litellm_params=litellm_params,
         )
-        if not isinstance(azure_client, AzureOpenAI):
+        if not isinstance(azure_client, (AzureOpenAI, OpenAI)):
             raise AzureOpenAIError(
                 status_code=500,
-                message="azure_client is not an instance of AzureOpenAI",
+                message="azure_client is not an instance of AzureOpenAI or OpenAI",
             )
         ## LOGGING
         logging_obj.pre_call(
@@ -534,7 +540,7 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
                     "api_key": api_key,
                     "azure_ad_token": azure_ad_token,
                 },
-                "api_base": azure_client._base_url._uri_reference,
+                "api_base": api_base,
                 "acompletion": True,
                 "complete_input_dict": data,
             },
@@ -578,8 +584,8 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
                 _is_async=True,
                 litellm_params=litellm_params,
             )
-            if not isinstance(azure_client, AsyncAzureOpenAI):
-                raise ValueError("Azure client is not an instance of AsyncAzureOpenAI")
+            if not isinstance(azure_client, (AsyncAzureOpenAI, AsyncOpenAI)):
+                raise ValueError("Azure client is not an instance of AsyncAzureOpenAI or AsyncOpenAI")
 
             ## LOGGING
             logging_obj.pre_call(
@@ -590,7 +596,7 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
                         "api_key": api_key,
                         "azure_ad_token": azure_ad_token,
                     },
-                    "api_base": azure_client._base_url._uri_reference,
+                    "api_base": api_base,
                     "acompletion": True,
                     "complete_input_dict": data,
                 },
@@ -657,8 +663,8 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
                 client=client,
                 litellm_params=litellm_params,
             )
-            if not isinstance(openai_aclient, AsyncAzureOpenAI):
-                raise ValueError("Azure client is not an instance of AsyncAzureOpenAI")
+            if not isinstance(openai_aclient, (AsyncAzureOpenAI, AsyncOpenAI)):
+                raise ValueError("Azure client is not an instance of AsyncAzureOpenAI or AsyncOpenAI")
 
             raw_response = await openai_aclient.embeddings.with_raw_response.create(
                 **data, timeout=timeout
@@ -776,10 +782,10 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
                 client=client,
                 litellm_params=litellm_params,
             )
-            if not isinstance(azure_client, AzureOpenAI):
+            if not isinstance(azure_client, (AzureOpenAI, OpenAI)):
                 raise AzureOpenAIError(
                     status_code=500,
-                    message="azure_client is not an instance of AzureOpenAI",
+                    message="azure_client is not an instance of AzureOpenAI or OpenAI",
                 )
 
             ## COMPLETION CALL
diff --git a/litellm/llms/azure/batches/handler.py b/litellm/llms/azure/batches/handler.py
index 7fc6388ba87..3996cb808e4 100644
--- a/litellm/llms/azure/batches/handler.py
+++ b/litellm/llms/azure/batches/handler.py
@@ -6,6 +6,8 @@ from typing import Any, Coroutine, Optional, Union, cast
 
 import httpx
 
+from openai import AsyncOpenAI, OpenAI
+
 from litellm.llms.azure.azure import AsyncAzureOpenAI, AzureOpenAI
 from litellm.types.llms.openai import (
     Batch,
@@ -33,7 +35,7 @@ class AzureBatchesAPI(BaseAzureLLM):
     async def acreate_batch(
         self,
         create_batch_data: CreateBatchRequest,
-        azure_client: AsyncAzureOpenAI,
+        azure_client: Union[AsyncAzureOpenAI, AsyncOpenAI],
     ) -> LiteLLMBatch:
         response = await azure_client.batches.create(**create_batch_data)
         return LiteLLMBatch(**response.model_dump())
@@ -47,11 +49,11 @@ class AzureBatchesAPI(BaseAzureLLM):
         api_version: Optional[str],
         timeout: Union[float, httpx.Timeout],
         max_retries: Optional[int],
-        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI]] = None,
+        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]] = None,
         litellm_params: Optional[dict] = None,
     ) -> Union[LiteLLMBatch, Coroutine[Any, Any, LiteLLMBatch]]:
         azure_client: Optional[
-            Union[AzureOpenAI, AsyncAzureOpenAI]
+            Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]
         ] = self.get_azure_openai_client(
             api_key=api_key,
             api_base=api_base,
@@ -66,20 +68,20 @@ class AzureBatchesAPI(BaseAzureLLM):
             )
 
         if _is_async is True:
-            if not isinstance(azure_client, AsyncAzureOpenAI):
+            if not isinstance(azure_client, (AsyncAzureOpenAI, AsyncOpenAI)):
                 raise ValueError(
                     "OpenAI client is not an instance of AsyncOpenAI. Make sure you passed an AsyncOpenAI client."
                 )
             return self.acreate_batch(  # type: ignore
                 create_batch_data=create_batch_data, azure_client=azure_client
             )
-        response = cast(AzureOpenAI, azure_client).batches.create(**create_batch_data)
+        response = cast(Union[AzureOpenAI, OpenAI], azure_client).batches.create(**create_batch_data)
         return LiteLLMBatch(**response.model_dump())
 
     async def aretrieve_batch(
         self,
         retrieve_batch_data: RetrieveBatchRequest,
-        client: AsyncAzureOpenAI,
+        client: Union[AsyncAzureOpenAI, AsyncOpenAI],
     ) -> LiteLLMBatch:
         response = await client.batches.retrieve(**retrieve_batch_data)
         return LiteLLMBatch(**response.model_dump())
@@ -93,11 +95,11 @@ class AzureBatchesAPI(BaseAzureLLM):
         api_version: Optional[str],
         timeout: Union[float, httpx.Timeout],
         max_retries: Optional[int],
-        client: Optional[AzureOpenAI] = None,
+        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]] = None,
         litellm_params: Optional[dict] = None,
     ):
         azure_client: Optional[
-            Union[AzureOpenAI, AsyncAzureOpenAI]
+            Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]
         ] = self.get_azure_openai_client(
             api_key=api_key,
             api_base=api_base,
@@ -112,14 +114,14 @@ class AzureBatchesAPI(BaseAzureLLM):
             )
 
         if _is_async is True:
-            if not isinstance(azure_client, AsyncAzureOpenAI):
+            if not isinstance(azure_client, (AsyncAzureOpenAI, AsyncOpenAI)):
                 raise ValueError(
                     "OpenAI client is not an instance of AsyncOpenAI. Make sure you passed an AsyncOpenAI client."
                 )
             return self.aretrieve_batch(  # type: ignore
                 retrieve_batch_data=retrieve_batch_data, client=azure_client
             )
-        response = cast(AzureOpenAI, azure_client).batches.retrieve(
+        response = cast(Union[AzureOpenAI, OpenAI], azure_client).batches.retrieve(
             **retrieve_batch_data
         )
         return LiteLLMBatch(**response.model_dump())
@@ -127,7 +129,7 @@ class AzureBatchesAPI(BaseAzureLLM):
     async def acancel_batch(
         self,
         cancel_batch_data: CancelBatchRequest,
-        client: AsyncAzureOpenAI,
+        client: Union[AsyncAzureOpenAI, AsyncOpenAI],
     ) -> Batch:
         response = await client.batches.cancel(**cancel_batch_data)
         return response
@@ -141,11 +143,11 @@ class AzureBatchesAPI(BaseAzureLLM):
         api_version: Optional[str],
         timeout: Union[float, httpx.Timeout],
         max_retries: Optional[int],
-        client: Optional[AzureOpenAI] = None,
+        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]] = None,
         litellm_params: Optional[dict] = None,
     ):
         azure_client: Optional[
-            Union[AzureOpenAI, AsyncAzureOpenAI]
+            Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]
         ] = self.get_azure_openai_client(
             api_key=api_key,
             api_base=api_base,
@@ -163,7 +165,7 @@ class AzureBatchesAPI(BaseAzureLLM):
 
     async def alist_batches(
         self,
-        client: AsyncAzureOpenAI,
+        client: Union[AsyncAzureOpenAI, AsyncOpenAI],
         after: Optional[str] = None,
         limit: Optional[int] = None,
     ):
@@ -180,11 +182,11 @@ class AzureBatchesAPI(BaseAzureLLM):
         max_retries: Optional[int],
         after: Optional[str] = None,
         limit: Optional[int] = None,
-        client: Optional[AzureOpenAI] = None,
+        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]] = None,
         litellm_params: Optional[dict] = None,
     ):
         azure_client: Optional[
-            Union[AzureOpenAI, AsyncAzureOpenAI]
+            Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]
         ] = self.get_azure_openai_client(
             api_key=api_key,
             api_base=api_base,
@@ -199,7 +201,7 @@ class AzureBatchesAPI(BaseAzureLLM):
             )
 
         if _is_async is True:
-            if not isinstance(azure_client, AsyncAzureOpenAI):
+            if not isinstance(azure_client, (AsyncAzureOpenAI, AsyncOpenAI)):
                 raise ValueError(
                     "OpenAI client is not an instance of AsyncOpenAI. Make sure you passed an AsyncOpenAI client."
                 )
diff --git a/litellm/llms/azure/common_utils.py b/litellm/llms/azure/common_utils.py
index 85596a628da..25b218fca8c 100644
--- a/litellm/llms/azure/common_utils.py
+++ b/litellm/llms/azure/common_utils.py
@@ -3,7 +3,7 @@ import os
 from typing import Any, Callable, Dict, Literal, Optional, Union, cast
 
 import httpx
-from openai import AsyncAzureOpenAI, AzureOpenAI
+from openai import AsyncAzureOpenAI, AsyncOpenAI, AzureOpenAI, OpenAI
 
 import litellm
 from litellm._logging import verbose_logger
@@ -439,12 +439,12 @@ class BaseAzureLLM(BaseOpenAILLM):
         api_key: Optional[str],
         api_base: Optional[str],
         api_version: Optional[str] = None,
-        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI]] = None,
+        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]] = None,
         litellm_params: Optional[dict] = None,
         _is_async: bool = False,
         model: Optional[str] = None,
-    ) -> Optional[Union[AzureOpenAI, AsyncAzureOpenAI]]:
-        openai_client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI]] = None
+    ) -> Optional[Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]]:
+        openai_client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]] = None
         client_initialization_params: dict = locals()
         client_initialization_params["is_async"] = _is_async
         if client is None:
@@ -453,9 +453,7 @@ class BaseAzureLLM(BaseOpenAILLM):
                 client_type="azure",
             )
             if cached_client:
-                if isinstance(cached_client, AzureOpenAI) or isinstance(
-                    cached_client, AsyncAzureOpenAI
-                ):
+                if isinstance(cached_client, (AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI)):
                     return cached_client
 
             azure_client_params = self.initialize_azure_sdk_client(
@@ -466,15 +464,40 @@ class BaseAzureLLM(BaseOpenAILLM):
                 api_version=api_version,
                 is_async=_is_async,
             )
-            if _is_async is True:
-                openai_client = AsyncAzureOpenAI(**azure_client_params)
+
+            # For Azure v1 API, use standard OpenAI client instead of AzureOpenAI
+            # See: https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#api-specs
+            if self._is_azure_v1_api_version(api_version):
+                # Extract only params that OpenAI client accepts
+                # Always use /openai/v1/ regardless of whether user passed "v1", "latest", or "preview"
+                v1_params = {
+                    "api_key": azure_client_params.get("api_key"),
+                    "base_url": f"{api_base}/openai/v1/",
+                }
+                if "timeout" in azure_client_params:
+                    v1_params["timeout"] = azure_client_params["timeout"]
+                if "max_retries" in azure_client_params:
+                    v1_params["max_retries"] = azure_client_params["max_retries"]
+                if "http_client" in azure_client_params:
+                    v1_params["http_client"] = azure_client_params["http_client"]
+
+                verbose_logger.debug(f"Using Azure v1 API with base_url: {v1_params['base_url']}")
+
+                if _is_async is True:
+                    openai_client = AsyncOpenAI(**v1_params)  # type: ignore
+                else:
+                    openai_client = OpenAI(**v1_params)  # type: ignore
             else:
-                openai_client = AzureOpenAI(**azure_client_params)  # type: ignore
+                # Traditional Azure API uses AzureOpenAI client
+                if _is_async is True:
+                    openai_client = AsyncAzureOpenAI(**azure_client_params)
+                else:
+                    openai_client = AzureOpenAI(**azure_client_params)  # type: ignore
         else:
             openai_client = client
             if api_version is not None and isinstance(
-                openai_client._custom_query, dict
-            ):
+                openai_client, (AzureOpenAI, AsyncAzureOpenAI)
+            ) and isinstance(openai_client._custom_query, dict):
                 # set api_version to version passed by user
                 openai_client._custom_query.setdefault("api-version", api_version)
 
diff --git a/litellm/llms/azure/files/handler.py b/litellm/llms/azure/files/handler.py
index 69b2d71753b..e53ced6b0e2 100644
--- a/litellm/llms/azure/files/handler.py
+++ b/litellm/llms/azure/files/handler.py
@@ -1,7 +1,7 @@
 from typing import Any, Coroutine, Optional, Union, cast
 
 import httpx
-from openai import AsyncAzureOpenAI, AzureOpenAI
+from openai import AsyncAzureOpenAI, AsyncOpenAI, AzureOpenAI, OpenAI
 from openai.types.file_deleted import FileDeleted
 
 from litellm._logging import verbose_logger
@@ -40,7 +40,7 @@ class AzureOpenAIFilesAPI(BaseAzureLLM):
     async def acreate_file(
         self,
         create_file_data: CreateFileRequest,
-        openai_client: AsyncAzureOpenAI,
+        openai_client: Union[AsyncAzureOpenAI, AsyncOpenAI],
     ) -> OpenAIFileObject:
         verbose_logger.debug("create_file_data=%s", create_file_data)
         response = await openai_client.files.create(**self._prepare_create_file_data(create_file_data))  # type: ignore[arg-type]
@@ -56,11 +56,11 @@ class AzureOpenAIFilesAPI(BaseAzureLLM):
         api_version: Optional[str],
         timeout: Union[float, httpx.Timeout],
         max_retries: Optional[int],
-        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI]] = None,
+        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]] = None,
         litellm_params: Optional[dict] = None,
     ) -> Union[OpenAIFileObject, Coroutine[Any, Any, OpenAIFileObject]]:
         openai_client: Optional[
-            Union[AzureOpenAI, AsyncAzureOpenAI]
+            Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]
         ] = self.get_azure_openai_client(
             litellm_params=litellm_params or {},
             api_key=api_key,
@@ -75,20 +75,20 @@ class AzureOpenAIFilesAPI(BaseAzureLLM):
             )
 
         if _is_async is True:
-            if not isinstance(openai_client, AsyncAzureOpenAI):
+            if not isinstance(openai_client, (AsyncAzureOpenAI, AsyncOpenAI)):
                 raise ValueError(
                     "AzureOpenAI client is not an instance of AsyncAzureOpenAI. Make sure you passed an AsyncAzureOpenAI client."
                 )
             return self.acreate_file(
                 create_file_data=create_file_data, openai_client=openai_client
             )
-        response = cast(AzureOpenAI, openai_client).files.create(**self._prepare_create_file_data(create_file_data))  # type: ignore[arg-type]
+        response = cast(Union[AzureOpenAI, OpenAI], openai_client).files.create(**self._prepare_create_file_data(create_file_data))  # type: ignore[arg-type]
         return OpenAIFileObject(**response.model_dump())
 
     async def afile_content(
         self,
         file_content_request: FileContentRequest,
-        openai_client: AsyncAzureOpenAI,
+        openai_client: Union[AsyncAzureOpenAI, AsyncOpenAI],
     ) -> HttpxBinaryResponseContent:
         response = await openai_client.files.content(**file_content_request)
         return HttpxBinaryResponseContent(response=response.response)
@@ -102,13 +102,13 @@ class AzureOpenAIFilesAPI(BaseAzureLLM):
         timeout: Union[float, httpx.Timeout],
         max_retries: Optional[int],
         api_version: Optional[str] = None,
-        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI]] = None,
+        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]] = None,
         litellm_params: Optional[dict] = None,
     ) -> Union[
         HttpxBinaryResponseContent, Coroutine[Any, Any, HttpxBinaryResponseContent]
     ]:
         openai_client: Optional[
-            Union[AzureOpenAI, AsyncAzureOpenAI]
+            Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]
         ] = self.get_azure_openai_client(
             litellm_params=litellm_params or {},
             api_key=api_key,
@@ -123,7 +123,7 @@ class AzureOpenAIFilesAPI(BaseAzureLLM):
             )
 
         if _is_async is True:
-            if not isinstance(openai_client, AsyncAzureOpenAI):
+            if not isinstance(openai_client, (AsyncAzureOpenAI, AsyncOpenAI)):
                 raise ValueError(
                     "AzureOpenAI client is not an instance of AsyncAzureOpenAI. Make sure you passed an AsyncAzureOpenAI client."
                 )
@@ -131,7 +131,7 @@ class AzureOpenAIFilesAPI(BaseAzureLLM):
                 file_content_request=file_content_request,
                 openai_client=openai_client,
             )
-        response = cast(AzureOpenAI, openai_client).files.content(
+        response = cast(Union[AzureOpenAI, OpenAI], openai_client).files.content(
             **file_content_request
         )
 
@@ -140,7 +140,7 @@ class AzureOpenAIFilesAPI(BaseAzureLLM):
     async def aretrieve_file(
         self,
         file_id: str,
-        openai_client: AsyncAzureOpenAI,
+        openai_client: Union[AsyncAzureOpenAI, AsyncOpenAI],
     ) -> FileObject:
         response = await openai_client.files.retrieve(file_id=file_id)
         return response
@@ -154,11 +154,11 @@ class AzureOpenAIFilesAPI(BaseAzureLLM):
         timeout: Union[float, httpx.Timeout],
         max_retries: Optional[int],
         api_version: Optional[str] = None,
-        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI]] = None,
+        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]] = None,
         litellm_params: Optional[dict] = None,
     ):
         openai_client: Optional[
-            Union[AzureOpenAI, AsyncAzureOpenAI]
+            Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]
         ] = self.get_azure_openai_client(
             litellm_params=litellm_params or {},
             api_key=api_key,
@@ -173,7 +173,7 @@ class AzureOpenAIFilesAPI(BaseAzureLLM):
             )
 
         if _is_async is True:
-            if not isinstance(openai_client, AsyncAzureOpenAI):
+            if not isinstance(openai_client, (AsyncAzureOpenAI, AsyncOpenAI)):
                 raise ValueError(
                     "AzureOpenAI client is not an instance of AsyncAzureOpenAI. Make sure you passed an AsyncAzureOpenAI client."
                 )
@@ -188,7 +188,7 @@ class AzureOpenAIFilesAPI(BaseAzureLLM):
     async def adelete_file(
         self,
         file_id: str,
-        openai_client: AsyncAzureOpenAI,
+        openai_client: Union[AsyncAzureOpenAI, AsyncOpenAI],
     ) -> FileDeleted:
         response = await openai_client.files.delete(file_id=file_id)
 
@@ -206,11 +206,11 @@ class AzureOpenAIFilesAPI(BaseAzureLLM):
         max_retries: Optional[int],
         organization: Optional[str] = None,
         api_version: Optional[str] = None,
-        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI]] = None,
+        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]] = None,
         litellm_params: Optional[dict] = None,
     ):
         openai_client: Optional[
-            Union[AzureOpenAI, AsyncAzureOpenAI]
+            Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]
         ] = self.get_azure_openai_client(
             litellm_params=litellm_params or {},
             api_key=api_key,
@@ -225,7 +225,7 @@ class AzureOpenAIFilesAPI(BaseAzureLLM):
             )
 
         if _is_async is True:
-            if not isinstance(openai_client, AsyncAzureOpenAI):
+            if not isinstance(openai_client, (AsyncAzureOpenAI, AsyncOpenAI)):
                 raise ValueError(
                     "AzureOpenAI client is not an instance of AsyncAzureOpenAI. Make sure you passed an AsyncAzureOpenAI client."
                 )
@@ -242,7 +242,7 @@ class AzureOpenAIFilesAPI(BaseAzureLLM):
 
     async def alist_files(
         self,
-        openai_client: AsyncAzureOpenAI,
+        openai_client: Union[AsyncAzureOpenAI, AsyncOpenAI],
         purpose: Optional[str] = None,
     ):
         if isinstance(purpose, str):
@@ -260,11 +260,11 @@ class AzureOpenAIFilesAPI(BaseAzureLLM):
         max_retries: Optional[int],
         purpose: Optional[str] = None,
         api_version: Optional[str] = None,
-        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI]] = None,
+        client: Optional[Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]] = None,
         litellm_params: Optional[dict] = None,
     ):
         openai_client: Optional[
-            Union[AzureOpenAI, AsyncAzureOpenAI]
+            Union[AzureOpenAI, AsyncAzureOpenAI, OpenAI, AsyncOpenAI]
         ] = self.get_azure_openai_client(
             litellm_params=litellm_params or {},
             api_key=api_key,
@@ -279,7 +279,7 @@ class AzureOpenAIFilesAPI(BaseAzureLLM):
             )
 
         if _is_async is True:
-            if not isinstance(openai_client, AsyncAzureOpenAI):
+            if not isinstance(openai_client, (AsyncAzureOpenAI, AsyncOpenAI)):
                 raise ValueError(
                     "AzureOpenAI client is not an instance of AsyncAzureOpenAI. Make sure you passed an AsyncAzureOpenAI client."
                 )
diff --git a/litellm/llms/azure_ai/anthropic/count_tokens/__init__.py b/litellm/llms/azure_ai/anthropic/count_tokens/__init__.py
new file mode 100644
index 00000000000..9605d401f8e
--- /dev/null
+++ b/litellm/llms/azure_ai/anthropic/count_tokens/__init__.py
@@ -0,0 +1,19 @@
+"""
+Azure AI Anthropic CountTokens API implementation.
+"""
+
+from litellm.llms.azure_ai.anthropic.count_tokens.handler import (
+    AzureAIAnthropicCountTokensHandler,
+)
+from litellm.llms.azure_ai.anthropic.count_tokens.token_counter import (
+    AzureAIAnthropicTokenCounter,
+)
+from litellm.llms.azure_ai.anthropic.count_tokens.transformation import (
+    AzureAIAnthropicCountTokensConfig,
+)
+
+__all__ = [
+    "AzureAIAnthropicCountTokensHandler",
+    "AzureAIAnthropicCountTokensConfig",
+    "AzureAIAnthropicTokenCounter",
+]
diff --git a/litellm/llms/azure_ai/anthropic/count_tokens/handler.py b/litellm/llms/azure_ai/anthropic/count_tokens/handler.py
new file mode 100644
index 00000000000..52a0bb8bb09
--- /dev/null
+++ b/litellm/llms/azure_ai/anthropic/count_tokens/handler.py
@@ -0,0 +1,127 @@
+"""
+Azure AI Anthropic CountTokens API handler.
+
+Uses httpx for HTTP requests with Azure authentication.
+"""
+
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+import litellm
+from litellm._logging import verbose_logger
+from litellm.llms.anthropic.common_utils import AnthropicError
+from litellm.llms.azure_ai.anthropic.count_tokens.transformation import (
+    AzureAIAnthropicCountTokensConfig,
+)
+from litellm.llms.custom_httpx.http_handler import get_async_httpx_client
+
+
+class AzureAIAnthropicCountTokensHandler(AzureAIAnthropicCountTokensConfig):
+    """
+    Handler for Azure AI Anthropic CountTokens API requests.
+
+    Uses httpx for HTTP requests with Azure authentication.
+    """
+
+    async def handle_count_tokens_request(
+        self,
+        model: str,
+        messages: List[Dict[str, Any]],
+        api_key: str,
+        api_base: str,
+        litellm_params: Optional[Dict[str, Any]] = None,
+        timeout: Optional[Union[float, httpx.Timeout]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Handle a CountTokens request using httpx with Azure authentication.
+
+        Args:
+            model: The model identifier (e.g., "claude-3-5-sonnet")
+            messages: The messages to count tokens for
+            api_key: The Azure AI API key
+            api_base: The Azure AI API base URL
+            litellm_params: Optional LiteLLM parameters
+            timeout: Optional timeout for the request (defaults to litellm.request_timeout)
+
+        Returns:
+            Dictionary containing token count response
+
+        Raises:
+            AnthropicError: If the API request fails
+        """
+        try:
+            # Validate the request
+            self.validate_request(model, messages)
+
+            verbose_logger.debug(
+                f"Processing Azure AI Anthropic CountTokens request for model: {model}"
+            )
+
+            # Transform request to Anthropic format
+            request_body = self.transform_request_to_count_tokens(
+                model=model,
+                messages=messages,
+            )
+
+            verbose_logger.debug(f"Transformed request: {request_body}")
+
+            # Get endpoint URL
+            endpoint_url = self.get_count_tokens_endpoint(api_base)
+
+            verbose_logger.debug(f"Making request to: {endpoint_url}")
+
+            # Get required headers with Azure authentication
+            headers = self.get_required_headers(
+                api_key=api_key,
+                litellm_params=litellm_params,
+            )
+
+            # Use LiteLLM's async httpx client
+            async_client = get_async_httpx_client(
+                llm_provider=litellm.LlmProviders.AZURE_AI
+            )
+
+            # Use provided timeout or fall back to litellm.request_timeout
+            request_timeout = timeout if timeout is not None else litellm.request_timeout
+
+            response = await async_client.post(
+                endpoint_url,
+                headers=headers,
+                json=request_body,
+                timeout=request_timeout,
+            )
+
+            verbose_logger.debug(f"Response status: {response.status_code}")
+
+            if response.status_code != 200:
+                error_text = response.text
+                verbose_logger.error(f"Azure AI Anthropic API error: {error_text}")
+                raise AnthropicError(
+                    status_code=response.status_code,
+                    message=error_text,
+                )
+
+            azure_response = response.json()
+
+            verbose_logger.debug(f"Azure AI Anthropic response: {azure_response}")
+
+            # Return Anthropic-compatible response directly - no transformation needed
+            return azure_response
+
+        except AnthropicError:
+            # Re-raise Anthropic exceptions as-is
+            raise
+        except httpx.HTTPStatusError as e:
+            # HTTP errors - preserve the actual status code
+            verbose_logger.error(f"HTTP error in CountTokens handler: {str(e)}")
+            raise AnthropicError(
+                status_code=e.response.status_code,
+                message=e.response.text,
+            )
+        except Exception as e:
+            verbose_logger.error(f"Error in CountTokens handler: {str(e)}")
+            raise AnthropicError(
+                status_code=500,
+                message=f"CountTokens processing error: {str(e)}",
+            )
diff --git a/litellm/llms/azure_ai/anthropic/count_tokens/token_counter.py b/litellm/llms/azure_ai/anthropic/count_tokens/token_counter.py
new file mode 100644
index 00000000000..14f92800079
--- /dev/null
+++ b/litellm/llms/azure_ai/anthropic/count_tokens/token_counter.py
@@ -0,0 +1,119 @@
+"""
+Azure AI Anthropic Token Counter implementation using the CountTokens API.
+"""
+
+import os
+from typing import Any, Dict, List, Optional
+
+from litellm._logging import verbose_logger
+from litellm.llms.azure_ai.anthropic.count_tokens.handler import (
+    AzureAIAnthropicCountTokensHandler,
+)
+from litellm.llms.base_llm.base_utils import BaseTokenCounter
+from litellm.types.utils import LlmProviders, TokenCountResponse
+
+# Global handler instance - reuse across all token counting requests
+azure_ai_anthropic_count_tokens_handler = AzureAIAnthropicCountTokensHandler()
+
+
+class AzureAIAnthropicTokenCounter(BaseTokenCounter):
+    """Token counter implementation for Azure AI Anthropic provider using the CountTokens API."""
+
+    def should_use_token_counting_api(
+        self,
+        custom_llm_provider: Optional[str] = None,
+    ) -> bool:
+        return custom_llm_provider == LlmProviders.AZURE_AI.value
+
+    async def count_tokens(
+        self,
+        model_to_use: str,
+        messages: Optional[List[Dict[str, Any]]],
+        contents: Optional[List[Dict[str, Any]]],
+        deployment: Optional[Dict[str, Any]] = None,
+        request_model: str = "",
+    ) -> Optional[TokenCountResponse]:
+        """
+        Count tokens using Azure AI Anthropic's CountTokens API.
+
+        Args:
+            model_to_use: The model identifier
+            messages: The messages to count tokens for
+            contents: Alternative content format (not used for Anthropic)
+            deployment: Deployment configuration containing litellm_params
+            request_model: The original request model name
+
+        Returns:
+            TokenCountResponse with token count, or None if counting fails
+        """
+        from litellm.llms.anthropic.common_utils import AnthropicError
+
+        if not messages:
+            return None
+
+        deployment = deployment or {}
+        litellm_params = deployment.get("litellm_params", {})
+
+        # Get Azure AI API key from deployment config or environment
+        api_key = litellm_params.get("api_key")
+        if not api_key:
+            api_key = os.getenv("AZURE_AI_API_KEY")
+
+        # Get API base from deployment config or environment
+        api_base = litellm_params.get("api_base")
+        if not api_base:
+            api_base = os.getenv("AZURE_AI_API_BASE")
+
+        if not api_key:
+            verbose_logger.warning("No Azure AI API key found for token counting")
+            return None
+
+        if not api_base:
+            verbose_logger.warning("No Azure AI API base found for token counting")
+            return None
+
+        try:
+            result = await azure_ai_anthropic_count_tokens_handler.handle_count_tokens_request(
+                model=model_to_use,
+                messages=messages,
+                api_key=api_key,
+                api_base=api_base,
+                litellm_params=litellm_params,
+            )
+
+            if result is not None:
+                return TokenCountResponse(
+                    total_tokens=result.get("input_tokens", 0),
+                    request_model=request_model,
+                    model_used=model_to_use,
+                    tokenizer_type="azure_ai_anthropic_api",
+                    original_response=result,
+                )
+        except AnthropicError as e:
+            verbose_logger.warning(
+                f"Azure AI Anthropic CountTokens API error: status={e.status_code}, message={e.message}"
+            )
+            return TokenCountResponse(
+                total_tokens=0,
+                request_model=request_model,
+                model_used=model_to_use,
+                tokenizer_type="azure_ai_anthropic_api",
+                error=True,
+                error_message=e.message,
+                status_code=e.status_code,
+            )
+        except Exception as e:
+            verbose_logger.warning(
+                f"Error calling Azure AI Anthropic CountTokens API: {e}"
+            )
+            return TokenCountResponse(
+                total_tokens=0,
+                request_model=request_model,
+                model_used=model_to_use,
+                tokenizer_type="azure_ai_anthropic_api",
+                error=True,
+                error_message=str(e),
+                status_code=500,
+            )
+
+        return None
diff --git a/litellm/llms/azure_ai/anthropic/count_tokens/transformation.py b/litellm/llms/azure_ai/anthropic/count_tokens/transformation.py
new file mode 100644
index 00000000000..e284595cc8a
--- /dev/null
+++ b/litellm/llms/azure_ai/anthropic/count_tokens/transformation.py
@@ -0,0 +1,88 @@
+"""
+Azure AI Anthropic CountTokens API transformation logic.
+
+Extends the base Anthropic CountTokens transformation with Azure authentication.
+"""
+
+from typing import Any, Dict, Optional
+
+from litellm.constants import ANTHROPIC_TOKEN_COUNTING_BETA_VERSION
+from litellm.llms.anthropic.count_tokens.transformation import (
+    AnthropicCountTokensConfig,
+)
+from litellm.llms.azure.common_utils import BaseAzureLLM
+from litellm.types.router import GenericLiteLLMParams
+
+
+class AzureAIAnthropicCountTokensConfig(AnthropicCountTokensConfig):
+    """
+    Configuration and transformation logic for Azure AI Anthropic CountTokens API.
+
+    Extends AnthropicCountTokensConfig with Azure authentication.
+    Azure AI Anthropic uses the same endpoint format but with Azure auth headers.
+    """
+
+    def get_required_headers(
+        self,
+        api_key: str,
+        litellm_params: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, str]:
+        """
+        Get the required headers for the Azure AI Anthropic CountTokens API.
+
+        Uses Azure authentication (api-key header) instead of Anthropic's x-api-key.
+
+        Args:
+            api_key: The Azure AI API key
+            litellm_params: Optional LiteLLM parameters for additional auth config
+
+        Returns:
+            Dictionary of required headers with Azure authentication
+        """
+        # Start with base headers
+        headers = {
+            "Content-Type": "application/json",
+            "anthropic-version": "2023-06-01",
+            "anthropic-beta": ANTHROPIC_TOKEN_COUNTING_BETA_VERSION,
+        }
+
+        # Use Azure authentication
+        litellm_params = litellm_params or {}
+        if "api_key" not in litellm_params:
+            litellm_params["api_key"] = api_key
+
+        litellm_params_obj = GenericLiteLLMParams(**litellm_params)
+
+        # Get Azure auth headers
+        azure_headers = BaseAzureLLM._base_validate_azure_environment(
+            headers={}, litellm_params=litellm_params_obj
+        )
+
+        # Merge Azure auth headers
+        headers.update(azure_headers)
+
+        return headers
+
+    def get_count_tokens_endpoint(self, api_base: str) -> str:
+        """
+        Get the Azure AI Anthropic CountTokens API endpoint.
+
+        Args:
+            api_base: The Azure AI API base URL 
+                      (e.g., https://my-resource.services.ai.azure.com or
+                       https://my-resource.services.ai.azure.com/anthropic)
+
+        Returns:
+            The endpoint URL for the CountTokens API
+        """
+        # Azure AI Anthropic endpoint format:
+        # https://<resource>.services.ai.azure.com/anthropic/v1/messages/count_tokens
+        api_base = api_base.rstrip("/")
+
+        # Ensure the URL has /anthropic path
+        if not api_base.endswith("/anthropic"):
+            if "/anthropic" not in api_base:
+                api_base = f"{api_base}/anthropic"
+
+        # Add the count_tokens path
+        return f"{api_base}/v1/messages/count_tokens"
diff --git a/litellm/llms/azure_ai/common_utils.py b/litellm/llms/azure_ai/common_utils.py
index 9487c7f83f2..01a3f5766c6 100644
--- a/litellm/llms/azure_ai/common_utils.py
+++ b/litellm/llms/azure_ai/common_utils.py
@@ -1,17 +1,22 @@
 from typing import List, Literal, Optional
 
 import litellm
-from litellm.llms.base_llm.base_utils import BaseLLMModelInfo
+from litellm.llms.base_llm.base_utils import BaseLLMModelInfo, BaseTokenCounter
 from litellm.secret_managers.main import get_secret_str
 from litellm.types.llms.openai import AllMessageValues
 
 
 class AzureFoundryModelInfo(BaseLLMModelInfo):
+    """Model info for Azure AI / Azure Foundry models."""
+
+    def __init__(self, model: Optional[str] = None):
+        self._model = model
+
     @staticmethod
     def get_azure_ai_route(model: str) -> Literal["agents", "default"]:
         """
         Get the Azure AI route for the given model.
-        
+
         Similar to BedrockModelInfo.get_bedrock_route().
         """
         if "agents/" in model:
@@ -20,34 +25,54 @@ class AzureFoundryModelInfo(BaseLLMModelInfo):
 
     @staticmethod
     def get_api_base(api_base: Optional[str] = None) -> Optional[str]:
-        return (
-                api_base
-                or litellm.api_base
-                or get_secret_str("AZURE_AI_API_BASE")
-        )
-    
+        return api_base or litellm.api_base or get_secret_str("AZURE_AI_API_BASE")
+
     @staticmethod
     def get_api_key(api_key: Optional[str] = None) -> Optional[str]:
         return (
-                api_key
-                or litellm.api_key
-                or litellm.openai_key
-                or get_secret_str("AZURE_AI_API_KEY")
-            )
-    
+            api_key
+            or litellm.api_key
+            or litellm.openai_key
+            or get_secret_str("AZURE_AI_API_KEY")
+        )
+
     @property
     def api_version(self, api_version: Optional[str] = None) -> Optional[str]:
         api_version = (
-            api_version
-            or litellm.api_version
-            or get_secret_str("AZURE_API_VERSION")
+            api_version or litellm.api_version or get_secret_str("AZURE_API_VERSION")
         )
         return api_version
-    
+
+    def get_token_counter(self) -> Optional[BaseTokenCounter]:
+        """
+        Factory method to create a token counter for Azure AI.
+
+        Returns:
+            AzureAIAnthropicTokenCounter for Claude models, None otherwise.
+        """
+        # Only return token counter for Claude models
+        if self._model and "claude" in self._model.lower():
+            from litellm.llms.azure_ai.anthropic.count_tokens.token_counter import (
+                AzureAIAnthropicTokenCounter,
+            )
+
+            return AzureAIAnthropicTokenCounter()
+        return None
+
+    def get_models(
+        self, api_key: Optional[str] = None, api_base: Optional[str] = None
+    ) -> List[str]:
+        """
+        Returns a list of models supported by Azure AI.
+        
+        Azure AI doesn't have a standard model listing endpoint,
+        so this returns an empty list.
+        """
+        return []
+
     #########################################################
     # Not implemented methods
     #########################################################
-        
 
     @staticmethod
     def get_base_model(model: str) -> Optional[str]:
@@ -64,4 +89,6 @@ class AzureFoundryModelInfo(BaseLLMModelInfo):
         api_base: Optional[str] = None,
     ) -> dict:
         """Azure Foundry sends api key in query params"""
-        raise NotImplementedError("Azure Foundry does not support environment validation")
+        raise NotImplementedError(
+            "Azure Foundry does not support environment validation"
+        )
diff --git a/litellm/llms/bedrock/chat/agentcore/sse_iterator.py b/litellm/llms/bedrock/chat/agentcore/sse_iterator.py
deleted file mode 100644
index 90c5ada769f..00000000000
--- a/litellm/llms/bedrock/chat/agentcore/sse_iterator.py
+++ /dev/null
@@ -1,252 +0,0 @@
-"""
-SSE Stream Iterator for Bedrock AgentCore.
-
-Handles Server-Sent Events (SSE) streaming responses from AgentCore.
-"""
-
-import json
-from typing import TYPE_CHECKING, Any, Optional
-
-import httpx
-
-from litellm._logging import verbose_logger
-from litellm._uuid import uuid
-from litellm.types.llms.bedrock_agentcore import AgentCoreUsage
-from litellm.types.utils import Delta, ModelResponse, StreamingChoices, Usage
-
-if TYPE_CHECKING:
-    pass
-
-
-class AgentCoreSSEStreamIterator:
-    """
-    Iterator for AgentCore SSE streaming responses.
-    Supports both sync and async iteration.
-
-    CRITICAL: The line iterators are created lazily on first access and reused.
-    We must NOT create new iterators in __aiter__/__iter__ because
-    CustomStreamWrapper calls __aiter__ on every call to its __anext__,
-    which would create new iterators and cause StreamConsumed errors.
-    """
-
-    def __init__(self, response: httpx.Response, model: str):
-        self.response = response
-        self.model = model
-        self.finished = False
-        self._sync_iter: Any = None
-        self._async_iter: Any = None
-        self._sync_iter_initialized = False
-        self._async_iter_initialized = False
-
-    def __iter__(self):
-        """Initialize sync iteration - create iterator lazily on first call only."""
-        if not self._sync_iter_initialized:
-            self._sync_iter = iter(self.response.iter_lines())
-            self._sync_iter_initialized = True
-        return self
-
-    def __aiter__(self):
-        """Initialize async iteration - create iterator lazily on first call only."""
-        if not self._async_iter_initialized:
-            self._async_iter = self.response.aiter_lines().__aiter__()
-            self._async_iter_initialized = True
-        return self
-
-    def _parse_sse_line(self, line: str) -> Optional[ModelResponse]:
-        """
-        Parse a single SSE line and return a ModelResponse chunk if applicable.
-
-        AgentCore SSE format:
-        - data: {"event": {"contentBlockDelta": {"delta": {"text": "..."}}}}
-        - data: {"event": {"metadata": {"usage": {...}}}}
-        - data: {"message": {...}}
-        """
-        line = line.strip()
-        if not line or not line.startswith("data:"):
-            return None
-
-        json_str = line[5:].strip()
-        if not json_str:
-            return None
-
-        try:
-            data = json.loads(json_str)
-
-            # Skip non-dict data (some lines contain Python repr strings)
-            if not isinstance(data, dict):
-                return None
-
-            # Process content delta events
-            if "event" in data and isinstance(data["event"], dict):
-                event_payload = data["event"]
-                content_block_delta = event_payload.get("contentBlockDelta")
-
-                if content_block_delta:
-                    delta = content_block_delta.get("delta", {})
-                    text = delta.get("text", "")
-
-                    if text:
-                        # Return chunk with text
-                        chunk = ModelResponse(
-                            id=f"chatcmpl-{uuid.uuid4()}",
-                            created=0,
-                            model=self.model,
-                            object="chat.completion.chunk",
-                        )
-
-                        chunk.choices = [
-                            StreamingChoices(
-                                finish_reason=None,
-                                index=0,
-                                delta=Delta(content=text, role="assistant"),
-                            )
-                        ]
-
-                        return chunk
-
-                # Check for metadata/usage - this signals the end
-                metadata = event_payload.get("metadata")
-                if metadata and "usage" in metadata:
-                    chunk = ModelResponse(
-                        id=f"chatcmpl-{uuid.uuid4()}",
-                        created=0,
-                        model=self.model,
-                        object="chat.completion.chunk",
-                    )
-
-                    chunk.choices = [
-                        StreamingChoices(
-                            finish_reason="stop",
-                            index=0,
-                            delta=Delta(),
-                        )
-                    ]
-
-                    usage_data: AgentCoreUsage = metadata["usage"]  # type: ignore
-                    setattr(
-                        chunk,
-                        "usage",
-                        Usage(
-                            prompt_tokens=usage_data.get("inputTokens", 0),
-                            completion_tokens=usage_data.get("outputTokens", 0),
-                            total_tokens=usage_data.get("totalTokens", 0),
-                        ),
-                    )
-
-                    self.finished = True
-                    return chunk
-
-            # Check for final message (alternative finish signal)
-            if "message" in data and isinstance(data["message"], dict):
-                if not self.finished:
-                    chunk = ModelResponse(
-                        id=f"chatcmpl-{uuid.uuid4()}",
-                        created=0,
-                        model=self.model,
-                        object="chat.completion.chunk",
-                    )
-
-                    chunk.choices = [
-                        StreamingChoices(
-                            finish_reason="stop",
-                            index=0,
-                            delta=Delta(),
-                        )
-                    ]
-
-                    self.finished = True
-                    return chunk
-
-        except json.JSONDecodeError:
-            verbose_logger.debug(f"Skipping non-JSON SSE line: {line[:100]}")
-
-        return None
-
-    def _create_final_chunk(self) -> ModelResponse:
-        """Create a final chunk to signal stream completion."""
-        chunk = ModelResponse(
-            id=f"chatcmpl-{uuid.uuid4()}",
-            created=0,
-            model=self.model,
-            object="chat.completion.chunk",
-        )
-
-        chunk.choices = [
-            StreamingChoices(
-                finish_reason="stop",
-                index=0,
-                delta=Delta(),
-            )
-        ]
-
-        return chunk
-
-    def __next__(self) -> ModelResponse:
-        """
-        Sync iteration - parse SSE events and yield ModelResponse chunks.
-        
-        Uses next() on the stored iterator to properly resume between calls.
-        """
-        try:
-            if self._sync_iter is None:
-                raise StopIteration
-
-            # Keep getting lines until we have a result to return
-            while True:
-                try:
-                    line = next(self._sync_iter)
-                except StopIteration:
-                    # Stream ended - send final chunk if not already finished
-                    if not self.finished:
-                        self.finished = True
-                        return self._create_final_chunk()
-                    raise
-
-                result = self._parse_sse_line(line)
-                if result is not None:
-                    return result
-
-        except StopIteration:
-            raise
-        except httpx.StreamConsumed:
-            raise StopIteration
-        except httpx.StreamClosed:
-            raise StopIteration
-        except Exception as e:
-            verbose_logger.error(f"Error in AgentCore SSE stream: {str(e)}")
-            raise StopIteration
-
-    async def __anext__(self) -> ModelResponse:
-        """
-        Async iteration - parse SSE events and yield ModelResponse chunks.
-
-        Uses __anext__() on the stored iterator to properly resume between calls.
-        """
-        try:
-            if self._async_iter is None:
-                raise StopAsyncIteration
-
-            # Keep getting lines until we have a result to return
-            while True:
-                try:
-                    line = await self._async_iter.__anext__()
-                except StopAsyncIteration:
-                    # Stream ended - send final chunk if not already finished
-                    if not self.finished:
-                        self.finished = True
-                        return self._create_final_chunk()
-                    raise
-
-                result = self._parse_sse_line(line)
-                if result is not None:
-                    return result
-
-        except StopAsyncIteration:
-            raise
-        except httpx.StreamConsumed:
-            raise StopAsyncIteration
-        except httpx.StreamClosed:
-            raise StopAsyncIteration
-        except Exception as e:
-            verbose_logger.error(f"Error in AgentCore SSE stream: {str(e)}")
-            raise StopAsyncIteration
diff --git a/litellm/llms/bedrock/chat/agentcore/transformation.py b/litellm/llms/bedrock/chat/agentcore/transformation.py
index 7c65cad94df..94e845e3095 100644
--- a/litellm/llms/bedrock/chat/agentcore/transformation.py
+++ b/litellm/llms/bedrock/chat/agentcore/transformation.py
@@ -5,6 +5,7 @@ https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agentcore_InvokeAgen
 """
 
 import json
+from collections.abc import AsyncGenerator
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union, cast
 from urllib.parse import quote
 
@@ -15,9 +16,9 @@ from litellm._uuid import uuid
 from litellm.litellm_core_utils.prompt_templates.common_utils import (
     convert_content_list_to_str,
 )
+from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper
 from litellm.llms.base_llm.chat.transformation import BaseConfig, BaseLLMException
 from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM
-from litellm.llms.bedrock.chat.agentcore.sse_iterator import AgentCoreSSEStreamIterator
 from litellm.llms.bedrock.common_utils import BedrockError
 from litellm.types.llms.bedrock_agentcore import (
     AgentCoreMessage,
@@ -25,19 +26,17 @@ from litellm.types.llms.bedrock_agentcore import (
     AgentCoreUsage,
 )
 from litellm.types.llms.openai import AllMessageValues
-from litellm.types.utils import Choices, Message, ModelResponse, Usage
+from litellm.types.utils import Choices, Delta, Message, ModelResponse, StreamingChoices, Usage
 
 if TYPE_CHECKING:
     from litellm.litellm_core_utils.litellm_logging import Logging as _LiteLLMLoggingObj
     from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler, HTTPHandler
-    from litellm.utils import CustomStreamWrapper
 
     LiteLLMLoggingObj = _LiteLLMLoggingObj
 else:
     LiteLLMLoggingObj = Any
     HTTPHandler = Any
     AsyncHTTPHandler = Any
-    CustomStreamWrapper = Any
 
 
 class AmazonAgentCoreConfig(BaseConfig, BaseAWSLLM):
@@ -116,7 +115,8 @@ class AmazonAgentCoreConfig(BaseConfig, BaseAWSLLM):
         fake_stream: Optional[bool] = None,
     ) -> Tuple[dict, Optional[bytes]]:
         # Check if api_key (bearer token) is provided for Cognito authentication
-        jwt_token = optional_params.get("api_key")
+        # Priority: api_key parameter first, then optional_params
+        jwt_token = api_key or optional_params.get("api_key")
         if jwt_token:
             verbose_logger.debug(
                 f"AgentCore: Using Bearer token authentication (Cognito/JWT) - token: {jwt_token[:50]}..."
@@ -437,22 +437,104 @@ class AmazonAgentCoreConfig(BaseConfig, BaseAWSLLM):
             content=content, usage=usage_data, final_message=final_message
         )
 
-    def get_streaming_response(
+    def _stream_agentcore_response_sync(
         self,
+        response: httpx.Response,
         model: str,
-        raw_response: httpx.Response,
-    ) -> AgentCoreSSEStreamIterator:
+    ):
         """
-        Return a streaming iterator for SSE responses.
-
-        Args:
-            model: The model name
-            raw_response: Raw HTTP response with streaming data
-
-        Returns:
-            AgentCoreSSEStreamIterator: Iterator that yields ModelResponse chunks
+        Internal sync generator that parses SSE and yields ModelResponse chunks.
         """
-        return AgentCoreSSEStreamIterator(response=raw_response, model=model)
+        buffer = ""
+        for text_chunk in response.iter_text():
+            buffer += text_chunk
+
+            # Process complete lines
+            while '\n' in buffer:
+                line, buffer = buffer.split('\n', 1)
+                line = line.strip()
+
+                if not line or not line.startswith('data:'):
+                    continue
+
+                json_str = line[5:].strip()
+                if not json_str:
+                    continue
+
+                try:
+                    data_obj = json.loads(json_str)
+                    if not isinstance(data_obj, dict):
+                        continue
+
+                    # Process contentBlockDelta events
+                    if "event" in data_obj and isinstance(data_obj["event"], dict):
+                        event_payload = data_obj["event"]
+                        content_block_delta = event_payload.get("contentBlockDelta")
+
+                        if content_block_delta:
+                            delta = content_block_delta.get("delta", {})
+                            text = delta.get("text", "")
+
+                            if text:
+                                chunk = ModelResponse(
+                                    id=f"chatcmpl-{uuid.uuid4()}",
+                                    created=0,
+                                    model=model,
+                                    object="chat.completion.chunk",
+                                )
+                                chunk.choices = [
+                                    StreamingChoices(
+                                        finish_reason=None,
+                                        index=0,
+                                        delta=Delta(content=text, role="assistant"),
+                                    )
+                                ]
+                                yield chunk
+
+                        # Process metadata/usage
+                        metadata = event_payload.get("metadata")
+                        if metadata and "usage" in metadata:
+                            chunk = ModelResponse(
+                                id=f"chatcmpl-{uuid.uuid4()}",
+                                created=0,
+                                model=model,
+                                object="chat.completion.chunk",
+                            )
+                            chunk.choices = [
+                                StreamingChoices(
+                                    finish_reason="stop",
+                                    index=0,
+                                    delta=Delta(),
+                                )
+                            ]
+                            usage_data: AgentCoreUsage = metadata["usage"]  # type: ignore
+                            setattr(chunk, "usage", Usage(
+                                prompt_tokens=usage_data.get("inputTokens", 0),
+                                completion_tokens=usage_data.get("outputTokens", 0),
+                                total_tokens=usage_data.get("totalTokens", 0),
+                            ))
+                            yield chunk
+
+                    # Process final message
+                    if "message" in data_obj and isinstance(data_obj["message"], dict):
+                        chunk = ModelResponse(
+                            id=f"chatcmpl-{uuid.uuid4()}",
+                            created=0,
+                            model=model,
+                            object="chat.completion.chunk",
+                        )
+                        chunk.choices = [
+                            StreamingChoices(
+                                finish_reason="stop",
+                                index=0,
+                                delta=Delta(),
+                            )
+                        ]
+                        yield chunk
+
+                except json.JSONDecodeError:
+                    verbose_logger.debug(f"Skipping non-JSON SSE line: {line[:100]}")
+                    continue
 
     def get_sync_custom_stream_wrapper(
         self,
@@ -466,17 +548,14 @@ class AmazonAgentCoreConfig(BaseConfig, BaseAWSLLM):
         client: Optional[Union[HTTPHandler, "AsyncHTTPHandler"]] = None,
         json_mode: Optional[bool] = None,
         signed_json_body: Optional[bytes] = None,
-    ) -> CustomStreamWrapper:
+    ) -> "CustomStreamWrapper":
         """
-        Get a CustomStreamWrapper for synchronous streaming.
-
-        This is called when stream=True is passed to completion().
+        Simplified sync streaming - returns a generator that yields ModelResponse chunks.
         """
         from litellm.llms.custom_httpx.http_handler import (
             HTTPHandler,
             _get_httpx_client,
         )
-        from litellm.utils import CustomStreamWrapper
 
         if client is None or not isinstance(client, HTTPHandler):
             client = _get_httpx_client(params={})
@@ -488,7 +567,7 @@ class AmazonAgentCoreConfig(BaseConfig, BaseAWSLLM):
             api_base,
             headers=headers,
             data=signed_json_body if signed_json_body else json.dumps(data),
-            stream=True,  # THIS IS KEY - tells httpx to not buffer
+            stream=True,
             logging_obj=logging_obj,
         )
 
@@ -497,18 +576,6 @@ class AmazonAgentCoreConfig(BaseConfig, BaseAWSLLM):
                 status_code=response.status_code, message=str(response.read())
             )
 
-        # Create iterator for SSE stream
-        completion_stream = self.get_streaming_response(
-            model=model, raw_response=response
-        )
-
-        streaming_response = CustomStreamWrapper(
-            completion_stream=completion_stream,
-            model=model,
-            custom_llm_provider=custom_llm_provider,
-            logging_obj=logging_obj,
-        )
-
         # LOGGING
         logging_obj.post_call(
             input=messages,
@@ -517,7 +584,112 @@ class AmazonAgentCoreConfig(BaseConfig, BaseAWSLLM):
             additional_args={"complete_input_dict": data},
         )
 
-        return streaming_response
+        # Wrap the generator in CustomStreamWrapper
+        return CustomStreamWrapper(
+            completion_stream=self._stream_agentcore_response_sync(response, model),
+            model=model,
+            custom_llm_provider="bedrock",
+            logging_obj=logging_obj,
+        )
+
+    async def _stream_agentcore_response(
+        self,
+        response: httpx.Response,
+        model: str,
+    ) -> AsyncGenerator[ModelResponse, None]:
+        """
+        Internal async generator that parses SSE and yields ModelResponse chunks.
+        """
+        buffer = ""
+        async for text_chunk in response.aiter_text():
+            buffer += text_chunk
+
+            # Process complete lines
+            while '\n' in buffer:
+                line, buffer = buffer.split('\n', 1)
+                line = line.strip()
+
+                if not line or not line.startswith('data:'):
+                    continue
+
+                json_str = line[5:].strip()
+                if not json_str:
+                    continue
+
+                try:
+                    data_obj = json.loads(json_str)
+                    if not isinstance(data_obj, dict):
+                        continue
+
+                    # Process contentBlockDelta events
+                    if "event" in data_obj and isinstance(data_obj["event"], dict):
+                        event_payload = data_obj["event"]
+                        content_block_delta = event_payload.get("contentBlockDelta")
+
+                        if content_block_delta:
+                            delta = content_block_delta.get("delta", {})
+                            text = delta.get("text", "")
+
+                            if text:
+                                chunk = ModelResponse(
+                                    id=f"chatcmpl-{uuid.uuid4()}",
+                                    created=0,
+                                    model=model,
+                                    object="chat.completion.chunk",
+                                )
+                                chunk.choices = [
+                                    StreamingChoices(
+                                        finish_reason=None,
+                                        index=0,
+                                        delta=Delta(content=text, role="assistant"),
+                                    )
+                                ]
+                                yield chunk
+
+                        # Process metadata/usage
+                        metadata = event_payload.get("metadata")
+                        if metadata and "usage" in metadata:
+                            chunk = ModelResponse(
+                                id=f"chatcmpl-{uuid.uuid4()}",
+                                created=0,
+                                model=model,
+                                object="chat.completion.chunk",
+                            )
+                            chunk.choices = [
+                                StreamingChoices(
+                                    finish_reason="stop",
+                                    index=0,
+                                    delta=Delta(),
+                                )
+                            ]
+                            usage_data: AgentCoreUsage = metadata["usage"]  # type: ignore
+                            setattr(chunk, "usage", Usage(
+                                prompt_tokens=usage_data.get("inputTokens", 0),
+                                completion_tokens=usage_data.get("outputTokens", 0),
+                                total_tokens=usage_data.get("totalTokens", 0),
+                            ))
+                            yield chunk
+
+                    # Process final message
+                    if "message" in data_obj and isinstance(data_obj["message"], dict):
+                        chunk = ModelResponse(
+                            id=f"chatcmpl-{uuid.uuid4()}",
+                            created=0,
+                            model=model,
+                            object="chat.completion.chunk",
+                        )
+                        chunk.choices = [
+                            StreamingChoices(
+                                finish_reason="stop",
+                                index=0,
+                                delta=Delta(),
+                            )
+                        ]
+                        yield chunk
+
+                except json.JSONDecodeError:
+                    verbose_logger.debug(f"Skipping non-JSON SSE line: {line[:100]}")
+                    continue
 
     async def get_async_custom_stream_wrapper(
         self,
@@ -531,17 +703,14 @@ class AmazonAgentCoreConfig(BaseConfig, BaseAWSLLM):
         client: Optional["AsyncHTTPHandler"] = None,
         json_mode: Optional[bool] = None,
         signed_json_body: Optional[bytes] = None,
-    ) -> CustomStreamWrapper:
+    ) -> "CustomStreamWrapper":
         """
-        Get a CustomStreamWrapper for asynchronous streaming.
-
-        This is called when stream=True is passed to acompletion().
+        Simplified async streaming - returns an async generator that yields ModelResponse chunks.
         """
         from litellm.llms.custom_httpx.http_handler import (
             AsyncHTTPHandler,
             get_async_httpx_client,
         )
-        from litellm.utils import CustomStreamWrapper
 
         if client is None or not isinstance(client, AsyncHTTPHandler):
             client = get_async_httpx_client(
@@ -555,7 +724,7 @@ class AmazonAgentCoreConfig(BaseConfig, BaseAWSLLM):
             api_base,
             headers=headers,
             data=signed_json_body if signed_json_body else json.dumps(data),
-            stream=True,  # THIS IS KEY - tells httpx to not buffer
+            stream=True,
             logging_obj=logging_obj,
         )
 
@@ -564,18 +733,6 @@ class AmazonAgentCoreConfig(BaseConfig, BaseAWSLLM):
                 status_code=response.status_code, message=str(await response.aread())
             )
 
-        # Create iterator for SSE stream
-        completion_stream = self.get_streaming_response(
-            model=model, raw_response=response
-        )
-
-        streaming_response = CustomStreamWrapper(
-            completion_stream=completion_stream,
-            model=model,
-            custom_llm_provider=custom_llm_provider,
-            logging_obj=logging_obj,
-        )
-
         # LOGGING
         logging_obj.post_call(
             input=messages,
@@ -584,7 +741,13 @@ class AmazonAgentCoreConfig(BaseConfig, BaseAWSLLM):
             additional_args={"complete_input_dict": data},
         )
 
-        return streaming_response
+        # Wrap the async generator in CustomStreamWrapper
+        return CustomStreamWrapper(
+            completion_stream=self._stream_agentcore_response(response, model),
+            model=model,
+            custom_llm_provider="bedrock",
+            logging_obj=logging_obj,
+        )
 
     @property
     def has_custom_stream_wrapper(self) -> bool:
@@ -692,4 +855,5 @@ class AmazonAgentCoreConfig(BaseConfig, BaseAWSLLM):
         stream: Optional[bool],
         custom_llm_provider: Optional[str] = None,
     ) -> bool:
-        return True
+        # AgentCore supports true streaming - don't buffer
+        return False
diff --git a/litellm/llms/bedrock/chat/converse_transformation.py b/litellm/llms/bedrock/chat/converse_transformation.py
index 59590e464fc..cb26a22edfa 100644
--- a/litellm/llms/bedrock/chat/converse_transformation.py
+++ b/litellm/llms/bedrock/chat/converse_transformation.py
@@ -53,7 +53,13 @@ from litellm.types.utils import (
     PromptTokensDetailsWrapper,
     Usage,
 )
-from litellm.utils import add_dummy_tool, has_tool_call_blocks, supports_reasoning
+from litellm.utils import (
+    add_dummy_tool,
+    any_assistant_message_has_thinking_blocks,
+    has_tool_call_blocks,
+    last_assistant_with_tool_calls_has_no_thinking_blocks,
+    supports_reasoning,
+)
 
 from ..common_utils import (
     BedrockError,
@@ -773,7 +779,7 @@ class AmazonConverseConfig(BaseConfig):
             return optional_params
 
         """
-        Follow similar approach to anthropic - translate to a single tool call. 
+        Follow similar approach to anthropic - translate to a single tool call.
 
         When using tools in this way: - https://docs.anthropic.com/en/docs/build-with-claude/tool-use#json-mode
         - You usually want to provide a single tool
@@ -1070,9 +1076,28 @@ class AmazonConverseConfig(BaseConfig):
                     llm_provider="bedrock",
                 )
 
+        # Drop thinking param if thinking is enabled but thinking_blocks are missing
+        # This prevents the error: "Expected thinking or redacted_thinking, but found tool_use"
+        #
+        # IMPORTANT: Only drop thinking if NO assistant messages have thinking_blocks.
+        # If any message has thinking_blocks, we must keep thinking enabled, otherwise
+        # Related issues: https://github.com/BerriAI/litellm/issues/14194
+        if (
+            optional_params.get("thinking") is not None
+            and messages is not None
+            and last_assistant_with_tool_calls_has_no_thinking_blocks(messages)
+            and not any_assistant_message_has_thinking_blocks(messages)
+        ):
+            if litellm.modify_params:
+                optional_params.pop("thinking", None)
+                litellm.verbose_logger.warning(
+                    "Dropping 'thinking' param because the last assistant message with tool_calls "
+                    "has no thinking_blocks. The model won't use extended thinking for this turn."
+                )
+
         # Prepare and separate parameters
-        inference_params, additional_request_params, request_metadata = (
-            self._prepare_request_params(optional_params, model)
+        inference_params, additional_request_params, request_metadata = self._prepare_request_params(
+            optional_params, model
         )
 
         original_tools = inference_params.pop("tools", [])
@@ -1459,11 +1484,11 @@ class AmazonConverseConfig(BaseConfig):
             )
 
         """
-        Bedrock Response Object has optional message block 
+        Bedrock Response Object has optional message block
 
         completion_response["output"].get("message", None)
 
-        A message block looks like this (Example 1): 
+        A message block looks like this (Example 1):
         "output": {
             "message": {
                 "role": "assistant",
diff --git a/litellm/llms/bedrock/chat/invoke_handler.py b/litellm/llms/bedrock/chat/invoke_handler.py
index c9677cf9edd..032283a2d2a 100644
--- a/litellm/llms/bedrock/chat/invoke_handler.py
+++ b/litellm/llms/bedrock/chat/invoke_handler.py
@@ -374,6 +374,29 @@ class BedrockLLM(BaseAWSLLM):
     def __init__(self) -> None:
         super().__init__()
 
+    @staticmethod
+    def is_claude_messages_api_model(model: str) -> bool:
+        """
+        Check if the model uses the Claude Messages API (Claude 3+).
+
+        Handles:
+        - Regional prefixes: eu.anthropic.claude-*, us.anthropic.claude-*
+        - Claude 3 models: claude-3-haiku, claude-3-sonnet, claude-3-opus, claude-3-5-*, claude-3-7-*
+        - Claude 4 models: claude-opus-4, claude-sonnet-4, claude-haiku-4
+        """
+        # Normalize model string to lowercase for matching
+        model_lower = model.lower()
+
+        # Claude 3+ indicators (all use Messages API)
+        messages_api_indicators = [
+            "claude-3",      # Claude 3.x models
+            "claude-opus-4", # Claude Opus 4
+            "claude-sonnet-4", # Claude Sonnet 4
+            "claude-haiku-4",  # Claude Haiku 4
+        ]
+
+        return any(indicator in model_lower for indicator in messages_api_indicators)
+
     def convert_messages_to_prompt(
         self, model, messages, provider, custom_prompt_dict
     ) -> Tuple[str, Optional[list]]:
@@ -465,7 +488,7 @@ class BedrockLLM(BaseAWSLLM):
                         completion_response["generations"][0]["finish_reason"]
                     )
             elif provider == "anthropic":
-                if model.startswith("anthropic.claude-3"):
+                if self.is_claude_messages_api_model(model):
                     json_schemas: dict = {}
                     _is_function_call = False
                     ## Handle Tool Calling
@@ -595,13 +618,12 @@ class BedrockLLM(BaseAWSLLM):
                         outputText = choice["message"].get("content")
                     elif "text" in choice:  # fallback for completion format
                         outputText = choice["text"]
-                    
                     # Set finish reason
                     if "finish_reason" in choice:
                         model_response.choices[0].finish_reason = map_finish_reason(
                             choice["finish_reason"]
                         )
-                    
+
                     # Set usage if available
                     if "usage" in completion_response:
                         usage = completion_response["usage"]
@@ -838,7 +860,7 @@ class BedrockLLM(BaseAWSLLM):
                     ] = True  # cohere requires stream = True in inference params
                 data = json.dumps({"prompt": prompt, **inference_params})
         elif provider == "anthropic":
-            if model.startswith("anthropic.claude-3"):
+            if self.is_claude_messages_api_model(model):
                 # Separate system prompt from rest of message
                 system_prompt_idx: list[int] = []
                 system_messages: list[str] = []
@@ -936,13 +958,13 @@ class BedrockLLM(BaseAWSLLM):
             # Use AmazonBedrockOpenAIConfig for proper OpenAI transformation
             openai_config = AmazonBedrockOpenAIConfig()
             supported_params = openai_config.get_supported_openai_params(model=model)
-            
+
             # Filter to only supported OpenAI params
             filtered_params = {
-                k: v for k, v in inference_params.items() 
+                k: v for k, v in inference_params.items()
                 if k in supported_params
             }
-            
+
             # OpenAI uses messages format, not prompt
             data = json.dumps({"messages": messages, **filtered_params})
         else:
diff --git a/litellm/llms/chatgpt/authenticator.py b/litellm/llms/chatgpt/authenticator.py
new file mode 100644
index 00000000000..ff053730c35
--- /dev/null
+++ b/litellm/llms/chatgpt/authenticator.py
@@ -0,0 +1,388 @@
+import base64
+import json
+import os
+import time
+from typing import Any, Dict, Optional
+
+import httpx
+
+from litellm._logging import verbose_logger
+from litellm.llms.custom_httpx.http_handler import _get_httpx_client
+
+from .common_utils import (
+    CHATGPT_API_BASE,
+    CHATGPT_AUTH_BASE,
+    CHATGPT_CLIENT_ID,
+    CHATGPT_DEVICE_CODE_URL,
+    CHATGPT_DEVICE_TOKEN_URL,
+    CHATGPT_DEVICE_VERIFY_URL,
+    CHATGPT_OAUTH_TOKEN_URL,
+    GetAccessTokenError,
+    GetDeviceCodeError,
+    RefreshAccessTokenError,
+)
+
+TOKEN_EXPIRY_SKEW_SECONDS = 60
+DEVICE_CODE_TIMEOUT_SECONDS = 15 * 60
+DEVICE_CODE_COOLDOWN_SECONDS = 5 * 60
+DEVICE_CODE_POLL_SLEEP_SECONDS = 5
+
+
+class Authenticator:
+    def __init__(self) -> None:
+        self.token_dir = os.getenv(
+            "CHATGPT_TOKEN_DIR",
+            os.path.expanduser("~/.config/litellm/chatgpt"),
+        )
+        self.auth_file = os.path.join(
+            self.token_dir, os.getenv("CHATGPT_AUTH_FILE", "auth.json")
+        )
+        self._ensure_token_dir()
+
+    def get_api_base(self) -> str:
+        return (
+            os.getenv("CHATGPT_API_BASE")
+            or os.getenv("OPENAI_CHATGPT_API_BASE")
+            or CHATGPT_API_BASE
+        )
+
+    def get_access_token(self) -> str:
+        auth_data = self._read_auth_file()
+        if auth_data:
+            access_token = auth_data.get("access_token")
+            if access_token and not self._is_token_expired(auth_data, access_token):
+                return access_token
+            refresh_token = auth_data.get("refresh_token")
+            if refresh_token:
+                try:
+                    refreshed = self._refresh_tokens(refresh_token)
+                    return refreshed["access_token"]
+                except RefreshAccessTokenError as exc:
+                    verbose_logger.warning(
+                        "ChatGPT refresh token failed, re-login required: %s", exc
+                    )
+
+        cooldown_remaining = self._get_device_code_cooldown_remaining(auth_data)
+        if cooldown_remaining > 0:
+            token = self._wait_for_access_token(cooldown_remaining)
+            if token:
+                return token
+
+        tokens = self._login_device_code()
+        return tokens["access_token"]
+
+    def get_account_id(self) -> Optional[str]:
+        auth_data = self._read_auth_file()
+        if not auth_data:
+            return None
+        account_id = auth_data.get("account_id")
+        if account_id:
+            return account_id
+        id_token = auth_data.get("id_token")
+        access_token = auth_data.get("access_token")
+        derived = self._extract_account_id(id_token or access_token)
+        if derived:
+            auth_data["account_id"] = derived
+            self._write_auth_file(auth_data)
+        return derived
+
+    def _ensure_token_dir(self) -> None:
+        if not os.path.exists(self.token_dir):
+            os.makedirs(self.token_dir, exist_ok=True)
+
+    def _read_auth_file(self) -> Optional[Dict[str, Any]]:
+        try:
+            with open(self.auth_file, "r") as f:
+                return json.load(f)
+        except IOError:
+            return None
+        except json.JSONDecodeError as exc:
+            verbose_logger.warning("Invalid ChatGPT auth file: %s", exc)
+            return None
+
+    def _write_auth_file(self, data: Dict[str, Any]) -> None:
+        try:
+            with open(self.auth_file, "w") as f:
+                json.dump(data, f)
+        except IOError as exc:
+            verbose_logger.error("Failed to write ChatGPT auth file: %s", exc)
+
+    def _is_token_expired(self, auth_data: Dict[str, Any], access_token: str) -> bool:
+        expires_at = auth_data.get("expires_at")
+        if expires_at is None:
+            expires_at = self._get_expires_at(access_token)
+            if expires_at:
+                auth_data["expires_at"] = expires_at
+                self._write_auth_file(auth_data)
+        if expires_at is None:
+            return True
+        return time.time() >= float(expires_at) - TOKEN_EXPIRY_SKEW_SECONDS
+
+    def _get_expires_at(self, token: str) -> Optional[int]:
+        claims = self._decode_jwt_claims(token)
+        exp = claims.get("exp")
+        if isinstance(exp, (int, float)):
+            return int(exp)
+        return None
+
+    def _decode_jwt_claims(self, token: str) -> Dict[str, Any]:
+        try:
+            parts = token.split(".")
+            if len(parts) < 2:
+                return {}
+            payload_b64 = parts[1]
+            payload_b64 += "=" * (-len(payload_b64) % 4)
+            payload_bytes = base64.urlsafe_b64decode(payload_b64)
+            return json.loads(payload_bytes.decode("utf-8"))
+        except Exception:
+            return {}
+
+    def _extract_account_id(self, token: Optional[str]) -> Optional[str]:
+        if not token:
+            return None
+        claims = self._decode_jwt_claims(token)
+        auth_claims = claims.get("https://api.openai.com/auth")
+        if isinstance(auth_claims, dict):
+            account_id = auth_claims.get("chatgpt_account_id")
+            if isinstance(account_id, str) and account_id:
+                return account_id
+        return None
+
+    def _login_device_code(self) -> Dict[str, str]:
+        cooldown_remaining = self._get_device_code_cooldown_remaining(
+            self._read_auth_file()
+        )
+        if cooldown_remaining > 0:
+            token = self._wait_for_access_token(cooldown_remaining)
+            if token:
+                return {"access_token": token}
+
+        device_code = self._request_device_code()
+        self._record_device_code_request()
+        print(  # noqa: T201
+            "Sign in with ChatGPT using device code:\n"
+            f"1) Visit {CHATGPT_DEVICE_VERIFY_URL}\n"
+            f"2) Enter code: {device_code['user_code']}\n"
+            "Device codes are a common phishing target. Never share this code.",
+            flush=True,
+        )
+        auth_code = self._poll_for_authorization_code(device_code)
+        tokens = self._exchange_code_for_tokens(auth_code)
+        auth_data = self._build_auth_record(tokens)
+        self._write_auth_file(auth_data)
+        return tokens
+
+    def _request_device_code(self) -> Dict[str, str]:
+        try:
+            client = _get_httpx_client()
+            resp = client.post(
+                CHATGPT_DEVICE_CODE_URL,
+                json={"client_id": CHATGPT_CLIENT_ID},
+            )
+            resp.raise_for_status()
+            data = resp.json()
+        except httpx.HTTPStatusError as exc:
+            raise GetDeviceCodeError(
+                message=f"Failed to request device code: {exc}",
+                status_code=exc.response.status_code,
+            )
+        except Exception as exc:
+            raise GetDeviceCodeError(
+                message=f"Failed to request device code: {exc}",
+                status_code=400,
+            )
+
+        device_auth_id = data.get("device_auth_id")
+        user_code = data.get("user_code") or data.get("usercode")
+        interval = data.get("interval")
+        if not device_auth_id or not user_code:
+            raise GetDeviceCodeError(
+                message=f"Device code response missing fields: {data}",
+                status_code=400,
+            )
+        return {
+            "device_auth_id": device_auth_id,
+            "user_code": user_code,
+            "interval": str(interval or "5"),
+        }
+
+    def _poll_for_authorization_code(self, device_code: Dict[str, str]) -> Dict[str, str]:
+        client = _get_httpx_client()
+        interval = int(device_code.get("interval", "5"))
+        start_time = time.time()
+        while time.time() - start_time < DEVICE_CODE_TIMEOUT_SECONDS:
+            try:
+                resp = client.post(
+                    CHATGPT_DEVICE_TOKEN_URL,
+                    json={
+                        "device_auth_id": device_code["device_auth_id"],
+                        "user_code": device_code["user_code"],
+                    },
+                )
+                if resp.status_code == 200:
+                    data = resp.json()
+                    if all(
+                        key in data
+                        for key in (
+                            "authorization_code",
+                            "code_challenge",
+                            "code_verifier",
+                        )
+                    ):
+                        return data
+                if resp.status_code in (403, 404):
+                    time.sleep(max(interval, DEVICE_CODE_POLL_SLEEP_SECONDS))
+                    continue
+                resp.raise_for_status()
+            except httpx.HTTPStatusError as exc:
+                status_code = exc.response.status_code if exc.response else None
+                if status_code in (403, 404):
+                    time.sleep(max(interval, DEVICE_CODE_POLL_SLEEP_SECONDS))
+                    continue
+                raise GetAccessTokenError(
+                    message=f"Polling failed: {exc}",
+                    status_code=exc.response.status_code,
+                )
+            except Exception as exc:
+                raise GetAccessTokenError(
+                    message=f"Polling failed: {exc}",
+                    status_code=400,
+                )
+            time.sleep(max(interval, DEVICE_CODE_POLL_SLEEP_SECONDS))
+
+        raise GetAccessTokenError(
+            message="Timed out waiting for device authorization",
+            status_code=408,
+        )
+
+    def _exchange_code_for_tokens(self, code_data: Dict[str, str]) -> Dict[str, str]:
+        try:
+            client = _get_httpx_client()
+            redirect_uri = f"{CHATGPT_AUTH_BASE}/deviceauth/callback"
+            body = (
+                "grant_type=authorization_code"
+                f"&code={code_data['authorization_code']}"
+                f"&redirect_uri={redirect_uri}"
+                f"&client_id={CHATGPT_CLIENT_ID}"
+                f"&code_verifier={code_data['code_verifier']}"
+            )
+            resp = client.post(
+                CHATGPT_OAUTH_TOKEN_URL,
+                headers={"Content-Type": "application/x-www-form-urlencoded"},
+                content=body,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+        except httpx.HTTPStatusError as exc:
+            raise GetAccessTokenError(
+                message=f"Token exchange failed: {exc}",
+                status_code=exc.response.status_code,
+            )
+        except Exception as exc:
+            raise GetAccessTokenError(
+                message=f"Token exchange failed: {exc}",
+                status_code=400,
+            )
+
+        if not all(key in data for key in ("access_token", "refresh_token", "id_token")):
+            raise GetAccessTokenError(
+                message=f"Token exchange response missing fields: {data}",
+                status_code=400,
+            )
+        return {
+            "access_token": data["access_token"],
+            "refresh_token": data["refresh_token"],
+            "id_token": data["id_token"],
+        }
+
+    def _refresh_tokens(self, refresh_token: str) -> Dict[str, str]:
+        try:
+            client = _get_httpx_client()
+            resp = client.post(
+                CHATGPT_OAUTH_TOKEN_URL,
+                json={
+                    "client_id": CHATGPT_CLIENT_ID,
+                    "grant_type": "refresh_token",
+                    "refresh_token": refresh_token,
+                    "scope": "openid profile email",
+                },
+            )
+            resp.raise_for_status()
+            data = resp.json()
+        except httpx.HTTPStatusError as exc:
+            raise RefreshAccessTokenError(
+                message=f"Refresh token failed: {exc}",
+                status_code=exc.response.status_code,
+            )
+        except Exception as exc:
+            raise RefreshAccessTokenError(
+                message=f"Refresh token failed: {exc}",
+                status_code=400,
+            )
+
+        access_token = data.get("access_token")
+        id_token = data.get("id_token")
+        if not access_token or not id_token:
+            raise RefreshAccessTokenError(
+                message=f"Refresh response missing fields: {data}",
+                status_code=400,
+            )
+
+        refreshed = {
+            "access_token": access_token,
+            "refresh_token": data.get("refresh_token", refresh_token),
+            "id_token": id_token,
+        }
+        auth_data = self._build_auth_record(refreshed)
+        self._write_auth_file(auth_data)
+        return refreshed
+
+    def _build_auth_record(self, tokens: Dict[str, str]) -> Dict[str, Any]:
+        access_token = tokens.get("access_token")
+        id_token = tokens.get("id_token")
+        expires_at = self._get_expires_at(access_token) if access_token else None
+        account_id = self._extract_account_id(id_token or access_token)
+        return {
+            "access_token": access_token,
+            "refresh_token": tokens.get("refresh_token"),
+            "id_token": id_token,
+            "expires_at": expires_at,
+            "account_id": account_id,
+        }
+
+    def _get_device_code_cooldown_remaining(
+        self, auth_data: Optional[Dict[str, Any]]
+    ) -> float:
+        if not auth_data:
+            return 0.0
+        requested_at = auth_data.get("device_code_requested_at")
+        if not isinstance(requested_at, (int, float, str)):
+            return 0.0
+        try:
+            requested_at = float(requested_at)
+        except (TypeError, ValueError):
+            return 0.0
+        elapsed = time.time() - requested_at
+        remaining = DEVICE_CODE_COOLDOWN_SECONDS - elapsed
+        return max(0.0, remaining)
+
+    def _record_device_code_request(self) -> None:
+        auth_data = self._read_auth_file() or {}
+        auth_data["device_code_requested_at"] = time.time()
+        self._write_auth_file(auth_data)
+
+    def _wait_for_access_token(self, timeout_seconds: float) -> Optional[str]:
+        deadline = time.time() + timeout_seconds
+        while time.time() < deadline:
+            auth_data = self._read_auth_file()
+            if auth_data:
+                access_token = auth_data.get("access_token")
+                if access_token and not self._is_token_expired(
+                    auth_data, access_token
+                ):
+                    return access_token
+            sleep_for = min(DEVICE_CODE_POLL_SLEEP_SECONDS, max(0.0, deadline - time.time()))
+            if sleep_for <= 0:
+                break
+            time.sleep(sleep_for)
+        return None
diff --git a/litellm/llms/chatgpt/chat/transformation.py b/litellm/llms/chatgpt/chat/transformation.py
new file mode 100644
index 00000000000..2db5eb3c58d
--- /dev/null
+++ b/litellm/llms/chatgpt/chat/transformation.py
@@ -0,0 +1,75 @@
+from typing import List, Optional, Tuple
+
+from litellm.exceptions import AuthenticationError
+from litellm.llms.openai.openai import OpenAIConfig
+from litellm.types.llms.openai import AllMessageValues
+
+from ..authenticator import Authenticator
+from ..common_utils import (
+    GetAccessTokenError,
+    ensure_chatgpt_session_id,
+    get_chatgpt_default_headers,
+)
+
+
+class ChatGPTConfig(OpenAIConfig):
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        api_base: Optional[str] = None,
+        custom_llm_provider: str = "openai",
+    ) -> None:
+        super().__init__()
+        self.authenticator = Authenticator()
+
+    def _get_openai_compatible_provider_info(
+        self,
+        model: str,
+        api_base: Optional[str],
+        api_key: Optional[str],
+        custom_llm_provider: str,
+    ) -> Tuple[Optional[str], Optional[str], str]:
+        dynamic_api_base = self.authenticator.get_api_base()
+        try:
+            dynamic_api_key = self.authenticator.get_access_token()
+        except GetAccessTokenError as e:
+            raise AuthenticationError(
+                model=model,
+                llm_provider=custom_llm_provider,
+                message=str(e),
+            )
+        return dynamic_api_base, dynamic_api_key, custom_llm_provider
+
+    def validate_environment(
+        self,
+        headers: dict,
+        model: str,
+        messages: List[AllMessageValues],
+        optional_params: dict,
+        litellm_params: dict,
+        api_key: Optional[str] = None,
+        api_base: Optional[str] = None,
+    ) -> dict:
+        validated_headers = super().validate_environment(
+            headers, model, messages, optional_params, litellm_params, api_key, api_base
+        )
+
+        account_id = self.authenticator.get_account_id()
+        session_id = ensure_chatgpt_session_id(litellm_params)
+        default_headers = get_chatgpt_default_headers(
+            api_key or "", account_id, session_id
+        )
+        return {**default_headers, **validated_headers}
+
+    def map_openai_params(
+        self,
+        non_default_params: dict,
+        optional_params: dict,
+        model: str,
+        drop_params: bool,
+    ) -> dict:
+        optional_params = super().map_openai_params(
+            non_default_params, optional_params, model, drop_params
+        )
+        optional_params.setdefault("stream", False)
+        return optional_params
diff --git a/litellm/llms/chatgpt/common_utils.py b/litellm/llms/chatgpt/common_utils.py
new file mode 100644
index 00000000000..d80487cde24
--- /dev/null
+++ b/litellm/llms/chatgpt/common_utils.py
@@ -0,0 +1,301 @@
+"""
+Constants and helpers for ChatGPT subscription OAuth.
+"""
+import os
+import platform
+from typing import Any, Optional, Union
+from uuid import uuid4
+
+import httpx
+
+from litellm.llms.base_llm.chat.transformation import BaseLLMException
+
+# OAuth + API constants (derived from openai/codex)
+CHATGPT_AUTH_BASE = "https://auth.openai.com"
+CHATGPT_DEVICE_CODE_URL = f"{CHATGPT_AUTH_BASE}/api/accounts/deviceauth/usercode"
+CHATGPT_DEVICE_TOKEN_URL = f"{CHATGPT_AUTH_BASE}/api/accounts/deviceauth/token"
+CHATGPT_OAUTH_TOKEN_URL = f"{CHATGPT_AUTH_BASE}/oauth/token"
+CHATGPT_DEVICE_VERIFY_URL = f"{CHATGPT_AUTH_BASE}/codex/device"
+CHATGPT_API_BASE = "https://chatgpt.com/backend-api/codex"
+CHATGPT_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann"
+
+DEFAULT_ORIGINATOR = "codex_cli_rs"
+DEFAULT_USER_AGENT = "codex_cli_rs/0.0.0 (Unknown 0; unknown) unknown"
+CHATGPT_DEFAULT_INSTRUCTIONS = """You are Codex, based on GPT-5. You are running as a coding agent in the Codex CLI on a user's computer.
+
+## General
+
+- When searching for text or files, prefer using `rg` or `rg --files` respectively because `rg` is much faster than alternatives like `grep`. (If the `rg` command is not found, then use alternatives.)
+
+## Editing constraints
+
+- Default to ASCII when editing or creating files. Only introduce non-ASCII or other Unicode characters when there is a clear justification and the file already uses them.
+- Add succinct code comments that explain what is going on if code is not self-explanatory. You should not add comments like "Assigns the value to the variable", but a brief comment might be useful ahead of a complex code block that the user would otherwise have to spend time parsing out. Usage of these comments should be rare.
+- Try to use apply_patch for single file edits, but it is fine to explore other options to make the edit if it does not work well. Do not use apply_patch for changes that are auto-generated (i.e. generating package.json or running a lint or format command like gofmt) or when scripting is more efficient (such as search and replacing a string across a codebase).
+- You may be in a dirty git worktree.
+    * NEVER revert existing changes you did not make unless explicitly requested, since these changes were made by the user.
+    * If asked to make a commit or code edits and there are unrelated changes to your work or changes that you didn't make in those files, don't revert those changes.
+    * If the changes are in files you've touched recently, you should read carefully and understand how you can work with the changes rather than reverting them.
+    * If the changes are in unrelated files, just ignore them and don't revert them.
+- Do not amend a commit unless explicitly requested to do so.
+- While you are working, you might notice unexpected changes that you didn't make. If this happens, STOP IMMEDIATELY and ask the user how they would like to proceed.
+- **NEVER** use destructive commands like `git reset --hard` or `git checkout --` unless specifically requested or approved by the user.
+
+## Plan tool
+
+When using the planning tool:
+- Skip using the planning tool for straightforward tasks (roughly the easiest 25%).
+- Do not make single-step plans.
+- When you made a plan, update it after having performed one of the sub-tasks that you shared on the plan.
+
+## Special user requests
+
+- If the user makes a simple request (such as asking for the time) which you can fulfill by running a terminal command (such as `date`), you should do so.
+- If the user asks for a "review", default to a code review mindset: prioritise identifying bugs, risks, behavioural regressions, and missing tests. Findings must be the primary focus of the response - keep summaries or overviews brief and only after enumerating the issues. Present findings first (ordered by severity with file/line references), follow with open questions or assumptions, and offer a change-summary only as a secondary detail. If no findings are discovered, state that explicitly and mention any residual risks or testing gaps.
+
+## Frontend tasks
+When doing frontend design tasks, avoid collapsing into "AI slop" or safe, average-looking layouts.
+Aim for interfaces that feel intentional, bold, and a bit surprising.
+- Typography: Use expressive, purposeful fonts and avoid default stacks (Inter, Roboto, Arial, system).
+- Color & Look: Choose a clear visual direction; define CSS variables; avoid purple-on-white defaults. No purple bias or dark mode bias.
+- Motion: Use a few meaningful animations (page-load, staggered reveals) instead of generic micro-motions.
+- Background: Don't rely on flat, single-color backgrounds; use gradients, shapes, or subtle patterns to build atmosphere.
+- Overall: Avoid boilerplate layouts and interchangeable UI patterns. Vary themes, type families, and visual languages across outputs.
+- Ensure the page loads properly on both desktop and mobile
+
+Exception: If working within an existing website or design system, preserve the established patterns, structure, and visual language.
+
+## Presenting your work and final message
+
+You are producing plain text that will later be styled by the CLI. Follow these rules exactly. Formatting should make results easy to scan, but not feel mechanical. Use judgment to decide how much structure adds value.
+
+- Default: be very concise; friendly coding teammate tone.
+- Ask only when needed; suggest ideas; mirror the user's style.
+- For substantial work, summarize clearly; follow final-answer formatting.
+- Skip heavy formatting for simple confirmations.
+- Don't dump large files you've written; reference paths only.
+- No "save/copy this file" - User is on the same machine.
+- Offer logical next steps (tests, commits, build) briefly; add verify steps if you couldn't do something.
+- For code changes:
+  * Lead with a quick explanation of the change, and then give more details on the context covering where and why a change was made. Do not start this explanation with "summary", just jump right in.
+  * If there are natural next steps the user may want to take, suggest them at the end of your response. Do not make suggestions if there are no natural next steps.
+  * When suggesting multiple options, use numeric lists for the suggestions so the user can quickly respond with a single number.
+- The user does not command execution outputs. When asked to show the output of a command (e.g. `git show`), relay the important details in your answer or summarize the key lines so the user understands the result.
+
+### Final answer structure and style guidelines
+
+- Plain text; CLI handles styling. Use structure only when it helps scanability.
+- Headers: optional; short Title Case (1-3 words) wrapped in **...**; no blank line before the first bullet; add only if they truly help.
+- Bullets: use - ; merge related points; keep to one line when possible; 4-6 per list ordered by importance; keep phrasing consistent.
+- Monospace: backticks for commands/paths/env vars/code ids and inline examples; use for literal keyword bullets; never combine with **.
+- Code samples or multi-line snippets should be wrapped in fenced code blocks; include an info string as often as possible.
+- Structure: group related bullets; order sections general -> specific -> supporting; for subsections, start with a bolded keyword bullet, then items; match complexity to the task.
+- Tone: collaborative, concise, factual; present tense, active voice; self-contained; no "above/below"; parallel wording.
+- Don'ts: no nested bullets/hierarchies; no ANSI codes; don't cram unrelated keywords; keep keyword lists short--wrap/reformat if long; avoid naming formatting styles in answers.
+- Adaptation: code explanations -> precise, structured with code refs; simple tasks -> lead with outcome; big changes -> logical walkthrough + rationale + next actions; casual one-offs -> plain sentences, no headers/bullets.
+- File References: When referencing files in your response follow the below rules:
+  * Use inline code to make file paths clickable.
+  * Each reference should have a stand alone path. Even if it's the same file.
+  * Accepted: absolute, workspace-relative, a/ or b/ diff prefixes, or bare filename/suffix.
+  * Optionally include line/column (1-based): :line[:column] or #Lline[Ccolumn] (column defaults to 1).
+  * Do not use URIs like file://, vscode://, or https://.
+  * Do not provide range of lines
+  * Examples: src/app.ts, src/app.ts:42, b/server/index.js#L10, C:\\repo\\project\\main.rs:12:5
+"""
+
+
+class ChatGPTAuthError(BaseLLMException):
+    def __init__(
+        self,
+        status_code,
+        message,
+        request: Optional[httpx.Request] = None,
+        response: Optional[httpx.Response] = None,
+        headers: Optional[Union[httpx.Headers, dict]] = None,
+        body: Optional[dict] = None,
+    ):
+        super().__init__(
+            status_code=status_code,
+            message=message,
+            request=request,
+            response=response,
+            headers=headers,
+            body=body,
+        )
+
+
+class GetDeviceCodeError(ChatGPTAuthError):
+    pass
+
+
+class GetAccessTokenError(ChatGPTAuthError):
+    pass
+
+
+class RefreshAccessTokenError(ChatGPTAuthError):
+    pass
+
+
+def _safe_header_value(value: str) -> str:
+    if not value:
+        return ""
+    return "".join(ch if 32 <= ord(ch) <= 126 else "_" for ch in value)
+
+
+def _sanitize_user_agent_token(value: str) -> str:
+    if not value:
+        return ""
+    return "".join(
+        ch if (ch.isalnum() or ch in "-_./") else "_" for ch in value
+    )
+
+
+def _terminal_user_agent() -> str:
+    term_program = os.getenv("TERM_PROGRAM")
+    if term_program:
+        version = os.getenv("TERM_PROGRAM_VERSION")
+        token = f"{term_program}/{version}" if version else term_program
+        return _sanitize_user_agent_token(token) or "unknown"
+
+    wezterm_version = os.getenv("WEZTERM_VERSION")
+    if wezterm_version is not None:
+        token = (
+            f"WezTerm/{wezterm_version}" if wezterm_version else "WezTerm"
+        )
+        return _sanitize_user_agent_token(token) or "WezTerm"
+
+    if (
+        os.getenv("ITERM_SESSION_ID")
+        or os.getenv("ITERM_PROFILE")
+        or os.getenv("ITERM_PROFILE_NAME")
+    ):
+        return "iTerm.app"
+
+    if os.getenv("TERM_SESSION_ID"):
+        return "Apple_Terminal"
+
+    if os.getenv("KITTY_WINDOW_ID") or "kitty" in (os.getenv("TERM") or ""):
+        return "kitty"
+
+    if os.getenv("ALACRITTY_SOCKET") or os.getenv("TERM") == "alacritty":
+        return "Alacritty"
+
+    konsole_version = os.getenv("KONSOLE_VERSION")
+    if konsole_version is not None:
+        token = (
+            f"Konsole/{konsole_version}" if konsole_version else "Konsole"
+        )
+        return _sanitize_user_agent_token(token) or "Konsole"
+
+    if os.getenv("GNOME_TERMINAL_SCREEN"):
+        return "gnome-terminal"
+
+    vte_version = os.getenv("VTE_VERSION")
+    if vte_version is not None:
+        token = f"VTE/{vte_version}" if vte_version else "VTE"
+        return _sanitize_user_agent_token(token) or "VTE"
+
+    if os.getenv("WT_SESSION"):
+        return "WindowsTerminal"
+
+    term = os.getenv("TERM")
+    if term:
+        return _sanitize_user_agent_token(term) or "unknown"
+
+    return "unknown"
+
+
+def _get_litellm_version() -> str:
+    try:
+        from importlib.metadata import version
+
+        return version("litellm")
+    except Exception:
+        return "0.0.0"
+
+
+def get_chatgpt_originator() -> str:
+    originator = os.getenv("CHATGPT_ORIGINATOR") or DEFAULT_ORIGINATOR
+    return _safe_header_value(originator) or DEFAULT_ORIGINATOR
+
+
+def get_chatgpt_user_agent(originator: str) -> str:
+    override = os.getenv("CHATGPT_USER_AGENT")
+    if override:
+        return _safe_header_value(override) or DEFAULT_USER_AGENT
+    version = _get_litellm_version()
+    os_type = platform.system() or "Unknown"
+    os_version = platform.release() or "0"
+    arch = platform.machine() or "unknown"
+    terminal_ua = _terminal_user_agent()
+    suffix = os.getenv("CHATGPT_USER_AGENT_SUFFIX", "").strip()
+    suffix = f" ({suffix})" if suffix else ""
+    candidate = (
+        f"{originator}/{version} ({os_type} {os_version}; {arch}) {terminal_ua}{suffix}"
+    )
+    return _safe_header_value(candidate) or DEFAULT_USER_AGENT
+
+
+def get_chatgpt_default_headers(
+    access_token: str,
+    account_id: Optional[str],
+    session_id: Optional[str] = None,
+) -> dict:
+    originator = get_chatgpt_originator()
+    user_agent = get_chatgpt_user_agent(originator)
+    headers = {
+        "Authorization": f"Bearer {access_token}",
+        "content-type": "application/json",
+        "accept": "text/event-stream",
+        "originator": originator,
+        "user-agent": user_agent,
+    }
+    if session_id:
+        headers["session_id"] = session_id
+    if account_id:
+        headers["ChatGPT-Account-Id"] = account_id
+    return headers
+
+
+def get_chatgpt_default_instructions() -> str:
+    return os.getenv("CHATGPT_DEFAULT_INSTRUCTIONS") or CHATGPT_DEFAULT_INSTRUCTIONS
+
+
+def _normalize_litellm_params(litellm_params: Optional[Any]) -> dict:
+    if litellm_params is None:
+        return {}
+    if isinstance(litellm_params, dict):
+        return litellm_params
+    if hasattr(litellm_params, "model_dump"):
+        try:
+            return litellm_params.model_dump()
+        except Exception:
+            return {}
+    if hasattr(litellm_params, "dict"):
+        try:
+            return litellm_params.dict()
+        except Exception:
+            return {}
+    return {}
+
+
+def get_chatgpt_session_id(litellm_params: Optional[Any]) -> Optional[str]:
+    params = _normalize_litellm_params(litellm_params)
+    for key in ("litellm_session_id", "session_id"):
+        value = params.get(key)
+        if value:
+            return str(value)
+    metadata = params.get("metadata")
+    if isinstance(metadata, dict):
+        value = metadata.get("session_id")
+        if value:
+            return str(value)
+    for key in ("litellm_trace_id", "litellm_call_id"):
+        value = params.get(key)
+        if value:
+            return str(value)
+    return None
+
+
+def ensure_chatgpt_session_id(litellm_params: Optional[Any]) -> str:
+    return get_chatgpt_session_id(litellm_params) or str(uuid4())
diff --git a/litellm/llms/chatgpt/responses/transformation.py b/litellm/llms/chatgpt/responses/transformation.py
new file mode 100644
index 00000000000..0ce24f63a89
--- /dev/null
+++ b/litellm/llms/chatgpt/responses/transformation.py
@@ -0,0 +1,191 @@
+import json
+from typing import Any, Optional
+
+from litellm.exceptions import AuthenticationError
+from litellm.constants import STREAM_SSE_DONE_STRING
+from litellm.litellm_core_utils.core_helpers import process_response_headers
+from litellm.llms.openai.common_utils import OpenAIError
+from litellm.llms.openai.responses.transformation import OpenAIResponsesAPIConfig
+from litellm.litellm_core_utils.llm_response_utils.convert_dict_to_response import (
+    _safe_convert_created_field,
+)
+from litellm.types.llms.openai import (
+    ResponsesAPIResponse,
+    ResponsesAPIStreamEvents,
+)
+from litellm.types.router import GenericLiteLLMParams
+from litellm.types.utils import LlmProviders
+from litellm.utils import CustomStreamWrapper
+
+from ..authenticator import Authenticator
+from ..common_utils import (
+    CHATGPT_API_BASE,
+    GetAccessTokenError,
+    ensure_chatgpt_session_id,
+    get_chatgpt_default_headers,
+    get_chatgpt_default_instructions,
+)
+
+
+class ChatGPTResponsesAPIConfig(OpenAIResponsesAPIConfig):
+    def __init__(self) -> None:
+        super().__init__()
+        self.authenticator = Authenticator()
+
+    @property
+    def custom_llm_provider(self) -> LlmProviders:
+        return LlmProviders.CHATGPT
+
+    def validate_environment(
+        self,
+        headers: dict,
+        model: str,
+        litellm_params: Optional[GenericLiteLLMParams],
+    ) -> dict:
+        try:
+            access_token = self.authenticator.get_access_token()
+        except GetAccessTokenError as e:
+            raise AuthenticationError(
+                model=model,
+                llm_provider="chatgpt",
+                message=str(e),
+            )
+
+        account_id = self.authenticator.get_account_id()
+        session_id = ensure_chatgpt_session_id(litellm_params)
+        default_headers = get_chatgpt_default_headers(
+            access_token, account_id, session_id
+        )
+        return {**default_headers, **headers}
+
+    def transform_responses_api_request(
+        self,
+        model: str,
+        input: Any,
+        response_api_optional_request_params: dict,
+        litellm_params: GenericLiteLLMParams,
+        headers: dict,
+    ) -> dict:
+        request = super().transform_responses_api_request(
+            model,
+            input,
+            response_api_optional_request_params,
+            litellm_params,
+            headers,
+        )
+        request.pop("max_output_tokens", None)
+        request.pop("max_tokens", None)
+        request.pop("max_completion_tokens", None)
+        request.pop("metadata", None)
+        base_instructions = get_chatgpt_default_instructions()
+        existing_instructions = request.get("instructions")
+        if existing_instructions:
+            if base_instructions not in existing_instructions:
+                request["instructions"] = (
+                    f"{base_instructions}\n\n{existing_instructions}"
+                )
+        else:
+            request["instructions"] = base_instructions
+        request["store"] = False
+        request["stream"] = True
+        include = list(request.get("include") or [])
+        if "reasoning.encrypted_content" not in include:
+            include.append("reasoning.encrypted_content")
+        request["include"] = include
+        return request
+
+    def transform_response_api_response(
+        self,
+        model: str,
+        raw_response: Any,
+        logging_obj: Any,
+    ):
+        content_type = (raw_response.headers or {}).get("content-type", "")
+        body_text = raw_response.text or ""
+        if "text/event-stream" not in content_type.lower():
+            trimmed_body = body_text.lstrip()
+            if not (
+                trimmed_body.startswith("event:")
+                or trimmed_body.startswith("data:")
+                or "\nevent:" in body_text
+                or "\ndata:" in body_text
+            ):
+                return super().transform_response_api_response(
+                    model=model,
+                    raw_response=raw_response,
+                    logging_obj=logging_obj,
+                )
+
+        logging_obj.post_call(
+            original_response=raw_response.text,
+            additional_args={"complete_input_dict": {}},
+        )
+
+        completed_response = None
+        error_message = None
+        for chunk in body_text.splitlines():
+            stripped_chunk = CustomStreamWrapper._strip_sse_data_from_chunk(chunk)
+            if not stripped_chunk:
+                continue
+            stripped_chunk = stripped_chunk.strip()
+            if not stripped_chunk:
+                continue
+            if stripped_chunk == STREAM_SSE_DONE_STRING:
+                break
+            try:
+                parsed_chunk = json.loads(stripped_chunk)
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(parsed_chunk, dict):
+                continue
+            event_type = parsed_chunk.get("type")
+            if event_type == ResponsesAPIStreamEvents.RESPONSE_COMPLETED:
+                response_payload = parsed_chunk.get("response")
+                if isinstance(response_payload, dict):
+                    response_payload = dict(response_payload)
+                    if "created_at" in response_payload:
+                        response_payload["created_at"] = _safe_convert_created_field(
+                            response_payload["created_at"]
+                        )
+                    try:
+                        completed_response = ResponsesAPIResponse(**response_payload)
+                    except Exception:
+                        completed_response = ResponsesAPIResponse.model_construct(
+                            **response_payload
+                        )
+                break
+            if event_type in (
+                ResponsesAPIStreamEvents.RESPONSE_FAILED,
+                ResponsesAPIStreamEvents.ERROR,
+            ):
+                error_obj = parsed_chunk.get("error") or (
+                    parsed_chunk.get("response") or {}
+                ).get("error")
+                if error_obj is not None:
+                    if isinstance(error_obj, dict):
+                        error_message = error_obj.get("message") or str(error_obj)
+                    else:
+                        error_message = str(error_obj)
+
+        if completed_response is None:
+            raise OpenAIError(
+                message=error_message or raw_response.text,
+                status_code=raw_response.status_code,
+            )
+
+        raw_headers = dict(raw_response.headers)
+        processed_headers = process_response_headers(raw_headers)
+        if not hasattr(completed_response, "_hidden_params"):
+            setattr(completed_response, "_hidden_params", {})
+        completed_response._hidden_params["additional_headers"] = processed_headers
+        completed_response._hidden_params["headers"] = raw_headers
+        return completed_response
+
+    def get_complete_url(
+        self,
+        api_base: Optional[str],
+        litellm_params: dict,
+    ) -> str:
+        api_base = api_base or self.authenticator.get_api_base() or CHATGPT_API_BASE
+        api_base = api_base.rstrip("/")
+        return f"{api_base}/responses"
diff --git a/litellm/llms/openai/realtime/handler.py b/litellm/llms/openai/realtime/handler.py
index 6ab43ab31e4..fd04ac4d458 100644
--- a/litellm/llms/openai/realtime/handler.py
+++ b/litellm/llms/openai/realtime/handler.py
@@ -56,7 +56,9 @@ class OpenAIRealtime(OpenAIChatCompletion):
         url = self._construct_url(api_base, query_params)
 
         try:
-            ssl_context = get_shared_realtime_ssl_context()
+            # Only use SSL context for secure websocket connections (wss://)
+            # websockets library doesn't accept ssl argument for ws:// URIs
+            ssl_context = None if url.startswith("ws://") else get_shared_realtime_ssl_context()
             # Log a masked request preview consistent with other endpoints.
             logging_obj.pre_call(
                 input=None,
diff --git a/litellm/llms/vertex_ai/common_utils.py b/litellm/llms/vertex_ai/common_utils.py
index 5b09bcc0289..152b99ca4db 100644
--- a/litellm/llms/vertex_ai/common_utils.py
+++ b/litellm/llms/vertex_ai/common_utils.py
@@ -150,6 +150,34 @@ def get_supports_response_schema(
     return _supports_response_schema
 
 
+def supports_response_json_schema(model: str) -> bool:
+    """
+    Check if the model supports responseJsonSchema (JSON Schema format).
+
+    responseJsonSchema is supported by Gemini 2.0+ models and uses standard
+    JSON Schema format with lowercase types (string, object, etc.) instead of
+    the OpenAPI-style responseSchema with uppercase types (STRING, OBJECT, etc.).
+
+    Benefits of responseJsonSchema:
+    - Supports additionalProperties for stricter schema validation
+    - Uses standard JSON Schema format (no type conversion needed)
+    - Better compatibility with Pydantic's model_json_schema()
+
+    Args:
+        model: The model name (e.g., "gemini-2.0-flash", "gemini-2.5-pro")
+
+    Returns:
+        True if the model supports responseJsonSchema, False otherwise
+    """
+    model_lower = model.lower()
+
+    # Gemini 2.0+ and 2.5+ models support responseJsonSchema
+    # Pattern matches: gemini-2.0-*, gemini-2.5-*, gemini-3-*, etc.
+    gemini_2_plus_pattern = re.compile(r"gemini-([2-9]|[1-9]\d+)\.")
+
+    return bool(gemini_2_plus_pattern.search(model_lower))
+
+
 from typing import Literal, Optional
 
 all_gemini_url_modes = Literal[
@@ -487,6 +515,44 @@ def _build_vertex_schema(parameters: dict, add_property_ordering: bool = False):
     return parameters
 
 
+def _build_json_schema(parameters: dict) -> dict:
+    """
+    Build a JSON Schema for use with Gemini's responseJsonSchema parameter.
+
+    Unlike _build_vertex_schema (used for responseSchema), this function:
+    - Does NOT convert types to uppercase (keeps standard JSON Schema format)
+    - Does NOT add propertyOrdering
+    - Does NOT filter fields (allows additionalProperties)
+    - Still unpacks $defs/$ref (Gemini doesn't support JSON Schema references)
+
+    Parameters:
+        parameters: dict - the JSON schema to process
+
+    Returns:
+        dict - the processed schema in standard JSON Schema format
+    """
+    # Unpack $defs references (Gemini doesn't support $ref)
+    defs = parameters.pop("$defs", {})
+    for name, value in defs.items():
+        unpack_defs(value, defs)
+    unpack_defs(parameters, defs)
+
+    # Convert anyOf with null to nullable
+    convert_anyof_null_to_nullable(parameters)
+
+    # Handle empty strings in enum values - Gemini doesn't accept empty strings in enums
+    _fix_enum_empty_strings(parameters)
+
+    # Remove enums for non-string typed fields (Gemini requires enum only on strings)
+    _fix_enum_types(parameters)
+
+    # Handle empty items objects
+    process_items(parameters)
+    add_object_type(parameters)
+
+    return parameters
+
+
 def _filter_anyof_fields(schema_dict: Dict[str, Any]) -> Dict[str, Any]:
     """
     When anyof is present, only keep the anyof field and its contents - otherwise VertexAI will throw an error - https://github.com/BerriAI/litellm/issues/11164
diff --git a/litellm/llms/vertex_ai/gemini/vertex_and_google_ai_studio_gemini.py b/litellm/llms/vertex_ai/gemini/vertex_and_google_ai_studio_gemini.py
index 46ea78ac9ef..2d2e07e74db 100644
--- a/litellm/llms/vertex_ai/gemini/vertex_and_google_ai_studio_gemini.py
+++ b/litellm/llms/vertex_ai/gemini/vertex_and_google_ai_studio_gemini.py
@@ -92,7 +92,12 @@ from litellm.utils import (
 )
 
 from ....utils import _remove_additional_properties, _remove_strict_from_schema
-from ..common_utils import VertexAIError, _build_vertex_schema
+from ..common_utils import (
+    VertexAIError,
+    _build_json_schema,
+    _build_vertex_schema,
+    supports_response_json_schema,
+)
 from ..vertex_llm_base import VertexBase
 from .transformation import (
     _gemini_convert_messages_with_history,
@@ -624,30 +629,55 @@ class VertexGeminiConfig(VertexAIBaseConfig, BaseConfig):
             )
         return old_schema
 
-    def apply_response_schema_transformation(self, value: dict, optional_params: dict):
+    def apply_response_schema_transformation(
+        self, value: dict, optional_params: dict, model: str
+    ):
         new_value = deepcopy(value)
-        # remove 'additionalProperties' from json schema
-        new_value = _remove_additional_properties(new_value)
-        # remove 'strict' from json schema
+        # remove 'strict' from json schema (not supported by Gemini)
         new_value = _remove_strict_from_schema(new_value)
-        if new_value["type"] == "json_object":
+
+        # Automatically use responseJsonSchema for Gemini 2.0+ models
+        # responseJsonSchema uses standard JSON Schema format and supports additionalProperties
+        # For older models (Gemini 1.5), fall back to responseSchema (OpenAPI format)
+        use_json_schema = supports_response_json_schema(model)
+
+        if not use_json_schema:
+            # For responseSchema, remove 'additionalProperties' (not supported)
+            new_value = _remove_additional_properties(new_value)
+
+        # Handle response type
+        if new_value.get("type") == "json_object":
             optional_params["response_mime_type"] = "application/json"
-        elif new_value["type"] == "text":
+        elif new_value.get("type") == "text":
             optional_params["response_mime_type"] = "text/plain"
+
+        # Extract schema from response_format
+        schema = None
         if "response_schema" in new_value:
             optional_params["response_mime_type"] = "application/json"
-            optional_params["response_schema"] = new_value["response_schema"]
-        elif new_value["type"] == "json_schema":  # type: ignore
-            if "json_schema" in new_value and "schema" in new_value["json_schema"]:  # type: ignore
+            schema = new_value["response_schema"]
+        elif new_value.get("type") == "json_schema":
+            if "json_schema" in new_value and "schema" in new_value["json_schema"]:
                 optional_params["response_mime_type"] = "application/json"
-                optional_params["response_schema"] = new_value["json_schema"]["schema"]  # type: ignore
+                schema = new_value["json_schema"]["schema"]
 
-        if "response_schema" in optional_params and isinstance(
-            optional_params["response_schema"], dict
-        ):
-            optional_params["response_schema"] = self._map_response_schema(
-                value=optional_params["response_schema"]
-            )
+        if schema and isinstance(schema, dict):
+            if use_json_schema:
+                # Use responseJsonSchema (Gemini 2.0+ only, opt-in)
+                # - Standard JSON Schema format (lowercase types)
+                # - Supports additionalProperties
+                # - No propertyOrdering needed
+                optional_params["response_json_schema"] = _build_json_schema(
+                    deepcopy(schema)
+                )
+            else:
+                # Use responseSchema (default, backwards compatible)
+                # - OpenAPI-style format (uppercase types)
+                # - No additionalProperties support
+                # - Requires propertyOrdering
+                optional_params["response_schema"] = self._map_response_schema(
+                    value=schema
+                )
 
     @staticmethod
     def _map_reasoning_effort_to_thinking_budget(
@@ -947,7 +977,7 @@ class VertexGeminiConfig(VertexAIBaseConfig, BaseConfig):
                 optional_params["max_output_tokens"] = value
             elif param == "response_format" and isinstance(value, dict):  # type: ignore
                 self.apply_response_schema_transformation(
-                    value=value, optional_params=optional_params
+                    value=value, optional_params=optional_params, model=model
                 )
             elif param == "frequency_penalty":
                 if self._supports_penalty_parameters(model):
diff --git a/litellm/llms/vertex_ai/multimodal_embeddings/transformation.py b/litellm/llms/vertex_ai/multimodal_embeddings/transformation.py
index 2cb2ac9ed8f..d82c2bebb7f 100644
--- a/litellm/llms/vertex_ai/multimodal_embeddings/transformation.py
+++ b/litellm/llms/vertex_ai/multimodal_embeddings/transformation.py
@@ -265,7 +265,7 @@ class VertexAIMultimodalEmbeddingConfig(BaseEmbeddingConfig):
                 image_count += 1
 
         ## Calculate video embeddings usage
-        video_length_seconds = 0
+        video_length_seconds = 0.0
         for prediction in vertex_predictions["predictions"]:
             video_embeddings = prediction.get("videoEmbeddings")
             if video_embeddings:
diff --git a/litellm/llms/vertex_ai/vertex_llm_base.py b/litellm/llms/vertex_ai/vertex_llm_base.py
index 826f151df35..a185370e376 100644
--- a/litellm/llms/vertex_ai/vertex_llm_base.py
+++ b/litellm/llms/vertex_ai/vertex_llm_base.py
@@ -23,6 +23,11 @@ from .common_utils import (
     is_global_only_vertex_model,
 )
 
+GOOGLE_IMPORT_ERROR_MESSAGE = (
+    "Google Cloud SDK not found. Install it with: pip install 'litellm[google]' "
+    "or pip install google-cloud-aiplatform"
+)
+
 if TYPE_CHECKING:
     from google.auth.credentials import Credentials as GoogleCredentialsObject
 else:
@@ -138,7 +143,10 @@ class VertexBase:
 
     # Google Auth Helpers -- extracted for mocking purposes in tests
     def _credentials_from_identity_pool(self, json_obj, scopes):
-        from google.auth import identity_pool
+        try:
+            from google.auth import identity_pool
+        except ImportError:
+            raise ImportError(GOOGLE_IMPORT_ERROR_MESSAGE)
 
         creds = identity_pool.Credentials.from_info(json_obj)
         if scopes and hasattr(creds, "requires_scopes") and creds.requires_scopes:
@@ -146,7 +154,10 @@ class VertexBase:
         return creds
 
     def _credentials_from_identity_pool_with_aws(self, json_obj, scopes):
-        from google.auth import aws
+        try:
+            from google.auth import aws
+        except ImportError:
+            raise ImportError(GOOGLE_IMPORT_ERROR_MESSAGE)
 
         creds = aws.Credentials.from_info(json_obj)
         if scopes and hasattr(creds, "requires_scopes") and creds.requires_scopes:
@@ -154,22 +165,30 @@ class VertexBase:
         return creds
 
     def _credentials_from_authorized_user(self, json_obj, scopes):
-        import google.oauth2.credentials
+        try:
+            import google.oauth2.credentials
+        except ImportError:
+            raise ImportError(GOOGLE_IMPORT_ERROR_MESSAGE)
 
         return google.oauth2.credentials.Credentials.from_authorized_user_info(
             json_obj, scopes=scopes
         )
 
     def _credentials_from_service_account(self, json_obj, scopes):
-        import google.oauth2.service_account
+        try:
+            import google.oauth2.service_account
+        except ImportError:
+            raise ImportError(GOOGLE_IMPORT_ERROR_MESSAGE)
 
         return google.oauth2.service_account.Credentials.from_service_account_info(
             json_obj, scopes=scopes
         )
 
     def _credentials_from_default_auth(self, scopes):
-
-        import google.auth as google_auth
+        try:
+            import google.auth as google_auth
+        except ImportError:
+            raise ImportError(GOOGLE_IMPORT_ERROR_MESSAGE)
 
         return google_auth.default(scopes=scopes)
 
@@ -261,9 +280,12 @@ class VertexBase:
         return api_base
 
     def refresh_auth(self, credentials: Any) -> None:
-        from google.auth.transport.requests import (
-            Request,  # type: ignore[import-untyped]
-        )
+        try:
+            from google.auth.transport.requests import (
+                Request,  # type: ignore[import-untyped]
+            )
+        except ImportError:
+            raise ImportError(GOOGLE_IMPORT_ERROR_MESSAGE)
 
         credentials.refresh(Request())
 
diff --git a/litellm/model_prices_and_context_window_backup.json b/litellm/model_prices_and_context_window_backup.json
index 4599cafe708..135b0d46ed0 100644
--- a/litellm/model_prices_and_context_window_backup.json
+++ b/litellm/model_prices_and_context_window_backup.json
@@ -13465,6 +13465,31 @@
         "supports_vision": true,
         "supports_web_search": true
     },
+    "gemini-2.5-computer-use-preview-10-2025": {
+        "input_cost_per_token": 1.25e-06,
+        "input_cost_per_token_above_200k_tokens": 2.5e-06,
+        "litellm_provider": "vertex_ai-language-models",
+        "max_images_per_prompt": 3000,
+        "max_input_tokens": 128000,
+        "max_output_tokens": 64000,
+        "max_tokens": 64000,
+        "mode": "chat",
+        "output_cost_per_token": 1e-05,
+        "output_cost_per_token_above_200k_tokens": 1.5e-05,
+        "source": "https://cloud.google.com/vertex-ai/generative-ai/docs/computer-use",
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true
+    },
     "gemini-embedding-001": {
         "input_cost_per_token": 1.5e-07,
         "litellm_provider": "vertex_ai-embedding-models",
@@ -15950,6 +15975,63 @@
         "max_tokens": 8191,
         "mode": "embedding"
     },
+    "chatgpt/gpt-5.2-codex": {
+        "litellm_provider": "chatgpt",
+        "max_input_tokens": 128000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "responses",
+        "supported_endpoints": [
+            "/v1/responses"
+        ],
+        "supports_function_calling": true,
+        "supports_parallel_function_calling": true,
+        "supports_response_schema": true,
+        "supports_vision": true
+    },
+    "chatgpt/gpt-5.2": {
+        "litellm_provider": "chatgpt",
+        "max_input_tokens": 128000,
+        "max_output_tokens": 64000,
+        "max_tokens": 64000,
+        "mode": "responses",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supports_function_calling": true,
+        "supports_parallel_function_calling": true,
+        "supports_response_schema": true,
+        "supports_vision": true
+    },
+    "chatgpt/gpt-5.1-codex-max": {
+        "litellm_provider": "chatgpt",
+        "max_input_tokens": 128000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "responses",
+        "supported_endpoints": [
+            "/v1/responses"
+        ],
+        "supports_function_calling": true,
+        "supports_parallel_function_calling": true,
+        "supports_response_schema": true,
+        "supports_vision": true
+    },
+    "chatgpt/gpt-5.1-codex-mini": {
+        "litellm_provider": "chatgpt",
+        "max_input_tokens": 128000,
+        "max_output_tokens": 64000,
+        "max_tokens": 64000,
+        "mode": "responses",
+        "supported_endpoints": [
+            "/v1/responses"
+        ],
+        "supports_function_calling": true,
+        "supports_parallel_function_calling": true,
+        "supports_response_schema": true,
+        "supports_vision": true
+    },
     "gigachat/GigaChat-2-Lite": {
         "input_cost_per_token": 0.0,
         "litellm_provider": "gigachat",
diff --git a/litellm/proxy/_types.py b/litellm/proxy/_types.py
index f717cca9b9f..2fd03ac2128 100644
--- a/litellm/proxy/_types.py
+++ b/litellm/proxy/_types.py
@@ -360,7 +360,6 @@ class LiteLLMRoutes(enum.Enum):
         # OCR
         "/ocr",
         "/v1/ocr",
-
         # containers API
         "/containers",
         "/v1/containers",
@@ -421,6 +420,7 @@ class LiteLLMRoutes(enum.Enum):
         "/a2a/{agent_id}",
         "/a2a/{agent_id}/message/send",
         "/a2a/{agent_id}/message/stream",
+        "/a2a/{agent_id}/.well-known/agent-card.json",
     ]
 
     google_routes = [
@@ -836,9 +836,9 @@ class GenerateRequestBase(LiteLLMPydanticObjectBase):
     allowed_cache_controls: Optional[list] = []
     config: Optional[dict] = {}
     permissions: Optional[dict] = {}
-    model_max_budget: Optional[dict] = (
-        {}
-    )  # {"gpt-4": 5.0, "gpt-3.5-turbo": 5.0}, defaults to {}
+    model_max_budget: Optional[
+        dict
+    ] = {}  # {"gpt-4": 5.0, "gpt-3.5-turbo": 5.0}, defaults to {}
 
     model_config = ConfigDict(protected_namespaces=())
     model_rpm_limit: Optional[dict] = None
@@ -1372,12 +1372,12 @@ class NewCustomerRequest(BudgetNewRequest):
     blocked: bool = False  # allow/disallow requests for this end-user
     budget_id: Optional[str] = None  # give either a budget_id or max_budget
     spend: Optional[float] = None
-    allowed_model_region: Optional[AllowedModelRegion] = (
-        None  # require all user requests to use models in this specific region
-    )
-    default_model: Optional[str] = (
-        None  # if no equivalent model in allowed region - default all requests to this model
-    )
+    allowed_model_region: Optional[
+        AllowedModelRegion
+    ] = None  # require all user requests to use models in this specific region
+    default_model: Optional[
+        str
+    ] = None  # if no equivalent model in allowed region - default all requests to this model
 
     @model_validator(mode="before")
     @classmethod
@@ -1399,12 +1399,12 @@ class UpdateCustomerRequest(LiteLLMPydanticObjectBase):
     blocked: bool = False  # allow/disallow requests for this end-user
     max_budget: Optional[float] = None
     budget_id: Optional[str] = None  # give either a budget_id or max_budget
-    allowed_model_region: Optional[AllowedModelRegion] = (
-        None  # require all user requests to use models in this specific region
-    )
-    default_model: Optional[str] = (
-        None  # if no equivalent model in allowed region - default all requests to this model
-    )
+    allowed_model_region: Optional[
+        AllowedModelRegion
+    ] = None  # require all user requests to use models in this specific region
+    default_model: Optional[
+        str
+    ] = None  # if no equivalent model in allowed region - default all requests to this model
 
 
 class DeleteCustomerRequest(LiteLLMPydanticObjectBase):
@@ -1490,15 +1490,15 @@ class NewTeamRequest(TeamBase):
     ] = None  # raise an error if 'guaranteed_throughput' is set and we're overallocating tpm
 
     model_tpm_limit: Optional[Dict[str, int]] = None
-    team_member_budget: Optional[float] = (
-        None  # allow user to set a budget for all team members
-    )
-    team_member_rpm_limit: Optional[int] = (
-        None  # allow user to set RPM limit for all team members
-    )
-    team_member_tpm_limit: Optional[int] = (
-        None  # allow user to set TPM limit for all team members
-    )
+    team_member_budget: Optional[
+        float
+    ] = None  # allow user to set a budget for all team members
+    team_member_rpm_limit: Optional[
+        int
+    ] = None  # allow user to set RPM limit for all team members
+    team_member_tpm_limit: Optional[
+        int
+    ] = None  # allow user to set TPM limit for all team members
     team_member_key_duration: Optional[str] = None  # e.g. "1d", "1w", "1m"
     allowed_vector_store_indexes: Optional[List[AllowedVectorStoreIndexItem]] = None
 
@@ -1586,9 +1586,9 @@ class BlockKeyRequest(LiteLLMPydanticObjectBase):
 
 class AddTeamCallback(LiteLLMPydanticObjectBase):
     callback_name: str
-    callback_type: Optional[Literal["success", "failure", "success_and_failure"]] = (
-        "success_and_failure"
-    )
+    callback_type: Optional[
+        Literal["success", "failure", "success_and_failure"]
+    ] = "success_and_failure"
     callback_vars: Dict[str, str]
 
     @model_validator(mode="before")
@@ -1916,9 +1916,9 @@ class ConfigList(LiteLLMPydanticObjectBase):
     stored_in_db: Optional[bool]
     field_default_value: Any
     premium_field: bool = False
-    nested_fields: Optional[List[FieldDetail]] = (
-        None  # For nested dictionary or Pydantic fields
-    )
+    nested_fields: Optional[
+        List[FieldDetail]
+    ] = None  # For nested dictionary or Pydantic fields
 
 
 class UserHeaderMapping(LiteLLMPydanticObjectBase):
@@ -2127,7 +2127,9 @@ class LiteLLM_VerificationToken(LiteLLMPydanticObjectBase):
     rotation_interval: Optional[str] = None  # How often to rotate (e.g., "30d", "90d")
     last_rotation_at: Optional[datetime] = None  # When this key was last rotated
     key_rotation_at: Optional[datetime] = None  # When this key should next be rotated
-    router_settings: Optional[Dict] = None  # Router settings for this key (Key > Team > Global precedence)
+    router_settings: Optional[
+        Dict
+    ] = None  # Router settings for this key (Key > Team > Global precedence)
 
     model_config = ConfigDict(protected_namespaces=())
 
@@ -2332,9 +2334,9 @@ class LiteLLM_OrganizationMembershipTable(LiteLLMPydanticObjectBase):
     budget_id: Optional[str] = None
     created_at: datetime
     updated_at: datetime
-    user: Optional[Any] = (
-        None  # You might want to replace 'Any' with a more specific type if available
-    )
+    user: Optional[
+        Any
+    ] = None  # You might want to replace 'Any' with a more specific type if available
     litellm_budget_table: Optional[LiteLLM_BudgetTable] = None
 
     model_config = ConfigDict(protected_namespaces=())
@@ -3306,9 +3308,9 @@ class TeamModelDeleteRequest(BaseModel):
 # Organization Member Requests
 class OrganizationMemberAddRequest(OrgMemberAddRequest):
     organization_id: str
-    max_budget_in_organization: Optional[float] = (
-        None  # Users max budget within the organization
-    )
+    max_budget_in_organization: Optional[
+        float
+    ] = None  # Users max budget within the organization
 
 
 class OrganizationMemberDeleteRequest(MemberDeleteRequest):
@@ -3523,9 +3525,9 @@ class ProviderBudgetResponse(LiteLLMPydanticObjectBase):
     Maps provider names to their budget configs.
     """
 
-    providers: Dict[str, ProviderBudgetResponseObject] = (
-        {}
-    )  # Dictionary mapping provider names to their budget configurations
+    providers: Dict[
+        str, ProviderBudgetResponseObject
+    ] = {}  # Dictionary mapping provider names to their budget configurations
 
 
 class ProxyStateVariables(TypedDict):
@@ -3668,9 +3670,9 @@ class LiteLLM_JWTAuth(LiteLLMPydanticObjectBase):
     enforce_rbac: bool = False
     roles_jwt_field: Optional[str] = None  # v2 on role mappings
     role_mappings: Optional[List[RoleMapping]] = None
-    object_id_jwt_field: Optional[str] = (
-        None  # can be either user / team, inferred from the role mapping
-    )
+    object_id_jwt_field: Optional[
+        str
+    ] = None  # can be either user / team, inferred from the role mapping
     scope_mappings: Optional[List[ScopeMapping]] = None
     enforce_scope_based_access: bool = False
     enforce_team_based_model_access: bool = False
diff --git a/litellm/proxy/auth/auth_utils.py b/litellm/proxy/auth/auth_utils.py
index 1a7f05716b3..9b9a988c07a 100644
--- a/litellm/proxy/auth/auth_utils.py
+++ b/litellm/proxy/auth/auth_utils.py
@@ -311,6 +311,88 @@ def get_request_route(request: Request) -> str:
         return request.url.path
 
 
+def normalize_request_route(route: str) -> str:
+    """
+    Normalize request routes by replacing dynamic path parameters with placeholders.
+    
+    This prevents high cardinality in Prometheus metrics by collapsing routes like:
+    - /v1/responses/1234567890 -> /v1/responses/{response_id}
+    - /v1/threads/thread_123 -> /v1/threads/{thread_id}
+    
+    Args:
+        route: The request route path
+        
+    Returns:
+        Normalized route with dynamic parameters replaced by placeholders
+        
+    Examples:
+        >>> normalize_request_route("/v1/responses/abc123")
+        '/v1/responses/{response_id}'
+        >>> normalize_request_route("/v1/responses/abc123/cancel")
+        '/v1/responses/{response_id}/cancel'
+        >>> normalize_request_route("/chat/completions")
+        '/chat/completions'
+    """
+    # Define patterns for routes with dynamic IDs
+    # Format: (regex_pattern, replacement_template)
+    patterns = [
+        # Responses API - must come before generic patterns
+        (r'^(/(?:openai/)?v1/responses)/([^/]+)(/input_items)$', r'\1/{response_id}\3'),
+        (r'^(/(?:openai/)?v1/responses)/([^/]+)(/cancel)$', r'\1/{response_id}\3'),
+        (r'^(/(?:openai/)?v1/responses)/([^/]+)$', r'\1/{response_id}'),
+        (r'^(/responses)/([^/]+)(/input_items)$', r'\1/{response_id}\3'),
+        (r'^(/responses)/([^/]+)(/cancel)$', r'\1/{response_id}\3'),
+        (r'^(/responses)/([^/]+)$', r'\1/{response_id}'),
+        
+        # Threads API
+        (r'^(/(?:openai/)?v1/threads)/([^/]+)(/runs)/([^/]+)(/steps)/([^/]+)$', r'\1/{thread_id}\3/{run_id}\5/{step_id}'),
+        (r'^(/(?:openai/)?v1/threads)/([^/]+)(/runs)/([^/]+)(/steps)$', r'\1/{thread_id}\3/{run_id}\5'),
+        (r'^(/(?:openai/)?v1/threads)/([^/]+)(/runs)/([^/]+)(/cancel)$', r'\1/{thread_id}\3/{run_id}\5'),
+        (r'^(/(?:openai/)?v1/threads)/([^/]+)(/runs)/([^/]+)(/submit_tool_outputs)$', r'\1/{thread_id}\3/{run_id}\5'),
+        (r'^(/(?:openai/)?v1/threads)/([^/]+)(/runs)/([^/]+)$', r'\1/{thread_id}\3/{run_id}'),
+        (r'^(/(?:openai/)?v1/threads)/([^/]+)(/runs)$', r'\1/{thread_id}\3'),
+        (r'^(/(?:openai/)?v1/threads)/([^/]+)(/messages)/([^/]+)$', r'\1/{thread_id}\3/{message_id}'),
+        (r'^(/(?:openai/)?v1/threads)/([^/]+)(/messages)$', r'\1/{thread_id}\3'),
+        (r'^(/(?:openai/)?v1/threads)/([^/]+)$', r'\1/{thread_id}'),
+        
+        # Vector Stores API
+        (r'^(/(?:openai/)?v1/vector_stores)/([^/]+)(/files)/([^/]+)$', r'\1/{vector_store_id}\3/{file_id}'),
+        (r'^(/(?:openai/)?v1/vector_stores)/([^/]+)(/files)$', r'\1/{vector_store_id}\3'),
+        (r'^(/(?:openai/)?v1/vector_stores)/([^/]+)(/file_batches)/([^/]+)$', r'\1/{vector_store_id}\3/{batch_id}'),
+        (r'^(/(?:openai/)?v1/vector_stores)/([^/]+)(/file_batches)$', r'\1/{vector_store_id}\3'),
+        (r'^(/(?:openai/)?v1/vector_stores)/([^/]+)$', r'\1/{vector_store_id}'),
+        
+        # Assistants API
+        (r'^(/(?:openai/)?v1/assistants)/([^/]+)$', r'\1/{assistant_id}'),
+        
+        # Files API
+        (r'^(/(?:openai/)?v1/files)/([^/]+)(/content)$', r'\1/{file_id}\3'),
+        (r'^(/(?:openai/)?v1/files)/([^/]+)$', r'\1/{file_id}'),
+        
+        # Batches API
+        (r'^(/(?:openai/)?v1/batches)/([^/]+)(/cancel)$', r'\1/{batch_id}\3'),
+        (r'^(/(?:openai/)?v1/batches)/([^/]+)$', r'\1/{batch_id}'),
+        
+        # Fine-tuning API
+        (r'^(/(?:openai/)?v1/fine_tuning/jobs)/([^/]+)(/events)$', r'\1/{fine_tuning_job_id}\3'),
+        (r'^(/(?:openai/)?v1/fine_tuning/jobs)/([^/]+)(/cancel)$', r'\1/{fine_tuning_job_id}\3'),
+        (r'^(/(?:openai/)?v1/fine_tuning/jobs)/([^/]+)(/checkpoints)$', r'\1/{fine_tuning_job_id}\3'),
+        (r'^(/(?:openai/)?v1/fine_tuning/jobs)/([^/]+)$', r'\1/{fine_tuning_job_id}'),
+        
+        # Models API
+        (r'^(/(?:openai/)?v1/models)/([^/]+)$', r'\1/{model}'),
+    ]
+    
+    # Apply patterns in order
+    for pattern, replacement in patterns:
+        normalized = re.sub(pattern, replacement, route)
+        if normalized != route:
+            return normalized
+    
+    # Return original route if no pattern matched
+    return route
+
+
 async def check_if_request_size_is_safe(request: Request) -> bool:
     """
     Enterprise Only:
diff --git a/litellm/proxy/auth/user_api_key_auth.py b/litellm/proxy/auth/user_api_key_auth.py
index bc0c164a0ad..7e7c7c8c90c 100644
--- a/litellm/proxy/auth/user_api_key_auth.py
+++ b/litellm/proxy/auth/user_api_key_auth.py
@@ -28,8 +28,8 @@ from litellm.proxy.auth.auth_checks import (
     _delete_cache_key_object,
     _get_user_role,
     _is_user_proxy_admin,
-    _virtual_key_max_budget_check,
     _virtual_key_max_budget_alert_check,
+    _virtual_key_max_budget_check,
     _virtual_key_soft_budget_check,
     can_key_call_model,
     common_checks,
@@ -45,6 +45,7 @@ from litellm.proxy.auth.auth_utils import (
     get_end_user_id_from_request_body,
     get_model_from_request,
     get_request_route,
+    normalize_request_route,
     pre_db_read_auth_checks,
     route_in_additonal_public_routes,
 )
@@ -1261,7 +1262,7 @@ async def user_api_key_auth(
     if end_user_id is not None:
         user_api_key_auth_obj.end_user_id = end_user_id
 
-    user_api_key_auth_obj.request_route = route
+    user_api_key_auth_obj.request_route = normalize_request_route(route)
 
     return user_api_key_auth_obj
 
diff --git a/litellm/proxy/guardrails/guardrail_hooks/bedrock_guardrails.py b/litellm/proxy/guardrails/guardrail_hooks/bedrock_guardrails.py
index 59032189438..d3e8a74945f 100644
--- a/litellm/proxy/guardrails/guardrail_hooks/bedrock_guardrails.py
+++ b/litellm/proxy/guardrails/guardrail_hooks/bedrock_guardrails.py
@@ -893,15 +893,53 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
                 return
 
         #########################################################
-        ########## 1. Make parallel Bedrock API requests ##########
+        ########## 1. Make Bedrock API requests ##########
         #########################################################
+        # Import asyncio for parallel execution
+        import asyncio
+
+        # Determine if INPUT validation is needed in post_call
+        # Skip INPUT validation if pre_call or during_call is already enabled
+        # (to avoid redundant validation - those hooks would have already validated INPUT)
+        should_validate_input = not (
+            self._event_hook_is_event_type(GuardrailEventHooks.pre_call)
+            or self._event_hook_is_event_type(GuardrailEventHooks.during_call)
+        )
+
         output_content_bedrock: Optional[Union[BedrockGuardrailResponse, str]] = None
-        try:
-            output_content_bedrock = await self.make_bedrock_api_request(
+
+        if should_validate_input:
+            # Prepare input messages (with optional filtering for latest role message)
+            input_filter = self._prepare_guardrail_messages_for_role(
+                messages=new_messages
+            )
+            input_messages = input_filter.payload_messages or new_messages
+
+            # Create tasks for parallel execution of both INPUT and OUTPUT validation
+            input_task = self.make_bedrock_api_request(
+                source="INPUT",
+                messages=input_messages,
+                request_data=data,
+            )
+            output_task = self.make_bedrock_api_request(
                 source="OUTPUT", response=response, request_data=data
             )
-        except GuardrailInterventionNormalStringError as e:
-            output_content_bedrock = e.message
+
+            # Execute both requests in parallel
+            try:
+                _, output_content_bedrock = await asyncio.gather(
+                    input_task, output_task
+                )
+            except GuardrailInterventionNormalStringError as e:
+                output_content_bedrock = e.message
+        else:
+            # Only run OUTPUT validation (INPUT was already validated in pre_call or during_call)
+            try:
+                output_content_bedrock = await self.make_bedrock_api_request(
+                    source="OUTPUT", response=response, request_data=data
+                )
+            except GuardrailInterventionNormalStringError as e:
+                output_content_bedrock = e.message
 
         #########################################################
         ########## 2. Apply masking to response with output guardrail response ##########
@@ -910,7 +948,7 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
             response = self.create_guardrail_blocked_response(
                 response=output_content_bedrock
             )
-        else:
+        elif output_content_bedrock is not None:
             self._apply_masking_to_response(
                 response=response,
                 bedrock_guardrail_response=output_content_bedrock,
@@ -997,36 +1035,54 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
         )
         if isinstance(assembled_model_response, ModelResponse):
             ####################################################################
-            ########## 1. Make parallel Bedrock Apply Guardrail API requests ##########
+            ########## 1. Make Bedrock Apply Guardrail API requests ##########
 
             # Bedrock will raise an exception if this violates the guardrail policy
             ###################################################################
-            # Create tasks for parallel execution
-            input_filter = self._prepare_guardrail_messages_for_role(
-                messages=request_data.get("messages")
+            # Determine if INPUT validation is needed in post_call
+            # Skip INPUT validation if pre_call or during_call is already enabled
+            # (to avoid redundant validation - those hooks would have already validated INPUT)
+            should_validate_input = not (
+                self._event_hook_is_event_type(GuardrailEventHooks.pre_call)
+                or self._event_hook_is_event_type(GuardrailEventHooks.during_call)
             )
-            input_messages = input_filter.payload_messages or request_data.get(
-                "messages"
-            )
-            input_task = self.make_bedrock_api_request(
-                source="INPUT",
-                messages=input_messages,
-                request_data=request_data,
-            )  # Only input messages
+
             output_guardrail_response: Optional[
                 Union[BedrockGuardrailResponse, str]
             ] = None
-            output_task = self.make_bedrock_api_request(
-                source="OUTPUT", response=assembled_model_response
-            )  # Only response
 
-            # Execute both requests in parallel
-            try:
-                _, output_guardrail_response = await asyncio.gather(
-                    input_task, output_task
+            if should_validate_input:
+                # Create tasks for parallel execution
+                input_filter = self._prepare_guardrail_messages_for_role(
+                    messages=request_data.get("messages")
                 )
-            except GuardrailInterventionNormalStringError as e:
-                output_guardrail_response = e.message
+                input_messages = input_filter.payload_messages or request_data.get(
+                    "messages"
+                )
+                input_task = self.make_bedrock_api_request(
+                    source="INPUT",
+                    messages=input_messages,
+                    request_data=request_data,
+                )  # Only input messages
+                output_task = self.make_bedrock_api_request(
+                    source="OUTPUT", response=assembled_model_response
+                )  # Only response
+
+                # Execute both requests in parallel
+                try:
+                    _, output_guardrail_response = await asyncio.gather(
+                        input_task, output_task
+                    )
+                except GuardrailInterventionNormalStringError as e:
+                    output_guardrail_response = e.message
+            else:
+                # Only run OUTPUT validation (INPUT was already validated in pre_call or during_call)
+                try:
+                    output_guardrail_response = await self.make_bedrock_api_request(
+                        source="OUTPUT", response=assembled_model_response
+                    )
+                except GuardrailInterventionNormalStringError as e:
+                    output_guardrail_response = e.message
 
             #########################################################################
             ########## 2. Apply masking to response with output guardrail response ##########
diff --git a/litellm/proxy/proxy_config.yaml b/litellm/proxy/proxy_config.yaml
index 646a062b720..958ddbf613c 100644
--- a/litellm/proxy/proxy_config.yaml
+++ b/litellm/proxy/proxy_config.yaml
@@ -1,51 +1,27 @@
 model_list:
-  - model_name: gemini/*
+  # Anthropic direct
+  - model_name: anthropic-claude
     litellm_params:
-      model: gemini/*
-  - model_name: -claude-sonnet-4-5-20250929
-    litellm_params:
-      model: bedrock/invoke/us.anthropic.claude-sonnet-4-5-20250929-v1:0
-    model_info:
-      cache_creation_input_token_cost: 3.75e-06
-      cache_read_input_token_cost: 3e-07
-      input_cost_per_token: 3e-06
-      input_cost_per_token_above_200k_tokens: 6e-06
-      output_cost_per_token_above_200k_tokens: 2.25e-05
-      cache_creation_input_token_cost_above_200k_tokens: 7.5e-06
-      cache_read_input_token_cost_above_200k_tokens: 6e-07
-      litellm_provider: bedrock_converse
-      max_input_tokens: 200000
-      max_output_tokens: 64000
-      max_tokens: 200000
-      mode: chat
-      output_cost_per_token: 1.5e-05
-      search_context_cost_per_query:
-        search_context_size_high: 0.01
-        search_context_size_low: 0.01
-        search_context_size_medium: 0.01
-      supports_assistant_prefill: true
-      supports_computer_use: true
-      supports_function_calling: true
-      supports_pdf_input: true
-      supports_prompt_caching: true
-      supports_reasoning: true
-      supports_response_schema: true
-      supports_tool_choice: true
-      supports_vision: true
-      tool_use_system_prompt_tokens: 346
+      model: anthropic/claude-sonnet-4-20250514
+      api_key: os.environ/ANTHROPIC_API_KEY
 
-  - model_name: us.anthropic.claude-sonnet-4-20250514-v1:0
+  # Azure AI Anthropic
+  - model_name: azure-ai-claude
     litellm_params:
-      model: bedrock/converse/us.anthropic.claude-sonnet-4-20250514-v1:0
-    model_info:
-      litellm_provider: bedrock_converse
-      mode: chat
-  - model_name: claude-sonnet-4-5-20250929
-    litellm_params:
-      model: azure_ai/claude-opus-4-5
-      api_base: https://krish-mh44t553-eastus2.services.ai.azure.com
+      model: azure_ai/claude-3-5-sonnet
+      api_base: https://krish-mh44t553-eastus2.services.ai.azure.com/
       api_key: os.environ/AZURE_ANTHROPIC_API_KEY
 
+  # Azure AI Anthropic (alternate endpoint format)
+  - model_name: claude-4.5-haiku
+    litellm_params:
+      model: anthropic/claude-haiku-4-5
+      api_base: https://krish-mh44t553-eastus2.services.ai.azure.com/anthropic/v1/messages
+      api_version: "2023-06-01"
+      api_key: os.environ/AZURE_ANTHROPIC_API_KEY
+
+
+
 # Search Tools Configuration - Define search providers for WebSearch interception
 # search_tools:
 #   - search_tool_name: "my-perplexity-search"
diff --git a/litellm/proxy/utils.py b/litellm/proxy/utils.py
index 9ea2ea7d5c9..e0855333e26 100644
--- a/litellm/proxy/utils.py
+++ b/litellm/proxy/utils.py
@@ -131,7 +131,6 @@ else:
 
 unified_guardrail = UnifiedLLMGuardrails()
 
-_anthropic_async_clients = {}
 
 def print_verbose(print_statement):
     """
@@ -961,8 +960,8 @@ class ProxyLogging:
         Returns:
             Updated data dictionary if guardrail passes, None if guardrail should be skipped
         """
-        from litellm.types.guardrails import GuardrailEventHooks
         from litellm.integrations.prometheus import PrometheusLogger
+        from litellm.types.guardrails import GuardrailEventHooks
 
         # Determine the event type based on call type
         event_type = GuardrailEventHooks.pre_call
@@ -2214,6 +2213,45 @@ class PrismaClient:
 
             raise e
 
+    async def _query_first_with_cached_plan_fallback(
+        self, sql_query: str
+    ) -> Optional[dict]:
+        """
+        Execute a query with automatic fallback for PostgreSQL cached plan errors.
+        
+        This handles the "cached plan must not change result type" error that occurs
+        during rolling deployments when schema changes are applied while old pods
+        still have cached query plans expecting the old schema.
+        
+        Args:
+            sql_query: SQL query string to execute
+            
+        Returns:
+            Query result or None
+            
+        Raises:
+            Original exception if not a cached plan error
+        """
+        try:
+            return await self.db.query_first(query=sql_query)
+        except Exception as e:
+            error_str = str(e)
+            if "cached plan must not change result type" in error_str:
+                # Force PostgreSQL to re-plan by invalidating the cache
+                # Add a unique comment to make the query different
+                sql_query_retry = sql_query.replace(
+                    "SELECT",
+                    f"SELECT /* cache_invalidated_{int(time.time() * 1000)} */"
+                )
+                verbose_proxy_logger.warning(
+                    "PostgreSQL cached plan error detected for token lookup, "
+                    "retrying with fresh plan. This may occur during rolling deployments "
+                    "when schema changes are applied."
+                )
+                return await self.db.query_first(query=sql_query_retry)
+            else:
+                raise
+
     @backoff.on_exception(
         backoff.expo,
         Exception,  # base exception to catch for the backoff
@@ -2545,7 +2583,7 @@ class PrismaClient:
                         WHERE v.token = '{token}'
                     """
 
-                    response = await self.db.query_first(query=sql_query)
+                    response = await self._query_first_with_cached_plan_fallback(sql_query)
 
                     if response is not None:
                         if response["team_models"] is None:
@@ -4253,74 +4291,6 @@ def construct_database_url_from_env_vars() -> Optional[str]:
     return None
 
 
-async def count_tokens_with_anthropic_api(
-    model_to_use: str,
-    messages: Optional[List[Dict[str, Any]]],
-    deployment: Optional[Dict[str, Any]] = None,
-) -> Optional[Dict[str, Any]]:
-    """
-    Helper function to count tokens using Anthropic API directly.
-
-    Args:
-        model_to_use: The model name to use for token counting
-        messages: The messages to count tokens for
-        deployment: Optional deployment configuration containing API key
-
-    Returns:
-        Optional dict with token count and tokenizer info, or None if failed
-    """
-    if not messages:
-        return None
-
-    try:
-        import os
-
-        import anthropic
-
-        # Get Anthropic API key from deployment config
-        anthropic_api_key = None
-        if deployment is not None:
-            anthropic_api_key = deployment.get("litellm_params", {}).get("api_key")
-
-        # Fallback to environment variable
-        if not anthropic_api_key:
-            anthropic_api_key = os.getenv("ANTHROPIC_API_KEY")
-
-        if anthropic_api_key and messages:
-            # Call Anthropic API directly for more accurate token counting
-            
-            # Use cached client if available to avoid socket exhaustion
-            if anthropic_api_key not in _anthropic_async_clients:
-                _anthropic_async_clients[anthropic_api_key] = anthropic.AsyncAnthropic(api_key=anthropic_api_key)
-            
-            client = _anthropic_async_clients[anthropic_api_key]
-
-            # Call with explicit parameters to satisfy type checking
-            # Type ignore for now since messages come from generic dict input
-            response = await client.beta.messages.count_tokens(
-                model=model_to_use,
-                messages=messages,  # type: ignore
-                betas=["token-counting-2024-11-01"],
-            )
-            total_tokens = response.input_tokens
-            tokenizer_used = "anthropic_api"
-
-            return {
-                "total_tokens": total_tokens,
-                "tokenizer_used": tokenizer_used,
-            }
-
-    except ImportError:
-        verbose_proxy_logger.warning(
-            "Anthropic library not available, falling back to LiteLLM tokenizer"
-        )
-    except Exception as e:
-        verbose_proxy_logger.warning(
-            f"Error calling Anthropic API: {e}, falling back to LiteLLM tokenizer"
-        )
-    return None
-
-
 async def get_available_models_for_user(
     user_api_key_dict: "UserAPIKeyAuth",
     llm_router: Optional["Router"],
diff --git a/litellm/responses/litellm_completion_transformation/streaming_iterator.py b/litellm/responses/litellm_completion_transformation/streaming_iterator.py
index dd7936059a0..b128452d9a4 100644
--- a/litellm/responses/litellm_completion_transformation/streaming_iterator.py
+++ b/litellm/responses/litellm_completion_transformation/streaming_iterator.py
@@ -81,6 +81,8 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
             Union[ModelResponse, TextCompletionResponse]
         ] = None
         self.final_text: str = ""
+        self._cached_item_id: Optional[str] = None
+        self._cached_response_id: Optional[str] = None
         self._pending_tool_events: List[BaseLiteLLMOpenAIResponseObject] = []
         self._tool_output_index_by_call_id: dict[str, int] = {}
         self._tool_args_by_call_id: dict[str, str] = {}
@@ -307,12 +309,15 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
         )
 
     def create_output_item_added_event(self) -> OutputItemAddedEvent:
+        if self._cached_item_id is None:
+            self._cached_item_id = f"msg_{str(uuid.uuid4())}"
+        
         return OutputItemAddedEvent(
             type=ResponsesAPIStreamEvents.OUTPUT_ITEM_ADDED,
             output_index=0,
             item=BaseLiteLLMOpenAIResponseObject(
                 **{
-                    "id": f"msg_{str(uuid.uuid4())}",
+                    "id": self._cached_item_id,
                     "type": "message",
                     "status": "in_progress",
                     "role": "assistant",
@@ -322,9 +327,12 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
         )
 
     def create_content_part_added_event(self) -> ContentPartAddedEvent:
+        if self._cached_item_id is None:
+            self._cached_item_id = f"msg_{str(uuid.uuid4())}"
+        
         return ContentPartAddedEvent(
             type=ResponsesAPIStreamEvents.CONTENT_PART_ADDED,
-            item_id=f"msg_{str(uuid.uuid4())}",
+            item_id=self._cached_item_id,
             output_index=0,
             content_index=0,
             part=BaseLiteLLMOpenAIResponseObject(
@@ -346,9 +354,12 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
     def create_output_text_done_event(
         self, litellm_complete_object: ModelResponse
     ) -> OutputTextDoneEvent:
+        if self._cached_item_id is None:
+            self._cached_item_id = f"msg_{str(uuid.uuid4())}"
+        
         return OutputTextDoneEvent(
             type=ResponsesAPIStreamEvents.OUTPUT_TEXT_DONE,
-            item_id=f"msg_{str(uuid.uuid4())}",
+            item_id=self._cached_item_id,
             output_index=0,
             content_index=0,
             text=getattr(litellm_complete_object.choices[0].message, "content", "")  # type: ignore
@@ -358,6 +369,8 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
     def create_output_content_part_done_event(
         self, litellm_complete_object: ModelResponse
     ) -> ContentPartDoneEvent:
+        if self._cached_item_id is None:
+            self._cached_item_id = f"msg_{str(uuid.uuid4())}"
 
         text = getattr(litellm_complete_object.choices[0].message, "content", "") or ""  # type: ignore
         reasoning_content = getattr(litellm_complete_object.choices[0].message, "reasoning_content", "") or ""  # type: ignore
@@ -383,7 +396,7 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
 
         return ContentPartDoneEvent(
             type=ResponsesAPIStreamEvents.CONTENT_PART_DONE,
-            item_id=f"msg_{str(uuid.uuid4())}",
+            item_id=self._cached_item_id,
             output_index=0,
             content_index=0,
             part=part,
@@ -392,6 +405,9 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
     def create_output_item_done_event(
         self, litellm_complete_object: ModelResponse
     ) -> OutputItemDoneEvent:
+        if self._cached_item_id is None:
+            self._cached_item_id = f"msg_{str(uuid.uuid4())}"
+        
         text = self.litellm_model_response.choices[0].message.content or ""  # type: ignore
         annotations = getattr(self.litellm_model_response.choices[0].message, "annotations", None)  # type: ignore
 
@@ -404,7 +420,7 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
             sequence_number=1,
             item=BaseLiteLLMOpenAIResponseObject(
                 **{
-                    "id": f"msg_{str(uuid.uuid4())}",
+                    "id": self._cached_item_id,
                     "status": "completed",
                     "type": "message",
                     "role": "assistant",
@@ -576,6 +592,10 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
         and the ReasoningSummaryTextDeltaEvent, which is used by the responses API to emit reasoning content.
         It also handles emitting annotation.added events when annotations are detected in the chunk.
         """
+        if self._cached_item_id is None and chunk.id:
+            self._cached_item_id = chunk.id
+        item_id = self._cached_item_id or chunk.id
+        
         # Check if this chunk has annotations first (before processing text/reasoning)
         # This ensures we detect and queue annotation events from the annotation chunk
         if chunk.choices and hasattr(chunk.choices[0].delta, "annotations"):
@@ -593,7 +613,7 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
                         annotation_dict = annotation.model_dump() if hasattr(annotation, 'model_dump') else dict(annotation)
                         event = OutputTextAnnotationAddedEvent(
                             type=ResponsesAPIStreamEvents.OUTPUT_TEXT_ANNOTATION_ADDED,
-                            item_id=chunk.id,
+                            item_id=item_id,
                             output_index=0,
                             content_index=0,
                             annotation_index=idx,
@@ -620,7 +640,7 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
         if delta_content:
             return OutputTextDeltaEvent(
                 type=ResponsesAPIStreamEvents.OUTPUT_TEXT_DELTA,
-                item_id=chunk.id,
+                item_id=item_id,
                 output_index=0,
                 content_index=0,
                 delta=delta_content,
diff --git a/litellm/router.py b/litellm/router.py
index 0b07d5ed8c1..3e312c154b4 100644
--- a/litellm/router.py
+++ b/litellm/router.py
@@ -4681,26 +4681,35 @@ class Router:
                 parent_otel_span=parent_otel_span,
             )
 
-            # raises an exception if this error should not be retries
-            self.should_retry_this_error(
-                error=e,
-                healthy_deployments=_healthy_deployments,
-                all_deployments=_all_deployments,
-                context_window_fallbacks=context_window_fallbacks,
-                regular_fallbacks=fallbacks,
-                content_policy_fallbacks=content_policy_fallbacks,
-            )
-
+            # Check retry policy FIRST, before should_retry_this_error
+            # This allows retry policies to override the healthy deployments check
+            _retry_policy_applies = False
             if (
                 self.retry_policy is not None
                 or self.model_group_retry_policy is not None
             ):
                 # get num_retries from retry policy
+                # Use the model_group captured at the start of the function, or get it from metadata
+                # kwargs.get("model") at this point is the deployment model, not the model_group
+                _model_group_for_retry_policy = model_group or _metadata.get("model_group") or kwargs.get("model")
                 _retry_policy_retries = self.get_num_retries_from_retry_policy(
-                    exception=original_exception, model_group=kwargs.get("model")
+                    exception=original_exception, model_group=_model_group_for_retry_policy
                 )
                 if _retry_policy_retries is not None:
                     num_retries = _retry_policy_retries
+                    _retry_policy_applies = True
+
+            # raises an exception if this error should not be retries
+            # Skip this check if retry policy applies (retry policy takes precedence)
+            if not _retry_policy_applies:
+                self.should_retry_this_error(
+                    error=e,
+                    healthy_deployments=_healthy_deployments,
+                    all_deployments=_all_deployments,
+                    context_window_fallbacks=context_window_fallbacks,
+                    regular_fallbacks=fallbacks,
+                    content_policy_fallbacks=content_policy_fallbacks,
+                )
             ## LOGGING
             if num_retries > 0:
                 kwargs = self.log_retry(kwargs=kwargs, e=original_exception)
@@ -4865,6 +4874,12 @@ class Router:
         ):
             raise error
 
+        status_code = getattr(error, "status_code", None)
+        if status_code is not None and not litellm._should_retry(status_code):
+            # 401/403 are special cases - allow retry if multiple deployments exist (handled below)
+            if status_code not in (401, 403):
+                raise error
+
         if isinstance(error, litellm.NotFoundError):
             raise error
         # Error we should only retry if there are other deployments
diff --git a/litellm/types/llms/anthropic.py b/litellm/types/llms/anthropic.py
index 779a6950d92..0e687be660f 100644
--- a/litellm/types/llms/anthropic.py
+++ b/litellm/types/llms/anthropic.py
@@ -642,4 +642,8 @@ ANTHROPIC_TOOL_SEARCH_BETA_HEADER = "advanced-tool-use-2025-11-20"
 # Effort beta header constant
 ANTHROPIC_EFFORT_BETA_HEADER = "effort-2025-11-24"
 
+# OAuth constants
+ANTHROPIC_OAUTH_TOKEN_PREFIX = "sk-ant-oat"
+ANTHROPIC_OAUTH_BETA_HEADER = "oauth-2025-04-20"
+
 
diff --git a/litellm/types/llms/vertex_ai.py b/litellm/types/llms/vertex_ai.py
index 74d6339887b..0a4a2d0f14c 100644
--- a/litellm/types/llms/vertex_ai.py
+++ b/litellm/types/llms/vertex_ai.py
@@ -207,6 +207,7 @@ class GenerationConfig(TypedDict, total=False):
     frequency_penalty: float
     response_mime_type: Literal["text/plain", "application/json"]
     response_schema: dict
+    response_json_schema: dict
     seed: int
     responseLogprobs: bool
     logprobs: int
diff --git a/litellm/types/utils.py b/litellm/types/utils.py
index 8c30e4d7e80..f5e217d8b46 100644
--- a/litellm/types/utils.py
+++ b/litellm/types/utils.py
@@ -63,6 +63,19 @@ def _generate_id():  # private helper function
     return "chatcmpl-" + str(uuid.uuid4())
 
 
+
+class SafeAttributeModel:
+    """
+    A base model that provides safe attribute access.
+    """
+    def __delattr__(self, name):
+        try:
+            super().__delattr__(name)
+        except AttributeError:
+            # noop if attribute does not exist
+            pass
+
+
 class LiteLLMCommonStrings(Enum):
     redacted_by_litellm = "redacted by litellm. 'litellm.turn_off_message_logging=True'"
     llm_provider_not_provided = "Unmapped LLM provider for this endpoint. You passed model={model}, custom_llm_provider={custom_llm_provider}. Check supported provider and route: https://docs.litellm.ai/docs/providers"
@@ -1020,7 +1033,7 @@ def add_provider_specific_fields(
     setattr(object, "provider_specific_fields", provider_specific_fields)
 
 
-class Message(OpenAIObject):
+class Message(SafeAttributeModel, OpenAIObject):
     content: Optional[str]
     role: Literal["assistant", "user", "system", "tool", "function"]
     tool_calls: Optional[List[ChatCompletionMessageToolCall]]
@@ -1140,7 +1153,7 @@ class Message(OpenAIObject):
             return self.dict()
 
 
-class Delta(OpenAIObject):
+class Delta(SafeAttributeModel, OpenAIObject):
     reasoning_content: Optional[str] = None
     thinking_blocks: Optional[
         List[Union[ChatCompletionThinkingBlock, ChatCompletionRedactedThinkingBlock]]
@@ -1237,7 +1250,7 @@ class Delta(OpenAIObject):
         setattr(self, key, value)
 
 
-class Choices(OpenAIObject):
+class Choices(SafeAttributeModel, OpenAIObject):
     finish_reason: str
     index: int
     message: Message
@@ -1330,6 +1343,7 @@ class CacheCreationTokenDetails(BaseModel):
 
 
 class PromptTokensDetailsWrapper(
+    SafeAttributeModel,
     PromptTokensDetails
 ):  # extends with image generation fields (text_tokens, image_tokens)
     text_tokens: Optional[int] = None
@@ -1377,7 +1391,7 @@ class ServerToolUse(BaseModel):
     tool_search_requests: Optional[int] = None
 
 
-class Usage(CompletionUsage):
+class Usage(SafeAttributeModel, CompletionUsage):
     _cache_creation_input_tokens: int = PrivateAttr(
         0
     )  # hidden param for prompt caching. Might change, once openai introduces their equivalent.
@@ -2958,6 +2972,7 @@ GenericBudgetConfigType = Dict[str, BudgetConfig]
 
 class LlmProviders(str, Enum):
     OPENAI = "openai"
+    CHATGPT = "chatgpt"
     OPENAI_LIKE = "openai_like"  # embedding only
     JINA_AI = "jina_ai"
     XAI = "xai"
diff --git a/litellm/utils.py b/litellm/utils.py
index 45090a78e2f..06eceefe0cc 100644
--- a/litellm/utils.py
+++ b/litellm/utils.py
@@ -87,6 +87,7 @@ def _get_cached_custom_logger():
     global _CustomLogger
     if _CustomLogger is None:
         from litellm.integrations.custom_logger import CustomLogger
+
         _CustomLogger = CustomLogger
     return _CustomLogger
 
@@ -100,6 +101,7 @@ def _get_cached_custom_guardrail():
     global _CustomGuardrail
     if _CustomGuardrail is None:
         from litellm.integrations.custom_guardrail import CustomGuardrail
+
         _CustomGuardrail = CustomGuardrail
     return _CustomGuardrail
 
@@ -113,6 +115,7 @@ def _get_cached_caching_handler_response():
     global _CachingHandlerResponse
     if _CachingHandlerResponse is None:
         from litellm.caching.caching_handler import CachingHandlerResponse
+
         _CachingHandlerResponse = CachingHandlerResponse
     return _CachingHandlerResponse
 
@@ -126,6 +129,7 @@ def _get_cached_llm_caching_handler():
     global _LLMCachingHandler
     if _LLMCachingHandler is None:
         from litellm.caching.caching_handler import LLMCachingHandler
+
         _LLMCachingHandler = LLMCachingHandler
     return _LLMCachingHandler
 
@@ -144,9 +148,11 @@ def _get_cached_audio_utils():
     global _audio_utils_module
     if _audio_utils_module is None:
         import litellm.litellm_core_utils.audio_utils.utils
+
         _audio_utils_module = litellm.litellm_core_utils.audio_utils.utils
     return _audio_utils_module
 
+
 from litellm.types.llms.openai import (
     AllMessageValues,
     AllPromptValues,
@@ -203,10 +209,6 @@ from litellm.types.utils import (
 #  Thank you users! We ❤️ you! - Krrish & Ishaan
 
 
-
-
-
-
 try:
     # Python 3.9+
     with resources.files("litellm.litellm_core_utils.tokenizers").joinpath(
@@ -250,10 +252,14 @@ from litellm.llms.base_llm.base_utils import (
 if TYPE_CHECKING:
     # Heavy types that are only needed for type checking; avoid importing
     # their modules at runtime during `litellm` import.
-    from litellm.caching.caching_handler import CachingHandlerResponse, LLMCachingHandler
+    from litellm.caching.caching_handler import (
+        CachingHandlerResponse,
+        LLMCachingHandler,
+    )
     from litellm.integrations.custom_logger import CustomLogger
     from litellm.llms.base_llm.files.transformation import BaseFilesConfig
     from litellm.proxy._types import AllowedModelRegion
+
     # Type stubs for lazy-loaded functions to help mypy understand their types
     # These imports allow mypy to understand the types when these are accessed via __getattr__
     from litellm.litellm_core_utils.exception_mapping_utils import exception_type
@@ -288,10 +294,13 @@ if TYPE_CHECKING:
     )
     from litellm.llms.base_llm.ocr.transformation import BaseOCRConfig
     from litellm.llms.base_llm.search.transformation import BaseSearchConfig
-    from litellm.llms.base_llm.text_to_speech.transformation import BaseTextToSpeechConfig
+    from litellm.llms.base_llm.text_to_speech.transformation import (
+        BaseTextToSpeechConfig,
+    )
     from litellm.llms.bedrock.common_utils import BedrockModelInfo
     from litellm.llms.cohere.common_utils import CohereModelInfo
     from litellm.llms.mistral.ocr.transformation import MistralOCRConfig
+
     # Type stubs for lazy-loaded functions and classes
     from litellm.litellm_core_utils.cached_imports import (
         get_coroutine_checker,
@@ -335,6 +344,7 @@ if TYPE_CHECKING:
         reset_retry_policy,
     )
     from litellm.secret_managers.main import get_secret
+
     # Type stubs for lazy-loaded config classes and types
     from litellm.llms.base_llm.batches.transformation import BaseBatchesConfig
     from litellm.llms.base_llm.containers.transformation import BaseContainerConfig
@@ -618,7 +628,7 @@ def load_credentials_from_list(kwargs: dict):
     Updates kwargs with the credentials if credential_name in kwarg
     """
     # Access CredentialAccessor via module to trigger lazy loading if needed
-    CredentialAccessor = getattr(sys.modules[__name__], 'CredentialAccessor')
+    CredentialAccessor = getattr(sys.modules[__name__], "CredentialAccessor")
 
     credential_name = kwargs.get("litellm_credential_name")
     if credential_name and litellm.credential_list:
@@ -699,9 +709,7 @@ def _process_tool_message_id(msg_copy: dict, thought_signature_separator: str) -
     """
     Process tool message to remove thought signature from tool_call_id.
     """
-    if msg_copy.get("role") == "tool" and isinstance(
-        msg_copy.get("tool_call_id"), str
-    ):
+    if msg_copy.get("role") == "tool" and isinstance(msg_copy.get("tool_call_id"), str):
         if thought_signature_separator in msg_copy["tool_call_id"]:
             msg_copy["tool_call_id"] = _remove_thought_signature_from_id(
                 msg_copy["tool_call_id"], thought_signature_separator
@@ -763,12 +771,12 @@ def function_setup(  # noqa: PLR0915
         function_id: Optional[str] = kwargs["id"] if "id" in kwargs else None
 
         ## LAZY LOAD COROUTINE CHECKER ##
-        get_coroutine_checker = getattr(sys.modules[__name__], 'get_coroutine_checker')
+        get_coroutine_checker = getattr(sys.modules[__name__], "get_coroutine_checker")
 
         ## DYNAMIC CALLBACKS ##
-        dynamic_callbacks: Optional[List[Union[str, Callable, "CustomLogger"]]] = (
-            kwargs.pop("callbacks", None)
-        )
+        dynamic_callbacks: Optional[
+            List[Union[str, Callable, "CustomLogger"]]
+        ] = kwargs.pop("callbacks", None)
         all_callbacks = get_dynamic_callbacks(dynamic_callbacks=dynamic_callbacks)
 
         if len(all_callbacks) > 0:
@@ -811,7 +819,7 @@ def function_setup(  # noqa: PLR0915
                     + litellm.failure_callback
                 )
             )
-            get_set_callbacks = getattr(sys.modules[__name__], 'get_set_callbacks')
+            get_set_callbacks = getattr(sys.modules[__name__], "get_set_callbacks")
             get_set_callbacks()(callback_list=callback_list, function_id=function_id)
         ## ASYNC CALLBACKS
         if len(litellm.input_callback) > 0:
@@ -939,7 +947,7 @@ def function_setup(  # noqa: PLR0915
             elif kwargs.get("messages", None):
                 messages = kwargs["messages"]
             ### PRE-CALL RULES ###
-            Rules = getattr(sys.modules[__name__], 'Rules')
+            Rules = getattr(sys.modules[__name__], "Rules")
             if (
                 Rules.has_pre_call_rules()
                 and isinstance(messages, list)
@@ -947,7 +955,6 @@ def function_setup(  # noqa: PLR0915
                 and isinstance(messages[0], dict)
                 and "content" in messages[0]
             ):
-
                 buffer = StringIO()
                 for m in messages:
                     content = m.get("content", "")
@@ -1041,9 +1048,7 @@ def function_setup(  # noqa: PLR0915
             _file_obj: FileTypes = args[1] if len(args) > 1 else kwargs["file"]
             # Lazy import audio_utils.utils only when needed for transcription calls
             audio_utils = _get_cached_audio_utils()
-            file_checksum = audio_utils.get_audio_file_content_hash(
-                file_obj=_file_obj
-            )
+            file_checksum = audio_utils.get_audio_file_content_hash(file_obj=_file_obj)
             if "metadata" in kwargs:
                 kwargs["metadata"]["file_checksum"] = file_checksum
             else:
@@ -1064,6 +1069,42 @@ def function_setup(  # noqa: PLR0915
                 else kwargs.get("input")
                 or kwargs.get("messages", "default-message-value")
             )
+        elif (
+            call_type == CallTypes.generate_content.value
+            or call_type == CallTypes.agenerate_content.value
+            or call_type == CallTypes.generate_content_stream.value
+            or call_type == CallTypes.agenerate_content_stream.value
+        ):
+            try:
+                from litellm.google_genai.adapters.transformation import (
+                    GoogleGenAIAdapter,
+                )
+                from litellm.litellm_core_utils.prompt_templates.common_utils import (
+                    get_last_user_message,
+                )
+
+                contents_param = args[1] if len(args) > 1 else kwargs.get("contents")
+                model_param = args[0] if len(args) > 0 else kwargs.get("model", "")
+
+                if contents_param:
+                    adapter = GoogleGenAIAdapter()
+                    transformed = adapter.translate_generate_content_to_completion(
+                        model=model_param,
+                        contents=contents_param,
+                        config=kwargs.get("config"),
+                    )
+                    transformed_messages = transformed.get("messages", [])
+                    messages = (
+                        get_last_user_message(transformed_messages)
+                        or "default-message-value"
+                    )
+                else:
+                    messages = "default-message-value"
+            except Exception as e:
+                verbose_logger.debug(
+                    f"Error extracting messages from Google contents: {str(e)}"
+                )
+                messages = "default-message-value"
         else:
             messages = "default-message-value"
         stream = False
@@ -1072,7 +1113,9 @@ def function_setup(  # noqa: PLR0915
             call_type=call_type,
         ):
             stream = True
-        get_litellm_logging_class = getattr(sys.modules[__name__], 'get_litellm_logging_class')
+        get_litellm_logging_class = getattr(
+            sys.modules[__name__], "get_litellm_logging_class"
+        )
         logging_obj = get_litellm_logging_class()(  # Victim for object pool
             model=model,  # type: ignore
             messages=messages,
@@ -1156,8 +1199,10 @@ def _get_wrapper_num_retries(
     if num_retries is None:
         num_retries = litellm.num_retries
     if kwargs.get("retry_policy", None):
-        get_num_retries_from_retry_policy = getattr(sys.modules[__name__], 'get_num_retries_from_retry_policy')
-        reset_retry_policy = getattr(sys.modules[__name__], 'reset_retry_policy')
+        get_num_retries_from_retry_policy = getattr(
+            sys.modules[__name__], "get_num_retries_from_retry_policy"
+        )
+        reset_retry_policy = getattr(sys.modules[__name__], "reset_retry_policy")
         retry_policy_num_retries = get_num_retries_from_retry_policy(
             exception=exception,
             retry_policy=kwargs.get("retry_policy"),
@@ -1185,7 +1230,7 @@ def _get_wrapper_timeout(
 
 
 def check_coroutine(value) -> bool:
-    get_coroutine_checker = getattr(sys.modules[__name__], 'get_coroutine_checker')
+    get_coroutine_checker = getattr(sys.modules[__name__], "get_coroutine_checker")
     return get_coroutine_checker().is_async_callable(value)
 
 
@@ -1344,7 +1389,7 @@ def post_call_processing(
 
 
 def client(original_function):  # noqa: PLR0915
-    Rules = getattr(sys.modules[__name__], 'Rules')
+    Rules = getattr(sys.modules[__name__], "Rules")
     rules_obj = Rules()
 
     @wraps(original_function)
@@ -1530,7 +1575,9 @@ def client(original_function):  # noqa: PLR0915
                     )
                 else:
                     # RETURN RESULT
-                    update_response_metadata = getattr(sys.modules[__name__], 'update_response_metadata')
+                    update_response_metadata = getattr(
+                        sys.modules[__name__], "update_response_metadata"
+                    )
                     update_response_metadata(
                         result=result,
                         logging_obj=logging_obj,
@@ -1574,7 +1621,7 @@ def client(original_function):  # noqa: PLR0915
             # Copy the current context to propagate it to the background thread
             # This is essential for OpenTelemetry span context propagation
             ctx = contextvars.copy_context()
-            executor = getattr(sys.modules[__name__], 'executor')
+            executor = getattr(sys.modules[__name__], "executor")
             executor.submit(
                 ctx.run,
                 logging_obj.success_handler,
@@ -1583,7 +1630,9 @@ def client(original_function):  # noqa: PLR0915
                 end_time,
             )
             # RETURN RESULT
-            update_response_metadata = getattr(sys.modules[__name__], 'update_response_metadata')
+            update_response_metadata = getattr(
+                sys.modules[__name__], "update_response_metadata"
+            )
             update_response_metadata(
                 result=result,
                 logging_obj=logging_obj,
@@ -1600,15 +1649,19 @@ def client(original_function):  # noqa: PLR0915
                     kwargs.get("num_retries", None) or litellm.num_retries or None
                 )
                 if kwargs.get("retry_policy", None):
-                    get_num_retries_from_retry_policy = getattr(sys.modules[__name__], 'get_num_retries_from_retry_policy')
-                    reset_retry_policy = getattr(sys.modules[__name__], 'reset_retry_policy')
+                    get_num_retries_from_retry_policy = getattr(
+                        sys.modules[__name__], "get_num_retries_from_retry_policy"
+                    )
+                    reset_retry_policy = getattr(
+                        sys.modules[__name__], "reset_retry_policy"
+                    )
                     num_retries = get_num_retries_from_retry_policy(
                         exception=e,
                         retry_policy=kwargs.get("retry_policy"),
                     )
-                    kwargs["retry_policy"] = (
-                        reset_retry_policy()
-                    )  # prevent infinite loops
+                    kwargs[
+                        "retry_policy"
+                    ] = reset_retry_policy()  # prevent infinite loops
                 litellm.num_retries = (
                     None  # set retries to None to prevent infinite loops
                 )
@@ -1645,15 +1698,19 @@ def client(original_function):  # noqa: PLR0915
                     kwargs.get("num_retries", None) or litellm.num_retries or None
                 )
                 if kwargs.get("retry_policy", None):
-                    get_num_retries_from_retry_policy = getattr(sys.modules[__name__], 'get_num_retries_from_retry_policy')
-                    reset_retry_policy = getattr(sys.modules[__name__], 'reset_retry_policy')
+                    get_num_retries_from_retry_policy = getattr(
+                        sys.modules[__name__], "get_num_retries_from_retry_policy"
+                    )
+                    reset_retry_policy = getattr(
+                        sys.modules[__name__], "reset_retry_policy"
+                    )
                     num_retries = get_num_retries_from_retry_policy(
                         exception=e,
                         retry_policy=kwargs.get("retry_policy"),
                     )
-                    kwargs["retry_policy"] = (
-                        reset_retry_policy()
-                    )  # prevent infinite loops
+                    kwargs[
+                        "retry_policy"
+                    ] = reset_retry_policy()  # prevent infinite loops
                 litellm.num_retries = (
                     None  # set retries to None to prevent infinite loops
                 )
@@ -1804,7 +1861,9 @@ def client(original_function):  # noqa: PLR0915
                         chunks, messages=kwargs.get("messages", None)
                     )
                 else:
-                    update_response_metadata = getattr(sys.modules[__name__], 'update_response_metadata')
+                    update_response_metadata = getattr(
+                        sys.modules[__name__], "update_response_metadata"
+                    )
                     update_response_metadata(
                         result=result,
                         logging_obj=logging_obj,
@@ -1869,7 +1928,9 @@ def client(original_function):  # noqa: PLR0915
                     end_time=end_time,
                 )
 
-            update_response_metadata = getattr(sys.modules[__name__], 'update_response_metadata')
+            update_response_metadata = getattr(
+                sys.modules[__name__], "update_response_metadata"
+            )
             update_response_metadata(
                 result=result,
                 logging_obj=logging_obj,
@@ -1969,7 +2030,7 @@ def client(original_function):  # noqa: PLR0915
             setattr(e, "timeout", timeout)
             raise e
 
-    get_coroutine_checker = getattr(sys.modules[__name__], 'get_coroutine_checker')
+    get_coroutine_checker = getattr(sys.modules[__name__], "get_coroutine_checker")
     is_coroutine = get_coroutine_checker().is_async_callable(original_function)
 
     # Return the appropriate wrapper based on the original function type
@@ -2330,7 +2391,7 @@ def supports_response_schema(
     """
     ## GET LLM PROVIDER ##
     try:
-        get_llm_provider = getattr(sys.modules[__name__], 'get_llm_provider')
+        get_llm_provider = getattr(sys.modules[__name__], "get_llm_provider")
         model, custom_llm_provider, _, _ = get_llm_provider(
             model=model, custom_llm_provider=custom_llm_provider
         )
@@ -2674,6 +2735,7 @@ def register_model(model_cost: Union[str, dict]):  # noqa: PLR0915
     # Skip get_model_info for these providers during model registration
     _skip_get_model_info_providers = {
         LlmProviders.GITHUB_COPILOT.value,
+        LlmProviders.CHATGPT.value,
     }
 
     for key, value in loaded_model_cost.items():
@@ -2694,10 +2756,10 @@ def register_model(model_cost: Union[str, dict]):  # noqa: PLR0915
         ## override / add new keys to the existing model cost dictionary
         updated_dictionary = _update_dictionary(existing_model, value)
         litellm.model_cost.setdefault(model_cost_key, {}).update(updated_dictionary)
-        
+
         # Invalidate case-insensitive lookup map since model_cost was modified
         _invalidate_model_cost_lowercase_map()
-        
+
         verbose_logger.debug(
             f"added/updated model={model_cost_key} in litellm.model_cost: {model_cost_key}"
         )
@@ -3034,7 +3096,9 @@ def get_optional_params_embeddings(  # noqa: PLR0915
     **kwargs,
 ):
     # Lazy load get_supported_openai_params
-    get_supported_openai_params = getattr(sys.modules[__name__], 'get_supported_openai_params')
+    get_supported_openai_params = getattr(
+        sys.modules[__name__], "get_supported_openai_params"
+    )
 
     # retrieve all parameters passed to the function
     passed_params = locals()
@@ -3308,8 +3372,8 @@ def get_optional_params_embeddings(  # noqa: PLR0915
         )
 
     elif custom_llm_provider == "ollama":
-        if 'dimensions' in non_default_params:
-            optional_params['dimensions']=non_default_params.pop('dimensions')
+        if "dimensions" in non_default_params:
+            optional_params["dimensions"] = non_default_params.pop("dimensions")
         if len(non_default_params.keys()) > 0:
             if (
                 litellm.drop_params is True or drop_params is True
@@ -3575,10 +3639,10 @@ def pre_process_non_default_params(
 
     if "response_format" in non_default_params:
         if provider_config is not None:
-            non_default_params["response_format"] = (
-                provider_config.get_json_schema_from_pydantic_object(
-                    response_format=non_default_params["response_format"]
-                )
+            non_default_params[
+                "response_format"
+            ] = provider_config.get_json_schema_from_pydantic_object(
+                response_format=non_default_params["response_format"]
             )
         else:
             non_default_params["response_format"] = type_to_response_format_param(
@@ -3707,16 +3771,16 @@ def pre_process_optional_params(
                     True  # so that main.py adds the function call to the prompt
                 )
                 if "tools" in non_default_params:
-                    optional_params["functions_unsupported_model"] = (
-                        non_default_params.pop("tools")
-                    )
+                    optional_params[
+                        "functions_unsupported_model"
+                    ] = non_default_params.pop("tools")
                     non_default_params.pop(
                         "tool_choice", None
                     )  # causes ollama requests to hang
                 elif "functions" in non_default_params:
-                    optional_params["functions_unsupported_model"] = (
-                        non_default_params.pop("functions")
-                    )
+                    optional_params[
+                        "functions_unsupported_model"
+                    ] = non_default_params.pop("functions")
             elif (
                 litellm.add_function_to_prompt
             ):  # if user opts to add it to prompt instead
@@ -3840,7 +3904,9 @@ def get_optional_params(  # noqa: PLR0915
                     message=f"{custom_llm_provider} does not support parameters: {list(unsupported_params.keys())}, for model={model}. To drop these, set `litellm.drop_params=True` or for proxy:\n\n`litellm_settings:\n drop_params: true`\n. \n If you want to use these params dynamically send allowed_openai_params={list(unsupported_params.keys())} in your request.",
                 )
 
-    get_supported_openai_params = getattr(sys.modules[__name__], 'get_supported_openai_params')
+    get_supported_openai_params = getattr(
+        sys.modules[__name__], "get_supported_openai_params"
+    )
     supported_params = get_supported_openai_params(
         model=model, custom_llm_provider=custom_llm_provider
     )
@@ -4095,7 +4161,7 @@ def get_optional_params(  # noqa: PLR0915
             ),
         )
     elif custom_llm_provider == "bedrock":
-        BedrockModelInfo = getattr(sys.modules[__name__], 'BedrockModelInfo')
+        BedrockModelInfo = getattr(sys.modules[__name__], "BedrockModelInfo")
         bedrock_route = BedrockModelInfo.get_bedrock_route(model)
         bedrock_base_model = BedrockModelInfo.get_base_model(model)
         if bedrock_route == "converse" or bedrock_route == "converse_like":
@@ -4522,8 +4588,8 @@ def get_optional_params(  # noqa: PLR0915
 
     # Apply nested drops from additional_drop_params
     if additional_drop_params:
-        is_nested_path = getattr(sys.modules[__name__], 'is_nested_path')
-        delete_nested_value = getattr(sys.modules[__name__], 'delete_nested_value')
+        is_nested_path = getattr(sys.modules[__name__], "is_nested_path")
+        delete_nested_value = getattr(sys.modules[__name__], "delete_nested_value")
         nested_paths = [p for p in additional_drop_params if is_nested_path(p)]
         for path in nested_paths:
             optional_params = delete_nested_value(optional_params, path)
@@ -4573,7 +4639,9 @@ def add_provider_specific_params_to_optional_params(
             else:
                 processed_extra_body = initial_extra_body
 
-            _ensure_extra_body_is_safe = getattr(sys.modules[__name__], '_ensure_extra_body_is_safe')
+            _ensure_extra_body_is_safe = getattr(
+                sys.modules[__name__], "_ensure_extra_body_is_safe"
+            )
             optional_params["extra_body"] = _ensure_extra_body_is_safe(
                 extra_body=processed_extra_body
             )
@@ -4866,9 +4934,9 @@ def get_response_string(response_obj: Union[ModelResponse, ModelResponseStream])
             return delta if isinstance(delta, str) else ""
 
     # Handle standard ModelResponse and ModelResponseStream
-    _choices: Union[List[Union[Choices, StreamingChoices]], List[StreamingChoices]] = (
-        response_obj.choices
-    )
+    _choices: Union[
+        List[Union[Choices, StreamingChoices]], List[StreamingChoices]
+    ] = response_obj.choices
 
     # Use list accumulation to avoid O(n^2) string concatenation across choices
     response_parts: List[str] = []
@@ -4986,7 +5054,7 @@ def get_max_tokens(model: str) -> Optional[int]:
                 return litellm.model_cost[model]["max_output_tokens"]
             elif "max_tokens" in litellm.model_cost[model]:
                 return litellm.model_cost[model]["max_tokens"]
-        get_llm_provider = getattr(sys.modules[__name__], 'get_llm_provider')
+        get_llm_provider = getattr(sys.modules[__name__], "get_llm_provider")
         model, custom_llm_provider, _, _ = get_llm_provider(model=model)
         if custom_llm_provider == "huggingface":
             max_tokens = _get_max_position_embeddings(model_name=model)
@@ -5062,7 +5130,7 @@ _model_cost_lowercase_map: Optional[Dict[str, str]] = None
 
 def _invalidate_model_cost_lowercase_map() -> None:
     """Invalidate the case-insensitive lookup map for model_cost.
-    
+
     Call this whenever litellm.model_cost is modified to ensure the map is rebuilt.
     """
     global _model_cost_lowercase_map
@@ -5071,7 +5139,7 @@ def _invalidate_model_cost_lowercase_map() -> None:
 
 def _rebuild_model_cost_lowercase_map() -> Dict[str, str]:
     """Rebuild the case-insensitive lookup map from the current model_cost.
-    
+
     Returns:
         The rebuilt map (guaranteed to be not None).
     """
@@ -5085,9 +5153,9 @@ def _handle_stale_map_entry_rebuild(
 ) -> Optional[str]:
     """
     Handle stale _model_cost_lowercase_map entry (key was popped).
-    
+
     Rebuilds the map and retries the lookup.
-    
+
     Returns:
         The matched key if found after rebuild, None otherwise.
     """
@@ -5104,9 +5172,9 @@ def _handle_new_key_with_scan(
 ) -> Optional[str]:
     """
     Handle new key added to model_cost without invalidating _model_cost_lowercase_map.
-    
+
     Scans model_cost for case-insensitive match and rebuilds the map if found.
-    
+
     Returns:
         The matched key if found, None otherwise.
     """
@@ -5121,20 +5189,20 @@ def _handle_new_key_with_scan(
 def _get_model_cost_key(potential_key: str) -> Optional[str]:
     """
     Get the actual key from model_cost, with case-insensitive fallback.
-    
+
     WARNING: Only O(1) lookup operations are acceptable. O(n) lookups will cause severe
     CPU overhead. This function is called frequently during router operations.
-    
+
     ALLOWED HELPER FUNCTIONS (conditionally called, O(n) operations are acceptable):
     - _rebuild_model_cost_lowercase_map: Rebuilds the lookup map (only when map is None)
     - _handle_stale_map_entry_rebuild: Rebuilds map when stale entry detected (rare case)
-    
+
     If you need to add a new helper function with O(n) operations that is conditionally
     called and confirmed not to cause performance issues, add it to the allowed_helpers
     list in: tests/code_coverage_tests/check_get_model_cost_key_performance.py
     """
     global _model_cost_lowercase_map
-    
+
     # Exact match (O(1))
     if potential_key in litellm.model_cost:
         return potential_key
@@ -5142,20 +5210,20 @@ def _get_model_cost_key(potential_key: str) -> Optional[str]:
     # Case-insensitive lookup via map (O(1))
     if _model_cost_lowercase_map is None:
         _model_cost_lowercase_map = _rebuild_model_cost_lowercase_map()
-    
+
     potential_key_lower = potential_key.lower()
     matched_key = _model_cost_lowercase_map.get(potential_key_lower)
-    
+
     # Verify key exists (O(1) - handles model_cost.pop() case)
     if matched_key is not None and matched_key in litellm.model_cost:
         return matched_key
-    
+
     # Rebuild map if stale entry detected (O(n) rebuild, but only when stale entry found)
     if matched_key is not None:
         matched_key = _handle_stale_map_entry_rebuild(potential_key_lower)
         if matched_key is not None:
             return matched_key
-    
+
     return None
 
 
@@ -5187,9 +5255,12 @@ def _check_provider_match(model_info: dict, custom_llm_provider: Optional[str])
             custom_llm_provider == "litellm_proxy"
         ):  # litellm_proxy is a special case, it's not a provider, it's a proxy for the provider
             return True
-        elif custom_llm_provider == "azure_ai" and model_info["litellm_provider"] in ("azure", "openai"):
-            # Azure AI also works with azure models 
-            # as a last attempt if the model is not on Azure AI, Azure then fallback to OpenAI cost 
+        elif custom_llm_provider == "azure_ai" and model_info["litellm_provider"] in (
+            "azure",
+            "openai",
+        ):
+            # Azure AI also works with azure models
+            # as a last attempt if the model is not on Azure AI, Azure then fallback to OpenAI cost
             # tracking the cost is better than attributing 0 cost to it.
             return True
         else:
@@ -5215,7 +5286,7 @@ def _get_potential_model_names(
     if custom_llm_provider is None:
         # Get custom_llm_provider
         try:
-            get_llm_provider = getattr(sys.modules[__name__], 'get_llm_provider')
+            get_llm_provider = getattr(sys.modules[__name__], "get_llm_provider")
             split_model, custom_llm_provider, _, _ = get_llm_provider(model=model)
         except Exception:
             split_model = model
@@ -5519,6 +5590,13 @@ def _get_model_info_helper(  # noqa: PLR0915
                 input_cost_per_image_token=_model_info.get(
                     "input_cost_per_image_token", None
                 ),
+                input_cost_per_image=_model_info.get("input_cost_per_image", None),
+                input_cost_per_audio_per_second=_model_info.get(
+                    "input_cost_per_audio_per_second", None
+                ),
+                input_cost_per_video_per_second=_model_info.get(
+                    "input_cost_per_video_per_second", None
+                ),
                 input_cost_per_token_batches=_model_info.get(
                     "input_cost_per_token_batches"
                 ),
@@ -5945,7 +6023,7 @@ def validate_environment(  # noqa: PLR0915
         }
     ## EXTRACT LLM PROVIDER - if model name provided
     try:
-        get_llm_provider = getattr(sys.modules[__name__], 'get_llm_provider')
+        get_llm_provider = getattr(sys.modules[__name__], "get_llm_provider")
         _, custom_llm_provider, _, _ = get_llm_provider(model=model)
     except Exception:
         custom_llm_provider = None
@@ -6508,7 +6586,7 @@ def register_prompt_template(
     complete_model = model
     potential_models = [complete_model]
     try:
-        get_llm_provider = getattr(sys.modules[__name__], 'get_llm_provider')
+        get_llm_provider = getattr(sys.modules[__name__], "get_llm_provider")
         model = get_llm_provider(model=model)[0]
         potential_models.append(model)
     except Exception:
@@ -6594,7 +6672,7 @@ class TextCompletionStreamWrapper:
         except StopIteration:
             raise StopIteration
         except Exception as e:
-            exception_type = getattr(sys.modules[__name__], 'exception_type')
+            exception_type = getattr(sys.modules[__name__], "exception_type")
             raise exception_type(
                 model=self.model,
                 custom_llm_provider=self.custom_llm_provider or "",
@@ -7218,14 +7296,20 @@ def _get_base_model_from_metadata(model_call_details=None):
             return _base_model
         metadata = litellm_params.get("metadata", {})
 
-        _get_base_model_from_litellm_call_metadata = getattr(sys.modules[__name__], '_get_base_model_from_litellm_call_metadata')
-        base_model_from_metadata = _get_base_model_from_litellm_call_metadata(metadata=metadata)
+        _get_base_model_from_litellm_call_metadata = getattr(
+            sys.modules[__name__], "_get_base_model_from_litellm_call_metadata"
+        )
+        base_model_from_metadata = _get_base_model_from_litellm_call_metadata(
+            metadata=metadata
+        )
         if base_model_from_metadata is not None:
             return base_model_from_metadata
 
         # Also check litellm_metadata (used by Responses API and other generic API calls)
         litellm_metadata = litellm_params.get("litellm_metadata", {})
-        _get_base_model_from_litellm_call_metadata = getattr(sys.modules[__name__], '_get_base_model_from_litellm_call_metadata')
+        _get_base_model_from_litellm_call_metadata = getattr(
+            sys.modules[__name__], "_get_base_model_from_litellm_call_metadata"
+        )
         return _get_base_model_from_litellm_call_metadata(metadata=litellm_metadata)
     return None
 
@@ -7631,12 +7715,30 @@ class ProviderConfigManager:
             # Format: (factory_function, needs_model_parameter: bool)
             LlmProviders.OPENAI: (lambda: litellm.OpenAIGPTConfig(), False),
             LlmProviders.ANTHROPIC: (lambda: litellm.AnthropicConfig(), False),
-            LlmProviders.AZURE: (lambda model: ProviderConfigManager._get_azure_config(model), True),
-            LlmProviders.AZURE_AI: (lambda model: ProviderConfigManager._get_azure_ai_config(model), True),
-            LlmProviders.VERTEX_AI: (lambda model: ProviderConfigManager._get_vertex_ai_config(model), True),
-            LlmProviders.BEDROCK: (lambda model: ProviderConfigManager._get_bedrock_config(model), True),
-            LlmProviders.COHERE: (lambda model: ProviderConfigManager._get_cohere_config(model), True),
-            LlmProviders.COHERE_CHAT: (lambda model: ProviderConfigManager._get_cohere_config(model), True),
+            LlmProviders.AZURE: (
+                lambda model: ProviderConfigManager._get_azure_config(model),
+                True,
+            ),
+            LlmProviders.AZURE_AI: (
+                lambda model: ProviderConfigManager._get_azure_ai_config(model),
+                True,
+            ),
+            LlmProviders.VERTEX_AI: (
+                lambda model: ProviderConfigManager._get_vertex_ai_config(model),
+                True,
+            ),
+            LlmProviders.BEDROCK: (
+                lambda model: ProviderConfigManager._get_bedrock_config(model),
+                True,
+            ),
+            LlmProviders.COHERE: (
+                lambda model: ProviderConfigManager._get_cohere_config(model),
+                True,
+            ),
+            LlmProviders.COHERE_CHAT: (
+                lambda model: ProviderConfigManager._get_cohere_config(model),
+                True,
+            ),
             # Simple provider mappings (no model parameter needed)
             LlmProviders.DEEPSEEK: (lambda: litellm.DeepSeekChatConfig(), False),
             LlmProviders.GROQ: (lambda: litellm.GroqChatConfig(), False),
@@ -7646,7 +7748,10 @@ class ProviderConfigManager:
             LlmProviders.ZAI: (lambda: litellm.ZAIChatConfig(), False),
             LlmProviders.LAMBDA_AI: (lambda: litellm.LambdaAIChatConfig(), False),
             LlmProviders.LLAMA: (lambda: litellm.LlamaAPIConfig(), False),
-            LlmProviders.TEXT_COMPLETION_OPENAI: (lambda: litellm.OpenAITextCompletionConfig(), False),
+            LlmProviders.TEXT_COMPLETION_OPENAI: (
+                lambda: litellm.OpenAITextCompletionConfig(),
+                False,
+            ),
             LlmProviders.SNOWFLAKE: (lambda: litellm.SnowflakeConfig(), False),
             LlmProviders.CLARIFAI: (lambda: litellm.ClarifaiConfig(), False),
             LlmProviders.ANTHROPIC_TEXT: (lambda: litellm.AnthropicTextConfig(), False),
@@ -7663,12 +7768,16 @@ class ProviderConfigManager:
             LlmProviders.GITHUB: (lambda: litellm.GithubChatConfig(), False),
             LlmProviders.COMPACTIFAI: (lambda: litellm.CompactifAIChatConfig(), False),
             LlmProviders.GITHUB_COPILOT: (lambda: litellm.GithubCopilotConfig(), False),
+            LlmProviders.CHATGPT: (lambda: litellm.ChatGPTConfig(), False),
             LlmProviders.GIGACHAT: (lambda: litellm.GigaChatConfig(), False),
             LlmProviders.RAGFLOW: (lambda: litellm.RAGFlowConfig(), False),
             LlmProviders.CUSTOM: (lambda: litellm.OpenAILikeChatConfig(), False),
             LlmProviders.CUSTOM_OPENAI: (lambda: litellm.OpenAILikeChatConfig(), False),
             LlmProviders.OPENAI_LIKE: (lambda: litellm.OpenAILikeChatConfig(), False),
-            LlmProviders.AIOHTTP_OPENAI: (lambda: litellm.AiohttpOpenAIChatConfig(), False),
+            LlmProviders.AIOHTTP_OPENAI: (
+                lambda: litellm.AiohttpOpenAIChatConfig(),
+                False,
+            ),
             LlmProviders.HOSTED_VLLM: (lambda: litellm.HostedVLLMChatConfig(), False),
             LlmProviders.LLAMAFILE: (lambda: litellm.LlamafileChatConfig(), False),
             LlmProviders.LM_STUDIO: (lambda: litellm.LMStudioChatConfig(), False),
@@ -7677,7 +7786,10 @@ class ProviderConfigManager:
             LlmProviders.HUGGINGFACE: (lambda: litellm.HuggingFaceChatConfig(), False),
             LlmProviders.TOGETHER_AI: (lambda: litellm.TogetherAIConfig(), False),
             LlmProviders.OPENROUTER: (lambda: litellm.OpenrouterConfig(), False),
-            LlmProviders.VERCEL_AI_GATEWAY: (lambda: litellm.VercelAIGatewayConfig(), False),
+            LlmProviders.VERCEL_AI_GATEWAY: (
+                lambda: litellm.VercelAIGatewayConfig(),
+                False,
+            ),
             LlmProviders.COMETAPI: (lambda: litellm.CometAPIConfig(), False),
             LlmProviders.DATAROBOT: (lambda: litellm.DataRobotConfig(), False),
             LlmProviders.GEMINI: (lambda: litellm.GoogleAIStudioGeminiConfig(), False),
@@ -7695,7 +7807,10 @@ class ProviderConfigManager:
             LlmProviders.CEREBRAS: (lambda: litellm.CerebrasConfig(), False),
             LlmProviders.BASETEN: (lambda: litellm.BasetenConfig(), False),
             LlmProviders.VOLCENGINE: (lambda: litellm.VolcEngineConfig(), False),
-            LlmProviders.TEXT_COMPLETION_CODESTRAL: (lambda: litellm.CodestralTextCompletionConfig(), False),
+            LlmProviders.TEXT_COMPLETION_CODESTRAL: (
+                lambda: litellm.CodestralTextCompletionConfig(),
+                False,
+            ),
             LlmProviders.SAMBANOVA: (lambda: litellm.SambanovaConfig(), False),
             LlmProviders.MARITALK: (lambda: litellm.MaritalkConfig(), False),
             LlmProviders.VLLM: (lambda: litellm.VLLMConfig(), False),
@@ -7703,17 +7818,26 @@ class ProviderConfigManager:
             LlmProviders.PREDIBASE: (lambda: litellm.PredibaseConfig(), False),
             LlmProviders.TRITON: (lambda: litellm.TritonConfig(), False),
             LlmProviders.PETALS: (lambda: litellm.PetalsConfig(), False),
-            LlmProviders.SAP_GENERATIVE_AI_HUB: (lambda: litellm.GenAIHubOrchestrationConfig(), False),
+            LlmProviders.SAP_GENERATIVE_AI_HUB: (
+                lambda: litellm.GenAIHubOrchestrationConfig(),
+                False,
+            ),
             LlmProviders.FEATHERLESS_AI: (lambda: litellm.FeatherlessAIConfig(), False),
             LlmProviders.NOVITA: (lambda: litellm.NovitaConfig(), False),
             LlmProviders.NEBIUS: (lambda: litellm.NebiusConfig(), False),
             LlmProviders.WANDB: (lambda: litellm.WandbConfig(), False),
             LlmProviders.DASHSCOPE: (lambda: litellm.DashScopeChatConfig(), False),
             LlmProviders.MOONSHOT: (lambda: litellm.MoonshotChatConfig(), False),
-            LlmProviders.DOCKER_MODEL_RUNNER: (lambda: litellm.DockerModelRunnerChatConfig(), False),
+            LlmProviders.DOCKER_MODEL_RUNNER: (
+                lambda: litellm.DockerModelRunnerChatConfig(),
+                False,
+            ),
             LlmProviders.V0: (lambda: litellm.V0ChatConfig(), False),
             LlmProviders.MORPH: (lambda: litellm.MorphChatConfig(), False),
-            LlmProviders.LITELLM_PROXY: (lambda: litellm.LiteLLMProxyChatConfig(), False),
+            LlmProviders.LITELLM_PROXY: (
+                lambda: litellm.LiteLLMProxyChatConfig(),
+                False,
+            ),
             LlmProviders.GRADIENT_AI: (lambda: litellm.GradientAIConfig(), False),
             LlmProviders.NSCALE: (lambda: litellm.NscaleConfig(), False),
             LlmProviders.HEROKU: (lambda: litellm.HerokuChatConfig(), False),
@@ -7721,7 +7845,10 @@ class ProviderConfigManager:
             LlmProviders.HYPERBOLIC: (lambda: litellm.HyperbolicChatConfig(), False),
             LlmProviders.OVHCLOUD: (lambda: litellm.OVHCloudChatConfig(), False),
             LlmProviders.AMAZON_NOVA: (lambda: litellm.AmazonNovaChatConfig(), False),
-            LlmProviders.LANGGRAPH: (lambda: ProviderConfigManager._get_langgraph_config(), False),
+            LlmProviders.LANGGRAPH: (
+                lambda: ProviderConfigManager._get_langgraph_config(),
+                False,
+            ),
         }
 
     @staticmethod
@@ -7751,6 +7878,7 @@ class ProviderConfigManager:
             from litellm.llms.vertex_ai.vertex_ai_partner_models.gpt_oss.transformation import (
                 VertexAIGPTOSSTransformation,
             )
+
             return VertexAIGPTOSSTransformation()
         elif model in litellm.vertex_mistral_models:
             if "codestral" in model:
@@ -7765,12 +7893,13 @@ class ProviderConfigManager:
     def _get_bedrock_config(model: str) -> BaseConfig:
         """Get Bedrock config based on model."""
         from litellm.llms.bedrock.common_utils import get_bedrock_chat_config
+
         return get_bedrock_chat_config(model=model)
 
     @staticmethod
     def _get_cohere_config(model: str) -> BaseConfig:
         """Get Cohere config based on route."""
-        CohereModelInfo = getattr(sys.modules[__name__], 'CohereModelInfo')
+        CohereModelInfo = getattr(sys.modules[__name__], "CohereModelInfo")
         route = CohereModelInfo.get_cohere_route(model)
         if route == "v2":
             return litellm.CohereV2ChatConfig()
@@ -7780,6 +7909,7 @@ class ProviderConfigManager:
     def _get_langgraph_config() -> BaseConfig:
         """Get LangGraph config."""
         from litellm.llms.langgraph.chat.transformation import LangGraphConfig
+
         return LangGraphConfig()
 
     @staticmethod
@@ -7810,7 +7940,9 @@ class ProviderConfigManager:
 
         # Initialize provider config map lazily (avoids circular imports)
         if ProviderConfigManager._PROVIDER_CONFIG_MAP is None:
-            ProviderConfigManager._PROVIDER_CONFIG_MAP = ProviderConfigManager._build_provider_config_map()
+            ProviderConfigManager._PROVIDER_CONFIG_MAP = (
+                ProviderConfigManager._build_provider_config_map()
+            )
 
         # O(1) dictionary lookup
         config_entry = ProviderConfigManager._PROVIDER_CONFIG_MAP.get(provider)
@@ -7880,6 +8012,7 @@ class ProviderConfigManager:
             from litellm.llms.openrouter.embedding.transformation import (
                 OpenrouterEmbeddingConfig,
             )
+
             return OpenrouterEmbeddingConfig()
         elif litellm.LlmProviders.GIGACHAT == provider:
             return litellm.GigaChatEmbeddingConfig()
@@ -8034,6 +8167,8 @@ class ProviderConfigManager:
             return litellm.XAIResponsesAPIConfig()
         elif litellm.LlmProviders.GITHUB_COPILOT == provider:
             return litellm.GithubCopilotResponsesAPIConfig()
+        elif litellm.LlmProviders.CHATGPT == provider:
+            return litellm.ChatGPTResponsesAPIConfig()
         elif litellm.LlmProviders.LITELLM_PROXY == provider:
             return litellm.LiteLLMProxyResponsesAPIConfig()
         elif litellm.LlmProviders.VOLCENGINE == provider:
@@ -8110,6 +8245,10 @@ class ProviderConfigManager:
             return litellm.ClarifaiConfig()
         elif LlmProviders.BEDROCK == provider:
             return litellm.llms.bedrock.common_utils.BedrockModelInfo()
+        elif LlmProviders.AZURE_AI == provider:
+            from litellm.llms.azure_ai.common_utils import AzureFoundryModelInfo
+
+            return AzureFoundryModelInfo(model=model)
         return None
 
     @staticmethod
@@ -8496,7 +8635,7 @@ class ProviderConfigManager:
 
             return get_vertex_ai_ocr_config(model=model)
 
-        MistralOCRConfig = getattr(sys.modules[__name__], 'MistralOCRConfig')
+        MistralOCRConfig = getattr(sys.modules[__name__], "MistralOCRConfig")
         PROVIDER_TO_CONFIG_MAP = {
             litellm.LlmProviders.MISTRAL: MistralOCRConfig,
         }
@@ -8637,7 +8776,9 @@ def get_end_user_id_for_cost_tracking(
 
     service_type: "litellm_logging" or "prometheus" - used to allow prometheus only disable cost tracking.
     """
-    get_litellm_metadata_from_kwargs = getattr(sys.modules[__name__], 'get_litellm_metadata_from_kwargs')
+    get_litellm_metadata_from_kwargs = getattr(
+        sys.modules[__name__], "get_litellm_metadata_from_kwargs"
+    )
     _metadata = cast(
         dict, get_litellm_metadata_from_kwargs(dict(litellm_params=litellm_params))
     )
diff --git a/model_prices_and_context_window.json b/model_prices_and_context_window.json
index 4599cafe708..135b0d46ed0 100644
--- a/model_prices_and_context_window.json
+++ b/model_prices_and_context_window.json
@@ -13465,6 +13465,31 @@
         "supports_vision": true,
         "supports_web_search": true
     },
+    "gemini-2.5-computer-use-preview-10-2025": {
+        "input_cost_per_token": 1.25e-06,
+        "input_cost_per_token_above_200k_tokens": 2.5e-06,
+        "litellm_provider": "vertex_ai-language-models",
+        "max_images_per_prompt": 3000,
+        "max_input_tokens": 128000,
+        "max_output_tokens": 64000,
+        "max_tokens": 64000,
+        "mode": "chat",
+        "output_cost_per_token": 1e-05,
+        "output_cost_per_token_above_200k_tokens": 1.5e-05,
+        "source": "https://cloud.google.com/vertex-ai/generative-ai/docs/computer-use",
+        "supported_modalities": [
+            "text",
+            "image"
+        ],
+        "supported_output_modalities": [
+            "text"
+        ],
+        "supports_computer_use": true,
+        "supports_function_calling": true,
+        "supports_system_messages": true,
+        "supports_tool_choice": true,
+        "supports_vision": true
+    },
     "gemini-embedding-001": {
         "input_cost_per_token": 1.5e-07,
         "litellm_provider": "vertex_ai-embedding-models",
@@ -15950,6 +15975,63 @@
         "max_tokens": 8191,
         "mode": "embedding"
     },
+    "chatgpt/gpt-5.2-codex": {
+        "litellm_provider": "chatgpt",
+        "max_input_tokens": 128000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "responses",
+        "supported_endpoints": [
+            "/v1/responses"
+        ],
+        "supports_function_calling": true,
+        "supports_parallel_function_calling": true,
+        "supports_response_schema": true,
+        "supports_vision": true
+    },
+    "chatgpt/gpt-5.2": {
+        "litellm_provider": "chatgpt",
+        "max_input_tokens": 128000,
+        "max_output_tokens": 64000,
+        "max_tokens": 64000,
+        "mode": "responses",
+        "supported_endpoints": [
+            "/v1/chat/completions",
+            "/v1/responses"
+        ],
+        "supports_function_calling": true,
+        "supports_parallel_function_calling": true,
+        "supports_response_schema": true,
+        "supports_vision": true
+    },
+    "chatgpt/gpt-5.1-codex-max": {
+        "litellm_provider": "chatgpt",
+        "max_input_tokens": 128000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "responses",
+        "supported_endpoints": [
+            "/v1/responses"
+        ],
+        "supports_function_calling": true,
+        "supports_parallel_function_calling": true,
+        "supports_response_schema": true,
+        "supports_vision": true
+    },
+    "chatgpt/gpt-5.1-codex-mini": {
+        "litellm_provider": "chatgpt",
+        "max_input_tokens": 128000,
+        "max_output_tokens": 64000,
+        "max_tokens": 64000,
+        "mode": "responses",
+        "supported_endpoints": [
+            "/v1/responses"
+        ],
+        "supports_function_calling": true,
+        "supports_parallel_function_calling": true,
+        "supports_response_schema": true,
+        "supports_vision": true
+    },
     "gigachat/GigaChat-2-Lite": {
         "input_cost_per_token": 0.0,
         "litellm_provider": "gigachat",
diff --git a/provider_endpoints_support.json b/provider_endpoints_support.json
index db11ec8a0de..b7892a67a17 100644
--- a/provider_endpoints_support.json
+++ b/provider_endpoints_support.json
@@ -919,6 +919,24 @@
         "interactions": true
       }
     },
+    "chatgpt": {
+      "display_name": "ChatGPT Subscription (`chatgpt`)",
+      "url": "https://docs.litellm.ai/docs/providers/chatgpt",
+      "endpoints": {
+        "chat_completions": true,
+        "messages": true,
+        "responses": true,
+        "embeddings": false,
+        "image_generations": false,
+        "audio_transcriptions": false,
+        "audio_speech": false,
+        "moderations": false,
+        "batches": false,
+        "rerank": false,
+        "a2a": false,
+        "interactions": false
+      }
+    },
     "github": {
       "display_name": "GitHub Models (`github`)",
       "url": "https://docs.litellm.ai/docs/providers/github",
diff --git a/pyproject.toml b/pyproject.toml
index c694bfddcd1..0ee9c53d603 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "litellm"
-version = "1.81.0"
+version = "1.81.1"
 description = "Library to easily interface with LLM API providers"
 authors = ["BerriAI"]
 license = "MIT"
@@ -53,14 +53,15 @@ azure-keyvault-secrets = {version = "^4.8.0", optional = true}
 azure-storage-blob = {version="^12.25.1", optional=true}
 google-cloud-kms = {version = "^2.21.3", optional = true}
 google-cloud-iam = {version = "^2.19.1", optional = true}
+google-cloud-aiplatform = {version = ">=1.38.0", optional = true}
 resend = {version = ">=0.8.0", optional = true}
 pynacl = {version = "^1.5.0", optional = true}
 websockets = {version = "^15.0.1", optional = true}
-boto3 = {version = "1.36.0", optional = true}
+boto3 = { version = "1.40.76", optional = true }
 redisvl = {version = "^0.4.1", optional = true, markers = "python_version >= '3.9' and python_version < '3.14'"}
 mcp = {version = ">=1.25.0,<2.0.0", optional = true, python = ">=3.10"}
 a2a-sdk = {version = "^0.3.22", optional = true, python = ">=3.10"}
-litellm-proxy-extras = {version = "0.4.23", optional = true}
+litellm-proxy-extras = {version = "0.4.25", optional = true}
 rich = {version = "13.7.1", optional = true}
 litellm-enterprise = {version = "0.1.27", optional = true}
 diskcache = {version = "^5.6.1", optional = true}
@@ -126,6 +127,7 @@ semantic-router = ["semantic-router"]
 
 mlflow = ["mlflow"]
 
+google = ["google-cloud-aiplatform"]
 
 [tool.isort]
 profile = "black"
@@ -169,7 +171,7 @@ requires = ["poetry-core", "wheel"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.commitizen]
-version = "1.81.0"
+version = "1.81.1"
 version_files = [
     "pyproject.toml:^version"
 ]
diff --git a/requirements.txt b/requirements.txt
index 68b85c3935d..f8755aa0c48 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -10,7 +10,7 @@ uvicorn==0.31.1 # server dep
 gunicorn==23.0.0 # server dep
 fastuuid==0.13.5 # for uuid4
 uvloop==0.21.0 # uvicorn dep, gives us much better performance under load
-boto3==1.36.0 # aws bedrock/sagemaker calls
+boto3==1.40.53 # aws bedrock/sagemaker calls (has bedrock-agentcore-control, compatible with aioboto3)
 redis==5.2.1 # redis caching
 prisma==0.11.0 # for db
 nodejs-wheel-binaries==24.12.0 ## required by prisma for migrations, prevents runtime download (updated from nodejs-bin for security fixes)
@@ -49,7 +49,7 @@ sentry_sdk==2.21.0 # for sentry error handling
 detect-secrets==1.5.0 # Enterprise - secret detection / masking in LLM requests
 cryptography==44.0.1
 tzdata==2025.1 # IANA time zone database
-litellm-proxy-extras==0.4.23 # for proxy extras - e.g. prisma migrations
+litellm-proxy-extras==0.4.25 # for proxy extras - e.g. prisma migrations
 llm-sandbox==0.3.31 # for skill execution in sandbox
 ### LITELLM PACKAGE DEPENDENCIES
 python-dotenv==1.0.1 # for env
@@ -59,8 +59,8 @@ tokenizers==0.20.2 # for calculating usage
 click==8.1.7 # for proxy cli
 rich==13.7.1 # for litellm proxy cli
 jinja2==3.1.6 # for prompt templates
+aioboto3==15.5.0 # for async sagemaker calls (updated to match boto3 1.40.73)
 aiohttp==3.13.3 # for network calls
-aioboto3==13.4.0 # for async sagemaker calls
 tenacity==8.5.0  # for retrying requests, when litellm.num_retries set
 pydantic>=2.11,<3 # proxy + openai req. + mcp
 jsonschema>=4.23.0,<5.0.0 # validating json schema - aligned with openapi-core + mcp
diff --git a/scripts/health_check/health_check_client.py b/scripts/health_check/health_check_client.py
index 4848735bb7b..873727b4535 100644
--- a/scripts/health_check/health_check_client.py
+++ b/scripts/health_check/health_check_client.py
@@ -20,6 +20,17 @@ from typing import Dict, List, Optional, Tuple
 import httpx
 import yaml
 
+# Default prompt for health checks - exactly 100k characters
+# Generate a repeating pattern to reach exactly 100,000 characters
+_base_text = "This is a health check test prompt for LiteLLM proxy. "
+_repeat_count = (100000 // len(_base_text)) + 1
+_DEFAULT_COMPLETION_PROMPT = (_base_text * _repeat_count)[:100000]
+
+# Default embedding text - also exactly 100k characters
+_embedding_base_text = "This is a test for vectorization. "
+_embedding_repeat_count = (100000 // len(_embedding_base_text)) + 1
+_DEFAULT_EMBEDDING_TEXT = (_embedding_base_text * _embedding_repeat_count)[:100000]
+
 
 class LiteLLMHealthCheckClient:
     """Client for health checking LiteLLM proxy models."""
@@ -29,8 +40,9 @@ class LiteLLMHealthCheckClient:
         base_url: str,
         api_key: str,
         timeout: int = 120,  # Match Go implementation's 120s timeout
-        completion_prompt: str = "Say this is a test",  # Match Go implementation
-        embedding_text: str = "This is a test for vectorization.",  # Match Go implementation
+        completion_prompt: str = _DEFAULT_COMPLETION_PROMPT,  # Default ~100k chars
+        embedding_text: str = _DEFAULT_EMBEDDING_TEXT,  # Default ~100k chars
+        custom_auth_header: Optional[str] = None,
     ):
         """
         Initialize the health check client.
@@ -41,16 +53,34 @@ class LiteLLMHealthCheckClient:
             timeout: Request timeout in seconds (default: 120, matching Go implementation)
             completion_prompt: Test prompt for chat/completion models
             embedding_text: Test text for embedding models
+            custom_auth_header: Optional custom header name for authentication (e.g., "x-ifood-requester-service").
+                If provided, uses this header instead of standard "Authorization" header.
         """
         self.base_url = base_url.rstrip("/")
         self.api_key = api_key
         self.timeout = timeout
         self.completion_prompt = completion_prompt
         self.embedding_text = embedding_text
-        self.headers = {
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json",
-        }
+        
+        # Debug: Print prompt/text lengths
+        print(f"DEBUG: Completion prompt length: {len(self.completion_prompt)} characters", file=sys.stderr)
+        print(f"DEBUG: Embedding text length: {len(self.embedding_text)} characters", file=sys.stderr)
+        
+        # Support custom auth header for proxies with custom authentication
+        # Handle both None and empty string
+        if custom_auth_header and custom_auth_header.strip():
+            custom_auth_header = custom_auth_header.strip()
+            self.headers = {
+                custom_auth_header: f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            }
+            print(f"Using custom auth header: {custom_auth_header}", file=sys.stderr)
+        else:
+            self.headers = {
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            }
+            print("Using standard Authorization header", file=sys.stderr)
 
     def load_models_from_yaml(self, yaml_path: str) -> List[Dict]:
         """
@@ -182,6 +212,8 @@ class LiteLLMHealthCheckClient:
 
             if is_embedding:
                 # Test embedding endpoint (matching Go implementation)
+                embedding_text_length = len(self.embedding_text)
+                print(f"DEBUG: Sending embedding text of length {embedding_text_length} chars to model {model_id}", file=sys.stderr)
                 embedding_response = await client.post(
                     f"{self.base_url}/v1/embeddings",
                     headers=self.headers,
@@ -202,6 +234,8 @@ class LiteLLMHealthCheckClient:
                 result["dimensions"] = dimensions
             else:
                 # Test chat completion endpoint (matching Go implementation)
+                prompt_length = len(self.completion_prompt)
+                print(f"DEBUG: Sending prompt of length {prompt_length} chars to model {model_id}", file=sys.stderr)
                 completion_response = await client.post(
                     f"{self.base_url}/v1/chat/completions",
                     headers=self.headers,
@@ -358,6 +392,11 @@ async def main():
     base_url = os.environ.get("LITELLM_BASE_URL", "http://localhost:4000")
     api_key = os.environ.get("LITELLM_API_KEY", "sk-1234")
     yaml_path = os.environ.get("LITELLM_MODELS_YAML")
+    custom_auth_header = os.environ.get("LITELLM_CUSTOM_AUTH_HEADER")  # e.g., "x-ifood-requester-service"
+    
+    # Debug: Print custom auth header value if set
+    if custom_auth_header:
+        print(f"Custom auth header from env: '{custom_auth_header}'", file=sys.stderr)
 
     if not base_url:
         print("Error: LITELLM_BASE_URL environment variable not set", file=sys.stderr)
@@ -369,10 +408,10 @@ async def main():
 
     timeout = int(os.environ.get("LITELLM_TIMEOUT", "120"))  # Match Go's 120s default
     completion_prompt = os.environ.get(
-        "LITELLM_COMPLETION_PROMPT", "Say this is a test"
+        "LITELLM_COMPLETION_PROMPT", _DEFAULT_COMPLETION_PROMPT
     )
     embedding_text = os.environ.get(
-        "LITELLM_EMBEDDING_TEXT", "This is a test for vectorization."
+        "LITELLM_EMBEDDING_TEXT", _DEFAULT_EMBEDDING_TEXT
     )
     json_output = os.environ.get("LITELLM_JSON_OUTPUT", "").lower() == "true"
     # Optional: only health-check these model IDs (comma-separated). E.g.:
@@ -386,6 +425,7 @@ async def main():
         timeout=timeout,
         completion_prompt=completion_prompt,
         embedding_text=embedding_text,
+        custom_auth_header=custom_auth_header,
     )
 
     # Load models from YAML if provided, otherwise fetch from API
diff --git a/scripts/health_check/health_check_client_README.md b/scripts/health_check/health_check_client_README.md
index e3132499e04..41c7ab7c35d 100644
--- a/scripts/health_check/health_check_client_README.md
+++ b/scripts/health_check/health_check_client_README.md
@@ -30,6 +30,14 @@ export LITELLM_MODELS_YAML="/path/to/config.yaml"
 python scripts/health_check/health_check_client.py
 ```
 
+**Option 3: Use custom authentication header**
+```bash
+export LITELLM_BASE_URL="https://litellm.example.com"
+export LITELLM_API_KEY="your-api-key"
+export LITELLM_CUSTOM_AUTH_HEADER="x-custom-auth-header"
+python scripts/health_check/health_check_client.py
+```
+
 ### As a Docker Container
 
 1. Build the Docker image:
@@ -47,6 +55,16 @@ docker run --rm \
   litellm/litellm-health-check:latest
 ```
 
+3. Run with custom authentication header:
+
+```bash
+docker run --rm \
+  -e LITELLM_BASE_URL="https://litellm.example.com" \
+  -e LITELLM_API_KEY="your-api-key" \
+  -e LITELLM_CUSTOM_AUTH_HEADER="x-custom-auth-header" \
+  litellm/litellm-health-check:latest
+```
+
 ### Parallel Execution (Stress Testing)
 
 Run multiple health check containers in parallel:
@@ -65,6 +83,30 @@ export LITELLM_API_KEY="your-api-key"
 ./scripts/health_check/run_parallel_health_checks.sh 16
 ```
 
+**With Custom Auth Header:**
+```powershell
+$env:LITELLM_BASE_URL="https://litellm.example.com"
+$env:LITELLM_API_KEY="your-api-key"
+$env:LITELLM_CUSTOM_AUTH_HEADER="x-custom-auth-header"
+.\scripts\health_check\run_parallel_health_checks.ps1 16
+```
+
+**With Custom Docker Image:**
+```powershell
+$env:LITELLM_BASE_URL="https://litellm.example.com"
+$env:LITELLM_API_KEY="your-api-key"
+$env:LITELLM_CUSTOM_AUTH_HEADER="x-custom-auth-header"
+.\scripts\health_check\run_parallel_health_checks.ps1 -NumParallelJobs 16 -ImageName "your-registry/your-image:tag"
+```
+
+**Bash with Custom Image:**
+```bash
+export LITELLM_BASE_URL="https://litellm.example.com"
+export LITELLM_API_KEY="your-api-key"
+export LITELLM_CUSTOM_AUTH_HEADER="x-custom-auth-header"
+./scripts/health_check/run_parallel_health_checks.sh 16 "your-registry/your-image:tag"
+```
+
 
 ## Configuration
 
@@ -73,14 +115,29 @@ export LITELLM_API_KEY="your-api-key"
 - `LITELLM_BASE_URL` (required): Base URL of the LiteLLM proxy
   - Example: `https://litellm.example.com`
 - `LITELLM_API_KEY` (required): API key for authentication
+- `LITELLM_CUSTOM_AUTH_HEADER` (optional): Custom header name for authentication
+  - Use this when your LiteLLM proxy uses a custom authentication header instead of the standard `Authorization` header
+  - Example: `x-custom-auth-header` (the API key will be sent as `Bearer <api_key>` in this header)
 - `LITELLM_MODELS_YAML` (optional): Path to YAML config file with model_list
   - If provided, reads models from YAML instead of fetching from API
   - Example: `/path/to/config.yaml`
 - `LITELLM_TIMEOUT` (optional): Request timeout in seconds (default: 120)
-- `LITELLM_COMPLETION_PROMPT` (optional): Test prompt for chat/completion models (default: "Say this is a test")
-- `LITELLM_EMBEDDING_TEXT` (optional): Test text for embedding models (default: "This is a test for vectorization.")
+- `LITELLM_COMPLETION_PROMPT` (optional): Test prompt for chat/completion models (default: ~100k characters)
+- `LITELLM_EMBEDDING_TEXT` (optional): Test text for embedding models (default: ~100k characters)
 - `LITELLM_JSON_OUTPUT` (optional): Output results as JSON (default: false)
 
+### Parallel Script Parameters
+
+**PowerShell (`run_parallel_health_checks.ps1`):**
+- `-NumParallelJobs` (optional): Number of parallel containers to run (default: 16)
+- `-ImageName` (optional): Docker image to use (default: `litellm/litellm-health-check:latest`)
+- `-ContainerRuntime` (optional): Container runtime to use (default: `docker`)
+
+**Bash (`run_parallel_health_checks.sh`):**
+- `[num_parallel_jobs]` (optional): Number of parallel containers to run (default: 16)
+- `[image_name]` (optional): Docker image to use (default: `litellm/litellm-health-check:latest`)
+- `[container_runtime]` (optional): Container runtime to use (default: `docker`)
+
 ## Output
 
 ### Standard Output (Human-Readable)
@@ -166,7 +223,20 @@ Run multiple health checks in parallel:
 
 **PowerShell:**
 ```powershell
+# Using default image
 .\scripts\health_check\run_parallel_health_checks.ps1 16
+
+# Using custom image
+.\scripts\health_check\run_parallel_health_checks.ps1 -NumParallelJobs 16 -ImageName "your-registry/your-image:tag"
+```
+
+**Bash:**
+```bash
+# Using default image
+./scripts/health_check/run_parallel_health_checks.sh 16
+
+# Using custom image
+./scripts/health_check/run_parallel_health_checks.sh 16 "your-registry/your-image:tag"
 ```
 
 ### 3. CI/CD Integration
diff --git a/scripts/health_check/run_parallel_health_checks.ps1 b/scripts/health_check/run_parallel_health_checks.ps1
index 856e7f20ec9..850fc6baab6 100644
--- a/scripts/health_check/run_parallel_health_checks.ps1
+++ b/scripts/health_check/run_parallel_health_checks.ps1
@@ -49,6 +49,11 @@ Write-Host "    2. Set LITELLM_BASE_URL to the correct URL (e.g., http://host.do
 Write-Host "    3. On Linux, you may need to use the host IP instead of host.docker.internal" -ForegroundColor Yellow
 Write-Host ""
 
+# Capture environment variables in parent scope for use in parallel block
+$baseUrl = $env:LITELLM_BASE_URL
+$apiKey = $env:LITELLM_API_KEY
+$customAuthHeader = $env:LITELLM_CUSTOM_AUTH_HEADER
+
 # Run parallel health checks
 # This creates an infinite loop that keeps spawning containers
 # Each container tests all models, then exits, and a new one starts
@@ -57,13 +62,20 @@ while ($true) {
     1..$NumParallelJobs | ForEach-Object -Parallel {
         $runtime = $using:ContainerRuntime
         $imageName = $using:ImageName
-        $baseUrl = $env:LITELLM_BASE_URL
-        $apiKey = $env:LITELLM_API_KEY
+        $baseUrl = $using:baseUrl
+        $apiKey = $using:apiKey
+        $customAuthHeader = $using:customAuthHeader
         
-        & $runtime run --rm `
-            -e LITELLM_BASE_URL="$baseUrl" `
-            -e LITELLM_API_KEY="$apiKey" `
-            -e LITELLM_JSON_OUTPUT="true" `
-            $imageName
+        $envVars = @(
+            "-e", "LITELLM_BASE_URL=$baseUrl",
+            "-e", "LITELLM_API_KEY=$apiKey",
+            "-e", "LITELLM_JSON_OUTPUT=true"
+        )
+        
+        if ($customAuthHeader) {
+            $envVars += "-e", "LITELLM_CUSTOM_AUTH_HEADER=$customAuthHeader"
+        }
+        
+        & $runtime run --rm $envVars $imageName
     } -ThrottleLimit $NumParallelJobs
 }
diff --git a/scripts/health_check/run_parallel_health_checks.sh b/scripts/health_check/run_parallel_health_checks.sh
index 9b6c5d9f393..d1913e3fdd6 100644
--- a/scripts/health_check/run_parallel_health_checks.sh
+++ b/scripts/health_check/run_parallel_health_checks.sh
@@ -54,11 +54,18 @@ echo ""
 
 # Function to run a single health check container
 run_health_check() {
-    "$CONTAINER_RUNTIME" run --rm \
-        -e LITELLM_BASE_URL="$LITELLM_BASE_URL" \
-        -e LITELLM_API_KEY="$LITELLM_API_KEY" \
-        -e LITELLM_JSON_OUTPUT="true" \
-        "$IMAGE_NAME"
+    local env_vars=(
+        -e "LITELLM_BASE_URL=$LITELLM_BASE_URL"
+        -e "LITELLM_API_KEY=$LITELLM_API_KEY"
+        -e "LITELLM_JSON_OUTPUT=true"
+    )
+    
+    # Pass through custom auth header if set
+    if [ -n "$LITELLM_CUSTOM_AUTH_HEADER" ]; then
+        env_vars+=(-e "LITELLM_CUSTOM_AUTH_HEADER=$LITELLM_CUSTOM_AUTH_HEADER")
+    fi
+    
+    "$CONTAINER_RUNTIME" run --rm "${env_vars[@]}" "$IMAGE_NAME"
 }
 
 # Run parallel health checks
diff --git a/taplo.toml b/taplo.toml
new file mode 100644
index 00000000000..e5065a69616
--- /dev/null
+++ b/taplo.toml
@@ -0,0 +1,23 @@
+[formatting]
+
+# Keep your table/key order as written (project, project.scripts, dependency-groups, tool.uv, ...)
+reorder_keys = false
+
+# Force arrays to stay multiline once expanded
+array_auto_expand = true
+array_auto_collapse = false
+
+# Keep nice spacing inside arrays and inline tables
+compact_arrays = false
+compact_inline_tables = true
+
+# Don’t align `=` vertically (matches your example)
+align_entries = true
+
+# Reasonable defaults
+align_comments = true
+trailing_newline = true
+reorder_arrays = true
+reorder_inline_tables = false
+allowed_blank_lines = 2
+crlf = false
diff --git a/tests/documentation_tests/test_env_keys.py b/tests/documentation_tests/test_env_keys.py
index 6b7c15e2b9d..4fed84d0431 100644
--- a/tests/documentation_tests/test_env_keys.py
+++ b/tests/documentation_tests/test_env_keys.py
@@ -16,6 +16,25 @@ get_secret_str_pattern = re.compile(
 # Set to store unique keys from the code
 env_keys = set()
 
+# Terminal/environment detection variables that should not be documented
+# These are internal variables used for terminal detection, not user-configurable settings
+EXCLUDED_TERMINAL_VARS = {
+    "TERM",
+    "TERM_PROGRAM",
+    "TERM_PROGRAM_VERSION",
+    "TERM_SESSION_ID",
+    "VTE_VERSION",
+    "KITTY_WINDOW_ID",
+    "KONSOLE_VERSION",
+    "ITERM_PROFILE",
+    "ITERM_PROFILE_NAME",
+    "ITERM_SESSION_ID",
+    "WEZTERM_VERSION",
+    "WT_SESSION",
+    "GNOME_TERMINAL_SCREEN",
+    "ALACRITTY_SOCKET",
+}
+
 # Walk through all files in the litellm repo to find references of os.getenv() and litellm.get_secret()
 for root, dirs, files in os.walk(repo_base):
     for file in files:
@@ -28,7 +47,8 @@ for root, dirs, files in os.walk(repo_base):
                 getenv_matches = getenv_pattern.findall(content)
                 env_keys.update(
                     match for match in getenv_matches
-                )  # Extract only the key part
+                    if match not in EXCLUDED_TERMINAL_VARS
+                )  # Extract only the key part, excluding terminal vars
 
                 # Find all keys using litellm.get_secret()
                 get_secret_matches = get_secret_pattern.findall(content)
diff --git a/tests/guardrails_tests/test_bedrock_guardrails.py b/tests/guardrails_tests/test_bedrock_guardrails.py
index 1795ff23605..cb594c221c4 100644
--- a/tests/guardrails_tests/test_bedrock_guardrails.py
+++ b/tests/guardrails_tests/test_bedrock_guardrails.py
@@ -1139,17 +1139,16 @@ async def test_convert_to_bedrock_format_post_call_streaming_hook():
             result_chunks.append(chunk)
 
         # Verify bedrock API calls were made
+        # Note: When event_hook is None (default), the guardrail is considered enabled for all hooks.
+        # In post_call, INPUT validation is skipped if pre_call/during_call is already enabled
+        # to avoid redundant validation. Since event_hook=None means all hooks are enabled,
+        # only OUTPUT validation should be performed in post_call.
         assert (
-            len(bedrock_calls) == 2
-        ), f"Expected 2 bedrock calls (INPUT and OUTPUT), got {len(bedrock_calls)}"
+            len(bedrock_calls) == 1
+        ), f"Expected 1 bedrock call (OUTPUT only), got {len(bedrock_calls)}"
 
-        # Find the OUTPUT call
-        output_calls = [call for call in bedrock_calls if call["source"] == "OUTPUT"]
-        assert (
-            len(output_calls) == 1
-        ), f"Expected 1 OUTPUT call, got {len(output_calls)}"
-
-        output_call = output_calls[0]
+        # Verify the OUTPUT call
+        output_call = bedrock_calls[0]
         assert output_call["source"] == "OUTPUT"
         assert output_call["response"] is not None
         assert output_call["messages"] is None  # OUTPUT calls don't need messages
@@ -1176,7 +1175,10 @@ async def test_convert_to_bedrock_format_post_call_streaming_hook():
         print(
             "✅ Post-call streaming hook test passed - OUTPUT source used for masking"
         )
-        print(f"✅ Bedrock calls made: {[call['source'] for call in bedrock_calls]}")
+        print(
+            f"✅ Bedrock calls made: {[call['source'] for call in bedrock_calls]} "
+            "(INPUT validation skipped due to event_hook=None implying pre_call/during_call enabled)"
+        )
         print(f"✅ Final masked content: {full_content}")
 
 
diff --git a/tests/litellm_core_utils/test_anthropic_dedup_factory.py b/tests/litellm_core_utils/test_anthropic_dedup_factory.py
new file mode 100644
index 00000000000..99248db0aec
--- /dev/null
+++ b/tests/litellm_core_utils/test_anthropic_dedup_factory.py
@@ -0,0 +1,83 @@
+
+import sys
+import os
+import pytest
+sys.path.insert(0, os.path.abspath("."))
+
+from litellm.litellm_core_utils.prompt_templates.factory import anthropic_messages_pt
+
+def test_anthropic_deduplication_logic():
+    """
+    Verify that anthropic_messages_pt correctly deduplicates tool calls
+    when merging consecutive assistant messages.
+    
+    Scenario:
+    - User message
+    - Assistant message with tool call A
+    - Assistant message (merged) with tool call A (duplicate) and tool call B (new)
+    
+    Expected Result:
+    - Assistant message contains tool call A and tool call B exactly once.
+    """
+    messages = [
+        {"role": "user", "content": "Weather in Paris?"},
+        {
+            "role": "assistant",
+            "content": None,
+            "tool_calls": [
+                {
+                    "id": "tool_call_unique_1",
+                    "type": "function",
+                    "function": {"name": "get_weather", "arguments": "{}"}
+                }
+            ]
+        },
+        {
+            "role": "assistant", 
+            "content": None,
+            "tool_calls": [
+                {
+                    "id": "tool_call_unique_1", # Duplicate! Should be removed
+                    "type": "function",
+                    "function": {"name": "get_weather", "arguments": "{}"}
+                },
+                {
+                    "id": "tool_call_unique_2", # New! Should be kept
+                    "type": "function",
+                    "function": {"name": "get_time", "arguments": "{}"}
+                }
+            ]
+        }
+    ]
+
+    # Run transformation
+    # We pass dummy model/provider args as they are required but valid for this test
+    result = anthropic_messages_pt(
+        messages=messages,
+        model="claude-3-opus-20240229", 
+        llm_provider="anthropic"
+    )
+
+    # Inspect results
+    # We expect 1 user message and 1 merged assistant message
+    assert len(result) == 2
+    assert result[0]["role"] == "user"
+    assert result[1]["role"] == "assistant"
+
+    assistant_content = result[1]["content"]
+    
+    # Filter for tool_use blocks
+    tool_uses = [
+        b for b in assistant_content 
+        if isinstance(b, dict) and b.get("type") == "tool_use"
+    ]
+
+    # We expect exactly 2 tool uses (one for unique_1, one for unique_2)
+    # The duplicate unique_1 should be gone.
+    assert len(tool_uses) == 2
+    
+    ids = [t["id"] for t in tool_uses]
+    assert "tool_call_unique_1" in ids
+    assert "tool_call_unique_2" in ids
+    assert ids.count("tool_call_unique_1") == 1
+    assert ids.count("tool_call_unique_2") == 1
diff --git a/tests/litellm_utils_tests/base_token_counter_test.py b/tests/litellm_utils_tests/base_token_counter_test.py
new file mode 100644
index 00000000000..b5e87021a0b
--- /dev/null
+++ b/tests/litellm_utils_tests/base_token_counter_test.py
@@ -0,0 +1,130 @@
+"""
+Base Token Counter Test Suite.
+
+This module provides an abstract base test class that enforces common tests
+across all token counter implementations. Similar to base_llm_unit_tests.py
+for LLM chat tests.
+
+Usage:
+    Create a test class that inherits from BaseTokenCounterTest and implement
+    the abstract methods to provide provider-specific configuration.
+"""
+
+import os
+import sys
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+import pytest
+
+sys.path.insert(
+    0, os.path.abspath("../..")
+)  # Adds the parent directory to the system path
+
+from litellm.llms.base_llm.base_utils import BaseTokenCounter
+from litellm.types.utils import TokenCountResponse
+
+
+class BaseTokenCounterTest(ABC):
+    """
+    Abstract base test class for token counter implementations.
+
+    Subclasses must implement:
+        - get_token_counter(): Returns the token counter instance
+        - get_test_model(): Returns the model name to use for testing
+        - get_test_messages(): Returns test messages for token counting
+        - get_deployment_config(): Returns deployment configuration with credentials
+        - get_custom_llm_provider(): Returns the provider name for should_use_token_counting_api
+    """
+
+    @abstractmethod
+    def get_token_counter(self) -> BaseTokenCounter:
+        """Must return the token counter instance to test."""
+        pass
+
+    @abstractmethod
+    def get_test_model(self) -> str:
+        """Must return the model name to use for testing."""
+        pass
+
+    @abstractmethod
+    def get_test_messages(self) -> List[Dict[str, Any]]:
+        """Must return test messages for token counting."""
+        pass
+
+    @abstractmethod
+    def get_deployment_config(self) -> Dict[str, Any]:
+        """Must return deployment configuration with credentials."""
+        pass
+
+    @abstractmethod
+    def get_custom_llm_provider(self) -> str:
+        """Must return the provider name for should_use_token_counting_api check."""
+        pass
+
+    @pytest.fixture(autouse=True)
+    def _handle_missing_credentials(self):
+        """Fixture to skip tests when credentials are missing."""
+        try:
+            yield
+        except Exception as e:
+            error_str = str(e).lower()
+            if "api key" in error_str or "api_key" in error_str or "unauthorized" in error_str:
+                pytest.skip(f"Missing or invalid credentials: {e}")
+            raise
+
+    @pytest.mark.asyncio
+    async def test_count_tokens_basic(self):
+        """
+        Test basic token counting functionality.
+
+        Verifies that:
+        - Token counter returns a TokenCountResponse
+        - total_tokens is greater than 0
+        - tokenizer_type is set
+        - No error occurred
+        """
+        token_counter = self.get_token_counter()
+        model = self.get_test_model()
+        messages = self.get_test_messages()
+        deployment = self.get_deployment_config()
+
+        result = await token_counter.count_tokens(
+            model_to_use=model,
+            messages=messages,
+            contents=None,
+            deployment=deployment,
+            request_model=model,
+        )
+
+        print(f"Token count result: {result}")
+
+        assert result is not None, "Token counter should return a result"
+        assert isinstance(result, TokenCountResponse), "Result should be TokenCountResponse"
+        assert result.total_tokens > 0, f"Token count should be > 0, got {result.total_tokens}"
+        assert result.tokenizer_type is not None, "tokenizer_type should be set"
+        assert result.error is not True, f"Token counting should not error: {result.error_message}"
+
+    def test_should_use_token_counting_api(self):
+        """
+        Test that should_use_token_counting_api returns True for the correct provider.
+
+        Verifies that the token counter correctly identifies when it should be used
+        based on the custom_llm_provider.
+        """
+        token_counter = self.get_token_counter()
+        provider = self.get_custom_llm_provider()
+
+        result = token_counter.should_use_token_counting_api(
+            custom_llm_provider=provider
+        )
+
+        assert result is True, f"should_use_token_counting_api should return True for {provider}"
+
+        # Also verify it returns False for other providers
+        other_provider = "some_other_provider_that_doesnt_exist"
+        result_other = token_counter.should_use_token_counting_api(
+            custom_llm_provider=other_provider
+        )
+
+        assert result_other is False, f"should_use_token_counting_api should return False for {other_provider}"
diff --git a/tests/litellm_utils_tests/test_anthropic_token_counter.py b/tests/litellm_utils_tests/test_anthropic_token_counter.py
new file mode 100644
index 00000000000..a1fbcecfdd4
--- /dev/null
+++ b/tests/litellm_utils_tests/test_anthropic_token_counter.py
@@ -0,0 +1,47 @@
+"""
+Anthropic Token Counter Tests.
+
+Tests for the Anthropic token counter implementation using the base test suite.
+"""
+
+import os
+import sys
+from typing import Any, Dict, List
+
+import pytest
+
+sys.path.insert(
+    0, os.path.abspath("../..")
+)  # Adds the parent directory to the system path
+
+from litellm.llms.anthropic.count_tokens import AnthropicTokenCounter
+from litellm.llms.base_llm.base_utils import BaseTokenCounter
+from tests.litellm_utils_tests.base_token_counter_test import BaseTokenCounterTest
+
+
+class TestAnthropicTokenCounter(BaseTokenCounterTest):
+    """Test suite for Anthropic token counter."""
+
+    def get_token_counter(self) -> BaseTokenCounter:
+        return AnthropicTokenCounter()
+
+    def get_test_model(self) -> str:
+        return "claude-sonnet-4-20250514"
+
+    def get_test_messages(self) -> List[Dict[str, Any]]:
+        return [
+            {"role": "user", "content": "Hello, how are you today?"}
+        ]
+
+    def get_deployment_config(self) -> Dict[str, Any]:
+        api_key = os.getenv("ANTHROPIC_API_KEY")
+        if not api_key:
+            pytest.skip("ANTHROPIC_API_KEY not set")
+        return {
+            "litellm_params": {
+                "api_key": api_key,
+            }
+        }
+
+    def get_custom_llm_provider(self) -> str:
+        return "anthropic"
diff --git a/tests/litellm_utils_tests/test_azure_ai_anthropic_token_counter.py b/tests/litellm_utils_tests/test_azure_ai_anthropic_token_counter.py
new file mode 100644
index 00000000000..031502cbece
--- /dev/null
+++ b/tests/litellm_utils_tests/test_azure_ai_anthropic_token_counter.py
@@ -0,0 +1,53 @@
+"""
+Azure AI Anthropic Token Counter Tests.
+
+Tests for the Azure AI Anthropic token counter implementation using the base test suite.
+"""
+
+import os
+import sys
+from typing import Any, Dict, List
+
+import pytest
+
+sys.path.insert(
+    0, os.path.abspath("../..")
+)  # Adds the parent directory to the system path
+
+from litellm.llms.azure_ai.anthropic.count_tokens import AzureAIAnthropicTokenCounter
+from litellm.llms.base_llm.base_utils import BaseTokenCounter
+from tests.litellm_utils_tests.base_token_counter_test import BaseTokenCounterTest
+
+
+class TestAzureAIAnthropicTokenCounter(BaseTokenCounterTest):
+    """Test suite for Azure AI Anthropic token counter."""
+
+    def get_token_counter(self) -> BaseTokenCounter:
+        return AzureAIAnthropicTokenCounter()
+
+    def get_test_model(self) -> str:
+        return "claude-3-5-sonnet"
+
+    def get_test_messages(self) -> List[Dict[str, Any]]:
+        return [
+            {"role": "user", "content": "Hello, how are you today?"}
+        ]
+
+    def get_deployment_config(self) -> Dict[str, Any]:
+        api_key = os.getenv("AZURE_AI_API_KEY")
+        api_base = os.getenv("AZURE_AI_API_BASE")
+        
+        if not api_key:
+            pytest.skip("AZURE_AI_API_KEY not set")
+        if not api_base:
+            pytest.skip("AZURE_AI_API_BASE not set")
+            
+        return {
+            "litellm_params": {
+                "api_key": api_key,
+                "api_base": api_base,
+            }
+        }
+
+    def get_custom_llm_provider(self) -> str:
+        return "azure_ai"
diff --git a/tests/litellm_utils_tests/test_bedrock_token_counter.py b/tests/litellm_utils_tests/test_bedrock_token_counter.py
new file mode 100644
index 00000000000..f7c29918820
--- /dev/null
+++ b/tests/litellm_utils_tests/test_bedrock_token_counter.py
@@ -0,0 +1,101 @@
+"""
+Bedrock Token Counter Tests.
+
+Tests for the Bedrock token counter implementation using the base test suite.
+
+Note: Not all Bedrock models support token counting. The CountTokens API
+is only available for specific models. If the model doesn't support token
+counting, the test will be skipped.
+"""
+
+import os
+import sys
+from typing import Any, Dict, List
+
+import pytest
+
+sys.path.insert(
+    0, os.path.abspath("../..")
+)  # Adds the parent directory to the system path
+
+from litellm.llms.base_llm.base_utils import BaseTokenCounter
+from litellm.llms.bedrock.count_tokens.bedrock_token_counter import BedrockTokenCounter
+from tests.litellm_utils_tests.base_token_counter_test import BaseTokenCounterTest
+
+
+class TestBedrockTokenCounter(BaseTokenCounterTest):
+    """Test suite for Bedrock token counter.
+    
+    Note: Bedrock CountTokens API support varies by model. Some models
+    (like older Claude versions) may not support token counting.
+    Use amazon.nova-* models for reliable token counting support.
+    """
+
+    def get_token_counter(self) -> BaseTokenCounter:
+        return BedrockTokenCounter()
+
+    def get_test_model(self) -> str:
+        # Use Amazon Nova model which supports token counting
+        # Alternatively, use environment variable to override
+        return os.getenv("BEDROCK_TEST_MODEL", "amazon.nova-lite-v1:0")
+
+    def get_test_messages(self) -> List[Dict[str, Any]]:
+        return [
+            {"role": "user", "content": "Hello, how are you today?"}
+        ]
+
+    def get_deployment_config(self) -> Dict[str, Any]:
+        # Bedrock uses AWS credentials from environment
+        # Check for AWS credentials
+        aws_access_key = os.getenv("AWS_ACCESS_KEY_ID")
+        aws_secret_key = os.getenv("AWS_SECRET_ACCESS_KEY")
+        aws_region = os.getenv("AWS_REGION_NAME", "us-east-1")
+        
+        if not aws_access_key or not aws_secret_key:
+            pytest.skip("AWS credentials not set (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)")
+            
+        return {
+            "litellm_params": {
+                "aws_access_key_id": aws_access_key,
+                "aws_secret_access_key": aws_secret_key,
+                "aws_region_name": aws_region,
+            }
+        }
+
+    def get_custom_llm_provider(self) -> str:
+        return "bedrock"
+
+    @pytest.mark.asyncio
+    async def test_count_tokens_basic(self):
+        """
+        Test basic token counting functionality.
+        
+        Override to handle models that don't support token counting.
+        """
+        from litellm.types.utils import TokenCountResponse
+
+        token_counter = self.get_token_counter()
+        model = self.get_test_model()
+        messages = self.get_test_messages()
+        deployment = self.get_deployment_config()
+
+        result = await token_counter.count_tokens(
+            model_to_use=model,
+            messages=messages,
+            contents=None,
+            deployment=deployment,
+            request_model=model,
+        )
+
+        print(f"Token count result: {result}")
+
+        assert result is not None, "Token counter should return a result"
+        assert isinstance(result, TokenCountResponse), "Result should be TokenCountResponse"
+        
+        # Check if the model doesn't support token counting
+        if result.error and "doesn't support counting tokens" in str(result.error_message):
+            pytest.skip(f"Model {model} doesn't support token counting: {result.error_message}")
+        
+        assert result.total_tokens > 0, f"Token count should be > 0, got {result.total_tokens}"
+        assert result.tokenizer_type is not None, "tokenizer_type should be set"
+        assert result.error is not True, f"Token counting should not error: {result.error_message}"
diff --git a/tests/llm_translation/test_bedrock_agentcore.py b/tests/llm_translation/test_bedrock_agentcore.py
index 3afb01482ac..f00ceb8eab4 100644
--- a/tests/llm_translation/test_bedrock_agentcore.py
+++ b/tests/llm_translation/test_bedrock_agentcore.py
@@ -12,10 +12,9 @@ sys.path.insert(
 )
 
 import litellm
-from unittest.mock import MagicMock, patch
-import pytest
-
+from unittest.mock import MagicMock, Mock, patch
 import pytest
+import httpx
 
 @pytest.mark.parametrize(
     "model", [
@@ -367,3 +366,279 @@ def test_bedrock_agentcore_without_api_key_uses_sigv4():
         assert "X-Amzn-Bedrock-AgentCore-Runtime-Session-Id" in headers
         assert headers["X-Amzn-Bedrock-AgentCore-Runtime-Session-Id"] == "sigv4-test-session"
 
+
+def test_agentcore_parse_json_response():
+    """
+    Unit test for JSON response parsing (non-streaming)
+    Verifies that content-type: application/json responses are parsed correctly
+    """
+    from litellm.llms.bedrock.chat.agentcore.transformation import AmazonAgentCoreConfig
+
+    config = AmazonAgentCoreConfig()
+
+    # Create a mock JSON response
+    mock_response = Mock(spec=httpx.Response)
+    mock_response.headers = {"content-type": "application/json"}
+    mock_response.json.return_value = {
+        "result": {
+            "role": "assistant",
+            "content": [{"text": "Hello from JSON response"}]
+        }
+    }
+
+    # Parse the response
+    parsed = config._get_parsed_response(mock_response)
+
+    # Verify content extraction
+    assert parsed["content"] == "Hello from JSON response"
+    # JSON responses don't include usage data
+    assert parsed["usage"] is None
+    # Final message should be the result object
+    assert parsed["final_message"] == mock_response.json.return_value["result"]
+
+
+def test_agentcore_parse_sse_response():
+    """
+    Unit test for SSE response parsing (streaming response consumed as text)
+    Verifies that text/event-stream responses are parsed correctly
+    """
+    from litellm.llms.bedrock.chat.agentcore.transformation import AmazonAgentCoreConfig
+
+    config = AmazonAgentCoreConfig()
+
+    # Create a mock SSE response with multiple events
+    sse_data = """data: {"event":{"contentBlockDelta":{"delta":{"text":"Hello "}}}}
+
+data: {"event":{"contentBlockDelta":{"delta":{"text":"from SSE"}}}}
+
+data: {"event":{"metadata":{"usage":{"inputTokens":10,"outputTokens":5,"totalTokens":15}}}}
+
+data: {"message":{"role":"assistant","content":[{"text":"Hello from SSE"}]}}
+"""
+
+    mock_response = Mock(spec=httpx.Response)
+    mock_response.headers = {"content-type": "text/event-stream"}
+    mock_response.text = sse_data
+
+    # Parse the response
+    parsed = config._get_parsed_response(mock_response)
+
+    # Verify content extraction from final message
+    assert parsed["content"] == "Hello from SSE"
+    # SSE responses can include usage data
+    assert parsed["usage"] is not None
+    assert parsed["usage"]["inputTokens"] == 10
+    assert parsed["usage"]["outputTokens"] == 5
+    assert parsed["usage"]["totalTokens"] == 15
+    # Final message should be present
+    assert parsed["final_message"] is not None
+    assert parsed["final_message"]["role"] == "assistant"
+
+
+def test_agentcore_parse_sse_response_without_final_message():
+    """
+    Unit test for SSE response parsing when only deltas are present (no final message)
+    """
+    from litellm.llms.bedrock.chat.agentcore.transformation import AmazonAgentCoreConfig
+
+    config = AmazonAgentCoreConfig()
+
+    # Create a mock SSE response with only content deltas
+    sse_data = """data: {"event":{"contentBlockDelta":{"delta":{"text":"First "}}}}
+
+data: {"event":{"contentBlockDelta":{"delta":{"text":"second "}}}}
+
+data: {"event":{"contentBlockDelta":{"delta":{"text":"third"}}}}
+"""
+
+    mock_response = Mock(spec=httpx.Response)
+    mock_response.headers = {"content-type": "text/event-stream"}
+    mock_response.text = sse_data
+
+    # Parse the response
+    parsed = config._get_parsed_response(mock_response)
+
+    # Content should be concatenated from deltas
+    assert parsed["content"] == "First second third"
+    # No final message
+    assert parsed["final_message"] is None
+
+
+def test_agentcore_transform_response_json():
+    """
+    Integration test for transform_response with JSON response
+    Verifies end-to-end transformation of JSON responses to ModelResponse
+    """
+    from litellm.llms.bedrock.chat.agentcore.transformation import AmazonAgentCoreConfig
+    from litellm.types.utils import ModelResponse
+
+    config = AmazonAgentCoreConfig()
+
+    # Create mock JSON response
+    mock_response = Mock(spec=httpx.Response)
+    mock_response.headers = {"content-type": "application/json"}
+    mock_response.json.return_value = {
+        "result": {
+            "role": "assistant",
+            "content": [{"text": "Response from transform_response"}]
+        }
+    }
+    mock_response.status_code = 200
+
+    # Create model response
+    model_response = ModelResponse()
+
+    # Mock logging object
+    mock_logging = MagicMock()
+
+    # Transform the response
+    result = config.transform_response(
+        model="bedrock/agentcore/arn:aws:bedrock-agentcore:us-west-2:123456789012:runtime/test",
+        raw_response=mock_response,
+        model_response=model_response,
+        logging_obj=mock_logging,
+        request_data={},
+        messages=[{"role": "user", "content": "test"}],
+        optional_params={},
+        litellm_params={},
+        encoding=None,
+    )
+
+    # Verify ModelResponse structure
+    assert len(result.choices) == 1
+    assert result.choices[0].message.content == "Response from transform_response"
+    assert result.choices[0].message.role == "assistant"
+    assert result.choices[0].finish_reason == "stop"
+    assert result.choices[0].index == 0
+
+
+def test_agentcore_transform_response_sse():
+    """
+    Integration test for transform_response with SSE response
+    Verifies end-to-end transformation of SSE responses to ModelResponse
+    """
+    from litellm.llms.bedrock.chat.agentcore.transformation import AmazonAgentCoreConfig
+    from litellm.types.utils import ModelResponse
+
+    config = AmazonAgentCoreConfig()
+
+    # Create mock SSE response
+    sse_data = """data: {"event":{"contentBlockDelta":{"delta":{"text":"SSE "}}}}
+
+data: {"event":{"contentBlockDelta":{"delta":{"text":"response"}}}}
+
+data: {"event":{"metadata":{"usage":{"inputTokens":20,"outputTokens":10,"totalTokens":30}}}}
+
+data: {"message":{"role":"assistant","content":[{"text":"SSE response"}]}}
+"""
+
+    mock_response = Mock(spec=httpx.Response)
+    mock_response.headers = {"content-type": "text/event-stream"}
+    mock_response.text = sse_data
+    mock_response.status_code = 200
+
+    # Create model response
+    model_response = ModelResponse()
+
+    # Mock logging object
+    mock_logging = MagicMock()
+
+    # Transform the response
+    result = config.transform_response(
+        model="bedrock/agentcore/arn:aws:bedrock-agentcore:us-west-2:123456789012:runtime/test",
+        raw_response=mock_response,
+        model_response=model_response,
+        logging_obj=mock_logging,
+        request_data={},
+        messages=[{"role": "user", "content": "test"}],
+        optional_params={},
+        litellm_params={},
+        encoding=None,
+    )
+
+    # Verify ModelResponse structure
+    assert len(result.choices) == 1
+    assert result.choices[0].message.content == "SSE response"
+    assert result.choices[0].message.role == "assistant"
+    assert result.choices[0].finish_reason == "stop"
+
+    # Verify usage data from SSE metadata
+    assert hasattr(result, "usage")
+    assert result.usage.prompt_tokens == 20
+    assert result.usage.completion_tokens == 10
+    assert result.usage.total_tokens == 30
+
+
+def test_agentcore_synchronous_non_streaming_response():
+    """
+    Test that synchronous (non-streaming) AgentCore calls still work correctly
+    after streaming simplification changes.
+
+    This test verifies:
+    1. Synchronous completion calls work (stream=False or no stream param)
+    2. Response is properly parsed and returned as ModelResponse
+    3. Content is extracted correctly
+    4. Usage data is calculated when not provided by API
+
+    This is a regression test for the streaming simplification changes
+    to ensure we didn't break the non-streaming code path.
+    """
+    from litellm.llms.custom_httpx.http_handler import HTTPHandler
+
+    litellm._turn_on_debug()
+    client = HTTPHandler()
+
+    # Mock a JSON response (typical for synchronous AgentCore calls)
+    mock_json_response = {
+        "result": {
+            "role": "assistant",
+            "content": [{"text": "This is a synchronous response from AgentCore."}]
+        }
+    }
+
+    # Create a mock response object
+    mock_response = Mock(spec=httpx.Response)
+    mock_response.status_code = 200
+    mock_response.headers = {"content-type": "application/json"}
+    mock_response.json.return_value = mock_json_response
+
+    with patch.object(client, "post", return_value=mock_response) as mock_post:
+        # Make a synchronous (non-streaming) completion call
+        response = litellm.completion(
+            model="bedrock/agentcore/arn:aws:bedrock-agentcore:us-west-2:888602223428:runtime/hosted_agent_r9jvp-3ySZuRHjLC",
+            messages=[
+                {
+                    "role": "user",
+                    "content": "Test synchronous response",
+                }
+            ],
+            stream=False,  # Explicitly disable streaming
+            client=client,
+        )
+
+        # Verify the response structure
+        assert response is not None
+        assert hasattr(response, "choices")
+        assert len(response.choices) > 0
+
+        # Verify content
+        message = response.choices[0].message
+        assert message is not None
+        assert message.content == "This is a synchronous response from AgentCore."
+        assert message.role == "assistant"
+
+        # Verify completion metadata
+        assert response.choices[0].finish_reason == "stop"
+        assert response.choices[0].index == 0
+
+        # Verify usage data exists (either from API or calculated)
+        assert hasattr(response, "usage")
+        assert response.usage is not None
+        assert response.usage.prompt_tokens > 0
+        assert response.usage.completion_tokens > 0
+        assert response.usage.total_tokens > 0
+
+        print(f"Synchronous response: {response}")
+        print(f"Content: {message.content}")
+        print(f"Usage: prompt={response.usage.prompt_tokens}, completion={response.usage.completion_tokens}, total={response.usage.total_tokens}")
+
diff --git a/tests/local_testing/test_amazing_vertex_completion.py b/tests/local_testing/test_amazing_vertex_completion.py
index 0373f5f4356..af8942f89eb 100644
--- a/tests/local_testing/test_amazing_vertex_completion.py
+++ b/tests/local_testing/test_amazing_vertex_completion.py
@@ -1386,14 +1386,15 @@ async def test_gemini_pro_json_schema_args_sent_httpx(
             print(mock_call.call_args.kwargs["json"]["generationConfig"])
 
             if supports_response_schema:
+                # Gemini 2.x+ uses response_json_schema, Gemini 1.x uses response_schema
+                gen_config = mock_call.call_args.kwargs["json"]["generationConfig"]
                 assert (
-                    "response_schema"
-                    in mock_call.call_args.kwargs["json"]["generationConfig"]
-                )
+                    "response_schema" in gen_config or "response_json_schema" in gen_config
+                ), f"Expected response_schema or response_json_schema in {gen_config}"
             else:
+                gen_config = mock_call.call_args.kwargs["json"]["generationConfig"]
                 assert (
-                    "response_schema"
-                    not in mock_call.call_args.kwargs["json"]["generationConfig"]
+                    "response_schema" not in gen_config and "response_json_schema" not in gen_config
                 )
                 assert (
                     "Use this JSON schema:"
@@ -1566,10 +1567,11 @@ async def test_gemini_pro_json_schema_args_sent_httpx_openai_schema(
             print(mock_call.call_args.kwargs["json"]["generationConfig"])
 
             if supports_response_schema:
+                # Gemini 2.x+ uses response_json_schema, Gemini 1.x uses response_schema
+                gen_config = mock_call.call_args.kwargs["json"]["generationConfig"]
                 assert (
-                    "response_schema"
-                    in mock_call.call_args.kwargs["json"]["generationConfig"]
-                )
+                    "response_schema" in gen_config or "response_json_schema" in gen_config
+                ), f"Expected response_schema or response_json_schema in {gen_config}"
                 assert (
                     "response_mime_type"
                     in mock_call.call_args.kwargs["json"]["generationConfig"]
@@ -1581,9 +1583,9 @@ async def test_gemini_pro_json_schema_args_sent_httpx_openai_schema(
                     == "application/json"
                 )
             else:
+                gen_config = mock_call.call_args.kwargs["json"]["generationConfig"]
                 assert (
-                    "response_schema"
-                    not in mock_call.call_args.kwargs["json"]["generationConfig"]
+                    "response_schema" not in gen_config and "response_json_schema" not in gen_config
                 )
                 assert (
                     "Use this JSON schema:"
diff --git a/tests/local_testing/test_gcs_bucket.py b/tests/local_testing/test_gcs_bucket.py
index 2f7d5cd0dec..e2f51eb76c7 100644
--- a/tests/local_testing/test_gcs_bucket.py
+++ b/tests/local_testing/test_gcs_bucket.py
@@ -29,6 +29,7 @@ def load_vertex_ai_credentials():
     # Define the path to the vertex_key.json file
     print("loading vertex ai credentials")
     os.environ["GCS_FLUSH_INTERVAL"] = "1"
+    os.environ["GCS_USE_BATCHED_LOGGING"] = "false"
     filepath = os.path.dirname(os.path.abspath(__file__))
     vertex_key_path = filepath + "/vertex_key.json"
 
diff --git a/tests/local_testing/test_get_llm_provider.py b/tests/local_testing/test_get_llm_provider.py
index 4df910bc73e..9b07111ea54 100644
--- a/tests/local_testing/test_get_llm_provider.py
+++ b/tests/local_testing/test_get_llm_provider.py
@@ -137,6 +137,9 @@ def test_default_api_base():
             # Get the API base for the given provider
             if provider == "github_copilot":
                 continue
+            # Skip chatgpt as it requires OAuth authentication
+            if provider == "chatgpt":
+                continue
             # Skip ragflow as it requires specific model format: ragflow/chat/{id}/{model} or ragflow/agent/{id}/{model}
             if provider == "ragflow":
                 continue
diff --git a/tests/local_testing/test_router_retries.py b/tests/local_testing/test_router_retries.py
index 65539cfeee0..1d72d5914c5 100644
--- a/tests/local_testing/test_router_retries.py
+++ b/tests/local_testing/test_router_retries.py
@@ -676,6 +676,85 @@ def test_no_retry_for_not_found_error_404():
         print("got exception", e)
 
 
+def test_no_retry_for_bad_request_error_400():
+    """
+    Test that 400 BadRequestError is NOT retried, even if healthy deployments exist.
+    This tests the fix for GitHub issue #19216.
+    """
+    healthy_deployments = ["deployment1", "deployment2"]  # Multiple healthy deployments
+
+    router = Router(
+        model_list=[
+            {
+                "model_name": "gpt-3.5-turbo",
+                "litellm_params": {
+                    "model": "azure/gpt-4.1-mini",
+                    "api_key": os.getenv("AZURE_API_KEY"),
+                    "api_version": os.getenv("AZURE_API_VERSION"),
+                    "api_base": os.getenv("AZURE_API_BASE"),
+                },
+            }
+        ]
+    )
+
+    # Act & Assert
+    error = litellm.BadRequestError(
+        message="400 Invalid request parameters",
+        model="gpt-3.5-turbo",
+        llm_provider="azure",
+    )
+    try:
+        response = router.should_retry_this_error(
+            error=error, healthy_deployments=healthy_deployments
+        )
+        pytest.fail(
+            "Should have raised BadRequestError - 400 errors should never be retried"
+        )
+    except litellm.BadRequestError as e:
+        print("Correctly raised BadRequestError without retry:", e)
+
+
+def test_no_retry_for_unprocessable_entity_error_422():
+    """
+    Test that 422 UnprocessableEntityError is NOT retried, even if healthy deployments exist.
+    """
+    healthy_deployments = ["deployment1", "deployment2"]  # Multiple healthy deployments
+
+    router = Router(
+        model_list=[
+            {
+                "model_name": "gpt-3.5-turbo",
+                "litellm_params": {
+                    "model": "azure/gpt-4.1-mini",
+                    "api_key": os.getenv("AZURE_API_KEY"),
+                    "api_version": os.getenv("AZURE_API_VERSION"),
+                    "api_base": os.getenv("AZURE_API_BASE"),
+                },
+            }
+        ]
+    )
+
+    # Act & Assert
+    error = litellm.UnprocessableEntityError(
+        message="422 Unprocessable Entity",
+        model="gpt-3.5-turbo",
+        llm_provider="azure",
+        response=httpx.Response(
+            status_code=422,
+            request=httpx.Request(method="POST", url="https://api.openai.com/v1"),
+        ),
+    )
+    try:
+        response = router.should_retry_this_error(
+            error=error, healthy_deployments=healthy_deployments
+        )
+        pytest.fail(
+            "Should have raised UnprocessableEntityError - 422 errors should never be retried"
+        )
+    except litellm.UnprocessableEntityError as e:
+        print("Correctly raised UnprocessableEntityError without retry:", e)
+
+
 internal_server_error = litellm.InternalServerError(
     message="internal server error",
     model="gpt-12",
@@ -809,7 +888,7 @@ async def test_router_timeout_model_specific_and_global():
 async def test_router_retry_num_retries_tracking():
     """
     Test that num_retries attribute is correctly set on exceptions when all retries are exhausted.
-    
+
     This verifies the fix for the bug where num_retries was incorrectly set to current_attempt
     (0-indexed) instead of the actual number of retries attempted.
     """
@@ -837,8 +916,17 @@ async def test_router_retry_num_retries_tracking():
         )
 
     with patch.object(router, "make_call", side_effect=mock_make_call):
-        with patch.object(router, "_async_get_healthy_deployments", return_value=([{"model_info": {"id": "test-id"}}], [{"model_info": {"id": "test-id"}}])):
-            with patch.object(router, "_time_to_sleep_before_retry", return_value=0.01):  # Fast retries for testing
+        with patch.object(
+            router,
+            "_async_get_healthy_deployments",
+            return_value=(
+                [{"model_info": {"id": "test-id"}}],
+                [{"model_info": {"id": "test-id"}}],
+            ),
+        ):
+            with patch.object(
+                router, "_time_to_sleep_before_retry", return_value=0.01
+            ):  # Fast retries for testing
                 try:
                     await router.acompletion(
                         model="gpt-3.5-turbo",
@@ -847,15 +935,27 @@ async def test_router_retry_num_retries_tracking():
                     pytest.fail("Expected exception to be raised")
                 except litellm.RateLimitError as e:
                     # Verify num_retries is correctly set to 3 (not 2, which would be current_attempt)
-                    assert hasattr(e, "num_retries"), "Exception should have num_retries attribute"
-                    assert hasattr(e, "max_retries"), "Exception should have max_retries attribute"
-                    assert e.num_retries == 3, f"Expected num_retries to be 3, got {e.num_retries}"
-                    assert e.max_retries == 3, f"Expected max_retries to be 3, got {e.max_retries}"
-                    
+                    assert hasattr(
+                        e, "num_retries"
+                    ), "Exception should have num_retries attribute"
+                    assert hasattr(
+                        e, "max_retries"
+                    ), "Exception should have max_retries attribute"
+                    assert (
+                        e.num_retries == 3
+                    ), f"Expected num_retries to be 3, got {e.num_retries}"
+                    assert (
+                        e.max_retries == 3
+                    ), f"Expected max_retries to be 3, got {e.max_retries}"
+
                     # Verify the error message includes correct retry information
                     error_str = str(e)
-                    assert "LiteLLM Retried: 3 times" in error_str, f"Error message should indicate 3 retries: {error_str}"
-                    assert "LiteLLM Max Retries: 3" in error_str, f"Error message should show max retries: {error_str}"
+                    assert (
+                        "LiteLLM Retried: 3 times" in error_str
+                    ), f"Error message should indicate 3 retries: {error_str}"
+                    assert (
+                        "LiteLLM Max Retries: 3" in error_str
+                    ), f"Error message should show max retries: {error_str}"
 
 
 @pytest.mark.asyncio
@@ -887,7 +987,14 @@ async def test_router_retry_num_retries_single_retry():
         )
 
     with patch.object(router, "make_call", side_effect=mock_make_call):
-        with patch.object(router, "_async_get_healthy_deployments", return_value=([{"model_info": {"id": "test-id"}}], [{"model_info": {"id": "test-id"}}])):
+        with patch.object(
+            router,
+            "_async_get_healthy_deployments",
+            return_value=(
+                [{"model_info": {"id": "test-id"}}],
+                [{"model_info": {"id": "test-id"}}],
+            ),
+        ):
             with patch.object(router, "_time_to_sleep_before_retry", return_value=0.01):
                 try:
                     await router.acompletion(
@@ -897,5 +1004,9 @@ async def test_router_retry_num_retries_single_retry():
                     pytest.fail("Expected exception to be raised")
                 except litellm.Timeout as e:
                     # With num_retries=1, we should attempt 1 retry
-                    assert e.num_retries == 1, f"Expected num_retries to be 1, got {e.num_retries}"
-                    assert e.max_retries == 1, f"Expected max_retries to be 1, got {e.max_retries}"
\ No newline at end of file
+                    assert (
+                        e.num_retries == 1
+                    ), f"Expected num_retries to be 1, got {e.num_retries}"
+                    assert (
+                        e.max_retries == 1
+                    ), f"Expected max_retries to be 1, got {e.max_retries}"
diff --git a/tests/pass_through_unit_tests/test_claude_code_marketplace.py b/tests/pass_through_unit_tests/test_claude_code_marketplace.py
index b4ba30e9c71..21387439d85 100644
--- a/tests/pass_through_unit_tests/test_claude_code_marketplace.py
+++ b/tests/pass_through_unit_tests/test_claude_code_marketplace.py
@@ -6,9 +6,12 @@ Tests:
 2. Get marketplace.json (list enabled plugins)
 """
 
+import json
 import os
 import sys
 import time
+from datetime import datetime, timezone
+from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 
@@ -17,7 +20,6 @@ sys.path.insert(0, os.path.abspath("../.."))
 import litellm
 from litellm.proxy._types import UserAPIKeyAuth
 from litellm.proxy.proxy_server import LitellmUserRoles
-from litellm.proxy.utils import PrismaClient, ProxyLogging
 from litellm.caching.caching import DualCache
 from litellm.types.proxy.claude_code_endpoints import RegisterPluginRequest
 
@@ -27,33 +29,118 @@ from litellm.proxy.anthropic_endpoints.claude_code_endpoints.claude_code_marketp
     get_marketplace,
 )
 
-proxy_logging_obj = ProxyLogging(user_api_key_cache=DualCache())
+
+class MockPluginRecord:
+    """Mock plugin record that mimics Prisma model behavior."""
+
+    def __init__(self, name, version, description, manifest_json, enabled=True, created_by=None):
+        self.id = f"plugin-{name}-{int(time.time())}"
+        self.name = name
+        self.version = version
+        self.description = description
+        self.manifest_json = manifest_json
+        self.files_json = "{}"
+        self.enabled = enabled
+        self.created_at = datetime.now(timezone.utc)
+        self.updated_at = datetime.now(timezone.utc)
+        self.created_by = created_by
 
 
 @pytest.fixture
-def prisma_client():
-    from litellm.proxy.proxy_cli import append_query_params
+def mock_prisma_client():
+    """Create a mock PrismaClient that doesn't require Prisma binaries."""
+    # In-memory storage for plugins
+    plugins_store = {}
 
-    params = {"connection_limit": 100, "pool_timeout": 60}
-    database_url = os.getenv("DATABASE_URL")
-    modified_url = append_query_params(database_url, params)
-    os.environ["DATABASE_URL"] = modified_url
+    # Create mock client
+    mock_client = MagicMock()
+    mock_client.proxy_logging_obj = MagicMock()
 
-    prisma_client = PrismaClient(
-        database_url=os.environ["DATABASE_URL"], proxy_logging_obj=proxy_logging_obj
-    )
+    # Mock the db attribute
+    mock_client.db = MagicMock()
 
-    litellm.proxy.proxy_server.litellm_proxy_budget_name = (
-        f"litellm-proxy-budget-{time.time()}"
-    )
+    # Mock the plugin table with async methods
+    mock_table = MagicMock()
 
-    return prisma_client
+    async def find_unique(where):
+        """Mock find_unique - returns plugin if exists, None otherwise."""
+        plugin_name = where.get("name")
+        return plugins_store.get(plugin_name)
+
+    async def find_many(where=None):
+        """Mock find_many - returns list of plugins matching where clause."""
+        if where is None or where == {}:
+            return list(plugins_store.values())
+        enabled = where.get("enabled")
+        if enabled is not None:
+            return [p for p in plugins_store.values() if p.enabled == enabled]
+        return list(plugins_store.values())
+
+    async def create(data):
+        """Mock create - creates a new plugin."""
+        plugin_name = data["name"]
+        manifest = data.get("manifest_json", "{}")
+        plugin = MockPluginRecord(
+            name=plugin_name,
+            version=data.get("version"),
+            description=data.get("description"),
+            manifest_json=manifest,
+            enabled=data.get("enabled", True),
+            created_by=data.get("created_by"),
+        )
+        plugins_store[plugin_name] = plugin
+        return plugin
+
+    async def update(where, data):
+        """Mock update - updates an existing plugin."""
+        plugin_name = where.get("name")
+        if plugin_name not in plugins_store:
+            raise ValueError(f"Plugin {plugin_name} not found")
+        plugin = plugins_store[plugin_name]
+        # Update fields
+        if "version" in data:
+            plugin.version = data["version"]
+        if "description" in data:
+            plugin.description = data["description"]
+        if "manifest_json" in data:
+            plugin.manifest_json = data["manifest_json"]
+        if "enabled" in data:
+            plugin.enabled = data["enabled"]
+        if "updated_at" in data:
+            plugin.updated_at = data["updated_at"]
+        return plugin
+
+    async def delete(where):
+        """Mock delete - deletes a plugin."""
+        plugin_name = where.get("name")
+        if plugin_name in plugins_store:
+            del plugins_store[plugin_name]
+        return None
+
+    async def connect():
+        """Mock connect - no-op."""
+        pass
+
+    # Set up async mocks
+    mock_table.find_unique = AsyncMock(side_effect=find_unique)
+    mock_table.find_many = AsyncMock(side_effect=find_many)
+    mock_table.create = AsyncMock(side_effect=create)
+    mock_table.update = AsyncMock(side_effect=update)
+    mock_table.delete = AsyncMock(side_effect=delete)
+
+    mock_client.db.litellm_claudecodeplugintable = mock_table
+    mock_client.connect = AsyncMock(side_effect=connect)
+
+    # Store plugins_store on the mock for cleanup if needed
+    mock_client._plugins_store = plugins_store
+
+    return mock_client
 
 
 @pytest.mark.asyncio
-async def test_register_plugin(prisma_client):
+async def test_register_plugin(mock_prisma_client):
     """Test registering a plugin in the marketplace."""
-    setattr(litellm.proxy.proxy_server, "prisma_client", prisma_client)
+    setattr(litellm.proxy.proxy_server, "prisma_client", mock_prisma_client)
     setattr(litellm.proxy.proxy_server, "master_key", "sk-1234")
 
     await litellm.proxy.proxy_server.prisma_client.connect()
@@ -85,16 +172,23 @@ async def test_register_plugin(prisma_client):
     assert response["plugin"]["version"] == "1.0.0"
     assert response["plugin"]["enabled"] is True
 
+    # Verify the plugin was stored in the mock
+    stored_plugin = await mock_prisma_client.db.litellm_claudecodeplugintable.find_unique(
+        where={"name": plugin_name}
+    )
+    assert stored_plugin is not None
+    assert stored_plugin.name == plugin_name
+
     # Cleanup - delete the plugin
-    await prisma_client.db.litellm_claudecodeplugintable.delete(
+    await mock_prisma_client.db.litellm_claudecodeplugintable.delete(
         where={"name": plugin_name}
     )
 
 
 @pytest.mark.asyncio
-async def test_get_marketplace(prisma_client):
+async def test_get_marketplace(mock_prisma_client):
     """Test getting marketplace.json with registered plugins."""
-    setattr(litellm.proxy.proxy_server, "prisma_client", prisma_client)
+    setattr(litellm.proxy.proxy_server, "prisma_client", mock_prisma_client)
     setattr(litellm.proxy.proxy_server, "master_key", "sk-1234")
 
     await litellm.proxy.proxy_server.prisma_client.connect()
@@ -124,7 +218,6 @@ async def test_get_marketplace(prisma_client):
     response = await get_marketplace()
 
     # Response is a JSONResponse, get the body
-    import json
     body = json.loads(response.body.decode())
 
     assert body["name"] == "litellm"
@@ -140,6 +233,6 @@ async def test_get_marketplace(prisma_client):
     assert our_plugin["version"] == "2.0.0"
 
     # Cleanup
-    await prisma_client.db.litellm_claudecodeplugintable.delete(
+    await mock_prisma_client.db.litellm_claudecodeplugintable.delete(
         where={"name": plugin_name}
     )
diff --git a/tests/proxy_unit_tests/test_proxy_token_counter.py b/tests/proxy_unit_tests/test_proxy_token_counter.py
index 8e1057bb8e1..2f161162dab 100644
--- a/tests/proxy_unit_tests/test_proxy_token_counter.py
+++ b/tests/proxy_unit_tests/test_proxy_token_counter.py
@@ -478,19 +478,20 @@ async def test_anthropic_endpoint_error_handling():
 @pytest.mark.asyncio
 async def test_factory_anthropic_endpoint_calls_anthropic_counter():
     """Test that /v1/messages/count_tokens with Anthropic model uses Anthropic counter."""
-    from unittest.mock import patch, AsyncMock
+    from unittest.mock import patch, AsyncMock, MagicMock
     from fastapi.testclient import TestClient
     from litellm.proxy.proxy_server import app
 
-    # Mock the anthropic token counting function
-    with patch(
-        "litellm.proxy.utils.count_tokens_with_anthropic_api"
-    ) as mock_anthropic_count:
-        mock_anthropic_count.return_value = {
-            "total_tokens": 42,
-            "tokenizer_used": "anthropic",
-        }
+    # Mock the global handler instance in token_counter module
+    mock_handler = MagicMock()
+    mock_handler.handle_count_tokens_request = AsyncMock(
+        return_value={"input_tokens": 42}
+    )
 
+    with patch(
+        "litellm.llms.anthropic.count_tokens.token_counter.anthropic_count_tokens_handler",
+        mock_handler
+    ):
         # Mock router to return Anthropic deployment
         with patch("litellm.proxy.proxy_server.llm_router") as mock_router:
             mock_router.model_list = [
@@ -510,36 +511,44 @@ async def test_factory_anthropic_endpoint_calls_anthropic_counter():
                 }
             )
 
-            client = TestClient(app)
+            # Set ANTHROPIC_API_KEY for the test
+            with patch.dict("os.environ", {"ANTHROPIC_API_KEY": "test-key"}):
+                client = TestClient(app)
 
-            response = client.post(
-                "/v1/messages/count_tokens",
-                json={
-                    "model": "claude-3-5-sonnet",
-                    "messages": [{"role": "user", "content": "Hello"}],
-                },
-                headers={"Authorization": "Bearer test-key"},
-            )
+                response = client.post(
+                    "/v1/messages/count_tokens",
+                    json={
+                        "model": "claude-3-5-sonnet",
+                        "messages": [{"role": "user", "content": "Hello"}],
+                    },
+                    headers={"Authorization": "Bearer test-key"},
+                )
 
-            assert response.status_code == 200
-            data = response.json()
-            assert data["input_tokens"] == 42
+                assert response.status_code == 200
+                data = response.json()
+                assert data["input_tokens"] == 42
 
-            # Verify that Anthropic API was called
-            mock_anthropic_count.assert_called_once()
+                # Verify that Anthropic handler was called
+                mock_handler.handle_count_tokens_request.assert_called_once()
 
 
 @pytest.mark.asyncio
 async def test_factory_gpt4_endpoint_does_not_call_anthropic_counter():
     """Test that /v1/messages/count_tokens with GPT-4 does NOT use Anthropic counter."""
-    from unittest.mock import patch, AsyncMock
+    from unittest.mock import patch, AsyncMock, MagicMock
     from fastapi.testclient import TestClient
     from litellm.proxy.proxy_server import app
 
-    # Mock the anthropic token counting function
+    # Mock the global handler instance in token_counter module
+    mock_handler = MagicMock()
+    mock_handler.handle_count_tokens_request = AsyncMock(
+        return_value={"input_tokens": 42}
+    )
+
     with patch(
-        "litellm.proxy.utils.count_tokens_with_anthropic_api"
-    ) as mock_anthropic_count:
+        "litellm.llms.anthropic.count_tokens.token_counter.anthropic_count_tokens_handler",
+        mock_handler
+    ):
         # Mock litellm token counter
         with patch("litellm.token_counter") as mock_litellm_counter:
             mock_litellm_counter.return_value = 50
@@ -578,21 +587,27 @@ async def test_factory_gpt4_endpoint_does_not_call_anthropic_counter():
                 data = response.json()
                 assert data["input_tokens"] == 50
 
-                # Verify that Anthropic API was NOT called
-                mock_anthropic_count.assert_not_called()
+                # Verify that Anthropic handler was NOT called
+                mock_handler.handle_count_tokens_request.assert_not_called()
 
 
 @pytest.mark.asyncio
 async def test_factory_normal_token_counter_endpoint_does_not_call_anthropic():
     """Test that /utils/token_counter does NOT use Anthropic counter even with Anthropic model."""
-    from unittest.mock import patch, AsyncMock
+    from unittest.mock import patch, AsyncMock, MagicMock
     from fastapi.testclient import TestClient
     from litellm.proxy.proxy_server import app
 
-    # Mock the anthropic token counting function
+    # Mock the global handler instance in token_counter module
+    mock_handler = MagicMock()
+    mock_handler.handle_count_tokens_request = AsyncMock(
+        return_value={"input_tokens": 42}
+    )
+
     with patch(
-        "litellm.proxy.utils.count_tokens_with_anthropic_api"
-    ) as mock_anthropic_count:
+        "litellm.llms.anthropic.count_tokens.token_counter.anthropic_count_tokens_handler",
+        mock_handler
+    ):
         # Mock litellm token counter
         with patch("litellm.token_counter") as mock_litellm_counter:
             mock_litellm_counter.return_value = 35
@@ -635,8 +650,8 @@ async def test_factory_normal_token_counter_endpoint_does_not_call_anthropic():
                 data = response.json()
                 assert data["total_tokens"] == 35
 
-                # Verify that Anthropic API was NOT called (since call_endpoint=False)
-                mock_anthropic_count.assert_not_called()
+                # Verify that Anthropic handler was NOT called (since call_endpoint=False)
+                mock_handler.handle_count_tokens_request.assert_not_called()
 
 
 @pytest.mark.asyncio
diff --git a/tests/spend_tracking_tests/test_spend_accuracy_tests.py b/tests/spend_tracking_tests/test_spend_accuracy_tests.py
index 821709250da..8101269f855 100644
--- a/tests/spend_tracking_tests/test_spend_accuracy_tests.py
+++ b/tests/spend_tracking_tests/test_spend_accuracy_tests.py
@@ -156,8 +156,8 @@ async def test_basic_spend_accuracy():
             response = await chat_completion(session, key)
             print("response: ", response)
 
-        # wait 15 seconds for spend to be updated
-        await asyncio.sleep(15)
+        # wait 25 seconds for spend to be updated
+        await asyncio.sleep(25)
 
         # Get spend information for each entity
         key_info = await get_spend_info(session, "key", key)
diff --git a/tests/test_litellm/integrations/test_prometheus_labels.py b/tests/test_litellm/integrations/test_prometheus_labels.py
index 8a4295e98fc..c0b863ef6ee 100644
--- a/tests/test_litellm/integrations/test_prometheus_labels.py
+++ b/tests/test_litellm/integrations/test_prometheus_labels.py
@@ -3,7 +3,7 @@ Unit tests for prometheus metric labels configuration
 """
 from litellm.types.integrations.prometheus import (
     PrometheusMetricLabels,
-    UserAPIKeyLabelNames
+    UserAPIKeyLabelNames,
 )
 
 
@@ -42,9 +42,10 @@ def test_user_email_label_exists():
 
 def test_prometheus_metric_labels_structure():
     """Test that all required prometheus metrics have proper label structure"""
-    from litellm.types.integrations.prometheus import DEFINED_PROMETHEUS_METRICS
     from typing import get_args
 
+    from litellm.types.integrations.prometheus import DEFINED_PROMETHEUS_METRICS
+
     # Test a few key metrics to ensure they have proper label structure
     test_metrics = [
         "litellm_proxy_total_requests_metric",
@@ -69,8 +70,161 @@ def test_prometheus_metric_labels_structure():
         print(f"✅ {metric_name} has proper label structure with user_email")
 
 
+def test_route_normalization_for_responses_api():
+    """
+    Test that route normalization prevents high cardinality in Prometheus metrics
+    for the /v1/responses/{response_id} endpoint.
+    
+    Issue: https://github.com/BerriAI/litellm/issues/XXXX
+    Each unique response ID was creating a separate metric line, causing the
+    /metrics endpoint to grow to ~30MB and take ~40 seconds to respond.
+    
+    Fix: Routes are normalized to collapse dynamic IDs into placeholders.
+    """
+    from litellm.proxy.auth.auth_utils import normalize_request_route
+
+    # Test responses API routes
+    responses_routes = [
+        ("/v1/responses/1234567890", "/v1/responses/{response_id}"),
+        ("/v1/responses/9876543210", "/v1/responses/{response_id}"),
+        ("/v1/responses/abcdefghij", "/v1/responses/{response_id}"),
+        ("/v1/responses/resp_abc123", "/v1/responses/{response_id}"),
+        ("/v1/responses/litellm_poll_xyz", "/v1/responses/{response_id}"),
+    ]
+    
+    for original, expected in responses_routes:
+        normalized = normalize_request_route(original)
+        assert normalized == expected, \
+            f"Failed: {original} -> {normalized} (expected {expected})"
+    
+    # Verify cardinality reduction
+    unique_normalized = set(normalize_request_route(route) for route, _ in responses_routes)
+    assert len(unique_normalized) == 1, \
+        f"Expected 1 unique normalized route, got {len(unique_normalized)}: {unique_normalized}"
+    
+    print(f"✅ Responses API routes: {len(responses_routes)} different IDs normalized to 1 metric label")
+    
+
+def test_route_normalization_for_sub_routes():
+    """Test that sub-routes like /cancel and /input_items are normalized correctly"""
+    from litellm.proxy.auth.auth_utils import normalize_request_route
+    
+    sub_routes = [
+        ("/v1/responses/id1/cancel", "/v1/responses/{response_id}/cancel"),
+        ("/v1/responses/id2/cancel", "/v1/responses/{response_id}/cancel"),
+        ("/v1/responses/id3/input_items", "/v1/responses/{response_id}/input_items"),
+        ("/openai/v1/responses/id4/input_items", "/openai/v1/responses/{response_id}/input_items"),
+    ]
+    
+    for original, expected in sub_routes:
+        normalized = normalize_request_route(original)
+        assert normalized == expected, \
+            f"Failed: {original} -> {normalized} (expected {expected})"
+    
+    print("✅ Sub-routes normalized correctly")
+
+
+def test_route_normalization_preserves_static_routes():
+    """Test that static routes are not affected by normalization"""
+    from litellm.proxy.auth.auth_utils import normalize_request_route
+    
+    static_routes = [
+        "/chat/completions",
+        "/v1/chat/completions",
+        "/v1/embeddings",
+        "/health",
+        "/metrics",
+        "/v1/models",
+        "/v1/responses",  # List endpoint without ID
+    ]
+    
+    for route in static_routes:
+        normalized = normalize_request_route(route)
+        assert normalized == route, \
+            f"Static route should not be modified: {route} -> {normalized}"
+    
+    print(f"✅ {len(static_routes)} static routes preserved")
+
+
+def test_route_normalization_other_dynamic_apis():
+    """Test normalization for other OpenAI-compatible APIs with dynamic IDs"""
+    from litellm.proxy.auth.auth_utils import normalize_request_route
+    
+    test_cases = [
+        # Threads API
+        ("/v1/threads/thread_123", "/v1/threads/{thread_id}"),
+        ("/v1/threads/thread_abc/messages", "/v1/threads/{thread_id}/messages"),
+        ("/v1/threads/thread_abc/runs/run_123", "/v1/threads/{thread_id}/runs/{run_id}"),
+        
+        # Vector Stores API
+        ("/v1/vector_stores/vs_123", "/v1/vector_stores/{vector_store_id}"),
+        ("/v1/vector_stores/vs_123/files", "/v1/vector_stores/{vector_store_id}/files"),
+        
+        # Assistants API
+        ("/v1/assistants/asst_123", "/v1/assistants/{assistant_id}"),
+        
+        # Files API
+        ("/v1/files/file_123", "/v1/files/{file_id}"),
+        ("/v1/files/file_123/content", "/v1/files/{file_id}/content"),
+        
+        # Batches API
+        ("/v1/batches/batch_123", "/v1/batches/{batch_id}"),
+        ("/v1/batches/batch_123/cancel", "/v1/batches/{batch_id}/cancel"),
+    ]
+    
+    for original, expected in test_cases:
+        normalized = normalize_request_route(original)
+        assert normalized == expected, \
+            f"Failed: {original} -> {normalized} (expected {expected})"
+    
+    print(f"✅ {len(test_cases)} other API routes normalized correctly")
+
+
+def test_prometheus_metrics_use_normalized_routes():
+    """
+    Test that Prometheus metrics use the normalized route in labels
+    to prevent high cardinality.
+    """
+    from unittest.mock import MagicMock
+
+    from litellm.integrations.prometheus import (
+        PrometheusLogger,
+        UserAPIKeyLabelValues,
+        prometheus_label_factory,
+    )
+
+    # Create a mock PrometheusLogger
+    prometheus_logger = MagicMock()
+    prometheus_logger.get_labels_for_metric = PrometheusLogger.get_labels_for_metric.__get__(prometheus_logger)
+    
+    # Test with a normalized route
+    enum_values = UserAPIKeyLabelValues(
+        route="/v1/responses/{response_id}",  # Normalized route
+        status_code="200",
+        requested_model="gpt-4",
+    )
+    
+    labels = prometheus_label_factory(
+        supported_enum_labels=prometheus_logger.get_labels_for_metric(
+            metric_name="litellm_proxy_total_requests_metric"
+        ),
+        enum_values=enum_values,
+    )
+    
+    # Verify the route is normalized in labels
+    assert labels["route"] == "/v1/responses/{response_id}", \
+        f"Expected normalized route in labels, got: {labels.get('route')}"
+    
+    print("✅ Prometheus metrics use normalized routes in labels")
+
+
 if __name__ == "__main__":
     test_user_email_in_required_metrics()
     test_user_email_label_exists()
     test_prometheus_metric_labels_structure()
-    print("All prometheus label tests passed!")
\ No newline at end of file
+    test_route_normalization_for_responses_api()
+    test_route_normalization_for_sub_routes()
+    test_route_normalization_preserves_static_routes()
+    test_route_normalization_other_dynamic_apis()
+    test_prometheus_metrics_use_normalized_routes()
+    print("\n✅ All prometheus label tests passed!")
\ No newline at end of file
diff --git a/tests/test_litellm/llms/anthropic/test_anthropic_common_utils.py b/tests/test_litellm/llms/anthropic/test_anthropic_common_utils.py
new file mode 100644
index 00000000000..0a397d116e7
--- /dev/null
+++ b/tests/test_litellm/llms/anthropic/test_anthropic_common_utils.py
@@ -0,0 +1,84 @@
+"""
+Tests for Anthropic OAuth token handling for Claude Code Max integration.
+"""
+
+import os
+import sys
+
+# Add litellm to path
+sys.path.insert(0, os.path.abspath("../../../../.."))
+
+# Fake OAuth token for testing (not a real secret)
+FAKE_OAUTH_TOKEN = "sk-ant-oat01-fake-token-for-testing-123456789abcdef"
+
+
+def test_oauth_detection_in_common_utils():
+    """Test 1: OAuth token detection in common_utils"""
+    from litellm.llms.anthropic.common_utils import optionally_handle_anthropic_oauth
+
+    headers = {"authorization": f"Bearer {FAKE_OAUTH_TOKEN}"}
+    updated_headers, extracted_api_key = optionally_handle_anthropic_oauth(headers, None)
+
+    assert extracted_api_key == FAKE_OAUTH_TOKEN
+    assert updated_headers["anthropic-beta"] == "oauth-2025-04-20"
+    assert updated_headers["anthropic-dangerous-direct-browser-access"] == "true"
+
+
+def test_oauth_integration_in_validate_environment():
+    """Test 2: OAuth integration in AnthropicConfig validate_environment"""
+    from litellm.llms.anthropic.common_utils import AnthropicModelInfo
+
+    config = AnthropicModelInfo()
+    headers = {"authorization": f"Bearer {FAKE_OAUTH_TOKEN}"}
+
+    updated_headers = config.validate_environment(
+        headers=headers,
+        model="claude-3-haiku-20240307",
+        messages=[{"role": "user", "content": "Hello"}],
+        optional_params={},
+        litellm_params={},
+        api_key=None,
+        api_base=None,
+    )
+
+    assert updated_headers["x-api-key"] == FAKE_OAUTH_TOKEN
+    assert updated_headers["anthropic-dangerous-direct-browser-access"] == "true"
+
+
+def test_oauth_detection_in_messages_transformation():
+    """Test 3: OAuth detection in messages transformation"""
+    from litellm.llms.anthropic.experimental_pass_through.messages.transformation import (
+        AnthropicMessagesConfig,
+    )
+
+    config = AnthropicMessagesConfig()
+    headers = {"authorization": f"Bearer {FAKE_OAUTH_TOKEN}"}
+
+    updated_headers, _ = config.validate_anthropic_messages_environment(
+        headers=headers,
+        model="claude-3-haiku-20240307",
+        messages=[{"role": "user", "content": "Hello"}],
+        optional_params={},
+        litellm_params={},
+        api_key=None,
+        api_base=None,
+    )
+
+    assert updated_headers["x-api-key"] == FAKE_OAUTH_TOKEN
+    assert "oauth-2025-04-20" in updated_headers["anthropic-beta"]
+    assert updated_headers["anthropic-dangerous-direct-browser-access"] == "true"
+
+
+def test_regular_api_keys_still_work():
+    """Test 4: Regular API keys still work (regression test)"""
+    from litellm.llms.anthropic.common_utils import optionally_handle_anthropic_oauth
+
+    regular_key = "sk-ant-api03-regular-key-123"
+    headers = {"authorization": f"Bearer {regular_key}"}
+
+    updated_headers, extracted_api_key = optionally_handle_anthropic_oauth(headers, regular_key)
+
+    # Regular key should be unchanged
+    assert extracted_api_key == regular_key
+    # OAuth headers should NOT be added
+    assert "anthropic-dangerous-direct-browser-access" not in updated_headers
\ No newline at end of file
diff --git a/tests/test_litellm/llms/azure/test_azure_common_utils.py b/tests/test_litellm/llms/azure/test_azure_common_utils.py
index 654720183a7..5a0680d66bf 100644
--- a/tests/test_litellm/llms/azure/test_azure_common_utils.py
+++ b/tests/test_litellm/llms/azure/test_azure_common_utils.py
@@ -1542,3 +1542,119 @@ def test_is_azure_v1_api_version(api_version, expected):
     """
     result = BaseAzureLLM._is_azure_v1_api_version(api_version=api_version)
     assert result == expected
+
+
+@pytest.mark.parametrize("api_version", ["v1", "latest", "preview"])
+def test_azure_v1_api_uses_openai_client(api_version):
+    """
+    Test that Azure v1 API versions use OpenAI client instead of AzureOpenAI.
+
+    When api_version is 'v1', 'latest', or 'preview', the client should be
+    instantiated as OpenAI/AsyncOpenAI with base_url pointing to /openai/v1/
+    instead of the traditional AzureOpenAI client with /deployments/ URL pattern.
+
+    See: https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#api-specs
+    """
+    from openai import AsyncOpenAI, OpenAI
+
+    base_llm = BaseAzureLLM()
+    api_base = "https://test.openai.azure.com"
+
+    # Test sync client
+    with patch.object(base_llm, "initialize_azure_sdk_client") as mock_init:
+        mock_init.return_value = {
+            "api_key": "test-key",
+            "azure_endpoint": api_base,
+            "api_version": api_version,
+            "azure_ad_token": None,
+            "azure_ad_token_provider": None,
+        }
+
+        client = base_llm.get_azure_openai_client(
+            api_key="test-key",
+            api_base=api_base,
+            api_version=api_version,
+            _is_async=False,
+        )
+
+        # Should be OpenAI client, not AzureOpenAI
+        assert isinstance(client, OpenAI), f"Expected OpenAI client for api_version={api_version}"
+        # base_url should be /openai/v1/ (not /deployments/)
+        assert "/openai/v1/" in str(client.base_url), f"base_url should contain /openai/v1/, got {client.base_url}"
+
+    # Test async client
+    with patch.object(base_llm, "initialize_azure_sdk_client") as mock_init:
+        mock_init.return_value = {
+            "api_key": "test-key",
+            "azure_endpoint": api_base,
+            "api_version": api_version,
+            "azure_ad_token": None,
+            "azure_ad_token_provider": None,
+        }
+
+        async_client = base_llm.get_azure_openai_client(
+            api_key="test-key",
+            api_base=api_base,
+            api_version=api_version,
+            _is_async=True,
+        )
+
+        # Should be AsyncOpenAI client, not AsyncAzureOpenAI
+        assert isinstance(async_client, AsyncOpenAI), f"Expected AsyncOpenAI client for api_version={api_version}"
+        # base_url should be /openai/v1/
+        assert "/openai/v1/" in str(async_client.base_url), f"base_url should contain /openai/v1/, got {async_client.base_url}"
+
+
+def test_azure_traditional_api_uses_azure_openai_client():
+    """
+    Test that traditional Azure API versions still use AzureOpenAI client.
+
+    When api_version is a dated version like '2023-05-15', the client should
+    be instantiated as AzureOpenAI/AsyncAzureOpenAI with the traditional
+    /deployments/ URL pattern.
+    """
+    from openai import AsyncAzureOpenAI, AzureOpenAI
+
+    base_llm = BaseAzureLLM()
+    api_base = "https://test.openai.azure.com"
+    api_version = "2023-05-15"
+
+    # Test sync client
+    with patch.object(base_llm, "initialize_azure_sdk_client") as mock_init:
+        mock_init.return_value = {
+            "api_key": "test-key",
+            "azure_endpoint": api_base,
+            "api_version": api_version,
+            "azure_ad_token": None,
+            "azure_ad_token_provider": None,
+        }
+
+        client = base_llm.get_azure_openai_client(
+            api_key="test-key",
+            api_base=api_base,
+            api_version=api_version,
+            _is_async=False,
+        )
+
+        # Should be AzureOpenAI client
+        assert isinstance(client, AzureOpenAI), f"Expected AzureOpenAI client for api_version={api_version}"
+
+    # Test async client
+    with patch.object(base_llm, "initialize_azure_sdk_client") as mock_init:
+        mock_init.return_value = {
+            "api_key": "test-key",
+            "azure_endpoint": api_base,
+            "api_version": api_version,
+            "azure_ad_token": None,
+            "azure_ad_token_provider": None,
+        }
+
+        async_client = base_llm.get_azure_openai_client(
+            api_key="test-key",
+            api_base=api_base,
+            api_version=api_version,
+            _is_async=True,
+        )
+
+        # Should be AsyncAzureOpenAI client
+        assert isinstance(async_client, AsyncAzureOpenAI), f"Expected AsyncAzureOpenAI client for api_version={api_version}"
diff --git a/tests/test_litellm/llms/bedrock/chat/test_converse_transformation.py b/tests/test_litellm/llms/bedrock/chat/test_converse_transformation.py
index 692866f8552..ee27775978e 100644
--- a/tests/test_litellm/llms/bedrock/chat/test_converse_transformation.py
+++ b/tests/test_litellm/llms/bedrock/chat/test_converse_transformation.py
@@ -275,10 +275,10 @@ def test_get_supported_openai_params():
 
 def test_get_supported_openai_params_bedrock_converse():
     """
-    Test that all documented bedrock converse models have the same set of supported openai params when using 
+    Test that all documented bedrock converse models have the same set of supported openai params when using
     `bedrock/converse/` or `bedrock/` prefix.
 
-    Note: This test is critical for routing, if we ever remove `litellm.BEDROCK_CONVERSE_MODELS`, 
+    Note: This test is critical for routing, if we ever remove `litellm.BEDROCK_CONVERSE_MODELS`,
     please update this test to read `bedrock_converse` models from the model cost map.
     """
     for model in litellm.BEDROCK_CONVERSE_MODELS:
@@ -380,7 +380,7 @@ def test_transform_response_with_computer_use_tool():
         @property
         def text(self):
             return json.dumps(response_json)
-    
+
     config = AmazonConverseConfig()
     model_response = ModelResponse()
     optional_params = {
@@ -471,7 +471,7 @@ def test_transform_response_with_bash_tool():
         @property
         def text(self):
             return json.dumps(response_json)
-    
+
     config = AmazonConverseConfig()
     model_response = ModelResponse()
     optional_params = {
@@ -525,7 +525,7 @@ def test_transform_response_with_structured_response_being_called():
                             "toolUseId": "tooluse_456",
                             "name": "json_tool_call",
                             "input": {
-                                "Current_Temperature": 62, 
+                                "Current_Temperature": 62,
                                 "Weather_Explanation": "San Francisco typically has mild, cool weather year-round due to its coastal location and marine influence. The city is known for its fog, moderate temperatures, and relatively stable climate with little seasonal variation."},
                         }
                     }
@@ -550,51 +550,51 @@ def test_transform_response_with_structured_response_being_called():
         @property
         def text(self):
             return json.dumps(response_json)
-    
+
     config = AmazonConverseConfig()
     model_response = ModelResponse()
     optional_params = {
         "json_mode": True,
         "tools": [
             {
-                'type': 'function', 
+                'type': 'function',
                 'function': {
-                    'name': 'get_weather', 
-                    'description': 'Get the current weather in a given location', 
+                    'name': 'get_weather',
+                    'description': 'Get the current weather in a given location',
                     'parameters': {
-                        'type': 'object', 
+                        'type': 'object',
                         'properties': {
                             'location': {
-                                'type': 'string', 
+                                'type': 'string',
                                 'description': 'The city and state, e.g. San Francisco, CA'
-                            }, 
+                            },
                             'unit': {
-                                'type': 'string', 
+                                'type': 'string',
                                 'enum': ['celsius', 'fahrenheit']
                             }
-                        }, 
+                        },
                         'required': ['location']
                     }
                 }
-            }, 
+            },
             {
-                'type': 'function', 
+                'type': 'function',
                 'function': {
-                    'name': 'json_tool_call', 
+                    'name': 'json_tool_call',
                     'parameters': {
-                        '$schema': 'http://json-schema.org/draft-07/schema#', 
-                        'type': 'object', 
-                        'required': ['Weather_Explanation', 'Current_Temperature'], 
+                        '$schema': 'http://json-schema.org/draft-07/schema#',
+                        'type': 'object',
+                        'required': ['Weather_Explanation', 'Current_Temperature'],
                         'properties': {
                             'Weather_Explanation': {
-                                'type': ['string', 'null'], 
+                                'type': ['string', 'null'],
                                 'description': '1-2 sentences explaining the weather in the location'
-                            }, 
+                            },
                             'Current_Temperature': {
-                                'type': ['number', 'null'], 
+                                'type': ['number', 'null'],
                                 'description': 'Current temperature in the location'
                             }
-                        }, 
+                        },
                         'additionalProperties': False
                     }
                 }
@@ -629,36 +629,36 @@ def test_transform_response_with_structured_response_calling_tool():
     response_json = {
         "metrics": {
             "latencyMs": 1148
-        }, 
+        },
         "output": {
-            "message": 
+            "message":
             {
                 "content": [
                     {
                         "text": "I\'ll check the current weather in San Francisco for you."
-                    }, 
+                    },
                     {
                         "toolUse": {
                             "input": {
                                 "location": "San Francisco, CA",
                                 "unit": "celsius"
-                            }, 
-                            "name": "get_weather", 
+                            },
+                            "name": "get_weather",
                             "toolUseId": "tooluse_oKk__QrqSUmufMw3Q7vGaQ"
                         }
                     }
-                ], 
+                ],
                 "role": "assistant"
             }
-        }, 
-        "stopReason": "tool_use", 
+        },
+        "stopReason": "tool_use",
         "usage": {
-            "cacheReadInputTokenCount": 0, 
-            "cacheReadInputTokens": 0, 
-            "cacheWriteInputTokenCount": 0, 
-            "cacheWriteInputTokens": 0, 
-            "inputTokens": 534, 
-            "outputTokens": 69, 
+            "cacheReadInputTokenCount": 0,
+            "cacheReadInputTokens": 0,
+            "cacheWriteInputTokenCount": 0,
+            "cacheWriteInputTokens": 0,
+            "inputTokens": 534,
+            "outputTokens": 69,
             "totalTokens": 603
         }
     }
@@ -669,51 +669,51 @@ def test_transform_response_with_structured_response_calling_tool():
         @property
         def text(self):
             return json.dumps(response_json)
-    
+
     config = AmazonConverseConfig()
     model_response = ModelResponse()
     optional_params = {
         "json_mode": True,
         "tools": [
             {
-                'type': 'function', 
+                'type': 'function',
                 'function': {
-                    'name': 'get_weather', 
-                    'description': 'Get the current weather in a given location', 
+                    'name': 'get_weather',
+                    'description': 'Get the current weather in a given location',
                     'parameters': {
-                        'type': 'object', 
+                        'type': 'object',
                         'properties': {
                             'location': {
-                                'type': 'string', 
+                                'type': 'string',
                                 'description': 'The city and state, e.g. San Francisco, CA'
-                            }, 
+                            },
                             'unit': {
-                                'type': 'string', 
+                                'type': 'string',
                                 'enum': ['celsius', 'fahrenheit']
                             }
-                        }, 
+                        },
                         'required': ['location']
                     }
                 }
-            }, 
+            },
             {
-                'type': 'function', 
+                'type': 'function',
                 'function': {
-                    'name': 'json_tool_call', 
+                    'name': 'json_tool_call',
                     'parameters': {
-                        '$schema': 'http://json-schema.org/draft-07/schema#', 
-                        'type': 'object', 
-                        'required': ['Weather_Explanation', 'Current_Temperature'], 
+                        '$schema': 'http://json-schema.org/draft-07/schema#',
+                        'type': 'object',
+                        'required': ['Weather_Explanation', 'Current_Temperature'],
                         'properties': {
                             'Weather_Explanation': {
-                                'type': ['string', 'null'], 
+                                'type': ['string', 'null'],
                                 'description': '1-2 sentences explaining the weather in the location'
-                            }, 
+                            },
                             'Current_Temperature': {
-                                'type': ['number', 'null'], 
+                                'type': ['number', 'null'],
                                 'description': 'Current temperature in the location'
                             }
-                        }, 
+                        },
                         'additionalProperties': False
                     }
                 }
@@ -743,7 +743,7 @@ def test_transform_response_with_structured_response_calling_tool():
 @pytest.mark.asyncio
 async def test_bedrock_bash_tool_acompletion():
     """Test Bedrock with bash tool for ls command using acompletion."""
-    
+
     # Test with bash tool instead of computer tool
     tools = [
         {
@@ -751,14 +751,14 @@ async def test_bedrock_bash_tool_acompletion():
             "name": "bash",
         }
     ]
-    
+
     messages = [
         {
-            "role": "user", 
+            "role": "user",
             "content": "run ls command and find all python files"
         }
     ]
-    
+
     try:
         response = await litellm.acompletion(
             model="bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
@@ -771,13 +771,13 @@ async def test_bedrock_bash_tool_acompletion():
         assert False, "Expected authentication error but got successful response"
     except Exception as e:
         error_str = str(e).lower()
-        
+
         # Check if it's an expected authentication/credentials error
         auth_error_indicators = [
-            "credentials", "authentication", "unauthorized", "access denied", 
+            "credentials", "authentication", "unauthorized", "access denied",
             "aws", "region", "profile", "token", "invalid", "signature"
         ]
-        
+
         if any(auth_error in error_str for auth_error in auth_error_indicators):
             # This is expected - request formatting succeeded, auth failed as expected
             assert True
@@ -789,7 +789,7 @@ async def test_bedrock_bash_tool_acompletion():
 @pytest.mark.asyncio
 async def test_bedrock_computer_use_acompletion():
     """Test Bedrock computer use with acompletion function."""
-    
+
     # Test with computer use tool
     tools = [
         {
@@ -800,10 +800,10 @@ async def test_bedrock_computer_use_acompletion():
             "display_number": 0,
         }
     ]
-    
+
     messages = [
         {
-            "role": "user", 
+            "role": "user",
             "content": [
                 {
                     "type": "text",
@@ -818,7 +818,7 @@ async def test_bedrock_computer_use_acompletion():
             ]
         }
     ]
-    
+
     try:
         response = await litellm.acompletion(
             model="bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
@@ -831,13 +831,13 @@ async def test_bedrock_computer_use_acompletion():
         assert False, "Expected authentication error but got successful response"
     except Exception as e:
         error_str = str(e).lower()
-        
+
         # Check if it's an expected authentication/credentials error
         auth_error_indicators = [
-            "credentials", "authentication", "unauthorized", "access denied", 
+            "credentials", "authentication", "unauthorized", "access denied",
             "aws", "region", "profile", "token", "invalid", "signature"
         ]
-        
+
         if any(auth_error in error_str for auth_error in auth_error_indicators):
             # This is expected - request formatting succeeded, auth failed as expected
             assert True
@@ -849,9 +849,9 @@ async def test_bedrock_computer_use_acompletion():
 @pytest.mark.asyncio
 async def test_transformation_directly():
     """Test the transformation directly to verify the request structure."""
-    
+
     config = AmazonConverseConfig()
-    
+
     tools = [
         {
             "type": "computer_20241022",
@@ -865,14 +865,14 @@ async def test_transformation_directly():
             "name": "bash",
         }
     ]
-    
+
     messages = [
         {
             "role": "user",
             "content": "run ls command and find all python files"
         }
     ]
-    
+
     # Transform request
     request_data = config.transform_request(
         model="anthropic.claude-3-5-sonnet-20241022-v2:0",
@@ -881,19 +881,19 @@ async def test_transformation_directly():
         litellm_params={},
         headers={}
     )
-    
+
     # Verify the structure
     assert "additionalModelRequestFields" in request_data
     additional_fields = request_data["additionalModelRequestFields"]
-    
+
     # Check that anthropic_beta is set correctly for computer use
     assert "anthropic_beta" in additional_fields
     assert additional_fields["anthropic_beta"] == ["computer-use-2024-10-22"]
-    
+
     # Check that tools are present
     assert "tools" in additional_fields
     assert len(additional_fields["tools"]) == 2
-    
+
     # Verify tool types
     tool_types = [tool.get("type") for tool in additional_fields["tools"]]
     assert "computer_20241022" in tool_types
@@ -933,7 +933,7 @@ def test_transform_request_helper_includes_anthropic_beta_and_tools_bash():
 def test_transform_request_with_multiple_tools():
     """Test transformation with multiple tools including computer, bash, and function tools."""
     config = AmazonConverseConfig()
-    
+
     # Use the exact payload from the user's error
     tools = [
         {
@@ -974,14 +974,14 @@ def test_transform_request_with_multiple_tools():
             }
         }
     ]
-    
+
     messages = [
         {
             "role": "user",
             "content": "run ls command and find all python files"
         }
     ]
-    
+
     # Transform request
     request_data = config.transform_request(
         model="anthropic.claude-3-5-sonnet-20241022-v2:0",
@@ -990,25 +990,25 @@ def test_transform_request_with_multiple_tools():
         litellm_params={},
         headers={}
     )
-    
+
     # Verify the structure
     assert "additionalModelRequestFields" in request_data
     additional_fields = request_data["additionalModelRequestFields"]
-    
+
     # Check that anthropic_beta is set correctly for computer use
     assert "anthropic_beta" in additional_fields
     assert additional_fields["anthropic_beta"] == ["computer-use-2024-10-22"]
-    
+
     # Check that tools are present
     assert "tools" in additional_fields
     assert len(additional_fields["tools"]) == 3  # computer, bash, text_editor tools
-    
+
     # Verify tool types
     tool_types = [tool.get("type") for tool in additional_fields["tools"]]
     assert "computer_20241022" in tool_types
     assert "bash_20241022" in tool_types
     assert "text_editor_20241022" in tool_types
-    
+
     # Function tools are processed separately and not included in computer use tools
     # They would be in toolConfig if present
 
@@ -1016,7 +1016,7 @@ def test_transform_request_with_multiple_tools():
 def test_transform_request_with_computer_tool_only():
     """Test transformation with only computer tool."""
     config = AmazonConverseConfig()
-    
+
     tools = [
         {
             "type": "computer_20241022",
@@ -1026,10 +1026,10 @@ def test_transform_request_with_computer_tool_only():
             "display_number": 0,
         }
     ]
-    
+
     messages = [
         {
-            "role": "user", 
+            "role": "user",
             "content": [
                 {
                     "type": "text",
@@ -1044,7 +1044,7 @@ def test_transform_request_with_computer_tool_only():
             ]
         }
     ]
-    
+
     # Transform request
     request_data = config.transform_request(
         model="anthropic.claude-3-5-sonnet-20241022-v2:0",
@@ -1053,15 +1053,15 @@ def test_transform_request_with_computer_tool_only():
         litellm_params={},
         headers={}
     )
-    
+
     # Verify the structure
     assert "additionalModelRequestFields" in request_data
     additional_fields = request_data["additionalModelRequestFields"]
-    
+
     # Check that anthropic_beta is set correctly for computer use
     assert "anthropic_beta" in additional_fields
     assert additional_fields["anthropic_beta"] == ["computer-use-2024-10-22"]
-    
+
     # Check that tools are present
     assert "tools" in additional_fields
     assert len(additional_fields["tools"]) == 1
@@ -1071,21 +1071,21 @@ def test_transform_request_with_computer_tool_only():
 def test_transform_request_with_bash_tool_only():
     """Test transformation with only bash tool."""
     config = AmazonConverseConfig()
-    
+
     tools = [
         {
             "type": "bash_20241022",
             "name": "bash",
         }
     ]
-    
+
     messages = [
         {
-            "role": "user", 
+            "role": "user",
             "content": "run ls command and find all python files"
         }
     ]
-    
+
     # Transform request
     request_data = config.transform_request(
         model="anthropic.claude-3-5-sonnet-20241022-v2:0",
@@ -1094,15 +1094,15 @@ def test_transform_request_with_bash_tool_only():
         litellm_params={},
         headers={}
     )
-    
+
     # Verify the structure
     assert "additionalModelRequestFields" in request_data
     additional_fields = request_data["additionalModelRequestFields"]
-    
+
     # Check that anthropic_beta is set correctly for computer use
     assert "anthropic_beta" in additional_fields
     assert additional_fields["anthropic_beta"] == ["computer-use-2024-10-22"]
-    
+
     # Check that tools are present
     assert "tools" in additional_fields
     assert len(additional_fields["tools"]) == 1
@@ -1112,21 +1112,21 @@ def test_transform_request_with_bash_tool_only():
 def test_transform_request_with_text_editor_tool():
     """Test transformation with text editor tool."""
     config = AmazonConverseConfig()
-    
+
     tools = [
         {
             "type": "text_editor_20241022",
             "name": "str_replace_editor",
         }
     ]
-    
+
     messages = [
         {
             "role": "user",
             "content": "Edit this text file"
         }
     ]
-    
+
     # Transform request
     request_data = config.transform_request(
         model="anthropic.claude-3-5-sonnet-20241022-v2:0",
@@ -1135,15 +1135,15 @@ def test_transform_request_with_text_editor_tool():
         litellm_params={},
         headers={}
     )
-    
+
     # Verify the structure
     assert "additionalModelRequestFields" in request_data
     additional_fields = request_data["additionalModelRequestFields"]
-    
+
     # Check that anthropic_beta is set correctly for computer use
     assert "anthropic_beta" in additional_fields
     assert additional_fields["anthropic_beta"] == ["computer-use-2024-10-22"]
-    
+
     # Check that tools are present
     assert "tools" in additional_fields
     assert len(additional_fields["tools"]) == 1
@@ -1153,7 +1153,7 @@ def test_transform_request_with_text_editor_tool():
 def test_transform_request_with_function_tool():
     """Test transformation with function tool."""
     config = AmazonConverseConfig()
-    
+
     tools = [
         {
             "type": "function",
@@ -1174,14 +1174,14 @@ def test_transform_request_with_function_tool():
             }
         }
     ]
-    
+
     messages = [
         {
             "role": "user",
             "content": "What's the weather like in San Francisco?"
         }
     ]
-    
+
     # Transform request
     request_data = config.transform_request(
         model="anthropic.claude-3-5-sonnet-20241022-v2:0",
@@ -1190,11 +1190,11 @@ def test_transform_request_with_function_tool():
         litellm_params={},
         headers={}
     )
-    
+
     # Verify the structure
     assert "additionalModelRequestFields" in request_data
     additional_fields = request_data["additionalModelRequestFields"]
-    
+
     # Function tools are not computer use tools, so they don't get anthropic_beta
     # They are processed through the regular tool config
     assert "toolConfig" in request_data
@@ -1206,7 +1206,7 @@ def test_transform_request_with_function_tool():
 def test_map_openai_params_with_response_format():
     """Test map_openai_params with response_format."""
     config = AmazonConverseConfig()
-    
+
     tools = [
         {
             "type": "function",
@@ -1277,12 +1277,12 @@ async def test_assistant_message_cache_control():
     messages = [
         {"role": "user", "content": "Hello"},
         {
-            "role": "assistant", 
+            "role": "assistant",
             "content": "Hi there!",
             "cache_control": {"type": "ephemeral"}
         }
     ]
-    
+
     result = _bedrock_converse_messages_pt(
         messages=messages,
         model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
@@ -1294,7 +1294,7 @@ async def test_assistant_message_cache_control():
         model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
         llm_provider="bedrock_converse"
     )
-    
+
     assert result == async_result
 
     async_result = await BedrockConverseMessagesProcessor._bedrock_converse_messages_pt_async(
@@ -1302,14 +1302,14 @@ async def test_assistant_message_cache_control():
         model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
         llm_provider="bedrock_converse"
     )
-    
+
     assert result == async_result
-    
+
     # Should have user message and assistant message
     assert len(result) == 2
     assert result[0]["role"] == "user"
     assert result[1]["role"] == "assistant"
-    
+
     # Assistant message should have text content and cachePoint
     assistant_content = result[1]["content"]
     assert len(assistant_content) == 2
@@ -1325,7 +1325,7 @@ async def test_assistant_message_list_content_cache_control():
         BedrockConverseMessagesProcessor,
         _bedrock_converse_messages_pt,
     )
-    
+
     messages = [
         {"role": "user", "content": "Hello"},
         {
@@ -1339,7 +1339,7 @@ async def test_assistant_message_list_content_cache_control():
             ]
         }
     ]
-    
+
     result = _bedrock_converse_messages_pt(
         messages=messages,
         model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
@@ -1351,9 +1351,9 @@ async def test_assistant_message_list_content_cache_control():
         model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
         llm_provider="bedrock_converse"
     )
-    
+
     assert result == async_result
-    
+
     # Assistant message should have text content and cachePoint
     assistant_content = result[1]["content"]
     assert len(assistant_content) == 2
@@ -1369,7 +1369,7 @@ async def test_tool_message_cache_control():
         BedrockConverseMessagesProcessor,
         _bedrock_converse_messages_pt,
     )
-    
+
     messages = [
         {"role": "user", "content": "What's the weather?"},
         {
@@ -1395,7 +1395,7 @@ async def test_tool_message_cache_control():
             ]
         }
     ]
-    
+
     result = _bedrock_converse_messages_pt(
         messages=messages,
         model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
@@ -1407,20 +1407,20 @@ async def test_tool_message_cache_control():
         model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
         llm_provider="bedrock_converse"
     )
-    
+
     assert result == async_result
-    
+
     # Should have user, assistant, and user (tool results) messages
     assert len(result) == 3
-    
+
     # Last message should contain tool result and cachePoint
     tool_message_content = result[2]["content"]
     assert len(tool_message_content) == 2
-    
+
     # First should be tool result
     assert "toolResult" in tool_message_content[0]
     assert tool_message_content[0]["toolResult"]["content"][0]["text"] == "Weather data: sunny, 25°C"
-    
+
     # Second should be cachePoint
     assert "cachePoint" in tool_message_content[1]
     assert tool_message_content[1]["cachePoint"]["type"] == "default"
@@ -1433,7 +1433,7 @@ async def test_tool_message_string_content_cache_control():
         BedrockConverseMessagesProcessor,
         _bedrock_converse_messages_pt,
     )
-    
+
     messages = [
         {"role": "user", "content": "What's the weather?"},
         {
@@ -1442,7 +1442,7 @@ async def test_tool_message_string_content_cache_control():
             "tool_calls": [
                 {
                     "id": "call_123",
-                    "type": "function", 
+                    "type": "function",
                     "function": {"name": "get_weather", "arguments": "{}"}
                 }
             ]
@@ -1454,7 +1454,7 @@ async def test_tool_message_string_content_cache_control():
             "cache_control": {"type": "ephemeral"}
         }
     ]
-    
+
     result = _bedrock_converse_messages_pt(
         messages=messages,
         model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
@@ -1466,17 +1466,17 @@ async def test_tool_message_string_content_cache_control():
         model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
         llm_provider="bedrock_converse"
     )
-    
+
     assert result == async_result
-    
+
     # Last message should contain tool result and cachePoint
     tool_message_content = result[2]["content"]
     assert len(tool_message_content) == 2
-    
+
     # First should be tool result
     assert "toolResult" in tool_message_content[0]
     assert tool_message_content[0]["toolResult"]["content"][0]["text"] == "Weather: sunny, 25°C"
-    
+
     # Second should be cachePoint
     assert "cachePoint" in tool_message_content[1]
     assert tool_message_content[1]["cachePoint"]["type"] == "default"
@@ -1489,7 +1489,7 @@ async def test_assistant_tool_calls_cache_control():
         BedrockConverseMessagesProcessor,
         _bedrock_converse_messages_pt,
     )
-    
+
     messages = [
         {"role": "user", "content": "Calculate 2+2"},
         {
@@ -1505,7 +1505,7 @@ async def test_assistant_tool_calls_cache_control():
             ]
         }
     ]
-    
+
     result = _bedrock_converse_messages_pt(
         messages=messages,
         model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
@@ -1517,18 +1517,18 @@ async def test_assistant_tool_calls_cache_control():
         model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
         llm_provider="bedrock_converse"
     )
-    
+
     assert result == async_result
-    
+
     # Assistant message should have tool use and cachePoint
     assistant_content = result[1]["content"]
     assert len(assistant_content) == 2
-    
+
     # First should be tool use
     assert "toolUse" in assistant_content[0]
     assert assistant_content[0]["toolUse"]["name"] == "calc"
     assert assistant_content[0]["toolUse"]["toolUseId"] == "call_proxy_123"
-    
+
     # Second should be cachePoint
     assert "cachePoint" in assistant_content[1]
     assert assistant_content[1]["cachePoint"]["type"] == "default"
@@ -1541,7 +1541,7 @@ async def test_multiple_tool_calls_with_mixed_cache_control():
         BedrockConverseMessagesProcessor,
         _bedrock_converse_messages_pt,
     )
-    
+
     messages = [
         {"role": "user", "content": "Do multiple calculations"},
         {
@@ -1563,7 +1563,7 @@ async def test_multiple_tool_calls_with_mixed_cache_control():
             ]
         }
     ]
-    
+
     result = _bedrock_converse_messages_pt(
         messages=messages,
         model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
@@ -1575,21 +1575,21 @@ async def test_multiple_tool_calls_with_mixed_cache_control():
         model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
         llm_provider="bedrock_converse"
     )
-    
+
     assert result == async_result
-    
+
     # Assistant message should have: toolUse1, cachePoint, toolUse2
     assistant_content = result[1]["content"]
     assert len(assistant_content) == 3
-    
+
     # First tool use with cache
     assert "toolUse" in assistant_content[0]
     assert assistant_content[0]["toolUse"]["toolUseId"] == "call_1"
-    
+
     # Cache point for first tool
     assert "cachePoint" in assistant_content[1]
     assert assistant_content[1]["cachePoint"]["type"] == "default"
-    
+
     # Second tool use without cache
     assert "toolUse" in assistant_content[2]
     assert assistant_content[2]["toolUse"]["toolUseId"] == "call_2"
@@ -1602,7 +1602,7 @@ async def test_no_cache_control_no_cache_point():
         BedrockConverseMessagesProcessor,
         _bedrock_converse_messages_pt,
     )
-    
+
     messages = [
         {"role": "user", "content": "Hello"},
         {"role": "assistant", "content": "Hi there!"},  # No cache_control
@@ -1612,7 +1612,7 @@ async def test_no_cache_control_no_cache_point():
             "content": "Tool result"  # No cache_control
         }
     ]
-    
+
     result = _bedrock_converse_messages_pt(
         messages=messages,
         model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
@@ -1624,14 +1624,14 @@ async def test_no_cache_control_no_cache_point():
         model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
         llm_provider="bedrock_converse"
     )
-    
+
     assert result == async_result
-    
+
     # Assistant message should only have text content, no cachePoint
     assistant_content = result[1]["content"]
     assert len(assistant_content) == 1
     assert assistant_content[0]["text"] == "Hi there!"
-    
+
     # Tool message should only have tool result, no cachePoint
     tool_content = result[2]["content"]
     assert len(tool_content) == 1
@@ -1867,11 +1867,11 @@ def test_guarded_text_with_tool_calls():
     # First should be regular text
     assert "text" in content[0]
     assert content[0]["text"] == "What's the weather?"
-    
+
     # Second should be guardContent
     assert "guardContent" in content[1]
     assert content[1]["guardContent"]["text"]["text"] == "Please be careful with sensitive information"
-    
+
     # Other messages should not have guardContent
     for i in range(1, 3):
         content = result[i]["content"]
@@ -2115,7 +2115,7 @@ def test_auto_convert_in_full_transformation():
     # Verify the transformation worked
     assert "messages" in result
     assert len(result["messages"]) == 1
-    
+
     # The message should have guardContent
     message = result["messages"][0]
     assert "content" in message
@@ -2626,79 +2626,79 @@ def test_empty_assistant_message_handling():
         {"role": "assistant", "content": ""},  # Empty content
         {"role": "user", "content": "How are you?"}
     ]
-    
+
     # Enable modify_params to prevent consecutive user message merging
     original_modify_params = litellm.modify_params
     litellm.modify_params = True
-    
+
     try:
         result = _bedrock_converse_messages_pt(
             messages=messages,
             model="anthropic.claude-3-5-sonnet-20240620-v1:0",
             llm_provider="bedrock_converse"
         )
-        
+
         # Should have 3 messages: user, assistant (with placeholder), user
         assert len(result) == 3
         assert result[0]["role"] == "user"
         assert result[1]["role"] == "assistant"
         assert result[2]["role"] == "user"
-        
+
         # Assistant message should have placeholder text instead of empty content
         assert len(result[1]["content"]) == 1
         assert result[1]["content"][0]["text"] == "Please continue."
-        
+
         # Test case 2: Whitespace-only content
         messages = [
             {"role": "user", "content": "Hello"},
             {"role": "assistant", "content": "   "},  # Whitespace-only content
             {"role": "user", "content": "How are you?"}
         ]
-        
+
         result = _bedrock_converse_messages_pt(
             messages=messages,
             model="anthropic.claude-3-5-sonnet-20240620-v1:0",
             llm_provider="bedrock_converse"
         )
-        
+
         # Assistant message should have placeholder text instead of whitespace
         assert len(result[1]["content"]) == 1
         assert result[1]["content"][0]["text"] == "Please continue."
-        
+
         # Test case 3: Empty list content
         messages = [
             {"role": "user", "content": "Hello"},
             {"role": "assistant", "content": [{"type": "text", "text": ""}]},  # Empty text in list
             {"role": "user", "content": "How are you?"}
         ]
-        
+
         result = _bedrock_converse_messages_pt(
             messages=messages,
             model="anthropic.claude-3-5-sonnet-20240620-v1:0",
             llm_provider="bedrock_converse"
         )
-        
+
         # Assistant message should have placeholder text instead of empty text
         assert len(result[1]["content"]) == 1
         assert result[1]["content"][0]["text"] == "Please continue."
-        
+
         # Test case 4: Normal content should not be affected
         messages = [
             {"role": "user", "content": "Hello"},
             {"role": "assistant", "content": "I'm doing well, thank you!"},  # Normal content
             {"role": "user", "content": "How are you?"}
         ]
-        
+
         result = _bedrock_converse_messages_pt(
             messages=messages,
             model="anthropic.claude-3-5-sonnet-20240620-v1:0",
             llm_provider="bedrock_converse"
         )
-        
+
         # Assistant message should keep original content
         assert len(result[1]["content"]) == 1
         assert result[1]["content"][0]["text"] == "I'm doing well, thank you!"
-        
+
     finally:
         # Restore original modify_params setting
         litellm.modify_params = original_modify_params
@@ -2707,30 +2707,30 @@ def test_empty_assistant_message_handling():
 def test_is_nova_lite_2_model():
     """Test the _is_nova_lite_2_model() method for detecting Nova 2 models."""
     config = AmazonConverseConfig()
-    
+
     # Test with amazon.nova-2-lite-v1:0
     assert config._is_nova_lite_2_model("amazon.nova-2-lite-v1:0") is True
-    
+
     # Test with regional variants
     assert config._is_nova_lite_2_model("us.amazon.nova-2-lite-v1:0") is True
     assert config._is_nova_lite_2_model("eu.amazon.nova-2-lite-v1:0") is True
     assert config._is_nova_lite_2_model("apac.amazon.nova-2-lite-v1:0") is True
-    
+
     # Test with other Nova 2 variants (pro, micro)
     assert config._is_nova_lite_2_model("amazon.nova-pro-1-5-v1:0") is False
     assert config._is_nova_lite_2_model("amazon.nova-micro-1-5-v1:0") is False
     assert config._is_nova_lite_2_model("us.amazon.nova-pro-1-5-v1:0") is False
     assert config._is_nova_lite_2_model("eu.amazon.nova-micro-1-5-v1:0") is False
-    
+
     # Test with non-Nova-1.5 lite models (should return False)
     assert config._is_nova_lite_2_model("amazon.nova-lite-v1:0") is False
     assert config._is_nova_lite_2_model("amazon.nova-pro-v1:0") is False
     assert config._is_nova_lite_2_model("amazon.nova-micro-v1:0") is False
-    
+
     # Test with Nova v1:0 models (should return False)
     assert config._is_nova_lite_2_model("us.amazon.nova-lite-v1:0") is False
     assert config._is_nova_lite_2_model("eu.amazon.nova-pro-v1:0") is False
-    
+
     # Test with completely different models (should return False)
     assert config._is_nova_lite_2_model("anthropic.claude-3-5-sonnet-20240620-v1:0") is False
     assert config._is_nova_lite_2_model("meta.llama3-70b-instruct-v1:0") is False
@@ -2740,21 +2740,21 @@ def test_is_nova_lite_2_model():
 def test_thinking_with_max_completion_tokens():
     """Test that thinking respects max_completion_tokens parameter."""
     config = AmazonConverseConfig()
-    
+
     # Test case 1: max_completion_tokens is specified - should NOT set maxTokens automatically
     non_default_params_with_max_completion = {
         "thinking": {"type": "enabled", "budget_tokens": 5000},
         "max_completion_tokens": 10000,
     }
     optional_params = {}
-    
+
     result = config.map_openai_params(
         non_default_params=non_default_params_with_max_completion,
         optional_params=optional_params,
         model="us.anthropic.claude-3-7-sonnet-20250219-v1:0",
         drop_params=False,
     )
-    
+
     # Should have maxTokens set to max_completion_tokens value
     assert "maxTokens" in result
     assert result["maxTokens"] == 10000
@@ -2762,21 +2762,21 @@ def test_thinking_with_max_completion_tokens():
     assert "thinking" in result
     assert result["thinking"]["type"] == "enabled"
     assert result["thinking"]["budget_tokens"] == 5000
-    
+
     # Test case 2: max_tokens is specified - should NOT set maxTokens automatically
     non_default_params_with_max_tokens = {
         "thinking": {"type": "enabled", "budget_tokens": 5000},
         "max_tokens": 8000,
     }
     optional_params = {}
-    
+
     result = config.map_openai_params(
         non_default_params=non_default_params_with_max_tokens,
         optional_params=optional_params,
         model="us.anthropic.claude-3-7-sonnet-20250219-v1:0",
         drop_params=False,
     )
-    
+
     # Should have maxTokens set to max_tokens value
     assert "maxTokens" in result
     assert result["maxTokens"] == 8000
@@ -2784,22 +2784,22 @@ def test_thinking_with_max_completion_tokens():
     assert "thinking" in result
     assert result["thinking"]["type"] == "enabled"
     assert result["thinking"]["budget_tokens"] == 5000
-    
+
     # Test case 3: Neither max_tokens nor max_completion_tokens specified - should set maxTokens automatically
     from litellm.constants import DEFAULT_MAX_TOKENS
-    
+
     non_default_params_without_max = {
         "thinking": {"type": "enabled", "budget_tokens": 5000},
     }
     optional_params = {}
-    
+
     result = config.map_openai_params(
         non_default_params=non_default_params_without_max,
         optional_params=optional_params,
         model="us.anthropic.claude-3-7-sonnet-20250219-v1:0",
         drop_params=False,
     )
-    
+
     # Should have maxTokens set to budget_tokens + DEFAULT_MAX_TOKENS
     assert "maxTokens" in result
     assert result["maxTokens"] == 5000 + DEFAULT_MAX_TOKENS
@@ -2807,3 +2807,133 @@ def test_thinking_with_max_completion_tokens():
     assert "thinking" in result
     assert result["thinking"]["type"] == "enabled"
     assert result["thinking"]["budget_tokens"] == 5000
+
+def test_drop_thinking_param_when_thinking_blocks_missing():
+    """
+    Test that thinking param is dropped when modify_params=True and
+    thinking_blocks are missing from assistant message with tool_calls.
+
+    This prevents the Anthropic/Bedrock error:
+    "Expected thinking or redacted_thinking, but found tool_use"
+
+    Related issue: https://github.com/BerriAI/litellm/issues/14194
+    """
+    from litellm.utils import last_assistant_with_tool_calls_has_no_thinking_blocks
+
+    # Save original modify_params setting
+    original_modify_params = litellm.modify_params
+
+    try:
+        # Test case 1: thinking should be dropped when modify_params=True
+        # and assistant message has tool_calls but no thinking_blocks
+        litellm.modify_params = True
+
+        messages_without_thinking_blocks = [
+            {"role": "user", "content": "Search for weather"},
+            {
+                "role": "assistant",
+                "content": "",
+                "tool_calls": [
+                    {
+                        "id": "call_123",
+                        "type": "function",
+                        "function": {"name": "search", "arguments": "{}"},
+                    }
+                ],
+                # No thinking_blocks - simulates OpenAI-compatible client
+            },
+            {"role": "tool", "content": "Weather is sunny", "tool_call_id": "call_123"},
+        ]
+
+        optional_params = {"thinking": {"type": "enabled", "budget_tokens": 1000}}
+
+        # Verify the condition is detected
+        assert last_assistant_with_tool_calls_has_no_thinking_blocks(
+            messages_without_thinking_blocks
+        ), "Should detect missing thinking_blocks"
+
+        # Simulate what _transform_request_helper does
+        if (
+            optional_params.get("thinking") is not None
+            and messages_without_thinking_blocks is not None
+            and last_assistant_with_tool_calls_has_no_thinking_blocks(
+                messages_without_thinking_blocks
+            )
+        ):
+            if litellm.modify_params:
+                optional_params.pop("thinking", None)
+
+        assert "thinking" not in optional_params, (
+            "thinking param should be dropped when modify_params=True "
+            "and thinking_blocks are missing"
+        )
+
+        # Test case 2: thinking should NOT be dropped when thinking_blocks are present
+        messages_with_thinking_blocks = [
+            {"role": "user", "content": "Search for weather"},
+            {
+                "role": "assistant",
+                "content": "",
+                "tool_calls": [
+                    {
+                        "id": "call_123",
+                        "type": "function",
+                        "function": {"name": "search", "arguments": "{}"},
+                    }
+                ],
+                "thinking_blocks": [
+                    {"type": "thinking", "thinking": "Let me search for weather..."}
+                ],
+            },
+            {"role": "tool", "content": "Weather is sunny", "tool_call_id": "call_123"},
+        ]
+
+        optional_params_with_thinking = {
+            "thinking": {"type": "enabled", "budget_tokens": 1000}
+        }
+
+        # Verify the condition is NOT detected when thinking_blocks are present
+        assert not last_assistant_with_tool_calls_has_no_thinking_blocks(
+            messages_with_thinking_blocks
+        ), "Should NOT detect missing thinking_blocks when they are present"
+
+        # Simulate what _transform_request_helper does
+        if (
+            optional_params_with_thinking.get("thinking") is not None
+            and messages_with_thinking_blocks is not None
+            and last_assistant_with_tool_calls_has_no_thinking_blocks(
+                messages_with_thinking_blocks
+            )
+        ):
+            if litellm.modify_params:
+                optional_params_with_thinking.pop("thinking", None)
+
+        assert "thinking" in optional_params_with_thinking, (
+            "thinking param should NOT be dropped when thinking_blocks are present"
+        )
+
+        # Test case 3: thinking should NOT be dropped when modify_params=False
+        litellm.modify_params = False
+
+        optional_params_no_modify = {
+            "thinking": {"type": "enabled", "budget_tokens": 1000}
+        }
+
+        # Simulate what _transform_request_helper does
+        if (
+            optional_params_no_modify.get("thinking") is not None
+            and messages_without_thinking_blocks is not None
+            and last_assistant_with_tool_calls_has_no_thinking_blocks(
+                messages_without_thinking_blocks
+            )
+        ):
+            if litellm.modify_params:
+                optional_params_no_modify.pop("thinking", None)
+
+        assert "thinking" in optional_params_no_modify, (
+            "thinking param should NOT be dropped when modify_params=False"
+        )
+
+    finally:
+        # Restore original modify_params setting
+        litellm.modify_params = original_modify_params
diff --git a/tests/test_litellm/llms/chatgpt/responses/test_chatgpt_responses_transformation.py b/tests/test_litellm/llms/chatgpt/responses/test_chatgpt_responses_transformation.py
new file mode 100644
index 00000000000..bec748d8dc8
--- /dev/null
+++ b/tests/test_litellm/llms/chatgpt/responses/test_chatgpt_responses_transformation.py
@@ -0,0 +1,125 @@
+"""
+Tests for ChatGPT subscription Responses API transformation
+
+Source: litellm/llms/chatgpt/responses/transformation.py
+"""
+import json
+import os
+import sys
+from unittest.mock import MagicMock, patch
+
+import httpx
+
+sys.path.insert(0, os.path.abspath("../../../../.."))
+
+from litellm.types.router import GenericLiteLLMParams
+from litellm.types.utils import LlmProviders
+from litellm.utils import ProviderConfigManager
+from litellm.llms.chatgpt.responses.transformation import ChatGPTResponsesAPIConfig
+
+
+class TestChatGPTResponsesAPITransformation:
+    def test_chatgpt_provider_config_registration(self):
+        config = ProviderConfigManager.get_provider_responses_api_config(
+            model="chatgpt/gpt-5.2",
+            provider=LlmProviders.CHATGPT,
+        )
+
+        assert config is not None
+        assert isinstance(config, ChatGPTResponsesAPIConfig)
+        assert config.custom_llm_provider == LlmProviders.CHATGPT
+
+    @patch("litellm.llms.chatgpt.responses.transformation.Authenticator")
+    def test_chatgpt_responses_endpoint_url(self, mock_authenticator_class):
+        mock_auth_instance = MagicMock()
+        mock_auth_instance.get_api_base.return_value = "https://chatgpt.example.com"
+        mock_authenticator_class.return_value = mock_auth_instance
+
+        config = ChatGPTResponsesAPIConfig()
+
+        url = config.get_complete_url(api_base=None, litellm_params={})
+        assert url == "https://chatgpt.example.com/responses"
+
+        custom_url = config.get_complete_url(
+            api_base="https://custom.chatgpt.com", litellm_params={}
+        )
+        assert custom_url == "https://custom.chatgpt.com/responses"
+
+        url_with_slash = config.get_complete_url(
+            api_base="https://chatgpt.example.com/", litellm_params={}
+        )
+        assert url_with_slash == "https://chatgpt.example.com/responses"
+
+    @patch("litellm.llms.chatgpt.responses.transformation.Authenticator")
+    def test_validate_environment_headers(self, mock_authenticator_class):
+        mock_auth_instance = MagicMock()
+        mock_auth_instance.get_access_token.return_value = "access-123"
+        mock_auth_instance.get_account_id.return_value = "acct-123"
+        mock_authenticator_class.return_value = mock_auth_instance
+
+        config = ChatGPTResponsesAPIConfig()
+        litellm_params = GenericLiteLLMParams(litellm_session_id="session-123")
+        headers = config.validate_environment(
+            headers={"originator": "custom-origin"},
+            model="gpt-5.2",
+            litellm_params=litellm_params,
+        )
+
+        assert headers["Authorization"] == "Bearer access-123"
+        assert headers["ChatGPT-Account-Id"] == "acct-123"
+        assert headers["originator"] == "custom-origin"
+        assert headers["content-type"] == "application/json"
+        assert headers["accept"] == "text/event-stream"
+        assert headers["session_id"] == "session-123"
+
+    def test_chatgpt_forces_streaming_and_reasoning_include(self):
+        config = ChatGPTResponsesAPIConfig()
+        request = config.transform_responses_api_request(
+            model="chatgpt/gpt-5.2-codex",
+            input="hi",
+            response_api_optional_request_params={},
+            litellm_params=GenericLiteLLMParams(),
+            headers={},
+        )
+
+        assert request["stream"] is True
+        assert "reasoning.encrypted_content" in request["include"]
+        assert request["instructions"].startswith(
+            "You are Codex, based on GPT-5."
+        )
+
+    def test_chatgpt_non_stream_sse_response_parsing(self):
+        config = ChatGPTResponsesAPIConfig()
+        response_payload = {
+            "id": "resp_test",
+            "object": "response",
+            "created_at": 1700000000,
+            "status": "completed",
+            "model": "gpt-5.2-codex",
+            "output": [
+                {
+                    "type": "message",
+                    "role": "assistant",
+                    "content": [{"type": "output_text", "text": "Hello!"}],
+                }
+            ],
+        }
+        sse_body = "\n".join(
+            [
+                f"data: {json.dumps({'type': 'response.completed', 'response': response_payload})}",
+                "data: [DONE]",
+                "",
+            ]
+        )
+        raw_response = httpx.Response(
+            200, headers={"content-type": "text/event-stream"}, text=sse_body
+        )
+        logging_obj = MagicMock()
+
+        parsed = config.transform_response_api_response(
+            model="chatgpt/gpt-5.2-codex",
+            raw_response=raw_response,
+            logging_obj=logging_obj,
+        )
+
+        assert parsed.output_text == "Hello!"
diff --git a/tests/test_litellm/llms/chatgpt/test_chatgpt_authenticator.py b/tests/test_litellm/llms/chatgpt/test_chatgpt_authenticator.py
new file mode 100644
index 00000000000..5a4b58e159a
--- /dev/null
+++ b/tests/test_litellm/llms/chatgpt/test_chatgpt_authenticator.py
@@ -0,0 +1,68 @@
+import base64
+import json
+import time
+from unittest.mock import mock_open, patch
+
+import pytest
+
+from litellm.llms.chatgpt.authenticator import Authenticator
+
+
+def _make_jwt(payload: dict) -> str:
+    header = {"alg": "none", "typ": "JWT"}
+
+    def _b64(obj: dict) -> str:
+        raw = json.dumps(obj, separators=(",", ":")).encode("utf-8")
+        return base64.urlsafe_b64encode(raw).decode("utf-8").rstrip("=")
+
+    return f"{_b64(header)}.{_b64(payload)}."
+
+
+class TestChatGPTAuthenticator:
+    @pytest.fixture
+    def authenticator(self):
+        with patch("os.path.exists", return_value=True):
+            return Authenticator()
+
+    def test_get_access_token_from_file(self, authenticator):
+        future_time = time.time() + 3600
+        auth_data = json.dumps({"access_token": "token-123", "expires_at": future_time})
+
+        with patch("builtins.open", mock_open(read_data=auth_data)):
+            token = authenticator.get_access_token()
+            assert token == "token-123"
+
+    def test_get_access_token_refresh(self, authenticator):
+        past_time = time.time() - 10
+        auth_data = json.dumps(
+            {
+                "access_token": "token-old",
+                "refresh_token": "refresh-123",
+                "expires_at": past_time,
+            }
+        )
+        refreshed = {
+            "access_token": "token-new",
+            "refresh_token": "refresh-123",
+            "id_token": "id-123",
+        }
+
+        with patch("builtins.open", mock_open(read_data=auth_data)), patch.object(
+            authenticator, "_refresh_tokens", return_value=refreshed
+        ):
+            token = authenticator.get_access_token()
+            assert token == "token-new"
+
+    def test_get_account_id_from_id_token(self, authenticator):
+        id_token = _make_jwt(
+            {"https://api.openai.com/auth": {"chatgpt_account_id": "acct-123"}}
+        )
+        auth_data = json.dumps({"id_token": id_token})
+
+        with patch("builtins.open", mock_open(read_data=auth_data)), patch.object(
+            authenticator, "_write_auth_file"
+        ) as mock_write:
+            account_id = authenticator.get_account_id()
+            assert account_id == "acct-123"
+            mock_write.assert_called_once()
+            assert mock_write.call_args[0][0]["account_id"] == "acct-123"
diff --git a/tests/test_litellm/llms/openai/realtime/test_openai_realtime_handler.py b/tests/test_litellm/llms/openai/realtime/test_openai_realtime_handler.py
index eb9f8027761..87923a8093b 100644
--- a/tests/test_litellm/llms/openai/realtime/test_openai_realtime_handler.py
+++ b/tests/test_litellm/llms/openai/realtime/test_openai_realtime_handler.py
@@ -265,3 +265,61 @@ async def test_async_realtime_uses_max_size_parameter():
 
         mock_realtime_streaming.assert_called_once()
         mock_streaming_instance.bidirectional_forward.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_async_realtime_ws_url_has_no_ssl():
+    """
+    Test that when using http:// api_base (converted to ws://), the ssl argument
+    is set to None. The websockets library doesn't accept ssl argument for ws:// URIs.
+
+    This verifies the fix for: https://github.com/BerriAI/litellm/issues/19222
+    """
+    from litellm.llms.openai.realtime.handler import OpenAIRealtime
+    from litellm.types.realtime import RealtimeQueryParams
+
+    handler = OpenAIRealtime()
+    api_base = "http://localhost:8113"  # Non-SSL local server
+    api_key = "test-key"
+    model = "test-model"
+    query_params: RealtimeQueryParams = {"model": model}
+
+    dummy_websocket = AsyncMock()
+    dummy_logging_obj = MagicMock()
+    mock_backend_ws = AsyncMock()
+
+    class DummyAsyncContextManager:
+        def __init__(self, value):
+            self.value = value
+        async def __aenter__(self):
+            return self.value
+        async def __aexit__(self, exc_type, exc, tb):
+            return None
+
+    with patch("websockets.connect", return_value=DummyAsyncContextManager(mock_backend_ws)) as mock_ws_connect, \
+         patch("litellm.llms.openai.realtime.handler.RealTimeStreaming") as mock_realtime_streaming:
+
+        mock_streaming_instance = MagicMock()
+        mock_realtime_streaming.return_value = mock_streaming_instance
+        mock_streaming_instance.bidirectional_forward = AsyncMock()
+
+        await handler.async_realtime(
+            model=model,
+            websocket=dummy_websocket,
+            logging_obj=dummy_logging_obj,
+            api_base=api_base,
+            api_key=api_key,
+            query_params=query_params,
+        )
+
+        # Verify websockets.connect was called
+        mock_ws_connect.assert_called_once()
+        called_url = mock_ws_connect.call_args[0][0]
+        called_kwargs = mock_ws_connect.call_args[1]
+
+        # Verify URL was converted from http:// to ws://
+        assert called_url.startswith("ws://localhost:8113/v1/realtime?")
+        assert f"model={model}" in called_url
+
+        # Verify ssl is None for ws:// URLs (the fix for issue #19222)
+        assert called_kwargs["ssl"] is None
diff --git a/tests/test_litellm/llms/vertex_ai/gemini/test_vertex_and_google_ai_studio_gemini.py b/tests/test_litellm/llms/vertex_ai/gemini/test_vertex_and_google_ai_studio_gemini.py
index fe262b8d840..5be080b53fa 100644
--- a/tests/test_litellm/llms/vertex_ai/gemini/test_vertex_and_google_ai_studio_gemini.py
+++ b/tests/test_litellm/llms/vertex_ai/gemini/test_vertex_and_google_ai_studio_gemini.py
@@ -74,6 +74,10 @@ def test_get_model_name_from_gemini_spec_model():
 
 
 def test_vertex_ai_response_schema_dict():
+    """
+    Test that older Gemini models (1.5) use responseSchema (OpenAPI format).
+    responseSchema requires propertyOrdering and doesn't support additionalProperties.
+    """
     v = VertexGeminiConfig()
     non_default_params = {
         "messages": [{"role": "user", "content": "Hello, world!"}],
@@ -109,7 +113,7 @@ def test_vertex_ai_response_schema_dict():
     transformed_request = v.map_openai_params(
         non_default_params=non_default_params,
         optional_params={},
-        model="gemini-2.0-flash-lite",
+        model="gemini-1.5-flash",  # Old model uses responseSchema (OpenAPI format)
         drop_params=False,
     )
 
@@ -160,6 +164,9 @@ class Step(BaseModel):
 
 
 def test_vertex_ai_response_schema_defs():
+    """
+    Test that $defs are unpacked for older Gemini models using responseSchema.
+    """
     v = VertexGeminiConfig()
 
     schema = cast(dict, v.get_json_schema_from_pydantic_object(MathReasoning))
@@ -173,7 +180,7 @@ def test_vertex_ai_response_schema_defs():
             "response_format": schema,
         },
         optional_params={},
-        model="gemini-2.0-flash-lite",
+        model="gemini-1.5-flash",  # Old model uses responseSchema (OpenAPI format)
         drop_params=False,
     )
 
@@ -203,7 +210,93 @@ def test_vertex_ai_response_schema_defs():
     }
 
 
+def test_vertex_ai_response_json_schema_for_gemini_2():
+    """
+    Test that Gemini 2.0+ models automatically use responseJsonSchema.
+
+    responseJsonSchema uses standard JSON Schema format:
+    - lowercase types (string, object, etc.)
+    - no propertyOrdering required
+    - supports additionalProperties
+    """
+    v = VertexGeminiConfig()
+
+    transformed_request = v.map_openai_params(
+        non_default_params={
+            "messages": [{"role": "user", "content": "Hello, world!"}],
+            "response_format": {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "test_schema",
+                    "schema": {
+                        "type": "object",
+                        "properties": {
+                            "name": {"type": "string"},
+                            "age": {"type": "integer"},
+                        },
+                        "required": ["name"],
+                        "additionalProperties": False,
+                    },
+                },
+            },
+        },
+        optional_params={},
+        model="gemini-2.0-flash",  # Gemini 2.0+ automatically uses responseJsonSchema
+        drop_params=False,
+    )
+
+    # Should use response_json_schema, not response_schema
+    assert "response_json_schema" in transformed_request
+    assert "response_schema" not in transformed_request
+
+    # Types should be lowercase (standard JSON Schema format)
+    assert transformed_request["response_json_schema"]["type"] == "object"
+    assert transformed_request["response_json_schema"]["properties"]["name"]["type"] == "string"
+    assert transformed_request["response_json_schema"]["properties"]["age"]["type"] == "integer"
+
+    # Should NOT have propertyOrdering (not needed for responseJsonSchema)
+    assert "propertyOrdering" not in transformed_request["response_json_schema"]
+
+    # additionalProperties should be preserved (supported by responseJsonSchema)
+    assert transformed_request["response_json_schema"].get("additionalProperties") == False
+
+
+def test_vertex_ai_response_schema_for_old_models():
+    """
+    Test that older models (Gemini 1.5) automatically use responseSchema.
+    """
+    v = VertexGeminiConfig()
+
+    transformed_request = v.map_openai_params(
+        non_default_params={
+            "messages": [{"role": "user", "content": "Hello, world!"}],
+            "response_format": {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "test_schema",
+                    "schema": {
+                        "type": "object",
+                        "properties": {
+                            "name": {"type": "string"},
+                        },
+                    },
+                },
+            },
+        },
+        optional_params={},
+        model="gemini-1.5-flash",  # Old model automatically uses responseSchema
+        drop_params=False,
+    )
+
+    # Should use response_schema for older models
+    assert "response_schema" in transformed_request
+    assert "response_json_schema" not in transformed_request
+
+
 def test_vertex_ai_retain_property_ordering():
+    """
+    Test that existing propertyOrdering is preserved for older models using responseSchema.
+    """
     v = VertexGeminiConfig()
     transformed_request = v.map_openai_params(
         non_default_params={
@@ -224,7 +317,7 @@ def test_vertex_ai_retain_property_ordering():
             },
         },
         optional_params={},
-        model="gemini-2.0-flash-lite",
+        model="gemini-1.5-flash",  # Old model uses responseSchema which needs propertyOrdering
         drop_params=False,
     )
 
diff --git a/tests/test_litellm/llms/vertex_ai/test_vertex_ai_common_utils.py b/tests/test_litellm/llms/vertex_ai/test_vertex_ai_common_utils.py
index 8fdaf4ea2df..953f54e4a54 100644
--- a/tests/test_litellm/llms/vertex_ai/test_vertex_ai_common_utils.py
+++ b/tests/test_litellm/llms/vertex_ai/test_vertex_ai_common_utils.py
@@ -440,7 +440,7 @@ def test_vertex_ai_complex_response_schema():
     optional_params = {}
 
     v.apply_response_schema_transformation(
-        value=non_default_params["response_format"], optional_params=optional_params
+        value=non_default_params["response_format"], optional_params=optional_params, model="gemini-1.5-pro-preview-0409"
     )
 
     # Assertions for the transformed schema
diff --git a/tests/test_litellm/proxy/auth/test_route_checks.py b/tests/test_litellm/proxy/auth/test_route_checks.py
index 04f973e9f86..b8084906fa5 100644
--- a/tests/test_litellm/proxy/auth/test_route_checks.py
+++ b/tests/test_litellm/proxy/auth/test_route_checks.py
@@ -371,6 +371,9 @@ def test_virtual_key_llm_api_routes_allows_registered_pass_through_endpoints():
     with patch(
         "litellm.proxy.pass_through_endpoints.pass_through_endpoints._registered_pass_through_routes",
         mock_registered_routes,
+    ), patch(
+        "litellm.proxy.pass_through_endpoints.pass_through_endpoints.get_server_root_path",
+        return_value="/",
     ):
         # Create a virtual key with llm_api_routes permission
         valid_token = UserAPIKeyAuth(
@@ -417,6 +420,9 @@ def test_virtual_key_without_llm_api_routes_cannot_access_pass_through():
     with patch(
         "litellm.proxy.pass_through_endpoints.pass_through_endpoints._registered_pass_through_routes",
         mock_registered_routes,
+    ), patch(
+        "litellm.proxy.pass_through_endpoints.pass_through_endpoints.get_server_root_path",
+        return_value="/",
     ):
         # Create a virtual key without llm_api_routes permission
         valid_token = UserAPIKeyAuth(
diff --git a/tests/test_litellm/proxy/google_endpoints/test_google_api_endpoints.py b/tests/test_litellm/proxy/google_endpoints/test_google_api_endpoints.py
index 26c60b2c303..2f2eaa905be 100644
--- a/tests/test_litellm/proxy/google_endpoints/test_google_api_endpoints.py
+++ b/tests/test_litellm/proxy/google_endpoints/test_google_api_endpoints.py
@@ -26,30 +26,28 @@ def test_google_generate_content_endpoint():
         from litellm.proxy.google_endpoints.endpoints import router as google_router
     except ImportError as e:
         pytest.skip(f"Skipping test due to missing dependency: {e}")
-    
+
     # Create a FastAPI app and include the router (required for FastAPI 0.120+)
     app = FastAPI()
     app.include_router(google_router)
-    
+
     # Create a test client
     client = TestClient(app)
-    
+
     # Mock the router's agenerate_content method
     with patch("litellm.proxy.proxy_server.llm_router") as mock_router:
         mock_router.agenerate_content = AsyncMock(return_value={"test": "response"})
-        
+
         # Send a request to the endpoint
         response = client.post(
             "/v1beta/models/test-model:generateContent",
-            json={
-                "contents": [{"role": "user", "parts": [{"text": "Hello"}]}]
-            }
+            json={"contents": [{"role": "user", "parts": [{"text": "Hello"}]}]},
         )
-        
+
         # Verify the response
         assert response.status_code == 200
         assert response.json() == {"test": "response"}
-        
+
         # Verify that agenerate_content was called
         mock_router.agenerate_content.assert_called_once()
 
@@ -64,40 +62,42 @@ def test_google_stream_generate_content_endpoint():
         from litellm.proxy.google_endpoints.endpoints import router as google_router
     except ImportError as e:
         pytest.skip(f"Skipping test due to missing dependency: {e}")
-    
+
     # Create a FastAPI app and include the router (required for FastAPI 0.120+)
     app = FastAPI()
     app.include_router(google_router)
-    
+
     # Create a test client
     client = TestClient(app)
-    
+
     # Mock the router's agenerate_content_stream method to return a stream
     async def mock_stream_generator():
         yield 'data: {"test": "stream_chunk_1"}\n\n'
         yield 'data: {"test": "stream_chunk_2"}\n\n'
         yield "data: [DONE]\n\n"
-    
+
     with patch("litellm.proxy.proxy_server.llm_router") as mock_router:
-        mock_router.agenerate_content_stream = AsyncMock(return_value=mock_stream_generator())
-        
+        mock_router.agenerate_content_stream = AsyncMock(
+            return_value=mock_stream_generator()
+        )
+
         # Send a request to the endpoint
         response = client.post(
             "/v1beta/models/test-model:streamGenerateContent",
-            json={
-                "contents": [{"role": "user", "parts": [{"text": "Hello"}]}]
-            }
+            json={"contents": [{"role": "user", "parts": [{"text": "Hello"}]}]},
         )
-        
+
         # Verify the response
         assert response.status_code == 200
-        
+
         # Verify that agenerate_content_stream was called with correct parameters
         mock_router.agenerate_content_stream.assert_called_once()
         call_args = mock_router.agenerate_content_stream.call_args
         assert call_args[1]["stream"] is True
         assert call_args[1]["model"] == "test-model"
-        assert call_args[1]["contents"] == [{"role": "user", "parts": [{"text": "Hello"}]}]
+        assert call_args[1]["contents"] == [
+            {"role": "user", "parts": [{"text": "Hello"}]}
+        ]
 
 
 def test_google_generate_content_with_cost_tracking_metadata():
@@ -110,25 +110,28 @@ def test_google_generate_content_with_cost_tracking_metadata():
         from litellm.proxy.google_endpoints.endpoints import router as google_router
     except ImportError as e:
         pytest.skip(f"Skipping test due to missing dependency: {e}")
-    
+
     # Create a FastAPI app and include the router (required for FastAPI 0.120+)
     app = FastAPI()
     app.include_router(google_router)
-    
+
     # Create a test client
     client = TestClient(app)
-    
+
     # Mock all required proxy server dependencies
-    with patch("litellm.proxy.proxy_server.llm_router") as mock_router, \
-         patch("litellm.proxy.proxy_server.general_settings", {}), \
-         patch("litellm.proxy.proxy_server.proxy_config") as mock_proxy_config, \
-         patch("litellm.proxy.proxy_server.version", "1.0.0"), \
-         patch("litellm.proxy.litellm_pre_call_utils.add_litellm_data_to_request") as mock_add_data:
-        
+    with patch("litellm.proxy.proxy_server.llm_router") as mock_router, patch(
+        "litellm.proxy.proxy_server.general_settings", {}
+    ), patch("litellm.proxy.proxy_server.proxy_config") as mock_proxy_config, patch(
+        "litellm.proxy.proxy_server.version", "1.0.0"
+    ), patch(
+        "litellm.proxy.litellm_pre_call_utils.add_litellm_data_to_request"
+    ) as mock_add_data:
         mock_router.agenerate_content = AsyncMock(return_value={"test": "response"})
-        
+
         # Mock add_litellm_data_to_request to return data with metadata
-        async def mock_add_litellm_data(data, request, user_api_key_dict, proxy_config, general_settings, version):
+        async def mock_add_litellm_data(
+            data, request, user_api_key_dict, proxy_config, general_settings, version
+        ):
             # Simulate adding user metadata
             data["litellm_metadata"] = {
                 "user_api_key_user_id": "test-user-id",
@@ -136,29 +139,27 @@ def test_google_generate_content_with_cost_tracking_metadata():
                 "user_api_key": "hashed-key",
             }
             return data
-        
+
         mock_add_data.side_effect = mock_add_litellm_data
-        
+
         # Send a request to the endpoint
         response = client.post(
             "/v1beta/models/test-model:generateContent",
-            json={
-                "contents": [{"role": "user", "parts": [{"text": "Hello"}]}]
-            },
-            headers={"Authorization": "Bearer sk-test-key"}
+            json={"contents": [{"role": "user", "parts": [{"text": "Hello"}]}]},
+            headers={"Authorization": "Bearer sk-test-key"},
         )
-        
+
         # Verify the response
         assert response.status_code == 200
-        
+
         # Verify that add_litellm_data_to_request was called
         mock_add_data.assert_called_once()
-        
+
         # Verify that agenerate_content was called with metadata
         mock_router.agenerate_content.assert_called_once()
         call_args = mock_router.agenerate_content.call_args
         called_data = call_args[1]
-        
+
         # Verify that litellm_metadata exists and contains user information
         assert "litellm_metadata" in called_data
         assert called_data["litellm_metadata"]["user_api_key_user_id"] == "test-user-id"
@@ -174,30 +175,33 @@ def test_google_stream_generate_content_with_cost_tracking_metadata():
         from litellm.proxy.google_endpoints.endpoints import router as google_router
     except ImportError as e:
         pytest.skip(f"Skipping test due to missing dependency: {e}")
-    
+
     # Create a FastAPI app and include the router (required for FastAPI 0.120+)
     app = FastAPI()
     app.include_router(google_router)
-    
+
     # Create a test client
     client = TestClient(app)
-    
+
     # Mock the router's agenerate_content_stream method to return a stream
     mock_stream = AsyncMock()
     mock_stream.__aiter__ = lambda self: mock_stream
     mock_stream.__anext__.side_effect = StopAsyncIteration
-    
+
     # Mock all required proxy server dependencies
-    with patch("litellm.proxy.proxy_server.llm_router") as mock_router, \
-         patch("litellm.proxy.proxy_server.general_settings", {}), \
-         patch("litellm.proxy.proxy_server.proxy_config") as mock_proxy_config, \
-         patch("litellm.proxy.proxy_server.version", "1.0.0"), \
-         patch("litellm.proxy.litellm_pre_call_utils.add_litellm_data_to_request") as mock_add_data:
-        
+    with patch("litellm.proxy.proxy_server.llm_router") as mock_router, patch(
+        "litellm.proxy.proxy_server.general_settings", {}
+    ), patch("litellm.proxy.proxy_server.proxy_config") as mock_proxy_config, patch(
+        "litellm.proxy.proxy_server.version", "1.0.0"
+    ), patch(
+        "litellm.proxy.litellm_pre_call_utils.add_litellm_data_to_request"
+    ) as mock_add_data:
         mock_router.agenerate_content_stream = AsyncMock(return_value=mock_stream)
-        
+
         # Mock add_litellm_data_to_request to return data with metadata
-        async def mock_add_litellm_data(data, request, user_api_key_dict, proxy_config, general_settings, version):
+        async def mock_add_litellm_data(
+            data, request, user_api_key_dict, proxy_config, general_settings, version
+        ):
             # Simulate adding user metadata
             data["litellm_metadata"] = {
                 "user_api_key_user_id": "test-user-id",
@@ -205,29 +209,27 @@ def test_google_stream_generate_content_with_cost_tracking_metadata():
                 "user_api_key": "hashed-key",
             }
             return data
-        
+
         mock_add_data.side_effect = mock_add_litellm_data
-        
+
         # Send a request to the endpoint
         response = client.post(
             "/v1beta/models/test-model:streamGenerateContent",
-            json={
-                "contents": [{"role": "user", "parts": [{"text": "Hello"}]}]
-            },
-            headers={"Authorization": "Bearer sk-test-key"}
+            json={"contents": [{"role": "user", "parts": [{"text": "Hello"}]}]},
+            headers={"Authorization": "Bearer sk-test-key"},
         )
-        
+
         # Verify the response
         assert response.status_code == 200
-        
+
         # Verify that add_litellm_data_to_request was called
         mock_add_data.assert_called_once()
-        
+
         # Verify that agenerate_content_stream was called with metadata
         mock_router.agenerate_content_stream.assert_called_once()
         call_args = mock_router.agenerate_content_stream.call_args
         called_data = call_args[1]
-        
+
         # Verify that litellm_metadata exists and contains user information
         assert "litellm_metadata" in called_data
         assert called_data["litellm_metadata"]["user_api_key_user_id"] == "test-user-id"
@@ -239,7 +241,7 @@ def test_google_stream_generate_content_with_cost_tracking_metadata():
 def test_google_generate_content_with_system_instruction():
     """
     Test that systemInstruction is correctly passed through from the endpoint to the router.
-    
+
     This test verifies the fix for systemInstruction being dropped when forwarding
     requests to Vertex AI through the Google GenAI endpoint.
     """
@@ -250,62 +252,63 @@ def test_google_generate_content_with_system_instruction():
         from litellm.proxy.google_endpoints.endpoints import router as google_router
     except ImportError as e:
         pytest.skip(f"Skipping test due to missing dependency: {e}")
-    
+
     # Create a FastAPI app and include the router
     app = FastAPI()
     app.include_router(google_router)
-    
+
     # Create a test client
     client = TestClient(app)
-    
+
     # Mock all required proxy server dependencies
-    with patch("litellm.proxy.proxy_server.llm_router") as mock_router, \
-         patch("litellm.proxy.proxy_server.general_settings", {}), \
-         patch("litellm.proxy.proxy_server.proxy_config") as mock_proxy_config, \
-         patch("litellm.proxy.proxy_server.version", "1.0.0"), \
-         patch("litellm.proxy.litellm_pre_call_utils.add_litellm_data_to_request") as mock_add_data:
-        
+    with patch("litellm.proxy.proxy_server.llm_router") as mock_router, patch(
+        "litellm.proxy.proxy_server.general_settings", {}
+    ), patch("litellm.proxy.proxy_server.proxy_config") as mock_proxy_config, patch(
+        "litellm.proxy.proxy_server.version", "1.0.0"
+    ), patch(
+        "litellm.proxy.litellm_pre_call_utils.add_litellm_data_to_request"
+    ) as mock_add_data:
         mock_router.agenerate_content = AsyncMock(return_value={"test": "response"})
-        
+
         # Mock add_litellm_data_to_request to pass through data unchanged
-        async def mock_add_litellm_data(data, request, user_api_key_dict, proxy_config, general_settings, version):
+        async def mock_add_litellm_data(
+            data, request, user_api_key_dict, proxy_config, general_settings, version
+        ):
             return data
-        
+
         mock_add_data.side_effect = mock_add_litellm_data
-        
+
         # Define the systemInstruction to test
-        system_instruction = {
-            "parts": [{"text": "Your name is Doodle."}]
-        }
-        
+        system_instruction = {"parts": [{"text": "Your name is Doodle."}]}
+
         # Send a request with systemInstruction
         response = client.post(
             "/v1beta/models/gemini-2.5-pro:generateContent",
             json={
                 "systemInstruction": system_instruction,
                 "contents": [
-                    {
-                        "parts": [{"text": "What is your name?"}],
-                        "role": "user"
-                    }
-                ]
+                    {"parts": [{"text": "What is your name?"}], "role": "user"}
+                ],
             },
-            headers={"Authorization": "Bearer sk-test-key"}
+            headers={"Authorization": "Bearer sk-test-key"},
         )
-        
+
         # Verify the response
         assert response.status_code == 200
-        
+
         # Verify that agenerate_content was called
         mock_router.agenerate_content.assert_called_once()
         call_args = mock_router.agenerate_content.call_args
         called_data = call_args[1]
-        
+
         # Verify that systemInstruction is present in the call arguments
         assert "systemInstruction" in called_data
         assert called_data["systemInstruction"] == system_instruction
-        assert called_data["systemInstruction"]["parts"][0]["text"] == "Your name is Doodle."
-        
+        assert (
+            called_data["systemInstruction"]["parts"][0]["text"]
+            == "Your name is Doodle."
+        )
+
         # Verify contents are also present
         assert "contents" in called_data
         assert len(called_data["contents"]) == 1
@@ -315,7 +318,7 @@ def test_google_generate_content_with_system_instruction():
 def test_google_generate_content_with_image_config():
     """
     Test that imageConfig is correctly passed through from generationConfig to the router.
-    
+
     This test verifies that imageConfig parameters (aspectRatio, imageSize) are preserved
     when forwarding requests to Google GenAI through the endpoint.
     """
@@ -326,69 +329,75 @@ def test_google_generate_content_with_image_config():
         from litellm.proxy.google_endpoints.endpoints import router as google_router
     except ImportError as e:
         pytest.skip(f"Skipping test due to missing dependency: {e}")
-    
+
     # Create a FastAPI app and include the router
     app = FastAPI()
     app.include_router(google_router)
-    
+
     # Create a test client
     client = TestClient(app)
-    
+
     # Mock all required proxy server dependencies
-    with patch("litellm.proxy.proxy_server.llm_router") as mock_router, \
-         patch("litellm.proxy.proxy_server.general_settings", {}), \
-         patch("litellm.proxy.proxy_server.proxy_config") as mock_proxy_config, \
-         patch("litellm.proxy.proxy_server.version", "1.0.0"), \
-         patch("litellm.proxy.litellm_pre_call_utils.add_litellm_data_to_request") as mock_add_data:
-        
+    with patch("litellm.proxy.proxy_server.llm_router") as mock_router, patch(
+        "litellm.proxy.proxy_server.general_settings", {}
+    ), patch("litellm.proxy.proxy_server.proxy_config") as mock_proxy_config, patch(
+        "litellm.proxy.proxy_server.version", "1.0.0"
+    ), patch(
+        "litellm.proxy.litellm_pre_call_utils.add_litellm_data_to_request"
+    ) as mock_add_data:
         mock_router.agenerate_content = AsyncMock(return_value={"test": "response"})
-        
+
         # Mock add_litellm_data_to_request to pass through data unchanged
-        async def mock_add_litellm_data(data, request, user_api_key_dict, proxy_config, general_settings, version):
+        async def mock_add_litellm_data(
+            data, request, user_api_key_dict, proxy_config, general_settings, version
+        ):
             return data
-        
+
         mock_add_data.side_effect = mock_add_litellm_data
-        
+
         # Send a request with generationConfig containing imageConfig
         response = client.post(
             "/v1beta/models/gemini-3-pro-image-preview:generateContent",
             json={
-                "contents": [{
-                    "role": "user",
-                    "parts": [{"text": "Create a vibrant infographic about photosynthesis"}]
-                }],
+                "contents": [
+                    {
+                        "role": "user",
+                        "parts": [
+                            {
+                                "text": "Create a vibrant infographic about photosynthesis"
+                            }
+                        ],
+                    }
+                ],
                 "generationConfig": {
                     "responseModalities": ["TEXT", "IMAGE"],
-                    "imageConfig": {
-                        "aspectRatio": "9:16",
-                        "imageSize": "4K"
-                    }
-                }
+                    "imageConfig": {"aspectRatio": "9:16", "imageSize": "4K"},
+                },
             },
-            headers={"Authorization": "Bearer sk-test-key"}
+            headers={"Authorization": "Bearer sk-test-key"},
         )
-        
+
         # Verify the response
         assert response.status_code == 200
-        
+
         # Verify that agenerate_content was called
         mock_router.agenerate_content.assert_called_once()
         call_args = mock_router.agenerate_content.call_args
         called_data = call_args[1]
-        
+
         # Verify that config is present in the call arguments
         assert "config" in called_data
-        
+
         # Verify that imageConfig is preserved in the config
         assert "imageConfig" in called_data["config"]
         assert called_data["config"]["imageConfig"]["aspectRatio"] == "9:16"
         assert called_data["config"]["imageConfig"]["imageSize"] == "4K"
-        
+
         # Verify that responseModalities is also preserved
         assert "responseModalities" in called_data["config"]
         assert called_data["config"]["responseModalities"] == ["TEXT", "IMAGE"]
-        
+
         # Verify contents are also present
         assert "contents" in called_data
         assert len(called_data["contents"]) == 1
-        assert called_data["contents"][0]["role"] == "user"
\ No newline at end of file
+        assert called_data["contents"][0]["role"] == "user"
diff --git a/tests/test_litellm/responses/litellm_completion_transformation/test_litellm_completion_responses.py b/tests/test_litellm/responses/litellm_completion_transformation/test_litellm_completion_responses.py
index 59c630b6a5b..f7a1984d32f 100644
--- a/tests/test_litellm/responses/litellm_completion_transformation/test_litellm_completion_responses.py
+++ b/tests/test_litellm/responses/litellm_completion_transformation/test_litellm_completion_responses.py
@@ -1351,4 +1351,219 @@ class TestUsageTransformation:
         assert response_usage.output_tokens == 27
         assert response_usage.total_tokens == 36
         assert response_usage.input_tokens_details is None
-        assert response_usage.output_tokens_details is None
\ No newline at end of file
+        assert response_usage.output_tokens_details is None
+
+
+class TestStreamingIDConsistency:
+    """Test cases for consistent IDs across streaming events (issue #14962)"""
+
+    def test_streaming_iterator_uses_consistent_item_ids(self):
+        """
+        Test that all streaming events use the same item_id throughout the stream.
+        This fixes the issue where text-start, text-delta, and text-end events
+        had different IDs, breaking SDK text accumulation.
+        
+        Reproduces: https://github.com/BerriAI/litellm/issues/14962
+        """
+        from unittest.mock import Mock
+
+        import litellm
+        from litellm.responses.litellm_completion_transformation.streaming_iterator import (
+            LiteLLMCompletionStreamingIterator,
+        )
+        from litellm.types.utils import Delta, ModelResponseStream, StreamingChoices
+
+        # Create a mock stream wrapper
+        mock_stream_wrapper = Mock(spec=litellm.CustomStreamWrapper)
+        mock_logging_obj = Mock()
+        mock_stream_wrapper.logging_obj = mock_logging_obj
+
+        # Create the streaming iterator
+        iterator = LiteLLMCompletionStreamingIterator(
+            model="gemini/gemini-2.5-flash-lite",
+            litellm_custom_stream_wrapper=mock_stream_wrapper,
+            request_input="Say Hello World",
+            responses_api_request={},
+            custom_llm_provider="gemini",
+        )
+
+        # Simulate streaming chunks with different IDs (as Gemini does)
+        chunk1 = ModelResponseStream(
+            id="chatcmpl-first-id",
+            choices=[
+                StreamingChoices(
+                    index=0,
+                    delta=Delta(content="Hello", role="assistant"),
+                    finish_reason=None,
+                )
+            ],
+            created=1234567890,
+            model="gemini-2.5-flash-lite",
+            object="chat.completion.chunk",
+        )
+
+        chunk2 = ModelResponseStream(
+            id="chatcmpl-second-id",  # Different ID from chunk1
+            choices=[
+                StreamingChoices(
+                    index=0,
+                    delta=Delta(content=" World", role=None),
+                    finish_reason=None,
+                )
+            ],
+            created=1234567890,
+            model="gemini-2.5-flash-lite",
+            object="chat.completion.chunk",
+        )
+
+        chunk3 = ModelResponseStream(
+            id="chatcmpl-third-id",  # Different ID from chunk1 and chunk2
+            choices=[
+                StreamingChoices(
+                    index=0,
+                    delta=Delta(content="", role=None),
+                    finish_reason="stop",
+                )
+            ],
+            created=1234567890,
+            model="gemini-2.5-flash-lite",
+            object="chat.completion.chunk",
+        )
+
+        # Transform chunks to response API events
+        event1 = iterator._transform_chat_completion_chunk_to_response_api_chunk(chunk1)
+        event2 = iterator._transform_chat_completion_chunk_to_response_api_chunk(chunk2)
+        event3 = iterator._transform_chat_completion_chunk_to_response_api_chunk(chunk3)
+
+        # Assert: All events should use the same item_id (from the first chunk)
+        assert event1 is not None, "First event should not be None"
+        assert event2 is not None, "Second event should not be None"
+        
+        # Extract item_ids from events
+        item_id_1 = getattr(event1, "item_id", None)
+        item_id_2 = getattr(event2, "item_id", None)
+        
+        assert item_id_1 is not None, "First event should have an item_id"
+        assert item_id_2 is not None, "Second event should have an item_id"
+        
+        # The critical assertion: IDs should match across all events
+        assert item_id_1 == item_id_2, (
+            f"Item IDs should be consistent across streaming events. "
+            f"Got {item_id_1} and {item_id_2}. "
+            f"This breaks SDK text accumulation (issue #14962)."
+        )
+        
+        # Verify the cached ID is set and matches
+        assert iterator._cached_item_id is not None, "Iterator should cache the item_id"
+        assert iterator._cached_item_id == item_id_1, "Cached ID should match event IDs"
+        assert iterator._cached_item_id == "chatcmpl-first-id", "Should use the first chunk's ID"
+
+    def test_streaming_iterator_initial_events_use_cached_id(self):
+        """
+        Test that initial events (output_item_added, content_part_added) also use the cached ID.
+        """
+        from unittest.mock import Mock
+
+        import litellm
+        from litellm.responses.litellm_completion_transformation.streaming_iterator import (
+            LiteLLMCompletionStreamingIterator,
+        )
+
+        # Create a mock stream wrapper
+        mock_stream_wrapper = Mock(spec=litellm.CustomStreamWrapper)
+        mock_logging_obj = Mock()
+        mock_stream_wrapper.logging_obj = mock_logging_obj
+
+        # Create the streaming iterator
+        iterator = LiteLLMCompletionStreamingIterator(
+            model="gemini/gemini-2.5-flash-lite",
+            litellm_custom_stream_wrapper=mock_stream_wrapper,
+            request_input="Test",
+            responses_api_request={},
+        )
+
+        # Create initial events
+        output_item_event = iterator.create_output_item_added_event()
+        content_part_event = iterator.create_content_part_added_event()
+
+        # Extract IDs
+        output_item_id = getattr(output_item_event.item, "id", None)
+        content_part_id = getattr(content_part_event, "item_id", None)
+
+        # Assert: Both should use the same cached ID
+        assert output_item_id is not None, "Output item should have an ID"
+        assert content_part_id is not None, "Content part should have an item_id"
+        assert output_item_id == content_part_id, (
+            f"Initial events should use consistent IDs. "
+            f"Got output_item_id={output_item_id}, content_part_id={content_part_id}"
+        )
+        
+        # Verify it matches the cached ID
+        assert iterator._cached_item_id is not None
+        assert iterator._cached_item_id == output_item_id
+
+    def test_streaming_iterator_done_events_use_cached_id(self):
+        """
+        Test that done events (output_text_done, content_part_done, output_item_done) use the cached ID.
+        """
+        from unittest.mock import Mock
+
+        import litellm
+        from litellm.responses.litellm_completion_transformation.streaming_iterator import (
+            LiteLLMCompletionStreamingIterator,
+        )
+        from litellm.types.utils import Choices, Message, ModelResponse
+
+        # Create a mock stream wrapper
+        mock_stream_wrapper = Mock(spec=litellm.CustomStreamWrapper)
+        mock_logging_obj = Mock()
+        mock_stream_wrapper.logging_obj = mock_logging_obj
+        mock_logging_obj._response_cost_calculator = Mock(return_value=0.001)
+
+        # Create the streaming iterator
+        iterator = LiteLLMCompletionStreamingIterator(
+            model="gemini/gemini-2.5-flash-lite",
+            litellm_custom_stream_wrapper=mock_stream_wrapper,
+            request_input="Test",
+            responses_api_request={},
+        )
+
+        # Set up a complete model response
+        complete_response = ModelResponse(
+            id="test-response-id",
+            created=1234567890,
+            model="gemini-2.5-flash-lite",
+            object="chat.completion",
+            choices=[
+                Choices(
+                    finish_reason="stop",
+                    index=0,
+                    message=Message(content="Hello World", role="assistant"),
+                )
+            ],
+        )
+        iterator.litellm_model_response = complete_response
+
+        # Create done events
+        text_done_event = iterator.create_output_text_done_event(complete_response)
+        content_done_event = iterator.create_output_content_part_done_event(complete_response)
+        item_done_event = iterator.create_output_item_done_event(complete_response)
+
+        # Extract IDs
+        text_done_id = getattr(text_done_event, "item_id", None)
+        content_done_id = getattr(content_done_event, "item_id", None)
+        item_done_id = getattr(item_done_event.item, "id", None)
+
+        # Assert: All done events should use the same cached ID
+        assert text_done_id is not None, "Text done event should have an item_id"
+        assert content_done_id is not None, "Content done event should have an item_id"
+        assert item_done_id is not None, "Item done event should have an id"
+        
+        assert text_done_id == content_done_id == item_done_id, (
+            f"All done events should use consistent IDs. "
+            f"Got text_done={text_done_id}, content_done={content_done_id}, item_done={item_done_id}"
+        )
+        
+        # Verify it matches the cached ID
+        assert iterator._cached_item_id is not None
+        assert iterator._cached_item_id == text_done_id
\ No newline at end of file
diff --git a/tests/test_litellm/test_responses_api_bridge_non_stream.py b/tests/test_litellm/test_responses_api_bridge_non_stream.py
new file mode 100644
index 00000000000..8f72debfc5d
--- /dev/null
+++ b/tests/test_litellm/test_responses_api_bridge_non_stream.py
@@ -0,0 +1,44 @@
+from litellm.completion_extras.litellm_responses_transformation.handler import (
+    ResponsesToCompletionBridgeHandler,
+)
+from litellm.types.llms.openai import ResponsesAPIResponse
+
+
+class _CompletedEvent:
+    def __init__(self, response):
+        self.response = response
+
+
+class _FakeResponsesStream:
+    def __init__(self, response):
+        self._emitted = False
+        self._response = response
+        self.completed_response = None
+        self._hidden_params = {"headers": {"x-test": "1"}}
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if not self._emitted:
+            self._emitted = True
+            self.completed_response = _CompletedEvent(self._response)
+            return {"type": "response.completed"}
+        raise StopIteration
+
+
+def test_should_collect_response_from_stream():
+    handler = ResponsesToCompletionBridgeHandler()
+    response = ResponsesAPIResponse.model_construct(
+        id="resp-1",
+        created_at=0,
+        output=[],
+        object="response",
+        model="gpt-5.2",
+    )
+    stream = _FakeResponsesStream(response)
+
+    collected = handler._collect_response_from_stream(stream)
+
+    assert collected.id == "resp-1"
+    assert collected._hidden_params.get("headers") == {"x-test": "1"}
diff --git a/tests/test_litellm/test_utils_custom.py b/tests/test_litellm/test_utils_custom.py
deleted file mode 100644
index 3e924e9c719..00000000000
--- a/tests/test_litellm/test_utils_custom.py
+++ /dev/null
@@ -1,45 +0,0 @@
-import pytest
-import sys
-from unittest.mock import MagicMock, patch, AsyncMock
-from litellm.proxy.utils import count_tokens_with_anthropic_api, _anthropic_async_clients
-
-@pytest.mark.asyncio
-async def test_count_tokens_caching():
-    """
-    Test that count_tokens_with_anthropic_api caches the client.
-    """
-    # Clear cache
-    _anthropic_async_clients.clear()
-    
-    api_key = "sk-ant-test-key"
-    messages = [{"role": "user", "content": "hello"}]
-    model = "claude-3-opus-20240229"
-    
-    # Create a mock anthropic module
-    mock_anthropic = MagicMock()
-    mock_client = MagicMock()
-    mock_anthropic.AsyncAnthropic.return_value = mock_client
-    
-    # Mock response
-    mock_response = MagicMock()
-    mock_response.input_tokens = 10
-    
-    # Setup async return for count_tokens
-    mock_client.beta.messages.count_tokens = AsyncMock(return_value=mock_response)
-    
-    # Patch sys.modules to ensure our mock is used when anthropic is imported
-    with patch.dict(sys.modules, {"anthropic": mock_anthropic}):
-        # First call
-        with patch.dict("os.environ", {"ANTHROPIC_API_KEY": api_key}):
-            await count_tokens_with_anthropic_api(model, messages)
-            
-        assert api_key in _anthropic_async_clients
-        assert _anthropic_async_clients[api_key] == mock_client
-        mock_anthropic.AsyncAnthropic.assert_called_once() # Should be called once
-        
-        # Second call
-        with patch.dict("os.environ", {"ANTHROPIC_API_KEY": api_key}):
-            await count_tokens_with_anthropic_api(model, messages)
-            
-        # Should still be called once (cached)
-        mock_anthropic.AsyncAnthropic.assert_called_once()
diff --git a/tests/test_service_logger_otel.py b/tests/test_service_logger_otel.py
new file mode 100644
index 00000000000..5cb21dadeae
--- /dev/null
+++ b/tests/test_service_logger_otel.py
@@ -0,0 +1,85 @@
+import os
+import sys
+import unittest
+from unittest.mock import patch, AsyncMock, MagicMock
+
+# Add the project root to sys.path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
+
+import litellm
+from litellm.integrations.langfuse.langfuse_otel import LangfuseOtelLogger
+from litellm.integrations.opentelemetry import OpenTelemetry
+from litellm.types.services import ServiceTypes
+from litellm._service_logger import ServiceLogging
+
+
+class TestServiceLoggerOTEL(unittest.IsolatedAsyncioTestCase):
+    def setUp(self):
+        # Reset callbacks before each test
+        litellm.service_callback = []
+        os.environ["LANGFUSE_PUBLIC_KEY"] = "pk-lf-123"
+        os.environ["LANGFUSE_SECRET_KEY"] = "sk-lf-123"
+
+    @patch("litellm.integrations.opentelemetry.OpenTelemetry._init_tracing")
+    @patch("litellm.integrations.opentelemetry.OpenTelemetry._init_metrics")
+    @patch("litellm.integrations.opentelemetry.OpenTelemetry._init_logs")
+    async def test_langfuse_otel_ignores_service_logs(
+        self, mock_logs, mock_metrics, mock_tracing
+    ):
+        """
+        Test that LangfuseOtelLogger overrides the service logging hooks with 'pass'.
+        """
+        logger = LangfuseOtelLogger()
+
+        # Verify hooks are overriden
+        self.assertEqual(
+            logger.async_service_success_hook.__qualname__,
+            "LangfuseOtelLogger.async_service_success_hook",
+        )
+        self.assertEqual(
+            logger.async_service_failure_hook.__qualname__,
+            "LangfuseOtelLogger.async_service_failure_hook",
+        )
+
+    @patch("litellm.integrations.opentelemetry.OpenTelemetry._init_tracing")
+    @patch("litellm.integrations.opentelemetry.OpenTelemetry._init_metrics")
+    @patch("litellm.integrations.opentelemetry.OpenTelemetry._init_logs")
+    async def test_service_logging_shadowing_fix(
+        self, mock_logs, mock_metrics, mock_tracing
+    ):
+        """
+        Test the architectural fix: multiple OTEL loggers should receive logs independently.
+        """
+        # 1. Initialize two loggers
+        langfuse_logger = LangfuseOtelLogger()
+        otel_logger = OpenTelemetry()
+
+        # 2. Setup service_callback list
+        litellm.service_callback = [langfuse_logger, otel_logger]
+
+        service_logging = ServiceLogging()
+
+        # 3. Mock the base OpenTelemetry hook
+        with patch.object(
+            OpenTelemetry, "async_service_success_hook", new_callable=AsyncMock
+        ) as mock_base_hook:
+            # Trigger a service event
+            await service_logging.async_service_success_hook(
+                service=ServiceTypes.DB,
+                call_type="success",
+                duration=0.1,
+                parent_otel_span=MagicMock(),
+                start_time=0.0,
+                end_time=1.0,
+            )
+
+            # The architectural fix ensures we call each correctly.
+            self.assertEqual(
+                mock_base_hook.call_count,
+                1,
+                "Generic OTEL logger should have received the log exactly once.",
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/ui/litellm-dashboard/src/app/(dashboard)/hooks/cloudzero/useCloudZeroCreate.ts b/ui/litellm-dashboard/src/app/(dashboard)/hooks/cloudzero/useCloudZeroCreate.ts
index e1263903622..29c5ae3a0f0 100644
--- a/ui/litellm-dashboard/src/app/(dashboard)/hooks/cloudzero/useCloudZeroCreate.ts
+++ b/ui/litellm-dashboard/src/app/(dashboard)/hooks/cloudzero/useCloudZeroCreate.ts
@@ -1,4 +1,4 @@
-import { getProxyBaseUrl } from "@/components/networking";
+import { getProxyBaseUrl, getGlobalLitellmHeaderName } from "@/components/networking";
 import { useMutation } from "@tanstack/react-query";
 
 interface CreateParams {
@@ -18,7 +18,7 @@ const performCloudZeroCreate = async (accessToken: string, params: CreateParams)
   const response = await fetch(url, {
     method: "POST",
     headers: {
-      Authorization: `Bearer ${accessToken}`,
+      [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
       "Content-Type": "application/json",
     },
     body: JSON.stringify({
diff --git a/ui/litellm-dashboard/src/app/(dashboard)/hooks/cloudzero/useCloudZeroDryRun.ts b/ui/litellm-dashboard/src/app/(dashboard)/hooks/cloudzero/useCloudZeroDryRun.ts
index 1ed8a141603..e00fd2a6375 100644
--- a/ui/litellm-dashboard/src/app/(dashboard)/hooks/cloudzero/useCloudZeroDryRun.ts
+++ b/ui/litellm-dashboard/src/app/(dashboard)/hooks/cloudzero/useCloudZeroDryRun.ts
@@ -1,4 +1,4 @@
-import { getProxyBaseUrl } from "@/components/networking";
+import { getProxyBaseUrl, getGlobalLitellmHeaderName } from "@/components/networking";
 import { useMutation } from "@tanstack/react-query";
 
 interface DryRunParams {
@@ -16,7 +16,7 @@ const performCloudZeroDryRun = async (accessToken: string, params: DryRunParams
   const response = await fetch(url, {
     method: "POST",
     headers: {
-      Authorization: `Bearer ${accessToken}`,
+      [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
       "Content-Type": "application/json",
     },
     body: JSON.stringify({
diff --git a/ui/litellm-dashboard/src/app/(dashboard)/hooks/cloudzero/useCloudZeroExport.ts b/ui/litellm-dashboard/src/app/(dashboard)/hooks/cloudzero/useCloudZeroExport.ts
index 47d559b20d2..ba9a013ecc6 100644
--- a/ui/litellm-dashboard/src/app/(dashboard)/hooks/cloudzero/useCloudZeroExport.ts
+++ b/ui/litellm-dashboard/src/app/(dashboard)/hooks/cloudzero/useCloudZeroExport.ts
@@ -1,4 +1,4 @@
-import { getProxyBaseUrl } from "@/components/networking";
+import { getProxyBaseUrl, getGlobalLitellmHeaderName } from "@/components/networking";
 import { useMutation } from "@tanstack/react-query";
 
 interface ExportParams {
@@ -16,7 +16,7 @@ const performCloudZeroExport = async (accessToken: string, params: ExportParams
   const response = await fetch(url, {
     method: "POST",
     headers: {
-      Authorization: `Bearer ${accessToken}`,
+      [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
       "Content-Type": "application/json",
     },
     body: JSON.stringify({
diff --git a/ui/litellm-dashboard/src/app/(dashboard)/hooks/cloudzero/useCloudZeroSettings.ts b/ui/litellm-dashboard/src/app/(dashboard)/hooks/cloudzero/useCloudZeroSettings.ts
index 96f5ab2f944..7fd61077385 100644
--- a/ui/litellm-dashboard/src/app/(dashboard)/hooks/cloudzero/useCloudZeroSettings.ts
+++ b/ui/litellm-dashboard/src/app/(dashboard)/hooks/cloudzero/useCloudZeroSettings.ts
@@ -1,5 +1,5 @@
 import { CloudZeroSettings } from "@/components/CloudZeroCostTracking/types";
-import { getProxyBaseUrl } from "@/components/networking";
+import { getProxyBaseUrl, getGlobalLitellmHeaderName } from "@/components/networking";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { createQueryKeys } from "../common/queryKeysFactory";
 
@@ -12,7 +12,7 @@ const getCloudZeroSettings = async (accessToken: string): Promise<CloudZeroSetti
   const response = await fetch(url, {
     method: "GET",
     headers: {
-      Authorization: `Bearer ${accessToken}`,
+      [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
       "Content-Type": "application/json",
     },
   });
@@ -82,7 +82,7 @@ const updateCloudZeroSettings = async (accessToken: string, params: UpdateParams
   const response = await fetch(url, {
     method: "PUT",
     headers: {
-      Authorization: `Bearer ${accessToken}`,
+      [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
       "Content-Type": "application/json",
     },
     body: JSON.stringify({
@@ -140,7 +140,7 @@ const deleteCloudZeroSettings = async (accessToken: string): Promise<DeleteRespo
   const response = await fetch(url, {
     method: "DELETE",
     headers: {
-      Authorization: `Bearer ${accessToken}`,
+      [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
       "Content-Type": "application/json",
     },
   });
diff --git a/ui/litellm-dashboard/src/app/(dashboard)/hooks/router/useRouterFields.test.ts b/ui/litellm-dashboard/src/app/(dashboard)/hooks/router/useRouterFields.test.ts
index fe4680cedeb..a9f5e1047ac 100644
--- a/ui/litellm-dashboard/src/app/(dashboard)/hooks/router/useRouterFields.test.ts
+++ b/ui/litellm-dashboard/src/app/(dashboard)/hooks/router/useRouterFields.test.ts
@@ -7,6 +7,7 @@ import { RouterFieldsResponse, useRouterFields } from "./useRouterFields";
 // Mock the networking module
 vi.mock("@/components/networking", () => ({
   proxyBaseUrl: null,
+  getGlobalLitellmHeaderName: vi.fn(() => "Authorization"),
 }));
 
 // Mock useAuthorized hook
diff --git a/ui/litellm-dashboard/src/app/(dashboard)/hooks/router/useRouterFields.ts b/ui/litellm-dashboard/src/app/(dashboard)/hooks/router/useRouterFields.ts
index 589508c5ddb..5fa22b41096 100644
--- a/ui/litellm-dashboard/src/app/(dashboard)/hooks/router/useRouterFields.ts
+++ b/ui/litellm-dashboard/src/app/(dashboard)/hooks/router/useRouterFields.ts
@@ -1,7 +1,7 @@
 import useAuthorized from "@/app/(dashboard)/hooks/useAuthorized";
 import { useQuery, UseQueryResult } from "@tanstack/react-query";
 import { createQueryKeys } from "../common/queryKeysFactory";
-import { proxyBaseUrl } from "@/components/networking";
+import { proxyBaseUrl, getGlobalLitellmHeaderName } from "@/components/networking";
 
 export interface RouterSettingsField {
   field_name: string;
@@ -39,7 +39,7 @@ const getRouterFields = async (accessToken: string): Promise<RouterFieldsRespons
     const response = await fetch(url, {
       method: "GET",
       headers: {
-        Authorization: `Bearer ${accessToken}`,
+        [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
         "Content-Type": "application/json",
       },
     });
diff --git a/ui/litellm-dashboard/src/components/AIHub/ClaudeCodeMarketplaceTab.tsx b/ui/litellm-dashboard/src/components/AIHub/ClaudeCodeMarketplaceTab.tsx
index df022f4a749..043077c0210 100644
--- a/ui/litellm-dashboard/src/components/AIHub/ClaudeCodeMarketplaceTab.tsx
+++ b/ui/litellm-dashboard/src/components/AIHub/ClaudeCodeMarketplaceTab.tsx
@@ -1,20 +1,19 @@
-import React, { useState, useEffect, useMemo } from "react";
-import { Input } from "antd";
-import { Card, TabGroup, TabList, Tab, TabPanels, TabPanel, Text } from "@tremor/react";
 import { SearchOutlined } from "@ant-design/icons";
-import { getClaudeCodeMarketplace } from "../networking";
-import { ModelDataTable } from "../model_dashboard/table";
-import { getMarketplaceTableColumns } from "./marketplace_table_columns";
-import NotificationsManager from "../molecules/notifications_manager";
-import {
-  MarketplaceResponse,
-  MarketplacePluginEntry,
-} from "../claude_code_plugins/types";
+import { Card, Tab, TabGroup, TabList, TabPanel, TabPanels, Text } from "@tremor/react";
+import { Input } from "antd";
+import React, { useEffect, useMemo, useState } from "react";
 import {
   extractCategories,
-  filterPluginsBySearch,
   filterPluginsByCategory,
+  filterPluginsBySearch,
 } from "../claude_code_plugins/helpers";
+import {
+  MarketplaceResponse
+} from "../claude_code_plugins/types";
+import { ModelDataTable } from "../model_dashboard/table";
+import NotificationsManager from "../molecules/notifications_manager";
+import { getClaudeCodeMarketplace } from "../networking";
+import { getMarketplaceTableColumns } from "./marketplace_table_columns";
 
 interface ClaudeCodeMarketplaceTabProps {
   publicPage?: boolean;
diff --git a/ui/litellm-dashboard/src/components/AIHub/marketplace/PluginCard.tsx b/ui/litellm-dashboard/src/components/AIHub/marketplace/PluginCard.tsx
index d8111b2da07..f7f00a2e3c0 100644
--- a/ui/litellm-dashboard/src/components/AIHub/marketplace/PluginCard.tsx
+++ b/ui/litellm-dashboard/src/components/AIHub/marketplace/PluginCard.tsx
@@ -1,15 +1,15 @@
-import React from "react";
-import { Card, Badge, Button, Text } from "@tremor/react";
-import { Tooltip } from "antd";
-import { CopyOutlined, ExternalLinkIcon } from "@heroicons/react/outline";
-import { MarketplacePluginEntry } from "@/components/claude_code_plugins/types";
 import {
   formatInstallCommand,
   getCategoryBadgeColor,
-  getSourceLink,
-  truncateText,
+  getSourceLink
 } from "@/components/claude_code_plugins/helpers";
+import { MarketplacePluginEntry } from "@/components/claude_code_plugins/types";
 import NotificationsManager from "@/components/molecules/notifications_manager";
+import { ExternalLinkIcon } from "@heroicons/react/outline";
+import { CopyOutlined } from "@ant-design/icons";
+import { Badge, Button, Card, Text } from "@tremor/react";
+import { Tooltip } from "antd";
+import React from "react";
 
 interface PluginCardProps {
   plugin: MarketplacePluginEntry;
diff --git a/ui/litellm-dashboard/src/components/CostTrackingSettings/pricing_calculator/use_cost_estimate.ts b/ui/litellm-dashboard/src/components/CostTrackingSettings/pricing_calculator/use_cost_estimate.ts
index a0fd4357481..2f1fe21312e 100644
--- a/ui/litellm-dashboard/src/components/CostTrackingSettings/pricing_calculator/use_cost_estimate.ts
+++ b/ui/litellm-dashboard/src/components/CostTrackingSettings/pricing_calculator/use_cost_estimate.ts
@@ -1,5 +1,5 @@
 import { useState, useCallback, useRef, useEffect } from "react";
-import { getProxyBaseUrl } from "@/components/networking";
+import { getProxyBaseUrl, getGlobalLitellmHeaderName } from "@/components/networking";
 import NotificationsManager from "../../molecules/notifications_manager";
 import { CostEstimateRequest, CostEstimateResponse } from "../types";
 import { PricingFormValues } from "./types";
@@ -36,7 +36,7 @@ export function useCostEstimate(accessToken: string | null) {
         const response = await fetch(url, {
           method: "POST",
           headers: {
-            Authorization: `Bearer ${accessToken}`,
+            [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
             "Content-Type": "application/json",
           },
           body: JSON.stringify(requestBody),
diff --git a/ui/litellm-dashboard/src/components/CostTrackingSettings/pricing_calculator/use_multi_cost_estimate.ts b/ui/litellm-dashboard/src/components/CostTrackingSettings/pricing_calculator/use_multi_cost_estimate.ts
index ed1794879f3..85d46cea9a4 100644
--- a/ui/litellm-dashboard/src/components/CostTrackingSettings/pricing_calculator/use_multi_cost_estimate.ts
+++ b/ui/litellm-dashboard/src/components/CostTrackingSettings/pricing_calculator/use_multi_cost_estimate.ts
@@ -1,5 +1,5 @@
 import { useState, useCallback, useRef, useEffect } from "react";
-import { getProxyBaseUrl } from "@/components/networking";
+import { getProxyBaseUrl, getGlobalLitellmHeaderName } from "@/components/networking";
 import { CostEstimateRequest, CostEstimateResponse } from "../types";
 import { ModelEntry, MultiModelResult } from "./types";
 
@@ -59,7 +59,7 @@ export function useMultiCostEstimate(accessToken: string | null) {
         const response = await fetch(url, {
           method: "POST",
           headers: {
-            Authorization: `Bearer ${accessToken}`,
+            [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
             "Content-Type": "application/json",
           },
           body: JSON.stringify(requestBody),
diff --git a/ui/litellm-dashboard/src/components/CostTrackingSettings/use_discount_config.ts b/ui/litellm-dashboard/src/components/CostTrackingSettings/use_discount_config.ts
index 0ed57aa8cc2..baa03cfee88 100644
--- a/ui/litellm-dashboard/src/components/CostTrackingSettings/use_discount_config.ts
+++ b/ui/litellm-dashboard/src/components/CostTrackingSettings/use_discount_config.ts
@@ -1,5 +1,5 @@
 import { useState, useCallback } from "react";
-import { getProxyBaseUrl } from "@/components/networking";
+import { getProxyBaseUrl, getGlobalLitellmHeaderName } from "@/components/networking";
 import NotificationsManager from "../molecules/notifications_manager";
 import { DiscountConfig } from "./types";
 import { getProviderBackendValue } from "./provider_display_helpers";
@@ -32,7 +32,7 @@ export function useDiscountConfig({ accessToken }: UseDiscountConfigProps): UseD
       const response = await fetch(url, {
         method: "GET",
         headers: {
-          Authorization: `Bearer ${accessToken}`,
+          [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
           "Content-Type": "application/json",
         },
       });
@@ -59,7 +59,7 @@ export function useDiscountConfig({ accessToken }: UseDiscountConfigProps): UseD
       const response = await fetch(url, {
         method: "PATCH",
         headers: {
-          Authorization: `Bearer ${accessToken}`,
+          [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
           "Content-Type": "application/json",
         },
         body: JSON.stringify(config),
diff --git a/ui/litellm-dashboard/src/components/CostTrackingSettings/use_margin_config.ts b/ui/litellm-dashboard/src/components/CostTrackingSettings/use_margin_config.ts
index f443e1c121e..e20ee952bda 100644
--- a/ui/litellm-dashboard/src/components/CostTrackingSettings/use_margin_config.ts
+++ b/ui/litellm-dashboard/src/components/CostTrackingSettings/use_margin_config.ts
@@ -1,5 +1,5 @@
 import { useState, useCallback } from "react";
-import { getProxyBaseUrl } from "@/components/networking";
+import { getProxyBaseUrl, getGlobalLitellmHeaderName } from "@/components/networking";
 import NotificationsManager from "../molecules/notifications_manager";
 import { MarginConfig } from "./types";
 import { getProviderBackendValue } from "./provider_display_helpers";
@@ -42,7 +42,7 @@ export function useMarginConfig({ accessToken }: UseMarginConfigProps): UseMargi
       const response = await fetch(url, {
         method: "GET",
         headers: {
-          Authorization: `Bearer ${accessToken}`,
+          [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
           "Content-Type": "application/json",
         },
       });
@@ -69,7 +69,7 @@ export function useMarginConfig({ accessToken }: UseMarginConfigProps): UseMargi
       const response = await fetch(url, {
         method: "PATCH",
         headers: {
-          Authorization: `Bearer ${accessToken}`,
+          [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
           "Content-Type": "application/json",
         },
         body: JSON.stringify(config),
diff --git a/ui/litellm-dashboard/src/components/claude_code_plugins/plugin_info.tsx b/ui/litellm-dashboard/src/components/claude_code_plugins/plugin_info.tsx
index a4eb4352e16..142d7757711 100644
--- a/ui/litellm-dashboard/src/components/claude_code_plugins/plugin_info.tsx
+++ b/ui/litellm-dashboard/src/components/claude_code_plugins/plugin_info.tsx
@@ -1,30 +1,29 @@
-import React, { useState, useEffect } from "react";
-import {
-  Card,
-  Title,
-  Text,
-  Button,
-  Badge,
-  Grid,
-} from "@tremor/react";
-import { Spin, Switch, Tooltip, Descriptions } from "antd";
-import { ArrowLeftIcon, ExternalLinkIcon } from "@heroicons/react/outline";
 import { CopyOutlined } from "@ant-design/icons";
+import { ArrowLeftIcon, ExternalLinkIcon } from "@heroicons/react/outline";
 import {
-  getClaudeCodePluginDetails,
-  enableClaudeCodePlugin,
-  disableClaudeCodePlugin,
-} from "../networking";
+  Badge,
+  Button,
+  Card,
+  Grid,
+  Text,
+  Title,
+} from "@tremor/react";
+import { Spin, Switch, Tooltip } from "antd";
+import React, { useEffect, useState } from "react";
 import NotificationsManager from "../molecules/notifications_manager";
-import { Plugin } from "./types";
 import {
-  formatInstallCommand,
-  getSourceDisplayText,
-  getSourceLink,
-  getCategoryBadgeColor,
+  disableClaudeCodePlugin,
+  enableClaudeCodePlugin,
+  getClaudeCodePluginDetails,
+} from "../networking";
+import {
   formatDateString,
-  formatKeywords,
+  formatInstallCommand,
+  getCategoryBadgeColor,
+  getSourceDisplayText,
+  getSourceLink
 } from "./helpers";
+import { Plugin } from "./types";
 
 interface PluginInfoViewProps {
   pluginId: string;
@@ -169,7 +168,9 @@ const PluginInfoView: React.FC<PluginInfoViewProps> = ({
       {/* Plugin Details */}
       <Card>
         <Title>Plugin Details</Title>
-        <Grid numColsSm={2} numColsLg={3} className="gap-6 mt-4">
+        <Grid
+          className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-6 mt-4"
+        >
           {/* Plugin ID */}
           <div>
             <Text className="text-gray-600 text-xs">Plugin ID</Text>
@@ -277,7 +278,7 @@ const PluginInfoView: React.FC<PluginInfoViewProps> = ({
       {plugin.author && (
         <Card>
           <Title>Author Information</Title>
-          <Grid numColsSm={2} className="gap-4 mt-4">
+          <Grid className="grid grid-cols-1 sm:grid-cols-2 gap-4 mt-4">
             {plugin.author.name && (
               <div>
                 <Text className="text-gray-600 text-xs">Name</Text>
@@ -322,7 +323,7 @@ const PluginInfoView: React.FC<PluginInfoViewProps> = ({
       {/* Timestamps */}
       <Card>
         <Title>Metadata</Title>
-        <Grid numColsSm={2} className="gap-4 mt-4">
+        <Grid className="grid grid-cols-1 sm:grid-cols-2 gap-4 mt-4">
           <div>
             <Text className="text-gray-600 text-xs">Created At</Text>
             <Text className="font-semibold mt-1">
diff --git a/ui/litellm-dashboard/src/components/claude_code_plugins/plugin_table.tsx b/ui/litellm-dashboard/src/components/claude_code_plugins/plugin_table.tsx
index df9fb9303c2..38d03069a3b 100644
--- a/ui/litellm-dashboard/src/components/claude_code_plugins/plugin_table.tsx
+++ b/ui/litellm-dashboard/src/components/claude_code_plugins/plugin_table.tsx
@@ -1,32 +1,10 @@
-import React, { useState } from "react";
+import { CopyOutlined } from "@ant-design/icons";
 import {
-  Table,
-  TableBody,
-  TableCell,
-  TableHead,
-  TableHeaderCell,
-  TableRow,
-  Button,
-  Badge,
-} from "@tremor/react";
-import {
-  SwitchVerticalIcon,
-  ChevronUpIcon,
   ChevronDownIcon,
+  ChevronUpIcon,
+  SwitchVerticalIcon,
   TrashIcon,
 } from "@heroicons/react/outline";
-import { Tooltip, Switch } from "antd";
-import { CopyOutlined } from "@ant-design/icons";
-import { Plugin } from "./types";
-import {
-  getCategoryBadgeColor,
-  formatDateString,
-} from "./helpers";
-import {
-  enableClaudeCodePlugin,
-  disableClaudeCodePlugin,
-} from "../networking";
-import NotificationsManager from "../molecules/notifications_manager";
 import {
   ColumnDef,
   flexRender,
@@ -35,6 +13,27 @@ import {
   SortingState,
   useReactTable,
 } from "@tanstack/react-table";
+import {
+  Badge,
+  Button,
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeaderCell,
+  TableRow,
+} from "@tremor/react";
+import { Switch, Tooltip } from "antd";
+import React, { useState } from "react";
+import NotificationsManager from "../molecules/notifications_manager";
+import {
+  disableClaudeCodePlugin,
+  enableClaudeCodePlugin,
+} from "../networking";
+import {
+  getCategoryBadgeColor
+} from "./helpers";
+import { Plugin } from "./types";
 
 interface PluginTableProps {
   pluginsList: Plugin[];
@@ -209,33 +208,33 @@ const PluginTable: React.FC<PluginTableProps> = ({
     },
     ...(isAdmin
       ? [
-          {
-            header: "Actions",
-            id: "actions",
-            enableSorting: false,
-            cell: ({ row }: any) => {
-              const plugin = row.original;
+        {
+          header: "Actions",
+          id: "actions",
+          enableSorting: false,
+          cell: ({ row }: any) => {
+            const plugin = row.original;
 
-              return (
-                <div className="flex items-center gap-1">
-                  <Tooltip title="Delete plugin">
-                    <Button
-                      size="xs"
-                      variant="light"
-                      color="red"
-                      onClick={(e) => {
-                        e.stopPropagation();
-                        onDeleteClick(plugin.name, plugin.name);
-                      }}
-                      icon={TrashIcon}
-                      className="text-red-500 hover:text-red-700 hover:bg-red-50"
-                    />
-                  </Tooltip>
-                </div>
-              );
-            },
+            return (
+              <div className="flex items-center gap-1">
+                <Tooltip title="Delete plugin">
+                  <Button
+                    size="xs"
+                    variant="light"
+                    color="red"
+                    onClick={(e) => {
+                      e.stopPropagation();
+                      onDeleteClick(plugin.name, plugin.name);
+                    }}
+                    icon={TrashIcon}
+                    className="text-red-500 hover:text-red-700 hover:bg-red-50"
+                  />
+                </Tooltip>
+              </div>
+            );
           },
-        ]
+        },
+      ]
       : []),
   ];
 
@@ -261,11 +260,10 @@ const PluginTable: React.FC<PluginTableProps> = ({
                 {headerGroup.headers.map((header) => (
                   <TableHeaderCell
                     key={header.id}
-                    className={`py-1 h-8 ${
-                      header.id === "actions"
+                    className={`py-1 h-8 ${header.id === "actions"
                         ? "sticky right-0 bg-white shadow-[-4px_0_8px_-6px_rgba(0,0,0,0.1)]"
                         : ""
-                    }`}
+                      }`}
                     onClick={
                       header.column.getCanSort()
                         ? header.column.getToggleSortingHandler()
@@ -277,9 +275,9 @@ const PluginTable: React.FC<PluginTableProps> = ({
                         {header.isPlaceholder
                           ? null
                           : flexRender(
-                              header.column.columnDef.header,
-                              header.getContext()
-                            )}
+                            header.column.columnDef.header,
+                            header.getContext()
+                          )}
                       </div>
                       {header.column.getCanSort() && (
                         <div className="w-4">
@@ -318,11 +316,10 @@ const PluginTable: React.FC<PluginTableProps> = ({
                   {row.getVisibleCells().map((cell) => (
                     <TableCell
                       key={cell.id}
-                      className={`py-0.5 max-h-8 overflow-hidden text-ellipsis whitespace-nowrap ${
-                        cell.column.id === "actions"
+                      className={`py-0.5 max-h-8 overflow-hidden text-ellipsis whitespace-nowrap ${cell.column.id === "actions"
                           ? "sticky right-0 bg-white shadow-[-4px_0_8px_-6px_rgba(0,0,0,0.1)]"
                           : ""
-                      }`}
+                        }`}
                     >
                       {flexRender(
                         cell.column.columnDef.cell,
diff --git a/ui/litellm-dashboard/src/components/cloudzero_export_modal.tsx b/ui/litellm-dashboard/src/components/cloudzero_export_modal.tsx
index 575cb0b89bc..391fd00089a 100644
--- a/ui/litellm-dashboard/src/components/cloudzero_export_modal.tsx
+++ b/ui/litellm-dashboard/src/components/cloudzero_export_modal.tsx
@@ -1,6 +1,7 @@
 import React, { useState, useEffect } from "react";
 import { Text, Button, Callout, TextInput } from "@tremor/react";
 import { Modal, Form, Spin, Select } from "antd";
+import { getGlobalLitellmHeaderName } from "@/components/networking";
 import NotificationsManager from "./molecules/notifications_manager";
 
 interface CloudZeroExportModalProps {
@@ -43,7 +44,7 @@ const CloudZeroExportModal: React.FC<CloudZeroExportModalProps> = ({ isOpen, onC
       const response = await fetch("/cloudzero/settings", {
         method: "GET",
         headers: {
-          Authorization: `Bearer ${accessToken}`,
+          [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
           "Content-Type": "application/json",
         },
       });
@@ -88,7 +89,7 @@ const CloudZeroExportModal: React.FC<CloudZeroExportModalProps> = ({ isOpen, onC
       const response = await fetch(endpoint, {
         method,
         headers: {
-          Authorization: `Bearer ${accessToken}`,
+          [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
           "Content-Type": "application/json",
         },
         body: JSON.stringify(payload),
@@ -128,7 +129,7 @@ const CloudZeroExportModal: React.FC<CloudZeroExportModalProps> = ({ isOpen, onC
       const response = await fetch("/cloudzero/export", {
         method: "POST",
         headers: {
-          Authorization: `Bearer ${accessToken}`,
+          [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
           "Content-Type": "application/json",
         },
         body: JSON.stringify({
diff --git a/ui/litellm-dashboard/src/components/cost_tracking_settings.tsx b/ui/litellm-dashboard/src/components/cost_tracking_settings.tsx
index bab61da6775..75d650306ee 100644
--- a/ui/litellm-dashboard/src/components/cost_tracking_settings.tsx
+++ b/ui/litellm-dashboard/src/components/cost_tracking_settings.tsx
@@ -15,7 +15,7 @@ import {
   Col,
   Subtitle,
 } from "@tremor/react";
-import { getProxyBaseUrl } from "@/components/networking";
+import { getProxyBaseUrl, getGlobalLitellmHeaderName } from "@/components/networking";
 import NotificationsManager from "./molecules/notifications_manager";
 
 interface CostTrackingSettingsProps {
@@ -56,7 +56,7 @@ const CostTrackingSettings: React.FC<CostTrackingSettingsProps> = ({
       const response = await fetch(url, {
         method: "GET",
         headers: {
-          Authorization: `Bearer ${accessToken}`,
+          [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
           "Content-Type": "application/json",
         },
       });
@@ -86,7 +86,7 @@ const CostTrackingSettings: React.FC<CostTrackingSettingsProps> = ({
       const response = await fetch(url, {
         method: "PATCH",
         headers: {
-          Authorization: `Bearer ${accessToken}`,
+          [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
           "Content-Type": "application/json",
         },
         body: JSON.stringify(discountConfig),
diff --git a/ui/litellm-dashboard/src/components/guardrails/edit_guardrail_form.tsx b/ui/litellm-dashboard/src/components/guardrails/edit_guardrail_form.tsx
index caa197e0cd5..a2cc3ad41dd 100644
--- a/ui/litellm-dashboard/src/components/guardrails/edit_guardrail_form.tsx
+++ b/ui/litellm-dashboard/src/components/guardrails/edit_guardrail_form.tsx
@@ -2,7 +2,7 @@ import React, { useState, useEffect } from "react";
 import { Form, Typography, Select, Input, Switch, Modal } from "antd";
 import { Button, TextInput } from "@tremor/react";
 import { guardrail_provider_map, guardrailLogoMap, getGuardrailProviders } from "./guardrail_info_helpers";
-import { getGuardrailUISettings } from "../networking";
+import { getGuardrailUISettings, getGlobalLitellmHeaderName } from "../networking";
 import PiiConfiguration from "./pii_configuration";
 import NotificationsManager from "../molecules/notifications_manager";
 
@@ -183,7 +183,7 @@ const EditGuardrailForm: React.FC<EditGuardrailFormProps> = ({
       const response = await fetch(url, {
         method: "PUT",
         headers: {
-          Authorization: `Bearer ${accessToken}`,
+          [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
           "Content-Type": "application/json",
         },
         body: JSON.stringify(guardrailData),
diff --git a/ui/litellm-dashboard/src/components/networking.tsx b/ui/litellm-dashboard/src/components/networking.tsx
index 155a078f34a..1fe72996cfd 100644
--- a/ui/litellm-dashboard/src/components/networking.tsx
+++ b/ui/litellm-dashboard/src/components/networking.tsx
@@ -6256,7 +6256,7 @@ export const tagCreateCall = async (accessToken: string, formValues: TagNewReque
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${accessToken}`,
+        [globalLitellmHeaderName]: `Bearer ${accessToken}`,
       },
       body: JSON.stringify(formValues),
     });
@@ -6282,7 +6282,7 @@ export const tagUpdateCall = async (accessToken: string, formValues: TagUpdateRe
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${accessToken}`,
+        [globalLitellmHeaderName]: `Bearer ${accessToken}`,
       },
       body: JSON.stringify(formValues),
     });
@@ -6308,7 +6308,7 @@ export const tagInfoCall = async (accessToken: string, tagNames: string[]): Prom
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${accessToken}`,
+        [globalLitellmHeaderName]: `Bearer ${accessToken}`,
       },
       body: JSON.stringify({ names: tagNames }),
     });
@@ -6334,7 +6334,7 @@ export const tagListCall = async (accessToken: string): Promise<TagListResponse>
     const response = await fetch(url, {
       method: "GET",
       headers: {
-        Authorization: `Bearer ${accessToken}`,
+        [globalLitellmHeaderName]: `Bearer ${accessToken}`,
       },
     });
 
@@ -6360,7 +6360,7 @@ export const tagDeleteCall = async (accessToken: string, tagName: string): Promi
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${accessToken}`,
+        [globalLitellmHeaderName]: `Bearer ${accessToken}`,
       },
       body: JSON.stringify({ name: tagName }),
     });
@@ -6452,7 +6452,7 @@ export const getTeamPermissionsCall = async (accessToken: string, teamId: string
       method: "GET",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${accessToken}`,
+        [globalLitellmHeaderName]: `Bearer ${accessToken}`,
       },
     });
 
@@ -6480,7 +6480,7 @@ export const teamPermissionsUpdateCall = async (accessToken: string, teamId: str
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${accessToken}`,
+        [globalLitellmHeaderName]: `Bearer ${accessToken}`,
       },
       body: JSON.stringify({
         team_id: teamId,
@@ -6544,7 +6544,7 @@ export const vectorStoreCreateCall = async (accessToken: string, formValues: Rec
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${accessToken}`,
+        [globalLitellmHeaderName]: `Bearer ${accessToken}`,
       },
       body: JSON.stringify(formValues),
     });
@@ -6573,7 +6573,7 @@ export const vectorStoreListCall = async (
       method: "GET",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${accessToken}`,
+        [globalLitellmHeaderName]: `Bearer ${accessToken}`,
       },
     });
 
@@ -6597,7 +6597,7 @@ export const vectorStoreDeleteCall = async (accessToken: string, vectorStoreId:
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${accessToken}`,
+        [globalLitellmHeaderName]: `Bearer ${accessToken}`,
       },
       body: JSON.stringify({ vector_store_id: vectorStoreId }),
     });
@@ -6622,7 +6622,7 @@ export const vectorStoreInfoCall = async (accessToken: string, vectorStoreId: st
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${accessToken}`,
+        [globalLitellmHeaderName]: `Bearer ${accessToken}`,
       },
       body: JSON.stringify({ vector_store_id: vectorStoreId }),
     });
@@ -6647,7 +6647,7 @@ export const vectorStoreUpdateCall = async (accessToken: string, formValues: Rec
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${accessToken}`,
+        [globalLitellmHeaderName]: `Bearer ${accessToken}`,
       },
       body: JSON.stringify(formValues),
     });
@@ -7768,7 +7768,7 @@ export const vectorStoreSearchCall = async (
     const response = await fetch(url, {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${accessToken}`,
+        [globalLitellmHeaderName]: `Bearer ${accessToken}`,
         "Content-Type": "application/json",
       },
       body: JSON.stringify({
@@ -7801,7 +7801,7 @@ export const searchToolQueryCall = async (
     const response = await fetch(url, {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${accessToken}`,
+        [globalLitellmHeaderName]: `Bearer ${accessToken}`,
         "Content-Type": "application/json",
       },
       body: JSON.stringify({
diff --git a/ui/litellm-dashboard/src/components/playground/chat_ui/ChatUI.test.tsx b/ui/litellm-dashboard/src/components/playground/chat_ui/ChatUI.test.tsx
index d992ff0ecb4..8d64d727189 100644
--- a/ui/litellm-dashboard/src/components/playground/chat_ui/ChatUI.test.tsx
+++ b/ui/litellm-dashboard/src/components/playground/chat_ui/ChatUI.test.tsx
@@ -19,7 +19,7 @@ vi.mock("../networking", () => ({
 
 // Mock scrollIntoView which is not available in jsdom
 beforeEach(() => {
-  Element.prototype.scrollIntoView = () => {};
+  Element.prototype.scrollIntoView = () => { };
 });
 
 describe("ChatUI", () => {
@@ -270,4 +270,43 @@ describe("ChatUI", () => {
       expect(mcpSelect).not.toHaveClass("ant-select-disabled");
     });
   });
+
+  it("should show Fill button and populate customProxyBaseUrl when proxySettings.LITELLM_UI_API_DOC_BASE_URL is provided", async () => {
+    const testProxyUrl = "http://localhost:5000";
+
+    render(
+      <ChatUI
+        accessToken="1234567890"
+        token="1234567890"
+        userRole="user"
+        userID="1234567890"
+        disabledPersonalKeyCreation={false}
+        proxySettings={{
+          LITELLM_UI_API_DOC_BASE_URL: testProxyUrl,
+        }}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText("Test Key")).toBeInTheDocument();
+    });
+
+    const fillButton = screen.getByText("Fill");
+    expect(fillButton).toBeInTheDocument();
+
+    act(() => {
+      fireEvent.click(fillButton);
+    });
+
+    await waitFor(() => {
+      expect(sessionStorage.getItem("customProxyBaseUrl")).toBe(testProxyUrl);
+    });
+
+    await waitFor(() => {
+      expect(screen.queryByText("Fill")).toBeNull();
+    });
+
+    const customProxyInput = screen.getByPlaceholderText("Optional: Enter custom proxy URL (e.g., http://localhost:5000)");
+    expect(customProxyInput).toHaveValue(testProxyUrl);
+  });
 });
diff --git a/ui/litellm-dashboard/src/components/playground/chat_ui/ChatUI.tsx b/ui/litellm-dashboard/src/components/playground/chat_ui/ChatUI.tsx
index cbdffe46819..a3bdaccd805 100644
--- a/ui/litellm-dashboard/src/components/playground/chat_ui/ChatUI.tsx
+++ b/ui/litellm-dashboard/src/components/playground/chat_ui/ChatUI.tsx
@@ -10,6 +10,7 @@ import {
   FilePdfOutlined,
   InfoCircleOutlined,
   KeyOutlined,
+  LinkOutlined,
   LoadingOutlined,
   PictureOutlined,
   RobotOutlined,
@@ -1172,9 +1173,23 @@ const ChatUI: React.FC<ChatUIProps> = ({
 
               <div>
                 <div className="flex items-center justify-between mb-2">
-                  <Text className="font-medium text-gray-700 flex items-center">
+                  <Text className="font-medium block text-gray-700 flex items-center">
                     <SettingOutlined className="mr-2" /> Custom Proxy Base URL
                   </Text>
+                  {proxySettings?.LITELLM_UI_API_DOC_BASE_URL && !customProxyBaseUrl && (
+                    <Button
+                      type="link"
+                      size="small"
+                      icon={<LinkOutlined />}
+                      onClick={() => {
+                        setCustomProxyBaseUrl(proxySettings.LITELLM_UI_API_DOC_BASE_URL || "");
+                        sessionStorage.setItem("customProxyBaseUrl", proxySettings.LITELLM_UI_API_DOC_BASE_URL || "");
+                      }}
+                      className="text-gray-500 hover:text-gray-700"
+                    >
+                      Fill
+                    </Button>
+                  )}
                   {customProxyBaseUrl && (
                     <Button
                       type="link"
@@ -1219,7 +1234,7 @@ const ChatUI: React.FC<ChatUIProps> = ({
                     try {
                       sessionStorage.removeItem("selectedModel");
                       sessionStorage.removeItem("selectedAgent");
-                    } catch {}
+                    } catch { }
                   }}
                   className="mb-4"
                 />
@@ -1575,7 +1590,7 @@ const ChatUI: React.FC<ChatUIProps> = ({
                     enabled={codeInterpreter.enabled}
                     onEnabledChange={codeInterpreter.setEnabled}
                     selectedContainerId={null}
-                    onContainerChange={() => {}}
+                    onContainerChange={() => { }}
                     selectedModel={selectedModel || ""}
                   />
                 </div>
@@ -2071,11 +2086,10 @@ const ChatUI: React.FC<ChatUIProps> = ({
                         }
                       >
                         <button
-                          className={`p-1.5 rounded-md transition-colors ${
-                            codeInterpreter.enabled
-                              ? "bg-blue-100 text-blue-600"
-                              : "text-gray-400 hover:text-gray-600 hover:bg-gray-100"
-                          }`}
+                          className={`p-1.5 rounded-md transition-colors ${codeInterpreter.enabled
+                            ? "bg-blue-100 text-blue-600"
+                            : "text-gray-400 hover:text-gray-600 hover:bg-gray-100"
+                            }`}
                           onClick={() => {
                             codeInterpreter.toggle();
                             if (!codeInterpreter.enabled) {
@@ -2096,9 +2110,9 @@ const ChatUI: React.FC<ChatUIProps> = ({
                     onKeyDown={handleKeyDown}
                     placeholder={
                       endpointType === EndpointType.CHAT ||
-                      endpointType === EndpointType.EMBEDDINGS ||
-                      endpointType === EndpointType.RESPONSES ||
-                      endpointType === EndpointType.ANTHROPIC_MESSAGES
+                        endpointType === EndpointType.EMBEDDINGS ||
+                        endpointType === EndpointType.RESPONSES ||
+                        endpointType === EndpointType.ANTHROPIC_MESSAGES
                         ? "Type your message... (Shift+Enter for new line)"
                         : endpointType === EndpointType.A2A_AGENTS
                           ? "Send a message to the A2A agent..."
diff --git a/ui/litellm-dashboard/src/components/playground/chat_ui/CodeInterpreterOutput.test.tsx b/ui/litellm-dashboard/src/components/playground/chat_ui/CodeInterpreterOutput.test.tsx
index d87a74f4641..a42bd42ed81 100644
--- a/ui/litellm-dashboard/src/components/playground/chat_ui/CodeInterpreterOutput.test.tsx
+++ b/ui/litellm-dashboard/src/components/playground/chat_ui/CodeInterpreterOutput.test.tsx
@@ -5,6 +5,7 @@ import CodeInterpreterOutput from "./CodeInterpreterOutput";
 
 vi.mock("@/components/networking", () => ({
   getProxyBaseUrl: vi.fn(() => "https://example.com"),
+  getGlobalLitellmHeaderName: vi.fn(() => "Authorization"),
 }));
 
 global.fetch = vi.fn();
diff --git a/ui/litellm-dashboard/src/components/playground/chat_ui/CodeInterpreterOutput.tsx b/ui/litellm-dashboard/src/components/playground/chat_ui/CodeInterpreterOutput.tsx
index 5625d0cbf4b..b72e55feaea 100644
--- a/ui/litellm-dashboard/src/components/playground/chat_ui/CodeInterpreterOutput.tsx
+++ b/ui/litellm-dashboard/src/components/playground/chat_ui/CodeInterpreterOutput.tsx
@@ -9,7 +9,7 @@ import {
 } from "@ant-design/icons";
 import { Prism as SyntaxHighlighter } from "react-syntax-highlighter";
 import { coy } from "react-syntax-highlighter/dist/esm/styles/prism";
-import { getProxyBaseUrl } from "@/components/networking";
+import { getProxyBaseUrl, getGlobalLitellmHeaderName } from "@/components/networking";
 
 interface ContainerFileCitation {
   type: "container_file_citation";
@@ -55,7 +55,7 @@ const CodeInterpreterOutput: React.FC<CodeInterpreterOutputProps> = ({
               `${proxyBaseUrl}/v1/containers/${annotation.container_id}/files/${annotation.file_id}/content`,
               {
                 headers: {
-                  Authorization: `Bearer ${accessToken}`,
+                  [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
                 },
               }
             );
@@ -90,7 +90,7 @@ const CodeInterpreterOutput: React.FC<CodeInterpreterOutputProps> = ({
         `${proxyBaseUrl}/v1/containers/${annotation.container_id}/files/${annotation.file_id}/content`,
         {
           headers: {
-            Authorization: `Bearer ${accessToken}`,
+            [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
           },
         }
       );
diff --git a/ui/litellm-dashboard/src/components/playground/llm_calls/a2a_send_message.tsx b/ui/litellm-dashboard/src/components/playground/llm_calls/a2a_send_message.tsx
index 0654db32920..b5cfc820f36 100644
--- a/ui/litellm-dashboard/src/components/playground/llm_calls/a2a_send_message.tsx
+++ b/ui/litellm-dashboard/src/components/playground/llm_calls/a2a_send_message.tsx
@@ -2,7 +2,7 @@
 // A2A Protocol (JSON-RPC 2.0) implementation for sending messages to agents
 
 import { v4 as uuidv4 } from "uuid";
-import { getProxyBaseUrl } from "../../networking";
+import { getProxyBaseUrl, getGlobalLitellmHeaderName } from "../../networking";
 import { A2ATaskMetadata } from "../chat_ui/types";
 
 interface A2AMessagePart {
@@ -143,7 +143,7 @@ export const makeA2ASendMessageRequest = async (
     const response = await fetch(url, {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${accessToken}`,
+        [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
         "Content-Type": "application/json",
       },
       body: JSON.stringify(jsonRpcRequest),
@@ -276,7 +276,7 @@ export const makeA2AStreamMessageRequest = async (
     const response = await fetch(url, {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${accessToken}`,
+        [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
         "Content-Type": "application/json",
       },
       body: JSON.stringify(jsonRpcRequest),
diff --git a/ui/litellm-dashboard/src/components/playground/llm_calls/embeddings_api.test.tsx b/ui/litellm-dashboard/src/components/playground/llm_calls/embeddings_api.test.tsx
index f24a50074c6..19a79f3f9be 100644
--- a/ui/litellm-dashboard/src/components/playground/llm_calls/embeddings_api.test.tsx
+++ b/ui/litellm-dashboard/src/components/playground/llm_calls/embeddings_api.test.tsx
@@ -3,6 +3,7 @@ import { makeOpenAIEmbeddingsRequest } from "./embeddings_api";
 
 vi.mock("@/components/networking", () => ({
   getProxyBaseUrl: vi.fn(() => "https://example.com"),
+  getGlobalLitellmHeaderName: vi.fn(() => "Authorization"),
 }));
 
 describe("embeddings_api", () => {
diff --git a/ui/litellm-dashboard/src/components/playground/llm_calls/embeddings_api.tsx b/ui/litellm-dashboard/src/components/playground/llm_calls/embeddings_api.tsx
index 84192a1d866..cc3c0f81dc5 100644
--- a/ui/litellm-dashboard/src/components/playground/llm_calls/embeddings_api.tsx
+++ b/ui/litellm-dashboard/src/components/playground/llm_calls/embeddings_api.tsx
@@ -1,5 +1,5 @@
 import NotificationManager from "@/components/molecules/notifications_manager";
-import { getProxyBaseUrl } from "@/components/networking";
+import { getProxyBaseUrl, getGlobalLitellmHeaderName } from "@/components/networking";
 
 export async function makeOpenAIEmbeddingsRequest(
   input: string,
@@ -34,7 +34,7 @@ export async function makeOpenAIEmbeddingsRequest(
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${accessToken}`,
+        [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
         ...headers,
       },
       body: JSON.stringify({
diff --git a/ui/litellm-dashboard/src/components/playground/llm_calls/fetch_agents.tsx b/ui/litellm-dashboard/src/components/playground/llm_calls/fetch_agents.tsx
index 889b012c5f7..f0f283c5252 100644
--- a/ui/litellm-dashboard/src/components/playground/llm_calls/fetch_agents.tsx
+++ b/ui/litellm-dashboard/src/components/playground/llm_calls/fetch_agents.tsx
@@ -1,6 +1,6 @@
 // fetch_agents.tsx
 
-import { getProxyBaseUrl } from "../../networking";
+import { getProxyBaseUrl, getGlobalLitellmHeaderName } from "../../networking";
 
 export interface Agent {
   agent_id: string;
@@ -27,7 +27,7 @@ export const fetchAvailableAgents = async (
     const response = await fetch(url, {
       method: "GET",
       headers: {
-        Authorization: `Bearer ${accessToken}`,
+        [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
         "Content-Type": "application/json",
       },
     });
diff --git a/ui/litellm-dashboard/src/components/prompts/prompt_editor_view/conversation_panel/useConversation.ts b/ui/litellm-dashboard/src/components/prompts/prompt_editor_view/conversation_panel/useConversation.ts
index 4372622232e..7b595c777c1 100644
--- a/ui/litellm-dashboard/src/components/prompts/prompt_editor_view/conversation_panel/useConversation.ts
+++ b/ui/litellm-dashboard/src/components/prompts/prompt_editor_view/conversation_panel/useConversation.ts
@@ -3,7 +3,7 @@ import NotificationsManager from "../../../molecules/notifications_manager";
 import { TokenUsage } from "../../../playground/chat_ui/ResponseMetrics";
 import { Message } from "./types";
 import { convertToDotPrompt, extractVariables } from "../utils";
-import { getProxyBaseUrl } from "../../../networking";
+import { getProxyBaseUrl, getGlobalLitellmHeaderName } from "../../../networking";
 
 export const useConversation = (prompt: any, accessToken: string | null) => {
   const [isLoading, setIsLoading] = useState(false);
@@ -91,7 +91,7 @@ export const useConversation = (prompt: any, accessToken: string | null) => {
       const response = await fetch(`${proxyBaseUrl}/prompts/test`, {
         method: "POST",
         headers: {
-          Authorization: `Bearer ${accessToken}`,
+          [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
           "Content-Type": "application/json",
         },
         body: JSON.stringify(requestBody),
diff --git a/ui/litellm-dashboard/src/components/ui_theme_settings.tsx b/ui/litellm-dashboard/src/components/ui_theme_settings.tsx
index 83c5cbb5c15..636163d1d70 100644
--- a/ui/litellm-dashboard/src/components/ui_theme_settings.tsx
+++ b/ui/litellm-dashboard/src/components/ui_theme_settings.tsx
@@ -1,7 +1,7 @@
 import React, { useState, useEffect } from "react";
 import { Card, Title, Text, TextInput, Button } from "@tremor/react";
 import { useTheme } from "@/contexts/ThemeContext";
-import { getProxyBaseUrl } from "@/components/networking";
+import { getProxyBaseUrl, getGlobalLitellmHeaderName } from "@/components/networking";
 import NotificationsManager from "./molecules/notifications_manager";
 
 interface UIThemeSettingsProps {
@@ -29,7 +29,7 @@ const UIThemeSettings: React.FC<UIThemeSettingsProps> = ({ userID, userRole, acc
       const response = await fetch(url, {
         method: "GET",
         headers: {
-          Authorization: `Bearer ${accessToken}`,
+          [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
           "Content-Type": "application/json",
         },
       });
@@ -53,7 +53,7 @@ const UIThemeSettings: React.FC<UIThemeSettingsProps> = ({ userID, userRole, acc
       const response = await fetch(url, {
         method: "PATCH",
         headers: {
-          Authorization: `Bearer ${accessToken}`,
+          [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
           "Content-Type": "application/json",
         },
         body: JSON.stringify({
@@ -87,7 +87,7 @@ const UIThemeSettings: React.FC<UIThemeSettingsProps> = ({ userID, userRole, acc
       const response = await fetch(url, {
         method: "PATCH",
         headers: {
-          Authorization: `Bearer ${accessToken}`,
+          [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
           "Content-Type": "application/json",
         },
         body: JSON.stringify({