feat: add Laya gateway and OSS classifier providers

litellm/llms/laya/__init__.py

@@ -0,0 +1 @@
+

litellm/llms/laya/common_utils.py

@@ -0,0 +1,60 @@
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import Final, Literal, TypeAlias
+
+from pydantic import AnyHttpUrl, BaseModel, TypeAdapter, ValidationError
+
+from litellm.secret_managers.main import get_secret_str
+
+LayaCheckpoint: TypeAlias = Literal["english", "multilingual", "typed-decisions"]
+
+
+def validate_laya_model(value: object) -> LayaCheckpoint:
+    try:
+        return TypeAdapter(LayaCheckpoint).validate_python(value)
+    except ValidationError as exc:
+        raise ValueError("Laya model must be 'english', 'multilingual', or 'typed-decisions'") from exc
+
+
+def validate_laya_request(body: Mapping[str, object]) -> LayaCheckpoint:
+    if "custom_body" in body:
+        raise ValueError("custom_body is not supported for Laya requests")
+    if body.get("stream"):
+        raise ValueError("Streaming is not supported for Laya requests")
+    return validate_laya_model(body.get("model"))
+
+
+@dataclass(frozen=True, slots=True)
+class LayaConnection:
+    api_base: str
+    api_key: str | None = field(repr=False)
+
+
+def validate_laya_api_base(value: str) -> str:
+    try:
+        url: Final = TypeAdapter(AnyHttpUrl).validate_python(value)
+    except ValidationError as exc:
+        raise ValueError("Laya api_base must be an HTTP or HTTPS server URL") from exc
+    if url.username or url.password or url.query or url.fragment:
+        raise ValueError("Laya api_base must not contain credentials, a query, or a fragment")
+    return str(url).rstrip("/")
+
+
+def laya_connection(api_base: str | None = None, api_key: str | None = None) -> LayaConnection:
+    base: Final = api_base if api_base is not None else get_secret_str("LAYA_API_BASE")
+    if not base:
+        raise ValueError("Laya requires api_base or LAYA_API_BASE pointing to a self-hosted server")
+    key: Final = api_key if api_base is not None else api_key or get_secret_str("LAYA_API_KEY")
+    return LayaConnection(api_base=validate_laya_api_base(base), api_key=key)
+
+
+class _LayaRouting(BaseModel):
+    model: str | None = None
+
+
+def laya_response_model(response: Mapping[str, object], requested_model: str | None) -> str:
+    try:
+        routing: Final = TypeAdapter(_LayaRouting).validate_python(response.get("routing") or _LayaRouting())
+    except ValidationError:
+        return requested_model or "unknown"
+    return routing.model or requested_model or "unknown"

litellm/model_prices_and_context_window_backup.json

@@ -72586,6 +72586,45 @@
         "supports_audio_input": true,
         "supports_video_input": true
     },
+    "laya/english": {
+        "input_cost_per_token": 0.0,
+        "litellm_provider": "laya",
+        "mode": "evaluation",
+        "output_cost_per_token": 0.0,
+        "source": "https://github.com/NandhaKishorM/laya",
+        "supported_endpoints": [
+            "/v1/systemone"
+        ],
+        "metadata": {
+            "notes": "Self-hosted decision model; infrastructure costs are paid separately"
+        }
+    },
+    "laya/multilingual": {
+        "input_cost_per_token": 0.0,
+        "litellm_provider": "laya",
+        "mode": "evaluation",
+        "output_cost_per_token": 0.0,
+        "source": "https://github.com/NandhaKishorM/laya",
+        "supported_endpoints": [
+            "/v1/systemone"
+        ],
+        "metadata": {
+            "notes": "Self-hosted decision model; infrastructure costs are paid separately"
+        }
+    },
+    "laya/typed-decisions": {
+        "input_cost_per_token": 0.0,
+        "litellm_provider": "laya",
+        "mode": "evaluation",
+        "output_cost_per_token": 0.0,
+        "source": "https://github.com/NandhaKishorM/laya",
+        "supported_endpoints": [
+            "/v1/systemone"
+        ],
+        "metadata": {
+            "notes": "Self-hosted decision model; infrastructure costs are paid separately"
+        }
+    },
     "typesafe/jev-1.13.0": {
         "input_cost_per_token": 4.2e-08,
         "litellm_provider": "typesafe",

litellm/proxy/_lazy_features.py

@@ -224,6 +224,7 @@ def matches(self, path: str) -> bool:
             "/tinyfish/",
             "/transcribe",
             "/typesafe/",
+            "/laya/",
             "/openrouter/",
             "/vertex-ai/",
             "/vertex_ai/",

litellm/proxy/_lazy_openapi_snapshot.json

@@ -26676,6 +26676,30 @@
           ]
         }
       },
