@oh-my-pi/pi-coding-agent 15.1.1 → 15.1.3

package/dist/types/config/model-registry.d.ts

@@ -0,0 +1,363 @@
+import { type Api, type AssistantMessageEventStream, type Context, type Model, type ModelRefreshStrategy, type SimpleStreamOptions, type ThinkingConfig } from "@oh-my-pi/pi-ai";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/utils/oauth/types";
+import { type ThemeColor } from "../modes/theme/theme";
+import type { AuthStorage } from "../session/auth-storage";
+import { type ConfigError, ConfigFile } from "./config-file";
+import { type CanonicalModelIndex, type CanonicalModelRecord, type CanonicalModelVariant, type ModelEquivalenceConfig } from "./model-equivalence";
+import { type Settings } from "./settings";
+export type { CanonicalModelIndex, CanonicalModelRecord, CanonicalModelVariant, ModelEquivalenceConfig };
+export declare const kNoAuth = "N/A";
+export declare function isAuthenticated(apiKey: string | undefined | null): apiKey is string;
+export type ModelRole = "default" | "smol" | "slow" | "vision" | "plan" | "designer" | "commit" | "task";
+export interface ModelRoleInfo {
+    tag?: string;
+    name: string;
+    color?: ThemeColor;
+}
+export declare const MODEL_ROLES: Record<ModelRole, ModelRoleInfo>;
+export declare const MODEL_ROLE_IDS: ModelRole[];
+/** Alias for ModelRoleInfo - used for both built-in and custom roles */
+export type RoleInfo = ModelRoleInfo;
+/**
+ * Return the canonical set of known roles for selector/carousel UI.
+ *
+ * Built-ins always come first. Configured cycle order, model assignments, and
+ * tag metadata can introduce additional custom roles without requiring duplicate
+ * entries across settings.
+ */
+export declare function getKnownRoleIds(settings: Settings): string[];
+/**
+ * Get role info for a role name (built-in or custom).
+ * Configured metadata overrides built-in defaults when present.
+ */
+export declare function getRoleInfo(role: string, settings: Settings): RoleInfo;
+export declare const ModelsConfigFile: ConfigFile<{
+    providers?: Record<string, {
+        baseUrl?: string | undefined;
+        apiKey?: string | undefined;
+        api?: "anthropic-messages" | "azure-openai-responses" | "google-generative-ai" | "google-vertex" | "openai-codex-responses" | "openai-completions" | "openai-responses" | undefined;
+        headers?: Record<string, string> | undefined;
+        compat?: {
+            supportsStore?: boolean | undefined;
+            supportsDeveloperRole?: boolean | undefined;
+            supportsMultipleSystemMessages?: boolean | undefined;
+            supportsReasoningEffort?: boolean | undefined;
+            reasoningEffortMap?: {
+                minimal?: string | undefined;
+                low?: string | undefined;
+                medium?: string | undefined;
+                high?: string | undefined;
+                xhigh?: string | undefined;
+            } | undefined;
+            maxTokensField?: "max_completion_tokens" | "max_tokens" | undefined;
+            supportsUsageInStreaming?: boolean | undefined;
+            requiresToolResultName?: boolean | undefined;
+            requiresMistralToolIds?: boolean | undefined;
+            requiresAssistantAfterToolResult?: boolean | undefined;
+            requiresThinkingAsText?: boolean | undefined;
+            reasoningContentField?: "reasoning" | "reasoning_content" | "reasoning_text" | undefined;
+            requiresReasoningContentForToolCalls?: boolean | undefined;
+            allowsSyntheticReasoningContentForToolCalls?: boolean | undefined;
+            requiresAssistantContentForToolCalls?: boolean | undefined;
+            supportsToolChoice?: boolean | undefined;
+            disableReasoningOnForcedToolChoice?: boolean | undefined;
+            disableReasoningOnToolChoice?: boolean | undefined;
+            thinkingFormat?: "openai" | "openrouter" | "qwen" | "qwen-chat-template" | "zai" | undefined;
+            openRouterRouting?: {
+                only?: string[] | undefined;
+                order?: string[] | undefined;
+            } | undefined;
+            vercelGatewayRouting?: {
+                only?: string[] | undefined;
+                order?: string[] | undefined;
+            } | undefined;
+            extraBody?: Record<string, unknown> | undefined;
+            supportsStrictMode?: boolean | undefined;
+            toolStrictMode?: "all_strict" | "none" | undefined;
+        } | undefined;
+        authHeader?: boolean | undefined;
+        auth?: "apiKey" | "none" | "oauth" | undefined;
+        discovery?: {
+            type: "llama.cpp" | "lm-studio" | "ollama" | "openai-models-list";
+        } | undefined;
+        models?: {
+            id: string;
+            name?: string | undefined;
+            api?: "anthropic-messages" | "azure-openai-responses" | "google-generative-ai" | "google-vertex" | "openai-codex-responses" | "openai-completions" | "openai-responses" | undefined;
+            baseUrl?: string | undefined;
+            reasoning?: boolean | undefined;
+            thinking?: {
+                minLevel: "high" | "low" | "medium" | "minimal" | "xhigh";
+                maxLevel: "high" | "low" | "medium" | "minimal" | "xhigh";
+                mode: "anthropic-adaptive" | "anthropic-budget-effort" | "budget" | "effort" | "google-level";
+                defaultLevel?: "high" | "low" | "medium" | "minimal" | "xhigh" | undefined;
+                levels?: ("high" | "low" | "medium" | "minimal" | "xhigh")[] | undefined;
+            } | undefined;
+            input?: ("image" | "text")[] | undefined;
+            cost?: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+            } | undefined;
+            premiumMultiplier?: number | undefined;
+            contextWindow?: number | undefined;
+            maxTokens?: number | undefined;
+            headers?: Record<string, string> | undefined;
+            compat?: {
+                supportsStore?: boolean | undefined;
+                supportsDeveloperRole?: boolean | undefined;
+                supportsMultipleSystemMessages?: boolean | undefined;
+                supportsReasoningEffort?: boolean | undefined;
+                reasoningEffortMap?: {
+                    minimal?: string | undefined;
+                    low?: string | undefined;
+                    medium?: string | undefined;
+                    high?: string | undefined;
+                    xhigh?: string | undefined;
+                } | undefined;
+                maxTokensField?: "max_completion_tokens" | "max_tokens" | undefined;
+                supportsUsageInStreaming?: boolean | undefined;
+                requiresToolResultName?: boolean | undefined;
+                requiresMistralToolIds?: boolean | undefined;
+                requiresAssistantAfterToolResult?: boolean | undefined;
+                requiresThinkingAsText?: boolean | undefined;
+                reasoningContentField?: "reasoning" | "reasoning_content" | "reasoning_text" | undefined;
+                requiresReasoningContentForToolCalls?: boolean | undefined;
+                allowsSyntheticReasoningContentForToolCalls?: boolean | undefined;
+                requiresAssistantContentForToolCalls?: boolean | undefined;
+                supportsToolChoice?: boolean | undefined;
+                disableReasoningOnForcedToolChoice?: boolean | undefined;
+                disableReasoningOnToolChoice?: boolean | undefined;
+                thinkingFormat?: "openai" | "openrouter" | "qwen" | "qwen-chat-template" | "zai" | undefined;
+                openRouterRouting?: {
+                    only?: string[] | undefined;
+                    order?: string[] | undefined;
+                } | undefined;
+                vercelGatewayRouting?: {
+                    only?: string[] | undefined;
+                    order?: string[] | undefined;
+                } | undefined;
+                extraBody?: Record<string, unknown> | undefined;
+                supportsStrictMode?: boolean | undefined;
+                toolStrictMode?: "all_strict" | "none" | undefined;
+            } | undefined;
+            contextPromotionTarget?: string | undefined;
+        }[] | undefined;
+        modelOverrides?: Record<string, {
+            name?: string | undefined;
+            reasoning?: boolean | undefined;
+            thinking?: {
+                minLevel: "high" | "low" | "medium" | "minimal" | "xhigh";
+                maxLevel: "high" | "low" | "medium" | "minimal" | "xhigh";
+                mode: "anthropic-adaptive" | "anthropic-budget-effort" | "budget" | "effort" | "google-level";
+                defaultLevel?: "high" | "low" | "medium" | "minimal" | "xhigh" | undefined;
+                levels?: ("high" | "low" | "medium" | "minimal" | "xhigh")[] | undefined;
+            } | undefined;
+            input?: ("image" | "text")[] | undefined;
+            cost?: {
+                input?: number | undefined;
+                output?: number | undefined;
+                cacheRead?: number | undefined;
+                cacheWrite?: number | undefined;
+            } | undefined;
+            premiumMultiplier?: number | undefined;
+            contextWindow?: number | undefined;
+            maxTokens?: number | undefined;
+            headers?: Record<string, string> | undefined;
+            compat?: {
+                supportsStore?: boolean | undefined;
+                supportsDeveloperRole?: boolean | undefined;
+                supportsMultipleSystemMessages?: boolean | undefined;
+                supportsReasoningEffort?: boolean | undefined;
+                reasoningEffortMap?: {
+                    minimal?: string | undefined;
+                    low?: string | undefined;
+                    medium?: string | undefined;
+                    high?: string | undefined;
+                    xhigh?: string | undefined;
+                } | undefined;
+                maxTokensField?: "max_completion_tokens" | "max_tokens" | undefined;
+                supportsUsageInStreaming?: boolean | undefined;
+                requiresToolResultName?: boolean | undefined;
+                requiresMistralToolIds?: boolean | undefined;
+                requiresAssistantAfterToolResult?: boolean | undefined;
+                requiresThinkingAsText?: boolean | undefined;
+                reasoningContentField?: "reasoning" | "reasoning_content" | "reasoning_text" | undefined;
+                requiresReasoningContentForToolCalls?: boolean | undefined;
+                allowsSyntheticReasoningContentForToolCalls?: boolean | undefined;
+                requiresAssistantContentForToolCalls?: boolean | undefined;
+                supportsToolChoice?: boolean | undefined;
+                disableReasoningOnForcedToolChoice?: boolean | undefined;
+                disableReasoningOnToolChoice?: boolean | undefined;
+                thinkingFormat?: "openai" | "openrouter" | "qwen" | "qwen-chat-template" | "zai" | undefined;
+                openRouterRouting?: {
+                    only?: string[] | undefined;
+                    order?: string[] | undefined;
+                } | undefined;
+                vercelGatewayRouting?: {
+                    only?: string[] | undefined;
+                    order?: string[] | undefined;
+                } | undefined;
+                extraBody?: Record<string, unknown> | undefined;
+                supportsStrictMode?: boolean | undefined;
+                toolStrictMode?: "all_strict" | "none" | undefined;
+            } | undefined;
+            contextPromotionTarget?: string | undefined;
+        }> | undefined;
+        disableStrictTools?: boolean | undefined;
+        transport?: "pi-native" | undefined;
+    }> | undefined;
+    equivalence?: {
+        overrides?: Record<string, string> | undefined;
+        exclude?: string[] | undefined;
+    } | undefined;
+}>;
+export type ProviderDiscoveryStatus = "idle" | "ok" | "empty" | "cached" | "unavailable" | "unauthenticated";
+export interface ProviderDiscoveryState {
+    provider: string;
+    status: ProviderDiscoveryStatus;
+    optional: boolean;
+    stale: boolean;
+    fetchedAt?: number;
+    models: string[];
+    error?: string;
+}
+export interface CanonicalModelQueryOptions {
+    availableOnly?: boolean;
+    candidates?: readonly Model<Api>[];
+}
+/**
+ * Model registry - loads and manages models, resolves API keys via AuthStorage.
+ */
+export declare class ModelRegistry {
+    #private;
+    readonly authStorage: AuthStorage;
+    /**
+     * @param authStorage - Auth storage for API key resolution
+     */
+    constructor(authStorage: AuthStorage, modelsPath?: string);
+    /**
+     * Reload models from disk (built-in + custom from models.json).
+     */
+    refresh(strategy?: ModelRefreshStrategy): Promise<void>;
+    refreshInBackground(strategy?: ModelRefreshStrategy): void;
+    refreshProvider(providerId: string, strategy?: ModelRefreshStrategy): Promise<void>;
+    /**
+     * Get any error from loading models.json (undefined if no error).
+     */
+    getError(): ConfigError | undefined;
+    /**
+     * Get all models (built-in + custom).
+     * If models.json had errors, returns only built-in models.
+     */
+    getAll(): Model<Api>[];
+    getCanonicalModels(options?: CanonicalModelQueryOptions): CanonicalModelRecord[];
+    getCanonicalVariants(canonicalId: string, options?: CanonicalModelQueryOptions): CanonicalModelVariant[];
+    resolveCanonicalModel(canonicalId: string, options?: CanonicalModelQueryOptions): Model<Api> | undefined;
+    getCanonicalId(model: Model<Api>): string | undefined;
+    /**
+     * Get only models that have auth configured.
+     * This is a fast check that doesn't refresh OAuth tokens.
+     */
+    getAvailable(): Model<Api>[];
+    /**
+     * Check whether auth is configured for a model's provider.
+     *
+     * Mirrors the upstream `@mariozechner/pi-coding-agent` API surface so that
+     * external plugins/extensions and downstream wrappers (e.g. subagent launch
+     * paths that pre-flight auth before model resolution) can probe a model
+     * without resolving an API key. Returns true for keyless providers as well
+     * as providers with stored credentials. See issue #993.
+     */
+    hasConfiguredAuth(model: Model<Api>): boolean;
+    getDiscoverableProviders(): string[];
+    getProviderDiscoveryState(provider: string): ProviderDiscoveryState | undefined;
+    /**
+     * Find a model by provider and ID.
+     */
+    find(provider: string, modelId: string): Model<Api> | undefined;
+    /**
+     * Get the base URL associated with a provider, if any model defines one.
+     */
+    getProviderBaseUrl(provider: string): string | undefined;
+    /**
+     * Get API key for a model.
+     */
+    getApiKey(model: Model<Api>, sessionId?: string): Promise<string | undefined>;
+    /**
+     * Get API key for a provider (e.g., "openai").
+     */
+    getApiKeyForProvider(provider: string, sessionId?: string, baseUrl?: string): Promise<string | undefined>;
+    /**
+     * Check if a model is using OAuth credentials (subscription).
+     */
+    isUsingOAuth(model: Model<Api>): boolean;
+    /**
+     * Remove custom API/OAuth registrations for a specific extension source.
+     */
+    clearSourceRegistrations(sourceId: string): void;
+    /**
+     * Remove registrations for extension sources that are no longer active.
+     */
+    syncExtensionSources(activeSourceIds: string[]): void;
+    /**
+     * Register a provider dynamically (from extensions).
+     *
+     * If provider has models: replaces all existing models for this provider.
+     * If provider has only baseUrl/headers: overrides existing models' URLs.
+     * If provider has streamSimple: registers a custom API streaming function.
+     * If provider has oauth: registers OAuth provider for /login support.
+     */
+    registerProvider(providerName: string, config: ProviderConfigInput, sourceId?: string): void;
+    /**
+     * Suppress a specific model selector (e.g., "provider/id") until a specific timestamp.
+     */
+    suppressSelector(selector: string, untilMs: number): void;
+    /**
+     * Check if a model selector is currently suppressed due to rate limits.
+     */
+    isSelectorSuppressed(selector: string): boolean;
+}
+/**
+ * Input type for registerProvider API (from extensions).
+ */
+export interface ProviderConfigInput {
+    baseUrl?: string;
+    apiKey?: string;
+    api?: Api;
+    streamSimple?: (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream;
+    headers?: Record<string, string>;
+    compat?: Model<Api>["compat"];
+    authHeader?: boolean;
+    /** Streaming transport override — see {@link Model.transport}. */
+    transport?: Model<Api>["transport"];
+    oauth?: {
+        name: string;
+        login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials | string>;
+        refreshToken?(credentials: OAuthCredentials): Promise<OAuthCredentials>;
+        getApiKey?(credentials: OAuthCredentials): string;
+        modifyModels?(models: Model<Api>[], credentials: OAuthCredentials): Model<Api>[];
+    };
+    models?: Array<{
+        id: string;
+        name: string;
+        api?: Api;
+        baseUrl?: string;
+        reasoning: boolean;
+        thinking?: ThinkingConfig;
+        input: ("text" | "image")[];
+        cost: {
+            input: number;
+            output: number;
+            cacheRead: number;
+            cacheWrite: number;
+        };
+        contextWindow: number;
+        maxTokens: number;
+        headers?: Record<string, string>;
+        compat?: Model<Api>["compat"];
+        contextPromotionTarget?: string;
+        premiumMultiplier?: number;
+    }>;
+}

package/dist/types/config/model-resolver.d.ts

@@ -0,0 +1,230 @@
+/**
+ * Model resolution, scoping, and initial selection
+ */
+import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import { type Api, type Effort, type KnownProvider, type Model } from "@oh-my-pi/pi-ai";
+import { type ModelRegistry, type ModelRole } from "./model-registry";
+import type { Settings } from "./settings";
+/** Default model IDs for each known provider */
+export declare const defaultModelPerProvider: Record<KnownProvider, string>;
+export interface ScopedModel {
+    model: Model<Api>;
+    thinkingLevel?: ThinkingLevel;
+    explicitThinkingLevel: boolean;
+}
+/**
+ * Parse a model string in "provider/modelId" format.
+ * Returns undefined if the format is invalid.
+ */
+export declare function parseModelString(modelStr: string): {
+    provider: string;
+    id: string;
+    thinkingLevel?: ThinkingLevel;
+} | undefined;
+/**
+ * Format a model as "provider/modelId" string.
+ */
+export declare function formatModelString(model: Model<Api>): string;
+export declare function formatModelSelectorValue(selector: string, thinkingLevel: ThinkingLevel | undefined): string;
+export declare function resolveProviderModelReference(provider: string, modelId: string, availableModels: readonly Model<Api>[]): Model<Api> | undefined;
+export interface ModelMatchPreferences {
+    /** Most-recently-used model keys (provider/modelId) to prefer when ambiguous. */
+    usageOrder?: string[];
+    /** Providers to deprioritize when no recent usage is available. */
+    deprioritizeProviders?: string[];
+}
+export type CanonicalModelRegistry = Partial<Pick<ModelRegistry, "resolveCanonicalModel" | "getCanonicalVariants" | "getCanonicalId">>;
+export type ModelLookupRegistry = Pick<ModelRegistry, "getAvailable"> & Partial<CanonicalModelRegistry>;
+type CliModelRegistry = Pick<ModelRegistry, "getAll"> & Partial<CanonicalModelRegistry>;
+type InitialModelRegistry = Pick<ModelRegistry, "getAvailable" | "find">;
+type RestorableModelRegistry = Pick<ModelRegistry, "getAvailable" | "find" | "getApiKey">;
+/**
+ * Find an exact explicit provider/model match.
+ * Bare model ids are handled separately so canonical ids can coalesce variants.
+ */
+export declare function findExactModelReferenceMatch(modelReference: string, availableModels: Model<Api>[]): Model<Api> | undefined;
+export interface ParsedModelResult {
+    model: Model<Api> | undefined;
+    /** Thinking level if explicitly specified in pattern, undefined otherwise */
+    thinkingLevel?: ThinkingLevel;
+    warning: string | undefined;
+    explicitThinkingLevel: boolean;
+}
+export declare function parseModelPattern(pattern: string, availableModels: Model<Api>[], preferences?: ModelMatchPreferences, options?: {
+    allowInvalidThinkingSelectorFallback?: boolean;
+    modelRegistry?: CanonicalModelRegistry;
+}): ParsedModelResult;
+/**
+ * Expand a role alias like "pi/smol" to the configured model string.
+ */
+export declare function expandRoleAlias(value: string, settings?: Settings): string;
+export declare function resolveConfiguredModelPatterns(value: string | string[] | undefined, settings?: Settings): string[];
+export interface AgentModelPatternResolutionOptions {
+    settingsOverride?: string | string[];
+    agentModel?: string | string[];
+    settings?: Settings;
+    activeModelPattern?: string;
+    fallbackModelPattern?: string;
+}
+export declare function resolveAgentModelPatterns(options: AgentModelPatternResolutionOptions): string[];
+/**
+ * Resolve a model role value into a concrete model and thinking metadata.
+ */
+export interface ResolvedModelRoleValue {
+    model: Model<Api> | undefined;
+    thinkingLevel?: ThinkingLevel;
+    explicitThinkingLevel: boolean;
+    warning: string | undefined;
+}
+export declare function resolveModelRoleValue(roleValue: string | undefined, availableModels: Model<Api>[], options?: {
+    settings?: Settings;
+    matchPreferences?: ModelMatchPreferences;
+    modelRegistry?: CanonicalModelRegistry;
+}): ResolvedModelRoleValue;
+export declare function extractExplicitThinkingSelector(value: string | undefined, settings?: Settings): ThinkingLevel | undefined;
+/**
+ * Resolve a model identifier or pattern to a Model instance.
+ */
+export declare function resolveModelFromString(value: string, available: Model<Api>[], matchPreferences?: ModelMatchPreferences, modelRegistry?: CanonicalModelRegistry): Model<Api> | undefined;
+/**
+ * Resolve a model from configured roles, honoring order and overrides.
+ */
+export declare function resolveModelFromSettings(options: {
+    settings: Settings;
+    availableModels: Model<Api>[];
+    matchPreferences?: ModelMatchPreferences;
+    roleOrder?: readonly ModelRole[];
+    modelRegistry?: CanonicalModelRegistry;
+}): Model<Api> | undefined;
+/**
+ * Resolve a list of override patterns to the first matching model.
+ */
+export declare function resolveModelOverride(modelPatterns: string[], modelRegistry: ModelLookupRegistry, settings?: Settings): {
+    model?: Model<Api>;
+    thinkingLevel?: ThinkingLevel;
+    explicitThinkingLevel: boolean;
+};
+/**
+ * Resolve a list of override patterns to the first matching model, with an
+ * auth-aware fallback to the parent session's active model.
+ *
+ * If the resolved subagent model has no working credentials (provider has no
+ * usable auth), and the parent's active model resolves with working auth,
+ * use the parent's model instead. This prevents subagent dispatch from
+ * silently routing to a provider the user can't actually call (e.g.
+ * `modelRoles.task` pointing at an unqualified id whose only available
+ * provider variant has no configured credentials — see #985).
+ *
+ * Keyless-by-design providers (llama.cpp, ollama, lm-studio) advertise the
+ * `kNoAuth` sentinel from `getApiKey` to signal that they do not require
+ * credentials. Those are treated as authenticated here so an explicitly
+ * configured local model is never silently rerouted to the parent's remote
+ * provider (see #1008).
+ *
+ * If neither the subagent nor the parent has working auth, returns the
+ * primary resolution unchanged so the existing error path still surfaces
+ * a meaningful failure downstream.
+ */
+export declare function resolveModelOverrideWithAuthFallback(modelPatterns: string[], parentActiveModelPattern: string | undefined, modelRegistry: ModelLookupRegistry & Pick<ModelRegistry, "getApiKey">, settings?: Settings): Promise<{
+    model?: Model<Api>;
+    thinkingLevel?: ThinkingLevel;
+    explicitThinkingLevel: boolean;
+    authFallbackUsed: boolean;
+}>;
+/**
+ * Resolve a list of role patterns to the first matching model.
+ */
+export declare function resolveRoleSelection(roles: readonly string[], settings: Settings, availableModels: Model<Api>[], modelRegistry?: CanonicalModelRegistry): {
+    model: Model<Api>;
+    thinkingLevel?: ThinkingLevel;
+} | undefined;
+/**
+ * Resolve model patterns to actual Model objects with optional thinking levels
+ * Format: "pattern:level" where :level is optional
+ * For each pattern, finds all matching models and picks the best version:
+ * 1. Prefer alias (e.g., claude-sonnet-4-5) over dated versions (claude-sonnet-4-5-20250929)
+ * 2. If no alias, pick the latest dated version
+ *
+ * Supports models with colons in their IDs (e.g., OpenRouter's model:exacto).
+ * The algorithm tries to match the full pattern first, then progressively
+ * strips colon-suffixes to find a match.
+ */
+export declare function resolveModelScope(patterns: string[], modelRegistry: Pick<ModelRegistry, "getAvailable" | "getCanonicalVariants">, preferences?: ModelMatchPreferences): Promise<ScopedModel[]>;
+/**
+ * Resolve the set of models a session is allowed to use, given the active
+ * settings. Starts from `modelRegistry.getAvailable()` (so disabled providers
+ * and providers without credentials are already filtered out) and, when
+ * `enabledModels` is configured for the current path scope, further restricts
+ * the result to models matching those patterns.
+ *
+ * Returns the unfiltered available list when `enabledModels` is empty.
+ * Returns an empty list when `enabledModels` is configured but no available
+ * model matches any pattern — callers MUST treat this as "no usable model"
+ * rather than falling back to the global default (see issue #1022).
+ */
+export declare function resolveAllowedModels(modelRegistry: Pick<ModelRegistry, "getAvailable" | "getCanonicalVariants">, settings: Settings | undefined, preferences?: ModelMatchPreferences): Promise<Model<Api>[]>;
+export interface ResolveCliModelResult {
+    model: Model<Api> | undefined;
+    selector?: string;
+    thinkingLevel?: ThinkingLevel;
+    warning: string | undefined;
+    error: string | undefined;
+}
+/**
+ * Resolve a single model from CLI flags.
+ */
+export declare function resolveCliModel(options: {
+    cliProvider?: string;
+    cliModel?: string;
+    modelRegistry: CliModelRegistry;
+    preferences?: ModelMatchPreferences;
+}): ResolveCliModelResult;
+export interface InitialModelResult {
+    model: Model<Api> | undefined;
+    thinkingLevel?: ThinkingLevel;
+    fallbackMessage: string | undefined;
+}
+/**
+ * Find the initial model to use based on priority:
+ * 1. CLI args (provider + model)
+ * 2. First model from scoped models (if not continuing/resuming)
+ * 3. Restored from session (if continuing/resuming)
+ * 4. Saved default from settings
+ * 5. First available model with valid API key
+ */
+export declare function findInitialModel(options: {
+    cliProvider?: string;
+    cliModel?: string;
+    scopedModels: ScopedModel[];
+    isContinuing: boolean;
+    defaultProvider?: string;
+    defaultModelId?: string;
+    defaultThinkingSelector?: Effort;
+    modelRegistry: InitialModelRegistry;
+}): Promise<InitialModelResult>;
+/**
+ * Restore model from session, with fallback to available models
+ */
+export declare function restoreModelFromSession(savedProvider: string, savedModelId: string, currentModel: Model<Api> | undefined, shouldPrintMessages: boolean, modelRegistry: RestorableModelRegistry): Promise<{
+    model: Model<Api> | undefined;
+    fallbackMessage: string | undefined;
+}>;
+/**
+ * Find a smol/fast model using the priority chain.
+ * Tries exact matches first, then fuzzy matches.
+ *
+ * @param modelRegistry The model registry to search
+ * @param savedModel Optional saved model string from settings (provider/modelId)
+ * @returns The best available smol model, or undefined if none found
+ */
+export declare function findSmolModel(modelRegistry: ModelLookupRegistry, savedModel?: string): Promise<Model<Api> | undefined>;
+/**
+ * Find a slow/comprehensive model using the priority chain.
+ * Prioritizes reasoning and codex models for thorough analysis.
+ *
+ * @param modelRegistry The model registry to search
+ * @param savedModel Optional saved model string from settings (provider/modelId)
+ * @returns The best available slow model, or undefined if none found
+ */
+export declare function findSlowModel(modelRegistry: ModelLookupRegistry, savedModel?: string): Promise<Model<Api> | undefined>;
+export {};