@bubblebrain-ai/bubble 0.0.58 → 0.0.60

package/dist/provider-error-record.js

@@ -1,6 +1,10 @@
 import { getCurrentVersion } from "./update/index.js";
 const MAX_FIELD_CHARS = 160;
 const RUNTIME_STARTED_AT = Date.now();
+const TRANSPORT_ERROR_CODES = new Set([
+    "UND_ERR_SOCKET", "UND_ERR_CONNECT_TIMEOUT", "UND_ERR_HEADERS_TIMEOUT", "UND_ERR_BODY_TIMEOUT",
+    "ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT", "ENOTFOUND", "EAI_AGAIN",
+]);
 const SAFE_ERROR_CODES = new Map([
     ["authentication_error", "authentication_error"],
     ["bad_request", "bad_request"],
@@ -8,6 +12,7 @@ const SAFE_ERROR_CODES = new Map([
     ["failed_precondition", "failed_precondition"],
     ["internal_error", "internal_error"],
     ["invalid_argument", "invalid_argument"],
+    ["invalid_request_error", "invalid_request_error"],
     ["invalidparameter", "invalid_parameter"],
     ["invalid_parameter", "invalid_parameter"],
     ["location_not_supported", "location_not_supported"],
@@ -20,6 +25,7 @@ const SAFE_ERROR_CODES = new Map([
     ["unauthenticated", "unauthenticated"],
     ["unsupported_parameter", "unsupported_parameter"],
     ["unsupported_value", "unsupported_value"],
+    ...Array.from(TRANSPORT_ERROR_CODES, (code) => [code.toLowerCase(), code]),
 ]);
 const SAFE_PARAMETER_NAMES = new Set([
     "contents",
@@ -59,7 +65,8 @@ export function createSanitizedProviderError(error, context) {
     const rawMessage = firstString(sources, ["message"])
         || (typeof error === "string" ? error : "Provider request failed.");
     const httpStatus = firstHttpStatus(sources);
-    const code = sanitizeErrorCode(firstScalarString(sources, ["code", "errorCode", "type"]));
+    // A wrapper's unknown code must not hide an allowlisted nested transport code.
+    const code = sources.flatMap((source) => ["code", "errorCode", "type"].map((key) => typeof source[key] === "string" ? sanitizeErrorCode(source[key]) : undefined)).find((value) => value !== undefined);
     const parameter = sanitizeParameterName(firstScalarString(sources, ["param", "parameter"]));
     return {
         providerId: sanitizeControlledIdentifier(context.providerId),
@@ -67,17 +74,37 @@ export function createSanitizedProviderError(error, context) {
         ...(context.model ? { model: sanitizeControlledIdentifier(context.model) } : {}),
         thinkingLevel: context.thinkingLevel,
         name: "ProviderError",
-        message: sanitizeProviderErrorText(rawMessage),
+        message: code && TRANSPORT_ERROR_CODES.has(code)
+            ? code.includes("TIMEOUT") || code === "ETIMEDOUT" ? "Provider request timed out." : "Provider connection failed."
+            : sanitizeProviderErrorText(rawMessage),
         ...(httpStatus !== undefined ? { httpStatus } : {}),
         ...(code ? { code } : {}),
         ...(parameter ? { parameter } : {}),
         messageCount: Math.max(0, Math.trunc(context.messageCount)),
         toolCount: Math.max(0, Math.trunc(context.toolCount)),
+        ...sanitizedRequestShape(sources),
         bubbleVersion: getCurrentVersion(),
         pid: process.pid,
         runtimeStartedAt: RUNTIME_STARTED_AT,
+        ...(context.retry ? { retry: {
+                attempt: context.retry.attempt,
+                maxAttempts: context.retry.maxAttempts,
+            } } : {}),
     };
 }
+function sanitizedRequestShape(sources) {
+    const raw = sources.find(source => asRecord(source.requestShape))?.requestShape;
+    const shape = asRecord(raw);
+    if (!shape)
+        return {};
+    const safe = {};
+    for (const key of ["messages", "tools", "assistant", "emptyAssistant", "reasoning", "toolCalls", "toolResults", "contentChars"]) {
+        const value = shape[key];
+        if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0)
+            safe[key] = value;
+    }
+    return { requestShape: safe };
+}
 export function sanitizeProviderErrorText(value) {
     const text = value.replace(/[\r\n\t]+/g, " ").replace(/\s{2,}/g, " ").trim();
     // Fail closed: provider/SDK messages can embed request headers, bodies,
@@ -99,6 +126,9 @@ export function sanitizeProviderErrorText(value) {
     if (/forbidden|permission denied|access denied|\b403\b/i.test(text)) {
         return "Provider denied the request.";
     }
+    if (/unprocessable entity|\b422\b/i.test(text)) {
+        return "Provider rejected the request (unprocessable entity).";
+    }
     if (/invalid[^.]{0,60}(?:parameter|argument)|unsupported[^.]{0,60}(?:parameter|argument)|bad request|\b400\b/i.test(text)) {
         return "Provider rejected a request parameter.";
     }
@@ -115,18 +145,16 @@ export function sanitizeProviderErrorText(value) {
 }
 function errorSources(error) {
     const sources = [];
-    const root = asRecord(error);
-    if (root)
-        sources.push(root);
-    const nested = asRecord(root?.error);
-    if (nested)
-        sources.push(nested);
-    const cause = asRecord(root?.cause);
-    if (cause)
-        sources.push(cause);
-    const causeError = asRecord(cause?.error);
-    if (causeError)
-        sources.push(causeError);
+    const pending = [error];
+    const seen = new Set();
+    while (pending.length && sources.length < 12) {
+        const source = asRecord(pending.shift());
+        if (!source || seen.has(source))
+            continue;
+        seen.add(source);
+        sources.push(source);
+        pending.push(source.error, source.cause);
+    }
     return sources;
 }
 function asRecord(value) {

package/dist/provider-grok.js

@@ -7,6 +7,7 @@
  * identity headers the proxy gates on, and a fetch wrapper that keeps the
  * OAuth bearer fresh across long sessions.
  */
+import { waitForOAuth } from "./oauth/refresh-control.js";
 import { getChatGptFetch } from "./network/chatgpt-transport.js";
 import { THINKING_LEVELS } from "./types.js";
 export const GROK_SUBSCRIPTION_BASE_URL = "https://cli-chat-proxy.grok.com/v1";
@@ -49,7 +50,10 @@ export function createGrokSubscriptionFetch(auth, baseFetch = getChatGptFetch())
         return credentials.accessToken || undefined;
     }
     return async (input, init) => {
-        const token = await freshAccessToken();
+        const signal = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+        signal?.throwIfAborted();
+        const token = await waitForOAuth(freshAccessToken(), signal);
+        signal?.throwIfAborted();
         if (!token) {
             return baseFetch(input, init);
         }

package/dist/provider-openai-codex.d.ts

@@ -14,6 +14,8 @@ export interface CodexModelDescriptor {
     /** Server-declared per-tool-output token cap (truncation_policy.limit when mode=tokens). */
     toolOutputTokenLimit?: number;
 }
+/** The Codex client version Bubble claims; the account catalog the server returns depends on it. */
+export declare function getCodexClientVersion(): string;
 export declare function isOpenAICodexBaseUrl(baseURL: string): boolean;
 export declare function getOpenAICodexFallbackModels(): string[];
 export interface OpenAICodexAuthAdapter {
@@ -45,6 +47,8 @@ export declare function fetchOpenAICodexModels(options: {
 export interface OpenAICodexModelCatalogResult {
     descriptors: CodexModelDescriptor[];
     status: "success" | "unavailable";
+    /** Why each discovery path failed, when status is "unavailable". */
+    reason?: string;
 }
 /**
  * Fetches the account-scoped Codex catalog while preserving the distinction
@@ -54,5 +58,9 @@ export declare function fetchOpenAICodexModelCatalog(options: {
     baseURL: string;
     accessToken: string;
     fetch?: ChatGptFetch;
+    /** Bounds both catalog GETs; a stalled warm-up must not pin the in-flight slot. */
+    signal?: AbortSignal;
+    /** Per-request timeout, so a slow first path still leaves the fallback a full window. */
+    timeoutMs?: number;
 }): Promise<OpenAICodexModelCatalogResult>;
 export declare function sortCodexModelDescriptors(descriptors: CodexModelDescriptor[]): CodexModelDescriptor[];

package/dist/provider-openai-codex.js

@@ -1,8 +1,10 @@
 import { createHash } from "node:crypto";
 import { THINKING_LEVELS } from "./types.js";
+import { waitForOAuth } from "./oauth/refresh-control.js";
 import { getBuiltinModel, listBuiltinModels } from "./model-catalog.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
 import { chatGptFetch } from "./network/chatgpt-transport.js";
+import { logProviderTransportFailure } from "./network/provider-transport-log.js";
 import { computeRetryDelayMs, getProviderMaxRetries, isRetryableHttpStatus, ProviderStreamInterruptedError, sleepBeforeRetry, } from "./network/retry.js";
 const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
 const OPENAI_BETA_RESPONSES = "responses=experimental";
@@ -10,7 +12,13 @@ const TOKEN_REFRESH_GRACE_MS = 5 * 60 * 1000;
 // OpenAI gates new codex models server-side by client_version (each model carries a
 // `minimal_client_version`). Track a recent real Codex CLI release; override via env
 // when OpenAI lifts the gate again before we cut a new release.
-const CODEX_CLIENT_VERSION = process.env.BUBBLE_CODEX_CLIENT_VERSION?.trim() || "0.150.0";
+// 2026-09-17: gpt-6-astra requires 0.153.0.
+// 2026-10-06: gpt-6.1-sol requires 0.159.0, the version the Codex app sends.
+const CODEX_CLIENT_VERSION = process.env.BUBBLE_CODEX_CLIENT_VERSION?.trim() || "0.159.0";
+/** The Codex client version Bubble claims; the account catalog the server returns depends on it. */
+export function getCodexClientVersion() {
+    return CODEX_CLIENT_VERSION;
+}
 const MODEL_DISCOVERY_PATHS = [
     `/codex/models?client_version=${CODEX_CLIENT_VERSION}`,
     "/models",
@@ -45,13 +53,20 @@ export function createOpenAICodexProvider(options) {
     const sessionId = globalThis.crypto?.randomUUID?.() ?? `bubble_${Date.now()}`;
     const fetchImpl = options.fetch ?? chatGptFetch;
     let refreshPromise;
-    async function resolveRequestAuth(forceRefresh = false) {
+    // `rejectedAccessToken`: the token a 401 was returned for. If storage already
+    // holds a different one, another process rotated it while the request was in
+    // flight — use that instead of spending its refresh token on a second rotation.
+    async function resolveRequestAuth(forceRefresh = false, rejectedAccessToken) {
         let credentials = await options.auth?.getCredentials();
         if (credentials && options.auth) {
             const expired = options.auth.isExpired
                 ? options.auth.isExpired(credentials, TOKEN_REFRESH_GRACE_MS)
                 : Date.now() >= credentials.expiresAt - TOKEN_REFRESH_GRACE_MS;
-            if ((forceRefresh || !credentials.accessToken || expired) && credentials.refreshToken) {
+            const alreadyRotated = rejectedAccessToken !== undefined
+                && !!credentials.accessToken
+                && credentials.accessToken !== rejectedAccessToken;
+            const mustRefresh = (forceRefresh && !alreadyRotated) || !credentials.accessToken || expired;
+            if (mustRefresh && credentials.refreshToken) {
                 if (!refreshPromise) {
                     refreshPromise = options.auth.refreshCredentials(credentials).finally(() => {
                         refreshPromise = undefined;
@@ -80,8 +95,12 @@ export function createOpenAICodexProvider(options) {
             promptCacheKey: options.promptCacheKey,
             useResponsesLite,
         }));
+        let sentAccessToken;
         const sendRequest = async (forceRefresh = false) => {
-            const { accessToken, accountId } = await resolveRequestAuth(forceRefresh);
+            chatOptions.abortSignal?.throwIfAborted();
+            const { accessToken, accountId } = await waitForOAuth(resolveRequestAuth(forceRefresh, forceRefresh ? sentAccessToken : undefined), chatOptions.abortSignal);
+            chatOptions.abortSignal?.throwIfAborted();
+            sentAccessToken = accessToken;
             return fetchImpl(resolveCodexUrl(options.baseURL), buildCodexRequestInit({
                 accessToken,
                 accountId,
@@ -92,14 +111,25 @@ export function createOpenAICodexProvider(options) {
             }));
         };
         for (let attempt = 0;; attempt++) {
+            const requestId = globalThis.crypto.randomUUID();
+            const startedAt = Date.now();
+            let responseStatus;
+            let receivedEvents = 0;
+            let lastEventAt;
             let sawParsedSseEvent = false;
             let currentToolCall;
+            // OpenAI streams one reasoning summary per part; each part is a
+            // self-contained markdown block. Separate parts so Thinking does not
+            // read as one run-on line.
+            let summaryPartsSeen = 0;
             try {
                 let response = await sendRequest();
+                responseStatus = response.status;
                 if (!response.ok) {
                     const errorText = await response.text().catch(() => "");
                     if (response.status === 401 && options.auth && isTokenExpiredError(errorText)) {
                         response = await sendRequest(true);
+                        responseStatus = response.status;
                     }
                     else {
                         throw new Error(`${response.status} status code${errorText ? `: ${errorText}` : " (no body)"}`);
@@ -111,6 +141,8 @@ export function createOpenAICodexProvider(options) {
                 }
                 for await (const event of parseSse(response)) {
                     sawParsedSseEvent = true;
+                    receivedEvents += 1;
+                    lastEventAt = Date.now();
                     const type = typeof event.type === "string" ? event.type : undefined;
                     if (!type)
                         continue;
@@ -151,6 +183,13 @@ export function createOpenAICodexProvider(options) {
                         }
                         continue;
                     }
+                    if (type === "response.reasoning_summary_part.added") {
+                        summaryPartsSeen += 1;
+                        if (summaryPartsSeen > 1) {
+                            yield { type: "reasoning_delta", content: "\n\n" };
+                        }
+                        continue;
+                    }
                     if (type === "response.reasoning_summary_text.delta") {
                         const delta = typeof event.delta === "string" ? event.delta : "";
                         if (delta) {
@@ -224,19 +263,30 @@ export function createOpenAICodexProvider(options) {
                 return;
             }
             catch (error) {
-                if (sawParsedSseEvent
+                const delegateRetry = sawParsedSseEvent
                     && !chatOptions.abortSignal?.aborted
-                    && isTransientCodexTransportError(error)) {
+                    && isTransientCodexTransportError(error);
+                const retry = shouldRetryCodexTransportError({
+                    error, attempt, sawParsedSseEvent, signal: chatOptions.abortSignal,
+                });
+                logProviderTransportFailure(error, {
+                    providerId: options.providerId ?? "openai-codex",
+                    modelId: chatOptions.model,
+                    thinkingLevel: chatOptions.thinkingLevel ?? options.thinkingLevel ?? "off",
+                    messageCount: messages.length,
+                    toolCount: chatOptions.tools?.length ?? 0,
+                    sessionId, requestId, attempt: attempt + 1, responseStatus, receivedEvents,
+                    elapsedMs: Date.now() - startedAt,
+                    lastEventAgeMs: lastEventAt === undefined ? undefined : Date.now() - lastEventAt,
+                    decision: chatOptions.abortSignal?.aborted ? "cancelled"
+                        : delegateRetry ? "delegate_retry" : retry ? "retry" : "fail",
+                });
+                if (delegateRetry) {
                     // Partial content already surfaced — the agent loop discards the
                     // half-built assistant message and re-issues the whole request.
-                    throw new ProviderStreamInterruptedError(error instanceof Error ? error.message : String(error), { cause: error });
+                    throw new ProviderStreamInterruptedError("ChatGPT connection interrupted while receiving a response.", { cause: error });
                 }
-                if (!shouldRetryCodexTransportError({
-                    error,
-                    attempt,
-                    sawParsedSseEvent,
-                    signal: chatOptions.abortSignal,
-                })) {
+                if (!retry) {
                     throw error;
                 }
                 await sleepBeforeRetry(computeRetryDelayMs(attempt + 1), chatOptions.abortSignal);
@@ -297,27 +347,50 @@ export async function fetchOpenAICodexModels(options) {
 export async function fetchOpenAICodexModelCatalog(options) {
     const accountId = extractChatGptAccountId(options.accessToken);
     if (!accountId) {
-        return { descriptors: [], status: "unavailable" };
+        return { descriptors: [], status: "unavailable", reason: "access token has no ChatGPT account id" };
     }
     const fetchImpl = options.fetch ?? chatGptFetch;
+    const failures = [];
     for (const path of MODEL_DISCOVERY_PATHS) {
+        const signal = options.timeoutMs === undefined
+            ? options.signal
+            : options.signal
+                ? AbortSignal.any([options.signal, AbortSignal.timeout(options.timeoutMs)])
+                : AbortSignal.timeout(options.timeoutMs);
+        const startedAt = Date.now();
         const response = await fetchImpl(resolveRelativeUrl(options.baseURL, path), {
             method: "GET",
             headers: buildBaseHeaders(options.accessToken, accountId, globalThis.crypto?.randomUUID?.() ?? `bubble_${Date.now()}`, { accept: "application/json" }),
-        }).catch(() => undefined);
-        if (!response?.ok)
+            signal,
+        }).catch((error) => {
+            failures.push(`${path}: ${error instanceof Error ? error.message : String(error)} after ${Date.now() - startedAt}ms`);
+            return undefined;
+        });
+        if (!response)
+            continue;
+        if (!response.ok) {
+            failures.push(`${path}: HTTP ${response.status} after ${Date.now() - startedAt}ms`);
             continue;
+        }
         const parsed = await response.json()
             .then((payload) => ({ ok: true, payload }))
             .catch(() => ({ ok: false }));
-        if (!parsed.ok)
+        if (!parsed.ok) {
+            failures.push(`${path}: invalid JSON`);
             continue;
+        }
+        const payload = parsed.payload;
+        if (!Array.isArray(payload) && !(payload && typeof payload === "object"
+            && (Array.isArray(payload.models) || Array.isArray(payload.data)))) {
+            failures.push(`${path}: unexpected payload`);
+            continue;
+        }
         return {
-            descriptors: sortCodexModelDescriptors(extractCodexModelDescriptors(parsed.payload)),
+            descriptors: sortCodexModelDescriptors(extractCodexModelDescriptors(payload)),
             status: "success",
         };
     }
-    return { descriptors: [], status: "unavailable" };
+    return { descriptors: [], status: "unavailable", reason: failures.join("; ") };
 }
 function buildRequestBody(messages, options) {
     const instructions = messages
@@ -379,6 +452,11 @@ function buildRequestBody(messages, options) {
         const wireEffort = options.reasoningEffort === "ultra" ? "max" : options.reasoningEffort;
         body.reasoning = {
             effort: wireEffort,
+            // The Codex backend's default_reasoning_summary is "none" for every
+            // current model, so without an explicit summary request no
+            // response.reasoning_summary_text.delta events arrive and the TUI never
+            // shows Thinking. Ask for the server-chosen summary like Codex CLI does.
+            summary: "auto",
             ...(options.useResponsesLite ? { context: "all_turns" } : {}),
         };
     }
@@ -515,6 +593,7 @@ function isTransientCodexTransportError(error) {
         /\bConnectionClosed\b/i,
         /\bECONNRESET\b/i,
         /\bUND_ERR_SOCKET\b/i,
+        /\bUND_ERR_(?:CONNECT|HEADERS|BODY)_TIMEOUT\b/i,
         /\bEPIPE\b/i,
         /socket hang up/i,
         /fetch failed/i,
@@ -533,6 +612,9 @@ function errorMessageChain(error) {
     for (let depth = 0; current && depth < 6; depth++) {
         if (current instanceof Error) {
             messages.push(current.name, current.message);
+            const code = current.code;
+            if (typeof code === "string")
+                messages.push(code);
             current = current.cause;
             continue;
         }
@@ -669,14 +751,15 @@ function extractCodexModelDescriptors(payload) {
     visit(payload);
     return out;
 }
-// Extracts the family version from a codex slug (e.g. "gpt-5.5-codex" → 5005).
-// Used so models from a newer family float to the top even before the static
-// catalog knows about them.
+// Extracts the family version from a codex slug (e.g. "gpt-5.5-codex" → 5005,
+// "gpt-6-astra" → 6000). Used so models from a newer family float to the top
+// even before the static catalog knows about them. Integer-major slugs must
+// rank above every older major.minor family, not fall to zero.
 function parseCodexFamilyRank(id) {
-    const match = id.match(/(\d+)\.(\d+)/);
+    const match = id.match(/(\d+)(?:\.(\d+))?/);
     if (!match)
         return 0;
-    return parseInt(match[1], 10) * 1000 + parseInt(match[2], 10);
+    return parseInt(match[1], 10) * 1000 + (match[2] ? parseInt(match[2], 10) : 0);
 }
 export function sortCodexModelDescriptors(descriptors) {
     const preferred = new Map(getOpenAICodexFallbackModels().map((id, index) => [id, index]));

package/dist/provider-registry.d.ts

@@ -64,7 +64,8 @@ export interface ModelDiscoveryResult {
  */
 export interface CachedDiscoverySnapshot {
     models: ModelInfo[];
-    source: Exclude<ModelDiscoverySource, "cache">;
+    /** "cache" marks a confirmed catalog retained past the live result's freshness. */
+    source: ModelDiscoverySource;
     complete: boolean;
     expiresAt: number;
     identityKey: string;
@@ -107,12 +108,50 @@ export declare class ProviderRegistry {
     private handleAuthMutation;
     getModelConfig(): ModelConfig;
     getAuthStorage(): AuthStorage;
+    /**
+     * Run discovery for an account-scoped (OAuth) provider so the routing
+     * snapshot knows the account's real catalog before the routing prompt is
+     * composed and before the first subagent spawn. Discovery was previously
+     * triggered only by the model picker, which left tier routing on the static
+     * builtin list for the whole session unless the user opened /model.
+     * Resolves when discovery settles (it never throws: failures resolve to the
+     * local fallback); resolves immediately when a fresh cache exists or the
+     * provider is not account-scoped. Hosts bound the wait, see waitForModelDiscovery.
+     */
+    warmModelDiscovery(providerId: string): Promise<void>;
+    /**
+     * Warm discovery but never hold startup hostage to the network: after
+     * `maxWaitMs` the host proceeds with whatever the snapshot has, and the
+     * still-running discovery updates the live accessor when it lands.
+     */
+    waitForModelDiscovery(providerId: string, maxWaitMs: number): Promise<void>;
     supportsOAuth(providerId: string): boolean;
+    /**
+     * Auth-storage keys currently backing a provider's OAuth login. The visible
+     * `openai` provider may still be backed by the legacy `openai-codex` key,
+     * so UI state and logout must not check `has(providerId)` directly.
+     */
+    getOAuthLoginKeys(providerId: string): string[];
     private resolveOAuthAuthKey;
     createOpenAICodexAuthAdapter(providerId: string): OpenAICodexAuthAdapter | undefined;
     createGrokAuthAdapter(providerId: string): GrokAuthAdapter | undefined;
     getDefaultModel(providerId: string, authType?: ProviderProfile["authType"]): string | undefined;
     prepareProvider(providerId: string): Promise<void>;
+    private refreshOpenAICredentials;
+    private refreshGrokCredentials;
+    /**
+     * The one place a refresh token is spent. auth.json is shared by every
+     * Bubble process and refresh tokens are single-use, so the token is only
+     * presented under the cross-process lock and only after re-reading the file:
+     * if another process already rotated it, its result is adopted and no
+     * request is made. A rejected token gets the same second look before the
+     * error surfaces, because the rotation may have landed mid-request.
+     *
+     * `used` is the credential set the caller was holding when it asked (the
+     * provider passes it, also for a forced refresh after a 401): "rotated" means
+     * the file no longer holds that set, not merely that it is unexpired.
+     */
+    private refreshSharedCredentials;
     getConfigured(): ProviderProfile[];
     getEnabled(): ProviderProfile[];
     getDefault(): ProviderProfile | undefined;
@@ -136,8 +175,12 @@ export declare class ProviderRegistry {
      * derived strictly: only a successful full remote catalog qualifies —
      * never static or fallback results, whose internal `authoritative` flag
      * this design does not trust.
+     * Desktop catalogs can explicitly retain the last confirmation beyond its
+     * routing horizon; ordinary routing callers keep the default expiry policy.
      */
-    getCachedDiscoverySnapshot(providerId: string): CachedDiscoverySnapshot | undefined;
+    getCachedDiscoverySnapshot(providerId: string, options?: {
+        allowExpiredConfirmation?: boolean;
+    }): CachedDiscoverySnapshot | undefined;
     private isCurrentModelDiscovery;
     private applyDynamicDiscoveryMetadata;
 }