import type { ThinkingLevel } from "./config.js";
export type RoutingStage = "define" | "plan" | "build" | "verify" | "debug" | "review" | "ship" | "fast-judge";
export type TaskRisk = "low" | "medium" | "high";
export type ProfileProvenance = "user" | "project" | "builtin" | "observed" | "inferred";
export type RoutingMode = "quality" | "balanced" | "economy" | "pinned" | "custom";
export type ModelPrivacy = "local" | "private" | "public" | "unknown";
export interface ModelCost {
    input: number;
    output: number;
    cacheRead: number;
    cacheWrite: number;
}
export interface DiscoveredModel {
    provider: string;
    model: string;
    displayName?: string;
    family?: string;
    api?: string;
    callable: boolean;
    reasoning: boolean;
    supportedThinking: readonly ThinkingLevel[];
    input: readonly ("text" | "image")[];
    contextWindow: number;
    maxOutputTokens: number;
    cost?: ModelCost;
    privacy?: ModelPrivacy;
}
export interface ModelCapabilityScores {
    requirements: number;
    architecture: number;
    coding: number;
    debugging: number;
    verification: number;
    review: number;
    release: number;
    structuredOutput: number;
    longContext: number;
    speed: number;
    economy: number;
}
export type CapabilityName = keyof ModelCapabilityScores;
export interface ModelCapabilityProfile {
    family?: string;
    confidence: number;
    provenance?: ProfileProvenance;
    version?: string;
    scores: Partial<ModelCapabilityScores>;
}
export interface ProfileSource {
    provenance: ProfileProvenance;
    profiles: Readonly<Record<string, ModelCapabilityProfile>>;
}
export interface ResolvedModelProfile {
    identity: ModelSelectionIdentity;
    family?: string;
    confidence: number;
    provenance: ProfileProvenance;
    version: string;
    scores: ModelCapabilityScores;
}
export interface TaskFeatures {
    contextTokens: number;
    expectedOutputTokens: number;
    requiredInput: readonly ("text" | "image")[];
    risk: TaskRisk;
    workKind: "feature" | "bug-fix" | "refactor" | "migration" | "test-only" | "documentation" | "configuration" | "release" | "unknown";
    fileCount: number;
    languages: readonly string[];
    riskSignals: readonly string[];
    failureSignals: readonly string[];
}
export interface StageRoutingPolicy {
    prefer: readonly string[];
    pins: readonly string[];
    requiredInput: readonly ("text" | "image")[];
    minimumContextWindow: number;
    minimumOutputTokens: number;
    requiresReasoning: boolean;
    minimumProfileConfidence: number;
    minimumScores: Partial<ModelCapabilityScores>;
    weights: Partial<ModelCapabilityScores>;
    thinking: ThinkingLevel;
}
export interface RoutingPolicy {
    version: string;
    mode: RoutingMode;
    allowInferredProfiles: boolean;
    unknownCost: "exclude" | "penalize" | "allow";
    unknownCostPenaltyBasisPoints: number;
    confidenceBonusBasisPoints: number;
    costPenaltyBasisPointsPerUsd: number;
    privacy: {
        allowed: readonly Exclude<ModelPrivacy, "unknown">[];
        allowUnknown: boolean;
        providers: Readonly<Record<string, ModelPrivacy>>;
    };
    deny: {
        providers: readonly string[];
        models: readonly string[];
        families: readonly string[];
    };
    separation: {
        checkerMustDifferFromBuilder: boolean;
        preferDifferentProviderFamily: boolean;
        requireDifferentProviderFamilyFor: readonly RoutingStage[];
    };
    limits: {
        maxEstimatedUsdPerRun: number;
        maxAttemptsPerStage: number;
    };
    stages: Record<RoutingStage, StageRoutingPolicy>;
}
export interface ModelSelectionIdentity {
    stage?: RoutingStage;
    provider: string;
    model: string;
    family?: string;
}
export interface RoutingRequest {
    stage: RoutingStage;
    task: TaskFeatures;
    models: readonly DiscoveredModel[];
    profiles: Readonly<Record<string, ModelCapabilityProfile>>;
    policy: RoutingPolicy;
    priorSelections: readonly ModelSelectionIdentity[];
}
export interface ScoreComponent {
    name: "capability-fit" | "task-feature-fit" | "profile-confidence" | "provider-diversity" | "estimated-cost" | "unknown-cost";
    value: number;
    detail: string;
}
export interface RankedModelCandidate {
    identity: ModelSelectionIdentity;
    thinking: ThinkingLevel;
    requestedThinking: ThinkingLevel;
    thinkingReason: string;
    score: number;
    scoreBreakdown: readonly ScoreComponent[];
    profile: Pick<ResolvedModelProfile, "confidence" | "provenance" | "version">;
    estimatedCostUsd?: number;
}
export type ExclusionCode = "not-callable" | "denied-provider" | "denied-model" | "denied-family" | "pinned-only" | "profile-unknown" | "profile-confidence-low" | "capability-score-low" | "input-unsupported" | "context-insufficient" | "output-insufficient" | "reasoning-required" | "cost-unknown" | "cost-limit-exceeded" | "privacy-not-allowed" | "same-builder-model" | "same-builder-family";
export interface ExcludedCandidate {
    identity: ModelSelectionIdentity;
    code: ExclusionCode;
    detail: string;
}
export interface RoutingDecision {
    stage: RoutingStage;
    policyVersion: string;
    eligible: readonly RankedModelCandidate[];
    excluded: readonly ExcludedCandidate[];
    taskFeatures: TaskFeatures;
}
export interface ThinkingSelection {
    requested: ThinkingLevel;
    selected: ThinkingLevel;
    clamped: boolean;
    reason: string;
}
export declare const DEFAULT_STAGE_REQUIREMENTS: Record<RoutingStage, StageRoutingPolicy>;
export declare const DEFAULT_ROUTING_POLICY: RoutingPolicy;
export declare function modelIdentityKey(identity: Pick<ModelSelectionIdentity, "provider" | "model">): string;
export declare function resolveModelProfiles(models: readonly DiscoveredModel[], profileSources: readonly ProfileSource[], policy: RoutingPolicy): ReadonlyMap<string, ResolvedModelProfile>;
export declare function rankModels(request: RoutingRequest): RoutingDecision;
export declare function selectThinkingLevel(stage: RoutingStage, model: DiscoveredModel, policy: RoutingPolicy, risk: TaskRisk): ThinkingSelection;