import { type AgentProviderId } from "./agent-provider-catalog.js";
export type AgentEngineProvider = AgentProviderId;
/**
 * Where a provider key is stored. `"user"` is the caller's personal key;
 * `"org"` is the active organization's (owners and admins only). A caller
 * with no organization always saves personally.
 */
export type AgentEngineKeyScope = "user" | "org";
export interface SaveAgentEngineApiKeyOptions {
    provider?: AgentEngineProvider;
    key?: string;
    apiKey: string;
    /** Defaults to `"user"`. */
    scope?: AgentEngineKeyScope;
}
export interface SaveAgentEngineProviderSettingsOptions {
    provider?: AgentEngineProvider;
    key?: string;
    apiKey?: string;
    baseUrl?: string;
    clearBaseUrl?: boolean;
    /** Defaults to `"user"`. Pass `"org"` only when the caller chose Organization. */
    scope?: AgentEngineKeyScope;
    /**
     * Also make this provider the default model in the same save when the
     * caller may change it (owners and admins; a user with no organization).
     * Otherwise only the key is saved. `engine` defaults to the provider's.
     */
    defaultModel?: {
        engine?: string;
        model?: string;
    };
}
export interface SavedAgentEngineSelection {
    engine: string;
    model: string;
}
/**
 * What a key save did to the default model. `skipped` means only the key was
 * saved: the caller can't change the default, or saved a personal key.
 */
export type AgentEngineDefaultModelOutcome = {
    status: "selected";
    engine: string;
    model: string;
} | {
    status: "skipped";
    reason: "not-allowed" | "personal-key";
} | {
    status: "failed";
    error: string;
};
export interface SaveAgentEngineProviderSettingsResult {
    /** Present only when `defaultModel` was requested. */
    defaultModel?: AgentEngineDefaultModelOutcome;
}
export interface AgentEngineProviderKeyStatus {
    /** `"invalid"`: the provider rejected the key in effect (see `rejectedAt`). */
    status: "set" | "unset" | "invalid" | "unknown";
    /** When the provider last rejected the key in effect (ms). */
    rejectedAt?: number;
    effectiveScope?: "user" | "org" | "workspace" | "env";
    overriddenScope?: "org" | "workspace";
    personalKeyPresent: boolean;
    organizationKeyPresent: boolean;
}
export declare function getAgentEngineProviderKeyStatus(provider: AgentEngineProvider): Promise<AgentEngineProviderKeyStatus>;
export declare function deleteAgentEnginePersonalProviderSettings(provider: AgentEngineProvider): Promise<void>;
/**
 * Remove a provider's stored key (and OpenAI's endpoint override) at one
 * scope. Removing an organization key needs owner or admin; the server
 * refuses anyone else.
 */
export declare function deleteAgentEngineProviderSettings({ provider, scope, }: {
    provider: AgentEngineProvider;
    /** Defaults to `"user"`. */
    scope?: AgentEngineKeyScope;
}): Promise<void>;
export declare function saveAgentEngineApiKey({ provider, key, apiKey, scope, }: SaveAgentEngineApiKeyOptions): Promise<void>;
export declare function saveAgentEngineProviderSettings({ provider, key, apiKey, baseUrl, clearBaseUrl, scope, defaultModel, }: SaveAgentEngineProviderSettingsOptions): Promise<SaveAgentEngineProviderSettingsResult>;
export declare function fetchOllamaModels(baseUrl?: string): Promise<string[]>;
export type ProviderModelsCheckCode = "rejected" | "wrong-provider" | "missing-key" | "invalid-endpoint" | "unreachable" | "provider-error";
/**
 * A provider's answer about a key. `ok: false` is a verdict (the key or
 * endpoint didn't work), not a transport failure; those throw.
 */
export type ProviderModelsCheck = {
    ok: true;
    provider: AgentEngineProvider;
    models: string[];
    /** More models existed than one check reads. */
    truncated?: boolean;
    checkedAt: number;
} | {
    ok: false;
    provider: AgentEngineProvider;
    models: [];
    code: ProviderModelsCheckCode;
    /** English reason; localize from `code` and the fields below. */
    reason: string;
    status?: number;
    expectedPrefix?: string;
    detectedProvider?: AgentEngineProvider;
    checkedAt: number;
};
export interface FetchProviderModelsOptions {
    provider: AgentEngineProvider;
    /** A pasted key. Omit to check the saved key. */
    key?: string;
    /**
     * OpenAI-compatible gateway or Ollama endpoint. Omit to use the saved one.
     * Needs `key` (except for Ollama): a saved key is only checked against its
     * saved endpoint, and the server answers 400 otherwise.
     */
    baseUrl?: string;
    /** Which saved key to check when `key` is omitted. `org` is owners/admins. */
    scope?: AgentEngineKeyScope;
}
/**
 * Check a provider key by asking the provider which models it reaches, through
 * the `check-provider-key` action. The same list fills the model checklist.
 * Omit `key` to check the saved key ("Check again"). Resolves with the
 * provider's verdict, including rejections; throws a readable Error only when
 * the check itself couldn't run (signed out, malformed request, server
 * unreachable).
 */
export declare function fetchProviderModels({ provider, key, baseUrl, scope, }: FetchProviderModelsOptions): Promise<ProviderModelsCheck>;
/**
 * Make a provider and model the default model (the organization's, or a
 * no-organization user's own). Only owners and admins may change an
 * organization's default; for anyone else this throws the server's refusal.
 * To save a key and select its provider in one step, pass `defaultModel` to
 * {@link saveAgentEngineProviderSettings} instead.
 */
export declare function setAgentEngineProvider({ provider, model, }: {
    provider: AgentEngineProvider;
    model?: string;
}): Promise<SavedAgentEngineSelection>;
/**
 * {@link setAgentEngineProvider} for any engine, Builder.io included. Throws
 * the server's refusal for anyone who may not change the default.
 */
export declare function setAgentEngineDefaultModel({ engine, model, label, }: {
    engine: string;
    model?: string;
    /** Names the engine in the fallback error. */
    label?: string;
}): Promise<SavedAgentEngineSelection>;