From f1bca734319fe1d01ea6dd002118746956dc2c9b Mon Sep 17 00:00:00 2001
From: yuneng-jiang <yuneng.jiang@gmail.com>
Date: Mon, 2 Feb 2026 12:38:36 -0800
Subject: [PATCH 01/29] temp commit for branch switching

---
 .../(dashboard)/hooks/sso/useSSOSettings.ts   |  5 +++
 .../Modals/BaseSSOSettingsForm.tsx            | 37 +++++++++++++++++++
 .../Modals/EditSSOSettingsModal.tsx           | 11 ++++++
 .../AdminSettings/SSOSettings/utils.ts        |  9 +++++
 4 files changed, 62 insertions(+)

diff --git a/ui/litellm-dashboard/src/app/(dashboard)/hooks/sso/useSSOSettings.ts b/ui/litellm-dashboard/src/app/(dashboard)/hooks/sso/useSSOSettings.ts
index f03f397711..fe901f5774 100644
--- a/ui/litellm-dashboard/src/app/(dashboard)/hooks/sso/useSSOSettings.ts
+++ b/ui/litellm-dashboard/src/app/(dashboard)/hooks/sso/useSSOSettings.ts
@@ -28,6 +28,7 @@ export interface SSOSettingsValues {
   user_email: string | null;
   ui_access_mode: string | null;
   role_mappings: RoleMappings;
+  team_mappings: TeamMappings;
 }
 
 export interface RoleMappings {
@@ -39,6 +40,10 @@ export interface RoleMappings {
   };
 }
 
+export interface TeamMappings {
+  team_id_jwt_field: string;
+}
+
 export interface SSOSettingsResponse {
   values: SSOSettingsValues;
   field_schema: SSOFieldSchema;
diff --git a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/BaseSSOSettingsForm.tsx b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/BaseSSOSettingsForm.tsx
index 6431b2dd3a..d16b04466e 100644
--- a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/BaseSSOSettingsForm.tsx
+++ b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/BaseSSOSettingsForm.tsx
@@ -251,6 +251,43 @@ const BaseSSOSettingsForm: React.FC<BaseSSOSettingsFormProps> = ({ form, onFormS
             ) : null;
           }}
         </Form.Item>
+
+        <Form.Item
+          noStyle
+          shouldUpdate={(prevValues, currentValues) => prevValues.sso_provider !== currentValues.sso_provider}
+        >
+          {({ getFieldValue }) => {
+            const provider = getFieldValue("sso_provider");
+            return provider === "okta" || provider === "generic" ? (
+              <Form.Item label="Use Team Mappings" name="use_team_mappings" valuePropName="checked">
+                <Checkbox />
+              </Form.Item>
+            ) : null;
+          }}
+        </Form.Item>
+
+        <Form.Item
+          noStyle
+          shouldUpdate={(prevValues, currentValues) =>
+            prevValues.use_team_mappings !== currentValues.use_team_mappings ||
+            prevValues.sso_provider !== currentValues.sso_provider
+          }
+        >
+          {({ getFieldValue }) => {
+            const useTeamMappings = getFieldValue("use_team_mappings");
+            const provider = getFieldValue("sso_provider");
+            const supportsTeamMappings = provider === "okta" || provider === "generic";
+            return useTeamMappings && supportsTeamMappings ? (
+              <Form.Item
+                label="Team IDs JWT Field"
+                name="team_ids_jwt_field"
+                rules={[{ required: true, message: "Please enter the team IDs JWT field" }]}
+              >
+                <TextInput />
+              </Form.Item>
+            ) : null;
+          }}
+        </Form.Item>
       </Form>
     </div>
   );
diff --git a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/EditSSOSettingsModal.tsx b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/EditSSOSettingsModal.tsx
index a731af68ff..bbae8f1451 100644
--- a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/EditSSOSettingsModal.tsx
+++ b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/EditSSOSettingsModal.tsx
@@ -68,11 +68,22 @@ const EditSSOSettingsModal: React.FC<EditSSOSettingsModalProps> = ({ isVisible,
         };
       }
 
+      // Extract team mappings if they exist
+      let teamMappingFields = {};
+      if (ssoData.values.team_mappings) {
+        const teamMappings = ssoData.values.team_mappings;
+        teamMappingFields = {
+          use_team_mappings: true,
+          team_ids_jwt_field: teamMappings.team_ids_jwt_field,
+        };
+      }
+
       // Set form values with existing data (excluding UI access control fields)
       const formValues = {
         sso_provider: selectedProvider,
         ...ssoData.values,
         ...roleMappingFields,
+        ...teamMappingFields,
       };
 
       console.log("Setting form values:", formValues); // Debug log
diff --git a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/utils.ts b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/utils.ts
index c199048df3..072aa4fc42 100644
--- a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/utils.ts
+++ b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/utils.ts
@@ -13,6 +13,8 @@ export const processSSOSettingsPayload = (formValues: Record<string, any>): Reco
     default_role,
     group_claim,
     use_role_mappings,
+    use_team_mappings,
+    team_ids_jwt_field,
     ...rest
   } = formValues;
 
@@ -52,6 +54,13 @@ export const processSSOSettingsPayload = (formValues: Record<string, any>): Reco
     };
   }
 
+  // Add team mappings only if use_team_mappings is checked
+  if (use_team_mappings) {
+    payload.team_mappings = {
+      team_ids_jwt_field: team_ids_jwt_field,
+    };
+  }
+
   return payload;
 };
 

From 899bafb29025e5ca81ae7196f7bbc806058d7c99 Mon Sep 17 00:00:00 2001
From: yuneng-jiang <yuneng.jiang@gmail.com>
Date: Mon, 2 Feb 2026 13:12:20 -0800
Subject: [PATCH 02/29] adding team mappings UI

---
 .../(dashboard)/hooks/sso/useSSOSettings.ts   |  2 +-
 .../Modals/DeleteSSOSettingsModal.tsx         |  1 +
 .../AdminSettings/SSOSettings/SSOSettings.tsx | 22 +++++++++++++++++--
 .../AdminSettings/SSOSettings/utils.ts        |  9 +++++---
 4 files changed, 28 insertions(+), 6 deletions(-)

diff --git a/ui/litellm-dashboard/src/app/(dashboard)/hooks/sso/useSSOSettings.ts b/ui/litellm-dashboard/src/app/(dashboard)/hooks/sso/useSSOSettings.ts
index fe901f5774..0431a8d39f 100644
--- a/ui/litellm-dashboard/src/app/(dashboard)/hooks/sso/useSSOSettings.ts
+++ b/ui/litellm-dashboard/src/app/(dashboard)/hooks/sso/useSSOSettings.ts
@@ -41,7 +41,7 @@ export interface RoleMappings {
 }
 
 export interface TeamMappings {
-  team_id_jwt_field: string;
+  team_ids_jwt_field: string;
 }
 
 export interface SSOSettingsResponse {
diff --git a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/DeleteSSOSettingsModal.tsx b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/DeleteSSOSettingsModal.tsx
index 44cbf0020e..2656c861aa 100644
--- a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/DeleteSSOSettingsModal.tsx
+++ b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/DeleteSSOSettingsModal.tsx
@@ -33,6 +33,7 @@ const DeleteSSOSettingsModal: React.FC<DeleteSSOSettingsModalProps> = ({ isVisib
       user_email: null,
       sso_provider: null,
       role_mappings: null,
+      team_mappings: null,
     };
 
     await editSSOSettings(clearSettings, {
diff --git a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/SSOSettings.tsx b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/SSOSettings.tsx
index adc1251cde..fdeda0ece3 100644
--- a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/SSOSettings.tsx
+++ b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/SSOSettings.tsx
@@ -1,7 +1,7 @@
 "use client";
 
 import { useSSOSettings, type SSOSettingsValues } from "@/app/(dashboard)/hooks/sso/useSSOSettings";
-import { Button, Card, Descriptions, Space, Typography } from "antd";
+import { Button, Card, Descriptions, Space, Tag, Typography } from "antd";
 import { Edit, Shield, Trash2 } from "lucide-react";
 import { useState } from "react";
 import { ssoProviderDisplayNames, ssoProviderLogoMap } from "./constants";
@@ -28,6 +28,7 @@ export default function SSOSettings() {
 
   const selectedProvider = ssoSettings?.values ? detectSSOProvider(ssoSettings.values) : null;
   const isRoleMappingsEnabled = Boolean(ssoSettings?.values.role_mappings);
+  const isTeamMappingsEnabled = Boolean(ssoSettings?.values.team_mappings);
 
   const renderEndpointValue = (value?: string | null) => (
     <Text className="font-mono text-gray-600 text-sm" copyable={!!value}>
@@ -38,6 +39,15 @@ export default function SSOSettings() {
   const renderSimpleValue = (value?: string | null) =>
     value ? value : <span className="text-gray-400 italic">Not configured</span>;
 
+  const renderTeamMappingsField = (values: SSOSettingsValues) => {
+    if (!values.team_mappings?.team_ids_jwt_field) {
+      return <span className="text-gray-400 italic">Not configured</span>;
+    }
+    return (
+      <Tag>{values.team_mappings.team_ids_jwt_field}</Tag>
+    );
+  };
+
   const descriptionsConfig = {
     column: {
       xxl: 1,
@@ -103,6 +113,10 @@ export default function SSOSettings() {
           render: (values: SSOSettingsValues) => renderEndpointValue(values.generic_userinfo_endpoint),
         },
         { label: "Proxy Base URL", render: (values: SSOSettingsValues) => renderSimpleValue(values.proxy_base_url) },
+        isTeamMappingsEnabled ? {
+          label: "Team IDs JWT Field",
+          render: (values: SSOSettingsValues) => renderTeamMappingsField(values),
+        } : null,
       ],
     },
     generic: {
@@ -129,6 +143,10 @@ export default function SSOSettings() {
           render: (values: SSOSettingsValues) => renderEndpointValue(values.generic_userinfo_endpoint),
         },
         { label: "Proxy Base URL", render: (values: SSOSettingsValues) => renderSimpleValue(values.proxy_base_url) },
+        isTeamMappingsEnabled ? {
+          label: "Team IDs JWT Field",
+          render: (values: SSOSettingsValues) => renderTeamMappingsField(values),
+        } : null,
       ],
     },
   };
@@ -155,7 +173,7 @@ export default function SSOSettings() {
             <span>{config.providerText}</span>
           </div>
         </Descriptions.Item>
-        {config.fields.map((field, index) => (
+        {config.fields.map((field, index) => field && (
           <Descriptions.Item key={index} label={field.label}>
             {field.render(values)}
           </Descriptions.Item>
diff --git a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/utils.ts b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/utils.ts
index 072aa4fc42..948ed4d2bf 100644
--- a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/utils.ts
+++ b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/utils.ts
@@ -23,7 +23,9 @@ export const processSSOSettingsPayload = (formValues: Record<string, any>): Reco
   };
 
   // Add role mappings only if use_role_mappings is checked AND provider supports role mappings
-  if (use_role_mappings) {
+  const provider = rest.sso_provider;
+  const supportsRoleMappings = provider === "okta" || provider === "generic";
+  if (use_role_mappings && supportsRoleMappings) {
     // Helper function to split comma-separated string into array
     const splitTeams = (teams: string | undefined): string[] => {
       if (!teams || teams.trim() === "") return [];
@@ -54,8 +56,9 @@ export const processSSOSettingsPayload = (formValues: Record<string, any>): Reco
     };
   }
 
-  // Add team mappings only if use_team_mappings is checked
-  if (use_team_mappings) {
+  // Add team mappings only if use_team_mappings is checked AND provider supports team mappings
+  const supportsTeamMappings = provider === "okta" || provider === "generic";
+  if (use_team_mappings && supportsTeamMappings) {
     payload.team_mappings = {
       team_ids_jwt_field: team_ids_jwt_field,
     };

From 65c62ffb1b0669bb1f78903c303ede7c49aeaa2c Mon Sep 17 00:00:00 2001
From: yuneng-jiang <yuneng.jiang@gmail.com>
Date: Mon, 2 Feb 2026 14:16:50 -0800
Subject: [PATCH 03/29] Adding tests

---
 .../Modals/BaseSSOSettingsForm.test.tsx       | 111 ++++++++++++++
 .../Modals/EditSSOSettingsModal.test.tsx      | 106 +++++++++++++
 .../AdminSettings/SSOSettings/utils.test.ts   | 144 ++++++++++++++++++
 3 files changed, 361 insertions(+)

diff --git a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/BaseSSOSettingsForm.test.tsx b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/BaseSSOSettingsForm.test.tsx
index a885bffa71..c68e2716f5 100644
--- a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/BaseSSOSettingsForm.test.tsx
+++ b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/BaseSSOSettingsForm.test.tsx
@@ -151,6 +151,117 @@ describe("BaseSSOSettingsForm", () => {
       expect(screen.getByText("Default Role")).toBeInTheDocument();
     });
   });
+
+  it("should show team mappings checkbox for okta provider", async () => {
+    const TestWrapper = () => {
+      const [form] = Form.useForm();
+      const handleSubmit = vi.fn();
+
+      return <BaseSSOSettingsForm form={form} onFormSubmit={handleSubmit} />;
+    };
+
+    renderWithProviders(<TestWrapper />);
+
+    const providerSelect = screen.getByLabelText("SSO Provider");
+    await act(async () => {
+      fireEvent.mouseDown(providerSelect);
+    });
+
+    await waitFor(() => {
+      const oktaOption = screen.getByText(/okta/i);
+      fireEvent.click(oktaOption);
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText("Use Team Mappings")).toBeInTheDocument();
+    });
+  });
+
+  it("should show team mappings checkbox for generic provider", async () => {
+    const TestWrapper = () => {
+      const [form] = Form.useForm();
+      const handleSubmit = vi.fn();
+
+      return <BaseSSOSettingsForm form={form} onFormSubmit={handleSubmit} />;
+    };
+
+    renderWithProviders(<TestWrapper />);
+
+    const providerSelect = screen.getByLabelText("SSO Provider");
+    await act(async () => {
+      fireEvent.mouseDown(providerSelect);
+    });
+
+    await waitFor(() => {
+      const genericOption = screen.getByText(/generic sso/i);
+      fireEvent.click(genericOption);
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText("Use Team Mappings")).toBeInTheDocument();
+    });
+  });
+
+  it("should show team IDs JWT field when use_team_mappings is checked for okta provider", async () => {
+    const TestWrapper = () => {
+      const [form] = Form.useForm();
+      const handleSubmit = vi.fn();
+
+      return <BaseSSOSettingsForm form={form} onFormSubmit={handleSubmit} />;
+    };
+
+    renderWithProviders(<TestWrapper />);
+
+    const providerSelect = screen.getByLabelText("SSO Provider");
+    await act(async () => {
+      fireEvent.mouseDown(providerSelect);
+    });
+
+    await waitFor(() => {
+      const oktaOption = screen.getByText(/okta/i);
+      fireEvent.click(oktaOption);
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText("Use Team Mappings")).toBeInTheDocument();
+    });
+
+    const checkbox = screen.getByLabelText("Use Team Mappings");
+    await act(async () => {
+      fireEvent.click(checkbox);
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText("Team IDs JWT Field")).toBeInTheDocument();
+    });
+  });
+
+  it("should not show team mappings checkbox for google provider", async () => {
+    const TestWrapper = () => {
+      const [form] = Form.useForm();
+      const handleSubmit = vi.fn();
+
+      return <BaseSSOSettingsForm form={form} onFormSubmit={handleSubmit} />;
+    };
+
+    renderWithProviders(<TestWrapper />);
+
+    const providerSelect = screen.getByLabelText("SSO Provider");
+    await act(async () => {
+      fireEvent.mouseDown(providerSelect);
+    });
+
+    await waitFor(() => {
+      const googleOption = screen.getByText(/google sso/i);
+      fireEvent.click(googleOption);
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText("Google Client ID")).toBeInTheDocument();
+    });
+
+    expect(screen.queryByText("Use Team Mappings")).not.toBeInTheDocument();
+  });
 });
 
 describe("renderProviderFields", () => {
diff --git a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/EditSSOSettingsModal.test.tsx b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/EditSSOSettingsModal.test.tsx
index 559d837b40..d2d5403339 100644
--- a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/EditSSOSettingsModal.test.tsx
+++ b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/Modals/EditSSOSettingsModal.test.tsx
@@ -105,6 +105,14 @@ const createRoleMappingsSSOData = (overrides: Record<string, any> = {}) =>
     ...overrides,
   });
 
+const createTeamMappingsSSOData = (overrides: Record<string, any> = {}) =>
+  createGenericSSOData({
+    team_mappings: {
+      team_ids_jwt_field: overrides.team_ids_jwt_field || "teams",
+    },
+    ...overrides,
+  });
+
 // Mock utilities
 const createMockHooks = (): {
   useSSOSettings: SSOSettingsHookReturn;
@@ -577,6 +585,104 @@ describe("EditSSOSettingsModal", () => {
         });
       });
     });
+  });
+
+  describe("Team Mappings", () => {
+    it("processes team mappings when team_mappings exists", async () => {
+      const ssoData = createTeamMappingsSSOData();
+
+      setupMocks({
+        useSSOSettings: { data: ssoData, isLoading: false, error: null },
+      });
+
+      renderComponent();
+
+      await waitFor(() => {
+        expect(mockForm.setFieldsValue).toHaveBeenCalledWith({
+          sso_provider: SSO_PROVIDERS.GENERIC,
+          ...ssoData.values,
+          use_team_mappings: true,
+          team_ids_jwt_field: "teams",
+        });
+      });
+    });
+
+    it("handles team mappings with custom JWT field name", async () => {
+      const ssoData = createTeamMappingsSSOData({
+        team_ids_jwt_field: "custom_teams_field",
+      });
+
+      setupMocks({
+        useSSOSettings: { data: ssoData, isLoading: false, error: null },
+      });
+
+      renderComponent();
+
+      await waitFor(() => {
+        expect(mockForm.setFieldsValue).toHaveBeenCalledWith({
+          sso_provider: SSO_PROVIDERS.GENERIC,
+          ...ssoData.values,
+          use_team_mappings: true,
+          team_ids_jwt_field: "custom_teams_field",
+        });
+      });
+    });
+
+    it("handles team mappings and role mappings together", async () => {
+      const ssoData = createGenericSSOData({
+        role_mappings: {
+          group_claim: "groups",
+          default_role: "internal_user",
+          roles: {
+            proxy_admin: ["admin-group"],
+            proxy_admin_viewer: [],
+            internal_user: [],
+            internal_user_viewer: [],
+          },
+        },
+        team_mappings: {
+          team_ids_jwt_field: "teams",
+        },
+      });
+
+      setupMocks({
+        useSSOSettings: { data: ssoData, isLoading: false, error: null },
+      });
+
+      renderComponent();
+
+      await waitFor(() => {
+        expect(mockForm.setFieldsValue).toHaveBeenCalledWith({
+          sso_provider: SSO_PROVIDERS.GENERIC,
+          ...ssoData.values,
+          use_role_mappings: true,
+          group_claim: "groups",
+          default_role: "internal_user",
+          proxy_admin_teams: "admin-group",
+          admin_viewer_teams: "",
+          internal_user_teams: "",
+          internal_viewer_teams: "",
+          use_team_mappings: true,
+          team_ids_jwt_field: "teams",
+        });
+      });
+    });
+
+    it("does not set team mapping fields when team_mappings is not present", async () => {
+      const ssoData = createGenericSSOData();
+
+      setupMocks({
+        useSSOSettings: { data: ssoData, isLoading: false, error: null },
+      });
+
+      renderComponent();
+
+      await waitFor(() => {
+        const callArgs = mockForm.setFieldsValue.mock.calls[0][0];
+        expect(callArgs.use_team_mappings).toBeUndefined();
+        expect(callArgs.team_ids_jwt_field).toBeUndefined();
+      });
+    });
 
     it("handles provider detection with partial SSO data", async () => {
       const ssoData = createSSOData({
diff --git a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/utils.test.ts b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/utils.test.ts
index 718302d35f..722d52d64f 100644
--- a/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/utils.test.ts
+++ b/ui/litellm-dashboard/src/components/Settings/AdminSettings/SSOSettings/utils.test.ts
@@ -12,6 +12,8 @@ describe("processSSOSettingsPayload", () => {
         default_role: "proxy_admin",
         group_claim: "groups",
         use_role_mappings: false,
+        use_team_mappings: false,
+        team_ids_jwt_field: "teams",
         other_field: "value",
         another_field: 123,
       };
@@ -23,6 +25,7 @@ describe("processSSOSettingsPayload", () => {
         another_field: 123,
       });
       expect(result.role_mappings).toBeUndefined();
+      expect(result.team_mappings).toBeUndefined();
     });
 
     it("should return all fields except role mapping fields when use_role_mappings is not present", () => {
@@ -33,6 +36,8 @@ describe("processSSOSettingsPayload", () => {
         internal_viewer_teams: "viewer1",
         default_role: "proxy_admin",
         group_claim: "groups",
+        use_team_mappings: false,
+        team_ids_jwt_field: "teams",
         other_field: "value",
       };
 
@@ -42,6 +47,7 @@ describe("processSSOSettingsPayload", () => {
         other_field: "value",
       });
       expect(result.role_mappings).toBeUndefined();
+      expect(result.team_mappings).toBeUndefined();
     });
   });
 
@@ -253,6 +259,143 @@ describe("processSSOSettingsPayload", () => {
     });
   });
 
+  describe("without team mappings", () => {
+    it("should return all fields except team mapping fields when use_team_mappings is false", () => {
+      const formValues = {
+        use_team_mappings: false,
+        team_ids_jwt_field: "teams",
+        sso_provider: "okta",
+        other_field: "value",
+      };
+
+      const result = processSSOSettingsPayload(formValues);
+
+      expect(result).toEqual({
+        sso_provider: "okta",
+        other_field: "value",
+      });
+      expect(result.team_mappings).toBeUndefined();
+    });
+
+    it("should return all fields except team mapping fields when use_team_mappings is not present", () => {
+      const formValues = {
+        team_ids_jwt_field: "teams",
+        sso_provider: "generic",
+        other_field: "value",
+      };
+
+      const result = processSSOSettingsPayload(formValues);
+
+      expect(result).toEqual({
+        sso_provider: "generic",
+        other_field: "value",
+      });
+      expect(result.team_mappings).toBeUndefined();
+    });
+
+    it("should not include team mappings for unsupported providers even when use_team_mappings is true", () => {
+      const formValues = {
+        use_team_mappings: true,
+        team_ids_jwt_field: "teams",
+        sso_provider: "google",
+        other_field: "value",
+      };
+
+      const result = processSSOSettingsPayload(formValues);
+
+      expect(result).toEqual({
+        sso_provider: "google",
+        other_field: "value",
+      });
+      expect(result.team_mappings).toBeUndefined();
+    });
+
+    it("should not include team mappings for microsoft provider even when use_team_mappings is true", () => {
+      const formValues = {
+        use_team_mappings: true,
+        team_ids_jwt_field: "teams",
+        sso_provider: "microsoft",
+        other_field: "value",
+      };
+
+      const result = processSSOSettingsPayload(formValues);
+
+      expect(result).toEqual({
+        sso_provider: "microsoft",
+        other_field: "value",
+      });
+      expect(result.team_mappings).toBeUndefined();
+    });
+  });
+
+  describe("with team mappings enabled", () => {
+    it("should create team mappings for okta provider when use_team_mappings is true", () => {
+      const formValues = {
+        use_team_mappings: true,
+        team_ids_jwt_field: "teams",
+        sso_provider: "okta",
+        other_field: "value",
+      };
+
+      const result = processSSOSettingsPayload(formValues);
+
+      expect(result.other_field).toBe("value");
+      expect(result.team_mappings).toEqual({
+        team_ids_jwt_field: "teams",
+      });
+    });
+
+    it("should create team mappings for generic provider when use_team_mappings is true", () => {
+      const formValues = {
+        use_team_mappings: true,
+        team_ids_jwt_field: "custom_teams",
+        sso_provider: "generic",
+        other_field: "value",
+      };
+
+      const result = processSSOSettingsPayload(formValues);
+
+      expect(result.other_field).toBe("value");
+      expect(result.team_mappings).toEqual({
+        team_ids_jwt_field: "custom_teams",
+      });
+    });
+
+    it("should exclude team mapping fields from payload when team mappings are included", () => {
+      const formValues = {
+        use_team_mappings: true,
+        team_ids_jwt_field: "teams",
+        sso_provider: "okta",
+        other_field: "value",
+      };
+
+      const result = processSSOSettingsPayload(formValues);
+
+      expect(result.use_team_mappings).toBeUndefined();
+      expect(result.team_ids_jwt_field).toBeUndefined();
+    });
+
+    it("should handle team mappings and role mappings together", () => {
+      const formValues = {
+        use_team_mappings: true,
+        team_ids_jwt_field: "teams",
+        use_role_mappings: true,
+        group_claim: "groups",
+        default_role: "internal_user",
+        sso_provider: "okta",
+        other_field: "value",
+      };
+
+      const result = processSSOSettingsPayload(formValues);
+
+      expect(result.team_mappings).toEqual({
+        team_ids_jwt_field: "teams",
+      });
+      expect(result.role_mappings).toBeDefined();
+      expect(result.role_mappings.group_claim).toBe("groups");
+    });
+  });
+
   describe("edge cases", () => {
     it("should handle empty form values", () => {
       const result = processSSOSettingsPayload({});
@@ -263,6 +406,7 @@ describe("processSSOSettingsPayload", () => {
     it("should preserve other fields in the payload", () => {
       const formValues = {
         use_role_mappings: false,
+        use_team_mappings: false,
         sso_provider: "google",
         client_id: "123",
         client_secret: "secret",

From edfe2394b951e335f18e3185b6c33991585e6428 Mon Sep 17 00:00:00 2001
From: yuneng-jiang <yuneng.jiang@gmail.com>
Date: Mon, 2 Feb 2026 15:52:30 -0800
Subject: [PATCH 04/29] reset_spend endpoint

---
 litellm/proxy/_types.py                       |   5 +
 .../key_management_endpoints.py               | 157 ++++
 .../test_key_management_endpoints.py          | 701 ++++++++++++++++++
 3 files changed, 863 insertions(+)

diff --git a/litellm/proxy/_types.py b/litellm/proxy/_types.py
index 045d2fd5f1..9ae95085f5 100644
--- a/litellm/proxy/_types.py
+++ b/litellm/proxy/_types.py
@@ -228,6 +228,7 @@ class KeyManagementRoutes(str, enum.Enum):
     KEY_BLOCK = "/key/block"
     KEY_UNBLOCK = "/key/unblock"
     KEY_BULK_UPDATE = "/key/bulk_update"
+    KEY_RESET_SPEND = "/key/{key_id}/reset_spend"
 
     # info and health routes
     KEY_INFO = "/key/info"
@@ -987,6 +988,10 @@ class RegenerateKeyRequest(GenerateKeyRequest):
     new_master_key: Optional[str] = None
 
 
+class ResetSpendRequest(LiteLLMPydanticObjectBase):
+    reset_to: float
+
+
 class KeyRequest(LiteLLMPydanticObjectBase):
     keys: Optional[List[str]] = None
     key_aliases: Optional[List[str]] = None
diff --git a/litellm/proxy/management_endpoints/key_management_endpoints.py b/litellm/proxy/management_endpoints/key_management_endpoints.py
index 278971a91a..d184036300 100644
--- a/litellm/proxy/management_endpoints/key_management_endpoints.py
+++ b/litellm/proxy/management_endpoints/key_management_endpoints.py
@@ -3373,6 +3373,163 @@ async def regenerate_key_fn(
         raise handle_exception_on_proxy(e)
 
 
+async def _check_proxy_or_team_admin_for_key(
+    key_in_db: LiteLLM_VerificationToken,
+    user_api_key_dict: UserAPIKeyAuth,
+    prisma_client: PrismaClient,
+    user_api_key_cache: DualCache,
+) -> None:
+    if user_api_key_dict.user_role == LitellmUserRoles.PROXY_ADMIN.value:
+        return
+
+    if key_in_db.team_id is not None:
+        team_table = await get_team_object(
+            team_id=key_in_db.team_id,
+            prisma_client=prisma_client,
+            user_api_key_cache=user_api_key_cache,
+            check_db_only=True,
+        )
+        if team_table is not None:
+            if _is_user_team_admin(
+                user_api_key_dict=user_api_key_dict,
+                team_obj=team_table,
+            ):
+                return
+
+    raise HTTPException(
+        status_code=status.HTTP_403_FORBIDDEN,
+        detail={"error": "You must be a proxy admin or team admin to reset key spend"},
+    )
+
+
+def _validate_reset_spend_value(
+    reset_to: Any, key_in_db: LiteLLM_VerificationToken
+) -> float:
+    if not isinstance(reset_to, (int, float)):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={"error": "reset_to must be a float"},
+        )
+
+    reset_to = float(reset_to)
+
+    if reset_to < 0:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={"error": "reset_to must be >= 0"},
+        )
+
+    current_spend = key_in_db.spend or 0.0
+    if reset_to > current_spend:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={"error": f"reset_to ({reset_to}) must be <= current spend ({current_spend})"},
+        )
+
+    max_budget = key_in_db.max_budget
+    if key_in_db.litellm_budget_table is not None:
+        budget_max_budget = getattr(key_in_db.litellm_budget_table, "max_budget", None)
+        if budget_max_budget is not None:
+            if max_budget is None or budget_max_budget < max_budget:
+                max_budget = budget_max_budget
+
+    if max_budget is not None and reset_to > max_budget:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={"error": f"reset_to ({reset_to}) must be <= budget ({max_budget})"},
+        )
+
+    return reset_to
+
+
+@router.post(
+    "/key/{key:path}/reset_spend",
+    tags=["key management"],
+    dependencies=[Depends(user_api_key_auth)],
+)
+@management_endpoint_wrapper
+async def reset_key_spend_fn(
+    key: str,
+    data: ResetSpendRequest,
+    user_api_key_dict: UserAPIKeyAuth = Depends(user_api_key_auth),
+    litellm_changed_by: Optional[str] = Header(
+        None,
+        description="The litellm-changed-by header enables tracking of actions performed by authorized users on behalf of other users, providing an audit trail for accountability",
+    ),
+) -> Dict[str, Any]:
+    try:
+        from litellm.proxy.proxy_server import (
+            hash_token,
+            prisma_client,
+            proxy_logging_obj,
+            user_api_key_cache,
+        )
+
+        if prisma_client is None:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail={"error": "DB not connected. prisma_client is None"},
+            )
+
+        if "sk" not in key:
+            hashed_api_key = key
+        else:
+            hashed_api_key = hash_token(key)
+
+        _key_in_db = await prisma_client.db.litellm_verificationtoken.find_unique(
+            where={"token": hashed_api_key},
+            include={"litellm_budget_table": True},
+        )
+        if _key_in_db is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail={"error": f"Key {key} not found."},
+            )
+
+        current_spend = _key_in_db.spend or 0.0
+        reset_to = _validate_reset_spend_value(data.reset_to, _key_in_db)
+
+        await _check_proxy_or_team_admin_for_key(
+            key_in_db=_key_in_db,
+            user_api_key_dict=user_api_key_dict,
+            prisma_client=prisma_client,
+            user_api_key_cache=user_api_key_cache,
+        )
+
+        updated_key = await prisma_client.db.litellm_verificationtoken.update(
+            where={"token": hashed_api_key},
+            data={"spend": reset_to},
+        )
+
+        if updated_key is None:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail={"error": "Failed to update key spend"},
+            )
+
+        await _delete_cache_key_object(
+            hashed_token=hashed_api_key,
+            user_api_key_cache=user_api_key_cache,
+            proxy_logging_obj=proxy_logging_obj,
+        )
+
+        max_budget = updated_key.max_budget
+        budget_reset_at = updated_key.budget_reset_at
+
+        return {
+            "key_hash": hashed_api_key,
+            "spend": reset_to,
+            "previous_spend": current_spend,
+            "max_budget": max_budget,
+            "budget_reset_at": budget_reset_at,
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        verbose_proxy_logger.exception("Error resetting key spend: %s", e)
+        raise handle_exception_on_proxy(e)
+
+
 async def validate_key_list_check(
     user_api_key_dict: UserAPIKeyAuth,
     user_id: Optional[str],
diff --git a/tests/test_litellm/proxy/management_endpoints/test_key_management_endpoints.py b/tests/test_litellm/proxy/management_endpoints/test_key_management_endpoints.py
index 3638fd7e2c..e90fb277ee 100644
--- a/tests/test_litellm/proxy/management_endpoints/test_key_management_endpoints.py
+++ b/tests/test_litellm/proxy/management_endpoints/test_key_management_endpoints.py
@@ -19,10 +19,12 @@ from litellm.proxy._types import (
     LiteLLM_BudgetTable,
     LiteLLM_OrganizationTable,
     LiteLLM_TeamTableCachedObj,
+    LiteLLM_UserTable,
     LiteLLM_VerificationToken,
     LitellmUserRoles,
     Member,
     ProxyException,
+    ResetSpendRequest,
     UpdateKeyRequest,
 )
 from litellm.proxy.auth.user_api_key_auth import UserAPIKeyAuth
@@ -37,6 +39,7 @@ from litellm.proxy.management_endpoints.key_management_endpoints import (
     _save_deleted_verification_token_records,
     _transform_verification_tokens_to_deleted_records,
     _validate_max_budget,
+    _validate_reset_spend_value,
     can_modify_verification_token,
     check_org_key_model_specific_limits,
     check_team_key_model_specific_limits,
@@ -44,6 +47,8 @@ from litellm.proxy.management_endpoints.key_management_endpoints import (
     generate_key_helper_fn,
     list_keys,
     prepare_key_update_data,
+    reset_key_spend_fn,
+    validate_key_list_check,
     validate_key_team_change,
 )
 from litellm.proxy.proxy_server import app
@@ -4690,3 +4695,699 @@ async def test_bulk_update_keys_partial_failures(monkeypatch):
                         assert response.successful_updates[0].key == "test-key-1"
                         assert response.failed_updates[0].key == "non-existent-key"
                         assert "Key not found" in response.failed_updates[0].failed_reason
+
+
+@pytest.mark.parametrize(
+    "reset_to,key_spend,key_max_budget,budget_max_budget,expected_error",
+    [
+        ("not_a_number", 100.0, None, None, "reset_to must be a float"),
+        (None, 100.0, None, None, "reset_to must be a float"),
+        ([], 100.0, None, None, "reset_to must be a float"),
+        ({}, 100.0, None, None, "reset_to must be a float"),
+        (-1.0, 100.0, None, None, "reset_to must be >= 0"),
+        (-0.1, 100.0, None, None, "reset_to must be >= 0"),
+        (101.0, 100.0, None, None, "reset_to (101.0) must be <= current spend (100.0)"),
+        (150.0, 100.0, None, None, "reset_to (150.0) must be <= current spend (100.0)"),
+        (50.0, 100.0, 30.0, None, "reset_to (50.0) must be <= budget (30.0)"),
+    ],
+)
+def test_validate_reset_spend_value_invalid(
+    reset_to, key_spend, key_max_budget, budget_max_budget, expected_error
+):
+    key_in_db = LiteLLM_VerificationToken(
+        token="test-token",
+        user_id="test-user",
+        spend=key_spend,
+        max_budget=key_max_budget,
+        litellm_budget_table=LiteLLM_BudgetTable(
+            budget_id="test-budget", max_budget=budget_max_budget
+        ).dict()
+        if budget_max_budget is not None
+        else None,
+    )
+
+    with pytest.raises(HTTPException) as exc_info:
+        _validate_reset_spend_value(reset_to, key_in_db)
+
+    assert exc_info.value.status_code == 400
+    assert expected_error in str(exc_info.value.detail)
+
+
+@pytest.mark.parametrize(
+    "reset_to,key_spend,key_max_budget,budget_max_budget",
+    [
+        (0.0, 100.0, None, None),
+        (0, 100.0, None, None),
+        (50.0, 100.0, None, None),
+        (100.0, 100.0, None, None),
+        (25.0, 100.0, 50.0, None),
+        (0.0, 0.0, None, None),
+        (10.5, 50.0, 20.0, None),
+    ],
+)
+def test_validate_reset_spend_value_valid(
+    reset_to, key_spend, key_max_budget, budget_max_budget
+):
+    key_in_db = LiteLLM_VerificationToken(
+        token="test-token",
+        user_id="test-user",
+        spend=key_spend,
+        max_budget=key_max_budget,
+        litellm_budget_table=LiteLLM_BudgetTable(
+            budget_id="test-budget", max_budget=budget_max_budget
+        ).dict()
+        if budget_max_budget is not None
+        else None,
+    )
+
+    result = _validate_reset_spend_value(reset_to, key_in_db)
+    assert result == float(reset_to)
+
+
+def test_validate_reset_spend_value_no_budget_table():
+    key_in_db = LiteLLM_VerificationToken(
+        token="test-token",
+        user_id="test-user",
+        spend=100.0,
+        max_budget=50.0,
+        litellm_budget_table=None,
+    )
+
+    result = _validate_reset_spend_value(25.0, key_in_db)
+    assert result == 25.0
+
+
+def test_validate_reset_spend_value_none_spend():
+    key_in_db = LiteLLM_VerificationToken(
+        token="test-token",
+        user_id="test-user",
+        spend=0.0,
+        max_budget=None,
+        litellm_budget_table=None,
+    )
+
+    result = _validate_reset_spend_value(0.0, key_in_db)
+    assert result == 0.0
+
+    with pytest.raises(HTTPException) as exc_info:
+        _validate_reset_spend_value(1.0, key_in_db)
+    assert exc_info.value.status_code == 400
+    assert "must be <= current spend" in str(exc_info.value.detail)
+
+
+@pytest.mark.asyncio
+async def test_reset_key_spend_success(monkeypatch):
+    mock_prisma_client = MagicMock()
+    mock_user_api_key_cache = MagicMock()
+    mock_proxy_logging_obj = MagicMock()
+
+    hashed_key = "hashed-test-key"
+    key_in_db = LiteLLM_VerificationToken(
+        token=hashed_key,
+        user_id="test-user",
+        spend=100.0,
+        max_budget=200.0,
+        litellm_budget_table=None,
+    )
+
+    updated_key = LiteLLM_VerificationToken(
+        token=hashed_key,
+        user_id="test-user",
+        spend=50.0,
+        max_budget=200.0,
+        budget_reset_at=None,
+    )
+
+    mock_prisma_client.db.litellm_verificationtoken.find_unique = AsyncMock(
+        return_value=key_in_db
+    )
+    mock_prisma_client.db.litellm_verificationtoken.update = AsyncMock(
+        return_value=updated_key
+    )
+
+    monkeypatch.setattr(
+        "litellm.proxy.proxy_server.prisma_client", mock_prisma_client
+    )
+    monkeypatch.setattr(
+        "litellm.proxy.proxy_server.user_api_key_cache", mock_user_api_key_cache
+    )
+    monkeypatch.setattr(
+        "litellm.proxy.proxy_server.proxy_logging_obj", mock_proxy_logging_obj
+    )
+
+    with patch(
+        "litellm.proxy.proxy_server.hash_token"
+    ) as mock_hash_token, patch(
+        "litellm.proxy.management_endpoints.key_management_endpoints._check_proxy_or_team_admin_for_key"
+    ) as mock_check_admin, patch(
+        "litellm.proxy.management_endpoints.key_management_endpoints._delete_cache_key_object"
+    ) as mock_delete_cache:
+        mock_hash_token.return_value = hashed_key
+        mock_check_admin.return_value = None
+        mock_delete_cache.return_value = None
+
+        user_api_key_dict = UserAPIKeyAuth(
+            user_role=LitellmUserRoles.PROXY_ADMIN,
+            api_key="sk-admin",
+            user_id="admin-user",
+        )
+
+        response = await reset_key_spend_fn(
+            key="sk-test-key",
+            data=ResetSpendRequest(reset_to=50.0),
+            user_api_key_dict=user_api_key_dict,
+            litellm_changed_by=None,
+        )
+
+        assert response["spend"] == 50.0
+        assert response["previous_spend"] == 100.0
+        assert response["key_hash"] == hashed_key
+        assert response["max_budget"] == 200.0
+        mock_prisma_client.db.litellm_verificationtoken.update.assert_called_once()
+        mock_delete_cache.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_reset_key_spend_success_team_admin(monkeypatch):
+    """Test that team admin can reset key spend for keys in their team."""
+    mock_prisma_client = MagicMock()
+    mock_user_api_key_cache = MagicMock()
+    mock_proxy_logging_obj = MagicMock()
+
+    hashed_key = "hashed-test-key"
+    team_id = "test-team-123"
+    key_in_db = LiteLLM_VerificationToken(
+        token=hashed_key,
+        user_id="test-user",
+        team_id=team_id,
+        spend=100.0,
+        max_budget=200.0,
+        litellm_budget_table=None,
+    )
+
+    updated_key = LiteLLM_VerificationToken(
+        token=hashed_key,
+        user_id="test-user",
+        team_id=team_id,
+        spend=50.0,
+        max_budget=200.0,
+        budget_reset_at=None,
+    )
+
+    mock_prisma_client.db.litellm_verificationtoken.find_unique = AsyncMock(
+        return_value=key_in_db
+    )
+    mock_prisma_client.db.litellm_verificationtoken.update = AsyncMock(
+        return_value=updated_key
+    )
+
+    # Set up team table with user as admin
+    team_table = LiteLLM_TeamTableCachedObj(
+        team_id=team_id,
+        team_alias="test-team",
+        tpm_limit=None,
+        rpm_limit=None,
+        max_budget=None,
+        spend=0.0,
+        models=[],
+        blocked=False,
+        members_with_roles=[
+            Member(user_id="team-admin-user", role="admin"),
+            Member(user_id="test-user", role="user"),
+        ],
+    )
+
+    async def mock_get_team_object(*args, **kwargs):
+        return team_table
+
+    monkeypatch.setattr(
+        "litellm.proxy.proxy_server.prisma_client", mock_prisma_client
+    )
+    monkeypatch.setattr(
+        "litellm.proxy.proxy_server.user_api_key_cache", mock_user_api_key_cache
+    )
+    monkeypatch.setattr(
+        "litellm.proxy.proxy_server.proxy_logging_obj", mock_proxy_logging_obj
+    )
+    monkeypatch.setattr(
+        "litellm.proxy.management_endpoints.key_management_endpoints.get_team_object",
+        mock_get_team_object,
+    )
+
+    with patch(
+        "litellm.proxy.proxy_server.hash_token"
+    ) as mock_hash_token, patch(
+        "litellm.proxy.management_endpoints.key_management_endpoints._delete_cache_key_object"
+    ) as mock_delete_cache:
+        mock_hash_token.return_value = hashed_key
+        mock_delete_cache.return_value = None
+
+        user_api_key_dict = UserAPIKeyAuth(
+            user_role=LitellmUserRoles.INTERNAL_USER,
+            api_key="sk-team-admin",
+            user_id="team-admin-user",
+        )
+
+        response = await reset_key_spend_fn(
+            key="sk-test-key",
+            data=ResetSpendRequest(reset_to=50.0),
+            user_api_key_dict=user_api_key_dict,
+            litellm_changed_by=None,
+        )
+
+        assert response["spend"] == 50.0
+        assert response["previous_spend"] == 100.0
+        assert response["key_hash"] == hashed_key
+        assert response["max_budget"] == 200.0
+        mock_prisma_client.db.litellm_verificationtoken.update.assert_called_once()
+        mock_delete_cache.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_reset_key_spend_key_not_found(monkeypatch):
+    mock_prisma_client = MagicMock()
+    mock_prisma_client.db.litellm_verificationtoken.find_unique = AsyncMock(
+        return_value=None
+    )
+
+    monkeypatch.setattr(
+        "litellm.proxy.proxy_server.prisma_client", mock_prisma_client
+    )
+
+    with patch("litellm.proxy.proxy_server.hash_token") as mock_hash_token:
+        mock_hash_token.return_value = "hashed-key"
+
+        user_api_key_dict = UserAPIKeyAuth(
+            user_role=LitellmUserRoles.PROXY_ADMIN,
+            api_key="sk-admin",
+            user_id="admin-user",
+        )
+
+        with pytest.raises(HTTPException) as exc_info:
+            await reset_key_spend_fn(
+                key="sk-test-key",
+                data=ResetSpendRequest(reset_to=50.0),
+                user_api_key_dict=user_api_key_dict,
+                litellm_changed_by=None,
+            )
+
+        assert exc_info.value.status_code == 404
+        assert "Key not found" in str(exc_info.value.detail) or "Key sk-test-key not found" in str(exc_info.value.detail)
+
+
+@pytest.mark.asyncio
+async def test_reset_key_spend_db_not_connected(monkeypatch):
+    monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", None)
+
+    user_api_key_dict = UserAPIKeyAuth(
+        user_role=LitellmUserRoles.PROXY_ADMIN,
+        api_key="sk-admin",
+        user_id="admin-user",
+    )
+
+    with pytest.raises(HTTPException) as exc_info:
+        await reset_key_spend_fn(
+            key="sk-test-key",
+            data=ResetSpendRequest(reset_to=50.0),
+            user_api_key_dict=user_api_key_dict,
+            litellm_changed_by=None,
+        )
+
+    assert exc_info.value.status_code == 500
+    assert "DB not connected" in str(exc_info.value.detail)
+
+
+@pytest.mark.asyncio
+async def test_reset_key_spend_validation_error(monkeypatch):
+    mock_prisma_client = MagicMock()
+    key_in_db = LiteLLM_VerificationToken(
+        token="hashed-key",
+        user_id="test-user",
+        spend=100.0,
+        max_budget=None,
+        litellm_budget_table=None,
+    )
+
+    mock_prisma_client.db.litellm_verificationtoken.find_unique = AsyncMock(
+        return_value=key_in_db
+    )
+
+    monkeypatch.setattr(
+        "litellm.proxy.proxy_server.prisma_client", mock_prisma_client
+    )
+
+    with patch("litellm.proxy.proxy_server.hash_token") as mock_hash_token:
+        mock_hash_token.return_value = "hashed-key"
+
+        user_api_key_dict = UserAPIKeyAuth(
+            user_role=LitellmUserRoles.PROXY_ADMIN,
+            api_key="sk-admin",
+            user_id="admin-user",
+        )
+
+        with pytest.raises(HTTPException) as exc_info:
+            await reset_key_spend_fn(
+                key="sk-test-key",
+                data=ResetSpendRequest(reset_to=150.0),
+                user_api_key_dict=user_api_key_dict,
+                litellm_changed_by=None,
+            )
+
+        assert exc_info.value.status_code == 400
+        assert "must be <= current spend" in str(exc_info.value.detail)
+
+
+@pytest.mark.asyncio
+async def test_reset_key_spend_authorization_failure(monkeypatch):
+    mock_prisma_client = MagicMock()
+    mock_user_api_key_cache = MagicMock()
+
+    hashed_key = "hashed-test-key"
+    key_in_db = LiteLLM_VerificationToken(
+        token=hashed_key,
+        user_id="test-user",
+        team_id="team-1",
+        spend=100.0,
+        max_budget=None,
+        litellm_budget_table=None,
+    )
+
+    mock_prisma_client.db.litellm_verificationtoken.find_unique = AsyncMock(
+        return_value=key_in_db
+    )
+
+    monkeypatch.setattr(
+        "litellm.proxy.proxy_server.prisma_client", mock_prisma_client
+    )
+    monkeypatch.setattr(
+        "litellm.proxy.proxy_server.user_api_key_cache", mock_user_api_key_cache
+    )
+
+    with patch("litellm.proxy.proxy_server.hash_token") as mock_hash_token, patch(
+        "litellm.proxy.management_endpoints.key_management_endpoints._check_proxy_or_team_admin_for_key"
+    ) as mock_check_admin:
+        mock_hash_token.return_value = hashed_key
+        mock_check_admin.side_effect = HTTPException(
+            status_code=403, detail={"error": "Not authorized"}
+        )
+
+        user_api_key_dict = UserAPIKeyAuth(
+            user_role=LitellmUserRoles.INTERNAL_USER,
+            api_key="sk-user",
+            user_id="user-1",
+        )
+
+        with pytest.raises(HTTPException) as exc_info:
+            await reset_key_spend_fn(
+                key="sk-test-key",
+                data=ResetSpendRequest(reset_to=50.0),
+                user_api_key_dict=user_api_key_dict,
+                litellm_changed_by=None,
+            )
+
+        assert exc_info.value.status_code == 403
+
+
+@pytest.mark.asyncio
+async def test_reset_key_spend_hashed_key(monkeypatch):
+    mock_prisma_client = MagicMock()
+    mock_user_api_key_cache = MagicMock()
+    mock_proxy_logging_obj = MagicMock()
+
+    hashed_key = "already-hashed-key"
+    key_in_db = LiteLLM_VerificationToken(
+        token=hashed_key,
+        user_id="test-user",
+        spend=100.0,
+        max_budget=None,
+        litellm_budget_table=None,
+    )
+
+    updated_key = LiteLLM_VerificationToken(
+        token=hashed_key,
+        user_id="test-user",
+        spend=50.0,
+        max_budget=None,
+        budget_reset_at=None,
+    )
+
+    mock_prisma_client.db.litellm_verificationtoken.find_unique = AsyncMock(
+        return_value=key_in_db
+    )
+    mock_prisma_client.db.litellm_verificationtoken.update = AsyncMock(
+        return_value=updated_key
+    )
+
+    monkeypatch.setattr(
+        "litellm.proxy.proxy_server.prisma_client", mock_prisma_client
+    )
+    monkeypatch.setattr(
+        "litellm.proxy.proxy_server.user_api_key_cache", mock_user_api_key_cache
+    )
+    monkeypatch.setattr(
+        "litellm.proxy.proxy_server.proxy_logging_obj", mock_proxy_logging_obj
+    )
+
+    with patch(
+        "litellm.proxy.management_endpoints.key_management_endpoints._check_proxy_or_team_admin_for_key"
+    ) as mock_check_admin, patch(
+        "litellm.proxy.management_endpoints.key_management_endpoints._delete_cache_key_object"
+    ) as mock_delete_cache:
+        mock_check_admin.return_value = None
+        mock_delete_cache.return_value = None
+
+        user_api_key_dict = UserAPIKeyAuth(
+            user_role=LitellmUserRoles.PROXY_ADMIN,
+            api_key="sk-admin",
+            user_id="admin-user",
+        )
+
+        response = await reset_key_spend_fn(
+            key=hashed_key,
+            data=ResetSpendRequest(reset_to=50.0),
+            user_api_key_dict=user_api_key_dict,
+            litellm_changed_by=None,
+        )
+
+        assert response["spend"] == 50.0
+        mock_prisma_client.db.litellm_verificationtoken.find_unique.assert_called_once_with(
+            where={"token": hashed_key}, include={"litellm_budget_table": True}
+        )
+
+
+@pytest.mark.asyncio
+async def test_validate_key_list_check_proxy_admin():
+    mock_prisma_client = AsyncMock()
+    user_api_key_dict = UserAPIKeyAuth(
+        user_role=LitellmUserRoles.PROXY_ADMIN,
+        user_id="admin-user",
+    )
+
+    result = await validate_key_list_check(
+        user_api_key_dict=user_api_key_dict,
+        user_id=None,
+        team_id=None,
+        organization_id=None,
+        key_alias=None,
+        key_hash=None,
+        prisma_client=mock_prisma_client,
+    )
+
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_validate_key_list_check_team_admin_success():
+    mock_prisma_client = AsyncMock()
+    user_info = LiteLLM_UserTable(
+        user_id="test-user",
+        user_email="test@example.com",
+        teams=["team-1"],
+        organization_memberships=[],
+    )
+
+    mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(
+        return_value=user_info
+    )
+
+    user_api_key_dict = UserAPIKeyAuth(
+        user_role=LitellmUserRoles.INTERNAL_USER,
+        user_id="test-user",
+    )
+
+    result = await validate_key_list_check(
+        user_api_key_dict=user_api_key_dict,
+        user_id=None,
+        team_id="team-1",
+        organization_id=None,
+        key_alias=None,
+        key_hash=None,
+        prisma_client=mock_prisma_client,
+    )
+
+    assert result is not None
+    assert result.user_id == "test-user"
+
+
+@pytest.mark.asyncio
+async def test_validate_key_list_check_team_admin_fail():
+    mock_prisma_client = AsyncMock()
+    user_info = LiteLLM_UserTable(
+        user_id="test-user",
+        user_email="test@example.com",
+        teams=["team-1"],
+        organization_memberships=[],
+    )
+
+    mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(
+        return_value=user_info
+    )
+
+    user_api_key_dict = UserAPIKeyAuth(
+        user_role=LitellmUserRoles.INTERNAL_USER,
+        user_id="test-user",
+    )
+
+    with pytest.raises(ProxyException) as exc_info:
+        await validate_key_list_check(
+            user_api_key_dict=user_api_key_dict,
+            user_id=None,
+            team_id="team-2",
+            organization_id=None,
+            key_alias=None,
+            key_hash=None,
+            prisma_client=mock_prisma_client,
+        )
+
+    assert exc_info.value.code == "403" or exc_info.value.code == 403
+    assert "not authorized to check this team's keys" in exc_info.value.message
+
+
+@pytest.mark.asyncio
+async def test_validate_key_list_check_key_hash_authorized():
+    mock_prisma_client = AsyncMock()
+    user_info = LiteLLM_UserTable(
+        user_id="test-user",
+        user_email="test@example.com",
+        teams=[],
+        organization_memberships=[],
+    )
+
+    key_info = LiteLLM_VerificationToken(
+        token="hashed-key",
+        user_id="test-user",
+    )
+
+    mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(
+        return_value=user_info
+    )
+    mock_prisma_client.db.litellm_verificationtoken.find_unique = AsyncMock(
+        return_value=key_info
+    )
+
+    user_api_key_dict = UserAPIKeyAuth(
+        user_role=LitellmUserRoles.INTERNAL_USER,
+        user_id="test-user",
+    )
+
+    with patch(
+        "litellm.proxy.management_endpoints.key_management_endpoints._can_user_query_key_info"
+    ) as mock_can_query:
+        mock_can_query.return_value = True
+
+        result = await validate_key_list_check(
+            user_api_key_dict=user_api_key_dict,
+            user_id=None,
+            team_id=None,
+            organization_id=None,
+            key_alias=None,
+            key_hash="hashed-key",
+            prisma_client=mock_prisma_client,
+        )
+
+        assert result is not None
+        assert result.user_id == "test-user"
+
+
+@pytest.mark.asyncio
+async def test_validate_key_list_check_key_hash_unauthorized():
+    mock_prisma_client = AsyncMock()
+    user_info = LiteLLM_UserTable(
+        user_id="test-user",
+        user_email="test@example.com",
+        teams=[],
+        organization_memberships=[],
+    )
+
+    key_info = LiteLLM_VerificationToken(
+        token="hashed-key",
+        user_id="other-user",
+    )
+
+    mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(
+        return_value=user_info
+    )
+    mock_prisma_client.db.litellm_verificationtoken.find_unique = AsyncMock(
+        return_value=key_info
+    )
+
+    user_api_key_dict = UserAPIKeyAuth(
+        user_role=LitellmUserRoles.INTERNAL_USER,
+        user_id="test-user",
+    )
+
+    with patch(
+        "litellm.proxy.management_endpoints.key_management_endpoints._can_user_query_key_info"
+    ) as mock_can_query:
+        mock_can_query.return_value = False
+
+        with pytest.raises(HTTPException) as exc_info:
+            await validate_key_list_check(
+                user_api_key_dict=user_api_key_dict,
+                user_id=None,
+                team_id=None,
+                organization_id=None,
+                key_alias=None,
+                key_hash="hashed-key",
+                prisma_client=mock_prisma_client,
+            )
+
+        assert exc_info.value.status_code == 403
+        assert "not allowed to access this key's info" in str(exc_info.value.detail)
+
+
+@pytest.mark.asyncio
+async def test_validate_key_list_check_key_hash_not_found():
+    mock_prisma_client = AsyncMock()
+    user_info = LiteLLM_UserTable(
+        user_id="test-user",
+        user_email="test@example.com",
+        teams=[],
+        organization_memberships=[],
+    )
+
+    mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(
+        return_value=user_info
+    )
+    mock_prisma_client.db.litellm_verificationtoken.find_unique = AsyncMock(
+        side_effect=Exception("Key not found")
+    )
+
+    user_api_key_dict = UserAPIKeyAuth(
+        user_role=LitellmUserRoles.INTERNAL_USER,
+        user_id="test-user",
+    )
+
+    with pytest.raises(ProxyException) as exc_info:
+        await validate_key_list_check(
+            user_api_key_dict=user_api_key_dict,
+            user_id=None,
+            team_id=None,
+            organization_id=None,
+            key_alias=None,
+            key_hash="non-existent-key",
+            prisma_client=mock_prisma_client,
+        )
+
+    assert exc_info.value.code == "403" or exc_info.value.code == 403
+    assert "Key Hash not found" in exc_info.value.message

From 16f0b4942a9acca0073a7c0494b1760f857dfd4a Mon Sep 17 00:00:00 2001
From: yuneng-jiang <yuneng.jiang@gmail.com>
Date: Mon, 2 Feb 2026 16:34:23 -0800
Subject: [PATCH 05/29] team setting disable global guardrail fix

---
 .../src/components/team/team_info.test.tsx    | 878 +++++++++---------
 .../src/components/team/team_info.tsx         |  28 +-
 2 files changed, 465 insertions(+), 441 deletions(-)

diff --git a/ui/litellm-dashboard/src/components/team/team_info.test.tsx b/ui/litellm-dashboard/src/components/team/team_info.test.tsx
index 6d5e55f734..bedc4d195c 100644
--- a/ui/litellm-dashboard/src/components/team/team_info.test.tsx
+++ b/ui/litellm-dashboard/src/components/team/team_info.test.tsx
@@ -1,10 +1,10 @@
 import * as networking from "@/components/networking";
-import { act, fireEvent, screen, waitFor } from "@testing-library/react";
-import { renderWithProviders } from "../../../tests/test-utils";
+import { screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { renderWithProviders } from "../../../tests/test-utils";
 import TeamInfoView from "./team_info";
 
-// Mock the networking module
 vi.mock("@/components/networking", () => ({
   teamInfoCall: vi.fn(),
   teamMemberDeleteCall: vi.fn(),
@@ -12,12 +12,18 @@ vi.mock("@/components/networking", () => ({
   teamMemberUpdateCall: vi.fn(),
   teamUpdateCall: vi.fn(),
   getGuardrailsList: vi.fn(),
+  getPoliciesList: vi.fn(),
+  getPolicyInfoWithGuardrails: vi.fn(),
   fetchMCPAccessGroups: vi.fn(),
   getTeamPermissionsCall: vi.fn(),
   organizationInfoCall: vi.fn(),
 }));
 
-// Mock hooks used by ModelSelect
+vi.mock("@/components/utils/dataUtils", () => ({
+  copyToClipboard: vi.fn().mockResolvedValue(true),
+  formatNumberWithCommas: vi.fn((value: number) => value.toLocaleString()),
+}));
+
 vi.mock("@/app/(dashboard)/hooks/models/useModels", () => ({
   useAllProxyModels: vi.fn(),
 }));
@@ -34,6 +40,59 @@ vi.mock("@/app/(dashboard)/hooks/users/useCurrentUser", () => ({
   useCurrentUser: vi.fn(),
 }));
 
+vi.mock("@/components/team/team_member_view", () => ({
+  default: vi.fn(({ setIsAddMemberModalVisible }) => (
+    <div>
+      <button onClick={() => setIsAddMemberModalVisible(true)}>Add Member</button>
+    </div>
+  )),
+}));
+
+vi.mock("@/components/common_components/user_search_modal", () => ({
+  default: vi.fn(({ isVisible, onCancel, onSubmit }) =>
+    isVisible ? (
+      <div>
+        <button onClick={onCancel}>Cancel</button>
+        <button onClick={() => onSubmit({ user_email: "new@test.com", user_id: "new-user", role: "user" })}>
+          Submit
+        </button>
+      </div>
+    ) : null
+  ),
+}));
+
+vi.mock("@/components/team/EditMembership", () => ({
+  default: vi.fn(({ visible, onCancel, onSubmit }) =>
+    visible ? (
+      <div>
+        <button onClick={onCancel}>Cancel</button>
+        <button onClick={() => onSubmit({ user_email: "edit@test.com", user_id: "edit-user", role: "admin" })}>
+          Submit
+        </button>
+      </div>
+    ) : null
+  ),
+}));
+
+vi.mock("@/components/common_components/DeleteResourceModal", () => ({
+  default: vi.fn(({ isOpen, onCancel, onOk }) =>
+    isOpen ? (
+      <div>
+        <button onClick={onCancel}>Cancel</button>
+        <button onClick={onOk}>Confirm Delete</button>
+      </div>
+    ) : null
+  ),
+}));
+
+vi.mock("@/components/team/member_permissions", () => ({
+  default: vi.fn(() => <div>Member Permissions</div>),
+}));
+
+vi.mock("@/components/team/member_permissions", () => ({
+  default: vi.fn(() => <div>Member Permissions</div>),
+}));
+
 import { useAllProxyModels } from "@/app/(dashboard)/hooks/models/useModels";
 import { useOrganization } from "@/app/(dashboard)/hooks/organizations/useOrganizations";
 import { useTeam } from "@/app/(dashboard)/hooks/teams/useTeams";
@@ -44,9 +103,60 @@ const mockUseTeam = vi.mocked(useTeam);
 const mockUseOrganization = vi.mocked(useOrganization);
 const mockUseCurrentUser = vi.mocked(useCurrentUser);
 
+const createMockTeamData = (overrides = {}) => ({
+  team_id: "123",
+  team_info: {
+    team_alias: "Test Team",
+    team_id: "123",
+    organization_id: null,
+    admins: ["admin@test.com"],
+    members: ["user1@test.com"],
+    members_with_roles: [
+      {
+        user_id: "user1@test.com",
+        user_email: "user1@test.com",
+        role: "member",
+        spend: 0,
+        budget_id: "budget1",
+      },
+    ],
+    metadata: {},
+    tpm_limit: null,
+    rpm_limit: null,
+    max_budget: null,
+    budget_duration: null,
+    models: [],
+    blocked: false,
+    spend: 0,
+    max_parallel_requests: null,
+    budget_reset_at: null,
+    model_id: null,
+    litellm_model_table: null,
+    created_at: "2024-01-01T00:00:00Z",
+    team_member_budget_table: null,
+    guardrails: [],
+    policies: [],
+    object_permission: null,
+    ...overrides,
+  },
+  keys: [],
+  team_memberships: [],
+});
+
 describe("TeamInfoView", () => {
+  const defaultProps = {
+    teamId: "123",
+    onUpdate: vi.fn(),
+    onClose: vi.fn(),
+    accessToken: "test-token",
+    is_team_admin: true,
+    is_proxy_admin: true,
+    userModels: ["gpt-4", "gpt-3.5-turbo"],
+    editTeam: false,
+    premiumUser: false,
+  };
+
   beforeEach(() => {
-    // Set up default mock implementations
     mockUseAllProxyModels.mockReturnValue({
       data: { data: [] },
       isLoading: false,
@@ -63,6 +173,14 @@ describe("TeamInfoView", () => {
       data: { models: [] },
       isLoading: false,
     } as any);
+
+    vi.mocked(networking.getGuardrailsList).mockResolvedValue({ guardrails: [] });
+    vi.mocked(networking.getPoliciesList).mockResolvedValue({ policies: [] });
+    vi.mocked(networking.fetchMCPAccessGroups).mockResolvedValue([]);
+    vi.mocked(networking.getTeamPermissionsCall).mockResolvedValue({
+      all_available_permissions: [],
+      team_member_permissions: [],
+    });
   });
 
   afterEach(() => {
@@ -70,503 +188,409 @@ describe("TeamInfoView", () => {
   });
 
   it("should render", async () => {
-    // Mock the team info response
-    vi.mocked(networking.teamInfoCall).mockResolvedValue({
-      team_id: "123",
-      team_info: {
-        team_alias: "Test Team",
-        team_id: "123",
-        organization_id: null,
-        admins: ["admin@test.com"],
-        members: ["user1@test.com", "user2@test.com"],
-        members_with_roles: [
-          {
-            user_id: "user1@test.com",
-            user_email: "user1@test.com",
-            role: "member",
-            spend: 0,
-            budget_id: "budget1",
-          },
-        ],
-        metadata: {},
-        tpm_limit: null,
-        rpm_limit: null,
-        max_budget: null,
-        budget_duration: null,
-        models: [],
-        blocked: false,
-        spend: 0,
-        max_parallel_requests: null,
-        budget_reset_at: null,
-        model_id: null,
-        litellm_model_table: null,
-        created_at: "2024-01-01T00:00:00Z",
-        team_member_budget_table: null,
-      },
-      keys: [],
-      team_memberships: [],
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(createMockTeamData());
+
+    renderWithProviders(<TeamInfoView {...defaultProps} />);
+
+    await waitFor(() => {
+      const teamNameElements = screen.queryAllByText("Test Team");
+      expect(teamNameElements.length).toBeGreaterThan(0);
     });
-
-    vi.mocked(networking.getGuardrailsList).mockResolvedValue({ guardrails: [] });
-    vi.mocked(networking.fetchMCPAccessGroups).mockResolvedValue([]);
-
-    renderWithProviders(
-      <TeamInfoView
-        teamId="123"
-        onUpdate={() => {}}
-        onClose={() => {}}
-        accessToken="123"
-        is_team_admin={true}
-        is_proxy_admin={true}
-        userModels={[]}
-        editTeam={false}
-        premiumUser={false}
-      />,
-    );
-    await waitFor(
-      () => {
-        expect(screen.queryByText("User ID")).not.toBeNull();
-      },
-      // This is a workaround to fix the flaky test issue. TODO: Remove this once we have a better solution.
-      { timeout: 10000 },
-    );
   });
 
-  it("should not show all-proxy-models option when user has no access to it", async () => {
+  it("should display loading state while fetching team data", () => {
+    vi.mocked(networking.teamInfoCall).mockImplementation(() => new Promise(() => { }));
+
+    renderWithProviders(<TeamInfoView {...defaultProps} />);
+
+    expect(screen.getByText("Loading...")).toBeInTheDocument();
+  });
+
+  it("should display error message when team is not found", async () => {
     vi.mocked(networking.teamInfoCall).mockResolvedValue({
       team_id: "123",
-      team_info: {
-        team_alias: "Test Team",
-        team_id: "123",
-        organization_id: null,
-        admins: ["admin@test.com"],
-        members: ["user1@test.com", "user2@test.com"],
-        members_with_roles: [
-          {
-            user_id: "user1@test.com",
-            user_email: "user1@test.com",
-            role: "member",
-            spend: 0,
-            budget_id: "budget1",
-          },
-        ],
-        metadata: {},
-        tpm_limit: null,
-        rpm_limit: null,
-        max_budget: null,
-        budget_duration: null,
-        models: ["gpt-4"],
-        blocked: false,
-        spend: 0,
-        max_parallel_requests: null,
-        budget_reset_at: null,
-        model_id: null,
-        litellm_model_table: null,
-        created_at: "2024-01-01T00:00:00Z",
-        team_member_budget_table: null,
-      },
+      team_info: null as any,
       keys: [],
       team_memberships: [],
     });
 
-    vi.mocked(networking.getGuardrailsList).mockResolvedValue({ guardrails: [] });
-    vi.mocked(networking.fetchMCPAccessGroups).mockResolvedValue([]);
-
-    renderWithProviders(
-      <TeamInfoView
-        teamId="123"
-        onUpdate={() => {}}
-        onClose={() => {}}
-        accessToken="123"
-        is_team_admin={true}
-        is_proxy_admin={true}
-        userModels={["gpt-4", "gpt-3.5-turbo"]}
-        editTeam={false}
-        premiumUser={false}
-      />,
-    );
+    renderWithProviders(<TeamInfoView {...defaultProps} />);
 
     await waitFor(() => {
-      expect(screen.getAllByText("Test Team")).not.toBeNull();
+      expect(screen.getByText("Team not found")).toBeInTheDocument();
+    });
+  });
+
+  it("should display budget information in overview", async () => {
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(
+      createMockTeamData({
+        max_budget: 1000,
+        spend: 250.5,
+        budget_duration: "30d",
+      })
+    );
+
+    renderWithProviders(<TeamInfoView {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByText("Budget Status")).toBeInTheDocument();
+    });
+  });
+
+  it("should display guardrails in overview when present", async () => {
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(
+      createMockTeamData({
+        guardrails: ["guardrail1", "guardrail2"],
+      })
+    );
+
+    renderWithProviders(<TeamInfoView {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByText("Guardrails")).toBeInTheDocument();
+    });
+  });
+
+  it("should display policies in overview when present", async () => {
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(
+      createMockTeamData({
+        policies: ["policy1"],
+      })
+    );
+    vi.mocked(networking.getPolicyInfoWithGuardrails).mockResolvedValue({
+      resolved_guardrails: ["guardrail1"],
+    });
+
+    renderWithProviders(<TeamInfoView {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByText("Policies")).toBeInTheDocument();
+    });
+  });
+
+  it("should show members tab when user can edit team", async () => {
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(createMockTeamData());
+
+    renderWithProviders(<TeamInfoView {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByRole("tab", { name: "Members" })).toBeInTheDocument();
+    });
+  });
+
+  it("should not show members tab when user cannot edit team", async () => {
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(createMockTeamData());
+
+    renderWithProviders(<TeamInfoView {...defaultProps} is_team_admin={false} is_proxy_admin={false} />);
+
+    await waitFor(() => {
+      const teamNameElements = screen.queryAllByText("Test Team");
+      expect(teamNameElements.length).toBeGreaterThan(0);
+    });
+
+    expect(screen.queryByRole("tab", { name: "Members" })).not.toBeInTheDocument();
+  });
+
+  it("should show settings tab when user can edit team", async () => {
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(createMockTeamData());
+
+    renderWithProviders(<TeamInfoView {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByRole("tab", { name: "Settings" })).toBeInTheDocument();
+    });
+  });
+
+  it("should navigate to settings tab when clicked", async () => {
+    const user = userEvent.setup();
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(createMockTeamData());
+
+    renderWithProviders(<TeamInfoView {...defaultProps} />);
+
+    await waitFor(() => {
+      const teamNameElements = screen.queryAllByText("Test Team");
+      expect(teamNameElements.length).toBeGreaterThan(0);
     });
 
     const settingsTab = screen.getByRole("tab", { name: "Settings" });
-    act(() => {
-      fireEvent.click(settingsTab);
-    });
+    await user.click(settingsTab);
 
     await waitFor(() => {
       expect(screen.getByText("Team Settings")).toBeInTheDocument();
     });
+  });
 
-    const editButton = screen.getByRole("button", { name: "Edit Settings" });
-    act(() => {
-      fireEvent.click(editButton);
-    });
+  it("should open edit mode when edit button is clicked", async () => {
+    const user = userEvent.setup();
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(createMockTeamData());
+
+    renderWithProviders(<TeamInfoView {...defaultProps} />);
 
     await waitFor(() => {
-      expect(screen.getByTestId("models-select")).toBeInTheDocument();
-    });
-
-    const allProxyModelsOption = screen.queryByText("All Proxy Models");
-    expect(allProxyModelsOption).not.toBeInTheDocument();
-  }, 10000); // This is a workaround to fix the flaky test issue. TODO: Remove this once we have a better solution.
-
-  it("should only show organization models in dropdown when team is in organization with limited models", async () => {
-    const organizationId = "org-123";
-    const organizationModels = ["gpt-4", "claude-3-opus"];
-    const userModels = ["gpt-4", "gpt-3.5-turbo", "claude-3-opus", "claude-2"];
-
-    // Mock all proxy models - should include all user models
-    const allProxyModels = userModels.map((id) => ({
-      id,
-      object: "model",
-      created: 1234567890,
-      owned_by: "openai",
-    }));
-
-    mockUseAllProxyModels.mockReturnValue({
-      data: { data: allProxyModels },
-      isLoading: false,
-    } as any);
-
-    mockUseCurrentUser.mockReturnValue({
-      data: { models: userModels },
-      isLoading: false,
-    } as any);
-
-    const organizationData = {
-      organization_id: organizationId,
-      organization_name: "Test Organization",
-      spend: 0,
-      max_budget: null,
-      models: organizationModels,
-      tpm_limit: null,
-      rpm_limit: null,
-      members: null,
-    };
-
-    mockUseOrganization.mockReturnValue({
-      data: organizationData,
-      isLoading: false,
-    } as any);
-
-    vi.mocked(networking.teamInfoCall).mockResolvedValue({
-      team_id: "123",
-      team_info: {
-        team_alias: "Test Team",
-        team_id: "123",
-        organization_id: organizationId,
-        admins: ["admin@test.com"],
-        members: ["user1@test.com"],
-        members_with_roles: [
-          {
-            user_id: "user1@test.com",
-            user_email: "user1@test.com",
-            role: "member",
-            spend: 0,
-            budget_id: "budget1",
-          },
-        ],
-        metadata: {},
-        tpm_limit: null,
-        rpm_limit: null,
-        max_budget: null,
-        budget_duration: null,
-        models: ["gpt-4"],
-        blocked: false,
-        spend: 0,
-        max_parallel_requests: null,
-        budget_reset_at: null,
-        model_id: null,
-        litellm_model_table: null,
-        created_at: "2024-01-01T00:00:00Z",
-        team_member_budget_table: null,
-      },
-      keys: [],
-      team_memberships: [],
-    });
-
-    vi.mocked(networking.organizationInfoCall).mockResolvedValue(organizationData);
-
-    vi.mocked(networking.getGuardrailsList).mockResolvedValue({ guardrails: [] });
-    vi.mocked(networking.fetchMCPAccessGroups).mockResolvedValue([]);
-
-    renderWithProviders(
-      <TeamInfoView
-        teamId="123"
-        onUpdate={() => {}}
-        onClose={() => {}}
-        accessToken="123"
-        is_team_admin={true}
-        is_proxy_admin={true}
-        userModels={userModels}
-        editTeam={false}
-        premiumUser={false}
-      />,
-    );
-
-    await waitFor(() => {
-      expect(screen.getAllByText("Test Team")).not.toBeNull();
+      const teamNameElements = screen.queryAllByText("Test Team");
+      expect(teamNameElements.length).toBeGreaterThan(0);
     });
 
     const settingsTab = screen.getByRole("tab", { name: "Settings" });
-    act(() => {
-      fireEvent.click(settingsTab);
-    });
+    await user.click(settingsTab);
 
     await waitFor(() => {
-      expect(screen.getByText("Team Settings")).toBeInTheDocument();
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
     });
 
     const editButton = screen.getByRole("button", { name: "Edit Settings" });
-    act(() => {
-      fireEvent.click(editButton);
-    });
+    await user.click(editButton);
 
     await waitFor(() => {
-      expect(screen.getByTestId("models-select")).toBeInTheDocument();
+      expect(screen.getByLabelText("Team Name")).toBeInTheDocument();
+    });
+  });
+
+  it("should close edit mode when cancel button is clicked", async () => {
+    const user = userEvent.setup();
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(createMockTeamData());
+
+    renderWithProviders(<TeamInfoView {...defaultProps} />);
+
+    await waitFor(() => {
+      const teamNameElements = screen.queryAllByText("Test Team");
+      expect(teamNameElements.length).toBeGreaterThan(0);
     });
 
-    // Find the Ant Design Select selector element to open the dropdown
-    // The data-testid is on the Select component, we need to find the selector inside it
-    const modelsSelectElement = screen.getByTestId("models-select");
-    const selectSelector = modelsSelectElement.querySelector(".ant-select-selector");
-    expect(selectSelector).toBeTruthy();
+    const settingsTab = screen.getByRole("tab", { name: "Settings" });
+    await user.click(settingsTab);
 
-    // Open the dropdown by clicking on the selector
-    act(() => {
-      fireEvent.mouseDown(selectSelector!);
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
     });
 
-    // Wait for dropdown to open - Ant Design renders options in a portal
-    await waitFor(
-      () => {
-        const dropdownOptions = document.querySelectorAll(".ant-select-item-option");
-        expect(dropdownOptions.length).toBeGreaterThan(0);
-      },
-      { timeout: 5000 },
-    );
+    const editButton = screen.getByRole("button", { name: "Edit Settings" });
+    await user.click(editButton);
 
-    const dropdownOptions = document.querySelectorAll(".ant-select-item-option");
-    const optionTexts = Array.from(dropdownOptions).map((option) => option.textContent?.trim() || "");
-
-    organizationModels.forEach((model) => {
-      expect(optionTexts).toContain(model);
+    await waitFor(() => {
+      expect(screen.getByLabelText("Team Name")).toBeInTheDocument();
     });
 
-    const modelsNotInOrganization = userModels.filter((m) => !organizationModels.includes(m));
-    modelsNotInOrganization.forEach((model) => {
-      expect(optionTexts).not.toContain(model);
+    const cancelButton = screen.getByRole("button", { name: "Cancel" });
+    await user.click(cancelButton);
+
+    await waitFor(() => {
+      expect(screen.queryByLabelText("Team Name")).not.toBeInTheDocument();
     });
-  }, 10000);
+  });
+
+  it("should call onClose when back button is clicked", async () => {
+    const user = userEvent.setup();
+    const onClose = vi.fn();
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(createMockTeamData());
+
+    renderWithProviders(<TeamInfoView {...defaultProps} onClose={onClose} />);
+
+    await waitFor(() => {
+      const teamNameElements = screen.queryAllByText("Test Team");
+      expect(teamNameElements.length).toBeGreaterThan(0);
+    });
+
+    const backButton = screen.getByRole("button", { name: /back to teams/i });
+    await user.click(backButton);
+
+    expect(onClose).toHaveBeenCalled();
+  });
+
+  it("should copy team ID to clipboard when copy button is clicked", async () => {
+    const user = userEvent.setup();
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(createMockTeamData());
+
+    renderWithProviders(<TeamInfoView {...defaultProps} />);
+
+    await waitFor(() => {
+      const teamNameElements = screen.queryAllByText("Test Team");
+      expect(teamNameElements.length).toBeGreaterThan(0);
+    });
+
+    const copyButtons = screen.getAllByRole("button");
+    const copyButton = copyButtons.find((btn) => btn.querySelector("svg"));
+    expect(copyButton).toBeTruthy();
+
+    if (copyButton) {
+      await user.click(copyButton);
+    }
+  });
 
   it("should disable secret manager settings for non-premium users", async () => {
-    const teamResponse = {
-      team_id: "123",
-      team_info: {
-        team_alias: "Test Team",
-        team_id: "123",
-        organization_id: null,
-        admins: ["admin@test.com"],
-        members: [],
-        members_with_roles: [],
+    const user = userEvent.setup();
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(
+      createMockTeamData({
         metadata: {
           secret_manager_settings: { provider: "aws", secret_id: "abc" },
         },
-        tpm_limit: null,
-        rpm_limit: null,
-        max_budget: null,
-        budget_duration: null,
-        models: ["gpt-4"],
-        blocked: false,
-        spend: 0,
-        max_parallel_requests: null,
-        budget_reset_at: null,
-        model_id: null,
-        litellm_model_table: null,
-        created_at: "2024-01-01T00:00:00Z",
-        team_member_budget_table: null,
-      },
-      keys: [],
-      team_memberships: [],
-    };
-
-    vi.mocked(networking.teamInfoCall).mockResolvedValue(teamResponse as any);
-    vi.mocked(networking.getGuardrailsList).mockResolvedValue({ guardrails: [] });
-    vi.mocked(networking.fetchMCPAccessGroups).mockResolvedValue([]);
-
-    renderWithProviders(
-      <TeamInfoView
-        teamId="123"
-        onUpdate={() => {}}
-        onClose={() => {}}
-        accessToken="123"
-        is_team_admin={true}
-        is_proxy_admin={true}
-        userModels={["gpt-4"]}
-        editTeam={false}
-        premiumUser={false}
-      />,
+      })
     );
 
-    const settingsTab = await screen.findByRole("tab", { name: "Settings" });
-    act(() => fireEvent.click(settingsTab));
+    renderWithProviders(<TeamInfoView {...defaultProps} premiumUser={false} />);
 
-    const editButton = await screen.findByRole("button", { name: "Edit Settings" });
-    act(() => fireEvent.click(editButton));
+    await waitFor(() => {
+      const teamNameElements = screen.queryAllByText("Test Team");
+      expect(teamNameElements.length).toBeGreaterThan(0);
+    });
+
+    const settingsTab = screen.getByRole("tab", { name: "Settings" });
+    await user.click(settingsTab);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
+    });
+
+    const editButton = screen.getByRole("button", { name: "Edit Settings" });
+    await user.click(editButton);
 
     const secretField = await screen.findByPlaceholderText(
-      '{"namespace": "admin", "mount": "secret", "path_prefix": "litellm"}',
+      '{"namespace": "admin", "mount": "secret", "path_prefix": "litellm"}'
     );
     expect(secretField).toBeDisabled();
-    expect(secretField).toHaveValue(JSON.stringify(teamResponse.team_info.metadata.secret_manager_settings, null, 2));
-  }, 10000);
+  });
 
-  it("should allow premium users to update secret manager settings", async () => {
-    const teamResponse = {
-      team_id: "123",
-      team_info: {
-        team_alias: "Test Team",
-        team_id: "123",
-        organization_id: null,
-        admins: ["admin@test.com"],
-        members: [],
-        members_with_roles: [],
+  it("should allow premium users to edit secret manager settings", async () => {
+    const user = userEvent.setup();
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(
+      createMockTeamData({
         metadata: {
           secret_manager_settings: { provider: "aws", secret_id: "abc" },
         },
-        tpm_limit: null,
-        rpm_limit: null,
-        max_budget: null,
-        budget_duration: null,
-        models: ["gpt-4"],
-        blocked: false,
-        spend: 0,
-        max_parallel_requests: null,
-        budget_reset_at: null,
-        model_id: null,
-        litellm_model_table: null,
-        created_at: "2024-01-01T00:00:00Z",
-        team_member_budget_table: null,
-      },
-      keys: [],
-      team_memberships: [],
-    };
-
-    vi.mocked(networking.teamInfoCall).mockResolvedValue(teamResponse as any);
-    vi.mocked(networking.getGuardrailsList).mockResolvedValue({ guardrails: [] });
-    vi.mocked(networking.fetchMCPAccessGroups).mockResolvedValue([]);
-    vi.mocked(networking.teamUpdateCall).mockResolvedValue({ data: teamResponse.team_info, team_id: "123" } as any);
-
-    renderWithProviders(
-      <TeamInfoView
-        teamId="123"
-        onUpdate={() => {}}
-        onClose={() => {}}
-        accessToken="123"
-        is_team_admin={true}
-        is_proxy_admin={true}
-        userModels={["gpt-4"]}
-        editTeam={false}
-        premiumUser={true}
-      />,
+      })
     );
+    vi.mocked(networking.teamUpdateCall).mockResolvedValue({ data: {}, team_id: "123" } as any);
 
-    const settingsTab = await screen.findByRole("tab", { name: "Settings" });
-    act(() => fireEvent.click(settingsTab));
+    renderWithProviders(<TeamInfoView {...defaultProps} premiumUser={true} />);
 
-    const editButton = await screen.findByRole("button", { name: "Edit Settings" });
-    act(() => fireEvent.click(editButton));
+    await waitFor(() => {
+      const teamNameElements = screen.queryAllByText("Test Team");
+      expect(teamNameElements.length).toBeGreaterThan(0);
+    });
+
+    const settingsTab = screen.getByRole("tab", { name: "Settings" });
+    await user.click(settingsTab);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
+    });
+
+    const editButton = screen.getByRole("button", { name: "Edit Settings" });
+    await user.click(editButton);
 
     const secretField = await screen.findByPlaceholderText(
-      '{"namespace": "admin", "mount": "secret", "path_prefix": "litellm"}',
+      '{"namespace": "admin", "mount": "secret", "path_prefix": "litellm"}'
     );
     expect(secretField).not.toBeDisabled();
+  });
 
-    act(() => {
-      fireEvent.change(secretField, { target: { value: '{"provider":"azure","secret_id":"xyz"}' } });
-    });
+  it("should add team member when form is submitted", async () => {
+    const user = userEvent.setup();
+    const onUpdate = vi.fn();
+    const teamData = createMockTeamData();
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(teamData);
+    vi.mocked(networking.teamMemberAddCall).mockResolvedValue({} as any);
 
-    const saveButton = await screen.findByRole("button", { name: "Save Changes" });
-    act(() => fireEvent.click(saveButton));
+    renderWithProviders(<TeamInfoView {...defaultProps} onUpdate={onUpdate} />);
 
     await waitFor(() => {
-      expect(networking.teamUpdateCall).toHaveBeenCalled();
+      const teamNameElements = screen.queryAllByText("Test Team");
+      expect(teamNameElements.length).toBeGreaterThan(0);
     });
 
-    const payload = vi.mocked(networking.teamUpdateCall).mock.calls[0][1];
-    expect(payload.metadata.secret_manager_settings).toEqual({ provider: "azure", secret_id: "xyz" });
-  }, 10000);
+    const membersTab = screen.getByRole("tab", { name: "Members" });
+    await user.click(membersTab);
 
-  it("should include vector stores in object_permission when updating team", async () => {
-    const teamResponse = {
-      team_id: "123",
-      team_info: {
-        team_alias: "Test Team",
-        team_id: "123",
-        organization_id: null,
-        admins: ["admin@test.com"],
-        members: [],
-        members_with_roles: [],
-        metadata: {},
-        tpm_limit: null,
-        rpm_limit: null,
-        max_budget: null,
-        budget_duration: null,
-        models: ["gpt-4"],
-        blocked: false,
-        spend: 0,
-        max_parallel_requests: null,
-        budget_reset_at: null,
-        model_id: null,
-        litellm_model_table: null,
-        created_at: "2024-01-01T00:00:00Z",
-        team_member_budget_table: null,
-        object_permission: {
-          vector_stores: ["store1", "store2"],
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Add Member" })).toBeInTheDocument();
+    });
+
+    const addButton = screen.getByRole("button", { name: "Add Member" });
+    await user.click(addButton);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Submit" })).toBeInTheDocument();
+    });
+
+    const submitButton = screen.getByRole("button", { name: "Submit" });
+    await user.click(submitButton);
+
+    await waitFor(() => {
+      expect(networking.teamMemberAddCall).toHaveBeenCalled();
+    });
+  });
+
+  it("should open delete member modal when delete is triggered", async () => {
+    const user = userEvent.setup();
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(createMockTeamData());
+    vi.mocked(networking.teamMemberDeleteCall).mockResolvedValue({} as any);
+
+    renderWithProviders(<TeamInfoView {...defaultProps} />);
+
+    await waitFor(() => {
+      const teamNameElements = screen.queryAllByText("Test Team");
+      expect(teamNameElements.length).toBeGreaterThan(0);
+    });
+
+    const membersTab = screen.getByRole("tab", { name: "Members" });
+    await user.click(membersTab);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Confirm Delete" })).toBeInTheDocument();
+    });
+  });
+
+  it("should display team member budget information when present", async () => {
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(
+      createMockTeamData({
+        team_member_budget_table: {
+          max_budget: 500,
+          budget_duration: "30d",
+          tpm_limit: 5000,
+          rpm_limit: 50,
         },
-      },
-      keys: [],
-      team_memberships: [],
-    };
-
-    vi.mocked(networking.teamInfoCall).mockResolvedValue(teamResponse as any);
-    vi.mocked(networking.getGuardrailsList).mockResolvedValue({ guardrails: [] });
-    vi.mocked(networking.fetchMCPAccessGroups).mockResolvedValue([]);
-    vi.mocked(networking.teamUpdateCall).mockResolvedValue({ data: teamResponse.team_info, team_id: "123" } as any);
-
-    renderWithProviders(
-      <TeamInfoView
-        teamId="123"
-        onUpdate={() => {}}
-        onClose={() => {}}
-        accessToken="123"
-        is_team_admin={true}
-        is_proxy_admin={true}
-        userModels={["gpt-4"]}
-        editTeam={false}
-        premiumUser={true}
-      />,
+      })
     );
 
-    const settingsTab = await screen.findByRole("tab", { name: "Settings" });
-    act(() => fireEvent.click(settingsTab));
-
-    const editButton = await screen.findByRole("button", { name: "Edit Settings" });
-    act(() => fireEvent.click(editButton));
-
-    // Verify that Vector Stores field is present
-    expect(screen.getByLabelText("Vector Stores")).toBeInTheDocument();
-
-    const saveButton = await screen.findByRole("button", { name: "Save Changes" });
-    act(() => fireEvent.click(saveButton));
+    renderWithProviders(<TeamInfoView {...defaultProps} />);
 
     await waitFor(() => {
-      expect(networking.teamUpdateCall).toHaveBeenCalled();
+      expect(screen.getByText("Budget Status")).toBeInTheDocument();
+    });
+  });
+
+  it("should display virtual keys information", async () => {
+    vi.mocked(networking.teamInfoCall).mockResolvedValue({
+      ...createMockTeamData(),
+      keys: [
+        { user_id: "user1", token: "key1" },
+        { token: "key2" },
+      ],
     });
 
-    const payload = vi.mocked(networking.teamUpdateCall).mock.calls[0][1];
-    expect(payload.object_permission.vector_stores).toEqual(["store1", "store2"]);
-  }, 10000);
+    renderWithProviders(<TeamInfoView {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByText("Virtual Keys")).toBeInTheDocument();
+    });
+  });
+
+  it("should display object permissions when present", async () => {
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(
+      createMockTeamData({
+        object_permission: {
+          object_permission_id: "perm-1",
+          mcp_servers: ["server1"],
+          vector_stores: ["store1"],
+        },
+      })
+    );
+
+    renderWithProviders(<TeamInfoView {...defaultProps} />);
+
+    await waitFor(() => {
+      const teamNameElements = screen.queryAllByText("Test Team");
+      expect(teamNameElements.length).toBeGreaterThan(0);
+    });
+  });
 });
diff --git a/ui/litellm-dashboard/src/components/team/team_info.tsx b/ui/litellm-dashboard/src/components/team/team_info.tsx
index 193d056fdd..34ff903c86 100644
--- a/ui/litellm-dashboard/src/components/team/team_info.tsx
+++ b/ui/litellm-dashboard/src/components/team/team_info.tsx
@@ -462,6 +462,7 @@ const TeamInfoView: React.FC<TeamInfoProps> = ({
           ...parsedMetadata,
           guardrails: values.guardrails || [],
           logging: values.logging_settings || [],
+          disable_global_guardrails: values.disable_global_guardrails || false,
           ...(secretManagerSettings !== undefined ? { secret_manager_settings: secretManagerSettings } : {}),
         },
         policies: values.policies || [],
@@ -572,11 +573,10 @@ const TeamInfoView: React.FC<TeamInfoProps> = ({
               size="small"
               icon={copiedStates["team-id"] ? <CheckIcon size={12} /> : <CopyIcon size={12} />}
               onClick={() => copyToClipboard(info.team_id, "team-id")}
-              className={`left-2 z-10 transition-all duration-200 ${
-                copiedStates["team-id"]
-                  ? "text-green-600 bg-green-50 border-green-200"
-                  : "text-gray-500 hover:text-gray-700 hover:bg-gray-100"
-              }`}
+              className={`left-2 z-10 transition-all duration-200 ${copiedStates["team-id"]
+                ? "text-green-600 bg-green-50 border-green-200"
+                : "text-gray-500 hover:text-gray-700 hover:bg-gray-100"
+                }`}
             />
           </div>
         </div>
@@ -588,10 +588,10 @@ const TeamInfoView: React.FC<TeamInfoProps> = ({
             <Tab key="overview">Overview</Tab>,
             ...(canEditTeam
               ? [
-                  <Tab key="members">Members</Tab>,
-                  <Tab key="member-permissions">Member Permissions</Tab>,
-                  <Tab key="settings">Settings</Tab>,
-                ]
+                <Tab key="members">Members</Tab>,
+                <Tab key="member-permissions">Member Permissions</Tab>,
+                <Tab key="settings">Settings</Tab>,
+              ]
               : []),
           ]}
         </TabList>
@@ -764,10 +764,10 @@ const TeamInfoView: React.FC<TeamInfoProps> = ({
                     disable_global_guardrails: info.metadata?.disable_global_guardrails || false,
                     metadata: info.metadata
                       ? JSON.stringify(
-                          (({ logging, secret_manager_settings, ...rest }) => rest)(info.metadata),
-                          null,
-                          2,
-                        )
+                        (({ logging, secret_manager_settings, ...rest }) => rest)(info.metadata),
+                        null,
+                        2,
+                      )
                       : "",
                     logging_settings: info.metadata?.logging || [],
                     secret_manager_settings: info.metadata?.secret_manager_settings
@@ -905,7 +905,7 @@ const TeamInfoView: React.FC<TeamInfoProps> = ({
                   <Form.Item
                     label={
                       <span>
-                        Disable Global Guardrails{" "}
+                        Disable Global Guardrails
                         <Tooltip title="When enabled, this team will bypass any guardrails configured to run on every request (global guardrails)">
                           <InfoCircleOutlined style={{ marginLeft: "4px" }} />
                         </Tooltip>

From 2645d258cbcb6e0c2cc7cf5db4d5c6c9ee56838a Mon Sep 17 00:00:00 2001
From: yuneng-jiang <yuneng.jiang@gmail.com>
Date: Mon, 2 Feb 2026 16:37:40 -0800
Subject: [PATCH 06/29] fixing tests

---
 .../src/components/team/team_info.test.tsx    | 20 -------------------
 1 file changed, 20 deletions(-)

diff --git a/ui/litellm-dashboard/src/components/team/team_info.test.tsx b/ui/litellm-dashboard/src/components/team/team_info.test.tsx
index bedc4d195c..6c68188e37 100644
--- a/ui/litellm-dashboard/src/components/team/team_info.test.tsx
+++ b/ui/litellm-dashboard/src/components/team/team_info.test.tsx
@@ -520,26 +520,6 @@ describe("TeamInfoView", () => {
     });
   });
 
-  it("should open delete member modal when delete is triggered", async () => {
-    const user = userEvent.setup();
-    vi.mocked(networking.teamInfoCall).mockResolvedValue(createMockTeamData());
-    vi.mocked(networking.teamMemberDeleteCall).mockResolvedValue({} as any);
-
-    renderWithProviders(<TeamInfoView {...defaultProps} />);
-
-    await waitFor(() => {
-      const teamNameElements = screen.queryAllByText("Test Team");
-      expect(teamNameElements.length).toBeGreaterThan(0);
-    });
-
-    const membersTab = screen.getByRole("tab", { name: "Members" });
-    await user.click(membersTab);
-
-    await waitFor(() => {
-      expect(screen.getByRole("button", { name: "Confirm Delete" })).toBeInTheDocument();
-    });
-  });
-
   it("should display team member budget information when present", async () => {
     vi.mocked(networking.teamInfoCall).mockResolvedValue(
       createMockTeamData({

From 32b1ff7d1128a450f2ae35bc4315dccba36e67a9 Mon Sep 17 00:00:00 2001
From: yuneng-jiang <yuneng.jiang@gmail.com>
Date: Mon, 2 Feb 2026 17:25:16 -0800
Subject: [PATCH 07/29] option to hide community engagement buttons

---
 .../CommunityEngagementButtons.test.tsx       | 50 +++++++++++++++++++
 .../CommunityEngagementButtons.tsx            | 36 +++++++++++++
 .../src/components/navbar.test.tsx            | 39 ++++++---------
 .../src/components/navbar.tsx                 | 24 ++-------
 4 files changed, 103 insertions(+), 46 deletions(-)
 create mode 100644 ui/litellm-dashboard/src/components/Navbar/CommunityEngagementButtons/CommunityEngagementButtons.test.tsx
 create mode 100644 ui/litellm-dashboard/src/components/Navbar/CommunityEngagementButtons/CommunityEngagementButtons.tsx

diff --git a/ui/litellm-dashboard/src/components/Navbar/CommunityEngagementButtons/CommunityEngagementButtons.test.tsx b/ui/litellm-dashboard/src/components/Navbar/CommunityEngagementButtons/CommunityEngagementButtons.test.tsx
new file mode 100644
index 0000000000..6994def858
--- /dev/null
+++ b/ui/litellm-dashboard/src/components/Navbar/CommunityEngagementButtons/CommunityEngagementButtons.test.tsx
@@ -0,0 +1,50 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { renderWithProviders, screen } from "../../../../tests/test-utils";
+import { CommunityEngagementButtons } from "./CommunityEngagementButtons";
+
+let mockUseDisableShowPromptsImpl = () => false;
+
+vi.mock("@/app/(dashboard)/hooks/useDisableShowPrompts", () => ({
+  useDisableShowPrompts: () => mockUseDisableShowPromptsImpl(),
+}));
+
+describe("CommunityEngagementButtons", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockUseDisableShowPromptsImpl = () => false;
+  });
+
+  it("should render", () => {
+    renderWithProviders(<CommunityEngagementButtons />);
+    expect(screen.getByRole("link", { name: /join slack/i })).toBeInTheDocument();
+  });
+
+  it("should render Join Slack button with correct link", () => {
+    renderWithProviders(<CommunityEngagementButtons />);
+
+    const joinSlackLink = screen.getByRole("link", { name: /join slack/i });
+    expect(joinSlackLink).toBeInTheDocument();
+    expect(joinSlackLink).toHaveAttribute("href", "https://www.litellm.ai/support");
+    expect(joinSlackLink).toHaveAttribute("target", "_blank");
+    expect(joinSlackLink).toHaveAttribute("rel", "noopener noreferrer");
+  });
+
+  it("should render Star us on GitHub button with correct link", () => {
+    renderWithProviders(<CommunityEngagementButtons />);
+
+    const starOnGithubLink = screen.getByRole("link", { name: /star us on github/i });
+    expect(starOnGithubLink).toBeInTheDocument();
+    expect(starOnGithubLink).toHaveAttribute("href", "https://github.com/BerriAI/litellm");
+    expect(starOnGithubLink).toHaveAttribute("target", "_blank");
+    expect(starOnGithubLink).toHaveAttribute("rel", "noopener noreferrer");
+  });
+
+  it("should not render buttons when prompts are disabled", () => {
+    mockUseDisableShowPromptsImpl = () => true;
+
+    renderWithProviders(<CommunityEngagementButtons />);
+
+    expect(screen.queryByRole("link", { name: /join slack/i })).not.toBeInTheDocument();
+    expect(screen.queryByRole("link", { name: /star us on github/i })).not.toBeInTheDocument();
+  });
+});
diff --git a/ui/litellm-dashboard/src/components/Navbar/CommunityEngagementButtons/CommunityEngagementButtons.tsx b/ui/litellm-dashboard/src/components/Navbar/CommunityEngagementButtons/CommunityEngagementButtons.tsx
new file mode 100644
index 0000000000..649bcc0b58
--- /dev/null
+++ b/ui/litellm-dashboard/src/components/Navbar/CommunityEngagementButtons/CommunityEngagementButtons.tsx
@@ -0,0 +1,36 @@
+import { useDisableShowPrompts } from "@/app/(dashboard)/hooks/useDisableShowPrompts";
+import { GithubOutlined, SlackOutlined } from "@ant-design/icons";
+import { Button } from "antd";
+import React from "react";
+
+export const CommunityEngagementButtons: React.FC = () => {
+  const disableShowPrompts = useDisableShowPrompts();
+
+  // Hide buttons if prompts are disabled
+  if (disableShowPrompts) {
+    return null;
+  }
+
+  return (
+    <>
+      <Button
+        href="https://www.litellm.ai/support"
+        target="_blank"
+        rel="noopener noreferrer"
+        icon={<SlackOutlined />}
+        className="shadow-md shadow-indigo-500/20 hover:shadow-indigo-500/50 transition-shadow"
+      >
+        Join Slack
+      </Button>
+      <Button
+        href="https://github.com/BerriAI/litellm"
+        target="_blank"
+        rel="noopener noreferrer"
+        className="shadow-md shadow-indigo-500/20 hover:shadow-indigo-500/50 transition-shadow"
+        icon={<GithubOutlined />}
+      >
+        Star us on GitHub
+      </Button>
+    </>
+  );
+};
diff --git a/ui/litellm-dashboard/src/components/navbar.test.tsx b/ui/litellm-dashboard/src/components/navbar.test.tsx
index a2996f7058..125187e234 100644
--- a/ui/litellm-dashboard/src/components/navbar.test.tsx
+++ b/ui/litellm-dashboard/src/components/navbar.test.tsx
@@ -12,11 +12,24 @@ vi.mock("@/utils/proxyUtils", () => ({
   fetchProxySettings: vi.fn(),
 }));
 
+// Mock CommunityEngagementButtons component
+vi.mock("./Navbar/CommunityEngagementButtons/CommunityEngagementButtons", () => ({
+  CommunityEngagementButtons: () => (
+    <div data-testid="community-engagement-buttons">
+      <a href="https://www.litellm.ai/support" target="_blank" rel="noopener noreferrer">
+        Join Slack
+      </a>
+      <a href="https://github.com/BerriAI/litellm" target="_blank" rel="noopener noreferrer">
+        Star us on GitHub
+      </a>
+    </div>
+  ),
+}));
+
 // Create mock functions that can be controlled in tests
 let mockUseThemeImpl = () => ({ logoUrl: null as string | null });
 let mockUseHealthReadinessImpl = () => ({ data: null as any });
 let mockGetLocalStorageItemImpl = (key: string) => null as string | null;
-let mockUseDisableShowPromptsImpl = () => false;
 let mockUseAuthorizedImpl = () => ({
   userId: "test-user",
   userEmail: "test@example.com",
@@ -32,10 +45,6 @@ vi.mock("@/app/(dashboard)/hooks/healthReadiness/useHealthReadiness", () => ({
   useHealthReadiness: () => mockUseHealthReadinessImpl(),
 }));
 
-vi.mock("@/app/(dashboard)/hooks/useDisableShowPrompts", () => ({
-  useDisableShowPrompts: () => mockUseDisableShowPromptsImpl(),
-}));
-
 vi.mock("@/app/(dashboard)/hooks/useAuthorized", () => ({
   default: () => mockUseAuthorizedImpl(),
 }));
@@ -79,26 +88,6 @@ describe("Navbar", () => {
     expect(screen.getByText("User")).toBeInTheDocument();
   });
 
-  it("should render Join Slack button with correct link", () => {
-    renderWithProviders(<Navbar {...defaultProps} />);
-
-    const joinSlackLink = screen.getByRole("link", { name: /join slack/i });
-    expect(joinSlackLink).toBeInTheDocument();
-    expect(joinSlackLink).toHaveAttribute("href", "https://www.litellm.ai/support");
-    expect(joinSlackLink).toHaveAttribute("target", "_blank");
-    expect(joinSlackLink).toHaveAttribute("rel", "noopener noreferrer");
-  });
-
-  it("should render Star us on GitHub button with correct link", () => {
-    renderWithProviders(<Navbar {...defaultProps} />);
-
-    const starOnGithubLink = screen.getByRole("link", { name: /star us on github/i });
-    expect(starOnGithubLink).toBeInTheDocument();
-    expect(starOnGithubLink).toHaveAttribute("href", "https://github.com/BerriAI/litellm");
-    expect(starOnGithubLink).toHaveAttribute("target", "_blank");
-    expect(starOnGithubLink).toHaveAttribute("rel", "noopener noreferrer");
-  });
-
   it("should display user information in dropdown", async () => {
     const user = userEvent.setup();
     renderWithProviders(<Navbar {...defaultProps} />);
diff --git a/ui/litellm-dashboard/src/components/navbar.tsx b/ui/litellm-dashboard/src/components/navbar.tsx
index 3649ca7623..2ffa0632f2 100644
--- a/ui/litellm-dashboard/src/components/navbar.tsx
+++ b/ui/litellm-dashboard/src/components/navbar.tsx
@@ -4,16 +4,15 @@ import { useTheme } from "@/contexts/ThemeContext";
 import { clearTokenCookies } from "@/utils/cookieUtils";
 import { fetchProxySettings } from "@/utils/proxyUtils";
 import {
-  GithubOutlined,
   MenuFoldOutlined,
   MenuUnfoldOutlined,
   MoonOutlined,
-  SlackOutlined,
   SunOutlined,
 } from "@ant-design/icons";
-import { Button, Switch, Tag } from "antd";
+import { Switch, Tag } from "antd";
 import Link from "next/link";
 import React, { useEffect, useState } from "react";
+import { CommunityEngagementButtons } from "./Navbar/CommunityEngagementButtons/CommunityEngagementButtons";
 import UserDropdown from "./Navbar/UserDropdown/UserDropdown";
 
 interface NavbarProps {
@@ -129,24 +128,7 @@ const Navbar: React.FC<NavbarProps> = ({
           </div>
           {/* Right side nav items */}
           <div className="flex items-center space-x-5 ml-auto">
-            <Button
-              href="https://www.litellm.ai/support"
-              target="_blank"
-              rel="noopener noreferrer"
-              icon={<SlackOutlined />}
-              className="shadow-md shadow-indigo-500/20 hover:shadow-indigo-500/50 transition-shadow"
-            >
-              Join Slack
-            </Button>
-            <Button
-              href="https://github.com/BerriAI/litellm"
-              target="_blank"
-              rel="noopener noreferrer"
-              className="shadow-md shadow-indigo-500/20 hover:shadow-indigo-500/50 transition-shadow"
-              icon={<GithubOutlined />}
-            >
-              Star us on GitHub
-            </Button>
+            <CommunityEngagementButtons />
             {/* Dark mode is currently a work in progress. To test, you can change 'false' to 'true' below.
             Do not set this to true by default until all components are confirmed to support dark mode styles. */}
             {false && <Switch

From 1b9631d26080722ee867c6c8439dc03c56d85c7e Mon Sep 17 00:00:00 2001
From: Alexsander Hamir <alexsanderhamirgomesbaptista@gmail.com>
Date: Mon, 2 Feb 2026 17:46:36 -0800
Subject: [PATCH 08/29] Add blog post: Achieving Sub-Millisecond Proxy Overhead
 (#20309)

---
 .../sub_millisecond_proxy_overhead/index.md   | 92 +++++++++++++++++++
 1 file changed, 92 insertions(+)
 create mode 100644 docs/my-website/blog/sub_millisecond_proxy_overhead/index.md

diff --git a/docs/my-website/blog/sub_millisecond_proxy_overhead/index.md b/docs/my-website/blog/sub_millisecond_proxy_overhead/index.md
new file mode 100644
index 0000000000..1857383363
--- /dev/null
+++ b/docs/my-website/blog/sub_millisecond_proxy_overhead/index.md
@@ -0,0 +1,92 @@
+---
+slug: sub-millisecond-proxy-overhead
+title: "Achieving Sub-Millisecond Proxy Overhead"
+date: 2026-02-02T10:00:00
+authors:
+  - name: Alexsander Hamir
+    title: "Performance Engineer, LiteLLM"
+    url: https://www.linkedin.com/in/alexsander-baptista/
+    image_url: https://github.com/AlexsanderHamir.png
+  - name: Krrish Dholakia
+    title: "CEO, LiteLLM"
+    url: https://www.linkedin.com/in/krish-d/
+    image_url: https://pbs.twimg.com/profile_images/1298587542745358340/DZv3Oj-h_400x400.jpg
+  - name: Ishaan Jaff
+    title: "CTO, LiteLLM"
+    url: https://www.linkedin.com/in/reffajnaahsi/
+    image_url: https://pbs.twimg.com/profile_images/1613813310264340481/lz54oEiB_400x400.jpg
+description: "Our Q1 performance target and architectural direction for achieving sub-millisecond proxy overhead on modest hardware."
+tags: [performance, architecture]
+hide_table_of_contents: false
+---
+
+![Sidecar architecture: Python control plane vs. sidecar hot path](https://raw.githubusercontent.com/AlexsanderHamir/assets/main/Screenshot%202026-02-02%20172554.png)
+
+# Achieving Sub-Millisecond Proxy Overhead
+
+## Introduction
+
+Our Q1 performance target is to aggressively move toward sub-millisecond proxy overhead on a single instance with 4 CPUs and 8 GB of RAM, and to continue pushing that boundary over time. Our broader goal is to make LiteLLM inexpensive to deploy, lightweight, and fast. This post outlines the architectural direction behind that effort.
+
+Proxy overhead refers to the latency introduced by LiteLLM itself, independent of the upstream provider.
+
+To measure it, we run the same workload directly against the provider and through LiteLLM at identical QPS (for example, 1,000 QPS) and compare the latency delta. To reduce noise, the load generator, LiteLLM, and a mock LLM endpoint all run on the same machine, ensuring the difference reflects proxy overhead rather than network latency.
+
+---
+
+## Where We're Coming From
+
+Under the same benchmark originally conducted by [TensorZero](https://www.tensorzero.com/docs/gateway/benchmarks), LiteLLM previously failed at around 1,000 QPS.
+
+That is no longer the case. Today, LiteLLM can be stress-tested at 1,000 QPS with no failures and can scale up to 5,000 QPS without failures on a 4-CPU, 8-GB RAM single instance setup.
+
+This establishes a more up to date baseline and provides useful context as we continue working on proxy overhead and overall performance.
+
+---
+
+## Design Choice
+
+Achieving sub-millisecond proxy overhead with a Python-based system requires being deliberate about where work happens.
+
+Python is a strong fit for flexibility and extensibility: provider abstraction, configuration-driven routing, and a rich callback ecosystem. These are areas where development velocity and correctness matter more than raw throughput.
+
+At higher request rates, however, certain classes of work become expensive when executed inside the Python process on every request. Rather than rewriting LiteLLM or introducing complex deployment requirements, we adopt an optional **sidecar architecture**.
+
+This architectural change is how we intend to make LiteLLM **permanently fast**. While it supports our near-term performance targets, it is a long-term investment.
+
+Python continues to own:
+
+- Request validation and normalization
+- Model and provider selection
+- Callbacks and integrations
+
+The sidecar owns **performance-critical execution**, such as:
+
+- Efficient request forwarding
+- Connection reuse and pooling
+- Enforcing timeouts and limits
+- Aggregating high-frequency metrics
+
+This separation allows each component to focus on what it does best: Python acts as the control plane, while the sidecar handles the hot path.
+
+---
+
+### Why the Sidecar Is Optional
+
+The sidecar is intentionally **optional**.
+
+This allows us to ship it incrementally, validate it under real-world workloads, and avoid making it a hard dependency before it is fully battle-tested across all LiteLLM features.
+
+Just as importantly, this ensures that self-hosting LiteLLM remains simple. The sidecar is bundled and started automatically, requires no additional infrastructure, and can be disabled entirely. From a user's perspective, LiteLLM continues to behave like a single service.
+
+As of today, the sidecar is an optimization, not a requirement.
+
+---
+
+## Conclusion
+
+Sub-millisecond proxy overhead is not achieved through a single optimization, but through architectural changes.
+
+By keeping Python focused on orchestration and extensibility, and offloading performance-critical execution to a sidecar, we establish a foundation for making LiteLLM **permanently fast over time**—even on modest hardware such as a 1-CPU, 2-GB RAM instance, while keeping deployment and self-hosting simple.
+
+This work extends beyond Q1, and we will continue sharing benchmarks and updates as the architecture evolves.

From cf734cb5864c269e5ccebe1889e2eb98af658135 Mon Sep 17 00:00:00 2001
From: yuneng-jiang <yuneng.jiang@gmail.com>
Date: Mon, 2 Feb 2026 17:57:35 -0800
Subject: [PATCH 09/29] Migrate Default Team settings to use reusable Model
 Select

---
 .../ModelSelect/ModelSelect.test.tsx          | 682 +++++++++---------
 .../components/ModelSelect/ModelSelect.tsx    |  12 +-
 .../src/components/TeamSSOSettings.test.tsx   | 636 +++++++++++++++-
 .../src/components/TeamSSOSettings.tsx        |  22 +-
 4 files changed, 974 insertions(+), 378 deletions(-)

diff --git a/ui/litellm-dashboard/src/components/ModelSelect/ModelSelect.test.tsx b/ui/litellm-dashboard/src/components/ModelSelect/ModelSelect.test.tsx
index 3052f79009..6da2f82a2f 100644
--- a/ui/litellm-dashboard/src/components/ModelSelect/ModelSelect.test.tsx
+++ b/ui/litellm-dashboard/src/components/ModelSelect/ModelSelect.test.tsx
@@ -37,12 +37,19 @@ vi.mock("antd", async (importOriginal) => {
       mode,
       ...props
     }: any) => {
+      // Simulate maxTagCount responsive behavior - if value length > 5, call maxTagPlaceholder
+      const shouldShowPlaceholder = maxTagCount === "responsive" && Array.isArray(value) && value.length > 5;
+      const visibleValues = shouldShowPlaceholder ? value.slice(0, 5) : value;
+      const omittedValues = shouldShowPlaceholder
+        ? value.slice(5).map((v: string) => ({ value: v, label: v }))
+        : [];
+
       return (
         <div data-testid={dataTestId || "model-select"}>
           <select
             multiple={mode === "multiple"}
             role="listbox"
-            value={value}
+            value={visibleValues}
             onChange={(e) => {
               const selectedValues = Array.from(e.target.selectedOptions, (option) => option.value);
               onChange(mode === "multiple" ? selectedValues : selectedValues[0]);
@@ -62,6 +69,9 @@ vi.mock("antd", async (importOriginal) => {
               </optgroup>
             ))}
           </select>
+          {shouldShowPlaceholder && maxTagPlaceholder && (
+            <div data-testid="max-tag-placeholder">{maxTagPlaceholder(omittedValues)}</div>
+          )}
         </div>
       );
     },
@@ -82,6 +92,24 @@ const mockUseTeam = vi.mocked(useTeam);
 const mockUseOrganization = vi.mocked(useOrganization);
 const mockUseCurrentUser = vi.mocked(useCurrentUser);
 
+const createMockOrganization = (models: string[]): Organization => ({
+  organization_id: "org-1",
+  organization_alias: "Test Org",
+  budget_id: "budget-1",
+  metadata: {},
+  models,
+  spend: 0,
+  model_spend: {},
+  created_at: "2024-01-01",
+  created_by: "user-1",
+  updated_at: "2024-01-01",
+  updated_by: "user-1",
+  litellm_budget_table: null,
+  teams: null,
+  users: null,
+  members: null,
+});
+
 describe("ModelSelect", () => {
   const mockProxyModels: ProxyModel[] = [
     { id: "gpt-4", object: "model", created: 1234567890, owned_by: "openai" },
@@ -112,125 +140,44 @@ describe("ModelSelect", () => {
     } as any);
   });
 
-  it("should render", async () => {
+  it("should render with all option groups", async () => {
     renderWithProviders(
       <ModelSelect onChange={mockOnChange} context="user" options={{ showAllProxyModelsOverride: true }} />,
     );
 
     await waitFor(() => {
       expect(screen.getByTestId("model-select")).toBeInTheDocument();
-    });
-  });
-
-  it("should show skeleton loader when loading", () => {
-    mockUseAllProxyModels.mockReturnValue({
-      data: undefined,
-      isLoading: true,
-    } as any);
-
-    renderWithProviders(<ModelSelect onChange={mockOnChange} context="user" />);
-
-    expect(screen.getByTestId("skeleton-input")).toBeInTheDocument();
-    expect(screen.queryByTestId("model-select")).not.toBeInTheDocument();
-  });
-
-  it("should show skeleton loader when team is loading", () => {
-    mockUseTeam.mockReturnValue({
-      data: undefined,
-      isLoading: true,
-    } as any);
-
-    renderWithProviders(<ModelSelect onChange={mockOnChange} context="team" teamID="team-1" />);
-
-    expect(screen.getByTestId("skeleton-input")).toBeInTheDocument();
-  });
-
-  it("should show skeleton loader when organization is loading", () => {
-    mockUseOrganization.mockReturnValue({
-      data: undefined,
-      isLoading: true,
-    } as any);
-
-    renderWithProviders(<ModelSelect onChange={mockOnChange} context="organization" organizationID="org-1" />);
-
-    expect(screen.getByTestId("skeleton-input")).toBeInTheDocument();
-  });
-
-  it("should show skeleton loader when current user is loading", () => {
-    mockUseCurrentUser.mockReturnValue({
-      data: undefined,
-      isLoading: true,
-    } as any);
-
-    renderWithProviders(<ModelSelect onChange={mockOnChange} context="user" />);
-
-    expect(screen.getByTestId("skeleton-input")).toBeInTheDocument();
-  });
-
-  it("should render special options group", async () => {
-    const mockOrganization: Organization = {
-      organization_id: "org-1",
-      organization_alias: "Test Org",
-      budget_id: "budget-1",
-      metadata: {},
-      models: ["all-proxy-models"],
-      spend: 0,
-      model_spend: {},
-      created_at: "2024-01-01",
-      created_by: "user-1",
-      updated_at: "2024-01-01",
-      updated_by: "user-1",
-      litellm_budget_table: null,
-      teams: null,
-      users: null,
-      members: null,
-    };
-
-    mockUseOrganization.mockReturnValue({
-      data: mockOrganization,
-      isLoading: false,
-    } as any);
-
-    renderWithProviders(
-      <ModelSelect
-        onChange={mockOnChange}
-        context="organization"
-        organizationID="org-1"
-        options={{ includeSpecialOptions: true }}
-      />,
-    );
-
-    await waitFor(() => {
-      const select = screen.getByTestId("model-select");
-      expect(select).toBeInTheDocument();
-      expect(screen.getByText("All Proxy Models")).toBeInTheDocument();
-      expect(screen.getByText("No Default Models")).toBeInTheDocument();
-    });
-  });
-
-  it("should render wildcard options group", async () => {
-    renderWithProviders(
-      <ModelSelect onChange={mockOnChange} context="user" options={{ showAllProxyModelsOverride: true }} />,
-    );
-
-    await waitFor(() => {
+      expect(screen.getByText("gpt-4")).toBeInTheDocument();
+      expect(screen.getByText("claude-3")).toBeInTheDocument();
       expect(screen.getByText("All Openai models")).toBeInTheDocument();
       expect(screen.getByText("All Anthropic models")).toBeInTheDocument();
     });
   });
 
-  it("should render regular models group", async () => {
-    renderWithProviders(
-      <ModelSelect onChange={mockOnChange} context="user" options={{ showAllProxyModelsOverride: true }} />,
-    );
+  it("should show skeleton loader when any data is loading", () => {
+    const loadingScenarios = [
+      { hook: mockUseAllProxyModels, context: "user" as const },
+      { hook: mockUseTeam, context: "team" as const, props: { teamID: "team-1" } },
+      { hook: mockUseOrganization, context: "organization" as const, props: { organizationID: "org-1" } },
+      { hook: mockUseCurrentUser, context: "user" as const },
+    ];
 
-    await waitFor(() => {
-      expect(screen.getByText("gpt-4")).toBeInTheDocument();
-      expect(screen.getByText("claude-3")).toBeInTheDocument();
+    loadingScenarios.forEach(({ hook, context, props = {} }) => {
+      hook.mockReturnValue({
+        data: undefined,
+        isLoading: true,
+      } as any);
+
+      const { unmount } = renderWithProviders(
+        <ModelSelect onChange={mockOnChange} context={context} {...props} />,
+      );
+
+      expect(screen.getByTestId("skeleton-input")).toBeInTheDocument();
+      unmount();
     });
   });
 
-  it("should call onChange when selecting a regular model", async () => {
+  it("should handle model selection and onChange", async () => {
     const user = userEvent.setup();
     renderWithProviders(
       <ModelSelect onChange={mockOnChange} context="user" options={{ showAllProxyModelsOverride: true }} />,
@@ -242,32 +189,16 @@ describe("ModelSelect", () => {
 
     const select = screen.getByRole("listbox");
     await user.selectOptions(select, "gpt-4");
-
     expect(mockOnChange).toHaveBeenCalledWith(["gpt-4"]);
+
+    await user.selectOptions(select, ["gpt-4", "claude-3"]);
+    expect(mockOnChange).toHaveBeenCalled();
   });
 
-  it("should call onChange with only last special option when multiple special options are selected", async () => {
+  it("should handle special options correctly", async () => {
     const user = userEvent.setup();
-    const mockOrganization: Organization = {
-      organization_id: "org-1",
-      organization_alias: "Test Org",
-      budget_id: "budget-1",
-      metadata: {},
-      models: ["all-proxy-models"],
-      spend: 0,
-      model_spend: {},
-      created_at: "2024-01-01",
-      created_by: "user-1",
-      updated_at: "2024-01-01",
-      updated_by: "user-1",
-      litellm_budget_table: null,
-      teams: null,
-      users: null,
-      members: null,
-    };
-
     mockUseOrganization.mockReturnValue({
-      data: mockOrganization,
+      data: createMockOrganization(["all-proxy-models"]),
       isLoading: false,
     } as any);
 
@@ -281,16 +212,16 @@ describe("ModelSelect", () => {
     );
 
     await waitFor(() => {
-      expect(screen.getByTestId("model-select")).toBeInTheDocument();
+      expect(screen.getByText("All Proxy Models")).toBeInTheDocument();
+      expect(screen.getByText("No Default Models")).toBeInTheDocument();
     });
 
     const select = screen.getByRole("listbox");
     await user.selectOptions(select, ["all-proxy-models", "no-default-models"]);
-
     expect(mockOnChange).toHaveBeenCalledWith(["no-default-models"]);
   });
 
-  it("should disable regular models when special option is selected", async () => {
+  it("should disable models when special option is selected", async () => {
     renderWithProviders(
       <ModelSelect
         onChange={mockOnChange}
@@ -301,187 +232,230 @@ describe("ModelSelect", () => {
     );
 
     await waitFor(() => {
-      const gpt4Option = screen.getByRole("option", { name: "gpt-4" });
-      expect(gpt4Option).toBeDisabled();
+      expect(screen.getByRole("option", { name: "gpt-4" })).toBeDisabled();
+      expect(screen.getByRole("option", { name: "All Openai models" })).toBeDisabled();
     });
   });
 
-  it("should disable wildcard models when special option is selected", async () => {
-    renderWithProviders(
-      <ModelSelect
-        onChange={mockOnChange}
-        value={["all-proxy-models"]}
-        context="user"
-        options={{ showAllProxyModelsOverride: true }}
-      />,
-    );
+  it("should filter models based on context", async () => {
+    const testCases = [
+      {
+        name: "user context with includeUserModels",
+        context: "user" as const,
+        options: { includeUserModels: true },
+        setup: () => {
+          mockUseCurrentUser.mockReturnValue({
+            data: { models: ["gpt-4"] },
+            isLoading: false,
+          } as any);
+        },
+        expectedVisible: ["gpt-4"],
+        expectedHidden: ["claude-3"],
+      },
+      {
+        name: "user context without includeUserModels",
+        context: "user" as const,
+        options: {},
+        setup: () => {
+          mockUseCurrentUser.mockReturnValue({
+            data: { models: ["gpt-4"] },
+            isLoading: false,
+          } as any);
+        },
+        expectedVisible: [],
+        expectedHidden: ["gpt-4", "claude-3"],
+      },
+      {
+        name: "team context without organization",
+        context: "team" as const,
+        options: {},
+        props: { teamID: "team-1" },
+        setup: () => {
+          mockUseTeam.mockReturnValue({
+            data: { team_id: "team-1", team_alias: "Test Team", models: [] },
+            isLoading: false,
+          } as any);
+          mockUseOrganization.mockReturnValue({
+            data: undefined,
+            isLoading: false,
+          } as any);
+        },
+        expectedVisible: ["gpt-4", "claude-3"],
+        expectedHidden: [],
+      },
+      {
+        name: "team context with organization having all-proxy-models",
+        context: "team" as const,
+        options: {},
+        props: { teamID: "team-1", organizationID: "org-1" },
+        setup: () => {
+          mockUseTeam.mockReturnValue({
+            data: { team_id: "team-1", team_alias: "Test Team", models: [] },
+            isLoading: false,
+          } as any);
+          mockUseOrganization.mockReturnValue({
+            data: createMockOrganization(["all-proxy-models"]),
+            isLoading: false,
+          } as any);
+        },
+        expectedVisible: ["gpt-4", "claude-3"],
+        expectedHidden: [],
+      },
+      {
+        name: "team context with organization filtering models",
+        context: "team" as const,
+        options: {},
+        props: { teamID: "team-1", organizationID: "org-1" },
+        setup: () => {
+          mockUseTeam.mockReturnValue({
+            data: { team_id: "team-1", team_alias: "Test Team", models: [] },
+            isLoading: false,
+          } as any);
+          mockUseOrganization.mockReturnValue({
+            data: createMockOrganization(["gpt-4"]),
+            isLoading: false,
+          } as any);
+        },
+        expectedVisible: ["gpt-4"],
+        expectedHidden: ["claude-3"],
+      },
+      {
+        name: "organization context",
+        context: "organization" as const,
+        options: {},
+        props: { organizationID: "org-1" },
+        setup: () => {
+          mockUseOrganization.mockReturnValue({
+            data: createMockOrganization(["gpt-4"]),
+            isLoading: false,
+          } as any);
+        },
+        expectedVisible: ["gpt-4", "claude-3"],
+        expectedHidden: [],
+      },
+      {
+        name: "global context",
+        context: "global" as const,
+        options: {},
+        setup: () => { },
+        expectedVisible: ["gpt-4", "claude-3"],
+        expectedHidden: [],
+      },
+    ];
 
-    await waitFor(() => {
-      const openaiWildcardOption = screen.getByRole("option", { name: "All Openai models" });
-      expect(openaiWildcardOption).toBeDisabled();
-    });
+    for (const testCase of testCases) {
+      testCase.setup();
+      const { unmount } = renderWithProviders(
+        <ModelSelect
+          onChange={mockOnChange}
+          context={testCase.context}
+          options={testCase.options}
+          {...(testCase.props || {})}
+        />,
+      );
+
+      await waitFor(() => {
+        testCase.expectedVisible.forEach((model) => {
+          expect(screen.getByText(model)).toBeInTheDocument();
+        });
+        testCase.expectedHidden.forEach((model) => {
+          expect(screen.queryByText(model)).not.toBeInTheDocument();
+        });
+      });
+
+      unmount();
+      vi.clearAllMocks();
+      mockUseAllProxyModels.mockReturnValue({
+        data: { data: mockProxyModels },
+        isLoading: false,
+      } as any);
+    }
   });
 
-  it("should disable other special options when one special option is selected", async () => {
-    const mockOrganization: Organization = {
-      organization_id: "org-1",
-      organization_alias: "Test Org",
-      budget_id: "budget-1",
-      metadata: {},
-      models: ["all-proxy-models"],
-      spend: 0,
-      model_spend: {},
-      created_at: "2024-01-01",
-      created_by: "user-1",
-      updated_at: "2024-01-01",
-      updated_by: "user-1",
-      litellm_budget_table: null,
-      teams: null,
-      users: null,
-      members: null,
-    };
+  it("should show All Proxy Models option based on conditions", async () => {
+    const testCases = [
+      {
+        name: "when showAllProxyModelsOverride is true",
+        context: "user" as const,
+        options: { showAllProxyModelsOverride: true, includeSpecialOptions: true },
+        setup: () => { },
+        shouldShow: true,
+      },
+      {
+        name: "when organization has all-proxy-models",
+        context: "organization" as const,
+        options: { includeSpecialOptions: true },
+        props: { organizationID: "org-1" },
+        setup: () => {
+          mockUseOrganization.mockReturnValue({
+            data: createMockOrganization(["all-proxy-models"]),
+            isLoading: false,
+          } as any);
+        },
+        shouldShow: true,
+      },
+      {
+        name: "when organization has empty models array",
+        context: "organization" as const,
+        options: { includeSpecialOptions: true },
+        props: { organizationID: "org-1" },
+        setup: () => {
+          mockUseOrganization.mockReturnValue({
+            data: createMockOrganization([]),
+            isLoading: false,
+          } as any);
+        },
+        shouldShow: true,
+      },
+      {
+        name: "when context is global",
+        context: "global" as const,
+        options: { includeSpecialOptions: true },
+        setup: () => { },
+        shouldShow: true,
+      },
+      {
+        name: "when organization has specific models",
+        context: "organization" as const,
+        options: { includeSpecialOptions: true },
+        props: { organizationID: "org-1" },
+        setup: () => {
+          mockUseOrganization.mockReturnValue({
+            data: createMockOrganization(["gpt-4"]),
+            isLoading: false,
+          } as any);
+        },
+        shouldShow: false,
+      },
+    ];
 
-    mockUseOrganization.mockReturnValue({
-      data: mockOrganization,
-      isLoading: false,
-    } as any);
+    for (const testCase of testCases) {
+      testCase.setup();
+      const { unmount } = renderWithProviders(
+        <ModelSelect
+          onChange={mockOnChange}
+          context={testCase.context}
+          options={testCase.options}
+          {...(testCase.props || {})}
+        />,
+      );
 
-    renderWithProviders(
-      <ModelSelect
-        onChange={mockOnChange}
-        value={["all-proxy-models"]}
-        context="organization"
-        organizationID="org-1"
-        options={{ showAllProxyModelsOverride: true, includeSpecialOptions: true }}
-      />,
-    );
+      await waitFor(() => {
+        if (testCase.shouldShow) {
+          expect(screen.getByText("All Proxy Models")).toBeInTheDocument();
+        } else {
+          expect(screen.queryByText("All Proxy Models")).not.toBeInTheDocument();
+          expect(screen.getByText("No Default Models")).toBeInTheDocument();
+        }
+      });
 
-    await waitFor(() => {
-      const noDefaultOption = screen.getByRole("option", { name: "No Default Models" });
-      expect(noDefaultOption).toBeDisabled();
-    });
-  });
-
-  it("should filter models when showAllProxyModelsOverride is true", async () => {
-    renderWithProviders(
-      <ModelSelect onChange={mockOnChange} context="user" options={{ showAllProxyModelsOverride: true }} />,
-    );
-
-    await waitFor(() => {
-      expect(screen.getByText("gpt-4")).toBeInTheDocument();
-      expect(screen.getByText("claude-3")).toBeInTheDocument();
-    });
-  });
-
-  it("should filter models when organization has all-proxy-models in models array", async () => {
-    const mockOrganization: Organization = {
-      organization_id: "org-1",
-      organization_alias: "Test Org",
-      budget_id: "budget-1",
-      metadata: {},
-      models: ["all-proxy-models"],
-      spend: 0,
-      model_spend: {},
-      created_at: "2024-01-01",
-      created_by: "user-1",
-      updated_at: "2024-01-01",
-      updated_by: "user-1",
-      litellm_budget_table: null,
-      teams: null,
-      users: null,
-      members: null,
-    };
-
-    mockUseOrganization.mockReturnValue({
-      data: mockOrganization,
-      isLoading: false,
-    } as any);
-
-    renderWithProviders(<ModelSelect onChange={mockOnChange} context="organization" organizationID="org-1" />);
-
-    await waitFor(() => {
-      expect(screen.getByText("gpt-4")).toBeInTheDocument();
-      expect(screen.getByText("claude-3")).toBeInTheDocument();
-    });
-  });
-
-  it("should show all models when organization context is used", async () => {
-    const mockOrganization: Organization = {
-      organization_id: "org-1",
-      organization_alias: "Test Org",
-      budget_id: "budget-1",
-      metadata: {},
-      models: ["gpt-4"],
-      spend: 0,
-      model_spend: {},
-      created_at: "2024-01-01",
-      created_by: "user-1",
-      updated_at: "2024-01-01",
-      updated_by: "user-1",
-      litellm_budget_table: null,
-      teams: null,
-      users: null,
-      members: null,
-    };
-
-    mockUseOrganization.mockReturnValue({
-      data: mockOrganization,
-      isLoading: false,
-    } as any);
-
-    renderWithProviders(<ModelSelect onChange={mockOnChange} context="organization" organizationID="org-1" />);
-
-    await waitFor(() => {
-      expect(screen.getByText("gpt-4")).toBeInTheDocument();
-      expect(screen.getByText("claude-3")).toBeInTheDocument();
-    });
-  });
-
-  it("should use custom dataTestId when provided", async () => {
-    renderWithProviders(
-      <ModelSelect
-        onChange={mockOnChange}
-        dataTestId="custom-test-id"
-        context="user"
-        options={{ showAllProxyModelsOverride: true }}
-      />,
-    );
-
-    await waitFor(() => {
-      expect(screen.getByTestId("custom-test-id")).toBeInTheDocument();
-    });
-  });
-
-  it("should handle multiple model selections", async () => {
-    const user = userEvent.setup();
-    renderWithProviders(
-      <ModelSelect onChange={mockOnChange} context="user" options={{ showAllProxyModelsOverride: true }} />,
-    );
-
-    await waitFor(() => {
-      expect(screen.getByTestId("model-select")).toBeInTheDocument();
-    });
-
-    const select = screen.getByRole("listbox");
-    await user.selectOptions(select, "gpt-4");
-    expect(mockOnChange).toHaveBeenCalledWith(["gpt-4"]);
-
-    await user.selectOptions(select, "claude-3");
-    expect(mockOnChange).toHaveBeenCalled();
-    const allCalls = mockOnChange.mock.calls.map((call) => call[0]);
-    expect(allCalls.some((call) => Array.isArray(call) && call.includes("gpt-4"))).toBe(true);
-    expect(allCalls.some((call) => Array.isArray(call) && call.includes("claude-3"))).toBe(true);
-  });
-
-  it("should capitalize provider name in wildcard options", async () => {
-    renderWithProviders(
-      <ModelSelect onChange={mockOnChange} context="user" options={{ showAllProxyModelsOverride: true }} />,
-    );
-
-    await waitFor(() => {
-      expect(screen.getByText("All Openai models")).toBeInTheDocument();
-      expect(screen.getByText("All Anthropic models")).toBeInTheDocument();
-    });
+      unmount();
+      vi.clearAllMocks();
+      mockUseAllProxyModels.mockReturnValue({
+        data: { data: mockProxyModels },
+        isLoading: false,
+      } as any);
+    }
   });
 
   it("should deduplicate models with same id", async () => {
@@ -505,52 +479,29 @@ describe("ModelSelect", () => {
     });
   });
 
-  it("should filter models based on user context with includeUserModels option", async () => {
-    mockUseCurrentUser.mockReturnValue({
-      data: { models: ["gpt-4"] },
-      isLoading: false,
-    } as any);
-
-    renderWithProviders(<ModelSelect onChange={mockOnChange} context="user" options={{ includeUserModels: true }} />);
+  it("should use custom dataTestId when provided", async () => {
+    renderWithProviders(
+      <ModelSelect
+        onChange={mockOnChange}
+        dataTestId="custom-test-id"
+        context="user"
+        options={{ showAllProxyModelsOverride: true }}
+      />,
+    );
 
     await waitFor(() => {
-      expect(screen.getByText("gpt-4")).toBeInTheDocument();
-      expect(screen.queryByText("claude-3")).not.toBeInTheDocument();
+      expect(screen.getByTestId("custom-test-id")).toBeInTheDocument();
     });
   });
 
-  it("should filter models based on team context", async () => {
-    const mockTeam = {
-      team_id: "team-1",
-      team_alias: "Test Team",
-      models: ["gpt-4"],
-    };
-
-    const mockOrganization: Organization = {
-      organization_id: "org-1",
-      organization_alias: "Test Org",
-      budget_id: "budget-1",
-      metadata: {},
-      models: ["gpt-4"],
-      spend: 0,
-      model_spend: {},
-      created_at: "2024-01-01",
-      created_by: "user-1",
-      updated_at: "2024-01-01",
-      updated_by: "user-1",
-      litellm_budget_table: null,
-      teams: null,
-      users: null,
-      members: null,
-    };
-
+  it("should return all proxy models for team context when organization has empty models array", async () => {
     mockUseTeam.mockReturnValue({
-      data: mockTeam,
+      data: { team_id: "team-1", team_alias: "Test Team", models: [] },
       isLoading: false,
     } as any);
 
     mockUseOrganization.mockReturnValue({
-      data: mockOrganization,
+      data: createMockOrganization([]),
       isLoading: false,
     } as any);
 
@@ -558,7 +509,62 @@ describe("ModelSelect", () => {
 
     await waitFor(() => {
       expect(screen.getByText("gpt-4")).toBeInTheDocument();
-      expect(screen.queryByText("claude-3")).not.toBeInTheDocument();
+      expect(screen.getByText("claude-3")).toBeInTheDocument();
+    });
+  });
+
+  it("should disable No Default Models when all-proxy-models is selected", async () => {
+    mockUseOrganization.mockReturnValue({
+      data: createMockOrganization(["all-proxy-models"]),
+      isLoading: false,
+    } as any);
+
+    renderWithProviders(
+      <ModelSelect
+        onChange={mockOnChange}
+        value={["all-proxy-models"]}
+        context="organization"
+        organizationID="org-1"
+        options={{ includeSpecialOptions: true }}
+      />,
+    );
+
+    await waitFor(() => {
+      const noDefaultOption = screen.getByRole("option", { name: "No Default Models" });
+      expect(noDefaultOption).toBeDisabled();
+    });
+  });
+
+  it("should render maxTagPlaceholder when many items are selected", async () => {
+    // Create many models to trigger maxTagCount responsive behavior
+    const manyModels: ProxyModel[] = Array.from({ length: 20 }, (_, i) => ({
+      id: `model-${i}`,
+      object: "model",
+      created: 1234567890,
+      owned_by: "test",
+    }));
+
+    mockUseAllProxyModels.mockReturnValue({
+      data: { data: manyModels },
+      isLoading: false,
+    } as any);
+
+    const selectedValues = manyModels.slice(0, 10).map((m) => m.id);
+
+    renderWithProviders(
+      <ModelSelect
+        onChange={mockOnChange}
+        value={selectedValues}
+        context="user"
+        options={{ showAllProxyModelsOverride: true }}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId("model-select")).toBeInTheDocument();
+      // Verify maxTagPlaceholder is rendered with omitted values
+      expect(screen.getByTestId("max-tag-placeholder")).toBeInTheDocument();
+      expect(screen.getByText(/\+5 more/)).toBeInTheDocument();
     });
   });
 });
diff --git a/ui/litellm-dashboard/src/components/ModelSelect/ModelSelect.tsx b/ui/litellm-dashboard/src/components/ModelSelect/ModelSelect.tsx
index 78ccdddd81..2b7399c456 100644
--- a/ui/litellm-dashboard/src/components/ModelSelect/ModelSelect.tsx
+++ b/ui/litellm-dashboard/src/components/ModelSelect/ModelSelect.tsx
@@ -30,10 +30,11 @@ export interface ModelSelectProps {
     showAllProxyModelsOverride?: boolean;
     includeSpecialOptions?: boolean;
   };
-  context: "team" | "organization" | "user";
+  context: "team" | "organization" | "user" | "global";
   dataTestId?: string;
   value?: string[];
   onChange: (values: string[]) => void;
+  style?: React.CSSProperties;
 }
 
 type FilterContextArgs = {
@@ -65,6 +66,10 @@ const contextFilters: Record<ModelSelectProps["context"], (args: FilterContextAr
   organization: ({ allProxyModels }) => {
     return allProxyModels;
   },
+
+  global: ({ allProxyModels }) => {
+    return allProxyModels;
+  },
 };
 
 const filterModels = (
@@ -84,7 +89,7 @@ const filterModels = (
 };
 
 export const ModelSelect = (props: ModelSelectProps) => {
-  const { teamID, organizationID, options, context, dataTestId, value = [], onChange } = props;
+  const { teamID, organizationID, options, context, dataTestId, value = [], onChange, style } = props;
   const { includeUserModels, showAllTeamModelsOption, showAllProxyModelsOverride, includeSpecialOptions } =
     options || {};
   const { data: allProxyModels, isLoading: isLoadingAllProxyModels } = useAllProxyModels();
@@ -98,7 +103,7 @@ export const ModelSelect = (props: ModelSelectProps) => {
   const organizationHasAllProxyModels = organization?.models.includes(MODEL_SELECT_ALL_PROXY_MODELS_SPECIAL_VALUE.value) || organization?.models.length === 0;
   const shouldShowAllProxyModels =
     showAllProxyModelsOverride ||
-    (organizationHasAllProxyModels && includeSpecialOptions);
+    (organizationHasAllProxyModels && includeSpecialOptions) || context === "global";
 
   if (isLoading) {
     return <Skeleton.Input active block />;
@@ -134,6 +139,7 @@ export const ModelSelect = (props: ModelSelectProps) => {
       data-testid={dataTestId}
       value={value}
       onChange={handleChange}
+      style={style}
       options={[
         includeSpecialOptions
           ? {
diff --git a/ui/litellm-dashboard/src/components/TeamSSOSettings.test.tsx b/ui/litellm-dashboard/src/components/TeamSSOSettings.test.tsx
index f5e43fc3d5..34085df8f1 100644
--- a/ui/litellm-dashboard/src/components/TeamSSOSettings.test.tsx
+++ b/ui/litellm-dashboard/src/components/TeamSSOSettings.test.tsx
@@ -1,63 +1,653 @@
-import { screen } from "@testing-library/react";
+import React from "react";
+import { screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { renderWithProviders } from "../../tests/test-utils";
 import TeamSSOSettings from "./TeamSSOSettings";
 import * as networking from "./networking";
+import NotificationsManager from "./molecules/notifications_manager";
 
-// Mock the networking functions
 vi.mock("./networking");
 
-// Mock the budget duration dropdown
+vi.mock("@tremor/react", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@tremor/react")>();
+  const React = await import("react");
+  return {
+    ...actual,
+    Card: ({ children }: { children: React.ReactNode }) => React.createElement("div", { "data-testid": "card" }, children),
+    Title: ({ children }: { children: React.ReactNode }) => React.createElement("h2", {}, children),
+    Text: ({ children }: { children: React.ReactNode }) => React.createElement("span", {}, children),
+    Divider: () => React.createElement("hr", {}),
+    TextInput: ({ value, onChange, placeholder, className }: any) =>
+      React.createElement("input", {
+        type: "text",
+        value: value || "",
+        onChange,
+        placeholder,
+        className,
+      }),
+  };
+});
+
 vi.mock("./common_components/budget_duration_dropdown", () => ({
   default: ({ value, onChange }: { value: string | null; onChange: (value: string) => void }) => (
-    <select data-testid="budget-duration-dropdown" value={value || ""} onChange={(e) => onChange(e.target.value)}>
+    <select
+      data-testid="budget-duration-dropdown"
+      value={value || ""}
+      onChange={(e) => onChange(e.target.value)}
+      aria-label="Budget duration"
+    >
       <option value="">Select duration</option>
       <option value="daily">Daily</option>
       <option value="monthly">Monthly</option>
     </select>
   ),
-  getBudgetDurationLabel: vi.fn((value: string) => value),
+  getBudgetDurationLabel: vi.fn((value: string) => `Budget: ${value}`),
 }));
 
-// Mock the model display name helper
 vi.mock("./key_team_helpers/fetch_available_models_team_key", () => ({
   getModelDisplayName: vi.fn((model: string) => model),
 }));
 
+vi.mock("./ModelSelect/ModelSelect", () => ({
+  ModelSelect: ({ value, onChange }: { value: string[]; onChange: (value: string[]) => void }) => (
+    <select
+      data-testid="model-select"
+      multiple
+      value={value || []}
+      onChange={(e) => {
+        const selectedValues = Array.from(e.target.selectedOptions, (option) => option.value);
+        onChange(selectedValues);
+      }}
+      aria-label="Models"
+    >
+      <option value="gpt-4">gpt-4</option>
+      <option value="claude-3">claude-3</option>
+    </select>
+  ),
+}));
+
+vi.mock("antd", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("antd")>();
+  const React = await import("react");
+  const SelectComponent = ({
+    value,
+    onChange,
+    mode,
+    children,
+    className,
+  }: {
+    value: any;
+    onChange: (value: any) => void;
+    mode?: string;
+    children: React.ReactNode;
+    className?: string;
+  }) => {
+    const isMultiple = mode === "multiple";
+    const selectValue = isMultiple ? (Array.isArray(value) ? value : []) : value || "";
+    return React.createElement(
+      "select",
+      {
+        multiple: isMultiple,
+        value: selectValue,
+        onChange: (e: React.ChangeEvent<HTMLSelectElement>) => {
+          const selectedValues = Array.from(e.target.selectedOptions, (option) => option.value);
+          onChange(isMultiple ? selectedValues : selectedValues[0] || undefined);
+        },
+        className,
+        "aria-label": "Select",
+        role: "listbox",
+      },
+      children,
+    );
+  };
+  SelectComponent.Option = ({ value: optionValue, children: optionChildren }: { value: string; children: React.ReactNode }) =>
+    React.createElement("option", { value: optionValue }, optionChildren);
+  return {
+    ...actual,
+    Spin: ({ size }: { size?: string }) => React.createElement("div", { "data-testid": "spinner", "data-size": size }),
+    Switch: ({ checked, onChange }: { checked: boolean; onChange: (checked: boolean) => void }) =>
+      React.createElement("input", {
+        type: "checkbox",
+        role: "switch",
+        checked: checked,
+        onChange: (e) => onChange(e.target.checked),
+        "aria-label": "Toggle switch",
+      }),
+    Select: SelectComponent,
+    Typography: {
+      Paragraph: ({ children }: { children: React.ReactNode }) => React.createElement("p", {}, children),
+    },
+  };
+});
+
+const mockGetDefaultTeamSettings = vi.mocked(networking.getDefaultTeamSettings);
+const mockUpdateDefaultTeamSettings = vi.mocked(networking.updateDefaultTeamSettings);
+const mockModelAvailableCall = vi.mocked(networking.modelAvailableCall);
+const mockNotificationsManager = vi.mocked(NotificationsManager);
+
 describe("TeamSSOSettings", () => {
+  const defaultProps = {
+    accessToken: "test-token",
+    userID: "test-user",
+    userRole: "admin",
+  };
+
+  const mockSettings = {
+    values: {
+      budget_duration: "monthly",
+      max_budget: 1000,
+      enabled: true,
+      allowed_models: ["gpt-4", "claude-3"],
+      models: ["gpt-4"],
+      status: "active",
+    },
+    field_schema: {
+      description: "Default team settings schema",
+      properties: {
+        budget_duration: {
+          type: "string",
+          description: "Budget duration setting",
+        },
+        max_budget: {
+          type: "number",
+          description: "Maximum budget amount",
+        },
+        enabled: {
+          type: "boolean",
+          description: "Enable feature",
+        },
+        allowed_models: {
+          type: "array",
+          items: {
+            enum: ["gpt-4", "claude-3", "gpt-3.5-turbo"],
+          },
+          description: "Allowed models",
+        },
+        models: {
+          type: "array",
+          description: "Selected models",
+        },
+        status: {
+          type: "string",
+          enum: ["active", "inactive", "pending"],
+          description: "Status",
+        },
+      },
+    },
+  };
+
   beforeEach(() => {
     vi.clearAllMocks();
+    mockModelAvailableCall.mockResolvedValue({
+      data: [{ id: "gpt-4" }, { id: "claude-3" }],
+    });
   });
 
-  it("renders the component", async () => {
-    // Mock successful API responses
-    vi.mocked(networking.getDefaultTeamSettings).mockResolvedValue({
+  it("should render", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByText("Default Team Settings")).toBeInTheDocument();
+    });
+  });
+
+  it("should show loading spinner while fetching settings", () => {
+    mockGetDefaultTeamSettings.mockImplementation(() => new Promise(() => { }));
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    expect(screen.getByTestId("spinner")).toBeInTheDocument();
+  });
+
+  it("should display message when no settings are available", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(null as any);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(
+        screen.getByText("No team settings available or you do not have permission to view them."),
+      ).toBeInTheDocument();
+    });
+  });
+
+  it("should not fetch settings when access token is null", async () => {
+    renderWithProviders(<TeamSSOSettings accessToken={null} userID="test-user" userRole="admin" />);
+
+    await waitFor(() => {
+      expect(mockGetDefaultTeamSettings).not.toHaveBeenCalled();
+    });
+  });
+
+  it("should display settings fields with correct values", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByText("Budget Duration")).toBeInTheDocument();
+      expect(screen.getByText("Max Budget")).toBeInTheDocument();
+    });
+
+    expect(screen.getByText("Budget: monthly")).toBeInTheDocument();
+    expect(screen.getByText("1000")).toBeInTheDocument();
+    const enabledTexts = screen.getAllByText("Enabled");
+    expect(enabledTexts.length).toBeGreaterThan(0);
+  });
+
+  it("should display 'Not set' for null values", async () => {
+    const settingsWithNulls = {
+      ...mockSettings,
       values: {
-        budget_duration: "monthly",
-        max_budget: 1000,
+        ...mockSettings.values,
+        max_budget: null,
       },
+    };
+    mockGetDefaultTeamSettings.mockResolvedValue(settingsWithNulls);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByText("Not set")).toBeInTheDocument();
+    });
+  });
+
+  it("should toggle edit mode when edit button is clicked", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
+    });
+
+    const editButton = screen.getByRole("button", { name: "Edit Settings" });
+    await userEvent.click(editButton);
+
+    expect(screen.getByRole("button", { name: "Cancel" })).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "Save Changes" })).toBeInTheDocument();
+    expect(screen.queryByRole("button", { name: "Edit Settings" })).not.toBeInTheDocument();
+  });
+
+  it("should cancel edit mode and reset values", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
+    });
+
+    const editButton = screen.getByRole("button", { name: "Edit Settings" });
+    await userEvent.click(editButton);
+
+    const cancelButton = screen.getByRole("button", { name: "Cancel" });
+    await userEvent.click(cancelButton);
+
+    expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
+    expect(screen.queryByRole("button", { name: "Cancel" })).not.toBeInTheDocument();
+  });
+
+  it("should save settings when save button is clicked", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+    mockUpdateDefaultTeamSettings.mockResolvedValue({
+      settings: mockSettings.values,
+    });
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
+    });
+
+    const editButton = screen.getByRole("button", { name: "Edit Settings" });
+    await userEvent.click(editButton);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Save Changes" })).toBeInTheDocument();
+    });
+
+    const saveButton = screen.getByRole("button", { name: "Save Changes" });
+    await userEvent.click(saveButton);
+
+    await waitFor(() => {
+      expect(mockUpdateDefaultTeamSettings).toHaveBeenCalledWith("test-token", mockSettings.values);
+    });
+
+    expect(mockNotificationsManager.success).toHaveBeenCalledWith("Default team settings updated successfully");
+  });
+
+  it("should show error notification when save fails", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+    mockUpdateDefaultTeamSettings.mockRejectedValue(new Error("Save failed"));
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
+    });
+
+    const editButton = screen.getByRole("button", { name: "Edit Settings" });
+    await userEvent.click(editButton);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Save Changes" })).toBeInTheDocument();
+    });
+
+    const saveButton = screen.getByRole("button", { name: "Save Changes" });
+    await userEvent.click(saveButton);
+
+    await waitFor(() => {
+      expect(mockNotificationsManager.fromBackend).toHaveBeenCalledWith("Failed to update team settings");
+    });
+  });
+
+  it("should render boolean field as switch in edit mode", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
+    });
+
+    const editButton = screen.getByRole("button", { name: "Edit Settings" });
+    await userEvent.click(editButton);
+
+    await waitFor(() => {
+      const switchElement = screen.getByRole("switch");
+      expect(switchElement).toBeInTheDocument();
+      expect(switchElement).toBeChecked();
+    });
+  });
+
+  it("should update boolean value when switch is toggled", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
+    });
+
+    const editButton = screen.getByRole("button", { name: "Edit Settings" });
+    await userEvent.click(editButton);
+
+    await waitFor(() => {
+      expect(screen.getByRole("switch")).toBeInTheDocument();
+    });
+
+    const switchElement = screen.getByRole("switch");
+    await userEvent.click(switchElement);
+
+    expect(switchElement).not.toBeChecked();
+  });
+
+  it("should render budget duration dropdown in edit mode", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
+    });
+
+    const editButton = screen.getByRole("button", { name: "Edit Settings" });
+    await userEvent.click(editButton);
+
+    await waitFor(() => {
+      expect(screen.getByLabelText("Budget duration")).toBeInTheDocument();
+    });
+  });
+
+  it("should update budget duration when dropdown value changes", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
+    });
+
+    const editButton = screen.getByRole("button", { name: "Edit Settings" });
+    await userEvent.click(editButton);
+
+    await waitFor(() => {
+      expect(screen.getByLabelText("Budget duration")).toBeInTheDocument();
+    });
+
+    const dropdown = screen.getByLabelText("Budget duration");
+    await userEvent.selectOptions(dropdown, "daily");
+
+    expect(dropdown).toHaveValue("daily");
+  });
+
+  it("should render text input for string fields in edit mode", async () => {
+    const settingsWithString = {
+      ...mockSettings,
       field_schema: {
-        description: "Default team settings",
+        ...mockSettings.field_schema,
         properties: {
-          budget_duration: {
+          ...mockSettings.field_schema.properties,
+          team_name: {
             type: "string",
-            description: "Budget duration",
-          },
-          max_budget: {
-            type: "number",
-            description: "Maximum budget",
+            description: "Team name",
           },
         },
       },
+      values: {
+        ...mockSettings.values,
+        team_name: "Test Team",
+      },
+    };
+    mockGetDefaultTeamSettings.mockResolvedValue(settingsWithString);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
     });
 
-    vi.mocked(networking.modelAvailableCall).mockResolvedValue({
-      data: [{ id: "gpt-4" }, { id: "claude-3" }],
+    const editButton = screen.getByRole("button", { name: "Edit Settings" });
+    await userEvent.click(editButton);
+
+    await waitFor(() => {
+      const textInput = screen.getByDisplayValue("Test Team");
+      expect(textInput).toBeInTheDocument();
+    });
+  });
+
+  it("should render enum select for string enum fields in edit mode", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
     });
 
-    renderWithProviders(<TeamSSOSettings accessToken="test-token" userID="test-user" userRole="admin" />);
+    const editButton = screen.getByRole("button", { name: "Edit Settings" });
+    await userEvent.click(editButton);
 
-    const container = await screen.findByText("Default Team Settings");
-    expect(container).toBeInTheDocument();
+    await waitFor(() => {
+      const statusSelect = screen.getAllByRole("listbox")[0];
+      expect(statusSelect).toBeInTheDocument();
+    });
+  });
+
+  it("should render multi-select for array enum fields in edit mode", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
+    });
+
+    const editButton = screen.getByRole("button", { name: "Edit Settings" });
+    await userEvent.click(editButton);
+
+    await waitFor(() => {
+      const multiSelects = screen.getAllByRole("listbox");
+      expect(multiSelects.length).toBeGreaterThan(0);
+    });
+  });
+
+  it("should render ModelSelect for models field in edit mode", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
+    });
+
+    const editButton = screen.getByRole("button", { name: "Edit Settings" });
+    await userEvent.click(editButton);
+
+    await waitFor(() => {
+      expect(screen.getByTestId("model-select")).toBeInTheDocument();
+    });
+  });
+
+  it("should display models as badges in view mode", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      const gpt4Elements = screen.getAllByText("gpt-4");
+      expect(gpt4Elements.length).toBeGreaterThan(0);
+    });
+  });
+
+  it("should display 'None' for empty arrays in view mode", async () => {
+    const settingsWithEmptyArray = {
+      ...mockSettings,
+      values: {
+        ...mockSettings.values,
+        models: [],
+      },
+    };
+    mockGetDefaultTeamSettings.mockResolvedValue(settingsWithEmptyArray);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      const noneTexts = screen.getAllByText("None");
+      expect(noneTexts.length).toBeGreaterThan(0);
+    });
+  });
+
+  it("should display schema description when available", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByText("Default team settings schema")).toBeInTheDocument();
+    });
+  });
+
+  it("should show error notification when fetching settings fails", async () => {
+    mockGetDefaultTeamSettings.mockRejectedValue(new Error("Fetch failed"));
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(mockNotificationsManager.fromBackend).toHaveBeenCalledWith("Failed to fetch team settings");
+    });
+  });
+
+  it("should handle model fetch error gracefully", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+    mockModelAvailableCall.mockRejectedValue(new Error("Model fetch failed"));
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByText("Default Team Settings")).toBeInTheDocument();
+    });
+  });
+
+  it("should disable cancel button while saving", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+    mockUpdateDefaultTeamSettings.mockImplementation(
+      () => new Promise((resolve) => setTimeout(() => resolve({ settings: mockSettings.values }), 100)),
+    );
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Edit Settings" })).toBeInTheDocument();
+    });
+
+    const editButton = screen.getByRole("button", { name: "Edit Settings" });
+    await userEvent.click(editButton);
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Save Changes" })).toBeInTheDocument();
+    });
+
+    const saveButton = screen.getByRole("button", { name: "Save Changes" });
+    await userEvent.click(saveButton);
+
+    const cancelButton = screen.getByRole("button", { name: "Cancel" });
+    expect(cancelButton).toBeDisabled();
+  });
+
+  it("should display field descriptions", async () => {
+    mockGetDefaultTeamSettings.mockResolvedValue(mockSettings);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByText("Budget duration setting")).toBeInTheDocument();
+      expect(screen.getByText("Maximum budget amount")).toBeInTheDocument();
+    });
+  });
+
+  it("should format field names by replacing underscores and capitalizing", async () => {
+    const settingsWithUnderscores = {
+      ...mockSettings,
+      field_schema: {
+        ...mockSettings.field_schema,
+        properties: {
+          ...mockSettings.field_schema.properties,
+          max_budget_per_user: {
+            type: "number",
+            description: "Max budget per user",
+          },
+        },
+      },
+      values: {
+        ...mockSettings.values,
+        max_budget_per_user: 500,
+      },
+    };
+    mockGetDefaultTeamSettings.mockResolvedValue(settingsWithUnderscores);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByText("Max Budget Per User")).toBeInTheDocument();
+    });
+  });
+
+  it("should display 'No schema information available' when schema is missing", async () => {
+    const settingsWithoutSchema = {
+      values: {},
+      field_schema: null,
+    };
+    mockGetDefaultTeamSettings.mockResolvedValue(settingsWithoutSchema);
+
+    renderWithProviders(<TeamSSOSettings {...defaultProps} />);
+
+    await waitFor(() => {
+      expect(screen.getByText("No schema information available")).toBeInTheDocument();
+    });
   });
 });
diff --git a/ui/litellm-dashboard/src/components/TeamSSOSettings.tsx b/ui/litellm-dashboard/src/components/TeamSSOSettings.tsx
index 8537b108cd..33bfc783af 100644
--- a/ui/litellm-dashboard/src/components/TeamSSOSettings.tsx
+++ b/ui/litellm-dashboard/src/components/TeamSSOSettings.tsx
@@ -5,6 +5,7 @@ import { getDefaultTeamSettings, updateDefaultTeamSettings, modelAvailableCall }
 import BudgetDurationDropdown, { getBudgetDurationLabel } from "./common_components/budget_duration_dropdown";
 import { getModelDisplayName } from "./key_team_helpers/fetch_available_models_team_key";
 import NotificationsManager from "./molecules/notifications_manager";
+import { ModelSelect } from "./ModelSelect/ModelSelect";
 
 interface TeamSSOSettingsProps {
   accessToken: string | null;
@@ -116,22 +117,15 @@ const TeamSSOSettings: React.FC<TeamSSOSettingsProps> = ({ accessToken, userID,
       );
     } else if (key === "models") {
       return (
-        <Select
-          mode="multiple"
-          style={{ width: "100%" }}
+        <ModelSelect
           value={editedValues[key] || []}
           onChange={(value) => handleTextInputChange(key, value)}
-          className="mt-2"
-        >
-          <Option key="no-default-models" value="no-default-models">
-            No Default Models
-          </Option>
-          {availableModels.map((model: string) => (
-            <Option key={model} value={model}>
-              {getModelDisplayName(model)}
-            </Option>
-          ))}
-        </Select>
+          context="global"
+          style={{ width: "100%" }}
+          options={{
+            includeSpecialOptions: true,
+          }}
+        />
       );
     } else if (type === "string" && property.enum) {
       return (

From 079f49ff6a1d28128812e0ce5929882604f7f4d9 Mon Sep 17 00:00:00 2001
From: Ishaan Jaff <ishaanjaffer0324@gmail.com>
Date: Mon, 2 Feb 2026 18:28:53 -0800
Subject: [PATCH 10/29] [Feat] - MCP Semantic Filtering Support  (#20296)

* init: SemanticMCPToolFilter

* init: SemanticToolFilterHook

* test_e2e_semantic_filter

* mock tests: test_semantic_filter_basic_filtering

* Update litellm/proxy/_experimental/mcp_server/semantic_tool_filter.py

Co-authored-by: greptile-apps[bot] <165735046+greptile-apps[bot]@users.noreply.github.com>

* refactor folder/file organization

* docs fix

* fix filter

* fix: filter_tools

* fix linting tool filrer

* initialize_from_config

* fix: _expand_mcp_tools

* _initialize_semantic_tool_filter

* working: async_post_call_response_headers_hook

* clean up semantic tool filter

* add _initialize_semantic_tool_filter

* build_router_from_mcp_registry

* _get_tools_by_names

* fiix config

* async_post_call_response_headers_hook

---------

Co-authored-by: greptile-apps[bot] <165735046+greptile-apps[bot]@users.noreply.github.com>
---
 litellm/constants.py                          |  14 +
 .../mcp_server/semantic_tool_filter.py        | 248 +++++++++++
 .../hooks/mcp_semantic_filter/ARCHITECTURE.md |  96 +++++
 .../hooks/mcp_semantic_filter/__init__.py     |   9 +
 .../proxy/hooks/mcp_semantic_filter/hook.py   | 353 ++++++++++++++++
 litellm/proxy/proxy_config.yaml               |  39 +-
 litellm/proxy/proxy_server.py                 |  43 ++
 .../test_semantic_tool_filter_e2e.py          |  74 ++++
 .../mcp_server/test_semantic_tool_filter.py   | 384 ++++++++++++++++++
 9 files changed, 1259 insertions(+), 1 deletion(-)
 create mode 100644 litellm/proxy/_experimental/mcp_server/semantic_tool_filter.py
 create mode 100644 litellm/proxy/hooks/mcp_semantic_filter/ARCHITECTURE.md
 create mode 100644 litellm/proxy/hooks/mcp_semantic_filter/__init__.py
 create mode 100644 litellm/proxy/hooks/mcp_semantic_filter/hook.py
 create mode 100644 tests/mcp_tests/test_semantic_tool_filter_e2e.py
 create mode 100644 tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py

diff --git a/litellm/constants.py b/litellm/constants.py
index 3c84547d7c..6427c36792 100644
--- a/litellm/constants.py
+++ b/litellm/constants.py
@@ -67,6 +67,20 @@ DEFAULT_REASONING_EFFORT_DISABLE_THINKING_BUDGET = int(
     os.getenv("DEFAULT_REASONING_EFFORT_DISABLE_THINKING_BUDGET", 0)
 )
 
+# MCP Semantic Tool Filter Defaults
+DEFAULT_MCP_SEMANTIC_FILTER_EMBEDDING_MODEL = str(
+    os.getenv("DEFAULT_MCP_SEMANTIC_FILTER_EMBEDDING_MODEL", "text-embedding-3-small")
+)
+DEFAULT_MCP_SEMANTIC_FILTER_TOP_K = int(
+    os.getenv("DEFAULT_MCP_SEMANTIC_FILTER_TOP_K", 10)
+)
+DEFAULT_MCP_SEMANTIC_FILTER_SIMILARITY_THRESHOLD = float(
+    os.getenv("DEFAULT_MCP_SEMANTIC_FILTER_SIMILARITY_THRESHOLD", 0.3)
+)
+MAX_MCP_SEMANTIC_FILTER_TOOLS_HEADER_LENGTH = int(
+    os.getenv("MAX_MCP_SEMANTIC_FILTER_TOOLS_HEADER_LENGTH", 150)
+)
+
 # Gemini model-specific minimal thinking budget constants
 DEFAULT_REASONING_EFFORT_MINIMAL_THINKING_BUDGET_GEMINI_2_5_FLASH = int(
     os.getenv("DEFAULT_REASONING_EFFORT_MINIMAL_THINKING_BUDGET_GEMINI_2_5_FLASH", 1)
diff --git a/litellm/proxy/_experimental/mcp_server/semantic_tool_filter.py b/litellm/proxy/_experimental/mcp_server/semantic_tool_filter.py
new file mode 100644
index 0000000000..c83ef13a64
--- /dev/null
+++ b/litellm/proxy/_experimental/mcp_server/semantic_tool_filter.py
@@ -0,0 +1,248 @@
+"""
+Semantic MCP Tool Filtering using semantic-router
+
+Filters MCP tools semantically for /chat/completions and /responses endpoints.
+"""
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from litellm._logging import verbose_logger
+
+if TYPE_CHECKING:
+    from mcp.types import Tool as MCPTool
+    from semantic_router.routers import SemanticRouter
+
+    from litellm.router import Router
+
+
+class SemanticMCPToolFilter:
+    """Filters MCP tools using semantic similarity to reduce context window size."""
+
+    def __init__(
+        self,
+        embedding_model: str,
+        litellm_router_instance: "Router",
+        top_k: int = 10,
+        similarity_threshold: float = 0.3,
+        enabled: bool = True,
+    ):
+        """
+        Initialize the semantic tool filter.
+
+        Args:
+            embedding_model: Model to use for embeddings (e.g., "text-embedding-3-small")
+            litellm_router_instance: Router instance for embedding generation
+            top_k: Maximum number of tools to return
+            similarity_threshold: Minimum similarity score for filtering
+            enabled: Whether filtering is enabled
+        """
+        self.enabled = enabled
+        self.top_k = top_k
+        self.similarity_threshold = similarity_threshold
+        self.embedding_model = embedding_model
+        self.router_instance = litellm_router_instance
+        self.tool_router: Optional["SemanticRouter"] = None
+        self._tool_map: Dict[str, Any] = {}  # MCPTool objects or OpenAI function dicts
+
+    async def build_router_from_mcp_registry(self) -> None:
+        """Build semantic router from all MCP tools in the registry (no auth checks)."""
+        from litellm.proxy._experimental.mcp_server.mcp_server_manager import (
+            global_mcp_server_manager,
+        )
+
+        try:
+            # Get all servers from registry without auth checks
+            registry = global_mcp_server_manager.get_registry()
+            if not registry:
+                verbose_logger.warning("MCP registry is empty")
+                self.tool_router = None
+                return
+
+            # Fetch tools from all servers in parallel
+            all_tools = []
+            for server_id, server in registry.items():
+                try:
+                    tools = await global_mcp_server_manager.get_tools_for_server(server_id)
+                    all_tools.extend(tools)
+                except Exception as e:
+                    verbose_logger.warning(f"Failed to fetch tools from server {server_id}: {e}")
+                    continue
+
+            if not all_tools:
+                verbose_logger.warning("No MCP tools found in registry")
+                self.tool_router = None
+                return
+
+            verbose_logger.info(f"Fetched {len(all_tools)} tools from {len(registry)} MCP servers")
+            self._build_router(all_tools)
+
+        except Exception as e:
+            verbose_logger.error(f"Failed to build router from MCP registry: {e}")
+            self.tool_router = None
+            raise
+
+    def _extract_tool_info(self, tool) -> tuple[str, str]:
+        """Extract name and description from MCP tool or OpenAI function dict."""
+        if isinstance(tool, dict):
+            # OpenAI function format
+            name = tool.get("name", "")
+            description = tool.get("description", name)
+        else:
+            # MCPTool object
+            name = tool.name
+            description = tool.description or tool.name
+        
+        return name, description
+
+    def _build_router(self, tools: List) -> None:
+        """Build semantic router with tools (MCPTool objects or OpenAI function dicts)."""
+        from semantic_router.routers import SemanticRouter
+        from semantic_router.routers.base import Route
+
+        from litellm.router_strategy.auto_router.litellm_encoder import (
+            LiteLLMRouterEncoder,
+        )
+
+        if not tools:
+            self.tool_router = None
+            return
+
+        try:
+            # Convert tools to routes
+            routes = []
+            self._tool_map = {}
+
+            for tool in tools:
+                name, description = self._extract_tool_info(tool)
+                self._tool_map[name] = tool
+
+                routes.append(
+                    Route(
+                        name=name,
+                        description=description,
+                        utterances=[description],
+                        score_threshold=self.similarity_threshold,
+                    )
+                )
+
+            self.tool_router = SemanticRouter(
+                routes=routes,
+                encoder=LiteLLMRouterEncoder(
+                    litellm_router_instance=self.router_instance,
+                    model_name=self.embedding_model,
+                    score_threshold=self.similarity_threshold,
+                ),
+                auto_sync="local",
+            )
+
+            verbose_logger.info(
+                f"Built semantic router with {len(routes)} tools"
+            )
+
+        except Exception as e:
+            verbose_logger.error(f"Failed to build semantic router: {e}")
+            self.tool_router = None
+            raise
+
+    async def filter_tools(
+        self,
+        query: str,
+        available_tools: List[Any],
+        top_k: Optional[int] = None,
+    ) -> List[Any]:
+        """
+        Filter tools semantically based on query.
+
+        Args:
+            query: User query to match against tools
+            available_tools: Full list of available MCP tools
+            top_k: Override default top_k (optional)
+
+        Returns:
+            Filtered and ordered list of tools (up to top_k)
+        """
+        # Early returns for cases where we can't/shouldn't filter
+        if not self.enabled:
+            return available_tools
+            
+        if not available_tools:
+            return available_tools
+            
+        if not query or not query.strip():
+            return available_tools
+
+        # Router should be built on startup - if not, something went wrong
+        if self.tool_router is None:
+            verbose_logger.warning("Router not initialized - was build_router_from_mcp_registry() called on startup?")
+            return available_tools
+
+        # Run semantic filtering
+        try:
+            limit = top_k or self.top_k
+            matches = self.tool_router(text=query, limit=limit)
+            matched_tool_names = self._extract_tool_names_from_matches(matches)
+            
+            if not matched_tool_names:
+                return available_tools
+            
+            return self._get_tools_by_names(matched_tool_names, available_tools)
+
+        except Exception as e:
+            verbose_logger.error(f"Semantic tool filter failed: {e}", exc_info=True)
+            return available_tools
+
+    def _extract_tool_names_from_matches(self, matches) -> List[str]:
+        """Extract tool names from semantic router match results."""
+        if not matches:
+            return []
+        
+        # Handle single match
+        if hasattr(matches, "name") and matches.name:
+            return [matches.name]
+        
+        # Handle list of matches
+        if isinstance(matches, list):
+            return [m.name for m in matches if hasattr(m, "name") and m.name]
+        
+        return []
+
+    def _get_tools_by_names(
+        self, tool_names: List[str], available_tools: List[Any]
+    ) -> List[Any]:
+        """Get tools from available_tools by their names, preserving order."""
+        # Match tools from available_tools (preserves format - dict or MCPTool)
+        matched_tools = []
+        for tool in available_tools:
+            tool_name, _ = self._extract_tool_info(tool)
+            if tool_name in tool_names:
+                matched_tools.append(tool)
+        
+        # Reorder to match semantic router's ordering
+        tool_map = {self._extract_tool_info(t)[0]: t for t in matched_tools}
+        return [tool_map[name] for name in tool_names if name in tool_map]
+
+    def extract_user_query(self, messages: List[Dict[str, Any]]) -> str:
+        """
+        Extract user query from messages for /chat/completions or /responses.
+
+        Args:
+            messages: List of message dictionaries (from 'messages' or 'input' field)
+
+        Returns:
+            Extracted query string
+        """
+        for msg in reversed(messages):
+            if msg.get("role") == "user":
+                content = msg.get("content", "")
+
+                if isinstance(content, str):
+                    return content
+
+                if isinstance(content, list):
+                    texts = [
+                        block.get("text", "") if isinstance(block, dict) else str(block)
+                        for block in content
+                        if isinstance(block, (dict, str))
+                    ]
+                    return " ".join(texts)
+
+        return ""
diff --git a/litellm/proxy/hooks/mcp_semantic_filter/ARCHITECTURE.md b/litellm/proxy/hooks/mcp_semantic_filter/ARCHITECTURE.md
new file mode 100644
index 0000000000..f2f9a1d485
--- /dev/null
+++ b/litellm/proxy/hooks/mcp_semantic_filter/ARCHITECTURE.md
@@ -0,0 +1,96 @@
+# MCP Semantic Tool Filter Architecture
+
+## Why Filter MCP Tools
+
+When multiple MCP servers are connected, the proxy may expose hundreds of tools. Sending all tools in every request wastes context window tokens and increases cost. The semantic filter keeps only the top-K most relevant tools based on embedding similarity.
+
+```mermaid
+sequenceDiagram
+    participant Client
+    participant Hook as SemanticToolFilterHook
+    participant Filter as SemanticMCPToolFilter
+    participant Router as semantic-router
+    participant LLM
+
+    Client->>Hook: POST /chat/completions
+    Note over Client,Hook: tools: [100+ MCP tools]
+    Note over Client,Hook: messages: [{"role": "user", "content": "Get my Jira issues"}]
+    
+    rect rgb(240, 240, 240)
+        Note over Hook: 1. Extract User Query
+        Hook->>Filter: filter_tools("Get my Jira issues", tools)
+    end
+    
+    rect rgb(240, 240, 240)
+        Note over Filter: 2. Convert Tools → Routes
+        Note over Filter: Tool name + description → Route
+    end
+    
+    rect rgb(240, 240, 240)
+        Note over Filter: 3. Semantic Matching
+        Filter->>Router: router(query)
+        Router->>Router: Embeddings + similarity
+        Router-->>Filter: [top 10 matches]
+    end
+    
+    rect rgb(240, 240, 240)
+        Note over Filter: 4. Return Filtered Tools
+        Filter-->>Hook: [10 relevant tools]
+    end
+    
+    Hook->>LLM: POST /chat/completions
+    Note over Hook,LLM: tools: [10 Jira-related tools] ← FILTERED
+    Note over Hook,LLM: messages: [...] ← UNCHANGED
+    
+    LLM-->>Client: Response (unchanged)
+```
+
+## Filter Operations
+
+The hook intercepts requests before they reach the LLM:
+
+| Operation | Description |
+|-----------|-------------|
+| **Extract query** | Get user message from `messages[-1]` |
+| **Convert to Routes** | Transform MCP tools into semantic-router Routes |
+| **Semantic match** | Use `semantic-router` to find top-K similar tools |
+| **Filter tools** | Replace request `tools` with filtered subset |
+
+## Trigger Conditions
+
+The filter only runs when:
+- Call type is `completion` or `acompletion`
+- Request contains `tools` field
+- Request contains `messages` field
+- Filter is enabled in config
+
+## What Does NOT Change
+
+- Request messages
+- Response body
+- Non-tool parameters
+
+## Integration with semantic-router
+
+Reuses existing LiteLLM infrastructure:
+- `semantic-router` - Already an optional dependency
+- `LiteLLMRouterEncoder` - Wraps `Router.aembedding()` for embeddings
+- `SemanticRouter` - Handles similarity calculation and top-K selection
+
+## Configuration
+
+```yaml
+litellm_settings:
+  mcp_semantic_tool_filter:
+    enabled: true
+    embedding_model: "openai/text-embedding-3-small"
+    top_k: 10
+    similarity_threshold: 0.3
+```
+
+## Error Handling
+
+The filter fails gracefully:
+- If filtering fails → Return all tools (no impact on functionality)
+- If query extraction fails → Skip filtering
+- If no matches found → Return all tools
diff --git a/litellm/proxy/hooks/mcp_semantic_filter/__init__.py b/litellm/proxy/hooks/mcp_semantic_filter/__init__.py
new file mode 100644
index 0000000000..36d357d560
--- /dev/null
+++ b/litellm/proxy/hooks/mcp_semantic_filter/__init__.py
@@ -0,0 +1,9 @@
+"""
+MCP Semantic Tool Filter Hook
+
+Semantic filtering for MCP tools to reduce context window size
+and improve tool selection accuracy.
+"""
+from litellm.proxy.hooks.mcp_semantic_filter.hook import SemanticToolFilterHook
+
+__all__ = ["SemanticToolFilterHook"]
diff --git a/litellm/proxy/hooks/mcp_semantic_filter/hook.py b/litellm/proxy/hooks/mcp_semantic_filter/hook.py
new file mode 100644
index 0000000000..fc9349c2a4
--- /dev/null
+++ b/litellm/proxy/hooks/mcp_semantic_filter/hook.py
@@ -0,0 +1,353 @@
+"""
+Semantic Tool Filter Hook
+
+Pre-call hook that filters MCP tools semantically before LLM inference.
+Reduces context window size and improves tool selection accuracy.
+"""
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+
+from litellm._logging import verbose_proxy_logger
+from litellm.constants import (
+    DEFAULT_MCP_SEMANTIC_FILTER_EMBEDDING_MODEL,
+    DEFAULT_MCP_SEMANTIC_FILTER_SIMILARITY_THRESHOLD,
+    DEFAULT_MCP_SEMANTIC_FILTER_TOP_K,
+)
+from litellm.integrations.custom_logger import CustomLogger
+
+if TYPE_CHECKING:
+    from litellm.caching.caching import DualCache
+    from litellm.proxy._experimental.mcp_server.semantic_tool_filter import (
+        SemanticMCPToolFilter,
+    )
+    from litellm.proxy._types import UserAPIKeyAuth
+    from litellm.router import Router
+
+
+class SemanticToolFilterHook(CustomLogger):
+    """
+    Pre-call hook that filters MCP tools semantically.
+    
+    This hook:
+    1. Extracts the user query from messages
+    2. Filters tools based on semantic similarity to the query
+    3. Returns only the top-k most relevant tools to the LLM
+    """
+    
+    def __init__(self, semantic_filter: "SemanticMCPToolFilter"):
+        """
+        Initialize the hook.
+        
+        Args:
+            semantic_filter: SemanticMCPToolFilter instance
+        """
+        super().__init__()
+        self.filter = semantic_filter
+        
+        verbose_proxy_logger.debug(
+            f"Initialized SemanticToolFilterHook with filter: "
+            f"enabled={semantic_filter.enabled}, top_k={semantic_filter.top_k}"
+        )
+    
+    def _should_expand_mcp_tools(self, tools: List[Any]) -> bool:
+        """
+        Check if tools contain MCP references with server_url="litellm_proxy".
+        
+        Only expands MCP tools pointing to litellm proxy, not external MCP servers.
+        """
+        from litellm.responses.mcp.litellm_proxy_mcp_handler import (
+            LiteLLM_Proxy_MCP_Handler,
+        )
+        
+        return LiteLLM_Proxy_MCP_Handler._should_use_litellm_mcp_gateway(tools)
+    
+    async def _expand_mcp_tools(
+        self,
+        tools: List[Any],
+        user_api_key_dict: "UserAPIKeyAuth",
+    ) -> List[Dict[str, Any]]:
+        """
+        Expand MCP references to actual tool definitions.
+        
+        Reuses LiteLLM_Proxy_MCP_Handler._process_mcp_tools_to_openai_format
+        which internally does: parse -> fetch -> filter -> deduplicate -> transform
+        """
+        from litellm.responses.mcp.litellm_proxy_mcp_handler import (
+            LiteLLM_Proxy_MCP_Handler,
+        )
+
+        # Parse to separate MCP tools from other tools
+        mcp_tools, _ = LiteLLM_Proxy_MCP_Handler._parse_mcp_tools(tools)
+        
+        if not mcp_tools:
+            return []
+        
+        # Use single combined method instead of 3 separate calls
+        # This already handles: fetch -> filter by allowed_tools -> deduplicate -> transform
+        openai_tools, _ = await LiteLLM_Proxy_MCP_Handler._process_mcp_tools_to_openai_format(
+            user_api_key_auth=user_api_key_dict,
+            mcp_tools_with_litellm_proxy=mcp_tools
+        )
+        
+        # Convert Pydantic models to dicts for compatibility
+        openai_tools_as_dicts = []
+        for tool in openai_tools:
+            if hasattr(tool, "model_dump"):
+                tool_dict = tool.model_dump(exclude_none=True)
+                verbose_proxy_logger.debug(f"Converted Pydantic tool to dict: {type(tool).__name__} -> dict with keys: {list(tool_dict.keys())}")
+                openai_tools_as_dicts.append(tool_dict)
+            elif hasattr(tool, "dict"):
+                tool_dict = tool.dict(exclude_none=True)
+                verbose_proxy_logger.debug(f"Converted Pydantic tool (v1) to dict: {type(tool).__name__} -> dict")
+                openai_tools_as_dicts.append(tool_dict)
+            elif isinstance(tool, dict):
+                verbose_proxy_logger.debug(f"Tool is already a dict with keys: {list(tool.keys())}")
+                openai_tools_as_dicts.append(tool)
+            else:
+                verbose_proxy_logger.warning(f"Tool is unknown type: {type(tool)}, passing as-is")
+                openai_tools_as_dicts.append(tool)
+        
+        verbose_proxy_logger.debug(
+            f"Expanded {len(mcp_tools)} MCP reference(s) to {len(openai_tools_as_dicts)} tools (all as dicts)"
+        )
+        
+        return openai_tools_as_dicts
+    
+    def _get_metadata_variable_name(self, data: dict) -> str:
+        if "litellm_metadata" in data:
+            return "litellm_metadata"
+        return "metadata"
+    
+    async def async_pre_call_hook(
+        self,
+        user_api_key_dict: "UserAPIKeyAuth",
+        cache: "DualCache",
+        data: dict,
+        call_type: str,
+    ) -> Optional[Union[Exception, str, dict]]:
+        """
+        Filter tools before LLM call based on user query.
+        
+        This hook is called before the LLM request is made. It filters the
+        tools list to only include semantically relevant tools.
+        
+        Args:
+            user_api_key_dict: User authentication
+            cache: Cache instance
+            data: Request data containing messages and tools
+            call_type: Type of call (completion, acompletion, etc.)
+            
+        Returns:
+            Modified data dict with filtered tools, or None if no changes
+        """
+        # Only filter endpoints that support tools
+        if call_type not in ("completion", "acompletion", "aresponses"):
+            verbose_proxy_logger.debug(
+                f"Skipping semantic filter for call_type={call_type}"
+            )
+            return None
+        
+        # Check if tools are present
+        tools = data.get("tools")
+        if not tools:
+            verbose_proxy_logger.debug("No tools in request, skipping semantic filter")
+            return None
+        
+        original_tool_count = len(tools)
+        
+        # Check for MCP references (server_url="litellm_proxy") and expand them
+        if self._should_expand_mcp_tools(tools):
+            verbose_proxy_logger.debug(
+                "Detected litellm_proxy MCP references, expanding before semantic filtering"
+            )
+            
+            try:
+                expanded_tools = await self._expand_mcp_tools(
+                    tools, user_api_key_dict
+                )
+                
+                if not expanded_tools:
+                    verbose_proxy_logger.warning(
+                        "No tools expanded from MCP references"
+                    )
+                    return None
+                
+                verbose_proxy_logger.info(
+                    f"Expanded {len(tools)} MCP reference(s) to {len(expanded_tools)} tools"
+                )
+                
+                # Update tools for filtering
+                tools = expanded_tools
+                original_tool_count = len(tools)
+                
+            except Exception as e:
+                verbose_proxy_logger.error(
+                    f"Failed to expand MCP references: {e}", exc_info=True
+                )
+                return None
+        
+        # Check if messages are present (try both "messages" and "input" for responses API)
+        messages = data.get("messages", [])
+        if not messages:
+            messages = data.get("input", [])
+        if not messages:
+            verbose_proxy_logger.debug("No messages in request, skipping semantic filter")
+            return None
+        
+        # Check if filter is enabled
+        if not self.filter.enabled:
+            verbose_proxy_logger.debug("Semantic filter disabled, skipping")
+            return None
+        
+        try:
+            # Extract user query from messages
+            user_query = self.filter.extract_user_query(messages)
+            if not user_query:
+                verbose_proxy_logger.debug("No user query found, skipping semantic filter")
+                return None
+            
+            verbose_proxy_logger.debug(
+                f"Applying semantic filter to {len(tools)} tools "
+                f"with query: '{user_query[:50]}...'"
+            )
+            
+            # Filter tools semantically
+            filtered_tools = await self.filter.filter_tools(
+                query=user_query,
+                available_tools=tools,  # type: ignore
+            )
+            
+            # Always update tools and emit header (even if count unchanged)
+            data["tools"] = filtered_tools
+            
+            # Store filter stats and tool names for response header
+            filter_stats = f"{original_tool_count}->{len(filtered_tools)}"
+            tool_names_csv = self._get_tool_names_csv(filtered_tools)
+            
+            _metadata_variable_name = self._get_metadata_variable_name(data)
+            data[_metadata_variable_name]["litellm_semantic_filter_stats"] = filter_stats
+            data[_metadata_variable_name]["litellm_semantic_filter_tools"] = tool_names_csv
+            
+            verbose_proxy_logger.info(
+                f"Semantic tool filter: {filter_stats} tools"
+            )
+            
+            return data
+            
+        except Exception as e:
+            verbose_proxy_logger.warning(
+                f"Semantic tool filter hook failed: {e}. Proceeding with all tools."
+            )
+            return None
+    
+    async def async_post_call_response_headers_hook(
+        self,
+        data: dict,
+        user_api_key_dict: "UserAPIKeyAuth",
+        response: Any,
+        request_headers: Optional[Dict[str, str]] = None,
+    ) -> Optional[Dict[str, str]]:
+        """Add semantic filter stats and tool names to response headers."""
+        from litellm.constants import MAX_MCP_SEMANTIC_FILTER_TOOLS_HEADER_LENGTH
+        
+        _metadata_variable_name = self._get_metadata_variable_name(data)
+        metadata = data[_metadata_variable_name]
+        
+        filter_stats = metadata.get("litellm_semantic_filter_stats")
+        if not filter_stats:
+            return None
+        
+        headers = {"x-litellm-semantic-filter": filter_stats}
+        
+        # Add CSV of filtered tool names (nginx-safe length)
+        tool_names_csv = metadata.get("litellm_semantic_filter_tools", "")
+        if tool_names_csv:
+            if len(tool_names_csv) > MAX_MCP_SEMANTIC_FILTER_TOOLS_HEADER_LENGTH:
+                tool_names_csv = tool_names_csv[:MAX_MCP_SEMANTIC_FILTER_TOOLS_HEADER_LENGTH - 3] + "..."
+            
+            headers["x-litellm-semantic-filter-tools"] = tool_names_csv
+        
+        return headers
+    
+    def _get_tool_names_csv(self, tools: List[Any]) -> str:
+        """Extract tool names and return as CSV string."""
+        if not tools:
+            return ""
+        
+        tool_names = []
+        for tool in tools:
+            name = tool.get("name", "") if isinstance(tool, dict) else getattr(tool, "name", "")
+            if name:
+                tool_names.append(name)
+        
+        return ",".join(tool_names)
+    
+    @staticmethod
+    async def initialize_from_config(
+        config: Optional[Dict[str, Any]],
+        llm_router: Optional["Router"],
+    ) -> Optional["SemanticToolFilterHook"]:
+        """
+        Initialize semantic tool filter from proxy config.
+        
+        Args:
+            config: Proxy configuration dict (litellm_settings.mcp_semantic_tool_filter)
+            llm_router: LiteLLM router instance for embeddings
+            
+        Returns:
+            SemanticToolFilterHook instance if enabled, None otherwise
+        """
+        from litellm.proxy._experimental.mcp_server.semantic_tool_filter import (
+            SemanticMCPToolFilter,
+        )
+        if not config or not config.get("enabled", False):
+            verbose_proxy_logger.debug("Semantic tool filter not enabled in config")
+            return None
+        
+        if llm_router is None:
+            verbose_proxy_logger.warning(
+                "Cannot initialize semantic filter: llm_router is None"
+            )
+            return None
+        
+        try:
+            
+            embedding_model = config.get(
+                "embedding_model", DEFAULT_MCP_SEMANTIC_FILTER_EMBEDDING_MODEL
+            )
+            top_k = config.get("top_k", DEFAULT_MCP_SEMANTIC_FILTER_TOP_K)
+            similarity_threshold = config.get(
+                "similarity_threshold", DEFAULT_MCP_SEMANTIC_FILTER_SIMILARITY_THRESHOLD
+            )
+            
+            semantic_filter = SemanticMCPToolFilter(
+                embedding_model=embedding_model,
+                litellm_router_instance=llm_router,
+                top_k=top_k,
+                similarity_threshold=similarity_threshold,
+                enabled=True,
+            )
+            
+            # Build router from MCP registry on startup
+            await semantic_filter.build_router_from_mcp_registry()
+            
+            hook = SemanticToolFilterHook(semantic_filter)
+            
+            verbose_proxy_logger.info(
+                f"✅ MCP Semantic Tool Filter enabled: "
+                f"embedding_model={embedding_model}, top_k={top_k}, "
+                f"similarity_threshold={similarity_threshold}"
+            )
+            
+            return hook
+            
+        except ImportError as e:
+            verbose_proxy_logger.warning(
+                f"semantic-router not installed. Install with: "
+                f"pip install 'litellm[semantic-router]'. Error: {e}"
+            )
+            return None
+        except Exception as e:
+            verbose_proxy_logger.exception(
+                f"Failed to initialize MCP semantic tool filter: {e}"
+            )
+            return None
diff --git a/litellm/proxy/proxy_config.yaml b/litellm/proxy/proxy_config.yaml
index e12e75b54f..d87ae8b14c 100644
--- a/litellm/proxy/proxy_config.yaml
+++ b/litellm/proxy/proxy_config.yaml
@@ -1,4 +1,14 @@
 model_list:
+  - model_name: gpt-4o
+    litellm_params:
+      model: openai/gpt-4o
+      api_key: os.environ/OPENAI_API_KEY
+
+  - model_name: text-embedding-3-small
+    litellm_params:
+      model: openai/text-embedding-3-small
+      api_key: os.environ/OPENAI_API_KEY
+
   - model_name: bedrock-claude-sonnet-3.5
     litellm_params:
       model: "bedrock/us.anthropic.claude-3-5-sonnet-20240620-v1:0"
@@ -22,4 +32,31 @@ model_list:
   - model_name: bedrock-nova-premier
     litellm_params:
       model: "bedrock/us.amazon.nova-premier-v1:0"
-      aws_region_name: "us-east-1"   
\ No newline at end of file
+      aws_region_name: "us-east-1"
+
+# MCP Server Configuration
+mcp_servers:
+  # Wikipedia MCP - reliable and works without external deps
+  wikipedia:
+    transport: "stdio"
+    command: "uvx"
+    args: ["mcp-server-fetch"]
+    description: "Fetch web pages and Wikipedia content"
+  deepwiki:
+    transport: "http"
+    url: "https://mcp.deepwiki.com/mcp"
+
+# General Settings
+general_settings:
+  master_key: sk-1234
+  store_model_in_db: false
+
+# LiteLLM Settings
+litellm_settings:
+  # Enable MCP Semantic Tool Filter
+  mcp_semantic_tool_filter:
+    enabled: true
+    embedding_model: "text-embedding-3-small"
+    top_k: 5
+    similarity_threshold: 0.3
+  
diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py
index 59e5fdc56a..8f433bfa48 100644
--- a/litellm/proxy/proxy_server.py
+++ b/litellm/proxy/proxy_server.py
@@ -793,6 +793,21 @@ async def proxy_startup_event(app: FastAPI):  # noqa: PLR0915
         redis_usage_cache=redis_usage_cache,
     )
 
+    ## SEMANTIC TOOL FILTER ##
+    # Read litellm_settings from config for semantic filter initialization
+    try:
+        verbose_proxy_logger.debug("About to initialize semantic tool filter")
+        _config = proxy_config.get_config_state()
+        _litellm_settings = _config.get("litellm_settings", {})
+        verbose_proxy_logger.debug(f"litellm_settings keys = {list(_litellm_settings.keys())}")
+        await ProxyStartupEvent._initialize_semantic_tool_filter(
+            llm_router=llm_router,
+            litellm_settings=_litellm_settings,
+        )
+        verbose_proxy_logger.debug("After semantic tool filter initialization")
+    except Exception as e:
+        verbose_proxy_logger.error(f"Semantic filter init failed: {e}", exc_info=True)
+
     ## JWT AUTH ##
     ProxyStartupEvent._initialize_jwt_auth(
         general_settings=general_settings,
@@ -4742,6 +4757,34 @@ class ProxyStartupEvent:
             llm_router=llm_router, redis_usage_cache=redis_usage_cache
         )
 
+    @classmethod
+    async def _initialize_semantic_tool_filter(
+        cls,
+        llm_router: Optional[Router],
+        litellm_settings: Dict[str, Any],
+    ):
+        """Initialize MCP semantic tool filter if configured"""
+        from litellm.proxy.hooks.mcp_semantic_filter import SemanticToolFilterHook
+        
+        verbose_proxy_logger.info(
+            f"Initializing semantic tool filter: llm_router={llm_router is not None}, "
+            f"litellm_settings keys={list(litellm_settings.keys())}"
+        )
+        
+        mcp_semantic_filter_config = litellm_settings.get("mcp_semantic_tool_filter", None)
+        verbose_proxy_logger.debug(f"Semantic filter config: {mcp_semantic_filter_config}")
+        
+        hook = await SemanticToolFilterHook.initialize_from_config(
+            config=mcp_semantic_filter_config,
+            llm_router=llm_router,
+        )
+        
+        if hook:
+            verbose_proxy_logger.debug("✅ Semantic tool filter hook registered")
+            litellm.logging_callback_manager.add_litellm_callback(hook)
+        else:
+            verbose_proxy_logger.warning("❌ Semantic tool filter hook not initialized")
+
     @classmethod
     def _initialize_jwt_auth(
         cls,
diff --git a/tests/mcp_tests/test_semantic_tool_filter_e2e.py b/tests/mcp_tests/test_semantic_tool_filter_e2e.py
new file mode 100644
index 0000000000..cf951c1884
--- /dev/null
+++ b/tests/mcp_tests/test_semantic_tool_filter_e2e.py
@@ -0,0 +1,74 @@
+"""
+End-to-end test for MCP Semantic Tool Filtering
+"""
+import asyncio
+import os
+import sys
+from unittest.mock import Mock
+
+import pytest
+
+sys.path.insert(0, os.path.abspath("../.."))
+
+from mcp.types import Tool as MCPTool
+
+
+@pytest.mark.asyncio
+async def test_e2e_semantic_filter():
+    """E2E: Load router/filter and verify hook filters tools."""
+    from litellm import Router
+    from litellm.proxy.hooks.mcp_semantic_filter import SemanticToolFilterHook
+    from litellm.proxy._experimental.mcp_server.semantic_tool_filter import (
+        SemanticMCPToolFilter,
+    )
+    
+    # Create router and filter
+    router = Router(
+        model_list=[{
+            "model_name": "text-embedding-3-small",
+            "litellm_params": {"model": "openai/text-embedding-3-small"},
+        }]
+    )
+    
+    filter_instance = SemanticMCPToolFilter(
+        embedding_model="text-embedding-3-small",
+        litellm_router_instance=router,
+        top_k=3,
+        enabled=True,
+    )
+    
+    hook = SemanticToolFilterHook(filter_instance)
+    
+    # Create 10 tools
+    tools = [
+        MCPTool(name="gmail_send", description="Send an email via Gmail", inputSchema={"type": "object"}),
+        MCPTool(name="calendar_create", description="Create a calendar event", inputSchema={"type": "object"}),
+        MCPTool(name="file_upload", description="Upload a file", inputSchema={"type": "object"}),
+        MCPTool(name="web_search", description="Search the web", inputSchema={"type": "object"}),
+        MCPTool(name="slack_send", description="Send Slack message", inputSchema={"type": "object"}),
+        MCPTool(name="doc_read", description="Read document", inputSchema={"type": "object"}),
+        MCPTool(name="db_query", description="Query database", inputSchema={"type": "object"}),
+        MCPTool(name="api_call", description="Make API call", inputSchema={"type": "object"}),
+        MCPTool(name="task_create", description="Create task", inputSchema={"type": "object"}),
+        MCPTool(name="note_add", description="Add note", inputSchema={"type": "object"}),
+    ]
+    
+    data = {
+        "model": "gpt-4",
+        "messages": [{"role": "user", "content": "Send an email and create a calendar event"}],
+        "tools": tools,
+    }
+    
+    # Call hook
+    result = await hook.async_pre_call_hook(
+        user_api_key_dict=Mock(),
+        cache=Mock(),
+        data=data,
+        call_type="completion",
+    )
+
+    # Single assertion: hook filtered tools
+    assert result and len(result["tools"]) < len(tools), f"Expected filtered tools, got {len(result['tools'])} tools (original: {len(tools)})"
+    
+    print(f"✅ E2E test passed: Filtering reduced tools from {len(tools)} to {len(result['tools'])}")
+    print(f"   Filtered tools: {[t.name for t in result['tools']]}")
diff --git a/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py b/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py
new file mode 100644
index 0000000000..8d35f5bbdc
--- /dev/null
+++ b/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py
@@ -0,0 +1,384 @@
+"""
+Unit tests for MCP Semantic Tool Filtering
+
+Tests the core filtering logic that takes a long list of tools and returns
+an ordered set of top K tools based on semantic similarity.
+"""
+import asyncio
+import os
+import sys
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+
+sys.path.insert(0, os.path.abspath("../.."))
+
+from mcp.types import Tool as MCPTool
+
+
+@pytest.mark.asyncio
+async def test_semantic_filter_basic_filtering():
+    """
+    Test that the semantic filter correctly filters tools based on query.
+    
+    Given: 10 email/calendar tools
+    When: Query is "send an email"
+    Then: Email tools should rank higher than calendar tools
+    """
+    from litellm.proxy._experimental.mcp_server.semantic_tool_filter import (
+        SemanticMCPToolFilter,
+    )
+
+    # Create mock tools - mix of email and calendar tools
+    tools = [
+        MCPTool(name="gmail_send", description="Send an email via Gmail", inputSchema={"type": "object"}),
+        MCPTool(name="outlook_send", description="Send an email via Outlook", inputSchema={"type": "object"}),
+        MCPTool(name="calendar_create", description="Create a calendar event", inputSchema={"type": "object"}),
+        MCPTool(name="calendar_update", description="Update a calendar event", inputSchema={"type": "object"}),
+        MCPTool(name="email_read", description="Read emails from inbox", inputSchema={"type": "object"}),
+        MCPTool(name="email_delete", description="Delete an email", inputSchema={"type": "object"}),
+        MCPTool(name="calendar_delete", description="Delete a calendar event", inputSchema={"type": "object"}),
+        MCPTool(name="email_search", description="Search for emails", inputSchema={"type": "object"}),
+        MCPTool(name="calendar_list", description="List calendar events", inputSchema={"type": "object"}),
+        MCPTool(name="email_forward", description="Forward an email to someone", inputSchema={"type": "object"}),
+    ]
+    
+    # Mock router that returns mock embeddings
+    from litellm.types.utils import Embedding, EmbeddingResponse
+    
+    mock_router = Mock()
+    
+    def mock_embedding_sync(*args, **kwargs):
+        return EmbeddingResponse(
+            data=[Embedding(embedding=[0.1] * 1536, index=0, object="embedding")],
+            model="text-embedding-3-small",
+            object="list",
+            usage={"prompt_tokens": 10, "total_tokens": 10}
+        )
+    
+    async def mock_embedding_async(*args, **kwargs):
+        return mock_embedding_sync()
+    
+    mock_router.embedding = mock_embedding_sync
+    mock_router.aembedding = mock_embedding_async
+    
+    # Create filter
+    filter_instance = SemanticMCPToolFilter(
+        embedding_model="text-embedding-3-small",
+        litellm_router_instance=mock_router,
+        top_k=3,
+        similarity_threshold=0.3,
+        enabled=True,
+    )
+    
+    # Filter tools with email-related query
+    filtered = await filter_instance.filter_tools(
+        query="send an email to john@example.com",
+        available_tools=tools,
+    )
+    
+    # Assertions - validate filtering mechanics work
+    assert len(filtered) <= 3, f"Should return at most 3 tools (top_k), got {len(filtered)}"
+    assert len(filtered) > 0, "Should return at least some tools"
+    assert len(filtered) < len(tools), f"Should filter down from {len(tools)} tools, got {len(filtered)}"
+    
+    # Validate tools are actual MCPTool objects
+    for tool in filtered:
+        assert hasattr(tool, 'name'), "Filtered result should be MCPTool with name"
+        assert hasattr(tool, 'description'), "Filtered result should be MCPTool with description"
+    
+    filtered_names = [t.name for t in filtered]
+    print(f"✅ Successfully filtered {len(tools)} tools down to top {len(filtered)}: {filtered_names}")
+    print(f"   Filter respects top_k parameter correctly")
+
+
+@pytest.mark.asyncio
+async def test_semantic_filter_top_k_limiting():
+    """
+    Test that the filter respects top_k parameter.
+    
+    Given: 20 tools
+    When: top_k=5
+    Then: Should return at most 5 tools
+    """
+    from litellm.proxy._experimental.mcp_server.semantic_tool_filter import (
+        SemanticMCPToolFilter,
+    )
+
+    # Create 20 tools
+    tools = [
+        MCPTool(name=f"tool_{i}", description=f"Tool number {i} for testing", inputSchema={"type": "object"})
+        for i in range(20)
+    ]
+    
+    # Mock router
+    from litellm.types.utils import Embedding, EmbeddingResponse
+    
+    mock_router = Mock()
+    
+    def mock_embedding_sync(*args, **kwargs):
+        return EmbeddingResponse(
+            data=[Embedding(embedding=[0.1] * 1536, index=0, object="embedding")],
+            model="text-embedding-3-small",
+            object="list",
+            usage={"prompt_tokens": 10, "total_tokens": 10}
+        )
+    
+    async def mock_embedding_async(*args, **kwargs):
+        return mock_embedding_sync()
+    
+    mock_router.embedding = mock_embedding_sync
+    mock_router.aembedding = mock_embedding_async
+    
+    # Create filter with top_k=5
+    filter_instance = SemanticMCPToolFilter(
+        embedding_model="text-embedding-3-small",
+        litellm_router_instance=mock_router,
+        top_k=5,
+        similarity_threshold=0.3,
+        enabled=True,
+    )
+    
+    # Filter tools
+    filtered = await filter_instance.filter_tools(
+        query="test query",
+        available_tools=tools,
+    )
+    
+    # Should return at most 5 tools
+    assert len(filtered) <= 5, f"Expected at most 5 tools, got {len(filtered)}"
+    print(f"Returned {len(filtered)} tools out of {len(tools)} (top_k=5)")
+
+
+@pytest.mark.asyncio
+async def test_semantic_filter_disabled():
+    """
+    Test that when filter is disabled, all tools are returned.
+    """
+    from litellm.proxy._experimental.mcp_server.semantic_tool_filter import (
+        SemanticMCPToolFilter,
+    )
+    
+    tools = [
+        MCPTool(name=f"tool_{i}", description=f"Tool {i}", inputSchema={"type": "object"})
+        for i in range(10)
+    ]
+    
+    mock_router = Mock()
+    
+    # Create disabled filter
+    filter_instance = SemanticMCPToolFilter(
+        embedding_model="text-embedding-3-small",
+        litellm_router_instance=mock_router,
+        top_k=3,
+        similarity_threshold=0.3,
+        enabled=False,  # Disabled
+    )
+    
+    # Filter tools
+    filtered = await filter_instance.filter_tools(
+        query="test query",
+        available_tools=tools,
+    )
+    
+    # Should return all tools when disabled
+    assert len(filtered) == len(tools), f"Expected all {len(tools)} tools, got {len(filtered)}"
+
+
+@pytest.mark.asyncio
+async def test_semantic_filter_empty_tools():
+    """
+    Test that filter handles empty tool list gracefully.
+    """
+    from litellm.proxy._experimental.mcp_server.semantic_tool_filter import (
+        SemanticMCPToolFilter,
+    )
+    
+    mock_router = Mock()
+    
+    filter_instance = SemanticMCPToolFilter(
+        embedding_model="text-embedding-3-small",
+        litellm_router_instance=mock_router,
+        top_k=3,
+        similarity_threshold=0.3,
+        enabled=True,
+    )
+    
+    # Filter empty list
+    filtered = await filter_instance.filter_tools(
+        query="test query",
+        available_tools=[],
+    )
+    
+    assert len(filtered) == 0, "Should return empty list for empty input"
+
+
+@pytest.mark.asyncio
+async def test_semantic_filter_extract_user_query():
+    """
+    Test that user query extraction works correctly from messages.
+    """
+    from litellm.proxy._experimental.mcp_server.semantic_tool_filter import (
+        SemanticMCPToolFilter,
+    )
+    
+    mock_router = Mock()
+    
+    filter_instance = SemanticMCPToolFilter(
+        embedding_model="text-embedding-3-small",
+        litellm_router_instance=mock_router,
+        top_k=3,
+        similarity_threshold=0.3,
+        enabled=True,
+    )
+    
+    # Test string content
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant"},
+        {"role": "user", "content": "Send an email to john@example.com"},
+    ]
+    
+    query = filter_instance.extract_user_query(messages)
+    assert query == "Send an email to john@example.com"
+    
+    # Test list content blocks
+    messages_with_blocks = [
+        {"role": "user", "content": [
+            {"type": "text", "text": "Hello, "},
+            {"type": "text", "text": "send email please"},
+        ]},
+    ]
+    
+    query2 = filter_instance.extract_user_query(messages_with_blocks)
+    assert "Hello" in query2 and "send email" in query2
+    
+    # Test no user messages
+    messages_no_user = [
+        {"role": "system", "content": "System message only"},
+    ]
+    
+    query3 = filter_instance.extract_user_query(messages_no_user)
+    assert query3 == ""
+
+
+@pytest.mark.asyncio
+async def test_semantic_filter_hook_triggers_on_completion():
+    """
+    Test that the hook triggers for completion requests with tools.
+    """
+    from litellm.proxy._experimental.mcp_server.semantic_tool_filter import (
+        SemanticMCPToolFilter,
+    )
+    from litellm.proxy.hooks.mcp_semantic_filter import SemanticToolFilterHook
+    from litellm.types.utils import Embedding, EmbeddingResponse
+
+    # Create mock filter
+    mock_router = Mock()
+    
+    def mock_embedding_sync(*args, **kwargs):
+        return EmbeddingResponse(
+            data=[Embedding(embedding=[0.1] * 1536, index=0, object="embedding")],
+            model="text-embedding-3-small",
+            object="list",
+            usage={"prompt_tokens": 10, "total_tokens": 10}
+        )
+    
+    async def mock_embedding_async(*args, **kwargs):
+        return mock_embedding_sync()
+    
+    mock_router.embedding = mock_embedding_sync
+    mock_router.aembedding = mock_embedding_async
+    
+    filter_instance = SemanticMCPToolFilter(
+        embedding_model="text-embedding-3-small",
+        litellm_router_instance=mock_router,
+        top_k=3,
+        similarity_threshold=0.3,
+        enabled=True,
+    )
+    
+    # Create hook
+    hook = SemanticToolFilterHook(filter_instance)
+    
+    # Prepare data - completion request with tools
+    tools = [
+        MCPTool(name=f"tool_{i}", description=f"Tool {i}", inputSchema={"type": "object"})
+        for i in range(10)
+    ]
+    
+    data = {
+        "model": "gpt-4",
+        "messages": [
+            {"role": "user", "content": "Send an email"}
+        ],
+        "tools": tools,
+    }
+    
+    # Mock user API key dict and cache
+    mock_user_api_key_dict = Mock()
+    mock_cache = Mock()
+    
+    # Call hook
+    result = await hook.async_pre_call_hook(
+        user_api_key_dict=mock_user_api_key_dict,
+        cache=mock_cache,
+        data=data,
+        call_type="completion",
+    )
+    
+    # Assertions
+    assert result is not None, "Hook should return modified data"
+    assert "tools" in result, "Result should contain tools"
+    assert len(result["tools"]) < len(tools), f"Hook should filter tools, got {len(result['tools'])}/{len(tools)}"
+    
+    print(f"✅ Hook triggered correctly: {len(tools)} -> {len(result['tools'])} tools")
+
+
+
+@pytest.mark.asyncio
+async def test_semantic_filter_hook_skips_no_tools():
+    """
+    Test that the hook does NOT trigger when there are no tools.
+    """
+    from litellm.proxy._experimental.mcp_server.semantic_tool_filter import (
+        SemanticMCPToolFilter,
+    )
+    from litellm.proxy.hooks.mcp_semantic_filter import SemanticToolFilterHook
+
+    # Create mock filter
+    mock_router = Mock()
+    filter_instance = SemanticMCPToolFilter(
+        embedding_model="text-embedding-3-small",
+        litellm_router_instance=mock_router,
+        top_k=3,
+        similarity_threshold=0.3,
+        enabled=True,
+    )
+    
+    # Create hook
+    hook = SemanticToolFilterHook(filter_instance)
+    
+    # Prepare data - completion without tools
+    data = {
+        "model": "gpt-4",
+        "messages": [
+            {"role": "user", "content": "Hello"}
+        ],
+    }
+    
+    # Mock user API key dict and cache
+    mock_user_api_key_dict = Mock()
+    mock_cache = Mock()
+    
+    # Call hook
+    result = await hook.async_pre_call_hook(
+        user_api_key_dict=mock_user_api_key_dict,
+        cache=mock_cache,
+        data=data,
+        call_type="completion",
+    )
+    
+    # Should return None (no modification)
+    assert result is None, "Hook should skip requests without tools"
+    print("✅ Hook correctly skips requests without tools")
+

From 0ef506a54ae149edc135cf25011e76c647a2e261 Mon Sep 17 00:00:00 2001
From: Ishaan Jaff <ishaanjaffer0324@gmail.com>
Date: Mon, 2 Feb 2026 18:29:07 -0800
Subject: [PATCH 11/29] Litellm docs mcp filtering semantic (#20316)

* init: SemanticMCPToolFilter

* init: SemanticToolFilterHook

* test_e2e_semantic_filter

* mock tests: test_semantic_filter_basic_filtering

* Update litellm/proxy/_experimental/mcp_server/semantic_tool_filter.py

Co-authored-by: greptile-apps[bot] <165735046+greptile-apps[bot]@users.noreply.github.com>

* refactor folder/file organization

* docs fix

* fix filter

* fix: filter_tools

* fix linting tool filrer

* initialize_from_config

* fix: _expand_mcp_tools

* _initialize_semantic_tool_filter

* working: async_post_call_response_headers_hook

* clean up semantic tool filter

* add _initialize_semantic_tool_filter

* build_router_from_mcp_registry

* _get_tools_by_names

* fiix config

* async_post_call_response_headers_hook

* docs mcp filter

* docs fix

---------

Co-authored-by: greptile-apps[bot] <165735046+greptile-apps[bot]@users.noreply.github.com>
---
 docs/my-website/docs/mcp_semantic_filter.md | 158 ++++++++++++++++++++
 docs/my-website/sidebars.js                 |   1 +
 2 files changed, 159 insertions(+)
 create mode 100644 docs/my-website/docs/mcp_semantic_filter.md

diff --git a/docs/my-website/docs/mcp_semantic_filter.md b/docs/my-website/docs/mcp_semantic_filter.md
new file mode 100644
index 0000000000..c58be80a68
--- /dev/null
+++ b/docs/my-website/docs/mcp_semantic_filter.md
@@ -0,0 +1,158 @@
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# MCP Semantic Tool Filter
+
+Automatically filter MCP tools by semantic relevance. When you have many MCP tools registered, LiteLLM semantically matches the user's query against tool descriptions and sends only the most relevant tools to the LLM.
+
+## How It Works
+
+Tool search shifts tool selection from a prompt-engineering problem to a retrieval problem. Instead of injecting a large static list of tools into every prompt, the semantic filter:
+
+1. Builds a semantic index of all available MCP tools on startup
+2. On each request, semantically matches the user's query against tool descriptions
+3. Returns only the top-K most relevant tools to the LLM
+
+This approach improves context efficiency, increases reliability by reducing tool confusion, and enables scalability to ecosystems with hundreds or thousands of MCP tools.
+
+```mermaid
+sequenceDiagram
+    participant Client
+    participant LiteLLM as LiteLLM Proxy
+    participant SemanticFilter as Semantic Filter
+    participant MCP as MCP Registry
+    participant LLM as LLM Provider
+
+    Note over LiteLLM,MCP: Startup: Build Semantic Index
+    LiteLLM->>MCP: Fetch all registered MCP tools
+    MCP->>LiteLLM: Return all tools (e.g., 50 tools)
+    LiteLLM->>SemanticFilter: Build semantic router with embeddings
+    SemanticFilter->>LLM: Generate embeddings for tool descriptions
+    LLM->>SemanticFilter: Return embeddings
+    Note over SemanticFilter: Index ready for fast lookup
+
+    Note over Client,LLM: Request: Semantic Tool Filtering
+    Client->>LiteLLM: POST /v1/responses with MCP tools
+    LiteLLM->>SemanticFilter: Expand MCP references (50 tools available)
+    SemanticFilter->>SemanticFilter: Extract user query from request
+    SemanticFilter->>LLM: Generate query embedding
+    LLM->>SemanticFilter: Return query embedding
+    SemanticFilter->>SemanticFilter: Match query against tool embeddings
+    SemanticFilter->>LiteLLM: Return top-K tools (e.g., 3 most relevant)
+    LiteLLM->>LLM: Forward request with filtered tools (3 tools)
+    LLM->>LiteLLM: Return response
+    LiteLLM->>Client: Response with headers<br/>x-litellm-semantic-filter: 50->3<br/>x-litellm-semantic-filter-tools: tool1,tool2,tool3
+```
+
+## Configuration
+
+Enable semantic filtering in your LiteLLM config:
+
+```yaml title="config.yaml" showLineNumbers
+litellm_settings:
+  mcp_semantic_tool_filter:
+    enabled: true
+    embedding_model: "text-embedding-3-small"  # Model for semantic matching
+    top_k: 5                                    # Max tools to return
+    similarity_threshold: 0.3                   # Min similarity score
+```
+
+**Configuration Options:**
+- `enabled` - Enable/disable semantic filtering (default: `false`)
+- `embedding_model` - Model for generating embeddings (default: `"text-embedding-3-small"`)
+- `top_k` - Maximum number of tools to return (default: `10`)
+- `similarity_threshold` - Minimum similarity score for matches (default: `0.3`)
+
+## Usage
+
+Use MCP tools normally with the Responses API or Chat Completions. The semantic filter runs automatically:
+
+<Tabs>
+<TabItem value="responses" label="Responses API">
+
+```bash title="Responses API with Semantic Filtering" showLineNumbers
+curl --location 'http://localhost:4000/v1/responses' \
+--header 'Content-Type: application/json' \
+--header "Authorization: Bearer sk-1234" \
+--data '{
+    "model": "gpt-4o",
+    "input": [
+    {
+      "role": "user",
+      "content": "give me TLDR of what BerriAI/litellm repo is about",
+      "type": "message"
+    }
+  ],
+    "tools": [
+        {
+            "type": "mcp",
+            "server_url": "litellm_proxy",
+            "require_approval": "never"
+        }
+    ],
+    "tool_choice": "required"
+}'
+```
+
+</TabItem>
+<TabItem value="chat" label="Chat Completions">
+
+```bash title="Chat Completions with Semantic Filtering" showLineNumbers
+curl --location 'http://localhost:4000/v1/chat/completions' \
+--header 'Content-Type: application/json' \
+--header "Authorization: Bearer sk-1234" \
+--data '{
+  "model": "gpt-4o",
+  "messages": [
+    {"role": "user", "content": "Search Wikipedia for LiteLLM"}
+  ],
+  "tools": [
+    {
+      "type": "mcp",
+      "server_url": "litellm_proxy"
+    }
+  ]
+}'
+```
+
+</TabItem>
+</Tabs>
+
+## Response Headers
+
+The semantic filter adds diagnostic headers to every response:
+
+```
+x-litellm-semantic-filter: 10->3
+x-litellm-semantic-filter-tools: wikipedia-fetch,github-search,slack-post
+```
+
+- **`x-litellm-semantic-filter`** - Shows before→after tool count (e.g., `10->3` means 10 tools were filtered down to 3)
+- **`x-litellm-semantic-filter-tools`** - CSV list of the filtered tool names (max 150 chars, clipped with `...` if longer)
+
+These headers help you understand which tools were selected for each request and verify the filter is working correctly.
+
+## Example
+
+If you have 50 MCP tools registered and make a request asking about Wikipedia, the semantic filter will:
+
+1. Semantically match your query `"Search Wikipedia for LiteLLM"` against all 50 tool descriptions
+2. Select the top 5 most relevant tools (e.g., `wikipedia-fetch`, `wikipedia-search`, etc.)
+3. Pass only those 5 tools to the LLM
+4. Add headers showing `x-litellm-semantic-filter: 50->5`
+
+This dramatically reduces prompt size while ensuring the LLM has access to the right tools for the task.
+
+## Performance
+
+The semantic filter is optimized for production:
+- Router builds once on startup (no per-request overhead)
+- Semantic matching typically takes under 50ms
+- Fails gracefully - returns all tools if filtering fails
+- No impact on latency for requests without MCP tools
+
+## Related
+
+- [MCP Overview](./mcp.md) - Learn about MCP in LiteLLM
+- [MCP Permission Management](./mcp_control.md) - Control tool access by key/team
+- [Using MCP](./mcp_usage.md) - Complete MCP usage guide
diff --git a/docs/my-website/sidebars.js b/docs/my-website/sidebars.js
index e533665032..49265ddf63 100644
--- a/docs/my-website/sidebars.js
+++ b/docs/my-website/sidebars.js
@@ -538,6 +538,7 @@ const sidebars = {
           items: [
             "mcp",
             "mcp_usage",
+            "mcp_semantic_filter",
             "mcp_control",
             "mcp_cost",
             "mcp_guardrail",

From 4e8c6d1b100426086d93ecc7ec55a1155b7d9f0d Mon Sep 17 00:00:00 2001
From: Ishaan Jaffer <ishaanjaffer0324@gmail.com>
Date: Mon, 2 Feb 2026 18:30:42 -0800
Subject: [PATCH 12/29] fix linting

---
 .../model_prices_and_context_window_backup.json    | 14 ++++++++++++++
 .../mcp_server/semantic_tool_filter.py             |  5 ++---
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/litellm/model_prices_and_context_window_backup.json b/litellm/model_prices_and_context_window_backup.json
index 6aeb51d581..485bee4f19 100644
--- a/litellm/model_prices_and_context_window_backup.json
+++ b/litellm/model_prices_and_context_window_backup.json
@@ -21488,6 +21488,20 @@
         "supports_tool_choice": true,
         "supports_web_search": true
     },
+    "moonshot/kimi-k2.5": {
+        "cache_read_input_token_cost": 1e-07,
+        "input_cost_per_token": 6e-07,
+        "litellm_provider": "moonshot",
+        "max_input_tokens": 262144,
+        "max_output_tokens": 262144,
+        "max_tokens": 262144,
+        "mode": "chat",
+        "output_cost_per_token": 3e-06,
+        "source": "https://platform.moonshot.ai/docs/pricing/chat",
+        "supports_function_calling": true,
+        "supports_tool_choice": true,
+        "supports_vision": true
+    },
     "moonshot/kimi-latest": {
         "cache_read_input_token_cost": 1.5e-07,
         "input_cost_per_token": 2e-06,
diff --git a/litellm/proxy/_experimental/mcp_server/semantic_tool_filter.py b/litellm/proxy/_experimental/mcp_server/semantic_tool_filter.py
index c83ef13a64..b01bf14238 100644
--- a/litellm/proxy/_experimental/mcp_server/semantic_tool_filter.py
+++ b/litellm/proxy/_experimental/mcp_server/semantic_tool_filter.py
@@ -8,7 +8,6 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from litellm._logging import verbose_logger
 
 if TYPE_CHECKING:
-    from mcp.types import Tool as MCPTool
     from semantic_router.routers import SemanticRouter
 
     from litellm.router import Router
@@ -88,8 +87,8 @@ class SemanticMCPToolFilter:
             description = tool.get("description", name)
         else:
             # MCPTool object
-            name = tool.name
-            description = tool.description or tool.name
+            name = str(tool.name)
+            description = str(tool.description) if tool.description else str(tool.name)
         
         return name, description
 

From c8f9af175866e72967f8bff25f19ef0c6d31bfe6 Mon Sep 17 00:00:00 2001
From: Ishaan Jaffer <ishaanjaffer0324@gmail.com>
Date: Mon, 2 Feb 2026 19:00:10 -0800
Subject: [PATCH 13/29] fix mypy lint

---
 litellm/proxy/_experimental/mcp_server/semantic_tool_filter.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/litellm/proxy/_experimental/mcp_server/semantic_tool_filter.py b/litellm/proxy/_experimental/mcp_server/semantic_tool_filter.py
index b01bf14238..e5cb6a0098 100644
--- a/litellm/proxy/_experimental/mcp_server/semantic_tool_filter.py
+++ b/litellm/proxy/_experimental/mcp_server/semantic_tool_filter.py
@@ -81,6 +81,9 @@ class SemanticMCPToolFilter:
 
     def _extract_tool_info(self, tool) -> tuple[str, str]:
         """Extract name and description from MCP tool or OpenAI function dict."""
+        name: str
+        description: str
+        
         if isinstance(tool, dict):
             # OpenAI function format
             name = tool.get("name", "")

From 333419b4d2cd7f229f7cd0c1d2cd5e8c5998d9f4 Mon Sep 17 00:00:00 2001
From: Sameer Kankute <sameer@berri.ai>
Date: Tue, 3 Feb 2026 09:03:27 +0530
Subject: [PATCH 14/29] Add documentation correctly for nova sonic

---
 docs/my-website/docs/providers/bedrock.md                   | 2 +-
 .../{tutorials => providers}/bedrock_realtime_with_audio.md | 6 +-----
 docs/my-website/sidebars.js                                 | 1 +
 3 files changed, 3 insertions(+), 6 deletions(-)
 rename docs/my-website/docs/{tutorials => providers}/bedrock_realtime_with_audio.md (98%)

diff --git a/docs/my-website/docs/providers/bedrock.md b/docs/my-website/docs/providers/bedrock.md
index 487212ad65..e546ed9765 100644
--- a/docs/my-website/docs/providers/bedrock.md
+++ b/docs/my-website/docs/providers/bedrock.md
@@ -9,7 +9,7 @@ ALL Bedrock models (Anthropic, Meta, Deepseek, Mistral, Amazon, etc.) are Suppor
 | Description | Amazon Bedrock is a fully managed service that offers a choice of high-performing foundation models (FMs). |
 | Provider Route on LiteLLM | `bedrock/`, [`bedrock/converse/`](#set-converse--invoke-route), [`bedrock/invoke/`](#set-invoke-route), [`bedrock/converse_like/`](#calling-via-internal-proxy), [`bedrock/llama/`](#deepseek-not-r1), [`bedrock/deepseek_r1/`](#deepseek-r1), [`bedrock/qwen3/`](#qwen3-imported-models), [`bedrock/qwen2/`](./bedrock_imported.md#qwen2-imported-models), [`bedrock/openai/`](./bedrock_imported.md#openai-compatible-imported-models-qwen-25-vl-etc), [`bedrock/moonshot`](./bedrock_imported.md#moonshot-kimi-k2-thinking) |
 | Provider Doc | [Amazon Bedrock ↗](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) |
-| Supported OpenAI Endpoints | `/chat/completions`, `/completions`, `/embeddings`, `/images/generations` |
+| Supported OpenAI Endpoints | `/chat/completions`, `/completions`, `/embeddings`, `/images/generations`, `/v1/realtime`|
 | Rerank Endpoint | `/rerank` |
 | Pass-through Endpoint | [Supported](../pass_through/bedrock.md) |
 
diff --git a/docs/my-website/docs/tutorials/bedrock_realtime_with_audio.md b/docs/my-website/docs/providers/bedrock_realtime_with_audio.md
similarity index 98%
rename from docs/my-website/docs/tutorials/bedrock_realtime_with_audio.md
rename to docs/my-website/docs/providers/bedrock_realtime_with_audio.md
index 07e29af532..a2d9813ffd 100644
--- a/docs/my-website/docs/tutorials/bedrock_realtime_with_audio.md
+++ b/docs/my-website/docs/providers/bedrock_realtime_with_audio.md
@@ -1,8 +1,4 @@
-# Call Bedrock Nova Sonic Realtime API with Audio Input/Output 
-
-:::info
-Requires LiteLLM Proxy v1.70.1+
-:::
+# Bedrock Realtime API
 
 ## Overview
 
diff --git a/docs/my-website/sidebars.js b/docs/my-website/sidebars.js
index 49265ddf63..d932b6af25 100644
--- a/docs/my-website/sidebars.js
+++ b/docs/my-website/sidebars.js
@@ -717,6 +717,7 @@ const sidebars = {
             "providers/bedrock_agents",
             "providers/bedrock_writer",
             "providers/bedrock_batches",
+            "providers/bedrock_realtime_with_audio",
             "providers/aws_polly",
         "providers/bedrock_vector_store",
       ]

From 5cfcf67d7c991074bb6b31546b8452f4a2cf672f Mon Sep 17 00:00:00 2001
From: Ishaan Jaff <ishaanjaffer0324@gmail.com>
Date: Mon, 2 Feb 2026 19:36:36 -0800
Subject: [PATCH 15/29] [Feat] /chat/completions - allow using OpenAI style
 tools for `web_search` with VertexAI/gemini models  (#20280)

* test_gemini_openai_web_search_tool_to_google_search

* feat: Handle OpenAI style web search tools
---
 .../vertex_and_google_ai_studio_gemini.py     |   7 ++
 tests/llm_translation/test_gemini.py          |  17 +++
 ...test_vertex_and_google_ai_studio_gemini.py | 105 ++++++++++++++++++
 3 files changed, 129 insertions(+)

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 a9ac21bb56..b5a6949f27 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
@@ -478,6 +478,13 @@ class VertexGeminiConfig(VertexAIBaseConfig, BaseConfig):
             if "type" in tool and tool["type"] == "computer_use":
                 computer_use_config = {k: v for k, v in tool.items() if k != "type"}
                 tool = {VertexToolName.COMPUTER_USE.value: computer_use_config}
+            # Handle OpenAI-style web_search and web_search_preview tools
+            # Transform them to Gemini's googleSearch tool
+            elif "type" in tool and tool["type"] in ("web_search", "web_search_preview"):
+                verbose_logger.info(
+                    f"Gemini: Transforming OpenAI-style '{tool['type']}' tool to googleSearch"
+                )
+                tool = {VertexToolName.GOOGLE_SEARCH.value: {}}
             # Handle tools with 'type' field (OpenAI spec compliance) Ignore this field -> https://github.com/BerriAI/litellm/issues/14644#issuecomment-3342061838
             elif "type" in tool:
                 tool = {k: tool[k] for k in tool if k != "type"}
diff --git a/tests/llm_translation/test_gemini.py b/tests/llm_translation/test_gemini.py
index e3e0578644..c1c52757cf 100644
--- a/tests/llm_translation/test_gemini.py
+++ b/tests/llm_translation/test_gemini.py
@@ -1435,3 +1435,20 @@ def test_gemini_image_size_limit_exceeded():
     error_message = str(excinfo.value)
     assert "Image size" in error_message
     assert "exceeds maximum allowed size" in error_message
+
+@pytest.mark.asyncio
+async def test_gemini_openai_web_search_tool_to_google_search():
+    """
+    Test that OpenAI-style web_search tools are transformed to Gemini's googleSearch.
+
+    When passing {"type": "web_search"} or {"type": "web_search_preview"} to Gemini,
+    these should be transformed to googleSearch, not silently ignored.
+    """
+    response = await litellm.acompletion(
+        model="gemini/gemini-2.5-flash",
+        messages=[{"role": "user", "content": "What is the capital of France?"}],
+        tools=[{"type": "web_search"}],
+    )
+    print("response: ", response.model_dump_json(indent=4))
+    assert hasattr(response, "vertex_ai_grounding_metadata")
+    assert getattr(response, "vertex_ai_grounding_metadata") is not 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 ac099a0168..cb3b51acd6 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
@@ -2663,6 +2663,111 @@ def test_vertex_ai_single_tool_type_still_works():
     assert tools[0]["code_execution"] == {}
 
 
+def test_vertex_ai_openai_web_search_tool_transformation():
+    """
+    Test that OpenAI-style web_search and web_search_preview tools are transformed to googleSearch.
+
+    This fixes the issue where passing OpenAI-style web search tools like:
+        {"type": "web_search"} or {"type": "web_search_preview"}
+    would be silently ignored (the request succeeds but grounding is not applied).
+
+    The fix transforms these to Gemini's googleSearch tool.
+
+    Input:
+        value=[{"type": "web_search"}]
+
+    Expected Output:
+        tools=[{"googleSearch": {}}]
+    """
+    v = VertexGeminiConfig()
+    optional_params = {}
+
+    # Test web_search transformation
+    tools = v._map_function(
+        value=[{"type": "web_search"}],
+        optional_params=optional_params
+    )
+
+    assert len(tools) == 1, f"Expected 1 Tool object, got {len(tools)}"
+    assert "googleSearch" in tools[0], f"Expected googleSearch in tool, got {tools[0].keys()}"
+    assert tools[0]["googleSearch"] == {}, f"Expected empty googleSearch config, got {tools[0]['googleSearch']}"
+
+
+def test_vertex_ai_openai_web_search_preview_tool_transformation():
+    """
+    Test that OpenAI-style web_search_preview tool is transformed to googleSearch.
+
+    Input:
+        value=[{"type": "web_search_preview"}]
+
+    Expected Output:
+        tools=[{"googleSearch": {}}]
+    """
+    v = VertexGeminiConfig()
+    optional_params = {}
+
+    # Test web_search_preview transformation
+    tools = v._map_function(
+        value=[{"type": "web_search_preview"}],
+        optional_params=optional_params
+    )
+
+    assert len(tools) == 1, f"Expected 1 Tool object, got {len(tools)}"
+    assert "googleSearch" in tools[0], f"Expected googleSearch in tool, got {tools[0].keys()}"
+    assert tools[0]["googleSearch"] == {}, f"Expected empty googleSearch config, got {tools[0]['googleSearch']}"
+
+
+def test_vertex_ai_openai_web_search_with_function_tools():
+    """
+    Test that OpenAI-style web_search tool works alongside function tools.
+
+    Input:
+        value=[
+            {"type": "web_search"},
+            {"type": "function", "function": {"name": "get_weather", "description": "Get weather"}},
+        ]
+
+    Expected Output:
+        tools=[
+            {"googleSearch": {}},
+            {"function_declarations": [{"name": "get_weather", "description": "Get weather"}]},
+        ]
+    """
+    v = VertexGeminiConfig()
+    optional_params = {}
+
+    tools = v._map_function(
+        value=[
+            {"type": "web_search"},
+            {"type": "function", "function": {"name": "get_weather", "description": "Get weather"}},
+        ],
+        optional_params=optional_params
+    )
+
+    # Should have 2 separate Tool objects
+    assert len(tools) == 2, f"Expected 2 Tool objects, got {len(tools)}"
+
+    # Find each tool type
+    search_tool = None
+    func_tool = None
+
+    for tool in tools:
+        if "googleSearch" in tool:
+            search_tool = tool
+        elif "function_declarations" in tool:
+            func_tool = tool
+
+    # Verify both tools are present
+    assert search_tool is not None, "googleSearch Tool should be present"
+    assert func_tool is not None, "function_declarations Tool should be present"
+
+    # Verify googleSearch is empty config
+    assert search_tool["googleSearch"] == {}
+
+    # Verify function declaration content
+    assert func_tool["function_declarations"][0]["name"] == "get_weather"
+
+
 def test_vertex_ai_multiple_function_declarations_grouped():
     """
     Test that multiple function declarations are grouped in ONE Tool object.

From 5aa8725c630d6b2e5bcb175be1aa6959d06d73dc Mon Sep 17 00:00:00 2001
From: Ishaan Jaffer <ishaanjaffer0324@gmail.com>
Date: Mon, 2 Feb 2026 19:48:00 -0800
Subject: [PATCH 16/29] docs Tracing Tools

---
 docs/my-website/docs/proxy/ui_logs.md |  35 ++++++++++++++++++++++++++
 docs/my-website/img/ui_tools.png      | Bin 0 -> 430362 bytes
 2 files changed, 35 insertions(+)
 create mode 100644 docs/my-website/img/ui_tools.png

diff --git a/docs/my-website/docs/proxy/ui_logs.md b/docs/my-website/docs/proxy/ui_logs.md
index b6d3d2ae7c..2e772197b9 100644
--- a/docs/my-website/docs/proxy/ui_logs.md
+++ b/docs/my-website/docs/proxy/ui_logs.md
@@ -23,6 +23,41 @@ View Spend, Token Usage, Key, Team Name for Each Request to LiteLLM
 
 **By default LiteLLM does not track the request and response content.**
 
+## Tracing Tools
+
+View which tools were provided and called in your completion requests.
+
+<Image img={require('../../img/ui_tools.png')}/>
+
+**Example:** Make a completion request with tools:
+
+```bash
+curl -X POST 'http://localhost:4000/chat/completions' \
+  -H 'Authorization: Bearer sk-1234' \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "model": "gpt-4",
+    "messages": [{"role": "user", "content": "What is the weather?"}],
+    "tools": [
+      {
+        "type": "function",
+        "function": {
+          "name": "get_weather",
+          "description": "Get the current weather",
+          "parameters": {
+            "type": "object",
+            "properties": {
+              "location": {"type": "string"}
+            }
+          }
+        }
+      }
+    ]
+  }'
+```
+
+Check the Logs page to see all tools provided and which ones were called.
+
 ## Tracking - Request / Response Content in Logs Page 
 
 If you want to view request and response content on LiteLLM Logs, you can enable it in either place:
diff --git a/docs/my-website/img/ui_tools.png b/docs/my-website/img/ui_tools.png
new file mode 100644
index 0000000000000000000000000000000000000000..6f4d0f874103804d933a0c405c0bf58361da4177
GIT binary patch
literal 430362
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
Ld%Z;M!L$DXTAi`s

literal 0
HcmV?d00001


From 7ae980410b093a27a5a87fd80cd53bf21c48d71c Mon Sep 17 00:00:00 2001
From: Ishaan Jaffer <ishaanjaffer0324@gmail.com>
Date: Mon, 2 Feb 2026 19:50:22 -0800
Subject: [PATCH 17/29] docs fix

---
 docs/my-website/docs/proxy/ui_logs.md | 29 +++++++++++++--------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/docs/my-website/docs/proxy/ui_logs.md b/docs/my-website/docs/proxy/ui_logs.md
index 2e772197b9..8cfe818ebf 100644
--- a/docs/my-website/docs/proxy/ui_logs.md
+++ b/docs/my-website/docs/proxy/ui_logs.md
@@ -23,6 +23,20 @@ View Spend, Token Usage, Key, Team Name for Each Request to LiteLLM
 
 **By default LiteLLM does not track the request and response content.**
 
+## Tracking - Request / Response Content in Logs Page 
+
+If you want to view request and response content on LiteLLM Logs, you can enable it in either place:
+
+- **From the UI (no restart):** Use [UI Spend Log Settings](./ui_spend_log_settings.md) — open Logs → Settings → enable "Store Prompts in Spend Logs" → Save. Takes effect immediately and overrides config.
+- **From config:** Add this to your `proxy_config.yaml` (requires restart):
+
+```yaml
+general_settings:
+  store_prompts_in_spend_logs: true
+```
+
+<Image img={require('../../img/ui_request_logs_content.png')}/>
+
 ## Tracing Tools
 
 View which tools were provided and called in your completion requests.
@@ -58,21 +72,6 @@ curl -X POST 'http://localhost:4000/chat/completions' \
 
 Check the Logs page to see all tools provided and which ones were called.
 
-## Tracking - Request / Response Content in Logs Page 
-
-If you want to view request and response content on LiteLLM Logs, you can enable it in either place:
-
-- **From the UI (no restart):** Use [UI Spend Log Settings](./ui_spend_log_settings.md) — open Logs → Settings → enable "Store Prompts in Spend Logs" → Save. Takes effect immediately and overrides config.
-- **From config:** Add this to your `proxy_config.yaml` (requires restart):
-
-```yaml
-general_settings:
-  store_prompts_in_spend_logs: true
-```
-
-<Image img={require('../../img/ui_request_logs_content.png')}/>
-
-
 ## Stop storing Error Logs in DB
 
 If you do not want to store error logs in DB, you can opt out with this setting

From 7dd0248987692d8908d0aa2cb55cfa3624318a0b Mon Sep 17 00:00:00 2001
From: Sameer Kankute <sameer@berri.ai>
Date: Tue, 3 Feb 2026 12:04:15 +0530
Subject: [PATCH 18/29] Revert "fix: models loadbalancing billing issue by
 filter (#18891) (#19220)"

This reverts commit 72e519345149f4b305645c51943b0f2cfd6c8acd.
---
 litellm/proxy/auth/model_checks.py            |  25 +-
 litellm/proxy/litellm_pre_call_utils.py       |  31 ---
 litellm/router.py                             |  12 +-
 litellm/router_utils/common_utils.py          |  79 +-----
 ...est_filter_deployments_by_access_groups.py | 227 ------------------
 5 files changed, 6 insertions(+), 368 deletions(-)
 delete mode 100644 tests/test_litellm/router_unit_tests/test_filter_deployments_by_access_groups.py

diff --git a/litellm/proxy/auth/model_checks.py b/litellm/proxy/auth/model_checks.py
index af2574d88e..71ae1348f3 100644
--- a/litellm/proxy/auth/model_checks.py
+++ b/litellm/proxy/auth/model_checks.py
@@ -64,27 +64,6 @@ def _get_models_from_access_groups(
     return all_models
 
 
-def get_access_groups_from_models(
-    model_access_groups: Dict[str, List[str]],
-    models: List[str],
-) -> List[str]:
-    """
-    Extract access group names from a models list.
-
-    Given a models list like ["gpt-4", "beta-models", "claude-v1"]
-    and access groups like {"beta-models": ["gpt-5", "gpt-6"]},
-    returns ["beta-models"].
-
-    This is used to pass allowed access groups to the router for filtering
-    deployments during load balancing (GitHub issue #18333).
-    """
-    access_groups = []
-    for model in models:
-        if model in model_access_groups:
-            access_groups.append(model)
-    return access_groups
-
-
 async def get_mcp_server_ids(
     user_api_key_dict: UserAPIKeyAuth,
 ) -> List[str]:
@@ -101,6 +80,7 @@ async def get_mcp_server_ids(
 
     # Make a direct SQL query to get just the mcp_servers
     try:
+
         result = await prisma_client.db.litellm_objectpermissiontable.find_unique(
             where={"object_permission_id": user_api_key_dict.object_permission_id},
         )
@@ -196,7 +176,6 @@ def get_complete_model_list(
     """
 
     unique_models = []
-
     def append_unique(models):
         for model in models:
             if model not in unique_models:
@@ -209,7 +188,7 @@ def get_complete_model_list(
     else:
         append_unique(proxy_model_list)
         if include_model_access_groups:
-            append_unique(list(model_access_groups.keys()))  # TODO: keys order
+            append_unique(list(model_access_groups.keys())) # TODO: keys order
 
         if user_model:
             append_unique([user_model])
diff --git a/litellm/proxy/litellm_pre_call_utils.py b/litellm/proxy/litellm_pre_call_utils.py
index 72f23e609a..9be78264e8 100644
--- a/litellm/proxy/litellm_pre_call_utils.py
+++ b/litellm/proxy/litellm_pre_call_utils.py
@@ -1021,37 +1021,6 @@ async def add_litellm_data_to_request(  # noqa: PLR0915
         "user_api_key_user_max_budget"
     ] = user_api_key_dict.user_max_budget
 
-    # Extract allowed access groups for router filtering (GitHub issue #18333)
-    # This allows the router to filter deployments based on key's and team's access groups
-    # NOTE: We keep key and team access groups SEPARATE because a key doesn't always
-    # inherit all team access groups (per maintainer feedback).
-    if llm_router is not None:
-        from litellm.proxy.auth.model_checks import get_access_groups_from_models
-
-        model_access_groups = llm_router.get_model_access_groups()
-
-        # Key-level access groups (from user_api_key_dict.models)
-        key_models = list(user_api_key_dict.models) if user_api_key_dict.models else []
-        key_allowed_access_groups = get_access_groups_from_models(
-            model_access_groups=model_access_groups, models=key_models
-        )
-        if key_allowed_access_groups:
-            data[_metadata_variable_name][
-                "user_api_key_allowed_access_groups"
-            ] = key_allowed_access_groups
-
-        # Team-level access groups (from user_api_key_dict.team_models)
-        team_models = (
-            list(user_api_key_dict.team_models) if user_api_key_dict.team_models else []
-        )
-        team_allowed_access_groups = get_access_groups_from_models(
-            model_access_groups=model_access_groups, models=team_models
-        )
-        if team_allowed_access_groups:
-            data[_metadata_variable_name][
-                "user_api_key_team_allowed_access_groups"
-            ] = team_allowed_access_groups
-
     data[_metadata_variable_name]["user_api_key_metadata"] = user_api_key_dict.metadata
     _headers = dict(request.headers)
     _headers.pop(
diff --git a/litellm/router.py b/litellm/router.py
index 65445e29c4..d01c8443da 100644
--- a/litellm/router.py
+++ b/litellm/router.py
@@ -88,7 +88,6 @@ from litellm.router_utils.clientside_credential_handler import (
     is_clientside_credential,
 )
 from litellm.router_utils.common_utils import (
-    filter_deployments_by_access_groups,
     filter_team_based_models,
     filter_web_search_deployments,
 )
@@ -8088,17 +8087,10 @@ class Router:
             request_kwargs=request_kwargs,
         )
 
-        verbose_router_logger.debug(f"healthy_deployments after web search filter: {healthy_deployments}")
-
-        # Filter by allowed access groups (GitHub issue #18333)
-        # This prevents cross-team load balancing when teams have models with same name in different access groups
-        healthy_deployments = filter_deployments_by_access_groups(
-            healthy_deployments=healthy_deployments,
-            request_kwargs=request_kwargs,
+        verbose_router_logger.debug(
+            f"healthy_deployments after web search filter: {healthy_deployments}"
         )
 
-        verbose_router_logger.debug(f"healthy_deployments after access group filter: {healthy_deployments}")
-
         if isinstance(healthy_deployments, dict):
             return healthy_deployments
 
diff --git a/litellm/router_utils/common_utils.py b/litellm/router_utils/common_utils.py
index 2c0ea5976d..10acc343ab 100644
--- a/litellm/router_utils/common_utils.py
+++ b/litellm/router_utils/common_utils.py
@@ -75,7 +75,6 @@ def filter_team_based_models(
         if deployment.get("model_info", {}).get("id") not in ids_to_remove
     ]
 
-
 def _deployment_supports_web_search(deployment: Dict) -> bool:
     """
     Check if a deployment supports web search.
@@ -113,7 +112,7 @@ def filter_web_search_deployments(
     is_web_search_request = False
     tools = request_kwargs.get("tools") or []
     for tool in tools:
-        # These are the two websearch tools for OpenAI / Azure.
+        # These are the two websearch tools for OpenAI / Azure. 
         if tool.get("type") == "web_search" or tool.get("type") == "web_search_preview":
             is_web_search_request = True
             break
@@ -122,82 +121,8 @@ def filter_web_search_deployments(
         return healthy_deployments
 
     # Filter out deployments that don't support web search
-    final_deployments = [
-        d for d in healthy_deployments if _deployment_supports_web_search(d)
-    ]
+    final_deployments = [d for d in healthy_deployments if _deployment_supports_web_search(d)]
     if len(healthy_deployments) > 0 and len(final_deployments) == 0:
         verbose_logger.warning("No deployments support web search for request")
     return final_deployments
 
-
-def filter_deployments_by_access_groups(
-    healthy_deployments: Union[List[Dict], Dict],
-    request_kwargs: Optional[Dict] = None,
-) -> Union[List[Dict], Dict]:
-    """
-    Filter deployments to only include those matching the user's allowed access groups.
-
-    Reads from TWO separate metadata fields (per maintainer feedback):
-    - `user_api_key_allowed_access_groups`: Access groups from the API Key's models.
-    - `user_api_key_team_allowed_access_groups`: Access groups from the Team's models.
-
-    A deployment is included if its access_groups overlap with EITHER the key's
-    or the team's allowed access groups. Deployments with no access_groups are
-    always included (not restricted).
-
-    This prevents cross-team load balancing when multiple teams have models with
-    the same name but in different access groups (GitHub issue #18333).
-    """
-    if request_kwargs is None:
-        return healthy_deployments
-
-    if isinstance(healthy_deployments, dict):
-        return healthy_deployments
-
-    metadata = request_kwargs.get("metadata") or {}
-    litellm_metadata = request_kwargs.get("litellm_metadata") or {}
-
-    # Gather key-level allowed access groups
-    key_allowed_access_groups = (
-        metadata.get("user_api_key_allowed_access_groups")
-        or litellm_metadata.get("user_api_key_allowed_access_groups")
-        or []
-    )
-
-    # Gather team-level allowed access groups
-    team_allowed_access_groups = (
-        metadata.get("user_api_key_team_allowed_access_groups")
-        or litellm_metadata.get("user_api_key_team_allowed_access_groups")
-        or []
-    )
-
-    # Combine both for the final allowed set
-    combined_allowed_access_groups = list(key_allowed_access_groups) + list(
-        team_allowed_access_groups
-    )
-
-    # If no access groups specified from either source, return all deployments (backwards compatible)
-    if not combined_allowed_access_groups:
-        return healthy_deployments
-
-    allowed_set = set(combined_allowed_access_groups)
-    filtered = []
-    for deployment in healthy_deployments:
-        model_info = deployment.get("model_info") or {}
-        deployment_access_groups = model_info.get("access_groups") or []
-
-        # If deployment has no access groups, include it (not restricted)
-        if not deployment_access_groups:
-            filtered.append(deployment)
-            continue
-
-        # Include if any of deployment's groups overlap with allowed groups
-        if set(deployment_access_groups) & allowed_set:
-            filtered.append(deployment)
-
-    if len(healthy_deployments) > 0 and len(filtered) == 0:
-        verbose_logger.warning(
-            f"No deployments match allowed access groups {combined_allowed_access_groups}"
-        )
-
-    return filtered
diff --git a/tests/test_litellm/router_unit_tests/test_filter_deployments_by_access_groups.py b/tests/test_litellm/router_unit_tests/test_filter_deployments_by_access_groups.py
deleted file mode 100644
index 9ac5072c5d..0000000000
--- a/tests/test_litellm/router_unit_tests/test_filter_deployments_by_access_groups.py
+++ /dev/null
@@ -1,227 +0,0 @@
-"""
-Unit tests for filter_deployments_by_access_groups function.
-
-Tests the fix for GitHub issue #18333: Models loadbalanced outside of Model Access Group.
-"""
-
-import pytest
-
-from litellm.router_utils.common_utils import filter_deployments_by_access_groups
-
-
-class TestFilterDeploymentsByAccessGroups:
-    """Tests for the filter_deployments_by_access_groups function."""
-
-    def test_no_filter_when_no_access_groups_in_metadata(self):
-        """When no allowed_access_groups in metadata, return all deployments."""
-        deployments = [
-            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
-            {"model_info": {"id": "2", "access_groups": ["AG2"]}},
-        ]
-        request_kwargs = {"metadata": {"user_api_key_team_id": "team-1"}}
-
-        result = filter_deployments_by_access_groups(
-            healthy_deployments=deployments,
-            request_kwargs=request_kwargs,
-        )
-
-        assert len(result) == 2  # All deployments returned
-
-    def test_filter_to_single_access_group(self):
-        """Filter to only deployments matching allowed access group."""
-        deployments = [
-            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
-            {"model_info": {"id": "2", "access_groups": ["AG2"]}},
-        ]
-        request_kwargs = {"metadata": {"user_api_key_allowed_access_groups": ["AG2"]}}
-
-        result = filter_deployments_by_access_groups(
-            healthy_deployments=deployments,
-            request_kwargs=request_kwargs,
-        )
-
-        assert len(result) == 1
-        assert result[0]["model_info"]["id"] == "2"
-
-    def test_filter_with_multiple_allowed_groups(self):
-        """Filter with multiple allowed access groups."""
-        deployments = [
-            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
-            {"model_info": {"id": "2", "access_groups": ["AG2"]}},
-            {"model_info": {"id": "3", "access_groups": ["AG3"]}},
-        ]
-        request_kwargs = {
-            "metadata": {"user_api_key_allowed_access_groups": ["AG1", "AG2"]}
-        }
-
-        result = filter_deployments_by_access_groups(
-            healthy_deployments=deployments,
-            request_kwargs=request_kwargs,
-        )
-
-        assert len(result) == 2
-        ids = [d["model_info"]["id"] for d in result]
-        assert "1" in ids
-        assert "2" in ids
-        assert "3" not in ids
-
-    def test_deployment_with_multiple_access_groups(self):
-        """Deployment with multiple access groups should match if any overlap."""
-        deployments = [
-            {"model_info": {"id": "1", "access_groups": ["AG1", "AG2"]}},
-            {"model_info": {"id": "2", "access_groups": ["AG3"]}},
-        ]
-        request_kwargs = {"metadata": {"user_api_key_allowed_access_groups": ["AG2"]}}
-
-        result = filter_deployments_by_access_groups(
-            healthy_deployments=deployments,
-            request_kwargs=request_kwargs,
-        )
-
-        assert len(result) == 1
-        assert result[0]["model_info"]["id"] == "1"
-
-    def test_deployment_without_access_groups_included(self):
-        """Deployments without access groups should be included (not restricted)."""
-        deployments = [
-            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
-            {"model_info": {"id": "2"}},  # No access_groups
-            {"model_info": {"id": "3", "access_groups": []}},  # Empty access_groups
-        ]
-        request_kwargs = {"metadata": {"user_api_key_allowed_access_groups": ["AG2"]}}
-
-        result = filter_deployments_by_access_groups(
-            healthy_deployments=deployments,
-            request_kwargs=request_kwargs,
-        )
-
-        # Should include deployments 2 and 3 (no restrictions)
-        assert len(result) == 2
-        ids = [d["model_info"]["id"] for d in result]
-        assert "2" in ids
-        assert "3" in ids
-
-    def test_dict_deployment_passes_through(self):
-        """When deployment is a dict (specific deployment), pass through."""
-        deployment = {"model_info": {"id": "1", "access_groups": ["AG1"]}}
-        request_kwargs = {"metadata": {"user_api_key_allowed_access_groups": ["AG2"]}}
-
-        result = filter_deployments_by_access_groups(
-            healthy_deployments=deployment,
-            request_kwargs=request_kwargs,
-        )
-
-        assert result == deployment  # Unchanged
-
-    def test_none_request_kwargs_passes_through(self):
-        """When request_kwargs is None, return deployments unchanged."""
-        deployments = [
-            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
-        ]
-
-        result = filter_deployments_by_access_groups(
-            healthy_deployments=deployments,
-            request_kwargs=None,
-        )
-
-        assert result == deployments
-
-    def test_litellm_metadata_fallback(self):
-        """Should also check litellm_metadata for allowed access groups."""
-        deployments = [
-            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
-            {"model_info": {"id": "2", "access_groups": ["AG2"]}},
-        ]
-        request_kwargs = {
-            "litellm_metadata": {"user_api_key_allowed_access_groups": ["AG1"]}
-        }
-
-        result = filter_deployments_by_access_groups(
-            healthy_deployments=deployments,
-            request_kwargs=request_kwargs,
-        )
-
-        assert len(result) == 1
-        assert result[0]["model_info"]["id"] == "1"
-
-
-def test_filter_deployments_by_access_groups_issue_18333():
-    """
-    Regression test for GitHub issue #18333.
-
-    Scenario: Two models named 'gpt-5' in different access groups (AG1, AG2).
-    Team2 has access to AG2 only. When Team2 requests 'gpt-5', only the AG2
-    deployment should be available for load balancing.
-    """
-    deployments = [
-        {
-            "model_name": "gpt-5",
-            "litellm_params": {"model": "gpt-4.1", "api_key": "key-1"},
-            "model_info": {"id": "ag1-deployment", "access_groups": ["AG1"]},
-        },
-        {
-            "model_name": "gpt-5",
-            "litellm_params": {"model": "gpt-4o", "api_key": "key-2"},
-            "model_info": {"id": "ag2-deployment", "access_groups": ["AG2"]},
-        },
-    ]
-
-    # Team2's request with allowed access groups
-    request_kwargs = {
-        "metadata": {
-            "user_api_key_team_id": "team-2",
-            "user_api_key_allowed_access_groups": ["AG2"],
-        }
-    }
-
-    result = filter_deployments_by_access_groups(
-        healthy_deployments=deployments,
-        request_kwargs=request_kwargs,
-    )
-
-    # Only AG2 deployment should be returned
-    assert len(result) == 1
-    assert result[0]["model_info"]["id"] == "ag2-deployment"
-    assert result[0]["litellm_params"]["model"] == "gpt-4o"
-
-
-def test_get_access_groups_from_models():
-    """
-    Test the helper function that extracts access group names from models list.
-    This is used by the proxy to populate user_api_key_allowed_access_groups.
-    """
-    from litellm.proxy.auth.model_checks import get_access_groups_from_models
-
-    # Setup: access groups definition
-    model_access_groups = {
-        "AG1": ["gpt-4", "gpt-5"],
-        "AG2": ["claude-v1", "claude-v2"],
-        "beta-models": ["gpt-5-turbo"],
-    }
-
-    # Test 1: Extract access groups from models list
-    models = ["gpt-4", "AG1", "AG2", "some-other-model"]
-    result = get_access_groups_from_models(
-        model_access_groups=model_access_groups, models=models
-    )
-    assert set(result) == {"AG1", "AG2"}
-
-    # Test 2: No access groups in models list
-    models = ["gpt-4", "claude-v1", "some-model"]
-    result = get_access_groups_from_models(
-        model_access_groups=model_access_groups, models=models
-    )
-    assert result == []
-
-    # Test 3: Empty models list
-    result = get_access_groups_from_models(
-        model_access_groups=model_access_groups, models=[]
-    )
-    assert result == []
-
-    # Test 4: All access groups
-    models = ["AG1", "AG2", "beta-models"]
-    result = get_access_groups_from_models(
-        model_access_groups=model_access_groups, models=models
-    )
-    assert set(result) == {"AG1", "AG2", "beta-models"}

From 86ae627007fb1d0b2088925547287d0cd99e32da Mon Sep 17 00:00:00 2001
From: Sameer Kankute <sameer@berri.ai>
Date: Tue, 3 Feb 2026 12:08:19 +0530
Subject: [PATCH 19/29] Fix
 litellm/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py
 tests

---
 .../test_semantic_tool_filter_e2e.py          | 19 +++++++++++++++++--
 .../mcp_server/test_semantic_tool_filter.py   | 16 +++++++++++++---
 2 files changed, 30 insertions(+), 5 deletions(-)

diff --git a/tests/mcp_tests/test_semantic_tool_filter_e2e.py b/tests/mcp_tests/test_semantic_tool_filter_e2e.py
index cf951c1884..91c072ae8a 100644
--- a/tests/mcp_tests/test_semantic_tool_filter_e2e.py
+++ b/tests/mcp_tests/test_semantic_tool_filter_e2e.py
@@ -12,8 +12,19 @@ sys.path.insert(0, os.path.abspath("../.."))
 
 from mcp.types import Tool as MCPTool
 
+# Check if semantic-router is available
+try:
+    import semantic_router
+    SEMANTIC_ROUTER_AVAILABLE = True
+except ImportError:
+    SEMANTIC_ROUTER_AVAILABLE = False
+
 
 @pytest.mark.asyncio
+@pytest.mark.skipif(
+    not SEMANTIC_ROUTER_AVAILABLE,
+    reason="semantic-router not installed. Install with: pip install 'litellm[semantic-router]'"
+)
 async def test_e2e_semantic_filter():
     """E2E: Load router/filter and verify hook filters tools."""
     from litellm import Router
@@ -37,8 +48,6 @@ async def test_e2e_semantic_filter():
         enabled=True,
     )
     
-    hook = SemanticToolFilterHook(filter_instance)
-    
     # Create 10 tools
     tools = [
         MCPTool(name="gmail_send", description="Send an email via Gmail", inputSchema={"type": "object"}),
@@ -53,10 +62,16 @@ async def test_e2e_semantic_filter():
         MCPTool(name="note_add", description="Add note", inputSchema={"type": "object"}),
     ]
     
+    # Build router with test tools
+    filter_instance._build_router(tools)
+    
+    hook = SemanticToolFilterHook(filter_instance)
+    
     data = {
         "model": "gpt-4",
         "messages": [{"role": "user", "content": "Send an email and create a calendar event"}],
         "tools": tools,
+        "metadata": {},  # Initialize metadata dict for hook to store filter stats
     }
     
     # Call hook
diff --git a/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py b/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py
index 8d35f5bbdc..87c597c659 100644
--- a/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py
+++ b/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py
@@ -71,6 +71,9 @@ async def test_semantic_filter_basic_filtering():
         enabled=True,
     )
     
+    # Build router with the tools before filtering
+    filter_instance._build_router(tools)
+    
     # Filter tools with email-related query
     filtered = await filter_instance.filter_tools(
         query="send an email to john@example.com",
@@ -139,6 +142,9 @@ async def test_semantic_filter_top_k_limiting():
         enabled=True,
     )
     
+    # Build router with the tools before filtering
+    filter_instance._build_router(tools)
+    
     # Filter tools
     filtered = await filter_instance.filter_tools(
         query="test query",
@@ -297,21 +303,25 @@ async def test_semantic_filter_hook_triggers_on_completion():
         enabled=True,
     )
     
-    # Create hook
-    hook = SemanticToolFilterHook(filter_instance)
-    
     # Prepare data - completion request with tools
     tools = [
         MCPTool(name=f"tool_{i}", description=f"Tool {i}", inputSchema={"type": "object"})
         for i in range(10)
     ]
     
+    # Build router with the tools before filtering
+    filter_instance._build_router(tools)
+    
+    # Create hook
+    hook = SemanticToolFilterHook(filter_instance)
+    
     data = {
         "model": "gpt-4",
         "messages": [
             {"role": "user", "content": "Send an email"}
         ],
         "tools": tools,
+        "metadata": {},  # Hook needs metadata field to store filter stats
     }
     
     # Mock user API key dict and cache

From b379fb6338690c674f1ff86c7fa1d58734148b04 Mon Sep 17 00:00:00 2001
From: Sameer Kankute <sameer@berri.ai>
Date: Tue, 3 Feb 2026 12:10:29 +0530
Subject: [PATCH 20/29] Fix code quality tests

---
 docs/my-website/docs/proxy/config_settings.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/docs/my-website/docs/proxy/config_settings.md b/docs/my-website/docs/proxy/config_settings.md
index 264c7d765b..385b4b0de3 100644
--- a/docs/my-website/docs/proxy/config_settings.md
+++ b/docs/my-website/docs/proxy/config_settings.md
@@ -545,6 +545,9 @@ router_settings:
 | DEFAULT_MAX_TOKENS | Default maximum tokens for LLM calls. Default is 4096
 | DEFAULT_MAX_TOKENS_FOR_TRITON | Default maximum tokens for Triton models. Default is 2000
 | DEFAULT_MAX_REDIS_BATCH_CACHE_SIZE | Default maximum size for redis batch cache. Default is 1000
+| DEFAULT_MCP_SEMANTIC_FILTER_EMBEDDING_MODEL | Default embedding model for MCP semantic tool filtering. Default is "text-embedding-3-small"
+| DEFAULT_MCP_SEMANTIC_FILTER_SIMILARITY_THRESHOLD | Default similarity threshold for MCP semantic tool filtering. Default is 0.3
+| DEFAULT_MCP_SEMANTIC_FILTER_TOP_K | Default number of top results to return for MCP semantic tool filtering. Default is 10
 | DEFAULT_MOCK_RESPONSE_COMPLETION_TOKEN_COUNT | Default token count for mock response completions. Default is 20
 | DEFAULT_MOCK_RESPONSE_PROMPT_TOKEN_COUNT | Default token count for mock response prompts. Default is 10
 | DEFAULT_MODEL_CREATED_AT_TIME | Default creation timestamp for models. Default is 1677610602
@@ -802,6 +805,7 @@ router_settings:
 | MAXIMUM_TRACEBACK_LINES_TO_LOG | Maximum number of lines to log in traceback in LiteLLM Logs UI. Default is 100
 | MAX_RETRY_DELAY | Maximum delay in seconds for retrying requests. Default is 8.0
 | MAX_LANGFUSE_INITIALIZED_CLIENTS | Maximum number of Langfuse clients to initialize on proxy. Default is 50. This is set since langfuse initializes 1 thread everytime a client is initialized. We've had an incident in the past where we reached 100% cpu utilization because Langfuse was initialized several times.
+| MAX_MCP_SEMANTIC_FILTER_TOOLS_HEADER_LENGTH | Maximum header length for MCP semantic filter tools. Default is 150
 | MIN_NON_ZERO_TEMPERATURE | Minimum non-zero temperature value. Default is 0.0001
 | MINIMUM_PROMPT_CACHE_TOKEN_COUNT | Minimum token count for caching a prompt. Default is 1024
 | MISTRAL_API_BASE | Base URL for Mistral API. Default is https://api.mistral.ai

From ecb6413028af12afd0924c7158c0a8aa964fe8ba Mon Sep 17 00:00:00 2001
From: Sameer Kankute <sameer@berri.ai>
Date: Tue, 3 Feb 2026 12:22:18 +0530
Subject: [PATCH 21/29] Revert "add missing indexes on VerificationToken table
 (#20040)"

This reverts commit 1e8848ca97bd53e596e715162d35d0d7953c9a08.
---
 .../migration.sql                                      |  8 --------
 .../litellm_proxy_extras/schema.prisma                 | 10 ----------
 litellm/proxy/schema.prisma                            | 10 ----------
 schema.prisma                                          | 10 ----------
 4 files changed, 38 deletions(-)
 delete mode 100644 litellm-proxy-extras/litellm_proxy_extras/migrations/20260129103648_add_verificationtoken_indexes/migration.sql

diff --git a/litellm-proxy-extras/litellm_proxy_extras/migrations/20260129103648_add_verificationtoken_indexes/migration.sql b/litellm-proxy-extras/litellm_proxy_extras/migrations/20260129103648_add_verificationtoken_indexes/migration.sql
deleted file mode 100644
index 572eea9b52..0000000000
--- a/litellm-proxy-extras/litellm_proxy_extras/migrations/20260129103648_add_verificationtoken_indexes/migration.sql
+++ /dev/null
@@ -1,8 +0,0 @@
--- CreateIndex
-CREATE INDEX "LiteLLM_VerificationToken_user_id_team_id_idx" ON "LiteLLM_VerificationToken"("user_id", "team_id");
-
--- CreateIndex
-CREATE INDEX "LiteLLM_VerificationToken_team_id_idx" ON "LiteLLM_VerificationToken"("team_id");
-
--- CreateIndex
-CREATE INDEX "LiteLLM_VerificationToken_budget_reset_at_expires_idx" ON "LiteLLM_VerificationToken"("budget_reset_at", "expires");
diff --git a/litellm-proxy-extras/litellm_proxy_extras/schema.prisma b/litellm-proxy-extras/litellm_proxy_extras/schema.prisma
index 3b81da1092..b118400b62 100644
--- a/litellm-proxy-extras/litellm_proxy_extras/schema.prisma
+++ b/litellm-proxy-extras/litellm_proxy_extras/schema.prisma
@@ -305,16 +305,6 @@ model LiteLLM_VerificationToken {
     litellm_budget_table LiteLLM_BudgetTable?   @relation(fields: [budget_id], references: [budget_id])
     litellm_organization_table LiteLLM_OrganizationTable?   @relation(fields: [organization_id], references: [organization_id])
     object_permission LiteLLM_ObjectPermissionTable?   @relation(fields: [object_permission_id], references: [object_permission_id])
-
-    // SELECT COUNT(*) FROM (SELECT "public"."LiteLLM_VerificationToken"."token" FROM "public"."LiteLLM_VerificationToken" WHERE ("public"."LiteLLM_VerificationToken"."user_id" = $1 AND ("public"."LiteLLM_VerificationToken"."team_id" IS NULL OR "public"."LiteLLM_VerificationToken"."team_id" <> $2)) OFFSET $3 ) AS "sub"
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."user_id" = $1 OFFSET $2
-    @@index([user_id, team_id])
-
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."team_id" = $1 OFFSET $2
-    @@index([team_id])
-
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE (("public"."LiteLLM_VerificationToken"."expires" IS NULL OR "public"."LiteLLM_VerificationToken"."expires" > $1) AND "public"."LiteLLM_VerificationToken"."budget_reset_at" < $2) OFFSET $3
-    @@index([budget_reset_at, expires])
 }
 
 // Audit table for deleted keys - preserves spend and key information for historical tracking
diff --git a/litellm/proxy/schema.prisma b/litellm/proxy/schema.prisma
index 3b81da1092..b118400b62 100644
--- a/litellm/proxy/schema.prisma
+++ b/litellm/proxy/schema.prisma
@@ -305,16 +305,6 @@ model LiteLLM_VerificationToken {
     litellm_budget_table LiteLLM_BudgetTable?   @relation(fields: [budget_id], references: [budget_id])
     litellm_organization_table LiteLLM_OrganizationTable?   @relation(fields: [organization_id], references: [organization_id])
     object_permission LiteLLM_ObjectPermissionTable?   @relation(fields: [object_permission_id], references: [object_permission_id])
-
-    // SELECT COUNT(*) FROM (SELECT "public"."LiteLLM_VerificationToken"."token" FROM "public"."LiteLLM_VerificationToken" WHERE ("public"."LiteLLM_VerificationToken"."user_id" = $1 AND ("public"."LiteLLM_VerificationToken"."team_id" IS NULL OR "public"."LiteLLM_VerificationToken"."team_id" <> $2)) OFFSET $3 ) AS "sub"
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."user_id" = $1 OFFSET $2
-    @@index([user_id, team_id])
-
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."team_id" = $1 OFFSET $2
-    @@index([team_id])
-
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE (("public"."LiteLLM_VerificationToken"."expires" IS NULL OR "public"."LiteLLM_VerificationToken"."expires" > $1) AND "public"."LiteLLM_VerificationToken"."budget_reset_at" < $2) OFFSET $3
-    @@index([budget_reset_at, expires])
 }
 
 // Audit table for deleted keys - preserves spend and key information for historical tracking
diff --git a/schema.prisma b/schema.prisma
index 3b81da1092..b118400b62 100644
--- a/schema.prisma
+++ b/schema.prisma
@@ -305,16 +305,6 @@ model LiteLLM_VerificationToken {
     litellm_budget_table LiteLLM_BudgetTable?   @relation(fields: [budget_id], references: [budget_id])
     litellm_organization_table LiteLLM_OrganizationTable?   @relation(fields: [organization_id], references: [organization_id])
     object_permission LiteLLM_ObjectPermissionTable?   @relation(fields: [object_permission_id], references: [object_permission_id])
-
-    // SELECT COUNT(*) FROM (SELECT "public"."LiteLLM_VerificationToken"."token" FROM "public"."LiteLLM_VerificationToken" WHERE ("public"."LiteLLM_VerificationToken"."user_id" = $1 AND ("public"."LiteLLM_VerificationToken"."team_id" IS NULL OR "public"."LiteLLM_VerificationToken"."team_id" <> $2)) OFFSET $3 ) AS "sub"
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."user_id" = $1 OFFSET $2
-    @@index([user_id, team_id])
-
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."team_id" = $1 OFFSET $2
-    @@index([team_id])
-
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE (("public"."LiteLLM_VerificationToken"."expires" IS NULL OR "public"."LiteLLM_VerificationToken"."expires" > $1) AND "public"."LiteLLM_VerificationToken"."budget_reset_at" < $2) OFFSET $3
-    @@index([budget_reset_at, expires])
 }
 
 // Audit table for deleted keys - preserves spend and key information for historical tracking

From 1b1854b704ae8b3640984fa4df26f37091603dd9 Mon Sep 17 00:00:00 2001
From: Sameer Kankute <sameer@berri.ai>
Date: Tue, 3 Feb 2026 14:29:16 +0530
Subject: [PATCH 22/29] Revert "Litellm tuesday cicd release"

---
 docs/my-website/docs/proxy/config_settings.md |   4 -
 .../migration.sql                             |   8 +
 .../litellm_proxy_extras/schema.prisma        |  10 +
 litellm/proxy/auth/model_checks.py            |  25 +-
 litellm/proxy/litellm_pre_call_utils.py       |  31 +++
 litellm/proxy/schema.prisma                   |  10 +
 litellm/router.py                             |  12 +-
 litellm/router_utils/common_utils.py          |  79 +++++-
 schema.prisma                                 |  10 +
 .../test_semantic_tool_filter_e2e.py          |  19 +-
 .../mcp_server/test_semantic_tool_filter.py   |  16 +-
 ...est_filter_deployments_by_access_groups.py | 227 ++++++++++++++++++
 12 files changed, 411 insertions(+), 40 deletions(-)
 create mode 100644 litellm-proxy-extras/litellm_proxy_extras/migrations/20260129103648_add_verificationtoken_indexes/migration.sql
 create mode 100644 tests/test_litellm/router_unit_tests/test_filter_deployments_by_access_groups.py

diff --git a/docs/my-website/docs/proxy/config_settings.md b/docs/my-website/docs/proxy/config_settings.md
index 385b4b0de3..264c7d765b 100644
--- a/docs/my-website/docs/proxy/config_settings.md
+++ b/docs/my-website/docs/proxy/config_settings.md
@@ -545,9 +545,6 @@ router_settings:
 | DEFAULT_MAX_TOKENS | Default maximum tokens for LLM calls. Default is 4096
 | DEFAULT_MAX_TOKENS_FOR_TRITON | Default maximum tokens for Triton models. Default is 2000
 | DEFAULT_MAX_REDIS_BATCH_CACHE_SIZE | Default maximum size for redis batch cache. Default is 1000
-| DEFAULT_MCP_SEMANTIC_FILTER_EMBEDDING_MODEL | Default embedding model for MCP semantic tool filtering. Default is "text-embedding-3-small"
-| DEFAULT_MCP_SEMANTIC_FILTER_SIMILARITY_THRESHOLD | Default similarity threshold for MCP semantic tool filtering. Default is 0.3
-| DEFAULT_MCP_SEMANTIC_FILTER_TOP_K | Default number of top results to return for MCP semantic tool filtering. Default is 10
 | DEFAULT_MOCK_RESPONSE_COMPLETION_TOKEN_COUNT | Default token count for mock response completions. Default is 20
 | DEFAULT_MOCK_RESPONSE_PROMPT_TOKEN_COUNT | Default token count for mock response prompts. Default is 10
 | DEFAULT_MODEL_CREATED_AT_TIME | Default creation timestamp for models. Default is 1677610602
@@ -805,7 +802,6 @@ router_settings:
 | MAXIMUM_TRACEBACK_LINES_TO_LOG | Maximum number of lines to log in traceback in LiteLLM Logs UI. Default is 100
 | MAX_RETRY_DELAY | Maximum delay in seconds for retrying requests. Default is 8.0
 | MAX_LANGFUSE_INITIALIZED_CLIENTS | Maximum number of Langfuse clients to initialize on proxy. Default is 50. This is set since langfuse initializes 1 thread everytime a client is initialized. We've had an incident in the past where we reached 100% cpu utilization because Langfuse was initialized several times.
-| MAX_MCP_SEMANTIC_FILTER_TOOLS_HEADER_LENGTH | Maximum header length for MCP semantic filter tools. Default is 150
 | MIN_NON_ZERO_TEMPERATURE | Minimum non-zero temperature value. Default is 0.0001
 | MINIMUM_PROMPT_CACHE_TOKEN_COUNT | Minimum token count for caching a prompt. Default is 1024
 | MISTRAL_API_BASE | Base URL for Mistral API. Default is https://api.mistral.ai
diff --git a/litellm-proxy-extras/litellm_proxy_extras/migrations/20260129103648_add_verificationtoken_indexes/migration.sql b/litellm-proxy-extras/litellm_proxy_extras/migrations/20260129103648_add_verificationtoken_indexes/migration.sql
new file mode 100644
index 0000000000..572eea9b52
--- /dev/null
+++ b/litellm-proxy-extras/litellm_proxy_extras/migrations/20260129103648_add_verificationtoken_indexes/migration.sql
@@ -0,0 +1,8 @@
+-- CreateIndex
+CREATE INDEX "LiteLLM_VerificationToken_user_id_team_id_idx" ON "LiteLLM_VerificationToken"("user_id", "team_id");
+
+-- CreateIndex
+CREATE INDEX "LiteLLM_VerificationToken_team_id_idx" ON "LiteLLM_VerificationToken"("team_id");
+
+-- CreateIndex
+CREATE INDEX "LiteLLM_VerificationToken_budget_reset_at_expires_idx" ON "LiteLLM_VerificationToken"("budget_reset_at", "expires");
diff --git a/litellm-proxy-extras/litellm_proxy_extras/schema.prisma b/litellm-proxy-extras/litellm_proxy_extras/schema.prisma
index b118400b62..3b81da1092 100644
--- a/litellm-proxy-extras/litellm_proxy_extras/schema.prisma
+++ b/litellm-proxy-extras/litellm_proxy_extras/schema.prisma
@@ -305,6 +305,16 @@ model LiteLLM_VerificationToken {
     litellm_budget_table LiteLLM_BudgetTable?   @relation(fields: [budget_id], references: [budget_id])
     litellm_organization_table LiteLLM_OrganizationTable?   @relation(fields: [organization_id], references: [organization_id])
     object_permission LiteLLM_ObjectPermissionTable?   @relation(fields: [object_permission_id], references: [object_permission_id])
+
+    // SELECT COUNT(*) FROM (SELECT "public"."LiteLLM_VerificationToken"."token" FROM "public"."LiteLLM_VerificationToken" WHERE ("public"."LiteLLM_VerificationToken"."user_id" = $1 AND ("public"."LiteLLM_VerificationToken"."team_id" IS NULL OR "public"."LiteLLM_VerificationToken"."team_id" <> $2)) OFFSET $3 ) AS "sub"
+    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."user_id" = $1 OFFSET $2
+    @@index([user_id, team_id])
+
+    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."team_id" = $1 OFFSET $2
+    @@index([team_id])
+
+    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE (("public"."LiteLLM_VerificationToken"."expires" IS NULL OR "public"."LiteLLM_VerificationToken"."expires" > $1) AND "public"."LiteLLM_VerificationToken"."budget_reset_at" < $2) OFFSET $3
+    @@index([budget_reset_at, expires])
 }
 
 // Audit table for deleted keys - preserves spend and key information for historical tracking
diff --git a/litellm/proxy/auth/model_checks.py b/litellm/proxy/auth/model_checks.py
index 71ae1348f3..af2574d88e 100644
--- a/litellm/proxy/auth/model_checks.py
+++ b/litellm/proxy/auth/model_checks.py
@@ -64,6 +64,27 @@ def _get_models_from_access_groups(
     return all_models
 
 
+def get_access_groups_from_models(
+    model_access_groups: Dict[str, List[str]],
+    models: List[str],
+) -> List[str]:
+    """
+    Extract access group names from a models list.
+
+    Given a models list like ["gpt-4", "beta-models", "claude-v1"]
+    and access groups like {"beta-models": ["gpt-5", "gpt-6"]},
+    returns ["beta-models"].
+
+    This is used to pass allowed access groups to the router for filtering
+    deployments during load balancing (GitHub issue #18333).
+    """
+    access_groups = []
+    for model in models:
+        if model in model_access_groups:
+            access_groups.append(model)
+    return access_groups
+
+
 async def get_mcp_server_ids(
     user_api_key_dict: UserAPIKeyAuth,
 ) -> List[str]:
@@ -80,7 +101,6 @@ async def get_mcp_server_ids(
 
     # Make a direct SQL query to get just the mcp_servers
     try:
-
         result = await prisma_client.db.litellm_objectpermissiontable.find_unique(
             where={"object_permission_id": user_api_key_dict.object_permission_id},
         )
@@ -176,6 +196,7 @@ def get_complete_model_list(
     """
 
     unique_models = []
+
     def append_unique(models):
         for model in models:
             if model not in unique_models:
@@ -188,7 +209,7 @@ def get_complete_model_list(
     else:
         append_unique(proxy_model_list)
         if include_model_access_groups:
-            append_unique(list(model_access_groups.keys())) # TODO: keys order
+            append_unique(list(model_access_groups.keys()))  # TODO: keys order
 
         if user_model:
             append_unique([user_model])
diff --git a/litellm/proxy/litellm_pre_call_utils.py b/litellm/proxy/litellm_pre_call_utils.py
index 9be78264e8..72f23e609a 100644
--- a/litellm/proxy/litellm_pre_call_utils.py
+++ b/litellm/proxy/litellm_pre_call_utils.py
@@ -1021,6 +1021,37 @@ async def add_litellm_data_to_request(  # noqa: PLR0915
         "user_api_key_user_max_budget"
     ] = user_api_key_dict.user_max_budget
 
+    # Extract allowed access groups for router filtering (GitHub issue #18333)
+    # This allows the router to filter deployments based on key's and team's access groups
+    # NOTE: We keep key and team access groups SEPARATE because a key doesn't always
+    # inherit all team access groups (per maintainer feedback).
+    if llm_router is not None:
+        from litellm.proxy.auth.model_checks import get_access_groups_from_models
+
+        model_access_groups = llm_router.get_model_access_groups()
+
+        # Key-level access groups (from user_api_key_dict.models)
+        key_models = list(user_api_key_dict.models) if user_api_key_dict.models else []
+        key_allowed_access_groups = get_access_groups_from_models(
+            model_access_groups=model_access_groups, models=key_models
+        )
+        if key_allowed_access_groups:
+            data[_metadata_variable_name][
+                "user_api_key_allowed_access_groups"
+            ] = key_allowed_access_groups
+
+        # Team-level access groups (from user_api_key_dict.team_models)
+        team_models = (
+            list(user_api_key_dict.team_models) if user_api_key_dict.team_models else []
+        )
+        team_allowed_access_groups = get_access_groups_from_models(
+            model_access_groups=model_access_groups, models=team_models
+        )
+        if team_allowed_access_groups:
+            data[_metadata_variable_name][
+                "user_api_key_team_allowed_access_groups"
+            ] = team_allowed_access_groups
+
     data[_metadata_variable_name]["user_api_key_metadata"] = user_api_key_dict.metadata
     _headers = dict(request.headers)
     _headers.pop(
diff --git a/litellm/proxy/schema.prisma b/litellm/proxy/schema.prisma
index b118400b62..3b81da1092 100644
--- a/litellm/proxy/schema.prisma
+++ b/litellm/proxy/schema.prisma
@@ -305,6 +305,16 @@ model LiteLLM_VerificationToken {
     litellm_budget_table LiteLLM_BudgetTable?   @relation(fields: [budget_id], references: [budget_id])
     litellm_organization_table LiteLLM_OrganizationTable?   @relation(fields: [organization_id], references: [organization_id])
     object_permission LiteLLM_ObjectPermissionTable?   @relation(fields: [object_permission_id], references: [object_permission_id])
+
+    // SELECT COUNT(*) FROM (SELECT "public"."LiteLLM_VerificationToken"."token" FROM "public"."LiteLLM_VerificationToken" WHERE ("public"."LiteLLM_VerificationToken"."user_id" = $1 AND ("public"."LiteLLM_VerificationToken"."team_id" IS NULL OR "public"."LiteLLM_VerificationToken"."team_id" <> $2)) OFFSET $3 ) AS "sub"
+    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."user_id" = $1 OFFSET $2
+    @@index([user_id, team_id])
+
+    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."team_id" = $1 OFFSET $2
+    @@index([team_id])
+
+    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE (("public"."LiteLLM_VerificationToken"."expires" IS NULL OR "public"."LiteLLM_VerificationToken"."expires" > $1) AND "public"."LiteLLM_VerificationToken"."budget_reset_at" < $2) OFFSET $3
+    @@index([budget_reset_at, expires])
 }
 
 // Audit table for deleted keys - preserves spend and key information for historical tracking
diff --git a/litellm/router.py b/litellm/router.py
index d01c8443da..65445e29c4 100644
--- a/litellm/router.py
+++ b/litellm/router.py
@@ -88,6 +88,7 @@ from litellm.router_utils.clientside_credential_handler import (
     is_clientside_credential,
 )
 from litellm.router_utils.common_utils import (
+    filter_deployments_by_access_groups,
     filter_team_based_models,
     filter_web_search_deployments,
 )
@@ -8087,10 +8088,17 @@ class Router:
             request_kwargs=request_kwargs,
         )
 
-        verbose_router_logger.debug(
-            f"healthy_deployments after web search filter: {healthy_deployments}"
+        verbose_router_logger.debug(f"healthy_deployments after web search filter: {healthy_deployments}")
+
+        # Filter by allowed access groups (GitHub issue #18333)
+        # This prevents cross-team load balancing when teams have models with same name in different access groups
+        healthy_deployments = filter_deployments_by_access_groups(
+            healthy_deployments=healthy_deployments,
+            request_kwargs=request_kwargs,
         )
 
+        verbose_router_logger.debug(f"healthy_deployments after access group filter: {healthy_deployments}")
+
         if isinstance(healthy_deployments, dict):
             return healthy_deployments
 
diff --git a/litellm/router_utils/common_utils.py b/litellm/router_utils/common_utils.py
index 10acc343ab..2c0ea5976d 100644
--- a/litellm/router_utils/common_utils.py
+++ b/litellm/router_utils/common_utils.py
@@ -75,6 +75,7 @@ def filter_team_based_models(
         if deployment.get("model_info", {}).get("id") not in ids_to_remove
     ]
 
+
 def _deployment_supports_web_search(deployment: Dict) -> bool:
     """
     Check if a deployment supports web search.
@@ -112,7 +113,7 @@ def filter_web_search_deployments(
     is_web_search_request = False
     tools = request_kwargs.get("tools") or []
     for tool in tools:
-        # These are the two websearch tools for OpenAI / Azure. 
+        # These are the two websearch tools for OpenAI / Azure.
         if tool.get("type") == "web_search" or tool.get("type") == "web_search_preview":
             is_web_search_request = True
             break
@@ -121,8 +122,82 @@ def filter_web_search_deployments(
         return healthy_deployments
 
     # Filter out deployments that don't support web search
-    final_deployments = [d for d in healthy_deployments if _deployment_supports_web_search(d)]
+    final_deployments = [
+        d for d in healthy_deployments if _deployment_supports_web_search(d)
+    ]
     if len(healthy_deployments) > 0 and len(final_deployments) == 0:
         verbose_logger.warning("No deployments support web search for request")
     return final_deployments
 
+
+def filter_deployments_by_access_groups(
+    healthy_deployments: Union[List[Dict], Dict],
+    request_kwargs: Optional[Dict] = None,
+) -> Union[List[Dict], Dict]:
+    """
+    Filter deployments to only include those matching the user's allowed access groups.
+
+    Reads from TWO separate metadata fields (per maintainer feedback):
+    - `user_api_key_allowed_access_groups`: Access groups from the API Key's models.
+    - `user_api_key_team_allowed_access_groups`: Access groups from the Team's models.
+
+    A deployment is included if its access_groups overlap with EITHER the key's
+    or the team's allowed access groups. Deployments with no access_groups are
+    always included (not restricted).
+
+    This prevents cross-team load balancing when multiple teams have models with
+    the same name but in different access groups (GitHub issue #18333).
+    """
+    if request_kwargs is None:
+        return healthy_deployments
+
+    if isinstance(healthy_deployments, dict):
+        return healthy_deployments
+
+    metadata = request_kwargs.get("metadata") or {}
+    litellm_metadata = request_kwargs.get("litellm_metadata") or {}
+
+    # Gather key-level allowed access groups
+    key_allowed_access_groups = (
+        metadata.get("user_api_key_allowed_access_groups")
+        or litellm_metadata.get("user_api_key_allowed_access_groups")
+        or []
+    )
+
+    # Gather team-level allowed access groups
+    team_allowed_access_groups = (
+        metadata.get("user_api_key_team_allowed_access_groups")
+        or litellm_metadata.get("user_api_key_team_allowed_access_groups")
+        or []
+    )
+
+    # Combine both for the final allowed set
+    combined_allowed_access_groups = list(key_allowed_access_groups) + list(
+        team_allowed_access_groups
+    )
+
+    # If no access groups specified from either source, return all deployments (backwards compatible)
+    if not combined_allowed_access_groups:
+        return healthy_deployments
+
+    allowed_set = set(combined_allowed_access_groups)
+    filtered = []
+    for deployment in healthy_deployments:
+        model_info = deployment.get("model_info") or {}
+        deployment_access_groups = model_info.get("access_groups") or []
+
+        # If deployment has no access groups, include it (not restricted)
+        if not deployment_access_groups:
+            filtered.append(deployment)
+            continue
+
+        # Include if any of deployment's groups overlap with allowed groups
+        if set(deployment_access_groups) & allowed_set:
+            filtered.append(deployment)
+
+    if len(healthy_deployments) > 0 and len(filtered) == 0:
+        verbose_logger.warning(
+            f"No deployments match allowed access groups {combined_allowed_access_groups}"
+        )
+
+    return filtered
diff --git a/schema.prisma b/schema.prisma
index b118400b62..3b81da1092 100644
--- a/schema.prisma
+++ b/schema.prisma
@@ -305,6 +305,16 @@ model LiteLLM_VerificationToken {
     litellm_budget_table LiteLLM_BudgetTable?   @relation(fields: [budget_id], references: [budget_id])
     litellm_organization_table LiteLLM_OrganizationTable?   @relation(fields: [organization_id], references: [organization_id])
     object_permission LiteLLM_ObjectPermissionTable?   @relation(fields: [object_permission_id], references: [object_permission_id])
+
+    // SELECT COUNT(*) FROM (SELECT "public"."LiteLLM_VerificationToken"."token" FROM "public"."LiteLLM_VerificationToken" WHERE ("public"."LiteLLM_VerificationToken"."user_id" = $1 AND ("public"."LiteLLM_VerificationToken"."team_id" IS NULL OR "public"."LiteLLM_VerificationToken"."team_id" <> $2)) OFFSET $3 ) AS "sub"
+    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."user_id" = $1 OFFSET $2
+    @@index([user_id, team_id])
+
+    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."team_id" = $1 OFFSET $2
+    @@index([team_id])
+
+    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE (("public"."LiteLLM_VerificationToken"."expires" IS NULL OR "public"."LiteLLM_VerificationToken"."expires" > $1) AND "public"."LiteLLM_VerificationToken"."budget_reset_at" < $2) OFFSET $3
+    @@index([budget_reset_at, expires])
 }
 
 // Audit table for deleted keys - preserves spend and key information for historical tracking
diff --git a/tests/mcp_tests/test_semantic_tool_filter_e2e.py b/tests/mcp_tests/test_semantic_tool_filter_e2e.py
index 91c072ae8a..cf951c1884 100644
--- a/tests/mcp_tests/test_semantic_tool_filter_e2e.py
+++ b/tests/mcp_tests/test_semantic_tool_filter_e2e.py
@@ -12,19 +12,8 @@ sys.path.insert(0, os.path.abspath("../.."))
 
 from mcp.types import Tool as MCPTool
 
-# Check if semantic-router is available
-try:
-    import semantic_router
-    SEMANTIC_ROUTER_AVAILABLE = True
-except ImportError:
-    SEMANTIC_ROUTER_AVAILABLE = False
-
 
 @pytest.mark.asyncio
-@pytest.mark.skipif(
-    not SEMANTIC_ROUTER_AVAILABLE,
-    reason="semantic-router not installed. Install with: pip install 'litellm[semantic-router]'"
-)
 async def test_e2e_semantic_filter():
     """E2E: Load router/filter and verify hook filters tools."""
     from litellm import Router
@@ -48,6 +37,8 @@ async def test_e2e_semantic_filter():
         enabled=True,
     )
     
+    hook = SemanticToolFilterHook(filter_instance)
+    
     # Create 10 tools
     tools = [
         MCPTool(name="gmail_send", description="Send an email via Gmail", inputSchema={"type": "object"}),
@@ -62,16 +53,10 @@ async def test_e2e_semantic_filter():
         MCPTool(name="note_add", description="Add note", inputSchema={"type": "object"}),
     ]
     
-    # Build router with test tools
-    filter_instance._build_router(tools)
-    
-    hook = SemanticToolFilterHook(filter_instance)
-    
     data = {
         "model": "gpt-4",
         "messages": [{"role": "user", "content": "Send an email and create a calendar event"}],
         "tools": tools,
-        "metadata": {},  # Initialize metadata dict for hook to store filter stats
     }
     
     # Call hook
diff --git a/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py b/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py
index 87c597c659..8d35f5bbdc 100644
--- a/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py
+++ b/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py
@@ -71,9 +71,6 @@ async def test_semantic_filter_basic_filtering():
         enabled=True,
     )
     
-    # Build router with the tools before filtering
-    filter_instance._build_router(tools)
-    
     # Filter tools with email-related query
     filtered = await filter_instance.filter_tools(
         query="send an email to john@example.com",
@@ -142,9 +139,6 @@ async def test_semantic_filter_top_k_limiting():
         enabled=True,
     )
     
-    # Build router with the tools before filtering
-    filter_instance._build_router(tools)
-    
     # Filter tools
     filtered = await filter_instance.filter_tools(
         query="test query",
@@ -303,25 +297,21 @@ async def test_semantic_filter_hook_triggers_on_completion():
         enabled=True,
     )
     
+    # Create hook
+    hook = SemanticToolFilterHook(filter_instance)
+    
     # Prepare data - completion request with tools
     tools = [
         MCPTool(name=f"tool_{i}", description=f"Tool {i}", inputSchema={"type": "object"})
         for i in range(10)
     ]
     
-    # Build router with the tools before filtering
-    filter_instance._build_router(tools)
-    
-    # Create hook
-    hook = SemanticToolFilterHook(filter_instance)
-    
     data = {
         "model": "gpt-4",
         "messages": [
             {"role": "user", "content": "Send an email"}
         ],
         "tools": tools,
-        "metadata": {},  # Hook needs metadata field to store filter stats
     }
     
     # Mock user API key dict and cache
diff --git a/tests/test_litellm/router_unit_tests/test_filter_deployments_by_access_groups.py b/tests/test_litellm/router_unit_tests/test_filter_deployments_by_access_groups.py
new file mode 100644
index 0000000000..9ac5072c5d
--- /dev/null
+++ b/tests/test_litellm/router_unit_tests/test_filter_deployments_by_access_groups.py
@@ -0,0 +1,227 @@
+"""
+Unit tests for filter_deployments_by_access_groups function.
+
+Tests the fix for GitHub issue #18333: Models loadbalanced outside of Model Access Group.
+"""
+
+import pytest
+
+from litellm.router_utils.common_utils import filter_deployments_by_access_groups
+
+
+class TestFilterDeploymentsByAccessGroups:
+    """Tests for the filter_deployments_by_access_groups function."""
+
+    def test_no_filter_when_no_access_groups_in_metadata(self):
+        """When no allowed_access_groups in metadata, return all deployments."""
+        deployments = [
+            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
+            {"model_info": {"id": "2", "access_groups": ["AG2"]}},
+        ]
+        request_kwargs = {"metadata": {"user_api_key_team_id": "team-1"}}
+
+        result = filter_deployments_by_access_groups(
+            healthy_deployments=deployments,
+            request_kwargs=request_kwargs,
+        )
+
+        assert len(result) == 2  # All deployments returned
+
+    def test_filter_to_single_access_group(self):
+        """Filter to only deployments matching allowed access group."""
+        deployments = [
+            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
+            {"model_info": {"id": "2", "access_groups": ["AG2"]}},
+        ]
+        request_kwargs = {"metadata": {"user_api_key_allowed_access_groups": ["AG2"]}}
+
+        result = filter_deployments_by_access_groups(
+            healthy_deployments=deployments,
+            request_kwargs=request_kwargs,
+        )
+
+        assert len(result) == 1
+        assert result[0]["model_info"]["id"] == "2"
+
+    def test_filter_with_multiple_allowed_groups(self):
+        """Filter with multiple allowed access groups."""
+        deployments = [
+            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
+            {"model_info": {"id": "2", "access_groups": ["AG2"]}},
+            {"model_info": {"id": "3", "access_groups": ["AG3"]}},
+        ]
+        request_kwargs = {
+            "metadata": {"user_api_key_allowed_access_groups": ["AG1", "AG2"]}
+        }
+
+        result = filter_deployments_by_access_groups(
+            healthy_deployments=deployments,
+            request_kwargs=request_kwargs,
+        )
+
+        assert len(result) == 2
+        ids = [d["model_info"]["id"] for d in result]
+        assert "1" in ids
+        assert "2" in ids
+        assert "3" not in ids
+
+    def test_deployment_with_multiple_access_groups(self):
+        """Deployment with multiple access groups should match if any overlap."""
+        deployments = [
+            {"model_info": {"id": "1", "access_groups": ["AG1", "AG2"]}},
+            {"model_info": {"id": "2", "access_groups": ["AG3"]}},
+        ]
+        request_kwargs = {"metadata": {"user_api_key_allowed_access_groups": ["AG2"]}}
+
+        result = filter_deployments_by_access_groups(
+            healthy_deployments=deployments,
+            request_kwargs=request_kwargs,
+        )
+
+        assert len(result) == 1
+        assert result[0]["model_info"]["id"] == "1"
+
+    def test_deployment_without_access_groups_included(self):
+        """Deployments without access groups should be included (not restricted)."""
+        deployments = [
+            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
+            {"model_info": {"id": "2"}},  # No access_groups
+            {"model_info": {"id": "3", "access_groups": []}},  # Empty access_groups
+        ]
+        request_kwargs = {"metadata": {"user_api_key_allowed_access_groups": ["AG2"]}}
+
+        result = filter_deployments_by_access_groups(
+            healthy_deployments=deployments,
+            request_kwargs=request_kwargs,
+        )
+
+        # Should include deployments 2 and 3 (no restrictions)
+        assert len(result) == 2
+        ids = [d["model_info"]["id"] for d in result]
+        assert "2" in ids
+        assert "3" in ids
+
+    def test_dict_deployment_passes_through(self):
+        """When deployment is a dict (specific deployment), pass through."""
+        deployment = {"model_info": {"id": "1", "access_groups": ["AG1"]}}
+        request_kwargs = {"metadata": {"user_api_key_allowed_access_groups": ["AG2"]}}
+
+        result = filter_deployments_by_access_groups(
+            healthy_deployments=deployment,
+            request_kwargs=request_kwargs,
+        )
+
+        assert result == deployment  # Unchanged
+
+    def test_none_request_kwargs_passes_through(self):
+        """When request_kwargs is None, return deployments unchanged."""
+        deployments = [
+            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
+        ]
+
+        result = filter_deployments_by_access_groups(
+            healthy_deployments=deployments,
+            request_kwargs=None,
+        )
+
+        assert result == deployments
+
+    def test_litellm_metadata_fallback(self):
+        """Should also check litellm_metadata for allowed access groups."""
+        deployments = [
+            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
+            {"model_info": {"id": "2", "access_groups": ["AG2"]}},
+        ]
+        request_kwargs = {
+            "litellm_metadata": {"user_api_key_allowed_access_groups": ["AG1"]}
+        }
+
+        result = filter_deployments_by_access_groups(
+            healthy_deployments=deployments,
+            request_kwargs=request_kwargs,
+        )
+
+        assert len(result) == 1
+        assert result[0]["model_info"]["id"] == "1"
+
+
+def test_filter_deployments_by_access_groups_issue_18333():
+    """
+    Regression test for GitHub issue #18333.
+
+    Scenario: Two models named 'gpt-5' in different access groups (AG1, AG2).
+    Team2 has access to AG2 only. When Team2 requests 'gpt-5', only the AG2
+    deployment should be available for load balancing.
+    """
+    deployments = [
+        {
+            "model_name": "gpt-5",
+            "litellm_params": {"model": "gpt-4.1", "api_key": "key-1"},
+            "model_info": {"id": "ag1-deployment", "access_groups": ["AG1"]},
+        },
+        {
+            "model_name": "gpt-5",
+            "litellm_params": {"model": "gpt-4o", "api_key": "key-2"},
+            "model_info": {"id": "ag2-deployment", "access_groups": ["AG2"]},
+        },
+    ]
+
+    # Team2's request with allowed access groups
+    request_kwargs = {
+        "metadata": {
+            "user_api_key_team_id": "team-2",
+            "user_api_key_allowed_access_groups": ["AG2"],
+        }
+    }
+
+    result = filter_deployments_by_access_groups(
+        healthy_deployments=deployments,
+        request_kwargs=request_kwargs,
+    )
+
+    # Only AG2 deployment should be returned
+    assert len(result) == 1
+    assert result[0]["model_info"]["id"] == "ag2-deployment"
+    assert result[0]["litellm_params"]["model"] == "gpt-4o"
+
+
+def test_get_access_groups_from_models():
+    """
+    Test the helper function that extracts access group names from models list.
+    This is used by the proxy to populate user_api_key_allowed_access_groups.
+    """
+    from litellm.proxy.auth.model_checks import get_access_groups_from_models
+
+    # Setup: access groups definition
+    model_access_groups = {
+        "AG1": ["gpt-4", "gpt-5"],
+        "AG2": ["claude-v1", "claude-v2"],
+        "beta-models": ["gpt-5-turbo"],
+    }
+
+    # Test 1: Extract access groups from models list
+    models = ["gpt-4", "AG1", "AG2", "some-other-model"]
+    result = get_access_groups_from_models(
+        model_access_groups=model_access_groups, models=models
+    )
+    assert set(result) == {"AG1", "AG2"}
+
+    # Test 2: No access groups in models list
+    models = ["gpt-4", "claude-v1", "some-model"]
+    result = get_access_groups_from_models(
+        model_access_groups=model_access_groups, models=models
+    )
+    assert result == []
+
+    # Test 3: Empty models list
+    result = get_access_groups_from_models(
+        model_access_groups=model_access_groups, models=[]
+    )
+    assert result == []
+
+    # Test 4: All access groups
+    models = ["AG1", "AG2", "beta-models"]
+    result = get_access_groups_from_models(
+        model_access_groups=model_access_groups, models=models
+    )
+    assert set(result) == {"AG1", "AG2", "beta-models"}

From eb8f4d3e05f33fef6262c6201934145477d492f7 Mon Sep 17 00:00:00 2001
From: Sameer Kankute <sameer@berri.ai>
Date: Tue, 3 Feb 2026 12:04:15 +0530
Subject: [PATCH 23/29] Revert "fix: models loadbalancing billing issue by
 filter (#18891) (#19220)"

This reverts commit 72e519345149f4b305645c51943b0f2cfd6c8acd.
---
 litellm/proxy/auth/model_checks.py            |  25 +-
 litellm/proxy/litellm_pre_call_utils.py       |  31 ---
 litellm/router.py                             |  12 +-
 litellm/router_utils/common_utils.py          |  79 +-----
 ...est_filter_deployments_by_access_groups.py | 227 ------------------
 5 files changed, 6 insertions(+), 368 deletions(-)
 delete mode 100644 tests/test_litellm/router_unit_tests/test_filter_deployments_by_access_groups.py

diff --git a/litellm/proxy/auth/model_checks.py b/litellm/proxy/auth/model_checks.py
index af2574d88e..71ae1348f3 100644
--- a/litellm/proxy/auth/model_checks.py
+++ b/litellm/proxy/auth/model_checks.py
@@ -64,27 +64,6 @@ def _get_models_from_access_groups(
     return all_models
 
 
-def get_access_groups_from_models(
-    model_access_groups: Dict[str, List[str]],
-    models: List[str],
-) -> List[str]:
-    """
-    Extract access group names from a models list.
-
-    Given a models list like ["gpt-4", "beta-models", "claude-v1"]
-    and access groups like {"beta-models": ["gpt-5", "gpt-6"]},
-    returns ["beta-models"].
-
-    This is used to pass allowed access groups to the router for filtering
-    deployments during load balancing (GitHub issue #18333).
-    """
-    access_groups = []
-    for model in models:
-        if model in model_access_groups:
-            access_groups.append(model)
-    return access_groups
-
-
 async def get_mcp_server_ids(
     user_api_key_dict: UserAPIKeyAuth,
 ) -> List[str]:
@@ -101,6 +80,7 @@ async def get_mcp_server_ids(
 
     # Make a direct SQL query to get just the mcp_servers
     try:
+
         result = await prisma_client.db.litellm_objectpermissiontable.find_unique(
             where={"object_permission_id": user_api_key_dict.object_permission_id},
         )
@@ -196,7 +176,6 @@ def get_complete_model_list(
     """
 
     unique_models = []
-
     def append_unique(models):
         for model in models:
             if model not in unique_models:
@@ -209,7 +188,7 @@ def get_complete_model_list(
     else:
         append_unique(proxy_model_list)
         if include_model_access_groups:
-            append_unique(list(model_access_groups.keys()))  # TODO: keys order
+            append_unique(list(model_access_groups.keys())) # TODO: keys order
 
         if user_model:
             append_unique([user_model])
diff --git a/litellm/proxy/litellm_pre_call_utils.py b/litellm/proxy/litellm_pre_call_utils.py
index 72f23e609a..9be78264e8 100644
--- a/litellm/proxy/litellm_pre_call_utils.py
+++ b/litellm/proxy/litellm_pre_call_utils.py
@@ -1021,37 +1021,6 @@ async def add_litellm_data_to_request(  # noqa: PLR0915
         "user_api_key_user_max_budget"
     ] = user_api_key_dict.user_max_budget
 
-    # Extract allowed access groups for router filtering (GitHub issue #18333)
-    # This allows the router to filter deployments based on key's and team's access groups
-    # NOTE: We keep key and team access groups SEPARATE because a key doesn't always
-    # inherit all team access groups (per maintainer feedback).
-    if llm_router is not None:
-        from litellm.proxy.auth.model_checks import get_access_groups_from_models
-
-        model_access_groups = llm_router.get_model_access_groups()
-
-        # Key-level access groups (from user_api_key_dict.models)
-        key_models = list(user_api_key_dict.models) if user_api_key_dict.models else []
-        key_allowed_access_groups = get_access_groups_from_models(
-            model_access_groups=model_access_groups, models=key_models
-        )
-        if key_allowed_access_groups:
-            data[_metadata_variable_name][
-                "user_api_key_allowed_access_groups"
-            ] = key_allowed_access_groups
-
-        # Team-level access groups (from user_api_key_dict.team_models)
-        team_models = (
-            list(user_api_key_dict.team_models) if user_api_key_dict.team_models else []
-        )
-        team_allowed_access_groups = get_access_groups_from_models(
-            model_access_groups=model_access_groups, models=team_models
-        )
-        if team_allowed_access_groups:
-            data[_metadata_variable_name][
-                "user_api_key_team_allowed_access_groups"
-            ] = team_allowed_access_groups
-
     data[_metadata_variable_name]["user_api_key_metadata"] = user_api_key_dict.metadata
     _headers = dict(request.headers)
     _headers.pop(
diff --git a/litellm/router.py b/litellm/router.py
index 65445e29c4..d01c8443da 100644
--- a/litellm/router.py
+++ b/litellm/router.py
@@ -88,7 +88,6 @@ from litellm.router_utils.clientside_credential_handler import (
     is_clientside_credential,
 )
 from litellm.router_utils.common_utils import (
-    filter_deployments_by_access_groups,
     filter_team_based_models,
     filter_web_search_deployments,
 )
@@ -8088,17 +8087,10 @@ class Router:
             request_kwargs=request_kwargs,
         )
 
-        verbose_router_logger.debug(f"healthy_deployments after web search filter: {healthy_deployments}")
-
-        # Filter by allowed access groups (GitHub issue #18333)
-        # This prevents cross-team load balancing when teams have models with same name in different access groups
-        healthy_deployments = filter_deployments_by_access_groups(
-            healthy_deployments=healthy_deployments,
-            request_kwargs=request_kwargs,
+        verbose_router_logger.debug(
+            f"healthy_deployments after web search filter: {healthy_deployments}"
         )
 
-        verbose_router_logger.debug(f"healthy_deployments after access group filter: {healthy_deployments}")
-
         if isinstance(healthy_deployments, dict):
             return healthy_deployments
 
diff --git a/litellm/router_utils/common_utils.py b/litellm/router_utils/common_utils.py
index 2c0ea5976d..10acc343ab 100644
--- a/litellm/router_utils/common_utils.py
+++ b/litellm/router_utils/common_utils.py
@@ -75,7 +75,6 @@ def filter_team_based_models(
         if deployment.get("model_info", {}).get("id") not in ids_to_remove
     ]
 
-
 def _deployment_supports_web_search(deployment: Dict) -> bool:
     """
     Check if a deployment supports web search.
@@ -113,7 +112,7 @@ def filter_web_search_deployments(
     is_web_search_request = False
     tools = request_kwargs.get("tools") or []
     for tool in tools:
-        # These are the two websearch tools for OpenAI / Azure.
+        # These are the two websearch tools for OpenAI / Azure. 
         if tool.get("type") == "web_search" or tool.get("type") == "web_search_preview":
             is_web_search_request = True
             break
@@ -122,82 +121,8 @@ def filter_web_search_deployments(
         return healthy_deployments
 
     # Filter out deployments that don't support web search
-    final_deployments = [
-        d for d in healthy_deployments if _deployment_supports_web_search(d)
-    ]
+    final_deployments = [d for d in healthy_deployments if _deployment_supports_web_search(d)]
     if len(healthy_deployments) > 0 and len(final_deployments) == 0:
         verbose_logger.warning("No deployments support web search for request")
     return final_deployments
 
-
-def filter_deployments_by_access_groups(
-    healthy_deployments: Union[List[Dict], Dict],
-    request_kwargs: Optional[Dict] = None,
-) -> Union[List[Dict], Dict]:
-    """
-    Filter deployments to only include those matching the user's allowed access groups.
-
-    Reads from TWO separate metadata fields (per maintainer feedback):
-    - `user_api_key_allowed_access_groups`: Access groups from the API Key's models.
-    - `user_api_key_team_allowed_access_groups`: Access groups from the Team's models.
-
-    A deployment is included if its access_groups overlap with EITHER the key's
-    or the team's allowed access groups. Deployments with no access_groups are
-    always included (not restricted).
-
-    This prevents cross-team load balancing when multiple teams have models with
-    the same name but in different access groups (GitHub issue #18333).
-    """
-    if request_kwargs is None:
-        return healthy_deployments
-
-    if isinstance(healthy_deployments, dict):
-        return healthy_deployments
-
-    metadata = request_kwargs.get("metadata") or {}
-    litellm_metadata = request_kwargs.get("litellm_metadata") or {}
-
-    # Gather key-level allowed access groups
-    key_allowed_access_groups = (
-        metadata.get("user_api_key_allowed_access_groups")
-        or litellm_metadata.get("user_api_key_allowed_access_groups")
-        or []
-    )
-
-    # Gather team-level allowed access groups
-    team_allowed_access_groups = (
-        metadata.get("user_api_key_team_allowed_access_groups")
-        or litellm_metadata.get("user_api_key_team_allowed_access_groups")
-        or []
-    )
-
-    # Combine both for the final allowed set
-    combined_allowed_access_groups = list(key_allowed_access_groups) + list(
-        team_allowed_access_groups
-    )
-
-    # If no access groups specified from either source, return all deployments (backwards compatible)
-    if not combined_allowed_access_groups:
-        return healthy_deployments
-
-    allowed_set = set(combined_allowed_access_groups)
-    filtered = []
-    for deployment in healthy_deployments:
-        model_info = deployment.get("model_info") or {}
-        deployment_access_groups = model_info.get("access_groups") or []
-
-        # If deployment has no access groups, include it (not restricted)
-        if not deployment_access_groups:
-            filtered.append(deployment)
-            continue
-
-        # Include if any of deployment's groups overlap with allowed groups
-        if set(deployment_access_groups) & allowed_set:
-            filtered.append(deployment)
-
-    if len(healthy_deployments) > 0 and len(filtered) == 0:
-        verbose_logger.warning(
-            f"No deployments match allowed access groups {combined_allowed_access_groups}"
-        )
-
-    return filtered
diff --git a/tests/test_litellm/router_unit_tests/test_filter_deployments_by_access_groups.py b/tests/test_litellm/router_unit_tests/test_filter_deployments_by_access_groups.py
deleted file mode 100644
index 9ac5072c5d..0000000000
--- a/tests/test_litellm/router_unit_tests/test_filter_deployments_by_access_groups.py
+++ /dev/null
@@ -1,227 +0,0 @@
-"""
-Unit tests for filter_deployments_by_access_groups function.
-
-Tests the fix for GitHub issue #18333: Models loadbalanced outside of Model Access Group.
-"""
-
-import pytest
-
-from litellm.router_utils.common_utils import filter_deployments_by_access_groups
-
-
-class TestFilterDeploymentsByAccessGroups:
-    """Tests for the filter_deployments_by_access_groups function."""
-
-    def test_no_filter_when_no_access_groups_in_metadata(self):
-        """When no allowed_access_groups in metadata, return all deployments."""
-        deployments = [
-            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
-            {"model_info": {"id": "2", "access_groups": ["AG2"]}},
-        ]
-        request_kwargs = {"metadata": {"user_api_key_team_id": "team-1"}}
-
-        result = filter_deployments_by_access_groups(
-            healthy_deployments=deployments,
-            request_kwargs=request_kwargs,
-        )
-
-        assert len(result) == 2  # All deployments returned
-
-    def test_filter_to_single_access_group(self):
-        """Filter to only deployments matching allowed access group."""
-        deployments = [
-            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
-            {"model_info": {"id": "2", "access_groups": ["AG2"]}},
-        ]
-        request_kwargs = {"metadata": {"user_api_key_allowed_access_groups": ["AG2"]}}
-
-        result = filter_deployments_by_access_groups(
-            healthy_deployments=deployments,
-            request_kwargs=request_kwargs,
-        )
-
-        assert len(result) == 1
-        assert result[0]["model_info"]["id"] == "2"
-
-    def test_filter_with_multiple_allowed_groups(self):
-        """Filter with multiple allowed access groups."""
-        deployments = [
-            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
-            {"model_info": {"id": "2", "access_groups": ["AG2"]}},
-            {"model_info": {"id": "3", "access_groups": ["AG3"]}},
-        ]
-        request_kwargs = {
-            "metadata": {"user_api_key_allowed_access_groups": ["AG1", "AG2"]}
-        }
-
-        result = filter_deployments_by_access_groups(
-            healthy_deployments=deployments,
-            request_kwargs=request_kwargs,
-        )
-
-        assert len(result) == 2
-        ids = [d["model_info"]["id"] for d in result]
-        assert "1" in ids
-        assert "2" in ids
-        assert "3" not in ids
-
-    def test_deployment_with_multiple_access_groups(self):
-        """Deployment with multiple access groups should match if any overlap."""
-        deployments = [
-            {"model_info": {"id": "1", "access_groups": ["AG1", "AG2"]}},
-            {"model_info": {"id": "2", "access_groups": ["AG3"]}},
-        ]
-        request_kwargs = {"metadata": {"user_api_key_allowed_access_groups": ["AG2"]}}
-
-        result = filter_deployments_by_access_groups(
-            healthy_deployments=deployments,
-            request_kwargs=request_kwargs,
-        )
-
-        assert len(result) == 1
-        assert result[0]["model_info"]["id"] == "1"
-
-    def test_deployment_without_access_groups_included(self):
-        """Deployments without access groups should be included (not restricted)."""
-        deployments = [
-            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
-            {"model_info": {"id": "2"}},  # No access_groups
-            {"model_info": {"id": "3", "access_groups": []}},  # Empty access_groups
-        ]
-        request_kwargs = {"metadata": {"user_api_key_allowed_access_groups": ["AG2"]}}
-
-        result = filter_deployments_by_access_groups(
-            healthy_deployments=deployments,
-            request_kwargs=request_kwargs,
-        )
-
-        # Should include deployments 2 and 3 (no restrictions)
-        assert len(result) == 2
-        ids = [d["model_info"]["id"] for d in result]
-        assert "2" in ids
-        assert "3" in ids
-
-    def test_dict_deployment_passes_through(self):
-        """When deployment is a dict (specific deployment), pass through."""
-        deployment = {"model_info": {"id": "1", "access_groups": ["AG1"]}}
-        request_kwargs = {"metadata": {"user_api_key_allowed_access_groups": ["AG2"]}}
-
-        result = filter_deployments_by_access_groups(
-            healthy_deployments=deployment,
-            request_kwargs=request_kwargs,
-        )
-
-        assert result == deployment  # Unchanged
-
-    def test_none_request_kwargs_passes_through(self):
-        """When request_kwargs is None, return deployments unchanged."""
-        deployments = [
-            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
-        ]
-
-        result = filter_deployments_by_access_groups(
-            healthy_deployments=deployments,
-            request_kwargs=None,
-        )
-
-        assert result == deployments
-
-    def test_litellm_metadata_fallback(self):
-        """Should also check litellm_metadata for allowed access groups."""
-        deployments = [
-            {"model_info": {"id": "1", "access_groups": ["AG1"]}},
-            {"model_info": {"id": "2", "access_groups": ["AG2"]}},
-        ]
-        request_kwargs = {
-            "litellm_metadata": {"user_api_key_allowed_access_groups": ["AG1"]}
-        }
-
-        result = filter_deployments_by_access_groups(
-            healthy_deployments=deployments,
-            request_kwargs=request_kwargs,
-        )
-
-        assert len(result) == 1
-        assert result[0]["model_info"]["id"] == "1"
-
-
-def test_filter_deployments_by_access_groups_issue_18333():
-    """
-    Regression test for GitHub issue #18333.
-
-    Scenario: Two models named 'gpt-5' in different access groups (AG1, AG2).
-    Team2 has access to AG2 only. When Team2 requests 'gpt-5', only the AG2
-    deployment should be available for load balancing.
-    """
-    deployments = [
-        {
-            "model_name": "gpt-5",
-            "litellm_params": {"model": "gpt-4.1", "api_key": "key-1"},
-            "model_info": {"id": "ag1-deployment", "access_groups": ["AG1"]},
-        },
-        {
-            "model_name": "gpt-5",
-            "litellm_params": {"model": "gpt-4o", "api_key": "key-2"},
-            "model_info": {"id": "ag2-deployment", "access_groups": ["AG2"]},
-        },
-    ]
-
-    # Team2's request with allowed access groups
-    request_kwargs = {
-        "metadata": {
-            "user_api_key_team_id": "team-2",
-            "user_api_key_allowed_access_groups": ["AG2"],
-        }
-    }
-
-    result = filter_deployments_by_access_groups(
-        healthy_deployments=deployments,
-        request_kwargs=request_kwargs,
-    )
-
-    # Only AG2 deployment should be returned
-    assert len(result) == 1
-    assert result[0]["model_info"]["id"] == "ag2-deployment"
-    assert result[0]["litellm_params"]["model"] == "gpt-4o"
-
-
-def test_get_access_groups_from_models():
-    """
-    Test the helper function that extracts access group names from models list.
-    This is used by the proxy to populate user_api_key_allowed_access_groups.
-    """
-    from litellm.proxy.auth.model_checks import get_access_groups_from_models
-
-    # Setup: access groups definition
-    model_access_groups = {
-        "AG1": ["gpt-4", "gpt-5"],
-        "AG2": ["claude-v1", "claude-v2"],
-        "beta-models": ["gpt-5-turbo"],
-    }
-
-    # Test 1: Extract access groups from models list
-    models = ["gpt-4", "AG1", "AG2", "some-other-model"]
-    result = get_access_groups_from_models(
-        model_access_groups=model_access_groups, models=models
-    )
-    assert set(result) == {"AG1", "AG2"}
-
-    # Test 2: No access groups in models list
-    models = ["gpt-4", "claude-v1", "some-model"]
-    result = get_access_groups_from_models(
-        model_access_groups=model_access_groups, models=models
-    )
-    assert result == []
-
-    # Test 3: Empty models list
-    result = get_access_groups_from_models(
-        model_access_groups=model_access_groups, models=[]
-    )
-    assert result == []
-
-    # Test 4: All access groups
-    models = ["AG1", "AG2", "beta-models"]
-    result = get_access_groups_from_models(
-        model_access_groups=model_access_groups, models=models
-    )
-    assert set(result) == {"AG1", "AG2", "beta-models"}

From 9a6bafe89e5b6fd76f0185cd39b127e4ea202e43 Mon Sep 17 00:00:00 2001
From: Sameer Kankute <sameer@berri.ai>
Date: Tue, 3 Feb 2026 12:08:19 +0530
Subject: [PATCH 24/29] Fix
 litellm/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py
 tests

---
 .../test_semantic_tool_filter_e2e.py          | 19 +++++++++++++++++--
 .../mcp_server/test_semantic_tool_filter.py   | 16 +++++++++++++---
 2 files changed, 30 insertions(+), 5 deletions(-)

diff --git a/tests/mcp_tests/test_semantic_tool_filter_e2e.py b/tests/mcp_tests/test_semantic_tool_filter_e2e.py
index cf951c1884..91c072ae8a 100644
--- a/tests/mcp_tests/test_semantic_tool_filter_e2e.py
+++ b/tests/mcp_tests/test_semantic_tool_filter_e2e.py
@@ -12,8 +12,19 @@ sys.path.insert(0, os.path.abspath("../.."))
 
 from mcp.types import Tool as MCPTool
 
+# Check if semantic-router is available
+try:
+    import semantic_router
+    SEMANTIC_ROUTER_AVAILABLE = True
+except ImportError:
+    SEMANTIC_ROUTER_AVAILABLE = False
+
 
 @pytest.mark.asyncio
+@pytest.mark.skipif(
+    not SEMANTIC_ROUTER_AVAILABLE,
+    reason="semantic-router not installed. Install with: pip install 'litellm[semantic-router]'"
+)
 async def test_e2e_semantic_filter():
     """E2E: Load router/filter and verify hook filters tools."""
     from litellm import Router
@@ -37,8 +48,6 @@ async def test_e2e_semantic_filter():
         enabled=True,
     )
     
-    hook = SemanticToolFilterHook(filter_instance)
-    
     # Create 10 tools
     tools = [
         MCPTool(name="gmail_send", description="Send an email via Gmail", inputSchema={"type": "object"}),
@@ -53,10 +62,16 @@ async def test_e2e_semantic_filter():
         MCPTool(name="note_add", description="Add note", inputSchema={"type": "object"}),
     ]
     
+    # Build router with test tools
+    filter_instance._build_router(tools)
+    
+    hook = SemanticToolFilterHook(filter_instance)
+    
     data = {
         "model": "gpt-4",
         "messages": [{"role": "user", "content": "Send an email and create a calendar event"}],
         "tools": tools,
+        "metadata": {},  # Initialize metadata dict for hook to store filter stats
     }
     
     # Call hook
diff --git a/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py b/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py
index 8d35f5bbdc..87c597c659 100644
--- a/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py
+++ b/tests/test_litellm/proxy/_experimental/mcp_server/test_semantic_tool_filter.py
@@ -71,6 +71,9 @@ async def test_semantic_filter_basic_filtering():
         enabled=True,
     )
     
+    # Build router with the tools before filtering
+    filter_instance._build_router(tools)
+    
     # Filter tools with email-related query
     filtered = await filter_instance.filter_tools(
         query="send an email to john@example.com",
@@ -139,6 +142,9 @@ async def test_semantic_filter_top_k_limiting():
         enabled=True,
     )
     
+    # Build router with the tools before filtering
+    filter_instance._build_router(tools)
+    
     # Filter tools
     filtered = await filter_instance.filter_tools(
         query="test query",
@@ -297,21 +303,25 @@ async def test_semantic_filter_hook_triggers_on_completion():
         enabled=True,
     )
     
-    # Create hook
-    hook = SemanticToolFilterHook(filter_instance)
-    
     # Prepare data - completion request with tools
     tools = [
         MCPTool(name=f"tool_{i}", description=f"Tool {i}", inputSchema={"type": "object"})
         for i in range(10)
     ]
     
+    # Build router with the tools before filtering
+    filter_instance._build_router(tools)
+    
+    # Create hook
+    hook = SemanticToolFilterHook(filter_instance)
+    
     data = {
         "model": "gpt-4",
         "messages": [
             {"role": "user", "content": "Send an email"}
         ],
         "tools": tools,
+        "metadata": {},  # Hook needs metadata field to store filter stats
     }
     
     # Mock user API key dict and cache

From 017b78de40ba0fecb14d89745a19e56363857edf Mon Sep 17 00:00:00 2001
From: Sameer Kankute <sameer@berri.ai>
Date: Tue, 3 Feb 2026 12:10:29 +0530
Subject: [PATCH 25/29] Fix code quality tests

---
 docs/my-website/docs/proxy/config_settings.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/docs/my-website/docs/proxy/config_settings.md b/docs/my-website/docs/proxy/config_settings.md
index 264c7d765b..385b4b0de3 100644
--- a/docs/my-website/docs/proxy/config_settings.md
+++ b/docs/my-website/docs/proxy/config_settings.md
@@ -545,6 +545,9 @@ router_settings:
 | DEFAULT_MAX_TOKENS | Default maximum tokens for LLM calls. Default is 4096
 | DEFAULT_MAX_TOKENS_FOR_TRITON | Default maximum tokens for Triton models. Default is 2000
 | DEFAULT_MAX_REDIS_BATCH_CACHE_SIZE | Default maximum size for redis batch cache. Default is 1000
+| DEFAULT_MCP_SEMANTIC_FILTER_EMBEDDING_MODEL | Default embedding model for MCP semantic tool filtering. Default is "text-embedding-3-small"
+| DEFAULT_MCP_SEMANTIC_FILTER_SIMILARITY_THRESHOLD | Default similarity threshold for MCP semantic tool filtering. Default is 0.3
+| DEFAULT_MCP_SEMANTIC_FILTER_TOP_K | Default number of top results to return for MCP semantic tool filtering. Default is 10
 | DEFAULT_MOCK_RESPONSE_COMPLETION_TOKEN_COUNT | Default token count for mock response completions. Default is 20
 | DEFAULT_MOCK_RESPONSE_PROMPT_TOKEN_COUNT | Default token count for mock response prompts. Default is 10
 | DEFAULT_MODEL_CREATED_AT_TIME | Default creation timestamp for models. Default is 1677610602
@@ -802,6 +805,7 @@ router_settings:
 | MAXIMUM_TRACEBACK_LINES_TO_LOG | Maximum number of lines to log in traceback in LiteLLM Logs UI. Default is 100
 | MAX_RETRY_DELAY | Maximum delay in seconds for retrying requests. Default is 8.0
 | MAX_LANGFUSE_INITIALIZED_CLIENTS | Maximum number of Langfuse clients to initialize on proxy. Default is 50. This is set since langfuse initializes 1 thread everytime a client is initialized. We've had an incident in the past where we reached 100% cpu utilization because Langfuse was initialized several times.
+| MAX_MCP_SEMANTIC_FILTER_TOOLS_HEADER_LENGTH | Maximum header length for MCP semantic filter tools. Default is 150
 | MIN_NON_ZERO_TEMPERATURE | Minimum non-zero temperature value. Default is 0.0001
 | MINIMUM_PROMPT_CACHE_TOKEN_COUNT | Minimum token count for caching a prompt. Default is 1024
 | MISTRAL_API_BASE | Base URL for Mistral API. Default is https://api.mistral.ai

From fae0554fdc55d81862faed85b52c84376f62d63d Mon Sep 17 00:00:00 2001
From: Sameer Kankute <sameer@berri.ai>
Date: Tue, 3 Feb 2026 12:22:18 +0530
Subject: [PATCH 26/29] Revert "add missing indexes on VerificationToken table
 (#20040)"

This reverts commit 1e8848ca97bd53e596e715162d35d0d7953c9a08.
---
 .../migration.sql                                      |  8 --------
 .../litellm_proxy_extras/schema.prisma                 | 10 ----------
 litellm/proxy/schema.prisma                            | 10 ----------
 schema.prisma                                          | 10 ----------
 4 files changed, 38 deletions(-)
 delete mode 100644 litellm-proxy-extras/litellm_proxy_extras/migrations/20260129103648_add_verificationtoken_indexes/migration.sql

diff --git a/litellm-proxy-extras/litellm_proxy_extras/migrations/20260129103648_add_verificationtoken_indexes/migration.sql b/litellm-proxy-extras/litellm_proxy_extras/migrations/20260129103648_add_verificationtoken_indexes/migration.sql
deleted file mode 100644
index 572eea9b52..0000000000
--- a/litellm-proxy-extras/litellm_proxy_extras/migrations/20260129103648_add_verificationtoken_indexes/migration.sql
+++ /dev/null
@@ -1,8 +0,0 @@
--- CreateIndex
-CREATE INDEX "LiteLLM_VerificationToken_user_id_team_id_idx" ON "LiteLLM_VerificationToken"("user_id", "team_id");
-
--- CreateIndex
-CREATE INDEX "LiteLLM_VerificationToken_team_id_idx" ON "LiteLLM_VerificationToken"("team_id");
-
--- CreateIndex
-CREATE INDEX "LiteLLM_VerificationToken_budget_reset_at_expires_idx" ON "LiteLLM_VerificationToken"("budget_reset_at", "expires");
diff --git a/litellm-proxy-extras/litellm_proxy_extras/schema.prisma b/litellm-proxy-extras/litellm_proxy_extras/schema.prisma
index 3b81da1092..b118400b62 100644
--- a/litellm-proxy-extras/litellm_proxy_extras/schema.prisma
+++ b/litellm-proxy-extras/litellm_proxy_extras/schema.prisma
@@ -305,16 +305,6 @@ model LiteLLM_VerificationToken {
     litellm_budget_table LiteLLM_BudgetTable?   @relation(fields: [budget_id], references: [budget_id])
     litellm_organization_table LiteLLM_OrganizationTable?   @relation(fields: [organization_id], references: [organization_id])
     object_permission LiteLLM_ObjectPermissionTable?   @relation(fields: [object_permission_id], references: [object_permission_id])
-
-    // SELECT COUNT(*) FROM (SELECT "public"."LiteLLM_VerificationToken"."token" FROM "public"."LiteLLM_VerificationToken" WHERE ("public"."LiteLLM_VerificationToken"."user_id" = $1 AND ("public"."LiteLLM_VerificationToken"."team_id" IS NULL OR "public"."LiteLLM_VerificationToken"."team_id" <> $2)) OFFSET $3 ) AS "sub"
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."user_id" = $1 OFFSET $2
-    @@index([user_id, team_id])
-
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."team_id" = $1 OFFSET $2
-    @@index([team_id])
-
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE (("public"."LiteLLM_VerificationToken"."expires" IS NULL OR "public"."LiteLLM_VerificationToken"."expires" > $1) AND "public"."LiteLLM_VerificationToken"."budget_reset_at" < $2) OFFSET $3
-    @@index([budget_reset_at, expires])
 }
 
 // Audit table for deleted keys - preserves spend and key information for historical tracking
diff --git a/litellm/proxy/schema.prisma b/litellm/proxy/schema.prisma
index 3b81da1092..b118400b62 100644
--- a/litellm/proxy/schema.prisma
+++ b/litellm/proxy/schema.prisma
@@ -305,16 +305,6 @@ model LiteLLM_VerificationToken {
     litellm_budget_table LiteLLM_BudgetTable?   @relation(fields: [budget_id], references: [budget_id])
     litellm_organization_table LiteLLM_OrganizationTable?   @relation(fields: [organization_id], references: [organization_id])
     object_permission LiteLLM_ObjectPermissionTable?   @relation(fields: [object_permission_id], references: [object_permission_id])
-
-    // SELECT COUNT(*) FROM (SELECT "public"."LiteLLM_VerificationToken"."token" FROM "public"."LiteLLM_VerificationToken" WHERE ("public"."LiteLLM_VerificationToken"."user_id" = $1 AND ("public"."LiteLLM_VerificationToken"."team_id" IS NULL OR "public"."LiteLLM_VerificationToken"."team_id" <> $2)) OFFSET $3 ) AS "sub"
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."user_id" = $1 OFFSET $2
-    @@index([user_id, team_id])
-
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."team_id" = $1 OFFSET $2
-    @@index([team_id])
-
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE (("public"."LiteLLM_VerificationToken"."expires" IS NULL OR "public"."LiteLLM_VerificationToken"."expires" > $1) AND "public"."LiteLLM_VerificationToken"."budget_reset_at" < $2) OFFSET $3
-    @@index([budget_reset_at, expires])
 }
 
 // Audit table for deleted keys - preserves spend and key information for historical tracking
diff --git a/schema.prisma b/schema.prisma
index 3b81da1092..b118400b62 100644
--- a/schema.prisma
+++ b/schema.prisma
@@ -305,16 +305,6 @@ model LiteLLM_VerificationToken {
     litellm_budget_table LiteLLM_BudgetTable?   @relation(fields: [budget_id], references: [budget_id])
     litellm_organization_table LiteLLM_OrganizationTable?   @relation(fields: [organization_id], references: [organization_id])
     object_permission LiteLLM_ObjectPermissionTable?   @relation(fields: [object_permission_id], references: [object_permission_id])
-
-    // SELECT COUNT(*) FROM (SELECT "public"."LiteLLM_VerificationToken"."token" FROM "public"."LiteLLM_VerificationToken" WHERE ("public"."LiteLLM_VerificationToken"."user_id" = $1 AND ("public"."LiteLLM_VerificationToken"."team_id" IS NULL OR "public"."LiteLLM_VerificationToken"."team_id" <> $2)) OFFSET $3 ) AS "sub"
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."user_id" = $1 OFFSET $2
-    @@index([user_id, team_id])
-
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE "public"."LiteLLM_VerificationToken"."team_id" = $1 OFFSET $2
-    @@index([team_id])
-
-    // SELECT ... FROM "public"."LiteLLM_VerificationToken" WHERE (("public"."LiteLLM_VerificationToken"."expires" IS NULL OR "public"."LiteLLM_VerificationToken"."expires" > $1) AND "public"."LiteLLM_VerificationToken"."budget_reset_at" < $2) OFFSET $3
-    @@index([budget_reset_at, expires])
 }
 
 // Audit table for deleted keys - preserves spend and key information for historical tracking

From 31cdffd3a46899d9c51940b48a53288206214b1b Mon Sep 17 00:00:00 2001
From: Sameer Kankute <sameer@berri.ai>
Date: Tue, 3 Feb 2026 15:15:30 +0530
Subject: [PATCH 27/29] Revert "fix: prevent error when max_fallbacks exceeds
 available models (#20071)"

This reverts commit ef73f330f1f216bb98ac21caaf7056a98779eb9c.
---
 .../router_utils/fallback_event_handlers.py   | 12 +-----
 tests/test_fallbacks.py                       | 42 -------------------
 2 files changed, 2 insertions(+), 52 deletions(-)

diff --git a/litellm/router_utils/fallback_event_handlers.py b/litellm/router_utils/fallback_event_handlers.py
index 738b82d702..62e706a0cf 100644
--- a/litellm/router_utils/fallback_event_handlers.py
+++ b/litellm/router_utils/fallback_event_handlers.py
@@ -113,16 +113,8 @@ async def run_async_fallback(
         The most recent exception if all fallback model groups fail.
     """
 
-    ### BASE CASE ### MAX FALLBACK DEPTH REACHED 
-    if fallback_depth >= max_fallbacks: 
-        raise original_exception
-
-    ### CHECK IF MODEL GROUP LIST EXHAUSTED
-    if original_model_group in fallback_model_group:
-        fallback_group_length = len(fallback_model_group) - 1
-    else:
-        fallback_group_length = len(fallback_model_group) 
-    if fallback_depth >= fallback_group_length:
+    ### BASE CASE ### MAX FALLBACK DEPTH REACHED
+    if fallback_depth >= max_fallbacks:
         raise original_exception
 
     error_from_fallbacks = original_exception
diff --git a/tests/test_fallbacks.py b/tests/test_fallbacks.py
index c22cefa6be..bc9aa4c64c 100644
--- a/tests/test_fallbacks.py
+++ b/tests/test_fallbacks.py
@@ -336,45 +336,3 @@ async def test_chat_completion_bad_and_good_model():
             f"Iteration {iteration + 1}: {'✓' if success else '✗'} ({time.time() - start_time:.2f}s)"
         )
         assert success, "Not all good model requests succeeded"
-
-
-@pytest.mark.asyncio
-async def test_router_fallback_exhaustion():
-    """
-    Test for Bug 19985:
-    """
-    from litellm import Router
-    import pytest
-
-    # Setup: Only ONE fallback model available
-    model_list = [
-        {
-            "model_name": "gpt-3.5-turbo",
-            "litellm_params": {"model": "openai/fake", "api_key": "bad-key"},
-        },
-        {
-            "model_name": "bad-model-1",
-            "litellm_params": {"model": "azure/fake", "api_key": "bad-key"},
-        }
-    ]
-
-    # max_fallbacks=10 is much larger than the 1 fallback provided in the list
-    router = Router(
-        model_list=model_list,
-        fallbacks=[{"gpt-3.5-turbo": ["bad-model-1"]}],
-        max_fallbacks=10
-    )
-
-    try:
-        # This will fail and attempt to fallback
-        await router.acompletion(
-            model="gpt-3.5-turbo",
-            messages=[{"role": "user", "content": "test"}]
-        )
-    except Exception as e:
-        # The success criteria is that we DON'T get an IndexError
-        assert not isinstance(e, IndexError), f"Expected API error, but got IndexError: {e}"
-        # Also ensure we actually hit a fallback attempt
-        print(f"Caught expected exception: {type(e).__name__}")
-
-

From 21e95c73e44e722da16486fadb38a45eec6759c2 Mon Sep 17 00:00:00 2001
From: Sameer Kankute <sameer@berri.ai>
Date: Tue, 3 Feb 2026 15:24:31 +0530
Subject: [PATCH 28/29] Fix litellm_security_tests

---
 ci_cd/security_scans.sh | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ci_cd/security_scans.sh b/ci_cd/security_scans.sh
index 3a212a56f6..340f8e9606 100755
--- a/ci_cd/security_scans.sh
+++ b/ci_cd/security_scans.sh
@@ -154,6 +154,7 @@ run_grype_scans() {
         "CVE-2025-15367" # No fix available yet
         "CVE-2025-12781" # No fix available yet
         "CVE-2025-11468" # No fix available yet
+        "CVE-2026-1299" # Python 3.13 email module header injection - not applicable, LiteLLM doesn't use BytesGenerator for email serialization
     )
 
     # Build JSON array of allowlisted CVE IDs for jq

From 47c5366cf37f97b5ad93368bdf23d5738b2435c0 Mon Sep 17 00:00:00 2001
From: Sameer Kankute <sameer@berri.ai>
Date: Tue, 3 Feb 2026 16:51:42 +0530
Subject: [PATCH 29/29] bump litellm 1.81.7

---
 pyproject.toml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 450dadac93..9832ca483d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "litellm"
-version = "1.81.6"
+version = "1.81.7"
 description = "Library to easily interface with LLM API providers"
 authors = ["BerriAI"]
 license = "MIT"
@@ -174,7 +174,7 @@ requires = ["poetry-core", "wheel"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.commitizen]
-version = "1.81.6"
+version = "1.81.7"
 version_files = [
     "pyproject.toml:^version"
 ]