@homeflare/distilled-litellm 0.2.0 → 0.4.0

package/dist/services/model_management.d.ts

@@ -26,6 +26,13 @@ export type LiteLLMParamsAdaptiveRouterConfigMap = {
     [key: string]: unknown | undefined;
 };
 export declare const LiteLLMParamsAdaptiveRouterConfigMap: S.Schema<LiteLLMParamsAdaptiveRouterConfigMap>;
+export interface AwsSessionTag {
+    Key: string;
+    Value: string;
+}
+export declare const AwsSessionTag: S.Schema<AwsSessionTag>;
+export type LiteLLMParamsAwsSessionTagsList = Array<AwsSessionTag>;
+export declare const LiteLLMParamsAwsSessionTagsList: S.Schema<LiteLLMParamsAwsSessionTagsList>;
 export type LiteLLMParamsBedrockTagsList = Array<unknown>;
 export declare const LiteLLMParamsBedrockTagsList: S.Schema<LiteLLMParamsBedrockTagsList>;
 export type LiteLLMParamsComplexityRouterConfigMap = {
@@ -40,6 +47,8 @@ export type LiteLLMParamsConfigurableClientsideAuthParamsItem = string | Configu
 export declare const LiteLLMParamsConfigurableClientsideAuthParamsItem: S.Schema<LiteLLMParamsConfigurableClientsideAuthParamsItem>;
 export type LiteLLMParamsConfigurableClientsideAuthParamsList = Array<LiteLLMParamsConfigurableClientsideAuthParamsItem>;
 export declare const LiteLLMParamsConfigurableClientsideAuthParamsList: S.Schema<LiteLLMParamsConfigurableClientsideAuthParamsList>;
+export type LiteLLMParamsDropParams = boolean | string;
+export declare const LiteLLMParamsDropParams: S.Schema<LiteLLMParamsDropParams>;
 export type LiteLLMParamsMilvusPartitionNamesList = Array<string>;
 export declare const LiteLLMParamsMilvusPartitionNamesList: S.Schema<LiteLLMParamsMilvusPartitionNamesList>;
 export type ChoicesFinishReason = "stop" | "content_filter" | "function_call" | "tool_calls" | "length" | "guardrail_intervened" | "eos" | "finish_reason_unspecified" | "malformed_function_call";
@@ -265,6 +274,7 @@ export interface LiteLLMParams {
     adaptive_router_default_model?: string | null;
     allow_client_keepalive_override?: boolean | null;
     annotation_cost_per_page?: number | null;
+    annotation_cost_per_page_batches?: number | null;
     api_base?: string | null;
     api_key?: string | null;
     api_version?: string | null;
@@ -273,6 +283,8 @@ export interface LiteLLMParams {
     auto_router_default_model?: string | null;
     auto_router_embedding_model?: string | null;
     auto_router_max_input_chars?: number | null;
+    auto_router_model_compression?: string | null;
+    auto_router_routing_compression?: string | null;
     aws_access_key_id?: string | null;
     aws_batch_role_arn?: string | null;
     aws_bedrock_project_id?: string | null;
@@ -283,10 +295,14 @@ export interface LiteLLMParams {
     aws_role_name?: string | null;
     aws_secret_access_key?: string | null;
     aws_session_name?: string | null;
+    aws_session_tags?: LiteLLMParamsAwsSessionTagsList | null;
     aws_session_token?: string | null;
     aws_sts_endpoint?: string | null;
     aws_web_identity_token?: string | null;
     azure_ad_token?: string | null;
+    azure_password?: string | null;
+    azure_scope?: string | null;
+    azure_username?: string | null;
     bedrock_tags?: LiteLLMParamsBedrockTagsList | null;
     budget_duration?: string | null;
     cache_creation_input_audio_token_cost?: number | null;
@@ -311,22 +327,27 @@ export interface LiteLLMParams {
     cache_read_input_token_cost_priority?: number | null;
     cache_read_input_token_cost_ultrafast?: number | null;
     citation_cost_per_token?: number | null;
+    client_id?: string | null;
+    client_secret?: string | null;
     complexity_router_config?: LiteLLMParamsComplexityRouterConfigMap | null;
     complexity_router_default_model?: string | null;
     configurable_clientside_auth_params?: LiteLLMParamsConfigurableClientsideAuthParamsList | null;
     custom_llm_provider?: string | null;
     default_api_key_rpm_limit?: number | null;
     default_api_key_tpm_limit?: number | null;
+    drop_params?: LiteLLMParamsDropParams | null;
     gcs_bucket_name?: string | null;
     google_maps_grounding_cost_per_query?: number | null;
     input_cost_per_audio_per_second?: number | null;
     input_cost_per_audio_per_second_above_128k_tokens?: number | null;
     input_cost_per_audio_token?: number | null;
+    input_cost_per_audio_token_batches?: number | null;
     input_cost_per_character?: number | null;
     input_cost_per_character_above_128k_tokens?: number | null;
     input_cost_per_image?: number | null;
     input_cost_per_image_above_128k_tokens?: number | null;
     input_cost_per_image_token?: number | null;
+    input_cost_per_image_token_batches?: number | null;
     input_cost_per_pixel?: number | null;
     input_cost_per_query?: number | null;
     input_cost_per_second?: number | null;
@@ -348,6 +369,7 @@ export interface LiteLLMParams {
     input_cost_per_video_per_second_above_15s_interval?: number | null;
     input_cost_per_video_per_second_above_8s_interval?: number | null;
     input_cost_per_video_token?: number | null;
+    input_cost_per_video_token_batches?: number | null;
     itpm?: number | null;
     keepalive_seconds?: number | null;
     litellm_credential_name?: string | null;
@@ -364,6 +386,7 @@ export interface LiteLLMParams {
     model_info?: LiteLLMParamsModelInfoMap | null;
     ocr_cost_per_credit?: number | null;
     ocr_cost_per_page?: number | null;
+    ocr_cost_per_page_batches?: number | null;
     organization?: string | null;
     otpm?: number | null;
     output_cost_per_audio_per_second?: number | null;
@@ -380,6 +403,7 @@ export interface LiteLLMParams {
     output_cost_per_second_1080p?: number | null;
     output_cost_per_second_480p?: number | null;
     output_cost_per_second_4k?: number | null;
+    output_cost_per_second_720p?: number | null;
     output_cost_per_token?: number | null;
     output_cost_per_token_above_128k_tokens?: number | null;
     output_cost_per_token_above_200k_tokens?: number | null;
@@ -404,12 +428,14 @@ export interface LiteLLMParams {
     rpm?: number | null;
     s3_bucket_name?: string | null;
     s3_encryption_key_id?: string | null;
+    s3_endpoint_url?: string | null;
     s3_output_bucket_name?: string | null;
     s3_region_name?: string | null;
     search_context_cost_per_query?: LiteLLMParamsSearchContextCostPerQueryMap | null;
     stream_timeout?: LiteLLMParamsStreamTimeout | null;
     tag_regex?: LiteLLMParamsTagRegexList | null;
     tags?: LiteLLMParamsTagsList | null;
+    tenant_id?: string | null;
     tiered_pricing?: LiteLLMParamsTieredPricingList | null;
     timeout?: LiteLLMParamsTimeout | null;
     tpm?: number | null;
@@ -453,6 +479,8 @@ export interface LitellmTypesRouterModelInfo {
     id: string | null;
     input_cost_per_character?: number | null;
     input_cost_per_token?: number | null;
+    internal_router_model?: boolean | null;
+    member_auto_router?: boolean;
     output_cost_per_character?: number | null;
     output_cost_per_token?: number | null;
     ptu_count?: number | null;
@@ -732,6 +760,10 @@ export interface GetModelInfoV2V2ModelInfoRequest {
     sortOrder?: string;
     /** Omit auto-router deployments (litellm model prefixed `auto_router/`). They select among deployments rather than being deployments themselves, so a caller rendering a deployment list can leave them out. Defaults to false, so existing callers are unaffected */
     exclude_auto_routers?: boolean;
+    /** Only return deployments whose `model_info.access_groups` contains this access group */
+    access_group?: string;
+    /** Only return wildcard deployments, i.e. those whose `model_name` contains `*` */
+    wildcard_only?: boolean;
 }
 export declare const GetModelInfoV2V2ModelInfoRequest: S.Schema<GetModelInfoV2V2ModelInfoRequest>;
 export interface GetModelInfoV2V2ModelInfoResponse {
@@ -834,6 +866,8 @@ export type UpdateLiteLLMParamsAdaptiveRouterConfigMap = {
     [key: string]: unknown | undefined;
 };
 export declare const UpdateLiteLLMParamsAdaptiveRouterConfigMap: S.Schema<UpdateLiteLLMParamsAdaptiveRouterConfigMap>;
+export type UpdateLiteLLMParamsAwsSessionTagsList = Array<AwsSessionTag>;
+export declare const UpdateLiteLLMParamsAwsSessionTagsList: S.Schema<UpdateLiteLLMParamsAwsSessionTagsList>;
 export type UpdateLiteLLMParamsBedrockTagsList = Array<unknown>;
 export declare const UpdateLiteLLMParamsBedrockTagsList: S.Schema<UpdateLiteLLMParamsBedrockTagsList>;
 export type UpdateLiteLLMParamsComplexityRouterConfigMap = {
@@ -844,6 +878,8 @@ export type UpdateLiteLLMParamsConfigurableClientsideAuthParamsItem = string | C
 export declare const UpdateLiteLLMParamsConfigurableClientsideAuthParamsItem: S.Schema<UpdateLiteLLMParamsConfigurableClientsideAuthParamsItem>;
 export type UpdateLiteLLMParamsConfigurableClientsideAuthParamsList = Array<UpdateLiteLLMParamsConfigurableClientsideAuthParamsItem>;
 export declare const UpdateLiteLLMParamsConfigurableClientsideAuthParamsList: S.Schema<UpdateLiteLLMParamsConfigurableClientsideAuthParamsList>;
+export type UpdateLiteLLMParamsDropParams = boolean | string;
+export declare const UpdateLiteLLMParamsDropParams: S.Schema<UpdateLiteLLMParamsDropParams>;
 export type UpdateLiteLLMParamsMilvusPartitionNamesList = Array<string>;
 export declare const UpdateLiteLLMParamsMilvusPartitionNamesList: S.Schema<UpdateLiteLLMParamsMilvusPartitionNamesList>;
 export type UpdateLiteLLMParamsMockResponse = string | ModelResponse | unknown;
@@ -885,6 +921,7 @@ export interface UpdateLiteLLMParams {
     adaptive_router_default_model?: string | null;
     allow_client_keepalive_override?: boolean | null;
     annotation_cost_per_page?: number | null;
+    annotation_cost_per_page_batches?: number | null;
     api_base?: string | null;
     api_key?: string | null;
     api_version?: string | null;
@@ -893,6 +930,8 @@ export interface UpdateLiteLLMParams {
     auto_router_default_model?: string | null;
     auto_router_embedding_model?: string | null;
     auto_router_max_input_chars?: number | null;
+    auto_router_model_compression?: string | null;
+    auto_router_routing_compression?: string | null;
     aws_access_key_id?: string | null;
     aws_batch_role_arn?: string | null;
     aws_bedrock_project_id?: string | null;
@@ -903,10 +942,14 @@ export interface UpdateLiteLLMParams {
     aws_role_name?: string | null;
     aws_secret_access_key?: string | null;
     aws_session_name?: string | null;
+    aws_session_tags?: UpdateLiteLLMParamsAwsSessionTagsList | null;
     aws_session_token?: string | null;
     aws_sts_endpoint?: string | null;
     aws_web_identity_token?: string | null;
     azure_ad_token?: string | null;
+    azure_password?: string | null;
+    azure_scope?: string | null;
+    azure_username?: string | null;
     bedrock_tags?: UpdateLiteLLMParamsBedrockTagsList | null;
     budget_duration?: string | null;
     cache_creation_input_audio_token_cost?: number | null;
@@ -931,22 +974,27 @@ export interface UpdateLiteLLMParams {
     cache_read_input_token_cost_priority?: number | null;
     cache_read_input_token_cost_ultrafast?: number | null;
     citation_cost_per_token?: number | null;
+    client_id?: string | null;
+    client_secret?: string | null;
     complexity_router_config?: UpdateLiteLLMParamsComplexityRouterConfigMap | null;
     complexity_router_default_model?: string | null;
     configurable_clientside_auth_params?: UpdateLiteLLMParamsConfigurableClientsideAuthParamsList | null;
     custom_llm_provider?: string | null;
     default_api_key_rpm_limit?: number | null;
     default_api_key_tpm_limit?: number | null;
+    drop_params?: UpdateLiteLLMParamsDropParams | null;
     gcs_bucket_name?: string | null;
     google_maps_grounding_cost_per_query?: number | null;
     input_cost_per_audio_per_second?: number | null;
     input_cost_per_audio_per_second_above_128k_tokens?: number | null;
     input_cost_per_audio_token?: number | null;
+    input_cost_per_audio_token_batches?: number | null;
     input_cost_per_character?: number | null;
     input_cost_per_character_above_128k_tokens?: number | null;
     input_cost_per_image?: number | null;
     input_cost_per_image_above_128k_tokens?: number | null;
     input_cost_per_image_token?: number | null;
+    input_cost_per_image_token_batches?: number | null;
     input_cost_per_pixel?: number | null;
     input_cost_per_query?: number | null;
     input_cost_per_second?: number | null;
@@ -968,6 +1016,7 @@ export interface UpdateLiteLLMParams {
     input_cost_per_video_per_second_above_15s_interval?: number | null;
     input_cost_per_video_per_second_above_8s_interval?: number | null;
     input_cost_per_video_token?: number | null;
+    input_cost_per_video_token_batches?: number | null;
     itpm?: number | null;
     keepalive_seconds?: number | null;
     litellm_credential_name?: string | null;
@@ -984,6 +1033,7 @@ export interface UpdateLiteLLMParams {
     model_info?: UpdateLiteLLMParamsModelInfoMap | null;
     ocr_cost_per_credit?: number | null;
     ocr_cost_per_page?: number | null;
+    ocr_cost_per_page_batches?: number | null;
     organization?: string | null;
     otpm?: number | null;
     output_cost_per_audio_per_second?: number | null;
@@ -1000,6 +1050,7 @@ export interface UpdateLiteLLMParams {
     output_cost_per_second_1080p?: number | null;
     output_cost_per_second_480p?: number | null;
     output_cost_per_second_4k?: number | null;
+    output_cost_per_second_720p?: number | null;
     output_cost_per_token?: number | null;
     output_cost_per_token_above_128k_tokens?: number | null;
     output_cost_per_token_above_200k_tokens?: number | null;
@@ -1024,12 +1075,14 @@ export interface UpdateLiteLLMParams {
     rpm?: number | null;
     s3_bucket_name?: string | null;
     s3_encryption_key_id?: string | null;
+    s3_endpoint_url?: string | null;
     s3_output_bucket_name?: string | null;
     s3_region_name?: string | null;
     search_context_cost_per_query?: UpdateLiteLLMParamsSearchContextCostPerQueryMap | null;
     stream_timeout?: UpdateLiteLLMParamsStreamTimeout | null;
     tag_regex?: UpdateLiteLLMParamsTagRegexList | null;
     tags?: UpdateLiteLLMParamsTagsList | null;
+    tenant_id?: string | null;
     tiered_pricing?: UpdateLiteLLMParamsTieredPricingList | null;
     timeout?: UpdateLiteLLMParamsTimeout | null;
     tpm?: number | null;
@@ -1093,7 +1146,7 @@ export interface PostBlockModelModelBlockResponse {
 export declare const PostBlockModelModelBlockResponse: S.Schema<PostBlockModelModelBlockResponse>;
 /** An operator-defined tier: the name the LLM classifier must return and its rubric description. */
 export interface TierDefinition {
-    /** What belongs in this tier; rendered as this tier's bullet in the classifier rubric. Required unless the name is a built-in tier (SIMPLE/MEDIUM/COMPLEX/REASONING), which inherits the built-in criteria when omitted */
+    /** What belongs in this tier; rendered as this tier's bullet in the classifier rubric. Required unless the name is a built-in tier (NON_REASONING, SIMPLE, MEDIUM, COMPLEX, REASONING), which inherits the built-in criteria when omitted */
     description?: string | null;
     /** Tier name; becomes a value the LLM classifier can return and a key of `tiers` */
     name: string;
@@ -1101,10 +1154,17 @@ export interface TierDefinition {
 export declare const TierDefinition: S.Schema<TierDefinition>;
 export type PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequestTierDefinitionsList = Array<TierDefinition>;
 export declare const PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequestTierDefinitionsList: S.Schema<PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequestTierDefinitionsList>;
+export type PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequestTierLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequestTierLabelsMap: S.Schema<PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequestTierLabelsMap>;
 export interface PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequest {
+    classification_examples?: string | null;
     classification_prompt?: string | null;
+    classification_rubric?: ClassificationRubric | (string & {}) | null;
     context_window_size?: number;
-    tier_definitions: PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequestTierDefinitionsList;
+    tier_definitions?: PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequestTierDefinitionsList | null;
+    tier_labels?: PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequestTierLabelsMap | null;
 }
 export declare const PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequest: S.Schema<PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequest>;
 /** When adaptive=True: 'all' scores every pool model with a tier-distance penalty (soft floors); 'classified_tier' Thompson-samples only inside the classified tier's pool */
@@ -1115,26 +1175,93 @@ export interface AdaptiveRouterWeights {
     quality?: number;
 }
 export declare const AdaptiveRouterWeights: S.Schema<AdaptiveRouterWeights>;
+export interface CapabilityCalibrationConfig {
+    intercept: number;
+    slope: number;
+    version: string;
+}
+export declare const CapabilityCalibrationConfig: S.Schema<CapabilityCalibrationConfig>;
+/** Use json_object for judges without strict JSON Schema support. This appends the verdict schema to the packaged system prompt; both modes validate the returned verdict identically. */
+export type CapabilityClassifierConfigResponseFormat = "json_schema" | "json_object";
+export declare const CapabilityClassifierConfigResponseFormat: any;
+/** Switchyard-compatible probability threshold policy for two model tiers. */
+export interface CapabilityClassifierConfig {
+    /** Lowest p_solve that routes a supported task to efficient_tier */
+    base_threshold: number;
+    /** Optional versioned sigmoid calibration fitted for this judge, capability card, efficient model, and execution setup. Applies sigmoid(slope * logit(clip(p_solve, 1e-6, 1-1e-6)) + intercept) before the threshold policy. Omit to route on the raw forecast. */
+    calibration?: CapabilityCalibrationConfig | null;
+    /** Higher, fail-closed tier used below the adjusted threshold or when the classifier verdict is unavailable */
+    capable_tier: string;
+    /** Tier used when the efficient model's forecasted solve probability meets the adjusted threshold */
+    efficient_tier: string;
+    /** Maximum completion tokens available to the capability classifier verdict */
+    max_output_tokens?: number;
+    /** Use json_object for judges without strict JSON Schema support. This appends the verdict schema to the packaged system prompt; both modes validate the returned verdict identically. */
+    response_format?: CapabilityClassifierConfigResponseFormat | (string & {});
+    /** Amount added once for uncertain or unmatched verdicts and twice for unsupported verdicts */
+    threshold_step?: number;
+}
+export declare const CapabilityClassifierConfig: S.Schema<CapabilityClassifierConfig>;
+/** When to run the complexity classifier. 'every_request' (the default) classifies every inference request, including the tool-result continuation turns of an agentic loop. 'user_turn' classifies only requests whose newest turn is a new human ask and replays the session's held routing decision on continuation turns, which cuts classifier spend and eliminates mid-loop model switches. Continuations with no held decision to replay (no resolvable session_id, expired pin, fresh restart) still classify. Unlike session_affinity, a new human ask always re-classifies, so a session can still move tiers between asks. Suppressed when plugins are configured, for the same reason session_affinity is: a replayed decision would bypass the plugin pipeline. */
+export type RequestComplexityRouterConfigClassificationMode = "every_request" | "user_turn";
+export declare const RequestComplexityRouterConfigClassificationMode: any;
 /** What classifies the request when the LLM classifier errors, times out, or returns an unparseable response. 'heuristic' runs the local complexity scorer, which is right when the classifier grades complexity too. 'default_model' skips scoring and routes to default_model, which is what a classifier on some other taxonomy wants: a prompt that grades data sensitivity has no use for a complexity score, and scoring one produces a tier unrelated to what the operator configured. Requires default_model when set to 'default_model'. Only applies when classifier_type is 'llm', 'custom', or 'heuristic_first'. */
 export type RequestComplexityRouterConfigClassifierFallback = "heuristic" | "default_model";
 export declare const RequestComplexityRouterConfigClassifierFallback: any;
+export type ClassifierLLMConfigReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export declare const ClassifierLLMConfigReasoningEffort: any;
+/** Whether the LLM classifier sees the images on the request it is classifying. Off by default because images cost far more than the text ask they arrive with, and the classifier runs on every request. A turn whose complexity lives in the image ("what is wrong in this stack trace screenshot") is invisible to a text-only classifier, which is what this buys. */
+export interface ClassifierVisionConfig {
+    /** Forward image content to the classifier. Requires a classifier model declared supports_vision, on the deployment's model_info or in the model cost map; images stay stripped otherwise, so a classifier that cannot read them is never sent one. Declare model_info.supports_vision on the deployment to enable a model the cost map does not describe. Only inline data: URIs are forwarded. A request whose images are http(s) URLs still classifies on its text alone, because some providers fetch such a URL from the proxy rather than the provider, which would let a caller aim a proxy-side request at an address of their choosing. */
+    enabled?: boolean;
+    /** How many images from the newest user turn to forward, in wire order. Bounds the added cost of a turn that attaches many images. Images on earlier turns are never forwarded. */
+    max_images?: number;
+}
+export declare const ClassifierVisionConfig: S.Schema<ClassifierVisionConfig>;
 /** Configuration for the LLM-based complexity classifier. */
 export interface ClassifierLLMConfig {
+    /** How long to skip this router's LLM classifier after a classification call times out. Requests use classifier_fallback during the cooldown. When it expires, one request probes the classifier while concurrent requests keep using the fallback; a successful probe closes the circuit and a failed probe restarts the cooldown. */
+    circuit_breaker_cooldown_seconds?: number;
+    /** Whether one classifier timeout temporarily sends requests through classifier_fallback. Enabled by default so an unhealthy classifier cannot repeat its timeout across sessions. */
+    circuit_breaker_enabled?: boolean;
     /** Which calibration examples the built-in rubric carries. 'agentic' anchors routine installs, builds, multi-file edits, and standard debugging at MEDIUM, so ordinary engineering does not route to the most expensive tier; it suits agent, terminal, and coding-assistant traffic as well as mixed traffic. 'chat' omits those engineering anchors, for a deployment serving only conversational traffic. 'business' carries business/sales anchors and business-flavored tier criteria that keep routine drafting and summarizing off the expensive tiers and reserve the top tier for committing to decisions under tradeoffs; it suits sales, support, and go-to-market traffic. Every preset keeps the same four tiers, so this moves where the boundary sits without changing the taxonomy. Leave unset for 'legacy', the rubric as it shipped before calibration examples existed, so an existing router's tier decisions and spend do not move on upgrade. Mutually exclusive with system_prompt, which replaces the rubric this would select. Only applies when classifier_type is 'llm'. */
     classification_rubric?: ClassificationRubric | (string & {}) | null;
     /** Model name (from the router's model_list) to call for classification */
     model: string;
+    /** Reasoning effort override for classifier calls. Leave unset to use the classifier deployment or provider default. */
+    reasoning_effort?: ClassifierLLMConfigReasoningEffort | (string & {}) | null;
     /** Replaces the built-in complexity rubric as the classifier's entire system role. When set, neither the default rubric nor the context-window closing line is appended, so the prompt owns the whole taxonomy and the tier names SIMPLE/MEDIUM/COMPLEX/REASONING become whatever buckets it defines: a prompt that classifies data sensitivity routes on that instead of on difficulty. Two consequences of full replacement. The default rubric's closing paragraph is the classifier's prompt-injection defense, telling it that the caller's quoted system prompt and prior turns are material to judge and never instructions; a replacement that omits it lets a caller ask for a tier and get it. And the heuristic fallback still scores complexity, so a router on some other taxonomy wants classifier_fallback='default_model'. Leave unset for the built-in rubric. Only applies when classifier_type is 'llm'. */
     system_prompt?: string | null;
     /** Timeout budget for the classification call, in milliseconds */
     timeout_ms?: number;
+    /** Whether the classifier sees images on the request, and how many */
+    vision?: ClassifierVisionConfig;
 }
 export declare const ClassifierLLMConfig: S.Schema<ClassifierLLMConfig>;
-/** Classification strategy: local regex/keyword scoring, an LLM call, a custom classifier plugin, or 'heuristic_first', which scores locally and only pays for the LLM classifier when the local scorer does not confidently land a cheap tier */
-export type RequestComplexityRouterConfigClassifierType = "heuristic" | "llm" | "custom" | "heuristic_first";
+/** Classification strategy: local regex/keyword scoring, the bundled trained four-tier heuristic, an LLM tier-selection call, a Switchyard-compatible capability forecast, a joint Fuse V2 forecast, a custom classifier plugin, 'heuristic_first', which scores locally and only pays for the LLM classifier when the local scorer does not confidently land a cheap tier, or 'hybrid', which trusts the local scorer everywhere except when its score lands near a tier boundary, or 'jev', a TypeSafe AI Jev structured choice call */
+export type RequestComplexityRouterConfigClassifierType = "heuristic" | "heuristic_v2" | "llm" | "capability" | "llm_v2" | "custom" | "heuristic_first" | "hybrid" | "jev";
 export declare const RequestComplexityRouterConfigClassifierType: any;
 export type RequestComplexityRouterConfigCodeKeywordsList = Array<string>;
 export declare const RequestComplexityRouterConfigCodeKeywordsList: S.Schema<RequestComplexityRouterConfigCodeKeywordsList>;
+export type CustomDimensionKeywordsList = Array<string>;
+export declare const CustomDimensionKeywordsList: S.Schema<CustomDimensionKeywordsList>;
+export type CustomDimensionPatternsList = Array<string>;
+export declare const CustomDimensionPatternsList: S.Schema<CustomDimensionPatternsList>;
+/** 'binary' scores 1 when any matcher hits. 'match_count' scores 0.5 when one distinct matcher hits and 1 when two or more do; repeated occurrences of one matcher never raise it. Keywords are distinct case-insensitively, patterns by source, and a keyword and a pattern are always distinct from each other. */
+export type CustomDimensionScoringMode = "binary" | "match_count";
+export declare const CustomDimensionScoringMode: any;
+export interface CustomDimension {
+    keywords?: CustomDimensionKeywordsList;
+    name: string;
+    patterns?: CustomDimensionPatternsList;
+    /** 'binary' scores 1 when any matcher hits. 'match_count' scores 0.5 when one distinct matcher hits and 1 when two or more do; repeated occurrences of one matcher never raise it. Keywords are distinct case-insensitively, patterns by source, and a keyword and a pattern are always distinct from each other. */
+    scoring_mode?: CustomDimensionScoringMode | (string & {});
+    weight: number;
+}
+export declare const CustomDimension: S.Schema<CustomDimension>;
+/** Named dimensions added to the heuristic-v1 score. Each contributes its inline weight once when any keyword matches the current ask or a case-insensitive regex matches its first 2048 characters; scoring_mode 'match_count' instead grades half weight for one distinct matcher and full for two or more. Regex quantifiers repeat one character or class at most 64 times. Unbounded quantifiers, repeated groups, backreferences and lookarounds are rejected. Conservative work limits include alternation paths, repeat lengths and subsequent matching: 2048 units per pattern, 8192 across the router. Only heuristic, heuristic_first and hybrid accept this field. Uses the existing heuristic tuning quota. */
+export type RequestComplexityRouterConfigCustomDimensionsList = Array<CustomDimension>;
+export declare const RequestComplexityRouterConfigCustomDimensionsList: S.Schema<RequestComplexityRouterConfigCustomDimensionsList>;
 export type RequestComplexityRouterConfigCustomTechnicalKeywordsList = Array<string>;
 export declare const RequestComplexityRouterConfigCustomTechnicalKeywordsList: S.Schema<RequestComplexityRouterConfigCustomTechnicalKeywordsList>;
 /** Weights for each scoring dimension */
@@ -1144,8 +1271,76 @@ export type RequestComplexityRouterConfigDimensionWeightsMap = {
 export declare const RequestComplexityRouterConfigDimensionWeightsMap: S.Schema<RequestComplexityRouterConfigDimensionWeightsMap>;
 export type RequestComplexityRouterConfigEscalationKeywordsList = Array<string>;
 export declare const RequestComplexityRouterConfigEscalationKeywordsList: S.Schema<RequestComplexityRouterConfigEscalationKeywordsList>;
+export interface TierCohortStatistic {
+    cohort: string;
+    observations: number;
+    successes: number;
+    tier: number;
+}
+export declare const TierCohortStatistic: S.Schema<TierCohortStatistic>;
+export type TrainedTierArtifactCohortStatisticsList = Array<TierCohortStatistic>;
+export declare const TrainedTierArtifactCohortStatisticsList: S.Schema<TrainedTierArtifactCohortStatisticsList>;
+export interface TierDataset {
+    license: string;
+    name: string;
+    rows: number;
+    success_definition?: string;
+    url: string;
+}
+export declare const TierDataset: S.Schema<TierDataset>;
+export type TrainedTierArtifactDatasetsList = Array<TierDataset>;
+export declare const TrainedTierArtifactDatasetsList: S.Schema<TrainedTierArtifactDatasetsList>;
+/** Fixed v0 taxonomy. User-extensible types come in v1. */
+export type RequestType = "code_generation" | "code_understanding" | "technical_design" | "analytical_reasoning" | "writing" | "factual_lookup" | "general";
+export declare const RequestType: any;
+export interface TierDomainStatistic {
+    observations: number;
+    request_type: RequestType | (string & {});
+    successes: number;
+    tier: number;
+}
+export declare const TierDomainStatistic: S.Schema<TierDomainStatistic>;
+export type TrainedTierArtifactDomainStatisticsList = Array<TierDomainStatistic>;
+export declare const TrainedTierArtifactDomainStatisticsList: S.Schema<TrainedTierArtifactDomainStatisticsList>;
+export interface TierGlobalStatistic {
+    observations: number;
+    successes: number;
+    tier: number;
+}
+export declare const TierGlobalStatistic: S.Schema<TierGlobalStatistic>;
+export type TrainedTierArtifactGlobalStatisticsList = Array<TierGlobalStatistic>;
+export declare const TrainedTierArtifactGlobalStatisticsList: S.Schema<TrainedTierArtifactGlobalStatisticsList>;
+export interface TrainedTierArtifact {
+    cohort_prior_mass?: number;
+    cohort_statistics?: TrainedTierArtifactCohortStatisticsList;
+    datasets?: TrainedTierArtifactDatasetsList;
+    domain_prior_mass?: number;
+    domain_statistics?: TrainedTierArtifactDomainStatisticsList;
+    global_statistics: TrainedTierArtifactGlobalStatisticsList;
+    routing_threshold?: number;
+    schema_version?: number;
+    split_method?: string;
+    success_definition?: string;
+}
+export declare const TrainedTierArtifact: S.Schema<TrainedTierArtifact>;
+/** Success-probability artifact used by classifier_type 'heuristic_v2'. The bundled UltraFeedback artifact is selected by default; an inline trained artifact may replace it */
+export type RequestComplexityRouterConfigHeuristicV2Artifact = TrainedTierArtifact | string;
+export declare const RequestComplexityRouterConfigHeuristicV2Artifact: S.Schema<RequestComplexityRouterConfigHeuristicV2Artifact>;
 export type RequestComplexityRouterConfigHousekeepingPatternsList = Array<string>;
 export declare const RequestComplexityRouterConfigHousekeepingPatternsList: S.Schema<RequestComplexityRouterConfigHousekeepingPatternsList>;
+export interface JevClassifierConfig {
+    /** TypeSafe API base, falling back to TYPESAFE_API_BASE and then https://api.typesafe.ai */
+    api_base?: string | null;
+    /** TypeSafe API key, falling back to TYPESAFE_API_KEY */
+    api_key?: string | null;
+    circuit_breaker_cooldown_seconds?: number;
+    circuit_breaker_enabled?: boolean;
+    /** Replaces the built-in Jev question instructions */
+    instructions?: string | null;
+    model?: string;
+    timeout_ms?: number;
+}
+export declare const JevClassifierConfig: S.Schema<JevClassifierConfig>;
 /** Keywords/phrases that trigger this rule (lexical or semantic match) */
 export type KeywordTierRuleKeywordsList = Array<string>;
 export declare const KeywordTierRuleKeywordsList: S.Schema<KeywordTierRuleKeywordsList>;
@@ -1159,6 +1354,36 @@ export interface KeywordTierRule {
 export declare const KeywordTierRule: S.Schema<KeywordTierRule>;
 export type RequestComplexityRouterConfigKeywordTierRulesList = Array<KeywordTierRule>;
 export declare const RequestComplexityRouterConfigKeywordTierRulesList: S.Schema<RequestComplexityRouterConfigKeywordTierRulesList>;
+export interface LLMV2ProbabilityCalibration {
+    intercept: number;
+    slope: number;
+}
+export declare const LLMV2ProbabilityCalibration: S.Schema<LLMV2ProbabilityCalibration>;
+export interface LLMV2Calibration {
+    capable: LLMV2ProbabilityCalibration;
+    efficient: LLMV2ProbabilityCalibration;
+    prompt_version: string;
+    version: string;
+}
+export declare const LLMV2Calibration: S.Schema<LLMV2Calibration>;
+export type LLMV2ConfigResponseFormat = "json_schema" | "json_object";
+export declare const LLMV2ConfigResponseFormat: any;
+export interface LLMV2Config {
+    calibration?: LLMV2Calibration | null;
+    capable_profile?: string | null;
+    capable_profile_preset?: string | null;
+    capable_tier?: string;
+    efficient_profile?: string | null;
+    efficient_profile_preset?: string | null;
+    efficient_tier?: string;
+    harness?: string | null;
+    harness_preset?: string | null;
+    max_output_tokens?: number;
+    /** Maximum estimated success loss allowed for efficient. */
+    max_quality_gap: number;
+    response_format?: LLMV2ConfigResponseFormat | (string & {});
+}
+export declare const LLMV2Config: S.Schema<LLMV2Config>;
 export type RequestComplexityRouterConfigPlanModePatternsList = Array<string>;
 export declare const RequestComplexityRouterConfigPlanModePatternsList: S.Schema<RequestComplexityRouterConfigPlanModePatternsList>;
 export type RequestComplexityRouterConfigReasoningKeywordsList = Array<string>;
@@ -1226,50 +1451,77 @@ export interface RequestComplexityRouterConfig {
     adaptive_eligible?: RequestComplexityRouterConfigAdaptiveEligible | (string & {});
     /** Quality vs cost weights for adaptive selection (used when adaptive=True) */
     adaptive_weights?: AdaptiveRouterWeights;
-    /** Replaces the opening instructions of the LLM classifier rubric (the judging-criteria prose) for a custom tier set. The per-tier bullets and the trust-boundary paragraph telling the classifier to ignore tier requests embedded in quoted caller text are always appended after it and cannot be overridden. Requires tier_definitions; a built-in-tier router customizes its prompt via classifier_llm_config.system_prompt or classification_rubric instead. */
+    /** Probability threshold policy required when classifier_type is 'capability'. The classifier forecasts p_solve for efficient_tier, adjusts base_threshold using the capability-card boundary, and otherwise routes to capable_tier */
+    capability_classifier_config?: CapabilityClassifierConfig | null;
+    /** Replaces the calibration examples of the LLM classifier rubric, and nothing else. Written as example lines only: the router renders the 'Calibration examples:' heading above them, after the per-tier bullets. Requires an LLM classifier and cannot be combined with classifier_llm_config.system_prompt. With built-in tiers the rubric preset still supplies the tier criteria and, unless classification_prompt replaces them, the classification instructions; a custom tier set ships no examples of its own, so the section renders only when this is set. */
+    classification_examples?: string | null;
+    /** When to run the complexity classifier. 'every_request' (the default) classifies every inference request, including the tool-result continuation turns of an agentic loop. 'user_turn' classifies only requests whose newest turn is a new human ask and replays the session's held routing decision on continuation turns, which cuts classifier spend and eliminates mid-loop model switches. Continuations with no held decision to replay (no resolvable session_id, expired pin, fresh restart) still classify. Unlike session_affinity, a new human ask always re-classifies, so a session can still move tiers between asks. Suppressed when plugins are configured, for the same reason session_affinity is: a replayed decision would bypass the plugin pipeline. */
+    classification_mode?: RequestComplexityRouterConfigClassificationMode | (string & {});
+    /** Replaces the classification instructions that open the LLM classifier rubric, and nothing else. The per-tier bullets follow it, the calibration examples follow those, and the trust-boundary paragraph telling the classifier to ignore tier requests embedded in quoted caller text is always appended after them and cannot be overridden. Requires an LLM classifier and cannot be combined with classifier_llm_config.system_prompt. With built-in tiers the rubric preset still supplies the tier criteria and, unless classification_examples replaces them, the calibration examples. */
     classification_prompt?: string | null;
-    /** Maximum characters of prior-turn text quoted to the LLM classifier, across the whole context window, per classification call. Turns are taken newest first and quoted whole while they fit, so a conversation small enough to quote entirely is never cut; once the budget runs out the older turns are dropped whole and only the turn straddling the boundary is truncated, into whatever space is left. The current ask and the caller's system prompt sit outside this budget and are always sent in full, as does the numbering each quoted turn carries. A budget under 120 leaves no room to quote a turn and suppresses the block; set classifier_context_window_size to 0 to turn context off deliberately. Only applies when classifier_type is 'llm'. */
+    /** Maximum characters of prior-turn text quoted to the LLM classifier, across the whole context window, per classification call. Turns are taken newest first and quoted whole while they fit, so a conversation small enough to quote entirely is never cut; once the budget runs out the older turns are dropped whole and only the turn straddling the boundary is truncated, into whatever space is left. The current ask and, except for Claude Code requests, the extracted system-role text sit outside this budget and are sent in full, as does the numbering each quoted turn carries. A budget under 120 leaves no room to quote a turn and suppresses the block; set classifier_context_window_size to 0 to turn context off deliberately. Only applies when classifier_type is 'llm'. */
     classifier_context_budget_chars?: number;
     /** Include assistant turns in the classifier context window, so difficulty stated by the model rather than by the user stays visible: a plan the assistant calls complex, which the user approves with 'yes', is classified on the work being approved instead of on the word 'yes'. When enabled, classifier_context_window_size counts the last N turns of the conversation across both roles rather than the last N user turns, and assistant text is sent to the classifier model, which may be a different deployment or provider than the routed completion model. Assistant replies spend classifier_context_budget_chars alongside user turns, so raise it if the oldest turns stop being quoted once replies join the window. Off by default because enabling it shifts tier decisions, and therefore spend, for an already-deployed router. Only applies when classifier_type is 'llm'. */
     classifier_context_include_assistant_turns?: boolean;
     /** Optional cap on each individual prior turn's text, applied before classifier_context_budget_chars bounds the block. Unset by default, so one long turn may spend the whole budget, which is usually what a follow-up needs; set it when no single turn should dominate the context the classifier sees. A capped turn keeps its opening and its ending with the middle elided. Only applies when classifier_type is 'llm'. */
     classifier_context_per_turn_chars?: number | null;
-    /** Number of prior user turns (tool output and harness reminders excluded) to include as context in the LLM classifier prompt, so a follow-up like 'now do the same for the streaming path' is classified against what it refers to. Counts turns of both roles when classifier_context_include_assistant_turns is enabled. These turns are sent to the classifier model, which may be a different deployment or provider than the routed completion model; that call already carries the current user ask and the caller's system prompt in full. Set to 0 to send neither prior turns nor any conversation context beyond the current ask. Only applies when classifier_type is 'llm'. */
+    /** Number of prior user turns (tool output and harness reminders excluded) to include as context in the LLM classifier prompt, so a follow-up like 'now do the same for the streaming path' is classified against what it refers to. Counts turns of both roles when classifier_context_include_assistant_turns is enabled. These turns are sent to the classifier model, which may be a different deployment or provider than the routed completion model; that call carries the current user ask and, except for Claude Code requests, the extracted system-role text in full. Claude Code system text is omitted to avoid classifying harness instructions; the routed completion still receives it. Set to 0 to send neither prior turns nor any conversation context beyond the current ask. Only applies when classifier_type is 'llm'. */
     classifier_context_window_size?: number;
     /** What classifies the request when the LLM classifier errors, times out, or returns an unparseable response. 'heuristic' runs the local complexity scorer, which is right when the classifier grades complexity too. 'default_model' skips scoring and routes to default_model, which is what a classifier on some other taxonomy wants: a prompt that grades data sensitivity has no use for a complexity score, and scoring one produces a tier unrelated to what the operator configured. Requires default_model when set to 'default_model'. Only applies when classifier_type is 'llm', 'custom', or 'heuristic_first'. */
     classifier_fallback?: RequestComplexityRouterConfigClassifierFallback | (string & {});
-    /** Configuration for the LLM classifier; required when classifier_type is 'llm' or 'heuristic_first' */
+    /** Configuration for the LLM classifier; required when classifier_type is 'llm', 'capability', 'heuristic_first' or 'hybrid' */
     classifier_llm_config?: ClassifierLLMConfig | null;
     /** Not settable over HTTP; the classifier plugin is a runtime object */
     classifier_plugin?: unknown | null;
     /** Timeout budget for the classifier plugin call, in milliseconds. On expiry the fallback path decides the tier. Only applies when classifier_type is 'custom'. */
     classifier_plugin_timeout_ms?: number;
-    /** Classification strategy: local regex/keyword scoring, an LLM call, a custom classifier plugin, or 'heuristic_first', which scores locally and only pays for the LLM classifier when the local scorer does not confidently land a cheap tier */
+    /** Classification strategy: local regex/keyword scoring, the bundled trained four-tier heuristic, an LLM tier-selection call, a Switchyard-compatible capability forecast, a joint Fuse V2 forecast, a custom classifier plugin, 'heuristic_first', which scores locally and only pays for the LLM classifier when the local scorer does not confidently land a cheap tier, or 'hybrid', which trusts the local scorer everywhere except when its score lands near a tier boundary, or 'jev', a TypeSafe AI Jev structured choice call */
     classifier_type?: RequestComplexityRouterConfigClassifierType | (string & {});
     /** Keywords indicating code-related content */
     code_keywords?: RequestComplexityRouterConfigCodeKeywordsList | null;
+    /** Fraction of a model's declared context window the estimated prompt must fit within. The token count is an estimate, so fitting against the full window would dispatch prompts that the provider's own tokenizer then rejects; 0.95 leaves room for that drift plus the response tokens. */
+    context_window_escalation_buffer?: number;
+    /** Named dimensions added to the heuristic-v1 score. Each contributes its inline weight once when any keyword matches the current ask or a case-insensitive regex matches its first 2048 characters; scoring_mode 'match_count' instead grades half weight for one distinct matcher and full for two or more. Regex quantifiers repeat one character or class at most 64 times. Unbounded quantifiers, repeated groups, backreferences and lookarounds are rejected. Conservative work limits include alternation paths, repeat lengths and subsequent matching: 2048 units per pattern, 8192 across the router. Only heuristic, heuristic_first and hybrid accept this field. Uses the existing heuristic tuning quota. */
+    custom_dimensions?: RequestComplexityRouterConfigCustomDimensionsList;
     /** Domain-specific technical keywords appended to the effective base list (technical_keywords if set, otherwise DEFAULT_TECHNICAL_KEYWORDS). Order is preserved; duplicates are removed case-insensitively against the base list and within this list. */
     custom_technical_keywords?: RequestComplexityRouterConfigCustomTechnicalKeywordsList | null;
     /** Default model to use if tier cannot be determined */
     default_model?: string | null;
-    /** When True and a session_id is resolvable on the request, pin the deployment chosen inside each routed model group and reuse it whenever the session returns to that group, without pinning which group the session routes to. Independent of session_affinity, which pins the model group instead (and always carries this deployment pin with it): with session_affinity off, every turn is still classified on its own merits while a session that escalates to a stronger tier and comes back still lands on the deployment it used before, which is what keeps a provider prompt cache warm. Pins are held per model group, so switching tiers does not disturb the pin left behind in the previous group. On by default because re-shuffling a conversation across deployments of the same model discards that cache for no benefit; set False to keep every turn load-balanced across the group, which is what a deployment set with tight per-deployment rate limits wants. Inert when no session_id is resolvable, since there is nothing to key a pin on, and suppressed when plugins are configured, for the same reason session_affinity is. */
+    /** When True and a client session_id is resolvable, reuse the session's chosen model for each classified tier and its deployment within each model group. With session_affinity off, every turn is still classified: moving to another tier leaves the previous tier's model pin intact for a later return. Pins yield to current candidate, context, modality, and availability constraints. Adaptive selection chooses the initial model from its eligible pool, then reuses that choice per tier. This reduces avoidable provider prompt-cache misses; it does not guarantee cache hits. Set False to select models and load-balance deployments on every turn, unless session_affinity or user_turn classification requires a pin. Inert without a client session_id and suppressed when plugins are configured. */
     deployment_affinity?: boolean;
     /** Weights for each scoring dimension */
     dimension_weights?: RequestComplexityRouterConfigDimensionWeightsMap;
     /** Embedding model (LiteLLM model name) used when semantic_keyword_matching is enabled */
     embedding_model?: string | null;
+    /** Escalate a request off a tier whose models provably cannot hold its prompt, before dispatch. The classifier scores complexity and never prompt size, so a long agentic session whose newest ask is trivial lands on a small-window tier and the provider rejects it with a context-window 400 that nothing retries. When every model of the decided tier has a declared window smaller than the estimated prompt, the request moves to the lowest configured tier with a model whose declared window fits; when only some of the tier's models fit, the pick is restricted to those and the tier keeps the request. Models with no resolvable window are never escalated away from and never escalated onto. Set false to dispatch on complexity alone, as before. */
+    enable_context_window_escalation?: boolean;
+    /** Add NON_REASONING as a fifth built-in tier below SIMPLE, for operational agent traffic that relays or reformats information rather than reasoning about it. Off by default: turning it on adds a rung to this router's ladder, a bullet to the LLM classifier's rubric, and a value the classifier may return, all of which move tier decisions and spend on an already-deployed router. Requires an LLM, Jev, or custom classifier plugin, since the heuristic scorers cannot produce the tier, and a model in `tiers` under the NON_REASONING key. Escalation still walks up from it, and it is never the savings baseline or a `heuristic_v2` prediction. */
+    enable_non_reasoning_tier?: boolean;
     /** Case-sensitive phrases a user can include to force a bump to the next-higher complexity tier when they aren't satisfied with results (they can force a stronger model, but not choose which one). Defaults to ['LITELLM ESCALATE'] when unset; set to an empty list to disable. */
     escalation_keywords?: RequestComplexityRouterConfigEscalationKeywordsList | null;
     /** Tier routed to when the LLM classifier fails (timeout, provider error, or an unparseable reply). Required with tier_definitions and must name a defined tier; the heuristic scorer cannot produce custom tiers, so this replaces the heuristic fallback for custom tier sets. */
     fallback_tier?: string | null;
     /** The highest tier the local scorer may decide on its own; required when classifier_type is 'heuristic_first' and rejected otherwise. A request whose heuristic tier is at or below this one skips the LLM classifier and routes straight to that heuristic tier, so the classifier call is only paid for on traffic the scorer could not place cheaply. The scorer must also have produced at least one signal: a prompt where no dimension fired scores 0.0 and would otherwise land SIMPLE by default rather than by evidence, which is how a chained router would silently send unclassified traffic to the cheapest model. Names a built-in tier, and may not name the highest one, since that would make the LLM classifier unreachable. */
     heuristic_first_max_tier?: string | null;
+    /** Success-probability artifact used by classifier_type 'heuristic_v2'. The bundled UltraFeedback artifact is selected by default; an inline trained artifact may replace it */
+    heuristic_v2_artifact?: RequestComplexityRouterConfigHeuristicV2Artifact;
     /** Additional case-sensitive literal sentinels that mark a request as client housekeeping, on top of the built-in conversation-title ones. For clients whose wording the built-ins don't cover, or after a client release changes its strings. */
     housekeeping_patterns?: RequestComplexityRouterConfigHousekeepingPatternsList | null;
+    /** How close to a tier boundary a heuristic score has to land before the LLM classifier breaks the tie; required when classifier_type is 'hybrid' and rejected otherwise. Everything further than this from every active boundary routes on the scorer's own tier with no classifier call, at any tier, which is what separates 'hybrid' from 'heuristic_first' and its cheap-tier ceiling. A prompt where no dimension fired still goes to the classifier, since the scorer has no opinion to be near a boundary with. 0 escalates only scores sitting exactly on a boundary. */
+    hybrid_boundary_margin?: number | null;
+    jev_classifier_config?: JevClassifierConfig | null;
     /** Rules that force a specific tier when their keywords match the prompt */
     keyword_tier_rules?: RequestComplexityRouterConfigKeywordTierRulesList | null;
+    /** Experimental joint task-demand and solver-capability forecasting for classifier_type llm_v2. */
+    llm_v2_config?: LLMV2Config | null;
     /** Minimum cosine similarity for a semantic keyword match */
     match_threshold?: number;
+    /** Set max_tokens on every routed request to the output ceiling of the tier model it lands on, replacing whatever the caller sent. A caller behind an auto-router cannot pick one value that fits every tier: the smallest tier's ceiling starves a bigger tier's thinking budget, and a bigger tier's ceiling is rejected by the smallest. The ceiling is the smallest max_output_tokens across the tier model's deployments, read from each deployment's model_info and then the model cost map; a tier model with a deployment whose ceiling is unknown keeps the caller's value. A max_tokens, max_completion_tokens or max_output_tokens in the tier's own litellm_params still wins. Set false to forward the caller's value unchanged. */
+    max_tokens_from_tier_model?: boolean;
+    /** Let modality_routing replace a kept session-affinity pin on the turns that carry an image. Without this, a session pinned to a text-only model fails every image turn with a provider 400, since the pin is exempt from the modality gate. When enabled, such a turn routes to a capable model for that request only and the stored pin is left untouched, so the next text turn replays the session's own model; the override is reported as cause modality_pin_override and is never itself pinned. Inert unless modality_routing is also enabled. */
+    modality_pin_override?: boolean;
+    /** Route image-bearing requests only to models that can accept image input. The classifier reads text alone, so an image request whose text classifies cheap otherwise lands on a text-only model and fails with a provider 400. When enabled, a routed model explicitly declared supports_vision false (deployment model_info or the model cost map; unmapped names stay routable) is replaced by the nearest HIGHER tier holding a capable model, then default_model, else a clear 400. A kept session-affinity pin still wins even when an image arrives, unless modality_pin_override is also enabled. */
+    modality_routing?: boolean;
     /** When set, requests carrying a coding-agent plan-mode sentinel (Claude Code plan mode, VS Code Copilot Plan mode, Copilot CLI's exit_plan_mode tool) are routed to at least this tier: the classified tier still wins when it is higher, and the floor also overrides a session-affinity pin to a lower tier for exactly the turns carrying the sentinel, without rewriting the pin -- the first turn after plan mode exits routes as if plan mode had never happened. Names a built-in tier, or with tier_definitions set, one of the defined tier names (list order is ascending severity, same as keyword_tier_rules). Unset disables detection entirely. The sentinels ride in client-injected prompt text, so a caller who pastes one can spend up to this tier's models -- never down, and never outside the configured pools. */
     plan_mode_min_tier?: string | null;
     /** Additional case-sensitive literal sentinels that mark a request as plan mode, on top of the built-in Claude Code and Copilot ones. For clients whose plan-mode wording the built-ins don't cover, or after a client release changes its strings. */
@@ -1280,7 +1532,7 @@ export interface RequestComplexityRouterConfig {
     reasoning_keywords?: RequestComplexityRouterConfigReasoningKeywordsList | null;
     /** Minimum weighted score a request must reach before 2+ reasoning markers may promote it to the reasoning tier. Unset tracks tier_boundaries.simple_medium, so the override never rescues a request the scorer placed in the cheapest tier; 0 restores the unconditional override */
     reasoning_override_min_score?: number | null;
-    /** Override the delimiter pairs used to recognize and strip harness-injected reminder blocks before classification. A harness that wraps injected context differently per agent type (main, subagent, cron) lists every pair it emits. Replaces, rather than adds to, the built-in default of ('<system-reminder>', '</system-reminder>'), so a harness that also emits that pair lists it too. Matching is case-insensitive. */
+    /** Override the delimiter pairs used to recognize and strip harness-injected reminder blocks before classification. A harness that wraps injected context differently per agent type (main, subagent, cron) lists every pair it emits. Replaces, rather than adds to, the built-in system-reminder pair and the Codex envelope pairs enabled for Codex user agents, so list every built-in pair your harness also emits. Matching is case-insensitive. */
     reminder_markers?: RequestComplexityRouterConfigReminderMarkersList | null;
     /** Return the resolved raw model name in the response model field instead of the client-requested complexity-router alias */
     return_raw_model_name?: boolean;
@@ -1290,15 +1542,21 @@ export interface RequestComplexityRouterConfig {
     semantic_keyword_matching?: boolean;
     /** When True and a session_id is resolvable on the request, pin the model chosen on the session's first turn and reuse it for every later turn, skipping re-classification. Off by default so every turn is classified on its own merits and routed to the cheapest adequate tier. Set True to keep a multi-turn session on one model, which preserves provider prompt caches and avoids cross-model conversation-history errors. Always implies the deployment pin regardless of deployment_affinity: the session sticks to one deployment of the pinned model, since freezing the model while re-shuffling its deployments would still go cache-cold. */
     session_affinity?: boolean;
-    /** TTL for the session affinity pin; refreshed on every cache hit. Bounds both the session_affinity model pin and the deployment_affinity deployment pin, so it measures idle time for the session's routing decisions rather than total session length */
+    /** TTL for the session affinity pin; refreshed on every cache hit. Bounds both the session_affinity model pin and the deployment_affinity per-tier model and deployment pins, so it measures idle time for the session's routing decisions rather than total session length */
     session_affinity_ttl_seconds?: number;
     /** Keywords indicating simple/basic queries */
     simple_keywords?: RequestComplexityRouterConfigSimpleKeywordsList | null;
+    /** Escalate mid-task to the next-higher configured tier when the assistant's own recent tool calls look stuck: the newest tool call repeats, or errors, at least stall_escalation_repeat_threshold times across the last stall_escalation_window calls. Both tests are anchored on the newest call, so a task that tried the same thing a few times and then moved on is not escalated on the strength of those older calls alone, while a retry loop broken up by an unrelated lookup still counts. One tier at most, on the same ladder escalation_keywords bumps along, and never above the highest configured tier. Detection re-runs on every classified turn from the tool calls visible in that request, so it needs no state and nothing survives past the task. Mutually exclusive with session_affinity and classification_mode='user_turn', which both replay a held routing decision instead of classifying most turns, so this would never see the tool calls to look at. Off by default. */
+    stall_escalation_enabled?: boolean;
+    /** How many of the last stall_escalation_window tool calls must repeat the newest call, or must have errored alongside it, before the task counts as stalled. Must not exceed stall_escalation_window, or the condition could never be reached. */
+    stall_escalation_repeat_threshold?: number;
+    /** How many of the assistant's most recent tool calls stall detection looks at, oldest ones dropped as new calls happen. Counted across the whole visible conversation rather than reset at the newest human ask, so evidence from before a plain follow-up message like 'try again' is still visible on the turn after it. */
+    stall_escalation_window?: number;
     /** Keywords indicating technical content */
     technical_keywords?: RequestComplexityRouterConfigTechnicalKeywordsList | null;
     /** Score boundaries between tiers. These keys (simple_medium, medium_complex, complex_reasoning) name the gaps between the default tier names and are not renameable by tier_labels; they are scorer knobs persisted by name on every routing decision */
     tier_boundaries?: RequestComplexityRouterConfigTierBoundariesMap;
-    /** Operator-defined tier set replacing the built-in SIMPLE/MEDIUM/COMPLEX/REASONING. Each entry's name becomes a value the LLM classifier can return and its description becomes that tier's rubric bullet; entries named after a built-in tier may omit the description and inherit the built-in criteria. List order is ascending severity and decides which tier wins when several keyword_tier_rules match. Requires classifier_type 'llm' or 'custom', a fallback_tier, and `tiers` keys matching the defined names exactly. Escalation, adaptive selection, session affinity, plugins, tier_labels, and the calibration-example rubric presets are unavailable with a custom tier set: the first four are built on the built-in tier ladder, and the last two rename or exemplify tiers the set replaces. */
+    /** Operator-defined tier set replacing the built-in SIMPLE/MEDIUM/COMPLEX/REASONING. Each entry's name becomes a value the LLM classifier can return and its description becomes that tier's rubric bullet; entries named after a built-in tier may omit the description and inherit the built-in criteria. List order is ascending severity and decides which tier wins when several keyword_tier_rules match. Requires classifier_type 'llm', 'jev' or 'custom', a fallback_tier, and `tiers` keys matching the defined names exactly. Escalation, adaptive selection, session affinity, plugins, tier_labels, and the calibration-example rubric presets are unavailable with a custom tier set: the first four are built on the built-in tier ladder, and the last two rename or exemplify tiers the set replaces. */
     tier_definitions?: RequestComplexityRouterConfigTierDefinitionsList | null;
     /** Score penalty per tier-step away from the classified tier when adaptive=True */
     tier_distance_penalty?: number;
@@ -1351,8 +1609,23 @@ export interface PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequest {
     tools?: PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestToolsList | null;
 }
 export declare const PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequest: S.Schema<PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequest>;
-export type StandardLoggingRoutingDecisionCause = "heuristic_scorer" | "reasoning_override" | "llm_classifier" | "heuristic_first_short_circuit" | "classifier_plugin" | "classifier_fallback" | "default_model_fallback" | "literal_keyword_match" | "semantic_keyword_match" | "plan_mode" | "housekeeping" | "session_affinity_pin" | "session_affinity_escalation" | "default_fallback" | "keyword" | "quality_tier" | "bandit";
+export type StandardLoggingRoutingDecisionCause = "heuristic_scorer" | "heuristic_v2" | "reasoning_override" | "llm_classifier" | "capability_classifier" | "jev_classifier" | "llm_v2_classifier" | "llm_v2_fallback" | "heuristic_first_short_circuit" | "hybrid_short_circuit" | "classifier_plugin" | "classifier_fallback" | "capability_classifier_fallback" | "default_model_fallback" | "literal_keyword_match" | "semantic_keyword_match" | "plan_mode" | "housekeeping" | "modality_escalation" | "modality_pin_override" | "health_failover" | "health_default_fallback" | "session_affinity_pin" | "session_affinity_escalation" | "user_turn_continuation" | "default_fallback" | "keyword" | "quality_tier" | "bandit";
 export declare const StandardLoggingRoutingDecisionCause: any;
+export type StandardLoggingRoutingDecisionClassifierProbabilitiesMap = {
+    [key: string]: number | undefined;
+};
+export declare const StandardLoggingRoutingDecisionClassifierProbabilitiesMap: S.Schema<StandardLoggingRoutingDecisionClassifierProbabilitiesMap>;
+export type StandardLoggingHeuristicV2ForecastProbabilitiesMap = {
+    [key: string]: number | undefined;
+};
+export declare const StandardLoggingHeuristicV2ForecastProbabilitiesMap: S.Schema<StandardLoggingHeuristicV2ForecastProbabilitiesMap>;
+export interface StandardLoggingHeuristicV2Forecast {
+    predicted_tier: string;
+    probabilities: StandardLoggingHeuristicV2ForecastProbabilitiesMap;
+    request_type: string;
+    threshold: number;
+}
+export declare const StandardLoggingHeuristicV2Forecast: S.Schema<StandardLoggingHeuristicV2Forecast>;
 export type StandardLoggingRoutingDecisionRouterType = "complexity" | "adaptive" | "quality";
 export declare const StandardLoggingRoutingDecisionRouterType: any;
 export type StandardLoggingRoutingDecisionSignalsList = Array<string>;
@@ -1371,11 +1644,29 @@ export declare const StandardLoggingRoutingDecisionTierLitellmParamsMap: S.Schem
 /** Per-request provenance for a pre-routing strategy (auto-router) decision. */
 export interface StandardLoggingRoutingDecision {
     cause?: StandardLoggingRoutingDecisionCause;
+    classifier_calibrated_capable_p_solve?: number;
+    classifier_calibrated_efficient_p_solve?: number;
+    classifier_calibrated_p_solve?: number;
+    classifier_calibration_version?: string;
+    classifier_capability_boundary?: string;
+    classifier_capable_p_solve?: number;
+    classifier_confidence?: number;
     classifier_cost?: number;
+    classifier_crux?: string;
+    classifier_efficient_p_solve?: number;
+    classifier_max_quality_gap?: number;
     classifier_model?: string;
+    classifier_p_solve?: number;
+    classifier_primary_rule?: string;
+    classifier_probabilities?: StandardLoggingRoutingDecisionClassifierProbabilitiesMap;
+    classifier_prompt_version?: string;
+    classifier_threshold?: number;
+    context_escalated?: boolean;
+    context_escalation_original_tier?: string;
     conversation_continuing?: boolean;
     escalated?: boolean;
     escalation_keyword?: string;
+    heuristic_v2_forecast?: StandardLoggingHeuristicV2Forecast;
     matched_keyword?: string;
     reasoning_override_min_score?: number;
     request_type?: string;
@@ -1551,7 +1842,7 @@ export type GetModelCostMapReloadStatusScheduleModelCostMapReloadStatusGetError
 /** Get Model Cost Map Reload Status ADMIN ONLY / MASTER KEY Only Endpoint Get the status of the scheduled model cost map reload job. */
 export declare const getModelCostMapReloadStatusScheduleModelCostMapReloadStatusGet: API.OperationMethod<GetModelCostMapReloadStatusScheduleModelCostMapReloadStatusGetRequest, GetModelCostMapReloadStatusScheduleModelCostMapReloadStatusGetResponse, GetModelCostMapReloadStatusScheduleModelCostMapReloadStatusGetError, LitellmOpContext>;
 export type GetModelCostMapSourceModelCostMapSourceGetError = LitellmOpError;
-/** Get Model Cost Map Source ADMIN ONLY / MASTER KEY Only Endpoint Returns information about where the current model cost/pricing data was loaded from. Response fields: - source: "local" (bundled backup) or "remote" (fetched from URL) - url: the remote URL that was attempted (null when env-forced local) - is_env_forced: true if LITELLM_LOCAL_MODEL_COST_MAP=True forced local usage - fallback_reason: human-readable reason why remote failed (null on success) - model_count: number of models in the currently loaded cost map */
+/** Get Model Cost Map Source ADMIN ONLY / MASTER KEY Only Endpoint Returns information about where the current model cost/pricing data was loaded from. Response fields: - source: "local" (bundled backup) or "remote" (fetched from URL) - url: the remote URL that was attempted (null when env-forced local) - is_env_forced: true if LITELLM_LOCAL_MODEL_COST_MAP=True forced local usage - fallback_reason: human-readable reason why remote failed (null on success) - loaded_at: when this pod last loaded the map - source_revision: git blob id of the loaded file, what git rev-parse <commit>:<path> prints for it - etag: the ETag of the remote fetch (null for the bundled backup) - model_count: number of models in the currently loaded cost map */
 export declare const getModelCostMapSourceModelCostMapSourceGet: API.OperationMethod<GetModelCostMapSourceModelCostMapSourceGetRequest, GetModelCostMapSourceModelCostMapSourceGetResponse, GetModelCostMapSourceModelCostMapSourceGetError, LitellmOpContext>;
 export type GetModelDeprecationsModelDeprecationError = UnprocessableEntity | LitellmOpError;
 /** Model Deprecations List models with known deprecation/sunset dates, bucketed by urgency. Reads `deprecation_date` metadata from `model_prices_and_context_window.json` (and any per-deployment `model_info.deprecation_date` overrides) for the models configured on this proxy. Parameters: warn_within_days: Window (in days) used to bucket "imminent" models, 30 by default. Returns: A payload with three lists of `ModelDeprecationInfo` entries: - `deprecated`: deprecation date is in the past, so these requests may fail at any time. - `imminent`: deprecation date is within `warn_within_days` from today. - `upcoming`: deprecation date is further out. Example: ```shell curl -X GET 'http://localhost:4000/model/deprecations' \ -H 'Authorization: Bearer sk-1234' ``` */
@@ -1566,16 +1857,16 @@ export type GetModelInfoModelsModelIdError = UnprocessableEntity | LitellmOpErro
 /** Model Info Retrieve information about a specific model accessible to your API key. Returns model details only if the model is available to your API key/team. Returns 404 if the model doesn't exist or is not accessible. Follows OpenAI API specification for individual model retrieval. https://platform.openai.com/docs/api-reference/models/retrieve Query parameters mirror `/v1/models` so the same caller context (team scoping, health filtering, paused deployments) drives both endpoints; the listing's public id must resolve to the same internal deployment here. */
 export declare const getModelInfoModelsModelId: API.OperationMethod<GetModelInfoModelsModelIdRequest, GetModelInfoModelsModelIdResponse, GetModelInfoModelsModelIdError, LitellmOpContext>;
 export type GetModelInfoV1ModelInfoError = UnprocessableEntity | LitellmOpError;
-/** Model Info V1 Provides more info about each model in /models, including config.yaml descriptions (except api key and api base) Parameters: litellm_model_id: Optional[str] = None (this is the value of `x-litellm-model-id` returned in response headers) - When litellm_model_id is passed, it will return the info for that specific model - When litellm_model_id is not passed, it will return the info for all models - include_team_models: When true, filter to deployments the caller can use (same as /v2/model/info). - teamId: Filter to models accessible by the given team. - healthy_only: When true, hide models whose backing deployments are all marked unhealthy by background health checks, matching `/v1/models?healthy_only=true`. Set `general_settings.model_list_healthy_only: true` to apply this to every caller without the query parameter. Requires `background_health_checks: true`, plus either `model_list_healthy_only` or `enable_health_check_routing` to keep deployment health state cached; without health state the listing is returned unfiltered (fail open). Ignored when `litellm_model_id` is passed, since that is a direct lookup of one deployment rather than a listing. Hiding is presentation-only: a hidden model can still be called directly. Each model in the list response includes `model_info.access_via_team_ids` and `model_info.direct_access` when the proxy database is connected. Returns: Returns a dictionary containing information about each model. Example Response: ```json { "data": [ { "model_name": "fake-openai-endpoint", "litellm_params": { "api_base": "https://exampleopenaiendpoint-production.up.railway.app/", "model": "openai/fake" }, "model_info": { "id": "112f74fab24a7a5245d2ced3536dd8f5f9192c57ee6e332af0f0512e08bed5af", "db_model": false } } ] } ``` */
+/** Model Info V1 Provides more info about each model in /models, including config.yaml descriptions (except api key and api base) Parameters: litellm_model_id: Optional[str] = None (this is the value of `x-litellm-model-id` returned in response headers) - When litellm_model_id is passed, it will return the info for that specific model - When litellm_model_id is not passed, it will return the info for all models - include_team_models: When true, filter to deployments the caller can use (same as /v2/model/info). - teamId: Filter to models accessible by the given team. - healthy_only: When true, hide models whose backing deployments are all marked unhealthy by background health checks, matching `/v1/models?healthy_only=true`. Set `general_settings.model_list_healthy_only: true` to apply this to every caller without the query parameter. Requires `background_health_checks: true`, plus either `model_list_healthy_only` or `enable_health_check_routing` to keep deployment health state cached; without health state the listing is returned unfiltered (fail open). Ignored when `litellm_model_id` is passed, since that is a direct lookup of one deployment rather than a listing. Hiding is presentation-only: a hidden model can still be called directly. Each model in the list response includes `model_info.access_via_team_ids` and `model_info.direct_access` when the proxy database is connected. Returns: A JSON response whose `data` list holds one entry per model. Example Response: ```json { "data": [ { "model_name": "fake-openai-endpoint", "litellm_params": { "api_base": "https://exampleopenaiendpoint-production.up.railway.app/", "model": "openai/fake" }, "model_info": { "id": "112f74fab24a7a5245d2ced3536dd8f5f9192c57ee6e332af0f0512e08bed5af", "db_model": false } } ] } ``` */
 export declare const getModelInfoV1ModelInfo: API.OperationMethod<GetModelInfoV1ModelInfoRequest, GetModelInfoV1ModelInfoResponse, GetModelInfoV1ModelInfoError, LitellmOpContext>;
 export type GetModelInfoV1ModelsModelIdError = UnprocessableEntity | LitellmOpError;
 /** Model Info Retrieve information about a specific model accessible to your API key. Returns model details only if the model is available to your API key/team. Returns 404 if the model doesn't exist or is not accessible. Follows OpenAI API specification for individual model retrieval. https://platform.openai.com/docs/api-reference/models/retrieve Query parameters mirror `/v1/models` so the same caller context (team scoping, health filtering, paused deployments) drives both endpoints; the listing's public id must resolve to the same internal deployment here. */
 export declare const getModelInfoV1ModelsModelId: API.OperationMethod<GetModelInfoV1ModelsModelIdRequest, GetModelInfoV1ModelsModelIdResponse, GetModelInfoV1ModelsModelIdError, LitellmOpContext>;
 export type GetModelInfoV1V1ModelInfoError = UnprocessableEntity | LitellmOpError;
-/** Model Info V1 Provides more info about each model in /models, including config.yaml descriptions (except api key and api base) Parameters: litellm_model_id: Optional[str] = None (this is the value of `x-litellm-model-id` returned in response headers) - When litellm_model_id is passed, it will return the info for that specific model - When litellm_model_id is not passed, it will return the info for all models - include_team_models: When true, filter to deployments the caller can use (same as /v2/model/info). - teamId: Filter to models accessible by the given team. - healthy_only: When true, hide models whose backing deployments are all marked unhealthy by background health checks, matching `/v1/models?healthy_only=true`. Set `general_settings.model_list_healthy_only: true` to apply this to every caller without the query parameter. Requires `background_health_checks: true`, plus either `model_list_healthy_only` or `enable_health_check_routing` to keep deployment health state cached; without health state the listing is returned unfiltered (fail open). Ignored when `litellm_model_id` is passed, since that is a direct lookup of one deployment rather than a listing. Hiding is presentation-only: a hidden model can still be called directly. Each model in the list response includes `model_info.access_via_team_ids` and `model_info.direct_access` when the proxy database is connected. Returns: Returns a dictionary containing information about each model. Example Response: ```json { "data": [ { "model_name": "fake-openai-endpoint", "litellm_params": { "api_base": "https://exampleopenaiendpoint-production.up.railway.app/", "model": "openai/fake" }, "model_info": { "id": "112f74fab24a7a5245d2ced3536dd8f5f9192c57ee6e332af0f0512e08bed5af", "db_model": false } } ] } ``` */
+/** Model Info V1 Provides more info about each model in /models, including config.yaml descriptions (except api key and api base) Parameters: litellm_model_id: Optional[str] = None (this is the value of `x-litellm-model-id` returned in response headers) - When litellm_model_id is passed, it will return the info for that specific model - When litellm_model_id is not passed, it will return the info for all models - include_team_models: When true, filter to deployments the caller can use (same as /v2/model/info). - teamId: Filter to models accessible by the given team. - healthy_only: When true, hide models whose backing deployments are all marked unhealthy by background health checks, matching `/v1/models?healthy_only=true`. Set `general_settings.model_list_healthy_only: true` to apply this to every caller without the query parameter. Requires `background_health_checks: true`, plus either `model_list_healthy_only` or `enable_health_check_routing` to keep deployment health state cached; without health state the listing is returned unfiltered (fail open). Ignored when `litellm_model_id` is passed, since that is a direct lookup of one deployment rather than a listing. Hiding is presentation-only: a hidden model can still be called directly. Each model in the list response includes `model_info.access_via_team_ids` and `model_info.direct_access` when the proxy database is connected. Returns: A JSON response whose `data` list holds one entry per model. Example Response: ```json { "data": [ { "model_name": "fake-openai-endpoint", "litellm_params": { "api_base": "https://exampleopenaiendpoint-production.up.railway.app/", "model": "openai/fake" }, "model_info": { "id": "112f74fab24a7a5245d2ced3536dd8f5f9192c57ee6e332af0f0512e08bed5af", "db_model": false } } ] } ``` */
 export declare const getModelInfoV1V1ModelInfo: API.OperationMethod<GetModelInfoV1V1ModelInfoRequest, GetModelInfoV1V1ModelInfoResponse, GetModelInfoV1V1ModelInfoError, LitellmOpContext>;
 export type GetModelInfoV2V2ModelInfoError = UnprocessableEntity | LitellmOpError;
-/** Model Info V2 Paginated model metadata for proxy deployments (pricing, provider, team access). Returns configured router deployments with enriched `model_info` (costs, provider, context window, etc.). Sensitive fields such as API keys and api_base are omitted. Query parameters: model: Filter to a single public `model_name`. user_models_only: When true, only return models created by the calling user. include_team_models: When true, populate `access_via_team_ids` and `direct_access` on each model and filter to deployments the caller can use. page / size: Pagination controls (defaults: page=1, size=50). search: Case-insensitive partial match on model name or team public name. modelId: Return a single deployment by LiteLLM model id. teamId: Filter to models with direct access or team membership for this team id. sortBy / sortOrder: Sort by model_name, created_at, updated_at, costs, or status. Example request: ``` curl -X GET 'http://localhost:4000/v2/model/info?include_team_models=true&page=1&size=50' \ --header 'Authorization: Bearer sk-1234' ``` Example response: ```json { "data": [ { "model_name": "gpt-4", "litellm_params": {"model": "openai/gpt-4.1"}, "model_info": { "id": "abc123", "litellm_provider": "openai", "access_via_team_ids": ["team-1"], "direct_access": true } } ], "total_count": 1, "current_page": 1, "total_pages": 1, "size": 50 } ``` */
+/** Model Info V2 Paginated model metadata for proxy deployments (pricing, provider, team access). Returns configured router deployments with enriched `model_info` (costs, provider, context window, etc.). Sensitive fields such as API keys and api_base are omitted. Query parameters: model: Filter to a single public `model_name`. user_models_only: When true, only return models created by the calling user. include_team_models: When true, populate `access_via_team_ids` and `direct_access` on each model and filter to deployments the caller can use. page / size: Pagination controls (defaults: page=1, size=50). search: Case-insensitive partial match on model name or team public name. modelId: Return a single deployment by LiteLLM model id. teamId: Filter to models with direct access or team membership for this team id. sortBy / sortOrder: Sort by model_name, created_at, updated_at, costs, or status. access_group: Only return deployments in this model access group. wildcard_only: Only return deployments whose `model_name` contains `*`. Example request: ``` curl -X GET 'http://localhost:4000/v2/model/info?include_team_models=true&page=1&size=50' \ --header 'Authorization: Bearer sk-1234' ``` Example response: ```json { "data": [ { "model_name": "gpt-4", "litellm_params": {"model": "openai/gpt-4.1"}, "model_info": { "id": "abc123", "litellm_provider": "openai", "access_via_team_ids": ["team-1"], "direct_access": true } } ], "total_count": 1, "current_page": 1, "total_pages": 1, "size": 50 } ``` */
 export declare const getModelInfoV2V2ModelInfo: API.OperationMethod<GetModelInfoV2V2ModelInfoRequest, GetModelInfoV2V2ModelInfoResponse, GetModelInfoV2V2ModelInfoError, LitellmOpContext>;
 export type GetModelMetricsExceptionsModelMetricsExceptionError = UnprocessableEntity | LitellmOpError;
 /** Model Metrics Exceptions View number of failed requests per model on config.yaml */
@@ -1644,6 +1935,6 @@ export type UpdateUsefulLinksModelHubUpdateUsefulLinksPostError = UnprocessableE
 /** Update Useful Links Update useful links */
 export declare const updateUsefulLinksModelHubUpdateUsefulLinksPost: API.OperationMethod<UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequest, UpdateUsefulLinksModelHubUpdateUsefulLinksPostResponse, UpdateUsefulLinksModelHubUpdateUsefulLinksPostError, LitellmOpContext>;
 export type ValidateComplexityRouterConfigAutoRouterValidateComplexityRouterConfigPostError = UnprocessableEntity | LitellmOpError;
-/** Validate Complexity Router Config Validate a complexity-router config without saving it. Runs the same check every write path runs (the router's own pydantic model), so a form can show the backend's exact verdict while the operator is still editing rather than after a rejected save. Gated exactly like the save it rehearses: a proxy admin, or a team admin naming their own team. Nothing is created, routed, or billed. */
+/** Validate Complexity Router Config Validate a complexity-router config without saving it. Runs the same check every write path runs (the router's own pydantic model), so a form can show the backend's exact verdict while the operator is still editing rather than after a rejected save. Uses the same team opt-in and model-access checks as configuration writes for members. Nothing is created, routed, or billed. */
 export declare const validateComplexityRouterConfigAutoRouterValidateComplexityRouterConfigPost: API.OperationMethod<ValidateComplexityRouterConfigAutoRouterValidateComplexityRouterConfigPostRequest, ComplexityRouterConfigValidationResponse, ValidateComplexityRouterConfigAutoRouterValidateComplexityRouterConfigPostError, LitellmOpContext>;
 //# sourceMappingURL=model_management.d.ts.map