@bubblebrain-ai/bubble 0.0.16 → 0.0.18

package/dist/provider-registry.js

@@ -11,7 +11,7 @@ import { fetchOpenAICodexModels } from "./provider-openai-codex.js";
 import { refreshOpenAICodex } from "./oauth/openai-codex.js";
 export const BUILTIN_PROVIDERS = CATALOG_PROVIDERS;
 export const USER_VISIBLE_PROVIDER_IDS = BUILTIN_PROVIDERS
-    .filter((provider) => provider.id !== "openrouter" && provider.id !== "openai-codex")
+    .filter((provider) => !provider.hidden && provider.id !== "openrouter" && provider.id !== "openai-codex")
     .map((provider) => provider.id);
 export function isUserVisibleProvider(providerId) {
     return USER_VISIBLE_PROVIDER_IDS.includes(providerId);
@@ -123,19 +123,27 @@ export class ProviderRegistry {
             providers = keys.map((id) => {
                 const builtin = getBuiltinProvider(id);
                 const cfg = modelsJsonProviders[id];
+                const baseURL = cfg.baseURL || builtin?.baseURL || "";
                 return {
                     id,
                     name: builtin?.name || id,
-                    baseURL: cfg.baseURL || builtin?.baseURL || "",
+                    baseURL,
                     apiKey: cfg.apiKey || "",
                     enabled: true,
                     authType: "api",
+                    protocol: resolveConfiguredProtocol(id, baseURL, cfg.protocol),
                 };
             });
         }
         else {
             // 2. Fall back to config.json providers (interactive TUI style)
-            providers = this.config.getProviders();
+            providers = this.config.getProviders().map((provider) => {
+                const builtin = getBuiltinProvider(provider.id);
+                return {
+                    ...provider,
+                    protocol: resolveConfiguredProtocol(provider.id, provider.baseURL, provider.protocol),
+                };
+            });
         }
         // 3. Inject OAuth access tokens
         for (const p of providers) {
@@ -283,6 +291,24 @@ export class ProviderRegistry {
         }));
     }
 }
+function resolveConfiguredProtocol(providerId, baseURL, explicitProtocol) {
+    if (explicitProtocol)
+        return explicitProtocol;
+    const builtin = getBuiltinProvider(providerId);
+    if (!builtin?.protocol)
+        return undefined;
+    const normalizedBaseURL = normalizeBaseURL(baseURL);
+    if (!normalizedBaseURL || normalizedBaseURL === normalizeBaseURL(builtin.baseURL)) {
+        return builtin.protocol;
+    }
+    if (normalizedBaseURL.includes("/anthropic")) {
+        return "anthropic-messages";
+    }
+    return undefined;
+}
+function normalizeBaseURL(baseURL) {
+    return baseURL.trim().replace(/\/+$/, "").toLowerCase();
+}
 /** Encode a model selection as "providerId:modelId". */
 export function encodeModel(providerId, modelId) {
     return `${providerId}:${modelId}`;

package/dist/provider-transform.d.ts

@@ -3,7 +3,7 @@ export { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingL
 export interface ProviderRequestConfig {
     effectiveThinkingLevel: ThinkingLevel;
     reasoningEffort?: ThinkingLevel;
-    reasoningContentEcho?: "tool_calls" | "all" | "none";
+    reasoningContentEcho?: "tool_calls" | "all" | "none" | "minimax";
     parallelToolCalls?: boolean;
     maxTokens?: number;
     extraBody?: Record<string, unknown>;

package/dist/provider-transform.js

@@ -4,6 +4,7 @@ const MOONSHOT_PROVIDER_IDS = new Set(["moonshot-cn", "moonshot-intl", "kimi-for
 const KIMI_K25_FAMILY = new Set(["kimi-k2.5", "k2.6-code-preview", "kimi-k2.6"]);
 const KIMI_THINKING_FAMILY = new Set(["kimi-k2-thinking", "kimi-k2-thinking-turbo"]);
 const KIMI_K26_DEFAULT_MAX_TOKENS = 32768;
+const MINIMAX_M3_FAMILY = new Set(["MiniMax-M3"]);
 function isFireworksKimi(providerId, modelId) {
     const model = modelId.toLowerCase();
     return providerId === "fireworks" && (model.includes("kimi")
@@ -45,6 +46,19 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
                 : { reasoning_effort: effectiveThinkingLevel },
         };
     }
+    if (providerId === "minimax" || providerId === "minimax-openai") {
+        const extraBody = { reasoning_split: true };
+        if (MINIMAX_M3_FAMILY.has(modelId)) {
+            extraBody.thinking = {
+                type: effectiveThinkingLevel === "off" ? "disabled" : "adaptive",
+            };
+        }
+        return {
+            effectiveThinkingLevel,
+            reasoningContentEcho: "minimax",
+            extraBody,
+        };
+    }
     // Zhipu/Z.AI OpenAI-compatible endpoints expose reasoning via a provider-specific
     // `thinking` block rather than OpenAI's `reasoning_effort` shape.
     if (["zhipuai", "zhipuai-coding-plan", "zai", "zai-coding-plan"].includes(providerId)) {

package/dist/provider.d.ts

@@ -4,12 +4,14 @@
  * Works with OpenRouter, OpenAI, DeepSeek, Google, Groq, Together, and local OpenAI-compatible endpoints.
  */
 import { type OpenAICodexAuthAdapter } from "./provider-openai-codex.js";
+import type { ProviderProtocol } from "./model-catalog.js";
 import type { Provider, ProviderMessage, StreamChunk, ThinkingLevel } from "./types.js";
-type ReasoningContentEcho = "tool_calls" | "all" | "none";
+type ReasoningContentEcho = "tool_calls" | "all" | "none" | "minimax";
 export type ToolArgsMergeMode = "delta" | "snapshot";
 export interface TranslateOpenAIStreamOptions {
     toolArgsMergeMode?: ToolArgsMergeMode;
     reasoningMergeMode?: ToolArgsMergeMode;
+    textMergeMode?: ToolArgsMergeMode;
     debugProviderId?: string;
     debugModelId?: string;
 }
@@ -24,6 +26,7 @@ export interface ProviderInstanceOptions {
     thinkingLevel?: ThinkingLevel;
     /** Stable per-session seed for provider prompt caches. */
     promptCacheKey?: string;
+    protocol?: ProviderProtocol;
     /** Dynamic OAuth access-token loader/refresh hook for ChatGPT Codex requests. */
     openAICodexAuth?: OpenAICodexAuthAdapter;
 }

package/dist/provider.js

@@ -5,6 +5,7 @@
  */
 import OpenAI from "openai";
 import { appendFileSync } from "node:fs";
+import { createAnthropicMessagesProvider } from "./provider-anthropic.js";
 import { createOpenAICodexProvider, isOpenAICodexBaseUrl } from "./provider-openai-codex.js";
 import { createProviderProtocolArtifactFilter } from "./provider-artifacts.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
@@ -36,6 +37,15 @@ export function toChatCompletionsMessage(message, options = {}) {
             // provider field, even when the original value is an empty string.
             out.reasoning_content = message.reasoning ?? "";
         }
+        if (reasoningContentEcho === "minimax" && message.reasoning) {
+            out.reasoning_details = [{
+                    type: "reasoning.text",
+                    id: "reasoning-text-1",
+                    format: "MiniMax-response-v1",
+                    index: 0,
+                    text: message.reasoning,
+                }];
+        }
         if (message.toolCalls && message.toolCalls.length > 0) {
             out.tool_calls = message.toolCalls.map((tc) => ({
                 id: tc.id,
@@ -65,6 +75,9 @@ export function createUnavailableProvider(message) {
     return { streamChat, complete };
 }
 export function createProviderInstance(options) {
+    if (resolveProviderProtocol(options) === "anthropic-messages") {
+        return createAnthropicMessagesProvider(options);
+    }
     if (isOpenAICodexBaseUrl(options.baseURL)) {
         return createOpenAICodexProvider({
             ...options,
@@ -93,11 +106,11 @@ export function createProviderInstance(options) {
                 reasoningContentEcho: requestConfig.reasoningContentEcho ?? "tool_calls",
             })),
             tools: tools && tools.length > 0 ? tools : undefined,
-            tool_choice: tools && tools.length > 0 ? "auto" : undefined,
+            tool_choice: tools && tools.length > 0 ? chatOptions.toolChoice ?? "auto" : undefined,
             stream: true,
         };
-        // DeepSeek only emits final usage in streaming mode when this flag is set.
-        if (options.providerId === "deepseek") {
+        // DeepSeek and MiniMax only emit final usage in streaming mode when this flag is set.
+        if (options.providerId === "deepseek" || isMiniMaxOpenAICompatible(options)) {
             body.stream_options = { include_usage: true };
         }
         if (!requestConfig.omitTemperature) {
@@ -121,6 +134,7 @@ export function createProviderInstance(options) {
         yield* translateOpenAIStream(stream, {
             toolArgsMergeMode: resolveToolArgsMergeMode(options.providerId || "", options.baseURL),
             reasoningMergeMode: resolveReasoningMergeMode(options.providerId || "", options.baseURL),
+            textMergeMode: resolveTextMergeMode(options.providerId || "", options.baseURL),
             debugProviderId: options.providerId || "",
             debugModelId: chatOptions.model,
         });
@@ -153,6 +167,26 @@ export function createProviderInstance(options) {
     }
     return { streamChat, complete };
 }
+function resolveProviderProtocol(options) {
+    if (options.protocol)
+        return options.protocol;
+    const providerId = (options.providerId || "").toLowerCase();
+    const baseURL = options.baseURL.toLowerCase();
+    if (providerId === "anthropic"
+        || providerId.endsWith("-anthropic")
+        || baseURL.includes("/anthropic")) {
+        return "anthropic-messages";
+    }
+    return "openai-chat";
+}
+function isMiniMaxOpenAICompatible(options) {
+    const providerId = (options.providerId || "").toLowerCase();
+    const baseURL = options.baseURL.toLowerCase();
+    return providerId === "minimax-openai"
+        || (providerId === "minimax" && !baseURL.includes("/anthropic"))
+        || baseURL.includes("api.minimaxi.com/v1")
+        || baseURL.includes("api.minimax.io/v1");
+}
 export function normalizeToolArgsDetailed(raw) {
     const s = (raw ?? "").trim();
     if (!s) {
@@ -210,6 +244,15 @@ function resolveReasoningMergeMode(providerId, baseURL) {
     const url = baseURL.toLowerCase();
     if (id === "fireworks" || url.includes("fireworks.ai"))
         return "snapshot";
+    if (id === "minimax" || url.includes("api.minimaxi.com") || url.includes("api.minimax.io"))
+        return "snapshot";
+    return "delta";
+}
+function resolveTextMergeMode(providerId, baseURL) {
+    const id = providerId.toLowerCase();
+    const url = baseURL.toLowerCase();
+    if (id === "minimax" || url.includes("api.minimaxi.com") || url.includes("api.minimax.io"))
+        return "snapshot";
     return "delta";
 }
 function extractBalancedJson(s, start) {
@@ -257,7 +300,9 @@ export async function* translateOpenAIStream(stream, options = {}) {
     const textFilter = createProviderProtocolArtifactFilter();
     const toolArgsMergeMode = options.toolArgsMergeMode ?? "delta";
     const reasoningMergeMode = options.reasoningMergeMode ?? "delta";
+    const textMergeMode = options.textMergeMode ?? "delta";
     let reasoningBuffer = "";
+    let textBuffer = "";
     let rawChunkSeq = 0;
     // DeepSeek (and some inference re-hosts) sometimes deliver reasoning twice:
     // once via a dedicated `reasoning_content` / `thinking` field, and again
@@ -318,6 +363,7 @@ export async function* translateOpenAIStream(stream, options = {}) {
             reasoning: summarizeDebugText(delta?.reasoning),
             thinking: summarizeDebugText(delta?.thinking),
             reasoningContent: summarizeDebugText(delta?.reasoning_content),
+            reasoningDetails: summarizeDebugText(extractReasoningDetailsText(delta?.reasoning_details)),
         });
         if (usage) {
             yield {
@@ -325,8 +371,16 @@ export async function* translateOpenAIStream(stream, options = {}) {
                 usage: {
                     promptTokens: typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0,
                     completionTokens: typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0,
-                    promptCacheHitTokens: typeof usage.prompt_cache_hit_tokens === "number" ? usage.prompt_cache_hit_tokens : undefined,
-                    promptCacheMissTokens: typeof usage.prompt_cache_miss_tokens === "number" ? usage.prompt_cache_miss_tokens : undefined,
+                    promptCacheHitTokens: typeof usage.prompt_cache_hit_tokens === "number"
+                        ? usage.prompt_cache_hit_tokens
+                        : typeof usage.prompt_tokens_details?.cached_tokens === "number"
+                            ? usage.prompt_tokens_details.cached_tokens
+                            : undefined,
+                    promptCacheMissTokens: typeof usage.prompt_cache_miss_tokens === "number"
+                        ? usage.prompt_cache_miss_tokens
+                        : typeof usage.prompt_tokens_details?.cached_tokens === "number" && typeof usage.prompt_tokens === "number"
+                            ? Math.max(0, usage.prompt_tokens - usage.prompt_tokens_details.cached_tokens)
+                            : undefined,
                     reasoningTokens: typeof usage.completion_tokens_details?.reasoning_tokens === "number"
                         ? usage.completion_tokens_details.reasoning_tokens
                         : undefined,
@@ -334,14 +388,21 @@ export async function* translateOpenAIStream(stream, options = {}) {
                 },
             };
         }
-        const reasoningField = delta?.reasoning !== undefined
-            ? "reasoning"
-            : delta?.thinking !== undefined
-                ? "thinking"
-                : delta?.reasoning_content !== undefined
-                    ? "reasoning_content"
-                    : undefined;
-        const reasoning = reasoningField ? delta[reasoningField] : undefined;
+        const reasoningDetails = extractReasoningDetailsText(delta?.reasoning_details);
+        const reasoningField = reasoningDetails !== undefined
+            ? "reasoning_details"
+            : delta?.reasoning !== undefined
+                ? "reasoning"
+                : delta?.thinking !== undefined
+                    ? "thinking"
+                    : delta?.reasoning_content !== undefined
+                        ? "reasoning_content"
+                        : undefined;
+        const reasoning = reasoningDetails !== undefined
+            ? reasoningDetails
+            : reasoningField
+                ? delta[reasoningField]
+                : undefined;
         if (reasoning) {
             hasDedicatedReasoningChannel = true;
             const merged = mergeStreamingText(reasoningBuffer, reasoning, reasoningMergeMode);
@@ -362,36 +423,41 @@ export async function* translateOpenAIStream(stream, options = {}) {
             }
         }
         if (delta?.content) {
-            const thinkMatch = delta.content.match(/<think>([\s\S]*?)<\/think>/);
-            if (thinkMatch) {
-                if (thinkMatch[1] && !hasDedicatedReasoningChannel) {
-                    const merged = mergeStreamingText(reasoningBuffer, thinkMatch[1], reasoningMergeMode);
-                    reasoningBuffer = merged.args;
-                    debugReasoningStream({
-                        stage: "provider_emit",
-                        providerId: options.debugProviderId,
-                        modelId: options.debugModelId,
-                        chunkSeq: rawChunkSeq,
-                        source: "content_think",
-                        mergeMode: reasoningMergeMode,
-                        suppressed: !merged.delta,
-                        emitted: summarizeDebugText(merged.delta),
-                        buffer: summarizeDebugText(reasoningBuffer),
-                    });
-                    if (merged.delta) {
-                        yield { type: "reasoning_delta", content: merged.delta };
+            const mergedContent = mergeStreamingText(textBuffer, delta.content, textMergeMode);
+            textBuffer = mergedContent.args;
+            const content = mergedContent.delta;
+            if (content) {
+                const thinkMatch = content.match(/<think>([\s\S]*?)<\/think>/);
+                if (thinkMatch) {
+                    if (thinkMatch[1] && !hasDedicatedReasoningChannel) {
+                        const merged = mergeStreamingText(reasoningBuffer, thinkMatch[1], reasoningMergeMode);
+                        reasoningBuffer = merged.args;
+                        debugReasoningStream({
+                            stage: "provider_emit",
+                            providerId: options.debugProviderId,
+                            modelId: options.debugModelId,
+                            chunkSeq: rawChunkSeq,
+                            source: "content_think",
+                            mergeMode: reasoningMergeMode,
+                            suppressed: !merged.delta,
+                            emitted: summarizeDebugText(merged.delta),
+                            buffer: summarizeDebugText(reasoningBuffer),
+                        });
+                        if (merged.delta) {
+                            yield { type: "reasoning_delta", content: merged.delta };
+                        }
+                    }
+                    const remaining = content.replace(/<think>[\s\S]*?<\/think>/, "");
+                    const cleaned = textFilter.push(remaining);
+                    if (cleaned) {
+                        yield { type: "text", content: cleaned };
                     }
                 }
-                const remaining = delta.content.replace(/<think>[\s\S]*?<\/think>/, "");
-                const cleaned = textFilter.push(remaining);
-                if (cleaned) {
-                    yield { type: "text", content: cleaned };
-                }
-            }
-            else {
-                const cleaned = textFilter.push(delta.content);
-                if (cleaned) {
-                    yield { type: "text", content: cleaned };
+                else {
+                    const cleaned = textFilter.push(content);
+                    if (cleaned) {
+                        yield { type: "text", content: cleaned };
+                    }
                 }
             }
         }
@@ -435,6 +501,19 @@ export async function* translateOpenAIStream(stream, options = {}) {
     }
     yield* flushToolCalls();
 }
+function extractReasoningDetailsText(value) {
+    if (!value)
+        return undefined;
+    const details = Array.isArray(value) ? value : [value];
+    const parts = details.flatMap((item) => {
+        if (!item || typeof item !== "object")
+            return [];
+        const record = item;
+        const text = record.text ?? record.thinking ?? record.content;
+        return typeof text === "string" ? [text] : [];
+    });
+    return parts.length > 0 ? parts.join("") : undefined;
+}
 function mergeToolArgumentDelta(current, incoming, mode) {
     if (!current) {
         debugToolArgs({ stage: "merge", branch: "empty-current", current, incoming, args: incoming, delta: incoming });

package/dist/session-log.js

@@ -1,4 +1,4 @@
-import { sanitizeInternalReminderBlocks } from "./agent/internal-reminder-sanitizer.js";
+import { sanitizeAssistantProviderMetadata, sanitizeInternalReminderBlocks } from "./agent/internal-reminder-sanitizer.js";
 export class SessionLog {
     entries = [];
     load(lines) {
@@ -128,6 +128,11 @@ export class SessionLog {
                     messages.push({
                         ...entry.message,
                         role: "assistant",
+                        content: sanitizeInternalReminderBlocks(entry.message.content),
+                        reasoning: entry.message.reasoning !== undefined
+                            ? sanitizeInternalReminderBlocks(entry.message.reasoning)
+                            : undefined,
+                        providerMetadata: sanitizeAssistantProviderMetadata(cloneProviderMetadata(entry.message.providerMetadata)),
                     });
                     break;
                 case "tool_call": {
@@ -190,7 +195,7 @@ function normalizeMessageToEntries(message, id, timestamp) {
                 type: "assistant_message",
                 message: {
                     role: "assistant",
-                    content: message.content,
+                    content: sanitizeInternalReminderBlocks(message.content),
                     reasoning: message.reasoning !== undefined
                         ? sanitizeInternalReminderBlocks(message.reasoning)
                         : undefined,
@@ -199,6 +204,7 @@ function normalizeMessageToEntries(message, id, timestamp) {
                     modelId: message.modelId,
                     usage: message.usage,
                     error: message.error,
+                    providerMetadata: sanitizeAssistantProviderMetadata(cloneProviderMetadata(message.providerMetadata)),
                 },
                 timestamp,
             };
@@ -250,6 +256,7 @@ function cloneMessage(message) {
         return {
             ...message,
             toolCalls: message.toolCalls?.map((toolCall) => ({ ...toolCall })),
+            providerMetadata: cloneProviderMetadata(message.providerMetadata),
         };
     }
     if (message.role === "user" && Array.isArray(message.content)) {
@@ -263,6 +270,11 @@ function cloneMessage(message) {
     }
     return { ...message };
 }
+function cloneProviderMetadata(metadata) {
+    if (metadata === undefined)
+        return undefined;
+    return JSON.parse(JSON.stringify(metadata));
+}
 function pruneIncompleteTail(messages) {
     let currentTurnStart = -1;
     let hasCompletedAssistant = false;

package/dist/session-title.js

@@ -1,6 +1,5 @@
 import { normalizeSingleLine, truncateVisual } from "./text-display.js";
-const LONG_PASTE_CHAR_THRESHOLD = 1000;
-const LONG_PASTE_LINE_THRESHOLD = 20;
+import { createPastedContentMarker, shouldCollapsePastedContent } from "./tui/paste-placeholder.js";
 const TITLE_INPUT_MAX_CHARS = 4000;
 const TITLE_MAX_WIDTH = 80;
 const TITLE_SYSTEM_PROMPT = [
@@ -81,10 +80,8 @@ export function deterministicTitleFromUserContent(content) {
     const text = userContentText(content);
     if (!text)
         return "User message";
-    const charCount = text.length;
-    const lineCount = text.split(/\r?\n/).length;
-    if (charCount > LONG_PASTE_CHAR_THRESHOLD || lineCount > LONG_PASTE_LINE_THRESHOLD) {
-        return `[Pasted Content ${charCount} chars]`;
+    if (shouldCollapsePastedContent(text)) {
+        return createPastedContentMarker(text);
     }
     return truncateVisual(normalizeSingleLine(text), TITLE_MAX_WIDTH) || "User message";
 }

package/dist/slash-commands/commands.js

@@ -4,7 +4,7 @@ import { formatDiagnostics } from "../lsp/index.js";
 import { normalizeNameForMCP } from "../mcp/name.js";
 import { parseRule } from "../permissions/rule.js";
 import { encodeModel, decodeModel, displayModel, BUILTIN_PROVIDERS, isUserVisibleProvider } from "../provider-registry.js";
-import { getAvailableThinkingLevels, normalizeThinkingLevel } from "../provider-transform.js";
+import { getAvailableThinkingLevels, getDefaultThinkingLevel, 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";
@@ -61,6 +61,9 @@ function persistSelectedModel(model, ctx) {
 }
 function syncSystemPrompt(ctx, model) {
     const { providerId, modelId } = decodeModel(model);
+    const toolPromptOptions = typeof ctx.agent.getSystemPromptToolOptions === "function"
+        ? ctx.agent.getSystemPromptToolOptions()
+        : {};
     ctx.agent.setSystemPrompt(buildSystemPrompt({
         agentName: "Bubble",
         configuredProvider: providerId,
@@ -68,6 +71,7 @@ function syncSystemPrompt(ctx, model) {
         configuredModelId: model,
         thinkingLevel: ctx.agent.thinking,
         workingDir: ctx.cwd,
+        ...toolPromptOptions,
         memoryPrompt: buildMemoryPrompt(ctx.cwd),
     }));
 }
@@ -131,7 +135,9 @@ function parseModelArgs(args) {
 }
 function displaySelectedModel(model, thinkingLevel) {
     const label = displayModel(model);
-    return thinkingLevel === "off" ? label : `${label} (${thinkingLevel})`;
+    const { providerId, modelId } = decodeModel(model);
+    const defaultLevel = providerId ? getDefaultThinkingLevel(providerId, modelId) : "off";
+    return thinkingLevel === "off" || thinkingLevel === defaultLevel ? label : `${label} (${thinkingLevel})`;
 }
 function parseMemoryScopeArgs(args) {
     const tokens = args.trim().split(/\s+/).filter(Boolean);

package/dist/stats/usage.d.ts

@@ -20,6 +20,7 @@ export interface ModelUsageStats {
     completionTokens: number;
     promptCacheHitTokens: number;
     promptCacheMissTokens: number;
+    cacheCreationTokens: number;
     reasoningTokens: number;
     totalTokens: number;
     cost?: number;

package/dist/stats/usage.js

@@ -187,6 +187,7 @@ function addModelUsage(accumulator, model, message, usage) {
         completionTokens: 0,
         promptCacheHitTokens: 0,
         promptCacheMissTokens: 0,
+        cacheCreationTokens: 0,
         reasoningTokens: 0,
         totalTokens: 0,
     };
@@ -195,6 +196,7 @@ function addModelUsage(accumulator, model, message, usage) {
     existing.completionTokens += usage.completionTokens;
     existing.promptCacheHitTokens += usage.promptCacheHitTokens ?? 0;
     existing.promptCacheMissTokens += usage.promptCacheMissTokens ?? 0;
+    existing.cacheCreationTokens += usage.cacheCreationTokens ?? 0;
     existing.reasoningTokens += usage.reasoningTokens ?? 0;
     existing.totalTokens += tokenTotal(usage);
     if (providerId && modelId) {
@@ -284,6 +286,9 @@ function formatSummaryLines(stats, width) {
     if (favorite) {
         lines.push(`  Favorite model ${truncate(favorite, Math.max(12, width - 17))}`);
     }
+    const cacheSummary = formatCacheSummary(stats.models);
+    if (cacheSummary)
+        lines.push(`  ${cacheSummary}`);
     const trackedCostText = formatTrackedCosts(stats);
     if (trackedCostText)
         lines.push(`  Tracked cost ${trackedCostText}`);
@@ -293,6 +298,17 @@ function formatSummaryLines(stats, width) {
     }
     return lines;
 }
+function formatCacheSummary(models) {
+    const read = models.reduce((sum, model) => sum + model.promptCacheHitTokens, 0);
+    const create = models.reduce((sum, model) => sum + model.cacheCreationTokens, 0);
+    const missWithCreate = models.reduce((sum, model) => sum + model.promptCacheMissTokens, 0);
+    const miss = Math.max(0, missWithCreate - create);
+    const observed = read + create + miss;
+    if (observed === 0)
+        return undefined;
+    const hitRate = Math.round((read / observed) * 100);
+    return `Prompt cache ${formatCompactNumber(read)} read · ${formatCompactNumber(create)} create · ${formatCompactNumber(miss)} miss · ${hitRate}% hit`;
+}
 function aggregateCosts(models) {
     const totals = {};
     for (const model of models) {
@@ -355,15 +371,24 @@ function normalizeUsage(raw) {
     if (!raw || typeof raw !== "object")
         return undefined;
     const value = raw;
-    const promptTokens = numberValue(value.promptTokens) ?? numberValue(value.input_tokens);
+    const rawInputTokens = numberValue(value.input_tokens);
+    const cacheReadTokens = numberValue(value.promptCacheHitTokens) ?? numberValue(value.cache_read_input_tokens);
+    const cacheCreationTokens = numberValue(value.cacheCreationTokens) ?? numberValue(value.cache_creation_input_tokens);
+    const promptTokens = numberValue(value.promptTokens)
+        ?? (rawInputTokens !== undefined
+            ? rawInputTokens + (cacheReadTokens ?? 0) + (cacheCreationTokens ?? 0)
+            : undefined);
     const completionTokens = numberValue(value.completionTokens) ?? numberValue(value.output_tokens);
     if (promptTokens === undefined || completionTokens === undefined)
         return undefined;
     return {
         promptTokens,
         completionTokens,
-        promptCacheHitTokens: numberValue(value.promptCacheHitTokens) ?? numberValue(value.cache_read_input_tokens),
-        promptCacheMissTokens: numberValue(value.promptCacheMissTokens) ?? numberValue(value.cache_creation_input_tokens),
+        promptCacheHitTokens: cacheReadTokens,
+        promptCacheMissTokens: numberValue(value.promptCacheMissTokens)
+            ?? numberValue(value.cache_miss_input_tokens)
+            ?? (rawInputTokens !== undefined ? rawInputTokens + (cacheCreationTokens ?? 0) : undefined),
+        cacheCreationTokens,
         reasoningTokens: numberValue(value.reasoningTokens),
         totalTokens: numberValue(value.totalTokens) ?? numberValue(value.total_tokens),
     };