@bubblebrain-ai/bubble 0.0.58 → 0.0.60

package/dist/permissions/trust.d.ts

@@ -0,0 +1,26 @@
+export interface PermissionTrustOptions {
+    bubbleHome?: string;
+}
+/** Parsed contents of the two repository settings files (null when absent). */
+export interface RepoSettingsRaw {
+    project: unknown;
+    local: unknown;
+}
+export interface RepoCapabilities {
+    allow: string[];
+    mcpServers: string[];
+    /** LSP server ids whose definition carries more than an on/off switch. */
+    lspServers: string[];
+}
+export declare function getPermissionTrustPath(options?: PermissionTrustOptions): string;
+export declare function repoCapabilities(raw: unknown): RepoCapabilities;
+/** Everything the given repository settings would enable, both scopes merged. */
+export declare function mergedRepoCapabilities(raw: RepoSettingsRaw): RepoCapabilities;
+export declare function describeRepoCapabilities(caps: RepoCapabilities): string[];
+export declare function hasRepoCapabilities(raw: RepoSettingsRaw): boolean;
+export declare function repoConfigFingerprint(cwd: string, raw: RepoSettingsRaw): string;
+/** True when the repository grants nothing, or the user trusted exactly this content. */
+export declare function isRepoConfigTrusted(cwd: string, raw: RepoSettingsRaw, options?: PermissionTrustOptions): boolean;
+export declare function trustRepoConfig(cwd: string, raw: RepoSettingsRaw, options?: PermissionTrustOptions): void;
+/** Reads both repository settings files; unparsable files count as absent. */
+export declare function readRepoSettings(cwd: string): RepoSettingsRaw;

package/dist/permissions/trust.js

@@ -0,0 +1,113 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { getBubbleHome } from "../bubble-home.js";
+export function getPermissionTrustPath(options = {}) {
+    return join(options.bubbleHome ?? getBubbleHome(), "permissions-trust.json");
+}
+export function repoCapabilities(raw) {
+    const settings = isRecord(raw) ? raw : {};
+    const permissions = isRecord(settings.permissions) ? settings.permissions : {};
+    const allow = Array.isArray(permissions.allow)
+        ? permissions.allow.filter((rule) => typeof rule === "string")
+        : [];
+    const mcpServers = isRecord(settings.mcpServers) ? Object.keys(settings.mcpServers) : [];
+    const lspServers = isRecord(settings.lsp)
+        ? Object.entries(settings.lsp)
+            .filter(([, server]) => isRecord(server) && Object.keys(server).some((key) => key !== "disabled"))
+            .map(([id]) => id)
+        : [];
+    return { allow, mcpServers, lspServers };
+}
+/** Everything the given repository settings would enable, both scopes merged. */
+export function mergedRepoCapabilities(raw) {
+    const project = repoCapabilities(raw.project);
+    const local = repoCapabilities(raw.local);
+    return {
+        allow: [...project.allow, ...local.allow],
+        mcpServers: [...new Set([...project.mcpServers, ...local.mcpServers])],
+        lspServers: [...new Set([...project.lspServers, ...local.lspServers])],
+    };
+}
+export function describeRepoCapabilities(caps) {
+    return [
+        ...caps.allow.map((rule) => `allow rule   ${rule}`),
+        ...caps.mcpServers.map((name) => `MCP server   ${name} (Bubble starts it)`),
+        ...caps.lspServers.map((id) => `LSP server   ${id} (custom command, env or options)`),
+    ];
+}
+export function hasRepoCapabilities(raw) {
+    return [raw.project, raw.local].some((scope) => {
+        const caps = repoCapabilities(scope);
+        return caps.allow.length + caps.mcpServers.length + caps.lspServers.length > 0;
+    });
+}
+export function repoConfigFingerprint(cwd, raw) {
+    const pick = (scope) => {
+        const settings = isRecord(scope) ? scope : {};
+        const permissions = isRecord(settings.permissions) ? settings.permissions : {};
+        return { allow: permissions.allow ?? null, mcpServers: settings.mcpServers ?? null, lsp: settings.lsp ?? null };
+    };
+    return createHash("sha256")
+        .update(JSON.stringify({ cwd: safeRealpath(cwd), project: pick(raw.project), local: pick(raw.local) }))
+        .digest("hex");
+}
+/** True when the repository grants nothing, or the user trusted exactly this content. */
+export function isRepoConfigTrusted(cwd, raw, options = {}) {
+    if (!hasRepoCapabilities(raw))
+        return true;
+    return readStore(options).projects[safeRealpath(cwd)]?.fingerprint === repoConfigFingerprint(cwd, raw);
+}
+export function trustRepoConfig(cwd, raw, options = {}) {
+    const store = readStore(options);
+    store.projects[safeRealpath(cwd)] = {
+        fingerprint: repoConfigFingerprint(cwd, raw),
+        trustedAt: new Date().toISOString(),
+    };
+    const path = getPermissionTrustPath(options);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(store, null, 2) + "\n", "utf-8");
+}
+/** Reads both repository settings files; unparsable files count as absent. */
+export function readRepoSettings(cwd) {
+    const read = (path) => {
+        if (!existsSync(path))
+            return null;
+        try {
+            return JSON.parse(readFileSync(path, "utf-8"));
+        }
+        catch {
+            return null;
+        }
+    };
+    return {
+        project: read(join(cwd, ".bubble", "settings.json")),
+        local: read(join(cwd, ".bubble", "settings.local.json")),
+    };
+}
+function readStore(options) {
+    const path = getPermissionTrustPath(options);
+    if (!existsSync(path))
+        return { version: 1, projects: {} };
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (parsed && typeof parsed.projects === "object" && parsed.projects !== null) {
+            return { version: 1, projects: parsed.projects };
+        }
+    }
+    catch {
+        // A corrupt store trusts nothing.
+    }
+    return { version: 1, projects: {} };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function safeRealpath(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}

