import { type ResolvedThinkingLevel, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
import { Effort, type Model } from "@oh-my-pi/pi-ai";
/**
 * Metadata used to render thinking selector values in the coding-agent UI.
 */
export interface ThinkingLevelMetadata {
    value: ThinkingLevel;
    label: string;
    description: string;
}
/**
 * Parses a provider-facing effort value.
 */
export declare function parseEffort(value: string | null | undefined): Effort | undefined;
/**
 * Parses an agent-local thinking selector.
 */
export declare function parseThinkingLevel(value: string | null | undefined): ThinkingLevel | undefined;
/**
 * Returns display metadata for a thinking selector.
 */
export declare function getThinkingLevelMetadata(level: ThinkingLevel): ThinkingLevelMetadata;
/**
 * Converts an agent-local selector into the effort sent to providers.
 */
export declare function toReasoningEffort(level: ThinkingLevel | undefined): Effort | undefined;
/**
 * True when a selector explicitly requests provider-side reasoning disablement.
 */
export declare function shouldDisableReasoning(level: ThinkingLevel | undefined): boolean;
/**
 * Resolves a selector against the current model while preserving explicit "off".
 */
export declare function resolveThinkingLevelForModel(model: Model | undefined, level: ThinkingLevel | undefined): ResolvedThinkingLevel | undefined;
/**
 * Sentinel selector for the coding-agent "auto" thinking mode. Kept entirely
 * inside the coding-agent layer: it is never an {@link Effort} or
 * {@link ThinkingLevel}, so provider mapping/clamping keeps seeing concrete
 * efforts. The session resolves `auto` to a concrete effort each turn.
 */
export declare const AUTO_THINKING: "auto";
/** A thinking selector as configured by the user — a concrete level or `auto`. */
export type ConfiguredThinkingLevel = ThinkingLevel | typeof AUTO_THINKING;
/** Maps the session-level `auto` sentinel to `undefined`; concrete levels pass through. */
export declare function concreteThinkingLevel(level: ConfiguredThinkingLevel | undefined): ThinkingLevel | undefined;
/** Metadata used to render the `auto` selector value alongside concrete levels. */
export interface ConfiguredThinkingLevelMetadata {
    value: ConfiguredThinkingLevel;
    label: string;
    description: string;
}
/**
 * Parses a configured thinking selector, accepting `auto` in addition to every
 * value {@link parseThinkingLevel} accepts. {@link parseThinkingLevel} itself
 * stays strict so model-suffix parsing (`model:high`) keeps rejecting `auto`.
 */
export declare function parseConfiguredThinkingLevel(value: string | null | undefined): ConfiguredThinkingLevel | undefined;
/** Returns display metadata for a configured selector, including `auto`. */
export declare function getConfiguredThinkingLevelMetadata(level: ConfiguredThinkingLevel): ConfiguredThinkingLevelMetadata;
/**
 * Thinking selectors accepted by the `--thinking` CLI flag, in display order:
 * `off`, every concrete effort (`minimal`..`xhigh`), then `auto`. Single source
 * for the flag's `options` list, shell completions, and the "invalid level"
 * warning so all three stay in sync.
 */
export declare const CLI_THINKING_LEVELS: readonly string[];
/**
 * Parses a `--thinking` CLI value. Accepts every {@link parseConfiguredThinkingLevel}
 * selector (`off`, `auto`, `minimal`..`xhigh`, plus the `max` alias) but rejects
 * `inherit`: an explicit `inherit` on the command line would suppress the
 * settings/scoped-model fallback during startup resolution only to resolve back
 * to the provider default, which is never what the user means.
 */
export declare function parseCliThinkingLevel(value: string | null | undefined): ConfiguredThinkingLevel | undefined;
/**
 * Resolves an auto-classified effort against the active model's supported
 * range. Unlike {@link clampThinkingLevelForModel}, `auto` never resolves below
 * {@link Effort.Low}: the eligible pool is the model's supported efforts at or
 * above Low (falling back to the full supported set only when the model maxes
 * out below Low). Within that pool the request snaps to the highest level not
 * exceeding it, or the pool minimum when the request is below the pool.
 *
 * Returns `undefined` for reasoning-capable models without a controllable
 * effort surface (`thinking.efforts` empty — e.g. devin-agent models, where
 * Cascade selects effort by routing to sibling model ids). Matches
 * {@link clampThinkingLevelForModel}: with no effort to pick, `auto` must not
 * forward a concrete effort that would then trip {@link requireSupportedEffort}
 * downstream.
 */
export declare function clampAutoThinkingEffort(model: Model | undefined, effort: Effort): Effort | undefined;
/**
 * The provisional concrete level shown while `auto` is configured but before a
 * turn has been classified. Prefers the model's `defaultLevel`, otherwise High,
 * clamped into the auto range. Returns `undefined` for non-reasoning models.
 */
export declare function resolveProvisionalAutoLevel(model: Model | undefined): Effort | undefined;
