/**
 * Cost tiers for model selection: cheap / default / best / ultra.
 *
 * An orchestrating agent picks a teammate's model by a stable, cost-first tier
 * instead of a concrete id that churns per release and varies per harness. A
 * tier resolves, per (harness, installed version), to a model that version
 * actually ships — so `--model cheap|default|best|ultra` works on `agents run`
 * and `agents teams add` alike, funnelling through `resolveModel()`.
 *
 * Ranking signal, in priority (see cli/docs — model ranking mechanisms):
 *   1. Provider-declared lineup — the catalog's own family names / descriptions
 *      (opus/sonnet/haiku/fable; Codex "frontier / balanced / fast"). Most
 *      drift-proof: the provider tells us its own ranking.
 *   2. Per-token price (prices.json) — cross-check + the $/Mtok display + budget.
 *   3. Size-token heuristic (nano|mini|lite|flash cheaper; pro|max|opus dearer).
 *   4. Reasoning effort for single-model harnesses (Grok) — tiers steer --effort.
 *
 * The mechanism differs per provider and drifts across versions, so tiers always
 * resolve against the installed version's own catalog.
 */
import type { AgentId } from './types.js';
import { type ModelInfo } from './models.js';
/** The four cross-harness cost tiers, cheapest -> most capable. */
export declare const MODEL_TIERS: readonly ["cheap", "default", "best", "ultra"];
export type ModelTier = (typeof MODEL_TIERS)[number];
/** True if `s` is one of the four tier tokens (not a concrete model id). */
export declare function isTierToken(s: string | undefined | null): s is ModelTier;
/** How a single tier resolved for a given (agent, version). */
export interface TierResolution {
    tier: ModelTier;
    /** Concrete model id to forward, or null when nothing resolves (fail-safe). */
    model: string | null;
    /** Reasoning effort to forward, for single-model harnesses where the tier is effort, not model. */
    effort?: string;
    /** Set when this tier has no rung of its own: the lower tier whose model it borrowed. */
    clampedFrom?: ModelTier;
    /** Human note (e.g. why it clamped, or that it is a curated/subscription mapping). */
    note?: string;
    /** Where the model came from: 'auto' ranking, a user 'override', or a 'curated' ladder. */
    source?: 'auto' | 'override' | 'curated';
}
/**
 * Resolve all four tiers for an (agent, version) -- what `agents models` prints and
 * `resolveTier` indexes. Precedence: user override -> curated ladder / auto-ranking.
 */
export declare function resolveTierMap(agent: AgentId, version: string): Record<ModelTier, TierResolution>;
/**
 * Apply user overrides on top of the auto/curated map. Pure (takes the resolved
 * override map, no config lookup) so it is directly testable. An overridden id is
 * used only when the version actually ships it (or when there is no catalog to
 * check, e.g. Droid); otherwise the tier keeps its base value with a note.
 */
export declare function applyTierOverrides(overrides: Partial<Record<ModelTier, string>>, label: string, catalogIds: Set<string> | null, base: Record<ModelTier, TierResolution>): Record<ModelTier, TierResolution>;
/**
 * Map a harness's catalog models onto the four tiers. Pure (no catalog lookup) so
 * it is directly testable. A single-model harness maps the tiers to reasoning effort.
 */
export declare function tierizeModels(agent: AgentId, models: ModelInfo[]): Record<ModelTier, TierResolution>;
/** Resolve one tier for an (agent, version). Null model => caller drops the flag. */
export declare function resolveTier(agent: AgentId, version: string, tier: ModelTier): TierResolution;
