@bubblebrain-ai/bubble 0.0.13 → 0.0.14

package/dist/provider-openai-codex.js

@@ -3,6 +3,9 @@ import { listBuiltinModels } from "./model-catalog.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
 const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
 const OPENAI_BETA_RESPONSES = "responses=experimental";
+const TOKEN_REFRESH_GRACE_MS = 5 * 60 * 1000;
+const CODEX_TRANSPORT_MAX_RETRIES = 2;
+const CODEX_TRANSPORT_RETRY_BASE_DELAY_MS = 250;
 // 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.
@@ -39,146 +42,198 @@ export function extractChatGptAccountId(accessToken) {
 }
 export function createOpenAICodexProvider(options) {
     const sessionId = globalThis.crypto?.randomUUID?.() ?? `bubble_${Date.now()}`;
-    async function* streamChat(messages, chatOptions) {
-        const requestConfig = resolveProviderRequestConfig("openai-codex", chatOptions.model, chatOptions.thinkingLevel ?? options.thinkingLevel ?? "off");
-        const accountId = extractChatGptAccountId(options.apiKey);
+    let refreshPromise;
+    async function resolveRequestAuth(forceRefresh = false) {
+        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) {
+                if (!refreshPromise) {
+                    refreshPromise = options.auth.refreshCredentials(credentials).finally(() => {
+                        refreshPromise = undefined;
+                    });
+                }
+                credentials = await refreshPromise;
+            }
+        }
+        const accessToken = credentials?.accessToken || options.apiKey;
+        const accountId = credentials?.accountId || extractChatGptAccountId(accessToken);
         if (!accountId) {
             throw new Error("Failed to extract chatgpt_account_id from ChatGPT OAuth token.");
         }
-        const response = await fetch(resolveCodexUrl(options.baseURL), {
-            method: "POST",
-            headers: buildSseHeaders(options.apiKey, accountId, sessionId),
-            signal: chatOptions.abortSignal,
-            body: JSON.stringify(buildRequestBody(messages, {
-                model: chatOptions.model,
-                tools: chatOptions.tools,
-                reasoningEffort: requestConfig.reasoningEffort,
+        return { accessToken, accountId };
+    }
+    async function* streamChat(messages, chatOptions) {
+        const requestConfig = resolveProviderRequestConfig("openai-codex", chatOptions.model, chatOptions.thinkingLevel ?? options.thinkingLevel ?? "off");
+        const body = JSON.stringify(buildRequestBody(messages, {
+            model: chatOptions.model,
+            tools: chatOptions.tools,
+            reasoningEffort: requestConfig.reasoningEffort,
+            sessionId,
+            providerId: options.providerId,
+            promptCacheKey: options.promptCacheKey,
+        }));
+        const sendRequest = async (forceRefresh = false) => {
+            const { accessToken, accountId } = await resolveRequestAuth(forceRefresh);
+            return fetch(resolveCodexUrl(options.baseURL), buildCodexRequestInit({
+                accessToken,
+                accountId,
                 sessionId,
-                providerId: options.providerId,
-                promptCacheKey: options.promptCacheKey,
-            })),
-        });
-        if (!response.ok) {
-            const errorText = await response.text().catch(() => "");
-            throw new Error(`${response.status} status code${errorText ? `: ${errorText}` : " (no body)"}`);
-        }
-        let currentToolCall;
-        for await (const event of parseSse(response)) {
-            const type = typeof event.type === "string" ? event.type : undefined;
-            if (!type)
-                continue;
-            if (type === "error") {
-                const message = typeof event.message === "string" ? event.message : JSON.stringify(event);
-                throw new Error(message);
-            }
-            if (type === "response.failed") {
-                const message = typeof event.response?.error?.message === "string"
-                    ? event.response.error.message
-                    : "Codex response failed";
-                throw new Error(message);
-            }
-            if (type === "response.output_item.added") {
-                const item = event.item;
-                if (item?.type === "function_call" && typeof item.call_id === "string" && typeof item.name === "string") {
-                    currentToolCall = {
-                        id: item.call_id,
-                        name: item.name,
-                        args: typeof item.arguments === "string" ? item.arguments : "",
-                        started: true,
-                    };
-                    yield {
-                        type: "tool_call",
-                        id: currentToolCall.id,
-                        name: currentToolCall.name,
-                        arguments: "",
-                        isStart: true,
-                        isEnd: false,
-                    };
-                }
-                continue;
-            }
-            if (type === "response.output_text.delta" || type === "response.refusal.delta") {
-                const delta = typeof event.delta === "string" ? event.delta : "";
-                if (delta) {
-                    yield { type: "text", content: delta };
-                }
-                continue;
-            }
-            if (type === "response.reasoning_summary_text.delta") {
-                const delta = typeof event.delta === "string" ? event.delta : "";
-                if (delta) {
-                    yield { type: "reasoning_delta", content: delta };
-                }
-                continue;
-            }
-            if (type === "response.function_call_arguments.delta" && currentToolCall) {
-                const delta = typeof event.delta === "string" ? event.delta : "";
-                if (delta) {
-                    currentToolCall.args += delta;
-                    yield {
-                        type: "tool_call",
-                        id: currentToolCall.id,
-                        name: currentToolCall.name,
-                        arguments: delta,
-                        isStart: false,
-                        isEnd: false,
-                    };
-                }
-                continue;
-            }
-            if (type === "response.function_call_arguments.done" && currentToolCall) {
-                const finalArgs = typeof event.arguments === "string" ? event.arguments : currentToolCall.args;
-                if (finalArgs.startsWith(currentToolCall.args)) {
-                    const tail = finalArgs.slice(currentToolCall.args.length);
-                    if (tail) {
-                        currentToolCall.args = finalArgs;
-                        yield {
-                            type: "tool_call",
-                            id: currentToolCall.id,
-                            name: currentToolCall.name,
-                            arguments: tail,
-                            isStart: false,
-                            isEnd: false,
-                        };
+                signal: chatOptions.abortSignal,
+                body,
+            }));
+        };
+        for (let attempt = 0;; attempt++) {
+            let sawParsedSseEvent = false;
+            let currentToolCall;
+            try {
+                let response = await sendRequest();
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => "");
+                    if (response.status === 401 && options.auth && isTokenExpiredError(errorText)) {
+                        response = await sendRequest(true);
+                    }
+                    else {
+                        throw new Error(`${response.status} status code${errorText ? `: ${errorText}` : " (no body)"}`);
                     }
                 }
-                else {
-                    currentToolCall.args = finalArgs;
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => "");
+                    throw new Error(`${response.status} status code${errorText ? `: ${errorText}` : " (no body)"}`);
                 }
-                continue;
-            }
-            if (type === "response.output_item.done" && currentToolCall) {
-                const item = event.item;
-                if (item?.type === "function_call" && item.call_id === currentToolCall.id) {
-                    yield {
-                        type: "tool_call",
-                        id: currentToolCall.id,
-                        name: currentToolCall.name,
-                        arguments: "",
-                        isStart: false,
-                        isEnd: true,
-                    };
-                    currentToolCall = undefined;
+                for await (const event of parseSse(response)) {
+                    sawParsedSseEvent = true;
+                    const type = typeof event.type === "string" ? event.type : undefined;
+                    if (!type)
+                        continue;
+                    if (type === "error") {
+                        const message = typeof event.message === "string" ? event.message : JSON.stringify(event);
+                        throw new Error(message);
+                    }
+                    if (type === "response.failed") {
+                        const message = typeof event.response?.error?.message === "string"
+                            ? event.response.error.message
+                            : "Codex response failed";
+                        throw new Error(message);
+                    }
+                    if (type === "response.output_item.added") {
+                        const item = event.item;
+                        if (item?.type === "function_call" && typeof item.call_id === "string" && typeof item.name === "string") {
+                            currentToolCall = {
+                                id: item.call_id,
+                                name: item.name,
+                                args: typeof item.arguments === "string" ? item.arguments : "",
+                                started: true,
+                            };
+                            yield {
+                                type: "tool_call",
+                                id: currentToolCall.id,
+                                name: currentToolCall.name,
+                                arguments: "",
+                                isStart: true,
+                                isEnd: false,
+                            };
+                        }
+                        continue;
+                    }
+                    if (type === "response.output_text.delta" || type === "response.refusal.delta") {
+                        const delta = typeof event.delta === "string" ? event.delta : "";
+                        if (delta) {
+                            yield { type: "text", content: delta };
+                        }
+                        continue;
+                    }
+                    if (type === "response.reasoning_summary_text.delta") {
+                        const delta = typeof event.delta === "string" ? event.delta : "";
+                        if (delta) {
+                            yield { type: "reasoning_delta", content: delta };
+                        }
+                        continue;
+                    }
+                    if (type === "response.function_call_arguments.delta" && currentToolCall) {
+                        const delta = typeof event.delta === "string" ? event.delta : "";
+                        if (delta) {
+                            currentToolCall.args += delta;
+                            yield {
+                                type: "tool_call",
+                                id: currentToolCall.id,
+                                name: currentToolCall.name,
+                                arguments: delta,
+                                isStart: false,
+                                isEnd: false,
+                            };
+                        }
+                        continue;
+                    }
+                    if (type === "response.function_call_arguments.done" && currentToolCall) {
+                        const finalArgs = typeof event.arguments === "string" ? event.arguments : currentToolCall.args;
+                        if (finalArgs.startsWith(currentToolCall.args)) {
+                            const tail = finalArgs.slice(currentToolCall.args.length);
+                            if (tail) {
+                                currentToolCall.args = finalArgs;
+                                yield {
+                                    type: "tool_call",
+                                    id: currentToolCall.id,
+                                    name: currentToolCall.name,
+                                    arguments: tail,
+                                    isStart: false,
+                                    isEnd: false,
+                                };
+                            }
+                        }
+                        else {
+                            currentToolCall.args = finalArgs;
+                        }
+                        continue;
+                    }
+                    if (type === "response.output_item.done" && currentToolCall) {
+                        const item = event.item;
+                        if (item?.type === "function_call" && item.call_id === currentToolCall.id) {
+                            yield {
+                                type: "tool_call",
+                                id: currentToolCall.id,
+                                name: currentToolCall.name,
+                                arguments: "",
+                                isStart: false,
+                                isEnd: true,
+                            };
+                            currentToolCall = undefined;
+                        }
+                        continue;
+                    }
+                    if (type === "response.completed" || type === "response.done" || type === "response.incomplete") {
+                        const usage = event.response?.usage;
+                        if (usage) {
+                            yield {
+                                type: "usage",
+                                usage: normalizeOpenAICodexUsage(usage),
+                            };
+                        }
+                        continue;
+                    }
                 }
-                continue;
+                yield { type: "done" };
+                return;
             }
-            if (type === "response.completed" || type === "response.done" || type === "response.incomplete") {
-                const usage = event.response?.usage;
-                if (usage) {
-                    yield {
-                        type: "usage",
-                        usage: normalizeOpenAICodexUsage(usage),
-                    };
+            catch (error) {
+                if (!shouldRetryCodexTransportError({
+                    error,
+                    attempt,
+                    sawParsedSseEvent,
+                    signal: chatOptions.abortSignal,
+                })) {
+                    throw error;
                 }
-                continue;
+                await sleepBeforeCodexRetry(codexRetryDelayMs(attempt), chatOptions.abortSignal);
             }
         }
-        yield { type: "done" };
     }
     async function complete(messages, chatOptions) {
         let content = "";
         for await (const chunk of streamChat(messages, {
-            model: chatOptions?.model ?? "gpt-5.4",
+            model: chatOptions?.model ?? "gpt-5.5",
             temperature: chatOptions?.temperature,
             thinkingLevel: chatOptions?.thinkingLevel,
             abortSignal: chatOptions?.abortSignal,
@@ -191,6 +246,9 @@ export function createOpenAICodexProvider(options) {
     }
     return { streamChat, complete };
 }
+function isTokenExpiredError(errorText) {
+    return /token_expired|session expired/i.test(errorText);
+}
 export function normalizeOpenAICodexUsage(usage) {
     const promptTokens = typeof usage?.input_tokens === "number" ? usage.input_tokens : 0;
     const cachedTokens = typeof usage?.input_tokens_details?.cached_tokens === "number"
@@ -359,6 +417,89 @@ async function* parseSse(response) {
         }
     }
 }
+function buildCodexRequestInit(options) {
+    const init = {
+        method: "POST",
+        headers: buildSseHeaders(options.accessToken, options.accountId, options.sessionId),
+        signal: options.signal,
+        body: options.body,
+        keepalive: false,
+    };
+    if (/^(1|true|yes)$/i.test(process.env.BUBBLE_CODEX_FETCH_VERBOSE ?? "")) {
+        init.verbose = true;
+    }
+    return init;
+}
+function shouldRetryCodexTransportError(input) {
+    if (input.signal?.aborted)
+        return false;
+    if (input.sawParsedSseEvent)
+        return false;
+    if (input.attempt >= CODEX_TRANSPORT_MAX_RETRIES)
+        return false;
+    return isTransientCodexTransportError(input.error);
+}
+function isTransientCodexTransportError(error) {
+    const text = errorMessageChain(error).join("\n");
+    if (/\bAbortError\b/i.test(text))
+        return false;
+    return [
+        /The socket connection was closed unexpectedly/i,
+        /\bConnectionClosed\b/i,
+        /\bECONNRESET\b/i,
+        /\bUND_ERR_SOCKET\b/i,
+        /\bEPIPE\b/i,
+        /socket hang up/i,
+        /fetch failed/i,
+    ].some((pattern) => pattern.test(text));
+}
+function errorMessageChain(error) {
+    const messages = [];
+    let current = error;
+    for (let depth = 0; current && depth < 6; depth++) {
+        if (current instanceof Error) {
+            messages.push(current.name, current.message);
+            current = current.cause;
+            continue;
+        }
+        if (typeof current === "object") {
+            const record = current;
+            for (const key of ["name", "code", "message"]) {
+                if (typeof record[key] === "string")
+                    messages.push(record[key]);
+            }
+            current = record.cause;
+            continue;
+        }
+        messages.push(String(current));
+        break;
+    }
+    return messages;
+}
+function codexRetryDelayMs(attempt) {
+    return CODEX_TRANSPORT_RETRY_BASE_DELAY_MS * Math.pow(3, attempt);
+}
+function sleepBeforeCodexRetry(ms, signal) {
+    if (signal?.aborted)
+        return Promise.reject(toAbortError(signal));
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            clearTimeout(timeout);
+            signal?.removeEventListener("abort", onAbort);
+            reject(toAbortError(signal));
+        };
+        const timeout = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function toAbortError(signal) {
+    if (signal?.reason instanceof Error)
+        return signal.reason;
+    return new DOMException(typeof signal?.reason === "string" ? signal.reason : "Aborted", "AbortError");
+}
 function buildBaseHeaders(accessToken, accountId, sessionId, extraHeaders) {
     const headers = new Headers(extraHeaders);
     headers.set("Authorization", `Bearer ${accessToken}`);

package/dist/provider-registry.d.ts

@@ -7,6 +7,7 @@
 import type { UserConfig } from "./config.js";
 import { ModelConfig } from "./model-config.js";
 import { AuthStorage } from "./oauth/index.js";
+import { type OpenAICodexAuthAdapter } from "./provider-openai-codex.js";
 export interface ProviderProfile {
     id: string;
     name: string;
@@ -32,6 +33,7 @@ export declare class ProviderRegistry {
     getAuthStorage(): AuthStorage;
     supportsOAuth(providerId: string): boolean;
     private resolveOAuthAuthKey;
+    createOpenAICodexAuthAdapter(providerId: string): OpenAICodexAuthAdapter | undefined;
     getDefaultModel(providerId: string, authType?: ProviderProfile["authType"]): string | undefined;
     prepareProvider(providerId: string): Promise<void>;
     getConfigured(): ProviderProfile[];

package/dist/provider-registry.js

@@ -35,11 +35,54 @@ export class ProviderRegistry {
         return !!getBuiltinProvider(providerId)?.supportsOAuth;
     }
     resolveOAuthAuthKey(providerId) {
-        if (providerId === "openai" && !this.authStorage.has("openai") && this.authStorage.has("openai-codex")) {
-            return "openai-codex";
+        if (providerId === "openai" || providerId === "openai-codex") {
+            if (this.authStorage.has("openai"))
+                return "openai";
+            if (this.authStorage.has("openai-codex"))
+                return "openai-codex";
         }
         return providerId;
     }
+    createOpenAICodexAuthAdapter(providerId) {
+        if (providerId !== "openai" && providerId !== "openai-codex")
+            return undefined;
+        if (!this.authStorage.has(this.resolveOAuthAuthKey(providerId)))
+            return undefined;
+        const readCredentials = () => this.authStorage.get(this.resolveOAuthAuthKey(providerId));
+        let refreshPromise;
+        return {
+            getCredentials: readCredentials,
+            isExpired: (_credentials, graceMs) => this.authStorage.isExpired(this.resolveOAuthAuthKey(providerId), graceMs),
+            refreshCredentials: async () => {
+                if (!refreshPromise) {
+                    refreshPromise = (async () => {
+                        const authKey = this.resolveOAuthAuthKey(providerId);
+                        const current = this.authStorage.get(authKey);
+                        if (!current?.refreshToken) {
+                            throw new Error(`OpenAI OAuth credentials for ${providerId} are missing a refresh token.`);
+                        }
+                        const refreshed = await refreshOpenAICodex(current.refreshToken);
+                        const next = {
+                            type: "oauth",
+                            accessToken: refreshed.accessToken,
+                            refreshToken: refreshed.refreshToken,
+                            expiresAt: refreshed.expiresAt,
+                            idToken: refreshed.idToken || current.idToken,
+                            accountId: refreshed.accountId || current.accountId,
+                        };
+                        this.authStorage.set("openai", next);
+                        if (authKey !== "openai") {
+                            this.authStorage.set(authKey, next);
+                        }
+                        return next;
+                    })().finally(() => {
+                        refreshPromise = undefined;
+                    });
+                }
+                return refreshPromise;
+            },
+        };
+    }
     getDefaultModel(providerId, authType = "api") {
         const customModels = this.modelConfig.getCustomModels(providerId);
         if (customModels.length > 0) {
@@ -52,18 +95,22 @@ export class ProviderRegistry {
     }
     async prepareProvider(providerId) {
         const authKey = this.resolveOAuthAuthKey(providerId);
-        if (providerId === "openai" && this.authStorage.isExpired(authKey)) {
+        if ((providerId === "openai" || providerId === "openai-codex") && this.authStorage.isExpired(authKey)) {
             const creds = this.authStorage.get(authKey);
             if (creds?.refreshToken) {
                 const refreshed = await refreshOpenAICodex(creds.refreshToken);
-                this.authStorage.set("openai", {
+                const next = {
                     type: "oauth",
                     accessToken: refreshed.accessToken,
                     refreshToken: refreshed.refreshToken,
                     expiresAt: refreshed.expiresAt,
-                    idToken: refreshed.idToken,
-                    accountId: refreshed.accountId,
-                });
+                    idToken: refreshed.idToken || creds.idToken,
+                    accountId: refreshed.accountId || creds.accountId,
+                };
+                this.authStorage.set("openai", next);
+                if (authKey !== "openai") {
+                    this.authStorage.set(authKey, next);
+                }
             }
         }
     }
@@ -194,9 +241,11 @@ export class ProviderRegistry {
         }
         if (provider.id === "openai" && provider.authType === "oauth" && provider.apiKey) {
             try {
+                await this.prepareProvider(provider.id);
+                const currentProvider = this.getConfigured().find((p) => p.id === provider.id) || provider;
                 const descriptors = await fetchOpenAICodexModels({
-                    baseURL: provider.baseURL,
-                    accessToken: provider.apiKey,
+                    baseURL: currentProvider.baseURL,
+                    accessToken: currentProvider.apiKey,
                 });
                 const visible = descriptors.filter((d) => d.visibility !== "hide");
                 if (visible.length > 0) {

package/dist/provider.d.ts

@@ -3,6 +3,7 @@
  *
  * Works with OpenRouter, OpenAI, DeepSeek, Google, Groq, Together, and local OpenAI-compatible endpoints.
  */
+import { type OpenAICodexAuthAdapter } from "./provider-openai-codex.js";
 import type { Provider, ProviderMessage, StreamChunk, ThinkingLevel } from "./types.js";
 type ReasoningContentEcho = "tool_calls" | "all" | "none";
 export type ToolArgsMergeMode = "delta" | "snapshot";
@@ -23,6 +24,8 @@ export interface ProviderInstanceOptions {
     thinkingLevel?: ThinkingLevel;
     /** Stable per-session seed for provider prompt caches. */
     promptCacheKey?: string;
+    /** Dynamic OAuth access-token loader/refresh hook for ChatGPT Codex requests. */
+    openAICodexAuth?: OpenAICodexAuthAdapter;
 }
 export declare function createUnavailableProvider(message: string): Provider;
 export declare function createProviderInstance(options: ProviderInstanceOptions): Provider;

package/dist/provider.js

@@ -66,7 +66,11 @@ export function createUnavailableProvider(message) {
 }
 export function createProviderInstance(options) {
     if (isOpenAICodexBaseUrl(options.baseURL)) {
-        return createOpenAICodexProvider({ ...options, providerId: options.providerId || "openai-codex" });
+        return createOpenAICodexProvider({
+            ...options,
+            providerId: options.providerId || "openai-codex",
+            auth: options.openAICodexAuth,
+        });
     }
     const client = new OpenAI({
         apiKey: options.apiKey,

package/dist/session-log.js

@@ -191,6 +191,11 @@ function normalizeMessageToEntries(message, id, timestamp) {
                     role: "assistant",
                     content: message.content,
                     reasoning: message.reasoning,
+                    model: message.model,
+                    providerId: message.providerId,
+                    modelId: message.modelId,
+                    usage: message.usage,
+                    error: message.error,
                 },
                 timestamp,
             };
@@ -228,7 +233,14 @@ function isSessionLogEntry(entry) {
     ].includes(entry.type);
 }
 function nextEntryId(entries) {
-    return `${entries.length + 1}`;
+    let max = 0;
+    for (const entry of entries) {
+        const match = /^(\d+)/.exec(entry.id);
+        if (!match)
+            continue;
+        max = Math.max(max, Number(match[1]));
+    }
+    return `${max + 1}`;
 }
 function cloneMessage(message) {
     if (message.role === "assistant") {

package/dist/slash-commands/commands.js

@@ -7,6 +7,7 @@ import { encodeModel, decodeModel, displayModel, BUILTIN_PROVIDERS, isUserVisibl
 import { getAvailableThinkingLevels, normalizeThinkingLevel } from "../provider-transform.js";
 import { buildSystemPrompt } from "../system-prompt.js";
 import { isThinkingLevel } from "../variant/thinking-level.js";
+import { collectUsageStatsBundle, formatStatsText } from "../stats/usage.js";
 import { buildMemoryPrompt, getMemoryStatus, isMemoryDisabled, resetMemory, searchMemory, } from "../memory/index.js";
 import { feishuCommand } from "./feishu.js";
 const VALID_SCOPES = ["user", "project", "local"];
@@ -795,6 +796,17 @@ const builtinSlashCommandEntries = [
             return `✓ Compaction complete · ${dropped} log entr${dropped === 1 ? "y" : "ies"} summarized`;
         },
     },
+    {
+        name: "stats",
+        description: "Show recent model usage statistics",
+        async handler(_args, ctx) {
+            if (ctx.openStats) {
+                ctx.openStats();
+                return;
+            }
+            return formatStatsText(collectUsageStatsBundle());
+        },
+    },
     {
         name: "feedback",
         description: "Send feedback or report a bug to Bubble developers",

package/dist/slash-commands/types.d.ts

@@ -46,6 +46,8 @@ export interface SlashCommandContext {
     setSidebarMode?: (mode: SidebarMode) => SidebarCommandState;
     /** Open the feedback dialog. `initialDescription` prefills the description field. */
     openFeedback?: (initialDescription: string) => void;
+    /** Open the interactive usage stats panel. */
+    openStats?: () => void;
 }
 /**
  * Return types for a slash command handler: