@bubblebrain-ai/bubble 0.0.16 → 0.0.17

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/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/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/types.d.ts

@@ -14,6 +14,14 @@ export interface ImageContent {
 export type ContentPart = TextContent | ImageContent;
 export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 export type ReasoningEffort = ThinkingLevel;
+export type ProviderRawContentBlock = Record<string, unknown> & {
+    type: string;
+};
+export interface AssistantProviderMetadata {
+    anthropic?: {
+        contentBlocks?: ProviderRawContentBlock[];
+    };
+}
 export interface UserMessage {
     role: "user";
     content: string | ContentPart[];
@@ -23,6 +31,7 @@ export interface AssistantMessage {
     content: string;
     reasoning?: string;
     toolCalls?: ToolCall[];
+    providerMetadata?: AssistantProviderMetadata;
     /** Model metadata captured for local usage statistics. */
     model?: string;
     providerId?: string;
@@ -239,6 +248,10 @@ export type StreamChunk = {
 } | {
     type: "reasoning_delta";
     content: string;
+} | {
+    type: "provider_content_block";
+    provider: "anthropic";
+    block: ProviderRawContentBlock;
 } | {
     type: "tool_call";
     id: string;

package/package.json

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