opencandle 0.11.1 → 0.13.0

package/dist/gui/server/market-state-api.js

@@ -0,0 +1,597 @@
+import { buildFreshnessStamp } from "../../infra/freshness.js";
+import { isZeroFilledQuote, searchYahooInstruments } from "../../market-state/resolve.js";
+import { MarketStateService } from "../../market-state/service.js";
+import { initDefaultDatabase } from "../../memory/sqlite.js";
+import { getProvider } from "../../onboarding/providers.js";
+import { wrapProvider } from "../../providers/wrap-provider.js";
+import { getHistory, getQuote, getYahooCompanyOverview, } from "../../providers/yahoo-finance.js";
+import { fetchHistoryWithFallback, HISTORY_INTERVALS, } from "../../tools/market/stock-history.js";
+import { HistorySnapshotStore } from "./history-snapshot-store.js";
+const instrumentHistorySnapshotStore = new HistorySnapshotStore();
+const DEFAULT_HISTORY_RANGE_MAP = {
+    "1D": { range: "1d", interval: "5m" },
+    "5D": { range: "5d", interval: "15m" },
+    "1M": { range: "1mo", interval: "1h" },
+    "6M": { range: "6mo", interval: "1d" },
+    YTD: { range: "ytd", interval: "1d" },
+    "1Y": { range: "1y", interval: "1d" },
+    "5Y": { range: "5y", interval: "1wk" },
+    MAX: { range: "max", interval: "1mo" },
+};
+const HISTORY_RANGE_SPAN_DAYS = {
+    "1D": 1,
+    "5D": 5,
+    "1M": 31,
+    "6M": 183,
+    YTD: 366,
+    "1Y": 366,
+    "5Y": 1_827,
+    MAX: Number.POSITIVE_INFINITY,
+};
+const INTRADAY_DEPTH_CAP_DAYS = {
+    "1m": 7,
+    "5m": 60,
+    "15m": 60,
+    "1h": 730,
+};
+const DAILY_OR_LONGER_INTERVALS = new Set(["1d", "1wk", "1mo"]);
+const HISTORY_PROVIDER_REGISTRY_IDS = {
+    yahoo: "yahoo",
+    alphavantage: "alpha_vantage",
+    lse: "lse",
+};
+function historyProviderDisplayName(provider) {
+    if (!(provider && provider in HISTORY_PROVIDER_REGISTRY_IDS))
+        return null;
+    const providerId = HISTORY_PROVIDER_REGISTRY_IDS[provider];
+    return getProvider(providerId).displayName;
+}
+export function resolveHistoryRange(rangeLabel, intervalOverride) {
+    const resolved = DEFAULT_HISTORY_RANGE_MAP[rangeLabel];
+    if (!resolved) {
+        return { status: "invalid_request", reason: `Unknown history range: ${rangeLabel}` };
+    }
+    if (intervalOverride === undefined)
+        return resolved;
+    if (!isHistoryInterval(intervalOverride)) {
+        return { status: "invalid_request", reason: `Unknown history interval: ${intervalOverride}` };
+    }
+    const depthCapDays = INTRADAY_DEPTH_CAP_DAYS[intervalOverride];
+    if (depthCapDays !== undefined &&
+        HISTORY_RANGE_SPAN_DAYS[rangeLabel] > depthCapDays) {
+        return {
+            status: "invalid_request",
+            reason: `History range ${rangeLabel} exceeds the depth cap for interval ${intervalOverride}`,
+        };
+    }
+    return { range: resolved.range, interval: intervalOverride };
+}
+function isHistoryInterval(value) {
+    return HISTORY_INTERVALS.includes(value);
+}
+export async function getInstrumentHistorySnapshot(symbol, rangeLabel = "1D", intervalOverride) {
+    const resolved = resolveHistoryRange(rangeLabel, intervalOverride);
+    if ("status" in resolved)
+        return resolved;
+    const key = `${symbol}|${resolved.range}|${resolved.interval}`;
+    return instrumentHistorySnapshotStore.get(key, async () => {
+        const result = await fetchHistoryWithFallback(symbol, resolved.range, resolved.interval);
+        if (result.status === "unavailable") {
+            return { status: "unavailable", reason: result.reason };
+        }
+        const source = historyProviderDisplayName(result.provider);
+        if (source === null) {
+            return { status: "unavailable", reason: "History provider attribution is unavailable" };
+        }
+        const bars = result.data.filter((bar) => Number.isFinite(bar.close));
+        const dataAsOf = bars.at(-1)?.date;
+        const chartBars = [];
+        for (const bar of bars) {
+            let time = bar.timestamp;
+            if (typeof time !== "number" || !Number.isFinite(time)) {
+                if (DAILY_OR_LONGER_INTERVALS.has(resolved.interval)) {
+                    time = Date.parse(`${bar.date}T00:00:00Z`) / 1_000;
+                }
+                if (typeof time !== "number" || !Number.isFinite(time)) {
+                    return {
+                        status: "unavailable",
+                        reason: `Historical bars for ${resolved.interval} are missing finite timestamps`,
+                        dataAsOf,
+                        stale: result.stale === true || undefined,
+                    };
+                }
+            }
+            chartBars.push({
+                time,
+                open: bar.open,
+                high: bar.high,
+                low: bar.low,
+                close: bar.close,
+                volume: bar.volume,
+            });
+        }
+        // Design D3: daily+ bars can honestly derive the previous close from the prior bar.
+        const prevClose = DAILY_OR_LONGER_INTERVALS.has(resolved.interval) && bars.length >= 2
+            ? bars[bars.length - 2].close
+            : null;
+        return {
+            status: "ok",
+            symbol,
+            range: rangeLabel,
+            interval: resolved.interval,
+            source,
+            fetchedAt: result.timestamp,
+            dataAsOf,
+            stale: result.stale === true,
+            prevClose,
+            bars: chartBars,
+        };
+    });
+}
+export function resetInstrumentHistoryMemoForTests() {
+    instrumentHistorySnapshotStore.clear();
+}
+export function createSavedSymbolsMemo(load, options = {}) {
+    const ttlMs = options.ttlMs ?? 30_000;
+    const now = options.now ?? Date.now;
+    let cachedAt = 0;
+    let cached = null;
+    return () => {
+        const current = now();
+        if (cached && current - cachedAt < ttlMs)
+            return cached;
+        cached = load();
+        cachedAt = current;
+        return cached;
+    };
+}
+export const getSavedMarketStateSymbols = createSavedSymbolsMemo(loadSavedMarketStateSymbols);
+export function buildMarketStateSnapshot(db) {
+    const ownedDb = db ?? initDefaultDatabase();
+    const service = new MarketStateService(ownedDb);
+    try {
+        const alerts = service.listAlertRules();
+        const instrumentIds = [
+            ...new Set(alerts.map((rule) => rule.instrumentId).filter((id) => id != null)),
+        ];
+        const watchlists = service.listWatchlists();
+        const portfolios = service.listPortfolios();
+        return {
+            instruments: instrumentIds
+                .map((id) => service.getInstrument(id))
+                .filter((instrument) => instrument != null),
+            watchlists,
+            portfolios,
+            watchlist: watchlists.flatMap((watchlist) => service.listWatchlistItems(watchlist.id)),
+            portfolio: portfolios.flatMap((portfolio) => service.listPortfolioLots(portfolio.id)),
+            alerts,
+            alertEvents: service.listAlertEvents(),
+            alertCheckRuns: service.listAlertCheckRuns(),
+            reportTemplates: service.listReportTemplates(),
+            reportRuns: service.listReportRuns(),
+            runnerLease: service.getAutomationRunnerLease(),
+            notifications: service.listNotificationEvents(),
+            notificationDeliveryAttempts: service.listNotificationDeliveryAttempts(),
+        };
+    }
+    finally {
+        if (!db)
+            ownedDb.close();
+    }
+}
+function loadSavedMarketStateSymbols() {
+    const db = initDefaultDatabase();
+    const service = new MarketStateService(db);
+    try {
+        const symbols = [
+            ...service
+                .listWatchlists()
+                .flatMap((watchlist) => service.listWatchlistItems(watchlist.id).map((item) => item.symbol)),
+            ...service
+                .listPortfolios()
+                .flatMap((portfolio) => service.listPortfolioLots(portfolio.id).map((lot) => lot.symbol)),
+        ];
+        return normalizeSymbols(symbols);
+    }
+    finally {
+        db.close();
+    }
+}
+function normalizeSymbols(symbols) {
+    const normalized = [];
+    for (const symbol of symbols) {
+        const next = symbol.trim().toUpperCase();
+        if (!next || normalized.includes(next))
+            continue;
+        normalized.push(next);
+    }
+    return normalized;
+}
+export async function buildMarketStateQuoteSnapshot(db) {
+    const ownedDb = db ?? initDefaultDatabase();
+    const service = new MarketStateService(ownedDb);
+    try {
+        const watchlist = service
+            .listWatchlists()
+            .flatMap((watchlist) => service.listWatchlistItems(watchlist.id));
+        const portfolios = service.listPortfolios();
+        const portfolioLots = portfolios.flatMap((portfolio) => service.listPortfolioLots(portfolio.id));
+        const symbols = [
+            ...new Set([
+                ...watchlist.map((item) => item.symbol),
+                ...portfolioLots.map((lot) => lot.symbol),
+            ]),
+        ];
+        const quoteMap = new Map();
+        const sparklineMap = new Map();
+        for (const symbol of symbols) {
+            const quote = await fetchQuoteSnapshot(symbol);
+            quoteMap.set(symbol, quote);
+            sparklineMap.set(symbol, quote.status === "ok"
+                ? await fetchSparklineSnapshot(symbol)
+                : unavailableSparkline(quote.reason));
+        }
+        const generatedAt = new Date().toISOString();
+        const watchlistQuotes = watchlist.map((item) => {
+            const quote = quoteMap.get(item.symbol);
+            if (quote == null || quote.status === "unavailable") {
+                return {
+                    itemId: item.id,
+                    instrumentId: item.instrumentId,
+                    symbol: item.symbol,
+                    status: "unavailable",
+                    reason: quote?.reason ?? "quote unavailable",
+                    sparkline: sparklineMap.get(item.symbol) ?? unavailableSparkline("History unavailable"),
+                };
+            }
+            return {
+                itemId: item.id,
+                instrumentId: item.instrumentId,
+                symbol: item.symbol,
+                name: quote.name,
+                status: "ok",
+                price: quote.price,
+                change: quote.change,
+                changePercent: quote.changePercent,
+                volume: quote.volume,
+                dayHigh: quote.high,
+                dayLow: quote.low,
+                week52High: quote.week52High,
+                week52Low: quote.week52Low,
+                currency: quote.currency,
+                fetchedAt: quote.fetchedAt,
+                dataAsOf: quote.dataAsOf,
+                marketState: quote.marketState,
+                extendedPrice: quote.extendedPrice,
+                extendedChange: quote.extendedChange,
+                extendedChangePercent: quote.extendedChangePercent,
+                extendedAsOf: quote.extendedAsOf,
+                stale: quote.stale,
+                sparkline: sparklineMap.get(item.symbol) ?? unavailableSparkline("History unavailable"),
+            };
+        });
+        const portfolioResults = portfolios.map((portfolio) => buildPortfolioQuoteResult({
+            portfolio,
+            lots: portfolioLots.filter((lot) => lot.portfolioId === portfolio.id),
+            quoteMap,
+            sparklineMap,
+        }));
+        const defaultPortfolio = portfolios.find((portfolio) => portfolio.isDefault) ?? portfolios[0];
+        const defaultResult = portfolioResults.find((result) => result.summary.portfolioId === defaultPortfolio.id) ??
+            portfolioResults[0];
+        return {
+            generatedAt,
+            watchlistQuotes,
+            portfolioQuotes: portfolioResults.flatMap((result) => result.quotes),
+            portfolioSummary: defaultResult.summary,
+            portfolioSummaries: portfolioResults.map((result) => result.summary),
+        };
+    }
+    finally {
+        if (!db)
+            ownedDb.close();
+    }
+}
+function buildPortfolioQuoteResult({ portfolio, lots, quoteMap, sparklineMap, }) {
+    const baseCurrency = portfolio.baseCurrency ?? "USD";
+    const portfolioQuotes = lots.map((lot) => {
+        const quote = quoteMap.get(lot.symbol);
+        const lotCurrency = lot.currency || baseCurrency;
+        const quoteCurrency = lot.instrumentCurrency || lotCurrency;
+        const includedInTotals = lotCurrency === baseCurrency && quoteCurrency === baseCurrency;
+        const totalCost = lot.avgCost * lot.quantity;
+        if (quote == null || quote.status === "unavailable") {
+            return {
+                lotId: lot.id,
+                portfolioId: lot.portfolioId,
+                instrumentId: lot.instrumentId,
+                symbol: lot.symbol,
+                name: quote.name,
+                status: "unavailable",
+                totalCost,
+                currency: lotCurrency,
+                includedInTotals: false,
+                reason: quote?.reason ?? "quote unavailable",
+                sparkline: sparklineMap.get(lot.symbol) ?? unavailableSparkline("History unavailable"),
+            };
+        }
+        const resolvedQuoteCurrency = quote.currency ?? quoteCurrency;
+        if (resolvedQuoteCurrency !== lotCurrency) {
+            return {
+                lotId: lot.id,
+                portfolioId: lot.portfolioId,
+                instrumentId: lot.instrumentId,
+                symbol: lot.symbol,
+                status: "unavailable",
+                currentPrice: null,
+                marketValue: null,
+                totalCost,
+                pnl: null,
+                pnlPercent: null,
+                currency: lotCurrency,
+                includedInTotals: false,
+                reason: `No FX conversion from ${resolvedQuoteCurrency} to ${lotCurrency}`,
+                fetchedAt: quote.fetchedAt,
+                dataAsOf: quote.dataAsOf,
+                marketState: quote.marketState,
+                extendedPrice: quote.extendedPrice,
+                extendedChange: quote.extendedChange,
+                extendedChangePercent: quote.extendedChangePercent,
+                extendedAsOf: quote.extendedAsOf,
+                stale: quote.stale,
+                sparkline: sparklineMap.get(lot.symbol) ?? unavailableSparkline("History unavailable"),
+            };
+        }
+        const marketValue = quote.price * lot.quantity;
+        return {
+            lotId: lot.id,
+            portfolioId: lot.portfolioId,
+            instrumentId: lot.instrumentId,
+            symbol: lot.symbol,
+            name: quote.name,
+            status: "ok",
+            currentPrice: quote.price,
+            changePercent: quote.changePercent,
+            marketValue,
+            totalCost,
+            pnl: marketValue - totalCost,
+            pnlPercent: totalCost > 0 ? ((marketValue - totalCost) / totalCost) * 100 : 0,
+            currency: lotCurrency,
+            includedInTotals,
+            fetchedAt: quote.fetchedAt,
+            dataAsOf: quote.dataAsOf,
+            marketState: quote.marketState,
+            extendedPrice: quote.extendedPrice,
+            extendedChange: quote.extendedChange,
+            extendedChangePercent: quote.extendedChangePercent,
+            extendedAsOf: quote.extendedAsOf,
+            stale: quote.stale,
+            sparkline: sparklineMap.get(lot.symbol) ?? unavailableSparkline("History unavailable"),
+            reason: includedInTotals
+                ? undefined
+                : `No FX conversion from ${lotCurrency === baseCurrency ? quoteCurrency : lotCurrency} to ${baseCurrency}`,
+        };
+    });
+    const included = portfolioQuotes.filter((quote) => quote.status === "ok" && quote.includedInTotals);
+    const totalValue = included.reduce((sum, quote) => sum + (quote.marketValue ?? 0), 0);
+    const totalCost = included.reduce((sum, quote) => sum + quote.totalCost, 0);
+    const quotes = portfolioQuotes.map((quote) => {
+        if (quote.status !== "ok" || !quote.includedInTotals || totalValue <= 0)
+            return quote;
+        return {
+            ...quote,
+            allocationPercent: ((quote.marketValue ?? 0) / totalValue) * 100,
+        };
+    });
+    const excludedFromTotals = quotes
+        .filter((quote) => quote.status !== "ok" || !quote.includedInTotals)
+        .map((quote) => ({
+        symbol: quote.symbol,
+        currency: quote.currency,
+        reason: quote.reason ?? "quote unavailable",
+    }));
+    return {
+        quotes,
+        summary: {
+            portfolioId: portfolio.id,
+            baseCurrency,
+            totalValue,
+            totalCost,
+            totalPnl: totalValue - totalCost,
+            totalPnlPercent: totalCost > 0 ? ((totalValue - totalCost) / totalCost) * 100 : 0,
+            excludedFromTotals,
+        },
+    };
+}
+export async function fetchSparklineSnapshot(symbol) {
+    const result = await wrapProvider("yahoo", () => getHistory(symbol, "1d", "5m"));
+    if (result.status === "unavailable")
+        return unavailableSparkline(result.reason);
+    const bars = result.data.filter((bar) => Number.isFinite(bar.close));
+    const dataAsOf = bars.at(-1)?.date;
+    if (result.stale) {
+        return unavailableSparkline("Historical data is stale", dataAsOf, true);
+    }
+    if (bars.length < 2) {
+        return unavailableSparkline("Not enough intraday history", dataAsOf);
+    }
+    return {
+        status: "ok",
+        source: "Yahoo Finance",
+        points: bars.map((bar) => bar.close),
+        fetchedAt: result.timestamp,
+        dataAsOf,
+        stale: false,
+    };
+}
+function unavailableSparkline(reason, dataAsOf, stale) {
+    return {
+        status: "unavailable",
+        source: "Yahoo Finance",
+        reason,
+        dataAsOf,
+        stale,
+    };
+}
+export async function searchInstrumentCandidates(query) {
+    const trimmed = query.trim();
+    if (!trimmed)
+        return { query: "", candidates: [] };
+    try {
+        return {
+            query: trimmed,
+            candidates: await searchYahooInstruments(trimmed),
+        };
+    }
+    catch (err) {
+        return {
+            query: trimmed,
+            candidates: [],
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export async function getInstrumentQuoteSnapshot(symbol) {
+    const normalized = symbol.trim().toUpperCase();
+    if (!normalized)
+        return { symbol: "", status: "unavailable", reason: "symbol is required" };
+    const quote = await fetchQuoteSnapshot(normalized);
+    if (quote.status === "unavailable")
+        return { symbol: normalized, ...quote };
+    return {
+        symbol: normalized,
+        status: quote.status,
+        name: quote.name,
+        price: quote.price,
+        change: quote.change,
+        changePercent: quote.changePercent,
+        volume: quote.volume,
+        high: quote.high,
+        low: quote.low,
+        week52High: quote.week52High,
+        week52Low: quote.week52Low,
+        marketCap: quote.marketCap,
+        fetchedAt: quote.fetchedAt,
+        dataAsOf: quote.dataAsOf,
+        marketState: quote.marketState,
+        extendedPrice: quote.extendedPrice,
+        extendedChange: quote.extendedChange,
+        extendedChangePercent: quote.extendedChangePercent,
+        extendedAsOf: quote.extendedAsOf,
+        stale: quote.stale,
+        currency: quote.currency,
+    };
+}
+const INSTRUMENT_OVERVIEW_TTL_MS = 5 * 60_000;
+const instrumentOverviewMemo = new Map();
+export async function getInstrumentOverviewSnapshot(symbol) {
+    const normalized = symbol.trim().toUpperCase();
+    if (!normalized)
+        return { symbol: "", status: "unavailable", reason: "symbol is required" };
+    const existing = instrumentOverviewMemo.get(normalized);
+    if (existing?.snapshot && Date.now() - existing.fetchedAtMs < INSTRUMENT_OVERVIEW_TTL_MS) {
+        return existing.snapshot;
+    }
+    if (existing?.snapshot) {
+        if (!existing.inFlight)
+            refreshInstrumentOverview(normalized, existing).catch(() => { });
+        return existing.snapshot.status === "ok"
+            ? { ...existing.snapshot, stale: true }
+            : existing.snapshot;
+    }
+    if (existing?.inFlight)
+        return existing.inFlight;
+    const entry = existing ?? { snapshot: null, fetchedAtMs: 0, inFlight: null };
+    return refreshInstrumentOverview(normalized, entry);
+}
+function refreshInstrumentOverview(normalized, entry) {
+    if (entry.inFlight)
+        return entry.inFlight;
+    const inFlight = loadInstrumentOverviewSnapshot(normalized)
+        .then((snapshot) => {
+        if (entry.snapshot?.status === "ok" && snapshot.status === "unavailable") {
+            return entry.snapshot;
+        }
+        entry.snapshot = snapshot;
+        entry.fetchedAtMs = Date.now();
+        return snapshot;
+    })
+        .finally(() => {
+        if (entry.inFlight === inFlight)
+            entry.inFlight = null;
+    });
+    entry.inFlight = inFlight;
+    instrumentOverviewMemo.set(normalized, entry);
+    return inFlight;
+}
+async function loadInstrumentOverviewSnapshot(normalized) {
+    const result = await wrapProvider("yahoo", () => getYahooCompanyOverview(normalized));
+    if (result.status === "unavailable") {
+        return { symbol: normalized, status: "unavailable", reason: result.reason };
+    }
+    return {
+        symbol: normalized,
+        status: "ok",
+        name: result.data.name,
+        description: result.data.description,
+        exchange: result.data.exchange,
+        sector: result.data.sector,
+        industry: result.data.industry,
+        marketCap: result.data.marketCap,
+        pe: result.data.pe,
+        forwardPe: result.data.forwardPe,
+        eps: result.data.eps,
+        dividendYield: result.data.dividendYield,
+        beta: result.data.beta,
+        avgVolume: result.data.avgVolume,
+        profitMargin: result.data.profitMargin,
+        revenueGrowth: result.data.revenueGrowth,
+        week52High: result.data.week52High,
+        week52Low: result.data.week52Low,
+        stale: result.stale === true,
+    };
+}
+export function resetInstrumentOverviewMemoForTests() {
+    instrumentOverviewMemo.clear();
+}
+export async function fetchQuoteSnapshot(symbol) {
+    const result = await wrapProvider("yahoo", () => getQuote(symbol));
+    if (result.status === "unavailable")
+        return { status: "unavailable", reason: result.reason };
+    if (result.stale)
+        return { status: "unavailable", reason: "provider returned stale market data" };
+    if (isZeroFilledQuote(result.data)) {
+        return { status: "unavailable", reason: "Yahoo returned no valid market data." };
+    }
+    const freshness = buildFreshnessStamp({
+        asOf: result.data.asOf,
+        cached: result.cached,
+        stale: result.stale,
+        cachedAt: result.timestamp,
+    });
+    if (freshness.isStaleForSession) {
+        return { status: "unavailable", reason: "provider returned stale market data" };
+    }
+    return {
+        status: "ok",
+        name: result.data.name,
+        price: result.data.price,
+        change: result.data.change,
+        changePercent: result.data.changePercent,
+        volume: result.data.volume,
+        high: result.data.high,
+        low: result.data.low,
+        week52High: result.data.week52High,
+        week52Low: result.data.week52Low,
+        marketCap: result.data.marketCap,
+        fetchedAt: result.timestamp,
+        dataAsOf: freshness.providerDataAt,
+        marketState: result.data.marketState,
+        extendedPrice: result.data.extendedPrice,
+        extendedChange: result.data.extendedChange,
+        extendedChangePercent: result.data.extendedChangePercent,
+        extendedAsOf: result.data.extendedAsOf,
+        stale: Boolean(result.stale),
+        currency: result.data.currency ?? null,
+    };
+}

package/dist/gui/server/model-setup.d.ts

@@ -0,0 +1,55 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { type ModelRuntime } from "@earendil-works/pi-coding-agent";
+export type ModelSetupRequirement = "ready" | "select_model" | "connect_auth";
+export interface ModelSetupProvider {
+    id: string;
+    label: string;
+    envVar: string;
+    defaultProvider: string;
+    defaultModel: string;
+    signupUrl: string;
+}
+export interface ModelSetupState {
+    requirement: ModelSetupRequirement;
+    currentModel?: string;
+    providers: ModelSetupProvider[];
+    availableModels: Array<{
+        provider: string;
+        id: string;
+        label: string;
+    }>;
+}
+export interface ModelSetupRegistry {
+    refresh(): void;
+    getAvailable(): Model<Api>[];
+    hasConfiguredAuth(model: Model<Api>): boolean;
+}
+interface ModelSetupSession {
+    modelRuntime: ModelRuntime;
+    model?: Model<Api>;
+    setModel(model: Model<Api>): Promise<void>;
+    settingsManager: {
+        flush(): Promise<void>;
+    };
+}
+interface ModelSetupSessionManager {
+    appendCustomMessageEntry(customType: string, content: string, isActive: boolean, data: Record<string, unknown>): void;
+}
+export interface ModelSetupController {
+    buildCurrentModelSetupState(): ModelSetupState;
+    handleSaveModelApiKey(providerId: string, apiKey: string): Promise<void>;
+    handleSaveProviderApiKey(providerId: string, apiKey: string): Promise<void>;
+    handleSelectModel(provider: string, modelId: string): Promise<void>;
+}
+export interface ModelSetupControllerOptions {
+    role: string;
+    getSession: () => ModelSetupSession;
+    getSessionManager: () => ModelSetupSessionManager;
+    broadcastState: () => void;
+}
+export declare const modelSetupProviders: ModelSetupProvider[];
+export declare function buildModelSetupState(registry: ModelSetupRegistry, currentModel: Model<Api> | undefined): ModelSetupState;
+export declare function findPreferredModel(registry: Pick<ModelSetupRegistry, "getAvailable">, provider: ModelSetupProvider): Model<Api> | undefined;
+export declare function sortModels(models: Model<Api>[], preferredProvider?: string): Model<Api>[];
+export declare function createModelSetupController({ role, getSession, getSessionManager, broadcastState, }: ModelSetupControllerOptions): ModelSetupController;
+export {};