/**
 * #369: each runtime's real model list, for `monomind agent models`
 * (capability `agent-models`). Callers used to keep hand-written lists that
 * went stale; every source here is what the runtime itself offers, and none
 * sends a prompt:
 *  - claude: the Agent SDK's `query().supportedModels()` — what Claude Code's
 *    `/model` picker shows for this account.
 *  - codex: `codex debug models`, only entries with `visibility: "list"`.
 *  - antigravity: `agy models` (`<id>\t<label>` lines).
 *  - opencode: `opencode models` (`<provider>/<model>` lines).
 *  - dsh: no listing command (its picker is the web Models page), so the
 *    runner's own curated list (dsh-runner-models.ts DSH_MODELS, incl. the
 *    free OpenRouter/NVIDIA routes) with `curated: true`.
 * Every other runtime has no listing command: `supported: false`, `[]`.
 */
import { type ClaudeCodeInfo } from './claude-sdk.js';
export interface AgentModel {
    /** What to pass as the runtime's model option. */
    id: string;
    /** The concrete model an alias (`default`, `opus`) resolves to today. */
    resolved_id?: string;
    /** On the canonical entry: every id that resolves to this same model,
     *  this entry's own `id` first (claude `default` and `opus`). Omitted when
     *  only one id does. */
    aliases?: string[];
    /** On a duplicate: the canonical entry's `id` (the first entry for the
     *  same resolved model). A caller that tests every model skips these; a
     *  lookup by id still finds them. */
    alias_of?: string;
    label: string;
    description?: string;
    /** The runtime's own default choice. */
    default?: boolean;
    effort_levels?: string[];
}
export interface ModelsResult {
    v: 1;
    runtime: string;
    /** false: this runtime has no model-listing command (`models` is `[]`). */
    supported: boolean;
    /** true: a static list monomind ships for a runtime with no listing
     *  command (dsh), not one the runtime printed. */
    curated?: boolean;
    claude_code?: ClaudeCodeInfo;
    models: AgentModel[];
    reason?: string;
    error?: {
        code: 'unknown-runtime' | 'missing-binary' | 'list-failed';
        message: string;
    };
}
interface SdkModelInfo {
    value?: string;
    resolvedModel?: string;
    displayName?: string;
    description?: string;
    supportedEffortLevels?: string[];
}
export declare function parseClaudeModels(list: SdkModelInfo[]): AgentModel[];
/**
 * Marks aliases of the same concrete model (claude `default` and `opus` both
 * → claude-opus-5-5), which would otherwise be tested and billed twice.
 * Every entry is kept, so a lookup by id (`opus`) still works: the first
 * entry per resolved model is canonical and lists every id in `aliases`; each
 * later one gets `alias_of: <canonical id>`.
 */
export declare function markAliases(models: AgentModel[]): AgentModel[];
export declare function parseCodexModels(stdout: string): AgentModel[];
export declare function parseAgyModels(stdout: string): AgentModel[];
export declare function parseOpencodeModels(stdout: string): AgentModel[];
export type CliRunner = (bin: string, args: string[], timeoutMs: number) => Promise<string>;
export type ClaudeLister = (timeoutMs: number) => Promise<SdkModelInfo[]>;
type ListOpts = {
    env?: NodeJS.ProcessEnv;
    timeoutMs?: number;
    runCli?: CliRunner;
    listClaude?: ClaudeLister;
};
/** A runtime's model list, minus the models that are never assigned or routed
 *  (Claude Fable, GPT Astra), so no caller is ever offered one as a choice. */
export declare function listRuntimeModels(runtime: string, opts?: ListOpts): Promise<ModelsResult>;
export {};
//# sourceMappingURL=agent-models.d.ts.map