package/dist/prompt/compose.d.ts

@@ -6,7 +6,10 @@ export interface ComposeSystemPromptOptions extends EnvironmentPromptOptions {
     guidelines?: string[];
     thinkingLevel?: ThinkingLevel;
     mode?: PermissionMode;
+    /** Prompt-visible skills; when given (and `skill` is a tool), listed as a catalog. */
     skills?: SkillSummary[];
+    /** Catalog budget in characters (default SKILL_CATALOG_CHARS); 0 falls back to search only. */
+    skillCatalogChars?: number;
     memoryPrompt?: string;
     agentProfilePrompt?: string;
     /** Rendered subagent model-routing menu (design §4). Placed right after the

package/dist/prompt/compose.js

@@ -9,6 +9,7 @@ import { buildKimiProviderPrompt } from "./provider-prompts/kimi.js";
 import { buildDelegationPolicyPrompt } from "./delegation.js";
 import { buildEnvironmentPrompt, defaultToolNames } from "./environment.js";
 import { buildRuntimePrompt } from "./runtime.js";
+import { buildSkillCatalog } from "../skills/format.js";
 export function composeSystemPrompt(options = {}) {
     const agentName = options.agentName ?? "Bubble";
     const providerPrompt = buildProviderPrompt(agentName, options.configuredProvider, options.configuredModelId, options.configuredModel);
@@ -21,10 +22,20 @@ export function composeSystemPrompt(options = {}) {
         tools: options.tools ?? defaultToolNames,
         toolSnippets: options.toolSnippets,
     });
+    const tools = options.tools ?? defaultToolNames;
+    // Level one of skill loading: names and one-line descriptions are always in
+    // context; bodies load on demand with `skill`. Last section, so the prefix
+    // above stays byte-identical while the skill set is unchanged.
+    const skillCatalog = options.skills && tools.includes("skill")
+        ? buildSkillCatalog(options.skills, {
+            budgetChars: options.skillCatalogChars,
+            searchable: tools.includes("skill_search"),
+        })
+        : undefined;
     const runtimePrompt = buildRuntimePrompt({
         thinkingLevel: options.thinkingLevel,
         mode: options.mode,
-        guidelines: buildGuidelines(options.tools ?? defaultToolNames, options.guidelines ?? []),
+        guidelines: buildGuidelines(tools, options.guidelines ?? [], skillCatalog),
     });
     const delegationPrompt = buildDelegationPolicyPrompt(options.tools ?? defaultToolNames);
     // Same gate as the delegation policy: children (no spawn_agent) never see the menu.
@@ -37,6 +48,7 @@ export function composeSystemPrompt(options = {}) {
         modelRoutingPrompt,
         options.agentProfilePrompt,
         options.memoryPrompt,
+        skillCatalog?.text,
     ].filter(Boolean).join("\n\n");
 }
 function buildProviderPrompt(agentName, providerId, modelId, modelName) {
@@ -67,23 +79,28 @@ function buildProviderPrompt(agentName, providerId, modelId, modelName) {
     }
     return buildDefaultProviderPrompt(agentName);
 }
-function buildGuidelines(tools, extraGuidelines) {
+function buildGuidelines(tools, extraGuidelines, skillCatalog) {
     const guidelines = [];
     const add = (item) => {
         if (!guidelines.includes(item)) {
             guidelines.push(item);
         }
     };
-    if (tools.includes("glob")) {
-        add("Use glob for file discovery and project structure inspection; do not use bash ls/find for this unless glob cannot answer");
+    if (tools.includes("ls")) {
+        add("Use ls to list directory contents, including files and subdirectories");
     }
-    if (tools.includes("bash") && tools.includes("grep")) {
-        add("Use grep for content search; do not run grep, rg, or ripgrep through bash");
+    if (tools.includes("grep")) {
+        add("Use grep to search file contents");
+    }
+    if (tools.includes("bash")) {
+        add("Use bash for file operations like ls, find, and rg when appropriate");
     }
     if (tools.includes("question")) {
         add("When the user is explicitly discussing, brainstorming, or shaping an approach instead of asking for immediate execution, use the question tool for targeted clarification or preference choices when it would materially improve the discussion; do not use it for generic permission-to-proceed questions");
     }
-    if (tools.includes("skill_search") && tools.includes("skill")) {
+    // With a catalog the Skills section itself says how to load; search remains
+    // the only route when the host gave no catalog or turned it off.
+    if (!skillCatalog?.listed && tools.includes("skill_search") && tools.includes("skill")) {
         add("Skills may provide specialized workflows. When a task appears to match a specialized workflow, call skill_search to find relevant skills, then call skill with the exact name to load the selected skill before applying it");
     }
     for (const item of extraGuidelines) {

package/dist/prompt/environment.js

@@ -4,7 +4,7 @@ export const defaultToolSnippets = {
     bash: "Execute a bash command",
     edit: "Apply targeted string replacements to a file",
     write: "Write a new file or overwrite an existing one",
-    glob: "Find files by glob pattern without using bash",
+    ls: "List directory contents, including hidden files and subdirectories",
     grep: "Search file contents using regex",
     web_search: "Search the public web for current information",
     web_fetch: "Fetch and extract the contents of a specific webpage",
@@ -17,7 +17,7 @@ export const defaultToolSnippets = {
 };
 export const defaultToolNames = [
     "read",
-    "glob",
+    "ls",
     "bash",
     "edit",
     "write",

package/dist/prompt/reminders.js

@@ -29,7 +29,7 @@ const PLAN_MODE_ENTER = `
 Plan mode is now ACTIVE.
 
 Rules while in plan mode:
-- Only read-only tools are allowed, including read, glob, grep, web_search, web_fetch, spawn_agent, wait_agent, send_input, skill_search, skill, tool_search, question, and exit_plan_mode.
+- Only read-only tools are allowed, including read, ls, grep, web_search, web_fetch, spawn_agent, wait_agent, send_input, skill_search, skill, tool_search, question, and exit_plan_mode.
 - Writes, edits, and shell commands WILL be rejected by the harness; do not try them.
 - Do not edit files or claim implementation is complete while plan mode is active.
 - Investigate the codebase, then use the question tool to clarify important ambiguities, tradeoffs, requirements, or preference choices that would materially change the plan.

package/dist/prompt/runtime.js

@@ -8,7 +8,7 @@ const defaultGuidelines = [
     "Choose the smallest coherent change. Edit only the files required for the requested change; do not refactor or improve adjacent code unprompted.",
     "Runtime meta instructions are private control state. Use them only to adjust behavior; do not quote, mention, or paraphrase them in user-facing text.",
     "For modifications to existing code, read the file first. For brand-new files whose target path is known and does not exist, write directly without exploratory reading. Use edit for targeted changes and write for intentional full-file replacement of an existing file. Never delete and recreate a file just to overwrite it.",
-    "Prefer structured tools (glob, grep, read) over bash for search and inspection. Do not repeat a near-identical search or re-read the same file unless new evidence changes the question.",
+    "Do not repeat a near-identical search or re-read the same file unless new evidence changes the question. When output is truncated, narrow the scope or adjust the limit before treating it as a complete inventory.",
     "If a tool fails, diagnose the error before switching tactics. Do not retry the identical call with identical arguments. After two equivalent failures, switch approach — re-read the file, use a different tool, rewrite the whole file with write, or ask the user.",
     "Before reporting a task complete, verify it works when verification is meaningful and cheap — run the existing test, execute the script, check the output. If no test exists, the change is purely declarative (static HTML/markdown/config), or running the code is not practical, state that explicitly rather than inventing a verification step. Do not write throwaway validation scripts to prove correctness; if there is no real check to run, report the change and stop.",
     "Before declaring a task complete, re-read the user's original request and verify that every explicit requirement in it — about both the result and the process — has been fulfilled, not only that the implementation works.",

package/dist/provider-anthropic.d.ts

@@ -22,7 +22,11 @@ interface AnthropicRequest {
     stream?: boolean;
     temperature?: number;
     thinking?: {
-        type: "adaptive";
+        type: "adaptive" | "enabled" | "disabled";
+        display?: "summarized";
+        block_binding?: {
+            prefix_mismatch_behavior: "drop_block";
+        };
     };
     output_config?: {
         effort: AnthropicEffort;
@@ -113,7 +117,7 @@ export declare function buildAnthropicRequest(options: AnthropicProviderOptions,
 export declare function placeMessageCacheBreakpoints(messages: AnthropicMessage[], budget: number): number;
 export declare function resolveAnthropicMaxTokens(options: AnthropicProviderOptions, model: string): number;
 export declare function supportsAnthropicPromptCache(options: AnthropicProviderOptions, model: string): boolean;
-export declare function toAnthropicMessages(messages: ProviderMessage[], echoThinking?: boolean): {
+export declare function toAnthropicMessages(messages: ProviderMessage[], echoThinking?: boolean | "all", allowUnsignedThinking?: boolean): {
     system: string;
     messages: AnthropicMessage[];
 };

package/dist/provider-anthropic.js

@@ -1,8 +1,11 @@
 import { getAvailableThinkingLevels, normalizeThinkingLevel } from "./provider-transform.js";
+import { getModelDefaultReasoningLevel } from "./model-catalog.js";
+import { isClaudeWithBoundThinking } from "./anthropic-thinking.js";
 import { RateLimitError } from "./network/errors.js";
 import { isProviderTransportError, normalizeProviderNetworkError, providerFetch } from "./network/provider-transport.js";
 import { computeRetryDelayMs, getProviderMaxRetries, isRetryableHttpStatus, ProviderStreamInterruptedError, retryAfterMsFromResponse, sleepBeforeRetry, } from "./network/retry.js";
 const ANTHROPIC_VERSION = "2023-06-01";
+const THINKING_BINDING_BETA = "thinking-binding-controls-2026-08-01";
 const DEFAULT_MAX_TOKENS = 8192;
 const ANTHROPIC_OPUS_LONG_OUTPUT_MAX_TOKENS = 128000;
 const ANTHROPIC_LONG_OUTPUT_MAX_TOKENS = 64000;
@@ -11,6 +14,8 @@ const ANTHROPIC_LONG_OUTPUT_MAX_TOKENS = 64000;
 // MiniMax's docs recommend M3 128K, M2.x 64K output.
 const MINIMAX_M3_MAX_TOKENS = 128000;
 const MINIMAX_M2_MAX_TOKENS = 64000;
+// MiMo counts thinking and visible text together; match its documented 128K cap.
+const MIMO_MAX_TOKENS = 131072;
 const ANTHROPIC_PROMPT_CACHE_CONTROL = { type: "ephemeral" };
 /** Hard API limit: a 5th cache_control breakpoint is a 400, not a warning. */
 const ANTHROPIC_MAX_CACHE_BREAKPOINTS = 4;
@@ -55,6 +60,7 @@ export function createAnthropicMessagesProvider(options) {
         });
         const events = streamAnthropicEventsWithRetry(options, {
             url: resolveAnthropicMessagesUrl(options.baseURL),
+            model: body.model,
             stream: true,
             method: "POST",
             body: JSON.stringify(body),
@@ -73,20 +79,25 @@ export function createAnthropicMessagesProvider(options) {
         });
         const response = await fetchAnthropicResponseWithRetry(options, {
             url: resolveAnthropicMessagesUrl(options.baseURL),
+            model: body.model,
             stream: false,
             method: "POST",
             body: JSON.stringify(body),
             signal: chatOptions?.abortSignal,
         });
         const data = await response.json();
+        reportThinkingPrefixDrops(data.input_transformations);
         return extractAnthropicText(data.content).join("");
     }
     return { streamChat, complete };
 }
 export function buildAnthropicRequest(options, messages, chatOptions) {
-    const { system, messages: anthropicMessages } = toAnthropicMessages(messages, shouldEchoThinking(options.providerId));
+    const mimo = isMiMoProvider(options);
+    const modernClaude = isClaudeWithBoundThinking(chatOptions.model);
+    const { system, messages: anthropicMessages } = toAnthropicMessages(messages, modernClaude ? "all" : shouldEchoThinking(options), !modernClaude);
     const enablePromptCache = supportsAnthropicPromptCache(options, chatOptions.model);
-    const tools = chatOptions.tools?.map((tool) => ({
+    // MiMo only supports tool_choice=auto. Removing tools enforces "none".
+    const tools = (mimo && chatOptions.toolChoice === "none" ? undefined : chatOptions.tools)?.map((tool) => ({
         name: tool.name,
         description: tool.description,
         input_schema: tool.parameters,
@@ -116,22 +127,35 @@ export function buildAnthropicRequest(options, messages, chatOptions) {
         && !messageCacheKillSwitchEnabled()) {
         placeMessageCacheBreakpoints(anthropicMessages, ANTHROPIC_MAX_CACHE_BREAKPOINTS - staticBreakpoints);
     }
-    const effectiveThinkingLevel = normalizeThinkingLevel(chatOptions.thinkingLevel ?? options.thinkingLevel ?? "off", getAvailableThinkingLevels(options.providerId || "", chatOptions.model));
+    const effectiveThinkingLevel = normalizeThinkingLevel(chatOptions.thinkingLevel ?? options.thinkingLevel
+        ?? (mimo ? "medium" : modernClaude || isClaude5WithOptionalThinking(chatOptions.model)
+            ? getModelDefaultReasoningLevel(options.providerId || "", chatOptions.model) ?? "off" : "off"), mimo ? ["off", "medium"] : getAvailableThinkingLevels(options.providerId || "", chatOptions.model));
     const body = {
         model: chatOptions.model,
         max_tokens: resolveAnthropicMaxTokens(options, chatOptions.model),
         system: buildAnthropicSystem(system, enablePromptCache),
         messages: anthropicMessages,
         tools: tools && tools.length > 0 ? tools : undefined,
-        tool_choice: tools && tools.length > 0 ? { type: chatOptions.toolChoice ?? "auto" } : undefined,
+        tool_choice: tools && tools.length > 0 ? { type: mimo ? "auto" : chatOptions.toolChoice ?? "auto" } : undefined,
         stream: chatOptions.stream || undefined,
     };
     if (typeof chatOptions.temperature === "number"
         && shouldSendTemperature(options, chatOptions.model, effectiveThinkingLevel)) {
         body.temperature = chatOptions.temperature;
     }
-    if (effectiveThinkingLevel !== "off") {
-        body.thinking = { type: "adaptive" };
+    if (mimo) {
+        // MiMo defaults to thinking on and rejects Claude's adaptive mode/effort.
+        body.thinking = { type: effectiveThinkingLevel === "off" ? "disabled" : "enabled" };
+    }
+    else if (effectiveThinkingLevel !== "off") {
+        body.thinking = modernClaude ? { type: "adaptive", display: "summarized" } : { type: "adaptive" };
+        if (modernClaude && isOfficialAnthropicBaseUrl(options.baseURL)) {
+            // Checkpoints proactively reset thinking. Runtime reminders, restored
+            // host context and tool changes can also change a prefix; let the API
+            // drop invalid blocks instead of failing the turn. Applied on every
+            // request so this behavior persists after restarts, per official guidance.
+            body.thinking.block_binding = { prefix_mismatch_behavior: "drop_block" };
+        }
         // Apply the selected reasoning depth via output_config.effort. Without this
         // every thinking request silently ran at Anthropic's default (high),
         // ignoring the chosen level. effort is an official-API feature, so only
@@ -145,6 +169,10 @@ export function buildAnthropicRequest(options, messages, chatOptions) {
             }
         }
     }
+    // Opus 5 and Sonnet 5 default to thinking on; omission cannot express Off.
+    if (!mimo && effectiveThinkingLevel === "off" && isClaude5WithOptionalThinking(chatOptions.model)) {
+        body.thinking = { type: "disabled" };
+    }
     return body;
 }
 /**
@@ -237,6 +265,8 @@ function messageCacheKillSwitchEnabled() {
     return raw === "0" || raw === "false";
 }
 export function resolveAnthropicMaxTokens(options, model) {
+    if (isMiMoProvider(options))
+        return MIMO_MAX_TOKENS;
     // MiniMax needs a large output budget so thinking doesn't starve the answer.
     if (isMiniMaxProvider(options)) {
         return /m3/i.test(model) ? MINIMAX_M3_MAX_TOKENS : MINIMAX_M2_MAX_TOKENS;
@@ -244,7 +274,8 @@ export function resolveAnthropicMaxTokens(options, model) {
     if (!isOfficialAnthropicBaseUrl(options.baseURL)) {
         return DEFAULT_MAX_TOKENS;
     }
-    if (isFableModelWith128kOutput(model) || isOpusModelWith128kOutput(model)) {
+    if (isFableModelWith128kOutput(model) || isOpusModelWith128kOutput(model)
+        || isClaudeFamilyVersionAtLeast(model, "sonnet", 5, 0)) {
         return ANTHROPIC_OPUS_LONG_OUTPUT_MAX_TOKENS;
     }
     if (isSonnetOrHaikuModelWith64kOutput(model)) {
@@ -269,7 +300,7 @@ export function supportsAnthropicPromptCache(options, model) {
     }
     return MINIMAX_PROMPT_CACHE_MODELS.has(model.toLowerCase());
 }
-export function toAnthropicMessages(messages, echoThinking = false) {
+export function toAnthropicMessages(messages, echoThinking = false, allowUnsignedThinking = true) {
     const system = [];
     const out = [];
     const thinkingReplayIndexes = getThinkingReplayIndexes(messages, echoThinking);
@@ -292,7 +323,7 @@ export function toAnthropicMessages(messages, echoThinking = false) {
             continue;
         }
         if (message.role === "assistant") {
-            const content = buildAssistantAnthropicBlocks(message, thinkingReplayIndexes.has(index));
+            const content = buildAssistantAnthropicBlocks(message, thinkingReplayIndexes.has(index), allowUnsignedThinking);
             if (content.length > 0) {
                 pushAnthropicMessage(out, { role: "assistant", content });
             }
@@ -307,7 +338,7 @@ export function toAnthropicMessages(messages, echoThinking = false) {
     }
     return { system: system.join("\n\n"), messages: out };
 }
-function buildAssistantAnthropicBlocks(message, includeThinking) {
+function buildAssistantAnthropicBlocks(message, includeThinking, allowUnsignedThinking) {
     const rawBlocks = message.providerMetadata?.anthropic?.contentBlocks;
     if (rawBlocks && rawBlocks.length > 0) {
         const blocks = rawBlocks
@@ -319,7 +350,7 @@ function buildAssistantAnthropicBlocks(message, includeThinking) {
         }
     }
     const content = [];
-    if (includeThinking && message.reasoning?.trim()) {
+    if (includeThinking && allowUnsignedThinking && message.reasoning?.trim()) {
         content.push({ type: "thinking", thinking: message.reasoning });
     }
     if (message.content.trim()) {
@@ -339,6 +370,15 @@ function getThinkingReplayIndexes(messages, echoThinking) {
     const indexes = new Set();
     if (!echoThinking)
         return indexes;
+    // MiMo and bound Claude thinking need intact historical blocks across user
+    // turns. Removing a middle block breaks the later Claude signature chain.
+    if (echoThinking === "all") {
+        messages.forEach((message, index) => {
+            if (message.role === "assistant")
+                indexes.add(index);
+        });
+        return indexes;
+    }
     let lastUserIndex = -1;
     for (let index = 0; index < messages.length; index++) {
         if (messages[index].role === "user") {
@@ -384,6 +424,7 @@ export async function* translateAnthropicStream(events) {
     for await (const event of events) {
         const type = typeof event.type === "string" ? event.type : "";
         if (type === "message_start") {
+            reportThinkingPrefixDrops(event.message?.input_transformations);
             usage = mergeAnthropicUsage(usage, event.message?.usage);
             if (usage)
                 yield { type: "usage", usage };
@@ -560,7 +601,7 @@ async function fetchAnthropicResponseWithRetry(options, request) {
         try {
             response = await providerFetch(request.url, {
                 method: request.method,
-                headers: buildAnthropicHeaders(options, request.stream),
+                headers: buildAnthropicHeaders(options, request.stream, request.model),
                 body: request.body,
                 signal: request.signal,
                 keepalive: false,
@@ -616,7 +657,7 @@ function resolveAnthropicMessagesUrl(baseURL) {
         return `${normalized}/messages`;
     return `${normalized || "https://api.anthropic.com"}/v1/messages`;
 }
-function buildAnthropicHeaders(options, stream) {
+function buildAnthropicHeaders(options, stream, model) {
     const headers = {
         "content-type": "application/json",
         "x-api-key": options.apiKey,
@@ -629,7 +670,25 @@ function buildAnthropicHeaders(options, stream) {
         headers.accept = "text/event-stream";
     // User-configured headers win last: anthropic-protocol coding plans gate on
     // client identity (e.g. a specific User-Agent), configured per provider.
-    return { ...headers, ...(options.headers ?? {}) };
+    const merged = { ...headers, ...(options.headers ?? {}) };
+    if (isOfficialAnthropicBaseUrl(options.baseURL) && isClaudeWithBoundThinking(model)) {
+        // Merge case-insensitively without losing user-configured beta features.
+        const betaKeys = Object.keys(merged).filter(key => key.toLowerCase() === "anthropic-beta");
+        const betas = betaKeys.flatMap(key => merged[key].split(",").map(value => value.trim()).filter(Boolean));
+        for (const key of betaKeys)
+            delete merged[key];
+        merged["anthropic-beta"] = [...new Set([...betas, THINKING_BINDING_BETA])].join(",");
+    }
+    return merged;
+}
+function reportThinkingPrefixDrops(transformations) {
+    if (!Array.isArray(transformations))
+        return;
+    const count = transformations.filter(item => item?.type === "thinking_dropped" && item?.reason === "prefix_binding_mismatch").length;
+    if (count > 0) {
+        // Count only; raw transformations, signatures and prompt text are private.
+        console.warn(`[anthropic-thinking] API discarded ${count} thinking block(s) after a conversation prefix change.`);
+    }
 }
 async function readAnthropicErrorDetail(response) {
     try {
@@ -788,18 +847,28 @@ function mergeAnthropicUsage(current, raw) {
         totalTokens: promptTokens + outputTokens,
     };
 }
-function shouldEchoThinking(providerId) {
-    return providerId?.startsWith("minimax") ?? false;
+function shouldEchoThinking(options) {
+    if (isMiMoProvider(options))
+        return "all";
+    return options.providerId?.startsWith("minimax") ?? false;
 }
 function shouldSendBearerAuth(options) {
     return !isOfficialAnthropicBaseUrl(options.baseURL) || options.providerId?.startsWith("minimax") === true;
 }
 function shouldSendTemperature(options, model, thinkingLevel) {
+    if (isMiMoProvider(options) && thinkingLevel !== "off")
+        return false;
     if (!isOfficialAnthropicBaseUrl(options.baseURL))
         return true;
     if (thinkingLevel !== "off")
         return false;
-    return !isOpusModelWithoutSamplingControls(model);
+    return !isOpusModelWithoutSamplingControls(model)
+        && !isFableModelWith128kOutput(model)
+        && !isClaudeFamilyVersionAtLeast(model, "sonnet", 5, 0);
+}
+function isClaude5WithOptionalThinking(model) {
+    return isClaudeFamilyVersionAtLeast(model, "sonnet", 5, 0)
+        || (isClaudeFamilyVersionAtLeast(model, "opus", 5, 0) && !isClaudeWithBoundThinking(model));
 }
 function isOpusModelWith128kOutput(model) {
     return isClaudeFamilyVersionAtLeast(model, "opus", 4, 6);
@@ -828,7 +897,7 @@ function isClaudeFamilyVersionAtLeast(model, family, minMajor, minMinor) {
     if (major < minMajor)
         return false;
     if (!minorSegment || minorSegment.length > 2)
-        return false;
+        return minMinor === 0;
     const minor = Number(minorSegment);
     return Number.isFinite(minor) && minor >= minMinor;
 }
@@ -858,3 +927,14 @@ function isMiniMaxProvider(options) {
     return (options.providerId || "").toLowerCase().startsWith("minimax")
         || options.baseURL.toLowerCase().includes("minimaxi");
 }
+function isMiMoProvider(options) {
+    if (options.providerId === "mimo-token-plan")
+        return true;
+    try {
+        return ["api.xiaomimimo.com", "token-plan-cn.xiaomimimo.com", "token-plan-sgp.xiaomimimo.com", "token-plan-ams.xiaomimimo.com"]
+            .includes(new URL(options.baseURL).hostname);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/provider-error-record.d.ts

@@ -14,6 +14,11 @@ export interface SanitizedProviderError {
     bubbleVersion: string;
     pid: number;
     runtimeStartedAt: number;
+    retry?: {
+        attempt: number;
+        maxAttempts: number;
+    };
+    requestShape?: Record<string, number>;
 }
 export interface ProviderErrorContext {
     providerId: string;
@@ -22,6 +27,10 @@ export interface ProviderErrorContext {
     thinkingLevel: ThinkingLevel;
     messageCount: number;
     toolCount: number;
+    retry?: {
+        attempt: number;
+        maxAttempts: number;
+    };
 }
 /**
  * Build the allowlisted diagnostic record written to a session log.