feat(anthropic): workload identity federation, pluggable identity sources, and provider-level setup (internal copy of #38013)

backend/routes/allowlist.py

@@ -55,6 +55,7 @@
     "/credentials",
     "/credential",
     "/provider/budgets",
+    "/provider/models/discover",
     # Tools / agents (registry & policy admin)
     "/v1/tool/",
     "/v1/agents",

litellm/batches/batch_utils.py

@@ -7,7 +7,10 @@
 
 import litellm
 from litellm._logging import verbose_logger
-from litellm.litellm_core_utils.get_litellm_params import AWS_CREDENTIAL_KWARGS_KEYS
+from litellm.litellm_core_utils.get_litellm_params import (
+    ANTHROPIC_WIF_KWARGS_KEYS,
+    AWS_CREDENTIAL_KWARGS_KEYS,
+)
 from litellm.litellm_core_utils.llm_cost_calc.utils import parse_prompt_tokens_details
 from litellm.types.llms.openai import Batch
 from litellm.types.utils import CallTypes, ModelInfo, Usage
@@ -507,6 +510,9 @@ def _extract_file_access_credentials(litellm_params: dict | None) -> dict:
             "max_retries",
             "_litellm_internal_model_credentials",
             *AWS_CREDENTIAL_KWARGS_KEYS,
+            # A federated deployment holds no api_key, so without these the fetch that reads a
+            # finished batch's output has nothing to authenticate with and its cost is never billed.
+            *sorted(ANTHROPIC_WIF_KWARGS_KEYS),
         )
         for key in credential_keys:
             if key in litellm_params:

litellm/batches/main.py

@@ -483,13 +483,15 @@ def _handle_retrieve_batch_providers_without_provider_config(
         )
         api_key = optional_params.api_key or litellm.api_key or litellm.azure_key or get_secret_str("ANTHROPIC_API_KEY")
 
+        batch_params: Final = dict(litellm_params)  # mutable-ok: handler contract, copied not shared
         response = anthropic_batches_instance.retrieve_batch(
             _is_async=_is_async,
             batch_id=batch_id,
             api_base=api_base,
             api_key=api_key,
             timeout=timeout,
             max_retries=optional_params.max_retries,
+            litellm_params=batch_params,
         )
     else:
         raise litellm.exceptions.BadRequestError(

litellm/litellm_core_utils/get_litellm_params.py

@@ -24,10 +24,54 @@
 # The per-deployment Rust opt-in.
 RUST_KWARG_KEY: Final = "rust"
 
+# Anthropic workload identity federation config, read from litellm_params by the
+# Anthropic auth tier. Registered like `rust`: here so the kwargs funnel carries
+# them, and in `all_litellm_params` so they never leak into the provider body.
+ANTHROPIC_WIF_KWARGS_KEYS: Final = frozenset(
+    {
+        "anthropic_federation_rule_id",
+        "anthropic_organization_id",
+        "anthropic_service_account_id",
+        "anthropic_workspace_id",
+        "anthropic_identity_token_file",
+        "anthropic_identity_token",
+        # Identity-source selection (Phase 1): absent means the legacy
+        # token_file/env resolver above, byte-identical to today.
+        "anthropic_identity_source",
+        # internal_issuer: litellm self-signs the workload assertion.
+        "anthropic_issuer_url",
+        "anthropic_issuer_subject",
+        "anthropic_issuer_audience",
+        "anthropic_issuer_ttl_seconds",
+        "anthropic_issuer_signing_key_ref",
+        # keycloak: litellm fetches the assertion via client_credentials.
+        "anthropic_keycloak_token_url",
+        "anthropic_keycloak_client_id",
+        "anthropic_keycloak_auth_method",
+        "anthropic_keycloak_client_secret_ref",
+        "anthropic_keycloak_scope",
+        # Set server-side when a client redirects api_base, to stop a federated deployment minting
+        # for a base the caller chose. It has to ride this funnel or it is dropped on the way and
+        # the deployment federates anyway; being carried here also request-bans it, which is right,
+        # since a caller must not be able to set it in either direction.
+        "anthropic_disable_workload_identity_federation",
+    }
+)
+
+OPENAI_WIF_KWARGS_KEYS: Final = frozenset(
+    {
+        "openai_identity_provider_id",
+        "openai_service_account_id",
+        "openai_identity_token_file",
+    }
+)
+
 # Keys `completion()` forwards from its own kwargs into `get_litellm_params`,
 # which are otherwise invisible to it because that call site passes explicit
 # named arguments rather than `**kwargs`.
-FORWARDED_KWARGS_KEYS: Final = AWS_CREDENTIAL_KWARGS_KEYS | frozenset({RUST_KWARG_KEY})
+FORWARDED_KWARGS_KEYS: Final = (
+    AWS_CREDENTIAL_KWARGS_KEYS | ANTHROPIC_WIF_KWARGS_KEYS | OPENAI_WIF_KWARGS_KEYS | frozenset({RUST_KWARG_KEY})
+)
 
 # Pre-define optional kwargs keys as frozenset for O(1) lookups
 # These are extracted from kwargs only if present, avoiding unnecessary .get() calls
@@ -65,6 +109,8 @@
         }
     )
     | AWS_CREDENTIAL_KWARGS_KEYS
+    | ANTHROPIC_WIF_KWARGS_KEYS
+    | OPENAI_WIF_KWARGS_KEYS
 )
 
 # Backward-compatible alias for existing imports/tests.

litellm/llms/anthropic/batches/handler.py

@@ -42,6 +42,7 @@ async def aretrieve_batch(
         timeout: float | httpx.Timeout,
         max_retries: int | None,
         logging_obj: LiteLLMLoggingObj | None = None,
+        litellm_params: dict | None = None,  # mutable-ok: handed straight to validate_environment
     ) -> LiteLLMBatch:
         """
         Async: Retrieve a batch from Anthropic.
@@ -60,9 +61,7 @@ async def aretrieve_batch(
         # Resolve API credentials
         api_base = api_base or self.anthropic_model_info.get_api_base(api_base)
         api_key = api_key or self.anthropic_model_info.get_api_key()
-
-        if not api_key:
-            raise ValueError("Missing Anthropic API Key")
+        resolved_litellm_params: Final = litellm_params if litellm_params is not None else {}
 
         # Create a minimal logging object if not provided
         if logging_obj is None:
@@ -85,16 +84,18 @@ async def aretrieve_batch(
             api_base=api_base,
             batch_id=batch_id,
             optional_params={},
-            litellm_params={},
+            litellm_params=resolved_litellm_params,
         )
 
-        # Validate environment and get headers
-        headers: Final = self.provider_config.validate_environment(
+        # Validate environment and get headers. Offloaded to a worker thread: a WIF token
+        # exchange here would otherwise block the event loop.
+        headers: Final = await asyncio.to_thread(
+            self.provider_config.validate_environment,
             headers={},
             model="",
             messages=[],
             optional_params={},
-            litellm_params={},
+            litellm_params=resolved_litellm_params,
             api_key=api_key,
             api_base=api_base,
         )
@@ -130,6 +131,7 @@ def retrieve_batch(
         timeout: float | httpx.Timeout,
         max_retries: int | None,
         logging_obj: LiteLLMLoggingObj | None = None,
+        litellm_params: dict | None = None,  # mutable-ok: handed straight to validate_environment
     ) -> LiteLLMBatch | Coroutine[Any, Any, LiteLLMBatch]:
         """
         Retrieve a batch from Anthropic.
@@ -154,6 +156,7 @@ def retrieve_batch(
                 timeout=timeout,
                 max_retries=max_retries,
                 logging_obj=logging_obj,
+                litellm_params=litellm_params,
             )
         else:
             return asyncio.run(
@@ -164,5 +167,6 @@ def retrieve_batch(
                     timeout=timeout,
                     max_retries=max_retries,
                     logging_obj=logging_obj,
+                    litellm_params=litellm_params,
                 )
             )

litellm/llms/anthropic/batches/transformation.py

@@ -13,6 +13,8 @@
 from litellm.types.llms.openai import AllMessageValues, CreateBatchRequest
 from litellm.types.utils import LiteLLMBatch, LlmProviders, ModelResponse
 
+from ..common_utils import merge_anthropic_beta_headers, without_caller_credential_headers
+
 if TYPE_CHECKING:
     import tiktoken
 
@@ -70,24 +72,30 @@ def validate_environment(
         api_base: str | None = None,
     ) -> dict:
         """Validate and prepare environment-specific headers and parameters."""
-        if api_base is None and isinstance(litellm_params, dict):
-            api_base = litellm_params.get("api_base")
-        auth_header: Final = self.anthropic_model_info.get_auth_header(api_key, api_base)
+        params_mapping: Final = litellm_params if isinstance(litellm_params, dict) else None
+        if api_base is None and params_mapping is not None:
+            api_base = params_mapping.get("api_base")
+        auth_header: Final = self.anthropic_model_info.get_auth_header(
+            api_key, api_base, litellm_params=params_mapping, allow_workload_identity=True
+        )
         if auth_header is None:
             raise ValueError(
                 "Missing Anthropic API Key - A call is being made to anthropic but no key is set either in the environment variables or via params"
             )
-        _headers: Final = {
+        merged_beta: Final = merge_anthropic_beta_headers(
+            merge_anthropic_beta_headers(headers.get("anthropic-beta"), auth_header.get("anthropic-beta")),
+            "message-batches-2024-09-24",
+        )
+        # The deployment's own credential is applied below, so a caller-supplied one must not
+        # ride along: without this a minted federation Bearer travels beside the caller's x-api-key.
+        return {
+            **without_caller_credential_headers(headers),
             "accept": "application/json",
             "anthropic-version": "2023-06-01",
             "content-type": "application/json",
+            **auth_header,
+            "anthropic-beta": merged_beta,
         }
-        _headers.update(auth_header)
-        # Add beta header for message batches
-        if "anthropic-beta" not in headers:
-            headers["anthropic-beta"] = "message-batches-2024-09-24"
-        headers.update(_headers)
-        return headers
 
     def get_complete_batch_url(
         self,

litellm/llms/anthropic/chat/transformation.py

@@ -3,7 +3,7 @@
 import time
 from collections.abc import Callable, Mapping, Sequence
 from types import MappingProxyType
-from typing import TYPE_CHECKING, Any, Final, NoReturn, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Final, NoReturn, cast
 
 import httpx
 from pydantic import ValidationError
@@ -284,6 +284,8 @@ class AnthropicConfig(AnthropicModelInfo, BaseConfig):
     to pass metadata to anthropic, it's {"user_id": "any-relevant-information"}
     """
 
+    _workload_identity_eligible: ClassVar[bool] = True
+
     max_tokens: int | None = None
     stop_sequences: list | None = None
     temperature: int | None = None