+      "/laya/v1/systemone": {
+        "post": {
+          "operationId": "laya_proxy_route_laya_v1_systemone_post",
+          "responses": {
+            "200": {
+              "content": {
+                "application/json": {
+                  "schema": {}
+                }
+              },
+              "description": "Successful Response"
+            }
+          },
+          "security": [
+            {
+              "APIKeyHeader": []
+            }
+          ],
+          "summary": "Laya Proxy Route",
+          "tags": [
+            "llm_passthrough"
+          ]
+        }
+      },
       "/milvus/{endpoint}": {
         "delete": {
           "description": "Enable using Milvus `/vectors` endpoint as a pass-through endpoint.",

litellm/proxy/_types.py

@@ -500,6 +500,7 @@ class LiteLLMRoutes(enum.Enum):
         "/vllm",
         "/mistral",
         "/typesafe",
+        "/laya",
         "/openrouter",
         "/milvus",
         "/gigachat",

litellm/proxy/auth/auth_utils.py

@@ -1883,6 +1883,15 @@ def _extract_model_candidates_from_request(
     llm_router: Router | None = None,
     team_id: str | None = None,
 ) -> list[str]:
+    if route.rstrip("/") == "/laya/v1/systemone":
+        from litellm.llms.laya.common_utils import validate_laya_model
+
+        try:
+            laya_request: Final = TypeAdapter(Mapping[str, object]).validate_python(request_data)
+            laya_model: Final = validate_laya_model(laya_request.get("model"))
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        return _dedupe_model_candidates((f"laya/{laya_model}",))
     if route == "/cost/predict-cache":
         prediction_models: Final = _cache_prediction_model_candidates(request_data, llm_router, team_id)  # pyright: ignore[reportUnknownArgumentType]  # the typed reader validates each deployment ID from this legacy payload
         return _dedupe_model_candidates(prediction_models)

litellm/proxy/management_endpoints/auto_router_endpoints.py

@@ -318,7 +318,7 @@ async def _authorize_models_this_test_can_call(
     its calls through the proxy. Team and member budgets are already enforced on every route.
     """
     models: Final = _models_this_test_can_call(config)
-    if not models and config.classifier_type != "jev":
+    if not models and config.classifier_type != "oss_classifier":
         return
 
     from litellm.proxy.proxy_server import proxy_logging_obj
@@ -344,9 +344,9 @@ async def _authorize_models_this_test_can_call(
             code=status.HTTP_400_BAD_REQUEST,
         ) from e
 
-    if config.classifier_type == "jev" and user_api_key_dict.budget_throttle_pct is not None:
+    if config.classifier_type == "oss_classifier" and user_api_key_dict.budget_throttle_pct is not None:
         raise ProxyException(
-            message="Budget has been exceeded! JEV Test Routing requires available budget.",
+            message="Budget has been exceeded! OSS Classifier Test Routing requires available budget.",
             type=ProxyErrorTypes.budget_exceeded,
             param=None,
             code=status.HTTP_400_BAD_REQUEST,

litellm/proxy/management_endpoints/model_management_endpoints.py

@@ -39,6 +39,7 @@
     SEARCH_CONTEXT_SIZES,
     ptu_config_error,
 )
+from litellm.litellm_core_utils.sensitive_data_masker import redact_credentials_in_payload
 from litellm.proxy._types import (
     BlockModelRequest,
     CommonProxyErrors,
@@ -115,6 +116,7 @@
     normalize_classification_examples,
     normalize_classification_prompt,
 )
+from litellm.router_strategy.complexity_router.config import resolve_complexity_router_config_write
 from litellm.router_utils.auto_router_model_naming import (
     GATED_AUTO_ROUTER_CAPABILITIES,
     STRATEGY_ROUTER_PARAM_FIELDS,
@@ -187,6 +189,25 @@ def model_info(self) -> object: ...
     def model_dump_json(self, *, exclude_none: bool = False) -> str: ...
 
 
+def _model_write_response(
+    row: _ProxyModelRow, member_write: MemberAutoRouterWrite | None
+) -> _ProxyModelRow | Mapping[str, object]:
+    if member_write is None:
+        return row
+    payload: Final = TypeAdapter(dict[str, object]).validate_json(row.model_dump_json())
+    stored_params: Final = payload.get("litellm_params")
+    params: Final = (
+        TypeAdapter(dict[str, object]).validate_json(stored_params)
+        if isinstance(stored_params, str)
+        else TypeAdapter(dict[str, object]).validate_python(stored_params)
+    )
+    redacted: Final = redact_credentials_in_payload(params)
+    return {
+        **payload,
+        "litellm_params": json.dumps(redacted) if isinstance(stored_params, str) else redacted,
+    }
+
+
 class _ProxyModelTable(Protocol):
     def find_unique(self, *, where: Mapping[str, object]) -> Awaitable[BaseModel | None]: ...
 
@@ -407,34 +428,13 @@ async def _raise_on_invalid_credential_name(
 
 def _effective_complexity_router_config(
     incoming_params: GenericLiteLLMParams | None, existing_params: GenericLiteLLMParams | None
-) -> object:
+) -> Mapping[str, object] | None:
     incoming: Final = None if incoming_params is None else incoming_params.complexity_router_config
     existing: Final = None if existing_params is None else existing_params.complexity_router_config
-    if incoming is None:
-        return existing
-    if existing is None or incoming.get("classifier_type") != "jev" or existing.get("classifier_type") != "jev":
-        return incoming
-    incoming_jev: Final[object] = incoming.get("jev_classifier_config")
-    existing_jev: Final[object] = existing.get("jev_classifier_config")
-    if not isinstance(incoming_jev, Mapping) or not isinstance(existing_jev, Mapping):
-        return incoming
-    supplied: Final = TypeAdapter(dict[str, object]).validate_python(incoming_jev)
-    stored: Final = TypeAdapter(dict[str, object]).validate_python(existing_jev)
-    same_base: Final = "api_base" not in supplied or supplied["api_base"] == stored.get("api_base")
-    transport: Final = MappingProxyType(
-        {
-            key: value
-            for key, value in stored.items()
-            if key in ("api_key", "api_base") and (key != "api_key" or same_base)
-        }
-    )
-    return {
-        **incoming,
-        "jev_classifier_config": {
-            **transport,
-            **supplied,
-        },
-    }
+    config_adapter: Final[TypeAdapter[Mapping[str, object] | None]] = TypeAdapter(Mapping[str, object] | None)
+    return resolve_complexity_router_config_write(
+        config_adapter.validate_python(incoming), config_adapter.validate_python(existing)
+    ).effective
 
 
 def _effective_model(
@@ -1304,7 +1304,7 @@ async def write_row(update_data: PrismaCompatibleUpdateDBModel) -> _ProxyModelRo
             live_after=reload_outcome.live_after,
         )
 
-        return updated_model
+        return _model_write_response(updated_model, member_write)
 
     except Exception as e:
         verbose_proxy_logger.exception("Error in patch_model: %s", e)
@@ -1501,10 +1501,18 @@ async def _add_model_to_db(
     slot: AbstractAsyncContextManager[_ProxyModelTable] | None = None,
 ) -> "_ProxyModelRow | LiteLLM_ProxyModelTable":
     # encrypt litellm params #
-    _litellm_params_dict: Final = model_params.litellm_params.dict(exclude_none=True)
+    _litellm_params_dict: Final = TypeAdapter(dict[str, object]).validate_python(
+        model_params.litellm_params.model_dump(exclude_none=True)
+    )
+    if "complexity_router_config" in _litellm_params_dict:
+        _litellm_params_dict["complexity_router_config"] = _effective_complexity_router_config(
+            model_params.litellm_params, None
+        )
     _original_litellm_model_name: Final = model_params.litellm_params.model
     for k, v in _litellm_params_dict.items():
-        encrypted_value = encrypt_value_helper(value=v, new_encryption_key=new_encryption_key)
+        encrypted_value = (
+            encrypt_value_helper(value=v, new_encryption_key=new_encryption_key) if isinstance(v, str) else v
+        )
         model_params.litellm_params[k] = encrypted_value
     _data: Final[dict] = {
         "model_id": model_params.model_info.id,
@@ -2536,7 +2544,7 @@ async def add_new_model(
             live_after=reload_outcome.live_after,
         )
 
-        return model_response
+        return _model_write_response(model_response, member_write)
 
     except Exception as e:
         verbose_proxy_logger.exception("litellm.proxy.proxy_server.add_new_model(): Exception occured - %s", e)
@@ -2760,7 +2768,7 @@ async def update_model(
                 live_after=reload_outcome.live_after,
             )
 
-            return model_response
+            return None if model_response is None else _model_write_response(model_response, member_write)
     except Exception as e:
         verbose_proxy_logger.exception("litellm.proxy.proxy_server.update_model(): Exception occured - %s", e)
         if isinstance(e, HTTPException):