uPj UdZddlmZddlmZddlmZddlmZm Z m Z ddl m Z m Z mZmZmZmZmZddlmZmZmZGdd eeZGd d eeZej4Ze eed <ed dhZe eeed<ej>ej@ejBejDfZ#e e$edfed<dZ%e e&ed<dZ'e e(ed<dZ)e e(ed<Gdde Z*dZ+e e(ed<dZ,e e(ed<dZ-e e(ed<d Z.e e(ed!<d"ed#zd$ed#zfd%Z/Gd&d'e Z0Gd(d)e Z1Gd*d+e Z2d,e3d-ed$e$ee4eze$e2dfffd.Z5gd/Z6e e4eed0<gd1Z7e e4eed2<gd3Z8e e4eed4<d5gZ9e e4eed6<d7Z:e e$edfed8<d9Z;e e$edfed:<d;Z<gd?Z>e e4eed@<dAdBdCdCdDdEdFdGZ?e e@ee&fedH<dIdJdKdLZAe e@ee&fedM<dNdOdPZBe e@ee(fedQ<dRdSdTdTdUZCe e@eefedV<GdWdXe ZDGdYdZe ZEeeEjZGe eeed[< eEZHe ed\<y#)]z Configuration for the Complexity Router. Contains default keyword lists, weights, tier boundaries, and configuration classes. All values are configurable via proxy config.yaml. )Mapping)EnumMappingProxyType) AnnotatedFinalLiteral) BaseModel ConfigDictFieldSkipValidationfield_serializerfield_validatormodel_validator)AdaptiveRouterWeightsClassifierPlugin RoutingPluginc eZdZdZdZdZdZdZy)ComplexityTierz'Complexity tiers for routing decisions.SIMPLEMEDIUMCOMPLEX REASONINGN)__name__ __module__ __qualname____doc__rrrru/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/litellm/router_strategy/complexity_router/config.pyrrs1 F FGIrrc eZdZdZdZdZdZdZy)ClassificationRubricziWhich calibration examples, and for BUSINESS which tier criteria, the built-in classifier rubric carries.legacyagenticchatbusinessN)rrrrLEGACYAGENTICCHATBUSINESSrrr r"r"ss FG DHrr"DEFAULT_CLASSIFICATION_RUBRICllmheuristic_firstLLM_CLASSIFIER_TYPES.TIER_SEVERITY_ORDER?DEFAULT_TIER_DISTANCE_PENALTY&DEFAULT_CLASSIFIER_CONTEXT_WINDOW_SIZEi@'DEFAULT_CLASSIFIER_CONTEXT_BUDGET_CHARSceZdZUdZeddZeeed<edZ eed<e dd e d e d e fd Z ed ddZy)KeywordTierRulezEA deterministic override: if any keyword matches, route to this tier.zCKeywords/phrases that trigger this rule (lexical or semantic match)) min_length descriptionkeywordszzTier to route to when this rule matches: a built-in tier name, or with tier_definitions set, one of the defined tier namesr9tierbeforemodevaluereturnc~t|tr |jSt|tr|j S|SN isinstancerr@strstripclsr@s r _coerce_tierzKeywordTierRule._coerce_tierJ3 e^ ,;;  eS !;;=  rafterc|jDcgc]}|jx}s|}}|s td||_|Scc}w)NzFkeyword_tier_rules entries must contain at least one non-empty keyword)r:rG ValueError)selfkeywordstrippedcleaneds r _normalize_keywordsz#KeywordTierRule._normalize_keywordsSsP 37--awPWP]P]P_D_HD_(aaef f  bs AAN)rAr6)rrrrr r:listrF__annotations__r<r classmethodobjectrJrrSrrr r6r6<sOYHd3i BD#V(+F,'" # rr6MAX_TIER_DEFINITIONS@MAX_TIER_NAME_CHARSiMAX_TIER_DESCRIPTION_CHARSiMAX_CLASSIFICATION_PROMPT_CHARSr@NrAc|y|j}|s tdt|tkDrtdtd|S)aAStrip, reject blank, and cap an operator-written classifier preamble. The single owner of the rule, so the dashboard's prompt preview normalizes exactly what the write gate stores: previewing the raw value would render leading whitespace the router strips, or an over-long prompt the write then rejects. N)must be non-empty; omit the field insteadzclassification_prompt exceeds characters)rGrNlenr])r@rQs r normalize_classification_promptrbfsP }kkmH DEE 8}669:Y9ZZefgg OrcreZdZUdZedZeed<eddZedzed<e d d d Z y) TierDefinitionz]An operator-defined tier: the name the LLM classifier must return and its rubric description.zMTier name; becomes a value the LLM classifier can return and a key of `tiers`r;nameNzWhat 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 omitteddefaultr9r9rLr>c.|jj}|j|jjxsdnd}|s tdt |t kDrtd|dt dt d|(t |t kDrtd|dt d|/|jtjvrtd|d||xsd f}td |Drtd|d ||_||_|S) Nz3tier_definitions entries must have a non-empty nameztier_definitions name z ... exceeds r`z!tier_definitions description for z exceeds ztier_definitions entry zw must have a description: only the built-in tiers (SIMPLE, MEDIUM, COMPLEX, REASONING) carry one the rubric can inheritc30K|]}d|vxsd|vyw)  Nr).0parts r z,TierDefinition._normalize..s Mtt|+tt|+Msz@ must not contain newlines; the rubric renders one line per tier) rerGr9rNrar[r\upperr __members__any)rOrer9rendered_on_one_lines r _normalizezTierDefinition._normalizesDiioo'CGCSCSC_d..446>$ei RS S t9* *(.B/B)C(FlSfRggrs   "s;'7:T'T3D89E_D``kl   4::<~7Q7Q#Q)$2XX (,[->B&? M8LM M)$1qr  & r)rArd) rrrrr rerFrUr9rrtrrr rdrdwsQgcD#$ :Kt'"#rrdcjeZdZUdZedZeed<edZeed<e dd d Z y ) ReminderMarkerPairaYOne open/close delimiter pair a harness wraps injected context in. Normalizing here rather than at the scan is what makes matching case-insensitive: markers reach the scan already lowered, so it lowercases only the haystack and never the needles. Stripping keeps YAML indentation whitespace from becoming part of the delimiter. z+Opening delimiter, e.g. ''r;openz,Closing delimiter, e.g. ''closerLr>c|jjj}|jjj}|r|s t d||k(r t d||_||_|S)Nz*reminder_markers entries must not be blankz9reminder_markers open and close must be different strings)rwrGlowerrxrN)rO open_marker close_markers r rtzReminderMarkerPair._normalizesn!YY__.446 "jj..0668 ,IJ J , &XY Y !  rN)rArv) rrrrr rwrFrUrxrrtrrr rvrvs@"OPD#P#QRE3R'" # rrvceZdZUedZeed<edZe e ee fe fed<e dded e ee fd e ee ffd Zedd e ee fd e ee ffd Zy )ComplexityTierModelT)frozen model_namectiSrCrrrr zComplexityTierModel.s 0 4rdefault_factorylitellm_paramsr=r>r@rAc*tt|SrC)rdictrHs r _freeze_litellm_paramsz*ComplexityTierModel._freeze_litellm_paramss U ,,rct|SrC)r)rOr@s r _serialize_litellm_paramsz-ComplexityTierModel._serialize_litellm_paramss E{rN)rrrr model_configrFrUr rrrrWr rrVrrrrrr r~r~sT*LOHM4INIgc6k2N4DDE%H5-73;+?-GCQWKDX-6-&'wsF{/CPSU[P[H\(rr~ raw_valuer<cFt|ttfr|n|f}td|D}td|D}t|tt |k7rt d|dt|ttfs|dj n t|}||fS)Nc3~K|]5}t|tr t|ntj|7yw)rN)rErFr~model_validatermentrys r roz*_normalize_tier_entries..s9 2.sEEu//Eztier zP contains duplicate model_name values; each pool entry needs distinct parametersr)rErTtuplera frozensetrNr)rr< raw_entriesentries model_names normalizeds r _normalize_tier_entriesrs'1T5M&JQZP\K GEWEEK ;3y5665&vwxx)dE]3   +  w r)-functionclassdefconstletvarimportexportrAasyncawaittrycatch exceptionerrordebugapiendpointrequestresponsedatabasesqlqueryschema algorithm implementrefactoroptimizepython javascript typescriptjavarustgolangreactvueangularnodedocker kubernetesgitcommitmergebranchz pull requestDEFAULT_CODE_KEYWORDS)z step by stepz think throughz let's thinkzreason throughz analyze thisz break downzexplain your reasoningzshow your workzchain of thoughtzthink carefullyz consider allevaluatez pros and conszcompare and contrastzweigh the optionslogicaldeduceinferconcludeDEFAULT_REASONING_KEYWORDS) architecture distributedscalable microservicezmachine learningzneural networkz deep learning encryptionauthentication authorization performancelatency throughput benchmark concurrencyparallel threadingmemorycpugpu optimizationprotocoltcphttpgrpc websocket container orchestrationDEFAULT_TECHNICAL_KEYWORDSzLITELLM ESCALATEDEFAULT_ESCALATION_KEYWORDS)zPlan mode is activezPlan mode still activePLAN_MODE_TAIL_SENTINELS)z)You are currently running in "Plan" mode.PLAN_MODE_SYSTEM_SENTINELS)z:Write the title in the predominant language of the sessionzcL|j|j td|S)Nzclassifier_llm_config.classification_rubric and system_prompt are mutually exclusive: system_prompt replaces the built-in rubric the preset would select. Drop one.)rrrNrOs r !_reject_rubric_with_system_promptz5ClassifierLLMConfig._reject_rubric_with_system_prompts5    )d.H.H.TI  r)rAr )rrrrr rrFrUrintrr"rrrVrrrrrr r r s@ZE3QJ:? :/$6"!& S!M3: _%d sTz&'" # rr c eZdZUdZeddZeeeeezfe d<eeZ e ee e dffe d<ed d Ze edfd ze d <ed d Zed ze d<ed d Zed ze d<eedZeeefe d<eddZeeefe d<ed d Zed ze d<eddZeeefe d<eddZeeefe d<ed d Zeed ze d<ed d Zeed ze d!<ed d" Zeed ze d#<ed d$ Zeed ze d%<ed d& Zeed ze d'<ed d( Zed ze d)<ed*d+ Z e!e d,<ed-d. Z"e#d/e d0<ed d1 Z$e%d ze d2<ed d3 Z&ed ze d4<ed d5 Z'e(d ze d6<ed7d8d9:Z)ee d;<ed-d< Z*e#d=e d><ee+d8d?@Z,ee dA<ee-d8dB@Z.ee dC<ed d8dD:Z/ed ze dE<ed*dF Z0e!e dG<ed*dH Z1e!e dI<edJdKZ2e3e dL<ee4dMdN@Z5ee dO<edPdQ Z6e#dRe dS<ed dT Z7eed ze dU<ed dV Z8ee9d ze dW<ed dX Z:ed ze dY<ed dZ Z;e edfd ze d[<ed\d] Ze!e db<ed dc Z?ed ze dd<ededMdfdghZ@ee di<ed*dj ZAe!e dk<ed\dl ZBe!e dm<ednd8do:ZCee dp<ed dq ZDeeEd ze dr<ed dsdtuZFe eGdfd ze dv<eHdwd\xZIeJddyzeKd{eLd|eLfd}ZMeNdyzeKd{eLd|eLfd~ZOeJdUeKd{eed zd|eed zfdZPeJdYdyzeKd{eLd|eLfdZQeJd[eKd{e edfd zd|e edfd zfdZReJd`eKd{e edfd zd|e edfd zfdZSeNdzddZTeNdzddZUeJd4dyzeKd{eLd|eLfdZVeNdzddZWeJdeKd{ed zd|ed zfdZXeJdeKd{ed zd|ed zfdZYeZd|e!fdZ[eZd|e!fdZ\d|e edffdZ]d|e edffdZ^ded|eezd zfdZ_d|e edffdZ`eNdzddZaeNdzddZbeNdzddZceNdzddZdeNdzddZeeNdzddZfeNdzddZgded|efdZhd|e e eefdffdZided|ed zfdZjy )ComplexityRouterConfigz'Configuration for the ComplexityRouter.c*tjSrC)r copyrrr rzComplexityRouterConfig.s 3 8 8 :rzMapping of complexity tiers to a model or model pool. A list is randomly picked from when adaptive=False, and used as a soft-floor home pool when adaptive=True)rr9tiersr.tier_model_configsNa 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.rftier_definitionsa 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_tieraReplaces 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.classification_promptaDisplay names for the complexity tiers, so a deployment can use its own vocabulary (e.g. Cheap/Standard/Premium/Deep) in the dashboard, spend logs, and the LLM classifier rubric. Purely operator-facing: config keys stay canonical (tiers, keyword_tier_rules[].tier, tier_boundaries), API callers never see these names, and the heuristic scorer never reads them. Unlisted tiers keep their canonical name. Partial maps are allowed. tier_labelsc*tjSrC)rrrrr rzComplexityRouterConfig.-s 7 < < >rzScore 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 decisiontier_boundariesaMinimum 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 overridereasoning_override_min_scorec*tjSrC)r rrrr rzComplexityRouterConfig.@s 8 = = ?rz8Token count thresholds for simple/complex classificationtoken_thresholdsc*tjSrC)rrrrr rzComplexityRouterConfig.Fs 9 > > @rz"Weights for each scoring dimensiondimension_weightsz(Keywords indicating code-related content code_keywordsz.Keywords indicating reasoning-required contentreasoning_keywordsz%Keywords indicating technical contenttechnical_keywordszDomain-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_keywordsz(Keywords indicating simple/basic queriessimple_keywordsz1Default model to use if tier cannot be determined default_modelFzvReturn the resolved raw model name in the response model field instead of the client-requested complexity-router aliasreturn_raw_model_name heuristiczClassification 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)r2r,customr-classifier_typezaConfiguration for the LLM classifier; required when classifier_type is 'llm' or 'heuristic_first'classifier_llm_configaThe 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_tierawCustom classifier deciding the tier; required when classifier_type is 'custom'. In the proxy config, a dotted path to a ClassifierPlugin instance (resolved at startup, like plugins). Its classify(context) receives the request messages and metadata (caller identity included) and returns the name of the tier to route to, or None to decline and let classifier_fallback decide.classifier_pluginrrzTimeout budget for the classifier plugin call, in milliseconds. On expiry the fallback path decides the tier. Only applies when classifier_type is 'custom'.)rggtr9classifier_plugin_timeout_msaZWhat 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'.)r2r0classifier_fallbackaNumber 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'.)rgger9classifier_context_window_sizeaMaximum 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'.classifier_context_budget_charsaOptional 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_charsa^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_turnszs 5c LrzHQuality vs cost weights for adaptive selection (used when adaptive=True)adaptive_weightsgzLScore penalty per tier-step away from the classified tier when adaptive=Truetier_distance_penaltyallzWhen 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)rFclassified_tieradaptive_eligibleaCase-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_keywordszERules that force a specific tier when their keywords match the promptkeyword_tier_rulesa#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_tierzAdditional 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.plan_mode_patternsTaRoute a coding agent's own housekeeping calls to the cheapest configured tier without classifying them. A client names the conversation by quoting the whole session and asking for a title, so the ask reads as the session's engineering work and lands on the most expensive tier, which is the reverse of what the call is worth. Detection is a literal match against client-owned sentinels on the newest ask only, so it cannot fire on an earlier turn, and it never lowers what anyone else asked for: a keyword_tier_rule or a session pin still decides instead, and an escalation keyword or the plan-mode floor still raises the tier from here. Only the classifier is displaced, and its call is skipped, so a matched request costs nothing to route. Set false to classify these calls like any other.#route_housekeeping_to_cheapest_tierzAdditional 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_patternszHMatch keyword_tier_rules by embedding similarity instead of literal textsemantic_keyword_matchingzSEmbedding model (LiteLLM model name) used when semantic_keyword_matching is enabledembedding_modelr0g?z6Minimum cosine similarity for a semantic keyword match)rgr;ler9match_thresholdatWhen 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_affinityaWWhen 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.deployment_affinityizTTL 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 lengthsession_affinity_ttl_secondsz[RoutingPlugin instances that narrow the classified tier's candidate models before selectionpluginsr7aOverride 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 ('', ''), so a harness that also emits that pair lists it too. Matching is case-insensitive.)rgr8r9reminder_markersallow)extraarbitrary_types_allowedr=r>r@rAct|ts|Si}|jD]E\}}t|tr|||<t|tt frt |||<A|||<G|SrC)rEritemsrFrTr)rIr@coercedkeyitems r _coerce_tier_valuesz*ComplexityRouterConfig._coerce_tier_valuesso%&L,. $IC$$# D4-0#Dz #  $rc ` t|ts|S|jd}t|ts|S|jd}t|j Dcic]\}}|t ||c}}}t|j Dcic] \}\}}|| c}}}} t|trSt|j D cic],\}} d| DD]} || j f| j.c} } }n ti t|j D cic]D\\}} td| Dst|tr|vrt fd| DFc} }}} i|| | dScc}}wcc}}}wcc} } }wcc} }}w)Nrrc3FK|]}tj|ywrC)r~r)rmr_s r rozGComplexityRouterConfig._normalize_tier_model_configs..s!_t"5"D"DT"J!_s!c34K|]}|jywrC)rrs r rozGComplexityRouterConfig._normalize_tier_model_configs..sAu++Arc 3K|]G}|jtdj|jf|jiIyw)r)updateN) model_copyrgetrr)rmrincoming_paramsr<s r rozGComplexityRouterConfig._normalize_tier_model_configs..s\ $$/ 0/2E2EtUM]M]F^`e`t`t2u % sA A)rr) rErrgrr\rrrrrr)rIr@ raw_tiersexisting_configsr<rnormalized_entriesr_normalized_tiersrrrrhs ` @r _normalize_tier_model_configsz4ComplexityRouterConfig._normalize_tier_model_configss%&L 99W- )T*L"')),@"A$4S\SbSbSd eiT*9d; ; e% #3;M;S;S;U V V"7$QT:  V# *D1 *:)?)?)A%g!_W^!_5++,e.B.BB, ""% %5+=*B*B*D  'D,1gAAA/64CS;Se ")    % "  %"4  C f W s!F F 1F" :A F) cX|y|Dcgc]}|jx}s|c}Scc}wrCrG)rIr@rPrQs r _normalize_escalation_keywordsz5ComplexityRouterConfig._normalize_escalation_keywordss0 =(-OWgmmo2M(2MOOOs''c~t|tr |jSt|tr|j S|SrCrDrHs r _coerce_plan_mode_min_tierz1ComplexityRouterConfig._coerce_plan_mode_min_tierrKrc2|ytfd|DS)zBlank patterns are dropped rather than kept: an empty string substring-matches every request, which would silently floor all traffic (same failure mode keyword_tier_rules rejects).Nc3HK|]}|jxsywrCrprmpatternrQs r rozGComplexityRouterConfig._normalize_plan_mode_patterns..!T'7==?7Rx7RXT""rrIr@rQs @r _normalize_plan_mode_patternsz4ComplexityRouterConfig._normalize_plan_mode_patternss =TUTTTrc2|ytfd|DS)zBlank patterns are dropped: an empty string substring-matches every request, which would silently route all traffic to the cheapest tier.Nc3HK|]}|jxsywrCrprvs r rozJComplexityRouterConfig._normalize_housekeeping_patterns..rxryrzr{s @r _normalize_housekeeping_patternsz7ComplexityRouterConfig._normalize_housekeeping_patternss =TUTTTrrLc ,|j|S|j|jvr8td|jddj|j|j|jvrtd|jd|S)Nzplan_mode_min_tier , is not an active tier: it must name one of , z has no model configured in tiers; a floor pointing at an unconfigured tier would route every plan-mode request to the default fallback instead of the premium pool the operator intended)rK tier_namesrNjoinrrs r _validate_plan_mode_min_tierz3ComplexityRouterConfig._validate_plan_mode_min_tiers  " " *K  " "$//*; ;%d&=&=%@A))DOO$5679   " "$** 4%d&=&=%>?UU   rc|jr$|jtd|j|jdk(r|j td|j(|jdk7rtd|jd|S)Nz:classifier_llm_config is required when classifier_type is r3z>classifier_plugin is required when classifier_type is 'custom'z0classifier_plugin is set but classifier_type is zV; the plugin would never run. Set classifier_type 'custom' or remove classifier_plugin)uses_llm_classifierr5rNr4r7rs r _validate_classifier_configz2ComplexityRouterConfig._validate_classifier_configs  # #(B(B(JYZ^ZnZnYqrs s   8 +0F0F0N]^ ^  ! ! -$2F2F(2RB4CWCWBZ[gg  rc~t|tr |jSt|tr|j S|SrCrDrHs r _coerce_heuristic_first_max_tierz7ComplexityRouterConfig._coerce_heuristic_first_max_tier rKrct|jdk7r'|jtd|jd|S|j}| td|j}||vr td|ddj |||dk(rtd|d ||j vrtd|d |S) Nr-z7heuristic_first_max_tier is set but classifier_type is z|; the local scorer would never gate the classifier. Set classifier_type 'heuristic_first' or remove heuristic_first_max_tierzheuristic_first_max_tier is required when classifier_type is 'heuristic_first': without a threshold there is nothing to decide whether a request escalates to the LLM classifierzheuristic_first_max_tier rrz is the highest tier, so every request would short-circuit and the LLM classifier would never run; name a lower tier or use classifier_type 'heuristic'z has no model configured in tiers; a threshold pointing at an unconfigured tier would route short-circuited requests to the default fallback instead of the pool the operator intended)r4r6rNrrr)rO thresholdnamess r "_validate_heuristic_first_max_tierz9ComplexityRouterConfig._validate_heuristic_first_max_tiers   #4 4,,8 MdNbNbMefKK K88  i ( E !+I=8deienenoteudvw  b !+I;7oo  DJJ &+I;7--   rcF|y|j}|s td|S)Nr_rr{s r _reject_blank_optional_textz2ComplexityRouterConfig._reject_blank_optional_text4s+ =++-HI Irct|SrC)rbrHs r &_normalize_classification_prompt_fieldz=ComplexityRouterConfig._normalize_classification_prompt_field>s/u55rc|jduS)zKTrue when the operator replaced the built-in tier set via tier_definitions.N)r rs r has_custom_tiersz'ComplexityRouterConfig.has_custom_tiersCs$$D00rc&|jtvS)a_True when this router can call classifier_llm_config.model, so the model is a real dependency: authorized against the caller's key, counted in the health graph, and given a prebuilt rubric. 'heuristic_first' only calls it for traffic the local scorer escalates, which still makes it a dependency on every one of those requests.)r4r.rs r rz*ComplexityRouterConfig.uses_llm_classifierHs ##';;;rc~|jtd|jDStdtDS)zPThe active tier names: the defined names, or the built-in set in severity order.c34K|]}|jywrCrerm definitions r roz4ComplexityRouterConfig.tier_names..SsQZQrc34K|]}|jywrC)r@)rmr<s r roz4ComplexityRouterConfig.tier_names..Ts@DTZZ@r)r rr/rs r rz!ComplexityRouterConfig.tier_namesPs7  ,Q4;P;PQQ Q@,?@@@rcz|j|jStd|jDS)zTThe tier names the classifier is told to emit: defined names, or the display labels.c3&K|] \}}| ywrCrrmrllabels r roz@ComplexityRouterConfig.classifier_wire_labels..Zs@xq%U@s)r rr labeled_tiersrs r classifier_wire_labelsz-ComplexityRouterConfig.classifier_wire_labelsVs5  ,??$ $@4+=+=+?@@@rrc|j|j|S|jjt fd|j DdS)zSResolve a classifier reply to the active tier it names, or None when it names none.Nc3JK|]}|jk(s|ywrCcasefold)rmrefoldeds r rozAComplexityRouterConfig.resolve_classified_tier..asUd4==?f;TTUs##)r tier_for_labelrGrnextr)rOrrs @r resolve_classified_tierz.ComplexityRouterConfig.resolve_classified_tier\sO  (&&u- - ..0Udoo&7UW[\\rc |j}tdd|jfd|jfdt |j fdt |j ffD}tdt |dj|df|d uxr|jd ud f|d uxr|jd ud f|jd k(d ft |jdffDS)zNError messages for config features that cannot coexist with a custom tier set.c3*K|] \}}|r| ywrCr)rmrenableds r rozDComplexityRouterConfig._tier_definition_conflicts..fs! ' w   ' r@rSrIrVc3*K|] \}}|r| ywrCr)rmpresentmessages r rozDComplexityRouterConfig._tier_definition_conflicts..ps!   :=   rrz cannot be combined with tier_definitions: these features rely on the built-in tier severity order, which a custom tier set does not defineNzclassifier_llm_config.system_prompt cannot be combined with tier_definitions: a wholesale replacement prompt drops the defined-tier bullets and the trust boundary; use classification_prompt, which replaces only the opening instructions and keeps bothzclassifier_llm_config.classification_rubric cannot be combined with tier_definitions: the preset calibration examples are written against the built-in tiers, which a custom tier set replacesr0zclassifier_fallback 'default_model' cannot be combined with tier_definitions: fallback_tier is where a custom-tier router routes when the classifier failsztier_labels cannot be combined with tier_definitions: labels rename the built-in tiers, which a custom tier set replaces; name the tiers directly in tier_definitions) r5rr@rSboolrIrVrrrr:r#)rO llm_configorder_dependents r _tier_definition_conflictsz1ComplexityRouterConfig._tier_definition_conflictscs. 66 !& ' T]]+#T%:%:;&T-E-E(FGD./ # ' "   )yy123hh d*Sz/G/Gt/Sid*[z/O/OW[/[#,,?U ))*d/%   rc  j?tddjfdjffDd}|t |dSt djD}dt |cxkr tks nt dtdt |t d |D t tt fd t| D}|rt d d j|jd vr t dj}|rt dj|t|}t t|tjz }|rt dd j|t ttj|z }|rt dd j|t tfd|D}|rt dd j|j t dj|vr*t djdd j|S)Nc3*K|] \}}|| ywrCr)rmfieldr@s r rozDComplexityRouterConfig._validate_tier_definitions..s$$u( rr!r"z requires tier_definitionsc34K|]}|jywrCrrs r rozDComplexityRouterConfig._validate_tier_definitions..sUZ__Urz+tier_definitions must define between 2 and z tiers, got c3<K|]}|jywrCr)rmres r rozDComplexityRouterConfig._validate_tier_definitions..s@$dmmo@sc3RK|]\}}j|dkDs| yw)r7N)count)rmrefoldrs r rozDComplexityRouterConfig._validate_tier_definitions..s'ajdD&,,W[J\_`J`Tas''z:tier_definitions names must be unique (case-insensitive): r)r2r-zrtier_definitions requires classifier_type 'llm' or 'custom': the heuristic scorer only produces the built-in tiers; z7tiers must map every defined tier to a model; missing: z9tiers keys must be defined in tier_definitions; unknown: c3ZK|]"}jj|r|$ywrC)rrg)rmrerOs r rozDComplexityRouterConfig._validate_tier_definitions..s!)]4 W[H\$)]s ++z@tiers must map every defined tier to at least one model; empty: zifallback_tier is required with tier_definitions: it is where requests route when the LLM classifier failszfallback_tier z" is not one of the defined tiers: )r rr!r"rNrrarYsortedrziprr4rr) rOorphanedr duplicated conflictsdefinedmissingunknown empty_poolsrs ` @r _validate_tier_definitionsz1ComplexityRouterConfig._validate_tier_definitionss  (")$*<*<=0$2L2LM) H# H:-G!HIIKUt?T?TUUCJ6"66=>R=SS_`cdi`j_kl @%@@! 9aCv4Faa b  YZ^ZcZcdnZoYpqr r   #C C.  ::< TYYy12 2"5)vg $**0E&EFG VW[W`W`ahWiVjkl lvi &;g&EFG XY]YbYbcjYkXlmn n"6)]5)]#]^ RSWS\S\]hSiRjk     %'    W , !3!3 66XY]YbYbchYiXjk  rc 4|js|St|jtt tfd|jD}|r=t ddj |ddj |j|S)Nc3TK|]}|jvs|j!ywrC)r<)rmrulevalids r rozFComplexityRouterConfig._validate_keyword_rule_tiers..s!e4dii_dNdTYYes((z,keyword_tier_rules reference unknown tiers: rz; valid tiers: )rJrrrrrNr)rO unknown_tiersrs @r _validate_keyword_rule_tiersz3ComplexityRouterConfig._validate_keyword_rule_tierss&&K !23$ 9e43J3Jee f  >tyy?W>XY $ $//*; <=?  rc z|js|S|jjDcic]\}}|t|tr|n|g}}}t |j s td|jDcgc] \}}|r | }}}|rtd|||_|Scc}}wcc}}w)Nz7adaptive=True requires at least one non-empty tier poolz9adaptive=True tier pools must be non-empty; empty tiers: )r@rr\rErTrrvaluesrN)rOr<modelsremptys r _validate_adaptive_poolsz/ComplexityRouterConfig._validate_adaptive_poolss}}KcgcmcmcscscuvS_SWY_dz&$'?VfXMv v:$$&'VW W1;1A1A1CRv6RR XY^X_`a a  wSs B1 B7B7c~|js|S|js td|js td|S)NzEembedding_model is required when semantic_keyword_matching is enabledzNkeyword_tier_rules must be non-empty when semantic_keyword_matching is enabled)rOrPrNrJrs r _validate_semantic_matchingz2ComplexityRouterConfig._validate_semantic_matchings?--K##de e&&mn n rc,|js|Sttd|jjD}|rt ddj |ttd|jjD}|rt ddj ||j tdDtfdtD}|rt dd j ||S) Nc3\K|]$\}}|jr|j&ywrC)rGr@rmr<rs r roz?ComplexityRouterConfig._validate_tier_labels..s$#p;4bgbmbmboDJJ#ps,,z>tier_labels values must be non-empty; blank labels for tiers: rc3K|]\}}|jjtjvrL|jj|jk7r!|jd|jyw)z -> N)rGrprrqr@rs r roz?ComplexityRouterConfig._validate_tier_labels..skD%;;=&&(N,F,FF5;;=K^K^K`dhdndnKn::,d5;;=/2sBBz|tier_labels values must not reuse another tier's canonical name, which would make logs and the classifier rubric ambiguous: c3BK|]\}}|jywrCrrs r roz?ComplexityRouterConfig._validate_tier_labels..s$N(!UU^^%5$Nsc3K|]I\}jdkDr0j|k(rdjfdDKyw)r7z and c3dK|]'\}}|jk(s|j)ywrC)rr@)rmr<rrs r rozIComplexityRouterConfig._validate_tier_labels... s(] e%..BRV\B\]s00N)rindexr)rmpositionr folded_labelslabeleds @r roz?ComplexityRouterConfig._validate_tier_labels..sR"  &""6*Q.=3F3Fv3NRZ3Z LL]w] ]" sAAzCtier_labels values must be unique across tiers; shared labels for: r)r#rrr\rNrr enumerate)rOblankshadowedrrrs @@r _validate_tier_labelsz,ComplexityRouterConfig._validate_tier_labelss KV#p$BRBRBXBXBZ#ppq ]^b^g^ghm^n]opq q #'#3#3#9#9#;   88< (8K7LN ++-$$Ng$NN !" $-m$<"  UVZV_V_`jVkUlm  rcL|jr|jr td|S)Nzplugins and adaptive=True cannot both be set: adaptive's bandit selection doesn't yet consume plugin-narrowed candidate pools. Disable adaptive or remove plugins.)rVr@rNrs r _validate_plugins_adaptive_comboz7ComplexityRouterConfig._validate_plugins_adaptive_combos) <.$sf! g ! i(<(<=@]]^ ! fAcUO! ! ! sAAztier entries carry complexity_router_config settings in their litellm_params, where the router never reads them and the outbound request forwards them to the provider as unknown body fields: rz.. Set these on complexity_router_config itself)rrr\rNr)rO misplaceds r _validate_tier_param_placementz5ComplexityRouterConfig._validate_tier_param_placements`!! !%!8!8!>!>!@!   $ ) 455ce   rr<cr|jj|djxs |jS)zLOperator-facing display name for a tier, falling back to its canonical name.ri)r#rgrGr@)rOr<s r tier_labelz!ComplexityRouterConfig.tier_label2s-##D"-335CCrc4tfdtDS)zEEvery tier paired with its display name, in ascending severity order.c3DK|]}|j|fywrC)r)rmr<rOs r roz7ComplexityRouterConfig.labeled_tiers..8sStdDOOD12Ss )rr/rs`r rz$ComplexityRouterConfig.labeled_tiers6sS?RSSSrc|jj|j}tfd|DtfdtDdS)zRResolve a display name back to its tier, case-insensitively, then canonical names.c3PK|]\}}|jk(s|ywrCr)rmr<rrs r roz8ComplexityRouterConfig.tier_for_label..?s& U&dJZ5H5H5Jf5TT Us&&c3^K|]$}|jjk(s!|&ywrC)r@r)rmr<rs r roz8ComplexityRouterConfig.tier_for_label..@s&Z4$**:M:M:OSY:Y$Zs"--N)rGrrrr/)rOrrrs @r rz%ComplexityRouterConfig.tier_for_label:sL ..0++- U' U Z#6Z\` a  r)rAr)krrrrr rrrFrTrUrrrr~r rdr!r"r#rr%floatr&r(rr*r+r,r-r.r/r0r1rr4r r5r r6r7rr9r:r3r<r4r=r>r?r@rDrr1rErHrIrJr6rKrLrMrNrOrPrRrSrTrUrVrrWrvr rrrVrWr`rrnrqrsr|rrrrrrrpropertyrrrrrrrrrrrrrrrrrrr rrs 1).: x)E4S49_$ %INIU+>+C%D DE;@ a ;eNC/047 !& -!M3:). 0 )3: .3 R .Knc)* ).> G)OT#u*%27 d2 %$,(-?N(d38n +0@8+tCJ' ',>'M49t#,1D,S D(,1;,S D(38 23tCy4/).>)OT#Y% !&G!M3: #( ;#4QV KQOWLM9>w9.5,1 b ,cDj 27 o2'$.).  T ) #BG U B!=> +06  ( +"C,17  H ,#S5:  a 5%sTz 8= a8. RHd/4L^/+$)- b$5 '"#'"#*D~D#DTuU>3+>%?%DET C NT,A rrrDEFAULT_COMPLEXITY_CONFIG)Ircollections.abcrenumrtypesrtypingrrr pydanticr r r r rrrlitellm.types.routerrrrrFrr"r'r+rUrr.rrrrr/rr1rr3rr4r6rYr[r\r]rbrdrvr~rWrTrrrrrrrrrrrrrr r r r model_fieldsrrrrr rs$",,uuuWWS$3>R=X=Xu%9:X /8@Q8R.SeIcN+S :U5!456/2uU|156&c 66:'s:!i!H$%eCj$"$U3Z$),E#J,.2s23:#*")Y)X0)$  3c?E"5s":; ;<0.+uT#Y'.`0E$s),,0E$s),@2D0DU49-D 4%c3h06dE%S/2c6E%S/2#3U3Z2-tCy)D65c5j!124tCJ/03%S#X/)+ .U4S>*A)AHR  YR  j8AAWAdAd7euYs^4e$:#;5;r