@bubblebrain-ai/bubble 0.0.47 → 0.0.48

package/dist/provider-grok.d.ts

@@ -9,9 +9,21 @@
  */
 import type { OAuthCredentials } from "./oauth/types.js";
 import { type ChatGptFetch } from "./network/chatgpt-transport.js";
+import type { ThinkingLevel } from "./types.js";
 export declare const GROK_SUBSCRIPTION_BASE_URL = "https://cli-chat-proxy.grok.com/v1";
 export declare const GROK_CLIENT_VERSION = "0.2.93";
 export declare function isGrokSubscriptionBaseUrl(baseURL: string): boolean;
+/**
+ * Infer reasoning levels for a Grok model id the /models endpoint returned
+ * without metadata. Flagship reasoning models (grok-N.M) expose
+ * low/medium/high with thinking always on — matching the curated grok-4.5
+ * entry — while composer/fast/mini/flash variants have no effort control and
+ * map to the plain "off" ladder.
+ */
+export declare function inferGrokReasoningLevels(modelId: string): {
+    levels: ThinkingLevel[];
+    defaultLevel?: ThinkingLevel;
+};
 export declare function buildGrokSubscriptionHeaders(): Record<string, string>;
 export interface GrokAuthAdapter {
     getCredentials: () => OAuthCredentials | undefined | Promise<OAuthCredentials | undefined>;
@@ -24,3 +36,17 @@ export interface GrokAuthAdapter {
  * proactively refreshes) the stored OAuth credentials per request instead.
  */
 export declare function createGrokSubscriptionFetch(auth: GrokAuthAdapter, baseFetch?: ChatGptFetch): ChatGptFetch;
+/**
+ * Fetch the model list for a Grok subscription account. The CLI chat proxy
+ * gates on the grok-cli identity headers plus a fresh OAuth bearer, so this
+ * rides the same refreshing fetch used for chat requests instead of a raw
+ * global fetch. Throws on a non-2xx so callers fall back to the curated
+ * catalog when the proxy exposes no /models endpoint.
+ */
+export declare function fetchGrokSubscriptionModels(baseURL: string, auth: GrokAuthAdapter, options?: {
+    timeoutMs?: number;
+    fetch?: ChatGptFetch;
+}): Promise<Array<{
+    id: string;
+    name?: string;
+}>>;

package/dist/provider-grok.js

@@ -17,6 +17,20 @@ export function isGrokSubscriptionBaseUrl(baseURL) {
     const normalized = baseURL.trim().replace(/\/+$/, "");
     return normalized === GROK_SUBSCRIPTION_BASE_URL || normalized.startsWith(`${GROK_SUBSCRIPTION_BASE_URL}/`);
 }
+/**
+ * Infer reasoning levels for a Grok model id the /models endpoint returned
+ * without metadata. Flagship reasoning models (grok-N.M) expose
+ * low/medium/high with thinking always on — matching the curated grok-4.5
+ * entry — while composer/fast/mini/flash variants have no effort control and
+ * map to the plain "off" ladder.
+ */
+export function inferGrokReasoningLevels(modelId) {
+    const id = modelId.toLowerCase();
+    if (/(composer|fast|mini|flash)/.test(id)) {
+        return { levels: ["off"] };
+    }
+    return { levels: ["low", "medium", "high"], defaultLevel: "high" };
+}
 export function buildGrokSubscriptionHeaders() {
     return {
         "User-Agent": "grok-cli",
@@ -57,3 +71,28 @@ export function createGrokSubscriptionFetch(auth, baseFetch = getChatGptFetch())
         return baseFetch(input, { ...(init ?? {}), headers });
     };
 }
+/**
+ * Fetch the model list for a Grok subscription account. The CLI chat proxy
+ * gates on the grok-cli identity headers plus a fresh OAuth bearer, so this
+ * rides the same refreshing fetch used for chat requests instead of a raw
+ * global fetch. Throws on a non-2xx so callers fall back to the curated
+ * catalog when the proxy exposes no /models endpoint.
+ */
+export async function fetchGrokSubscriptionModels(baseURL, auth, options = {}) {
+    const fetchImpl = createGrokSubscriptionFetch(auth, options.fetch);
+    const base = baseURL.trim().replace(/\/+$/, "");
+    const response = await fetchImpl(`${base}/models`, {
+        headers: buildGrokSubscriptionHeaders(),
+        signal: AbortSignal.timeout(options.timeoutMs ?? 5_000),
+    });
+    if (!response.ok)
+        throw new Error(`HTTP ${response.status}`);
+    const payload = (await response.json());
+    const entries = payload.data ?? payload.models ?? [];
+    return entries
+        .filter((entry) => typeof entry?.id === "string" && entry.id.trim().length > 0)
+        .map((entry) => ({
+        id: entry.id,
+        name: typeof entry.name === "string" ? entry.name : undefined,
+    }));
+}

package/dist/provider-registry.d.ts

@@ -9,7 +9,7 @@ import { type ProviderProtocol } from "./model-catalog.js";
 import { ModelConfig } from "./model-config.js";
 import { AuthStorage } from "./oauth/index.js";
 import { type OpenAICodexAuthAdapter } from "./provider-openai-codex.js";
-import type { GrokAuthAdapter } from "./provider-grok.js";
+import { type GrokAuthAdapter } from "./provider-grok.js";
 import type { ThinkingLevel } from "./types.js";
 export interface ProviderProfile {
     id: string;

package/dist/provider-registry.js

@@ -10,6 +10,7 @@ import { ModelConfig } from "./model-config.js";
 import { AuthStorage } from "./oauth/index.js";
 import { fetchGeminiModels } from "./provider-ai-sdk.js";
 import { extractChatGptAccountId, fetchOpenAICodexModelCatalog } from "./provider-openai-codex.js";
+import { fetchGrokSubscriptionModels, inferGrokReasoningLevels } from "./provider-grok.js";
 import { refreshOpenAICodex } from "./oauth/openai-codex.js";
 import { refreshGrok } from "./oauth/grok.js";
 /** True for providers speaking the OpenAI chat-completions protocol (the default). */
@@ -521,6 +522,45 @@ export class ProviderRegistry {
                 return this.fallbackDiscovery(provider, error);
             }
         }
+        // Grok subscription: the CLI chat proxy gates on the grok-cli identity
+        // headers and a fresh OAuth bearer, neither of which the generic path below
+        // sends. Discover through the refreshing subscription fetch, then merge the
+        // curated catalog with any remote-only ids so newly-released models surface
+        // without a code change. Authoritative because the merged list is what the
+        // routing catalog and model picker should treat as the account's catalog.
+        if (provider.id === "grok" && provider.authType === "oauth" && provider.apiKey) {
+            try {
+                await this.prepareProvider("grok");
+                const currentProvider = this.getConfigured().find((item) => item.id === "grok") ?? provider;
+                const grokAuth = this.createGrokAuthAdapter("grok");
+                if (!grokAuth)
+                    throw new Error("Grok OAuth credentials are unavailable.");
+                const remote = await fetchGrokSubscriptionModels(currentProvider.baseURL, grokAuth);
+                const local = this.localModelsForProvider(currentProvider);
+                const known = new Set(local.map((model) => model.id));
+                const extras = remote
+                    .filter((entry) => !known.has(entry.id) && isLikelyChatModelId(entry.id))
+                    .map((entry) => {
+                    const inferred = inferGrokReasoningLevels(entry.id);
+                    return {
+                        id: entry.id,
+                        name: entry.name || entry.id,
+                        providerId: currentProvider.id,
+                        reasoningLevels: inferred.levels,
+                        ...(inferred.defaultLevel ? { defaultReasoningLevel: inferred.defaultLevel } : {}),
+                    };
+                })
+                    .sort((a, b) => a.id.localeCompare(b.id));
+                return {
+                    models: [...local, ...extras],
+                    source: "remote",
+                    authoritative: true,
+                };
+            }
+            catch (error) {
+                return this.fallbackDiscovery(provider, error);
+            }
+        }
         // Generic OpenAI-compatible discovery: most vendors expose GET /models on
         // the same base URL. Probed against every configured provider, their lists
         // turned out to be neither complete nor clean — zhipuai omits glm-5.2,
@@ -642,7 +682,9 @@ export class ProviderRegistry {
             ? "openai-codex"
             : provider.id === "google" && provider.protocol === "ai-sdk"
                 ? "google"
-                : undefined;
+                : provider.id === "grok"
+                    ? "grok"
+                    : undefined;
         if (!dynamicProviderId)
             return;
         if (!result.authoritative) {
@@ -653,8 +695,11 @@ export class ProviderRegistry {
             id: model.id,
             name: model.name,
             providerId: dynamicProviderId,
-            // Empty means the remote model exists but declared no trusted effort metadata.
-            reasoningLevels: model.reasoningLevels ?? [],
+            // A remote model with no trusted effort metadata still has to be
+            // selectable: default it to the plain "off" level (no reasoning control)
+            // rather than an empty ladder, which the model picker would render
+            // "unavailable" and skip during arrow-key navigation.
+            reasoningLevels: model.reasoningLevels ?? ["off"],
             defaultReasoningLevel: model.defaultReasoningLevel,
             contextWindow: model.contextWindow,
             useResponsesLite: model.useResponsesLite,

package/dist/tui-ink/input-box.js

@@ -8,7 +8,7 @@ import { useTheme } from "./theme.js";
 import { filterFileSuggestions, findAtContext, listProjectFiles } from "./file-mentions.js";
 import { bareImageFilenameFromPaste, extractImagePathTokens, ingestClipboardImage, ingestImagePath, isImageFilePath, isScreenshotTempPath, splitPastedPaths, } from "./image-paste.js";
 import { appendHistoryEntry, loadHistoryEntriesSync, pushHistoryEntry, stepHistory, } from "./input-history.js";
-import { cloneComposerBuffer, createComposerBuffer, deleteComposerBackward, deleteComposerForward, expandComposerBuffer, hasActiveComposerPastes, insertComposerPaste, insertComposerText, moveComposerCursor, replaceComposerRange, } from "./composer-buffer.js";
+import { cloneComposerBuffer, createComposerBuffer, deleteComposerBackward, deleteComposerForward, expandComposerBuffer, insertComposerPaste, insertComposerText, moveComposerCursor, replaceComposerRange, } from "./composer-buffer.js";
 import { isKeyReleaseEvent } from "./key-events.js";
 import { PasteOperationTracker } from "./paste-operation-tracker.js";
 import { stripTerminalMouseSequences } from "./terminal-mouse.js";
@@ -26,6 +26,18 @@ export function createComposerDraftSnapshot(input) {
         imageLabelStartOverride: input.imageLabelStartOverride,
     };
 }
+/**
+ * Rebuild a composer buffer from a persisted history entry. Text long enough to
+ * have been collapsed at paste time is collapsed again into a `[Pasted text #N …]`
+ * marker, but its full content is preserved in the buffer's paste spans so the
+ * composer stays compact, no content is lost, and the next submit re-expands it.
+ */
+function bufferFromHistoryText(text) {
+    if (shouldCollapsePastedContent(text)) {
+        return insertComposerPaste(createComposerBuffer(), text);
+    }
+    return createComposerBuffer(text);
+}
 /**
  * Browse persisted history without turning marker-shaped text into live paste
  * tokens, while preserving the exact unsent draft in memory for the final
@@ -68,7 +80,7 @@ export function stepComposerHistory(state, history, direction) {
         };
     }
     return {
-        buffer: createComposerBuffer(result.text),
+        buffer: bufferFromHistoryText(result.text),
         attachments: (result.images ?? []).map((attachment) => ({ ...attachment })),
         imageLabelStartOverride: result.imageDisplayStart ?? null,
         historyIndex: result.index,
@@ -716,10 +728,10 @@ export function InputBox({ onSubmit, onQueue, onPasteNotice, disabled, onArrowDo
             return;
         submittedPayloadFingerprintRef.current = fingerprint;
         deliver(payload);
-        // A collapsed text-paste marker cannot be safely replayed once its
-        // in-memory reference is gone; skip those. Image-label stripping is fine to
-        // replay (the attachments are stored on the history entry).
-        if (!hasActiveComposerPastes(submittedBuffer) && (expandedText.trim().length > 0 || attachments.length > 0)) {
+        // Always record the submitted text so ↑/↓ can recall it. The full expanded
+        // text is persisted (content is never lost); on recall, long text is
+        // re-collapsed into a paste marker that still carries its full content.
+        if (expandedText.trim().length > 0 || attachments.length > 0) {
             const historyEntry = {
                 text: expandedText,
                 images: attachments,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.47",
+  "version": "0.0.48",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {