Repository navigation
Combo + quota-shared deep audit: 5 fixes + strategy validation + E2E + complexity routing (2026) #3779
There are no files selected for viewing
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,111 @@ | ||
| /** | ||
| * complexityRouter.ts — Request-complexity classification for tier-aware routing. | ||
| * | ||
| * 2026 strategy: route by the intrinsic difficulty of the *request* (not only by | ||
| * provider stats), so trivial prompts can use cheap models and hard/reasoning | ||
| * prompts escalate to capable ones. Built on the existing specificity detector | ||
| * (codeComplexity / mathComplexity / reasoningDepth / contextSize / toolCalling | ||
| * / domainSpecificity), adding an explicit tool-use → minimum-tier escalation: | ||
| * a request carrying tool/function schemas (or agentic tool-calling signals) | ||
| * should not be routed below the "cheap" tier even when the prose looks | ||
| * trivial, because function-calling reliability matters more than raw cost. | ||
| * | ||
| * The classification maps to a `recommendedTier` that feeds the auto-router's | ||
| * tier-affinity / specificity-match scoring factors (see scoreAutoTargets, | ||
| * gated by config.complexityAwareRouting). | ||
| */ | ||
| import { | ||
| analyzeSpecificity, | ||
| getSpecificityLevel, | ||
| getRecommendedMinTier, | ||
| } from "../specificityDetector"; | ||
| import type { RuleInput, SpecificityLevel } from "../specificityTypes"; | ||
| import { generateRoutingHints, type RoutingHint } from "../manifestAdapter"; | ||
|
|
||
| export type ComplexityTier = "free" | "cheap" | "premium"; | ||
|
|
||
| export interface ComplexityClassification { | ||
| /** 0..100 specificity / difficulty score. */ | ||
| score: number; | ||
| /** trivial | simple | moderate | complex | expert */ | ||
| level: SpecificityLevel; | ||
| /** Minimum provider tier recommended for this request. */ | ||
| recommendedTier: ComplexityTier; | ||
| /** True when the request carries tool/function schemas or agentic tool signals. */ | ||
| hasToolUse: boolean; | ||
| /** Names of the specificity rules that fired (for the inspector / dashboard). */ | ||
| signals: string[]; | ||
| } | ||
|
|
||
| const TIER_ORDER: ComplexityTier[] = ["free", "cheap", "premium"]; | ||
|
|
||
| /** Raise `tier` to at least `floor`; never lowers it. */ | ||
| export function escalateTier(tier: ComplexityTier, floor: ComplexityTier): ComplexityTier { | ||
| return TIER_ORDER.indexOf(tier) >= TIER_ORDER.indexOf(floor) ? tier : floor; | ||
| } | ||
|
|
||
| /** | ||
| * Classify a request's complexity and recommend a minimum provider tier. | ||
| * Pure + dependency-light (no DB / network); safe on the hot path. | ||
| */ | ||
| export function classifyRequestComplexity(input: RuleInput): ComplexityClassification { | ||
| const result = analyzeSpecificity(input); | ||
| const level = getSpecificityLevel(result.score); | ||
|
|
||
| const explicitTools = Array.isArray(input.tools) && input.tools.length > 0; | ||
| const hasToolUse = explicitTools || result.breakdown.toolCalling > 0; | ||
|
|
||
| let recommendedTier = getRecommendedMinTier(level) as ComplexityTier; | ||
| // Tool-using / agentic requests need reliable function calling — floor at "cheap". | ||
| if (hasToolUse) recommendedTier = escalateTier(recommendedTier, "cheap"); | ||
|
|
||
| return { | ||
| score: result.score, | ||
| level, | ||
| recommendedTier, | ||
| hasToolUse, | ||
| signals: result.rulesTriggered, | ||
| }; | ||
| } | ||
|
|
||
| /** | ||
| * Build the opt-in complexity-aware routing hint for the auto-router. Returns a | ||
| * RoutingHint whose `recommendedMinTier` is escalated to the request's intrinsic | ||
| * complexity (and floored at "cheap" for tool-using requests), or `null` on any | ||
| * failure — fail-open, so scoring stays tier-neutral. Extracted from combo.ts to | ||
| * keep the complexity-routing logic in one module. | ||
| */ | ||
| export function buildComplexityRoutingHint( | ||
| modelTargets: Parameters<typeof generateRoutingHints>[0], | ||
| body: { messages?: unknown; tools?: unknown; model?: unknown } | null | undefined, | ||
| log: { info: (tag: string, message: string) => void } | ||
| ): RoutingHint | null { | ||
| try { | ||
| const ruleInput = { | ||
| messages: Array.isArray(body?.messages) | ||
| ? (body.messages as Array<{ role?: string; content?: string | unknown }>) | ||
| : [], | ||
| tools: Array.isArray(body?.tools) | ||
| ? (body.tools as Array<{ | ||
| function?: { name: string; description?: string; parameters?: unknown }; | ||
| }>) | ||
| : undefined, | ||
| model: typeof body?.model === "string" ? body.model : undefined, | ||
| }; | ||
| const hint = generateRoutingHints(modelTargets, ruleInput); | ||
| // Tool-use escalation: floor the recommended tier at "cheap" so scoring | ||
| // favors function-calling-reliable models for agentic requests. | ||
| const classification = classifyRequestComplexity(ruleInput); | ||
| hint.recommendedMinTier = escalateTier( | ||
| hint.recommendedMinTier as ComplexityTier, | ||
| classification.recommendedTier | ||
| ) as typeof hint.recommendedMinTier; | ||
| log.info( | ||
| "COMBO", | ||
| `Complexity-aware routing: level=${classification.level} score=${classification.score} minTier=${hint.recommendedMinTier} tools=${classification.hasToolUse}` | ||
| ); | ||
| return hint; | ||
| } catch { | ||
| return null; // fail-open: scoring stays tier-neutral | ||
| } | ||
| } | ||
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
To prevent potential runtime
TypeErrorexceptions ifresult.breakdownis undefined, use optional chaining and nullish coalescing to safely accesstoolCalling.