@bubblebrain-ai/bubble 0.0.47 → 0.0.49

package/README.md

@@ -21,6 +21,23 @@ The `npm install` step puts a small Node.js launcher named `bubble` on your PATH
 
 ## Install
 
+One-line install (macOS / Linux):
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/DylanDDeng/bubble/main/install.sh | sh
+```
+
+Windows (PowerShell):
+
+```powershell
+powershell -c "irm https://raw.githubusercontent.com/DylanDDeng/bubble/main/install.ps1 | iex"
+```
+
+The installer checks for Node.js 20+ and Bun (installing Bun for you if it is
+missing), then installs the `bubble` CLI globally via npm.
+
+Or install directly via npm:
+
 ```bash
 npm install -g @bubblebrain-ai/bubble
 ```

package/dist/agent.d.ts

@@ -214,7 +214,7 @@ export declare class Agent {
     unlockDeferredTools(names: string[]): void;
     /** All deferred tools in this session (for tool_search to inspect). */
     listDeferredTools(): ToolRegistryEntry[];
-    getSystemPromptToolOptions(): Pick<import("./system-prompt.js").SystemPromptOptions, "tools" | "toolSnippets" | "guidelines" | "modelRoutingPrompt">;
+    getSystemPromptToolOptions(): Pick<import("./system-prompt.js").SystemPromptOptions, "tools" | "toolSnippets" | "guidelines" | "modelRoutingPrompt" | "memoryPrompt">;
     /** Current routing menu (design §4); undefined when no accessor is wired. */
     buildModelRoutingPromptSection(): string | undefined;
     /**

package/dist/agent.js

@@ -345,6 +345,9 @@ export class Agent {
             // Rendered through the live accessor (design §1.5), so every host-
             // triggered prompt rebuild picks up the current catalog.
             modelRoutingPrompt: this.buildModelRoutingPromptSection(),
+            // Model switches rebuild the prompt from these options; without this the
+            // persistent memory (buildMemoryPrompt) is silently dropped on switch.
+            memoryPrompt: this.memoryPrompt,
         };
     }
     /** Current routing menu (design §4); undefined when no accessor is wired. */
@@ -705,6 +708,7 @@ export class Agent {
                 const textSanitizer = createStreamingInternalReminderSanitizer();
                 const reasoningSanitizer = createStreamingInternalReminderSanitizer();
                 let turnUsage;
+                let turnSystemFingerprint;
                 let assistantAppended = false;
                 currentAssistantMsg = assistantMsg;
                 currentAssistantAppended = false;
@@ -898,6 +902,10 @@ export class Agent {
                                     }
                                 }
                                 break;
+                            case "response_metadata":
+                                turnSystemFingerprint = chunk.systemFingerprint;
+                                assistantMsg.systemFingerprint = chunk.systemFingerprint;
+                                break;
                         }
                         for (const update of this.subagents.drainToolUpdates())
                             yield emit(update);
@@ -938,7 +946,7 @@ export class Agent {
                         if (consecutiveEmptyAssistantRecoveries < MAX_EMPTY_ASSISTANT_RECOVERIES) {
                             consecutiveEmptyAssistantRecoveries += 1;
                             this.injectSystemReminder(EMPTY_ASSISTANT_RECOVERY_REMINDER);
-                            yield emit({ type: "turn_end", usage: turnUsage, willContinue: true });
+                            yield emit({ type: "turn_end", usage: turnUsage, systemFingerprint: turnSystemFingerprint, willContinue: true });
                             continue;
                         }
                         assistantMsg.content = EMPTY_ASSISTANT_FALLBACK;
@@ -1328,7 +1336,7 @@ export class Agent {
                         },
                     });
                     flushQueuedReminders();
-                    yield emit({ type: "turn_end", usage: turnUsage, willContinue: true });
+                    yield emit({ type: "turn_end", usage: turnUsage, systemFingerprint: turnSystemFingerprint, willContinue: true });
                     // Auto-continue: if we have tool results, the LLM needs to respond to them.
                     // Emitting the turn boundary keeps UI renderers aligned with the persisted
                     // assistant/tool message sequence instead of merging the next answer into
@@ -1360,7 +1368,7 @@ export class Agent {
                 for (const event of stopHook.events)
                     yield emit(event);
                 const willContinue = !!hookState.forceContinuationReason;
-                yield emit({ type: "turn_end", usage: turnUsage, willContinue });
+                yield emit({ type: "turn_end", usage: turnUsage, systemFingerprint: turnSystemFingerprint, willContinue });
                 if (willContinue) {
                     delete hookState.forceContinuationReason;
                     continue;

package/dist/model-catalog.d.ts

@@ -48,5 +48,18 @@ export declare function listDynamicModelMetadata(providerId: string): BuiltinMod
 export declare function getBuiltinModel(providerId: string, modelId: string): BuiltinModelDefinition | undefined;
 export declare function getModelDefaultReasoningLevel(providerId: string, modelId: string): ReasoningEffort | undefined;
 export declare function getBuiltinProvider(providerId: string): BuiltinProviderDefinition | undefined;
+/**
+ * Infer capability metadata 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 and a 500K context window — matching the curated
+ * grok-4.5 entry — while composer/fast/mini/flash variants have no effort
+ * control and a 200K window. Pure (id-only) so it works even before remote
+ * model discovery runs.
+ */
+export declare function inferGrokModelMetadata(modelId: string): {
+    levels: ReasoningEffort[];
+    defaultLevel?: ReasoningEffort;
+    contextWindow?: number;
+};
 export declare function getModelContextWindow(providerId: string, modelId: string): number | undefined;
 export declare function getToolOutputTokenLimit(providerId: string, modelId: string): number | undefined;

package/dist/model-catalog.js

@@ -239,10 +239,28 @@ export function getBuiltinModel(providerId, modelId) {
         || (providerId === "openai" ? dynamicOverlay.get(overlayKey("openai-codex", modelId)) : undefined);
     if (overlayHit)
         return overlayHit;
-    return BUILTIN_MODELS.find((model) => model.providerId === providerId && model.id === modelId)
+    const staticHit = BUILTIN_MODELS.find((model) => model.providerId === providerId && model.id === modelId)
         || (providerId === "openai"
             ? BUILTIN_MODELS.find((model) => model.providerId === "openai-codex" && model.id === modelId)
             : undefined);
+    if (staticHit)
+        return staticHit;
+    // Dynamically-discovered grok models aren't in the static catalog until
+    // remote discovery runs. Synthesize their metadata from the id so reasoning
+    // levels, default effort, and context window resolve correctly on a fresh
+    // start or resumed session (before the first /model discovery).
+    if (providerId === "grok") {
+        const inferred = inferGrokModelMetadata(modelId);
+        return {
+            id: modelId,
+            name: modelId,
+            providerId: "grok",
+            reasoningLevels: inferred.levels,
+            defaultReasoningLevel: inferred.defaultLevel,
+            contextWindow: inferred.contextWindow,
+        };
+    }
+    return undefined;
 }
 export function getModelDefaultReasoningLevel(providerId, modelId) {
     return getBuiltinModel(providerId, modelId)?.defaultReasoningLevel;
@@ -250,8 +268,32 @@ export function getModelDefaultReasoningLevel(providerId, modelId) {
 export function getBuiltinProvider(providerId) {
     return BUILTIN_PROVIDERS.find((provider) => provider.id === providerId);
 }
+/**
+ * Infer capability metadata 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 and a 500K context window — matching the curated
+ * grok-4.5 entry — while composer/fast/mini/flash variants have no effort
+ * control and a 200K window. Pure (id-only) so it works even before remote
+ * model discovery runs.
+ */
+export function inferGrokModelMetadata(modelId) {
+    const id = modelId.toLowerCase();
+    if (/(composer|fast|mini|flash)/.test(id)) {
+        return { levels: ["off"], contextWindow: 200000 };
+    }
+    return { levels: ["low", "medium", "high"], defaultLevel: "high", contextWindow: 500000 };
+}
 export function getModelContextWindow(providerId, modelId) {
-    return getBuiltinModel(providerId, modelId)?.contextWindow;
+    const builtin = getBuiltinModel(providerId, modelId);
+    if (builtin?.contextWindow !== undefined)
+        return builtin.contextWindow;
+    // Dynamically-discovered grok models aren't in the static catalog until
+    // discovery runs; infer the window from the id so context usage can render a
+    // percentage even before discovery (e.g. on a resumed session right after
+    // startup).
+    if (providerId === "grok")
+        return inferGrokModelMetadata(modelId).contextWindow;
+    return undefined;
 }
 export function getToolOutputTokenLimit(providerId, modelId) {
     return getBuiltinModel(providerId, modelId)?.toolOutputTokenLimit;

package/dist/provider-grok.d.ts

@@ -9,6 +9,7 @@
  */
 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;
@@ -24,3 +25,26 @@ export interface GrokAuthAdapter {
  * proactively refreshes) the stored OAuth credentials per request instead.
  */
 export declare function createGrokSubscriptionFetch(auth: GrokAuthAdapter, baseFetch?: ChatGptFetch): ChatGptFetch;
+export interface GrokModelDescriptor {
+    id: string;
+    name?: string;
+    /** Server-declared context window (the /models `context_window` field). */
+    contextWindow?: number;
+    /** Server-declared reasoning effort ladder, sorted ascending. */
+    reasoningEfforts?: ThinkingLevel[];
+    /** Server-declared default effort (the /models `reasoning_effort` field). */
+    defaultReasoningEffort?: ThinkingLevel;
+}
+/**
+ * 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. The /models payload carries richer metadata than id+name —
+ * `context_window`, `reasoning_efforts`, and the default `reasoning_effort` —
+ * which this surfaces so discovery can stop inferring them. Throws on a
+ * non-2xx so callers fall back to the curated catalog.
+ */
+export declare function fetchGrokSubscriptionModels(baseURL: string, auth: GrokAuthAdapter, options?: {
+    timeoutMs?: number;
+    fetch?: ChatGptFetch;
+}): Promise<GrokModelDescriptor[]>;

package/dist/provider-grok.js

@@ -8,6 +8,7 @@
  * OAuth bearer fresh across long sessions.
  */
 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";
 // The proxy rejects requests below a minimum client version; identify as the
 // same pinned CLI build Bubble verifies elsewhere.
@@ -57,3 +58,49 @@ 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. The /models payload carries richer metadata than id+name —
+ * `context_window`, `reasoning_efforts`, and the default `reasoning_effort` —
+ * which this surfaces so discovery can stop inferring them. Throws on a
+ * non-2xx so callers fall back to the curated catalog.
+ */
+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) => {
+        const id = entry.id;
+        const rawEfforts = Array.isArray(entry.reasoning_efforts) ? entry.reasoning_efforts : [];
+        const reasoningEfforts = rawEfforts
+            .map((effort) => (effort && typeof effort === "object" && typeof effort.value === "string"
+            ? effort.value
+            : undefined))
+            .filter((value) => typeof value === "string" && THINKING_LEVELS.includes(value))
+            .sort((a, b) => THINKING_LEVELS.indexOf(a) - THINKING_LEVELS.indexOf(b));
+        const defaultReasoningEffort = typeof entry.reasoning_effort === "string"
+            && THINKING_LEVELS.includes(entry.reasoning_effort)
+            ? entry.reasoning_effort
+            : undefined;
+        return {
+            id,
+            name: typeof entry.name === "string" ? entry.name : undefined,
+            contextWindow: typeof entry.context_window === "number" && entry.context_window > 0
+                ? entry.context_window
+                : undefined,
+            reasoningEfforts: reasoningEfforts.length > 0 ? reasoningEfforts : undefined,
+            defaultReasoningEffort,
+        };
+    });
+}

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;
@@ -77,6 +77,7 @@ export declare class ProviderRegistry {
     private modelConfig;
     private authStorage;
     private modelDiscoveryCache;
+    private readonly discoveryDiskCachePath;
     private modelDiscoveryInFlight;
     private modelDiscoveryGeneration;
     /** Last membership seen per discovery key — survives cache eviction/TTL so
@@ -85,6 +86,14 @@ export declare class ProviderRegistry {
     private routingRevision;
     private identityFingerprints;
     constructor(config: UserConfig);
+    /** The on-disk cache is production-only; disable it under the test runner so
+     *  tests sharing one isolated BUBBLE_HOME never contaminate each other. */
+    private get discoveryDiskCacheEnabled();
+    /** Restore a prior successful discovery so dynamic models resolve without a
+     *  network round-trip right after startup (no fetch on every launch). */
+    private loadDiscoveryDiskCache;
+    /** Persist successful discoveries so the next launch can reuse them. */
+    private saveDiscoveryDiskCache;
     /**
      * Monotonic counter of semantic routing-world changes: provider set,
      * credential identity, provider key/config, discovery membership.

package/dist/provider-registry.js

@@ -5,11 +5,15 @@
  * Reads provider configuration from models.json first, then falls back to config.json.
  */
 import { createHash } from "node:crypto";
-import { BUILTIN_PROVIDERS as CATALOG_PROVIDERS, clearDynamicModelMetadata, getBuiltinModel, getBuiltinProvider, listBuiltinModels, replaceDynamicModelMetadata, } from "./model-catalog.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getBubbleHome } from "./bubble-home.js";
+import { BUILTIN_PROVIDERS as CATALOG_PROVIDERS, clearDynamicModelMetadata, getBuiltinModel, getBuiltinProvider, inferGrokModelMetadata, listBuiltinModels, replaceDynamicModelMetadata, } from "./model-catalog.js";
 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 } 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). */
@@ -59,6 +63,8 @@ export function sanitizeProviderHeaders(value) {
 }
 const MODEL_DISCOVERY_SUCCESS_TTL_MS = 60_000;
 const MODEL_DISCOVERY_FAILURE_TTL_MS = 10_000;
+/** How long a successful discovery survives on disk before a fresh fetch. */
+const MODEL_DISCOVERY_DISK_TTL_MS = 24 * 60 * 60 * 1000;
 /** Discovery must never delay startup or a model picker for long. */
 const MODEL_DISCOVERY_TIMEOUT_MS = 5_000;
 export const BUILTIN_PROVIDERS = CATALOG_PROVIDERS;
@@ -73,6 +79,7 @@ export class ProviderRegistry {
     modelConfig;
     authStorage;
     modelDiscoveryCache = new Map();
+    discoveryDiskCachePath = join(getBubbleHome(), "model-discovery-cache.json");
     modelDiscoveryInFlight = new Map();
     modelDiscoveryGeneration = new Map();
     /** Last membership seen per discovery key — survives cache eviction/TTL so
@@ -90,6 +97,72 @@ export class ProviderRegistry {
                 this.identityFingerprints.set(authKey, fingerprint);
         }
         this.authStorage.onMutation((authKey) => this.handleAuthMutation(authKey));
+        this.loadDiscoveryDiskCache();
+    }
+    /** The on-disk cache is production-only; disable it under the test runner so
+     *  tests sharing one isolated BUBBLE_HOME never contaminate each other. */
+    get discoveryDiskCacheEnabled() {
+        const v = process.env.VITEST?.trim().toLowerCase();
+        return v !== "true" && v !== "1";
+    }
+    /** Restore a prior successful discovery so dynamic models resolve without a
+     *  network round-trip right after startup (no fetch on every launch). */
+    loadDiscoveryDiskCache() {
+        if (!this.discoveryDiskCacheEnabled)
+            return;
+        try {
+            if (!existsSync(this.discoveryDiskCachePath))
+                return;
+            const parsed = JSON.parse(readFileSync(this.discoveryDiskCachePath, "utf8"));
+            const now = Date.now();
+            for (const [key, entry] of Object.entries(parsed)) {
+                if (!entry || typeof entry.expiresAt !== "number" || entry.expiresAt <= now)
+                    continue;
+                if (!entry.result || !Array.isArray(entry.result.models))
+                    continue;
+                this.modelDiscoveryCache.set(key, {
+                    result: entry.result,
+                    expiresAt: entry.expiresAt,
+                    identityKey: entry.identityKey ?? "unknown",
+                    providerId: entry.providerId ?? "",
+                    authType: entry.authType,
+                    protocol: entry.protocol,
+                });
+                // Rebuild the dynamic overlay so context window / reasoning levels
+                // resolve from the cached catalog at startup, not only on /model open.
+                if (entry.providerId) {
+                    this.applyDynamicDiscoveryMetadata({ id: entry.providerId, authType: entry.authType, protocol: entry.protocol }, entry.result);
+                }
+            }
+        }
+        catch {
+            // Missing/corrupt cache is fine; the next discovery re-fetches.
+        }
+    }
+    /** Persist successful discoveries so the next launch can reuse them. */
+    saveDiscoveryDiskCache() {
+        if (!this.discoveryDiskCacheEnabled)
+            return;
+        try {
+            const data = {};
+            for (const [key, entry] of this.modelDiscoveryCache) {
+                if (entry.result.error)
+                    continue;
+                data[key] = {
+                    result: entry.result,
+                    expiresAt: Date.now() + MODEL_DISCOVERY_DISK_TTL_MS,
+                    identityKey: entry.identityKey,
+                    providerId: entry.providerId,
+                    authType: entry.authType,
+                    protocol: entry.protocol,
+                };
+            }
+            mkdirSync(dirname(this.discoveryDiskCachePath), { recursive: true });
+            writeFileSync(this.discoveryDiskCachePath, JSON.stringify(data, null, 2), { mode: 0o600 });
+        }
+        catch {
+            // Persistence is best-effort.
+        }
     }
     /**
      * Monotonic counter of semantic routing-world changes: provider set,
@@ -419,7 +492,12 @@ export class ProviderRegistry {
                 result: { ...result, source: result.source === "cache" ? "remote" : result.source },
                 expiresAt: Date.now() + (result.error ? MODEL_DISCOVERY_FAILURE_TTL_MS : MODEL_DISCOVERY_SUCCESS_TTL_MS),
                 identityKey: this.discoveryIdentity(provider),
+                providerId: provider.id,
+                authType: provider.authType,
+                protocol: provider.protocol,
             });
+            if (!result.error)
+                this.saveDiscoveryDiskCache();
             this.lastDiscoveryMembership.set(key, {
                 ids: result.models.map((model) => model.id),
                 authoritative: result.authoritative,
@@ -521,6 +599,59 @@ 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 = inferGrokModelMetadata(entry.id);
+                    // Prefer the server-declared effort ladder and context window over
+                    // id-based inference; fall back to inference only when the endpoint
+                    // omitted them (or for ids that don't match a known family).
+                    const levels = entry.reasoningEfforts && entry.reasoningEfforts.length > 0
+                        ? entry.reasoningEfforts
+                        : inferred.levels;
+                    const defaultLevel = entry.defaultReasoningEffort && levels.includes(entry.defaultReasoningEffort)
+                        ? entry.defaultReasoningEffort
+                        : inferred.defaultLevel;
+                    return {
+                        id: entry.id,
+                        name: entry.name || entry.id,
+                        providerId: currentProvider.id,
+                        reasoningLevels: levels,
+                        ...(defaultLevel ? { defaultReasoningLevel: defaultLevel } : {}),
+                        ...(entry.contextWindow !== undefined
+                            ? { contextWindow: entry.contextWindow }
+                            : inferred.contextWindow !== undefined
+                                ? { contextWindow: inferred.contextWindow }
+                                : {}),
+                    };
+                })
+                    .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 +773,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 +786,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/provider.js

@@ -397,6 +397,9 @@ function extractBalancedJson(s, start) {
  * execute safely.
  */
 export async function* translateOpenAIFullResponse(response) {
+    if (typeof response?.system_fingerprint === "string" && response.system_fingerprint) {
+        yield { type: "response_metadata", systemFingerprint: response.system_fingerprint };
+    }
     const usageChunk = usageToStreamChunk(response?.usage);
     if (usageChunk)
         yield usageChunk;
@@ -502,6 +505,7 @@ export async function* translateOpenAIStream(stream, options = {}) {
     let reasoningBuffer = "";
     let textBuffer = "";
     let rawChunkSeq = 0;
+    let systemFingerprint;
     // DeepSeek (and some inference re-hosts) sometimes deliver reasoning twice:
     // once via a dedicated `reasoning_content` / `thinking` field, and again
     // embedded as `<think>...</think>` inside `delta.content`. Track whether we
@@ -553,6 +557,13 @@ export async function* translateOpenAIStream(stream, options = {}) {
         const delta = choice?.delta;
         const usage = chunk.usage ?? choice?.usage;
         const finishReason = choice?.finish_reason;
+        if (typeof chunk?.system_fingerprint === "string"
+            && chunk.system_fingerprint
+            && chunk.system_fingerprint !== systemFingerprint) {
+            const nextSystemFingerprint = chunk.system_fingerprint;
+            systemFingerprint = nextSystemFingerprint;
+            yield { type: "response_metadata", systemFingerprint: nextSystemFingerprint };
+        }
         debugReasoningStream({
             stage: "provider_raw",
             providerId: options.debugProviderId,

package/dist/session-log.js

@@ -203,6 +203,7 @@ function normalizeMessageToEntries(message, id, timestamp) {
                     providerId: message.providerId,
                     modelId: message.modelId,
                     usage: message.usage,
+                    systemFingerprint: message.systemFingerprint,
                     error: message.error,
                     providerMetadata: sanitizeAssistantProviderMetadata(cloneProviderMetadata(message.providerMetadata)),
                 },

package/dist/tui-ink/app.js

@@ -22,6 +22,7 @@ import { SkillRegistry } from "../skills/registry.js";
 import { parseSkillInvocation } from "../skills/invocation.js";
 import { useTerminalSize } from "./use-terminal-size.js";
 import { WelcomeBanner, shouldShowWelcomeBanner } from "./welcome.js";
+import { BubbleCodeWordmark } from "./wordmark.js";
 import { expandAtMentions } from "./file-mentions.js";
 import { TodosPanel } from "./todos.js";
 import { CompactionProgressCard } from "./compaction-progress.js";
@@ -56,6 +57,7 @@ import { GROK_SUBSCRIPTION_PROVIDER_ID, isGrokSubscriptionProviderId, withGrokSu
 import { classifyExternalRuntimeBinding, stopExternalRuntimeForSessionSwitch, } from "../external-runtime/session-policy.js";
 import os from "node:os";
 import { rmSync } from "node:fs";
+import { execFile } from "node:child_process";
 function buildTips(agent, registry, grokActive = false) {
     const tips = [];
     if (grokActive) {
@@ -116,6 +118,25 @@ function truncate(value, max) {
         return value;
     return `${value.slice(0, Math.max(0, max - 1))}…`;
 }
+function formatCompactTokens(n) {
+    if (n < 1000)
+        return `${Math.round(n)}`;
+    if (n < 1_000_000)
+        return `${(n / 1000).toFixed(n >= 10000 ? 0 : 1)}K`;
+    return `${(n / 1_000_000).toFixed(n >= 10_000_000 ? 0 : 1)}M`;
+}
+function formatContextUsageLabel(snapshot) {
+    if (!snapshot.contextWindow || snapshot.contextWindow <= 0) {
+        return `${formatCompactTokens(snapshot.usedTokens)} context`;
+    }
+    const percent = (snapshot.usedTokens / snapshot.contextWindow) * 100;
+    const label = percent >= 10
+        ? `${Math.round(percent)}%`
+        : percent >= 0.05
+            ? `${percent.toFixed(1)}%`
+            : "<0.1%";
+    return `${label} context`;
+}
 export function reconstructDisplayMessages(agentMessages) {
     const result = [];
     for (const m of agentMessages) {
@@ -168,13 +189,14 @@ export function reconstructDisplayMessages(agentMessages) {
             const content = interrupted
                 ? stripInterruptedAssistantMarker(m.content, INTERRUPTED_ASSISTANT_CONTENT)
                 : m.content;
-            if (content || m.reasoning || toolCalls.length > 0) {
+            if (content || m.reasoning || toolCalls.length > 0 || m.systemFingerprint) {
                 result.push({
                     key: nextDisplayMessageKey("asst"),
                     role: "assistant",
                     content,
                     reasoning: m.reasoning || undefined,
                     toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                    systemFingerprint: m.systemFingerprint,
                 });
             }
             if (interrupted) {
@@ -328,21 +350,31 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
     }, [subagentMembers.length, subagentEntryFocused]);
     // Live progress for a manual `/compact` run (null when not compacting).
     const [compaction, setCompaction] = useState(null);
-    // Normalize agent.thinking against the current model's supported levels so the
-    // banner displays the *effective* level, not a stale user-config value like
-    // "xhigh" when switching to a model that only supports ["high","max","off"].
-    const [thinkingLevel, setThinkingLevel] = useState(() => {
-        const modelParts = agent.model.includes(":")
-            ? agent.model.split(":")
-            : [agent.providerId || safeRegistry.getDefault()?.id || "openai", agent.model];
-        const providerId = modelParts[0];
-        const modelId = modelParts.slice(1).join(":");
-        const availableLevels = getAvailableThinkingLevels(providerId, modelId);
-        return normalizeThinkingLevel(agent.thinking, availableLevels);
-    });
+    // The reasoning level is persisted on the agent (agent.thinking); display it
+    // directly. switchAgentModel re-normalizes on explicit model switches, so the
+    // initial value needs no clamping against the (possibly not-yet-discovered)
+    // model ladder.
+    const [thinkingLevel, setThinkingLevel] = useState(agent.thinking);
     const [permissionMode, setPermissionMode] = useState(agent.mode);
     const [todos, setTodos] = useState(() => agent.getTodos());
     const [goalLine, setGoalLine] = useState("");
+    const [branch, setBranch] = useState(undefined);
+    const [contextUsage, setContextUsage] = useState("");
+    useEffect(() => {
+        let cancelled = false;
+        execFile("git", ["-C", args.cwd, "branch", "--show-current"], { timeout: 3000 }, (error, stdout) => {
+            if (cancelled)
+                return;
+            if (error)
+                return;
+            const name = stdout.trim();
+            setBranch(name || undefined);
+        });
+        return () => { cancelled = true; };
+    }, [args.cwd]);
+    useEffect(() => {
+        setContextUsage(formatContextUsageLabel(agent.getContextUsageSnapshot()));
+    }, [agent]);
     const [currentUpdateNotice, setCurrentUpdateNotice] = useState(updateNotice);
     const [pendingPlan, setPendingPlan] = useState(null);
     const [pendingApproval, setPendingApproval] = useState(null);
@@ -1075,6 +1107,7 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
             const effortNote = nextThinkingLevel && nextThinkingLevel !== "off"
                 ? (isThinkingToggle || isThinkingOnly ? " in thinking mode" : ` with ${nextThinkingLevel} effort`)
                 : "";
+            setContextUsage(formatContextUsageLabel(agent.getContextUsageSnapshot()));
             addMessage("assistant", `Model switched to ${displayModel(model)}${effortNote}.`, "ui_notice");
             closePicker();
             return nextThinkingLevel;
@@ -1415,6 +1448,7 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                 let runErrored = false;
                 const toolCalls = [];
                 const assistantParts = [];
+                let assistantSystemFingerprint;
                 // Entries whose members all reached a final status are now covered by
                 // the settled transcript; drop them so the accumulator stays bounded
                 // across a long session. Running entries survive — for a workflow
@@ -1480,6 +1514,9 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                     if (taskElapsedMs !== undefined && Number.isFinite(taskElapsedMs) && taskElapsedMs > 0) {
                         msg.taskElapsedMs = taskElapsedMs;
                     }
+                    if (assistantSystemFingerprint) {
+                        msg.systemFingerprint = assistantSystemFingerprint;
+                    }
                     updateDisplayMessages((prev) => [...prev, msg]);
                     if (runExternalRuntime) {
                         runSessionManager.appendMessage({
@@ -1502,6 +1539,7 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                     setStreamingParts([]);
                     assistantContent = "";
                     assistantReasoning = "";
+                    assistantSystemFingerprint = undefined;
                     toolCalls.length = 0;
                     assistantParts.length = 0;
                 };
@@ -1719,6 +1757,8 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                                     goalRunUsageReported = true;
                                     goalRunTokens += tokenUsageTotal(event.usage);
                                 }
+                                assistantSystemFingerprint = event.systemFingerprint;
+                                setContextUsage(formatContextUsageLabel(agent.getContextUsageSnapshot()));
                                 if (event.willContinue) {
                                     commitAssistantMessage();
                                     clearAssistantStream();
@@ -2375,7 +2415,16 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
     const bannerThinkingLabel = grokSessionBound
         ? externalRuntimeBinding?.reasoningEffort
         : !externalSessionBound && showThinkingLabel ? thinkingLevel : undefined;
-    const welcomeBannerNode = showWelcome ? (_jsx(WelcomeBanner, { terminalColumns: terminalColumns, tips: bannerTips, updateNotice: currentUpdateNotice, cwd: friendlyCwd(args.cwd), sessionLabel: sessionBasename(currentSessionFile()), providerId: bannerProviderId, modelId: bannerModelId, modelLabel: bannerModelLabel, thinkingLabel: bannerThinkingLabel })) : null;
+    // Footer surfaces the graded effort level too (grok/DeepSeek/OpenAI ladders),
+    // but skips on/off toggles and thinking-only placeholders ("medium").
+    const footerThinkingLabel = !externalSessionBound
+        && thinkingLevel
+        && thinkingLevel !== "off"
+        && !isThinkingToggle
+        && !isThinkingOnly
+        ? thinkingLevel
+        : undefined;
+    const welcomeBannerNode = showWelcome ? (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(BubbleCodeWordmark, { width: terminalColumns }), _jsx(WelcomeBanner, { terminalColumns: terminalColumns, tips: bannerTips, updateNotice: currentUpdateNotice, cwd: friendlyCwd(args.cwd), sessionLabel: sessionBasename(currentSessionFile()), providerId: bannerProviderId, modelId: bannerModelId, modelLabel: bannerModelLabel, thinkingLabel: bannerThinkingLabel })] })) : null;
     const commandPaletteItems = useMemo(() => buildCommandPaletteItems(safeSkillRegistry, externalSessionBound), [externalSessionBound, safeSkillRegistry]);
     const mcpReconnectItems = useMemo(() => buildMcpReconnectItems(mcpManager), [mcpManager]);
     // No fixed-height frame: settled rows flow into the terminal's native
@@ -2502,6 +2551,15 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                                     ? `Grok Subscription${externalRuntimeBinding?.modelId ? ` · ${externalRuntimeBinding.modelId}` : ""}${externalRuntimeBinding?.reasoningEffort && externalRuntimeBinding.reasoningEffort !== "off" ? ` · ${externalRuntimeBinding.reasoningEffort}` : ""} · workspace`
                                     : "Unsupported external runtime · recovery-only")
                                 : undefined,
+                            cwd: friendlyCwd(args.cwd),
+                            branch,
+                            model: externalSessionBound
+                                ? undefined
+                                : (agent.model
+                                    ? `${displayModel(agent.model)}${footerThinkingLabel ? ` · ${footerThinkingLabel}` : ""}`
+                                    : undefined),
+                            sessionTitle: externalSessionBound ? undefined : (sessionManager?.getMetadata().title?.trim() || undefined),
+                            contextUsage: externalSessionBound ? undefined : (contextUsage || undefined),
                         }) }) }))] }) }));
 }
 function buildCommandPaletteItems(skillRegistry, grokSessionBound = false) {

package/dist/tui-ink/display-history.d.ts

@@ -17,6 +17,8 @@ export interface DisplayMessage {
     compactionSummary?: string;
     hiddenCount?: number;
     taskElapsedMs?: number;
+    /** Backend configuration fingerprint reported for this model response. */
+    systemFingerprint?: string;
 }
 export declare function userInputStatusBadgeLabel(status?: UserInputStatus): string | undefined;
 export declare function setUserInputStatus(message: DisplayMessage, inputStatus?: UserInputStatus): DisplayMessage;

package/dist/tui-ink/footer.d.ts

@@ -3,11 +3,22 @@ export interface FooterData {
     mode?: PermissionMode;
     goalLine?: string;
     runtimeLabel?: string;
+    /** Friendly working directory (e.g. `~/project`). */
+    cwd?: string;
+    /** Current git branch, when the cwd is a git repo. */
+    branch?: string;
+    /** Display name of the active model. */
+    model?: string;
+    /** Current session title, when one has been assigned. */
+    sessionTitle?: string;
+    /** Compact context usage, e.g. `42K/500K`. */
+    contextUsage?: string;
 }
 /**
- * Bottom status line. Path / provider / model live in the welcome banner and
- * the model-switch transcript notices; the footer only surfaces the
- * permission-mode badge, so it renders nothing (zero rows) in the default mode.
+ * Bottom status line. Always surfaces a `cwd | branch | model | title | ctx`
+ * row (each segment only when its data is present), and appends the
+ * permission-mode badge for non-default modes. Renders nothing (zero rows)
+ * when no data is available.
  */
 export declare function FooterBar({ data }: {
     data: FooterData;

package/dist/tui-ink/footer.js

@@ -1,19 +1,33 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from "react";
 import { Box, Text } from "ink";
 import { useTheme } from "./theme.js";
 import { PERMISSION_MODE_INFO } from "../permission/mode.js";
 /**
- * Bottom status line. Path / provider / model live in the welcome banner and
- * the model-switch transcript notices; the footer only surfaces the
- * permission-mode badge, so it renders nothing (zero rows) in the default mode.
+ * Bottom status line. Always surfaces a `cwd | branch | model | title | ctx`
+ * row (each segment only when its data is present), and appends the
+ * permission-mode badge for non-default modes. Renders nothing (zero rows)
+ * when no data is available.
  */
 export function FooterBar({ data }) {
+    const theme = useTheme();
     const showMode = !!data.mode && data.mode !== "default";
     const goalLine = data.goalLine?.trim();
     const runtimeLabel = data.runtimeLabel?.trim();
-    if (!showMode && !goalLine && !runtimeLabel)
+    const segments = [];
+    if (data.cwd?.trim())
+        segments.push({ key: "cwd", text: data.cwd.trim(), color: theme.muted });
+    if (data.branch?.trim())
+        segments.push({ key: "branch", text: data.branch.trim(), color: theme.muted });
+    if (data.model?.trim())
+        segments.push({ key: "model", text: data.model.trim(), color: theme.accent });
+    if (data.sessionTitle?.trim())
+        segments.push({ key: "title", text: data.sessionTitle.trim(), color: theme.muted });
+    if (data.contextUsage?.trim())
+        segments.push({ key: "ctx", text: data.contextUsage.trim(), color: theme.muted });
+    if (!showMode && !goalLine && !runtimeLabel && segments.length === 0)
         return null;
-    return (_jsxs(Box, { paddingX: 1, flexShrink: 0, flexDirection: "column", children: [goalLine && _jsx(GoalBadge, { line: goalLine }), runtimeLabel && _jsx(RuntimeBadge, { label: runtimeLabel }), showMode && _jsx(ModeBadge, { mode: data.mode })] }));
+    return (_jsxs(Box, { paddingX: 1, flexShrink: 0, flexDirection: "column", children: [goalLine && _jsx(GoalBadge, { line: goalLine }), runtimeLabel && _jsx(RuntimeBadge, { label: runtimeLabel }), (segments.length > 0 || showMode) && (_jsxs(Box, { children: [showMode && (_jsxs(React.Fragment, { children: [_jsx(ModeBadge, { mode: data.mode }), segments.length > 0 && _jsx(Text, { color: theme.muted, children: " | " })] })), segments.map((segment, index) => (_jsxs(React.Fragment, { children: [index > 0 && _jsx(Text, { color: theme.muted, children: " | " }), _jsx(Text, { color: segment.color, children: segment.text })] }, segment.key)))] }))] }));
 }
 function RuntimeBadge({ label }) {
     const theme = useTheme();

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/dist/tui-ink/wordmark.d.ts

@@ -0,0 +1,8 @@
+export interface WordmarkCell {
+    char: string;
+    color: string | null;
+}
+export declare function buildBubbleCodeGrid(): WordmarkCell[][];
+export declare function BubbleCodeWordmark({ width }: {
+    width?: number;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/tui-ink/wordmark.js

@@ -0,0 +1,103 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+/**
+ * Retro terminal pixel-art wordmark: "BUBBLE CODE" rendered in a 5×7 block
+ * font with a light-blue front face and a dark-blue offset shadow (extrusion),
+ * plus a pale highlight along the top edge. Purely decorative; keeps the
+ * terminal background.
+ */
+const LETTER_W = 5;
+const LETTER_H = 7;
+const LETTER_GAP = 2;
+const WORD_GAP = 4;
+const SHADOW_DX = 1;
+const SHADOW_DY = 1;
+const FRONT = "#E0E6ED";
+const SHADOW = "#3A4A5A";
+const HIGHLIGHT = "#FFFFFF";
+// 5×7 bold block pixel font ("1" = filled, "0" = empty).
+const FONT = {
+    B: ["11110", "10001", "10001", "11110", "10001", "10001", "11110"],
+    U: ["10001", "10001", "10001", "10001", "10001", "10001", "01110"],
+    L: ["10000", "10000", "10000", "10000", "10000", "10000", "11111"],
+    E: ["11111", "10000", "10000", "11110", "10000", "10000", "11111"],
+    C: ["01111", "10000", "10000", "10000", "10000", "10000", "01111"],
+    O: ["01110", "10001", "10001", "10001", "10001", "10001", "01110"],
+    D: ["11110", "10001", "10001", "10001", "10001", "10001", "11110"],
+    " ": ["00000", "00000", "00000", "00000", "00000", "00000", "00000"],
+};
+const WORD = "BUBBLE CODE";
+function letterOffsets() {
+    const offsets = [];
+    let x = 0;
+    for (const ch of WORD) {
+        offsets.push({ ch, x });
+        x += ch === " " ? WORD_GAP : LETTER_W + LETTER_GAP;
+    }
+    return offsets;
+}
+export function buildBubbleCodeGrid() {
+    const offsets = letterOffsets();
+    const last = offsets[offsets.length - 1];
+    const width = last.x + LETTER_W + SHADOW_DX;
+    const height = LETTER_H + SHADOW_DY;
+    const grid = Array.from({ length: height }, () => Array.from({ length: width }, () => ({ char: " ", color: null })));
+    const set = (x, y, color) => {
+        if (x >= 0 && x < width && y >= 0 && y < height) {
+            grid[y][x] = { char: "█", color };
+        }
+    };
+    const forEachPixel = (cb) => {
+        for (const { ch, x } of offsets) {
+            const glyph = FONT[ch] ?? FONT[" "];
+            for (let r = 0; r < LETTER_H; r++) {
+                for (let c = 0; c < LETTER_W; c++) {
+                    if (glyph[r][c] === "1")
+                        cb(x + c, r);
+                }
+            }
+        }
+    };
+    // Extrusion (dark blue), offset one cell right + one down.
+    forEachPixel((x, y) => set(x + SHADOW_DX, y + SHADOW_DY, SHADOW));
+    // Front face (light blue).
+    forEachPixel((x, y) => set(x, y, FRONT));
+    // Top-edge highlight (pale blue) for a bit of shine.
+    for (const { ch, x } of offsets) {
+        const glyph = FONT[ch] ?? FONT[" "];
+        for (let c = 0; c < LETTER_W; c++) {
+            if (glyph[0][c] === "1")
+                set(x + c, 0, HIGHLIGHT);
+        }
+    }
+    return grid;
+}
+function mergeRow(row) {
+    const segments = [];
+    let current = null;
+    for (const cell of row) {
+        if (current && current.color === cell.color) {
+            current.text += cell.char;
+        }
+        else {
+            current = { text: cell.char, color: cell.color };
+            segments.push(current);
+        }
+    }
+    // Drop trailing empty cells so the wordmark has no trailing whitespace.
+    while (segments.length > 0 && segments[segments.length - 1].color === null) {
+        segments.pop();
+    }
+    return segments;
+}
+export function BubbleCodeWordmark({ width }) {
+    const grid = buildBubbleCodeGrid();
+    const contentWidth = grid[0]?.length ?? 0;
+    const leftPad = width && width > contentWidth
+        ? Math.floor((width - contentWidth) / 2)
+        : 0;
+    return (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: leftPad, children: grid.map((row, rowIndex) => {
+            const segments = mergeRow(row);
+            return (_jsx(Box, { flexDirection: "row", flexShrink: 0, children: segments.map((segment, segmentIndex) => (_jsx(Text, { color: segment.color ?? undefined, children: segment.text }, segmentIndex))) }, rowIndex));
+        }) }));
+}

package/dist/types.d.ts

@@ -47,6 +47,8 @@ export interface AssistantMessage {
     providerId?: string;
     modelId?: string;
     usage?: TokenUsage;
+    /** Backend configuration fingerprint reported by the model provider. */
+    systemFingerprint?: string;
     error?: {
         name: string;
         message: string;
@@ -310,6 +312,9 @@ export type StreamChunk = {
 } | {
     type: "usage";
     usage: TokenUsage;
+} | {
+    type: "response_metadata";
+    systemFingerprint: string;
 } | {
     type: "done";
 };
@@ -430,6 +435,7 @@ export type AgentEvent = {
     type: "turn_end";
     usage?: TokenUsage;
     cost?: UsageCost;
+    systemFingerprint?: string;
     willContinue?: boolean;
 } | {
     type: "context_recovered";

package/package.json

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