@bubblebrain-ai/bubble 0.0.15 → 0.0.17

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")
@@ -36,6 +37,28 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
             },
         };
     }
+    if (providerId === "stepfun") {
+        return {
+            effectiveThinkingLevel,
+            reasoningContentEcho: "none",
+            extraBody: effectiveThinkingLevel === "off"
+                ? undefined
+                : { 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,
@@ -96,8 +109,8 @@ export function createProviderInstance(options) {
             tool_choice: tools && tools.length > 0 ? "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/reasoning-debug.js

@@ -1,8 +1,10 @@
 import { createHash } from "node:crypto";
 import { appendFileSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
+import { sanitizeInternalReminderBlocks } from "./agent/internal-reminder-sanitizer.js";
 const DEBUG_PATH = process.env.BUBBLE_DEBUG_REASONING_STREAM?.trim();
 const INCLUDE_PREVIEW = process.env.BUBBLE_DEBUG_REASONING_PREVIEW !== "0";
+const INCLUDE_RAW_PREVIEW = ["1", "true", "yes", "on"].includes(process.env.BUBBLE_DEBUG_REASONING_RAW?.trim().toLowerCase() ?? "");
 const PREVIEW_CHARS = 180;
 let sequence = 0;
 export function summarizeDebugText(value) {
@@ -13,7 +15,8 @@ export function summarizeDebugText(value) {
     const hash = createHash("sha256").update(value).digest("hex").slice(0, 16);
     const summary = { length: value.length, hash };
     if (INCLUDE_PREVIEW) {
-        summary.preview = value.replace(/\s+/g, " ").slice(0, PREVIEW_CHARS);
+        const previewValue = INCLUDE_RAW_PREVIEW ? value : sanitizeInternalReminderBlocks(value);
+        summary.preview = previewValue.replace(/\s+/g, " ").slice(0, PREVIEW_CHARS);
     }
     return summary;
 }

package/dist/session-log.js

@@ -1,3 +1,4 @@
+import { sanitizeAssistantProviderMetadata, sanitizeInternalReminderBlocks } from "./agent/internal-reminder-sanitizer.js";
 export class SessionLog {
     entries = [];
     load(lines) {
@@ -127,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": {
@@ -189,13 +195,16 @@ function normalizeMessageToEntries(message, id, timestamp) {
                 type: "assistant_message",
                 message: {
                     role: "assistant",
-                    content: message.content,
-                    reasoning: message.reasoning,
+                    content: sanitizeInternalReminderBlocks(message.content),
+                    reasoning: message.reasoning !== undefined
+                        ? sanitizeInternalReminderBlocks(message.reasoning)
+                        : undefined,
                     model: message.model,
                     providerId: message.providerId,
                     modelId: message.modelId,
                     usage: message.usage,
                     error: message.error,
+                    providerMetadata: sanitizeAssistantProviderMetadata(cloneProviderMetadata(message.providerMetadata)),
                 },
                 timestamp,
             };
@@ -247,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)) {
@@ -260,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/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";
@@ -131,7 +131,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

@@ -1,3 +1,4 @@
+import type { PricingCurrency } from "../model-pricing.js";
 export type StatsRange = "7d" | "30d";
 export interface DailyUsage {
     date: string;
@@ -22,6 +23,7 @@ export interface ModelUsageStats {
     reasoningTokens: number;
     totalTokens: number;
     cost?: number;
+    costCurrency?: PricingCurrency;
 }
 export interface UsageStats {
     range: StatsRange;
@@ -32,7 +34,9 @@ export interface UsageStats {
     heatmap: HeatmapColumn[];
     models: ModelUsageStats[];
     totalTokens: number;
+    trackedCosts?: Partial<Record<PricingCurrency, number>>;
     trackedCost?: number;
+    trackedCostCurrency?: PricingCurrency;
     activeDays: number;
     sessionsScanned: number;
     sessionsWithoutTokenData: number;

package/dist/stats/usage.js

@@ -61,11 +61,15 @@ export function formatCompactNumber(value) {
     return String(Math.round(value));
 }
 export function formatCurrency(value) {
-    if (value >= 1)
-        return `$${value.toFixed(2)}`;
-    if (value >= 0.01)
-        return `$${value.toFixed(3)}`;
-    return `$${value.toFixed(4)}`;
+    return formatCurrencyFor(value, "USD");
+}
+function formatCurrencyFor(value, currency) {
+    const amount = value >= 1
+        ? value.toFixed(2)
+        : value >= 0.01
+            ? value.toFixed(3)
+            : value.toFixed(4);
+    return currency === "USD" ? `$${amount}` : `CNY ${amount}`;
 }
 function createAccumulator(range, days, now) {
     const end = startOfLocalDay(now);
@@ -146,7 +150,11 @@ function finalizeAccumulator(accumulator) {
         .filter((model) => model.totalTokens > 0)
         .sort((a, b) => b.totalTokens - a.totalTokens);
     const totalTokens = models.reduce((sum, model) => sum + model.totalTokens, 0);
-    const trackedCost = models.reduce((sum, model) => sum + (model.cost ?? 0), 0);
+    const trackedCosts = aggregateCosts(models);
+    const trackedCostEntries = trackedCosts
+        ? Object.entries(trackedCosts)
+        : [];
+    const trackedCostEntry = trackedCostEntries.length === 1 ? trackedCostEntries[0] : undefined;
     return {
         range: accumulator.range,
         days: accumulator.days,
@@ -156,7 +164,9 @@ function finalizeAccumulator(accumulator) {
         heatmap: buildHeatmap(daily),
         models,
         totalTokens,
-        trackedCost: trackedCost > 0 ? trackedCost : undefined,
+        trackedCosts,
+        trackedCost: trackedCostEntry ? trackedCostEntry[1] : undefined,
+        trackedCostCurrency: trackedCostEntry ? trackedCostEntry[0] : undefined,
         activeDays: daily.filter((day) => day.active).length,
         sessionsScanned: accumulator.sessionsScanned,
         sessionsWithoutTokenData: accumulator.sessionsWithoutTokenData,
@@ -189,8 +199,10 @@ function addModelUsage(accumulator, model, message, usage) {
     existing.totalTokens += tokenTotal(usage);
     if (providerId && modelId) {
         const cost = calculateUsageCost(providerId, modelId, usage);
-        if (cost)
+        if (cost) {
             existing.cost = (existing.cost ?? 0) + cost.cost;
+            existing.costCurrency = cost.currency;
+        }
     }
     accumulator.modelUsage.set(key, existing);
 }
@@ -254,7 +266,9 @@ function formatModelUsageLines(stats, width) {
         const percentText = `${Math.round(percent * 100)}%`.padStart(4, " ");
         const tokenText = formatCompactNumber(model.totalTokens).padStart(6, " ");
         const turnsText = `${model.turns}t`.padStart(4, " ");
-        const costText = showCost ? ` ${(model.cost !== undefined ? formatCurrency(model.cost) : "").padStart(7, " ")}` : "";
+        const costText = showCost
+            ? ` ${(model.cost !== undefined ? formatCurrencyFor(model.cost, model.costCurrency ?? "USD") : "").padStart(7, " ")}`
+            : "";
         return `  ${truncate(model.displayName, labelWidth).padEnd(labelWidth, " ")} ${bar} ${percentText} ${tokenText} ${turnsText}${costText}`.trimEnd();
     });
     if (stats.models.length > MAX_MODEL_ROWS) {
@@ -270,14 +284,37 @@ function formatSummaryLines(stats, width) {
     if (favorite) {
         lines.push(`  Favorite model ${truncate(favorite, Math.max(12, width - 17))}`);
     }
-    if (stats.trackedCost !== undefined)
-        lines.push(`  Tracked cost ${formatCurrency(stats.trackedCost)}`);
+    const trackedCostText = formatTrackedCosts(stats);
+    if (trackedCostText)
+        lines.push(`  Tracked cost ${trackedCostText}`);
     lines.push(`  Sessions scanned ${stats.sessionsScanned}`);
     if (stats.sessionsWithoutTokenData > 0) {
         lines.push(`  Sessions without token data ${stats.sessionsWithoutTokenData}`);
     }
     return lines;
 }
+function aggregateCosts(models) {
+    const totals = {};
+    for (const model of models) {
+        if (model.cost === undefined)
+            continue;
+        const currency = model.costCurrency ?? "USD";
+        totals[currency] = (totals[currency] ?? 0) + model.cost;
+    }
+    return Object.keys(totals).length > 0 ? totals : undefined;
+}
+function formatTrackedCosts(stats) {
+    if (stats.trackedCosts) {
+        const parts = Object.entries(stats.trackedCosts)
+            .filter(([, value]) => value > 0)
+            .map(([currency, value]) => formatCurrencyFor(value, currency));
+        return parts.length > 0 ? parts.join(" + ") : undefined;
+    }
+    if (stats.trackedCost !== undefined) {
+        return formatCurrencyFor(stats.trackedCost, stats.trackedCostCurrency ?? "USD");
+    }
+    return undefined;
+}
 function heatmapCell(day, maxTokens) {
     if (!day)
         return " ";

package/dist/tools/glob.js

@@ -65,6 +65,7 @@ export function createGlobTool(cwd) {
             }
             files.sort((a, b) => b.mtimeMs - a.mtimeMs || a.path.localeCompare(b.path));
             const matches = files.slice(0, MAX_RESULTS).map((item) => item.path);
+            const absoluteMatches = matches.map((item) => resolve(root, item));
             const wasTruncated = truncated.value || files.length > MAX_RESULTS;
             if (matches.length === 0) {
                 return {
@@ -78,6 +79,7 @@ export function createGlobTool(cwd) {
                         truncated: false,
                         searchSignature: `glob:${root}:${pattern}`,
                         searchFamily: `glob:${pattern}`,
+                        paths: [],
                     },
                 };
             }
@@ -92,6 +94,7 @@ export function createGlobTool(cwd) {
                     truncated: wasTruncated,
                     searchSignature: `glob:${root}:${pattern}`,
                     searchFamily: `glob:${pattern}`,
+                    paths: absoluteMatches,
                 },
             };
         },

package/dist/tools/grep.js

@@ -2,6 +2,7 @@
  * Grep tool - search file contents using ripgrep.
  */
 import { execFile } from "node:child_process";
+import { resolve as resolvePath } from "node:path";
 import { isSensitivePath } from "./sensitive-paths.js";
 import { analyzeToolIntent } from "../agent/tool-intent.js";
 import { resolveToolPath } from "./path-utils.js";
@@ -57,6 +58,7 @@ export function createGrepTool(cwd) {
                     // rg returns exit code 1 when no matches found, which is not an error for us
                     const lines = stdout.split("\n").filter((l) => l.trim() !== "");
                     const matches = [];
+                    const matchedPaths = new Set();
                     for (const line of lines) {
                         try {
                             const obj = JSON.parse(line);
@@ -64,6 +66,9 @@ export function createGrepTool(cwd) {
                                 const path = obj.data.path.text;
                                 const lineNum = obj.data.line_number;
                                 const text = obj.data.lines.text?.trim() ?? "";
+                                if (typeof path === "string" && path.trim()) {
+                                    matchedPaths.add(resolvePath(cwd, path));
+                                }
                                 matches.push(`${path}:${lineNum}: ${text}`);
                             }
                         }
@@ -83,6 +88,7 @@ export function createGrepTool(cwd) {
                                 truncated: false,
                                 searchSignature: intent.search?.signature,
                                 searchFamily: intent.search?.familyKey,
+                                paths: [],
                             },
                         });
                         return;
@@ -103,6 +109,7 @@ export function createGrepTool(cwd) {
                             truncated,
                             searchSignature: intent.search?.signature,
                             searchFamily: intent.search?.familyKey,
+                            paths: [...matchedPaths],
                         },
                     });
                 });