@bubblebrain-ai/bubble 0.0.58 → 0.0.60

package/dist/mcp/manager.d.ts

@@ -7,6 +7,7 @@
  * agent down.
  */
 import type { ToolRegistryEntry } from "../types.js";
+import type { ApprovalController } from "../approval/types.js";
 import type { UnifiedCommand } from "../slash-commands/unified.js";
 import type { McpServerState, ScopedMcpServerConfig } from "./types.js";
 export interface McpManagerOptions {
@@ -32,7 +33,10 @@ export declare class McpManager {
     /** Shutdown all connections. Best-effort; errors are ignored. */
     shutdown(): Promise<void>;
     getStates(): McpServerState[];
-    /** Produce ToolRegistryEntry[] for every tool from every connected server. */
+    /**
+     * Produce ToolRegistryEntry[] for every tool from every connected server.
+     * Hosts must pass them through gateMcpTools before handing them to an agent.
+     */
     getToolEntries(): ToolRegistryEntry[];
     /**
      * Produce UnifiedCommand[] for every prompt from every connected server.
@@ -53,3 +57,11 @@ export declare class McpManager {
      */
     getPromptCommands(): UnifiedCommand[];
 }
+/**
+ * Puts MCP tools behind the approval controller. MCP servers can do anything
+ * (open PRs, post messages, write databases) and their read-only hints are
+ * self-reported, so each call is an `external_tool` request: allowed by rules
+ * (`mcp__server__tool`, or `mcp__server` for the whole server), a session
+ * grant, or bypassPermissions — otherwise the user is asked.
+ */
+export declare function gateMcpTools(tools: ToolRegistryEntry[], approval: ApprovalController | undefined): ToolRegistryEntry[];

package/dist/mcp/manager.js

@@ -6,6 +6,7 @@
  * per-server state so /mcp can surface them to the user without taking the
  * agent down.
  */
+import { gateToolAction } from "../approval/tool-helper.js";
 import { MCPClient } from "./client.js";
 import { HttpTransport, StdioTransport } from "./transports.js";
 import { buildMcpToolName, normalizeNameForMCP } from "./name.js";
@@ -99,7 +100,10 @@ export class McpManager {
     getStates() {
         return [...this.connections.values()].map((c) => c.state);
     }
-    /** Produce ToolRegistryEntry[] for every tool from every connected server. */
+    /**
+     * Produce ToolRegistryEntry[] for every tool from every connected server.
+     * Hosts must pass them through gateMcpTools before handing them to an agent.
+     */
     getToolEntries() {
         const entries = [];
         for (const conn of this.connections.values()) {
@@ -295,3 +299,30 @@ function formatToolContent(content) {
     }
     return parts.join("\n");
 }
+/**
+ * Puts MCP tools behind the approval controller. MCP servers can do anything
+ * (open PRs, post messages, write databases) and their read-only hints are
+ * self-reported, so each call is an `external_tool` request: allowed by rules
+ * (`mcp__server__tool`, or `mcp__server` for the whole server), a session
+ * grant, or bypassPermissions — otherwise the user is asked.
+ */
+export function gateMcpTools(tools, approval) {
+    if (!approval)
+        return tools;
+    return tools.map((tool) => ({
+        ...tool,
+        requiresApproval: true,
+        async execute(args, ctx) {
+            const gate = await gateToolAction(approval, {
+                type: "external_tool",
+                toolCallId: ctx?.toolCall?.id ?? "",
+                title: tool.name,
+                kind: "mcp",
+                rawInput: args,
+            });
+            if (!gate.approved)
+                return gate.result;
+            return tool.execute(args, ctx);
+        },
+    }));
+}

package/dist/mcp/transports.js

@@ -49,6 +49,14 @@ export class StdioTransport {
         child.on("error", (err) => {
             this.errorHandler?.(err);
         });
+        // A server that exits (or closes stdin) makes our next write fail with
+        // EPIPE on the pipe itself; unhandled, that error event kills the whole
+        // host. Report it as a transport failure instead.
+        child.stdin.on("error", (err) => {
+            this.errorHandler?.(new Error(`stdio server stopped reading its input (${err.code ?? err.message})${this.stderrBuffer ? `\nstderr:\n${this.stderrBuffer.trim()}` : ""}`));
+        });
+        child.stdout.on("error", (err) => this.errorHandler?.(err));
+        child.stderr.on("error", (err) => this.errorHandler?.(err));
         child.on("exit", (code, signal) => {
             if (this.closed)
                 return;
@@ -80,6 +88,9 @@ export class StdioTransport {
     async send(message) {
         if (!this.child || this.closed)
             throw new Error("Transport not started or already closed");
+        if (this.child.stdin.destroyed || this.child.stdin.writableEnded) {
+            throw new Error("stdio server is no longer accepting input");
+        }
         this.child.stdin.write(JSON.stringify(message) + "\n");
     }
     onMessage(handler) {

package/dist/memory/db.d.ts

@@ -5,6 +5,7 @@ export interface Stage1Output {
     cwd: string;
     entryCount: number;
     sourceUpdatedAt: string;
+    extractorVersion?: string;
     generatedAt: string;
     rawMemory: string;
     rolloutSummary: string;

package/dist/memory/db.js

@@ -2,7 +2,7 @@ import { mkdirSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname } from "node:path";
 import { getMemoryPaths } from "./paths.js";
-const SCHEMA_VERSION = 1;
+const SCHEMA_VERSION = 2;
 const GLOBAL_CONSOLIDATION_KIND = "memory_consolidate_global";
 const GLOBAL_CONSOLIDATION_KEY = "global";
 const PHASE1_KIND = "memory_phase1_extract";
@@ -26,8 +26,8 @@ export class MemoryDatabase {
         this.db.prepare(`
       INSERT INTO memory_stage1_outputs (
         session_file, cwd, entry_count, source_updated_at, generated_at,
-        raw_memory, rollout_summary, rollout_slug, usage_count, selected_for_phase2
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, 0)
+        raw_memory, rollout_summary, rollout_slug, extractor_version, usage_count, selected_for_phase2
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0)
       ON CONFLICT(session_file) DO UPDATE SET
         cwd = excluded.cwd,
         entry_count = excluded.entry_count,
@@ -36,12 +36,14 @@ export class MemoryDatabase {
         raw_memory = excluded.raw_memory,
         rollout_summary = excluded.rollout_summary,
         rollout_slug = excluded.rollout_slug,
+        extractor_version = excluded.extractor_version,
         selected_for_phase2 = CASE
           WHEN memory_stage1_outputs.selected_for_phase2_source_updated_at = excluded.source_updated_at
+            AND memory_stage1_outputs.extractor_version IS excluded.extractor_version
           THEN memory_stage1_outputs.selected_for_phase2
           ELSE 0
         END
-    `).run(output.sessionFile, output.cwd, output.entryCount, output.sourceUpdatedAt, output.generatedAt, output.rawMemory, output.rolloutSummary, output.rolloutSlug ?? null);
+    `).run(output.sessionFile, output.cwd, output.entryCount, output.sourceUpdatedAt, output.generatedAt, output.rawMemory, output.rolloutSummary, output.rolloutSlug ?? null, output.extractorVersion ?? null);
     }
     getStage1Output(sessionFile) {
         const row = this.db.prepare("SELECT * FROM memory_stage1_outputs WHERE session_file = ?").get(sessionFile);
@@ -261,6 +263,19 @@ export class MemoryDatabase {
         updated_at TEXT NOT NULL
       )
     `).run();
+        const hasExtractorVersion = () => this.db.prepare("PRAGMA table_info(memory_stage1_outputs)").all()
+            .some(column => column.name === "extractor_version");
+        if (!hasExtractorVersion()) {
+            try {
+                this.db.prepare("ALTER TABLE memory_stage1_outputs ADD COLUMN extractor_version TEXT").run();
+            }
+            catch (error) {
+                // Another process sharing this database can win the first-start
+                // migration between the check and the ALTER; that is success.
+                if (!hasExtractorVersion())
+                    throw error;
+            }
+        }
         this.db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('version', ?)").run(String(SCHEMA_VERSION));
     }
 }
@@ -270,6 +285,7 @@ function mapStage1(row) {
         cwd: String(row.cwd),
         entryCount: Number(row.entry_count),
         sourceUpdatedAt: String(row.source_updated_at),
+        extractorVersion: typeof row.extractor_version === "string" ? row.extractor_version : undefined,
         generatedAt: String(row.generated_at),
         rawMemory: String(row.raw_memory),
         rolloutSummary: String(row.rollout_summary),

package/dist/memory/phase1.js

@@ -1,6 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
+import { sanitizeInternalReminderBlocks } from "../agent/internal-reminder-sanitizer.js";
+import { tryCheckpointMessages } from "../context/checkpoint.js";
+import { isCompactionSummaryMessage } from "../context/compact.js";
 import { MemoryDatabase } from "./db.js";
 import { getBubbleHome } from "./paths.js";
 import { buildStageOneMessages, parseJsonObject } from "./prompts.js";
@@ -11,6 +14,8 @@ const DEFAULT_MIN_ENTRIES = 4;
 const DEFAULT_LIMIT = 24;
 const MAX_TRANSCRIPT_CHARS = 70_000;
 const MAX_CONTENT_CHARS = 3_000;
+// Bump when the extraction input/selection contract changes, even if the archive does not.
+const EXTRACTOR_VERSION = "checkpoint-segments-v1";
 export async function runMemoryPhase1(options) {
     const result = { scanned: 0, claimed: 0, succeeded: 0, empty: 0, failed: 0, skipped: 0, errors: [] };
     if (!options.model) {
@@ -48,7 +53,8 @@ export async function runMemoryPhase1(options) {
             }
             const sourceUpdatedAt = statSync(sessionFile).mtime.toISOString();
             const existing = db.getStage1Output(sessionFile);
-            if (existing && existing.entryCount === entryCount && existing.sourceUpdatedAt === sourceUpdatedAt) {
+            if (existing && existing.extractorVersion === EXTRACTOR_VERSION
+                && existing.entryCount === entryCount && existing.sourceUpdatedAt === sourceUpdatedAt) {
                 result.skipped++;
                 continue;
             }
@@ -81,6 +87,7 @@ export async function runMemoryPhase1(options) {
                     cwd: sessionCwd,
                     entryCount,
                     sourceUpdatedAt,
+                    extractorVersion: EXTRACTOR_VERSION,
                     generatedAt: (options.now ?? new Date()).toISOString(),
                     rawMemory: redactSecrets(rawMemory || rolloutSummary).text,
                     rolloutSummary: redactSecrets(rolloutSummary || rawMemory).text,
@@ -131,35 +138,134 @@ function collectSessionFiles(dir) {
     return files;
 }
 function serializeSessionEntries(entries) {
-    const parts = [];
-    let total = 0;
+    // A checkpoint supersedes originals only within its /clear segment. Unlike
+    // live context, durable memory must still consider completed pre-clear work.
+    const segments = [];
+    let segment = [];
     for (const entry of entries) {
-        if (total >= MAX_TRANSCRIPT_CHARS)
-            break;
-        const line = serializeSessionEntry(entry);
-        if (!line)
+        if (entry.type === "marker" && entry.kind === "conversation_clear") {
+            if (segment.length)
+                segments.push(segment);
+            segment = [];
+        }
+        else if (entry.type === "context_checkpoint") {
+            // An unreadable checkpoint supersedes nothing; its originals stay in play.
+            const messages = tryCheckpointMessages(entry.checkpoint);
+            if (!messages)
+                continue;
+            segment = messages.flatMap(serializeCheckpointMessage);
+            if (entry.checkpoint.summary && !segment.some(line => line.summary)) {
+                segment.unshift({ text: `[summary] ${cleanText(entry.checkpoint.summary, MAX_CONTENT_CHARS)}`, summary: true });
+            }
+        }
+        else if (entry.type === "summary") {
+            // Legacy summaries have the same superseding semantics as checkpoints.
+            segment = [{ text: serializeSessionEntry(entry), summary: true }];
+        }
+        else {
+            const text = serializeSessionEntry(entry);
+            if (text)
+                segment.push({ text });
+        }
+    }
+    if (segment.length)
+        segments.push(segment);
+    // Give every clear segment a share so a long new conversation cannot erase
+    // all prior durable evidence. Spend unused shares on the newest segments.
+    const budgets = segments.map(() => Math.floor(MAX_TRANSCRIPT_CHARS / Math.max(1, segments.length)));
+    const sizes = segments.map(lines => lines.reduce((total, line) => total + line.text.length + 1, 0) + 40);
+    let spare = MAX_TRANSCRIPT_CHARS;
+    for (let i = 0; i < budgets.length; i++) {
+        budgets[i] = Math.min(budgets[i], sizes[i]);
+        spare -= budgets[i];
+    }
+    for (let i = budgets.length - 1; i >= 0 && spare > 0; i--) {
+        const extra = Math.min(spare, sizes[i] - budgets[i]);
+        budgets[i] += extra;
+        spare -= extra;
+    }
+    return segments.map((lines, i) => selectTranscriptLines(lines, budgets[i], i)).filter(Boolean).join("\n");
+}
+function selectTranscriptLines(lines, budget, segment) {
+    const header = `[conversation segment ${segment + 1}]\n`;
+    if (budget <= header.length + 1)
+        return "";
+    let remaining = budget - header.length - 1;
+    if (lines.reduce((total, line) => total + line.text.length + 1, 0) <= remaining) {
+        return header + lines.map(line => line.text).join("\n");
+    }
+    const selected = new Map();
+    // Reserve at most half for summaries, leaving room for retained and suffix
+    // evidence (especially corrections/revocations). Emit in chronological order.
+    let summaryBudget = Math.floor(remaining / 2);
+    for (let i = lines.length - 1; i >= 0 && summaryBudget > 40; i--) {
+        if (!lines[i].summary)
             continue;
-        parts.push(line);
-        total += line.length + 1;
+        const text = truncate(lines[i].text, Math.min(summaryBudget, remaining) - 1);
+        selected.set(i, text);
+        remaining -= text.length + 1;
+        summaryBudget -= text.length + 1;
+    }
+    for (let i = lines.length - 1; i >= 0 && remaining > 1; i--) {
+        if (selected.has(i))
+            continue;
+        if (lines[i].text.length >= remaining && remaining <= 40)
+            break;
+        const text = truncate(lines[i].text, remaining - 1);
+        selected.set(i, text);
+        remaining -= text.length + 1;
     }
-    return truncate(parts.join("\n"), MAX_TRANSCRIPT_CHARS);
+    return header + [...selected].sort(([a], [b]) => a - b).map(([, text]) => text).join("\n");
+}
+function serializeCheckpointMessage(message) {
+    if (isCompactionSummaryMessage(message)) {
+        // Projected summaries use an internal-context envelope, but unlike runtime
+        // reminders its payload is durable. Unwrap only this recognized summary.
+        const text = contentToText(message.content).trim()
+            .replace(/^<bubble_internal_context\b[^>]*>\s*/, "")
+            .replace(/\s*<\/bubble_internal_context>$/, "");
+        return [{ text: `[summary] ${cleanText(text, MAX_CONTENT_CHARS)}`, summary: true }];
+    }
+    switch (message.role) {
+        case "user":
+            return textLine("user", contentToText(message.content), MAX_CONTENT_CHARS);
+        case "assistant":
+            return [
+                ...textLine("assistant", message.content, MAX_CONTENT_CHARS),
+                ...(message.toolCalls ?? []).flatMap(call => textLine(`tool_call:${call.name}`, call.arguments, 1_500)),
+            ];
+        case "tool":
+            return textLine(`tool_result${message.isError ? " error=true" : ""}`, message.content, 2_000);
+        case "system":
+        case "meta":
+            return []; // Host prompts and ephemeral runtime reminders are not memory.
+    }
+}
+function textLine(label, content, limit) {
+    const text = cleanText(content, limit);
+    return text.trim() ? [{ text: `[${label}] ${text}` }] : [];
+}
+function cleanText(content, limit) {
+    return truncate(sanitizeInternalReminderBlocks(content), limit);
 }
 function serializeSessionEntry(entry) {
     switch (entry.type) {
         case "metadata":
             return `[metadata] ${JSON.stringify(entry.metadata)}`;
         case "summary":
-            return `[summary] ${truncate(entry.summary, MAX_CONTENT_CHARS)}`;
+            return `[summary] ${cleanText(entry.summary, MAX_CONTENT_CHARS)}`;
         case "marker":
-            return `[marker:${entry.kind}] ${entry.value}`;
+            return `[marker:${entry.kind}] ${cleanText(entry.value, MAX_CONTENT_CHARS)}`;
         case "user_message":
-            return `[user] ${truncate(contentToText(entry.message.content), MAX_CONTENT_CHARS)}`;
+            return serializeCheckpointMessage(entry.message).map(line => line.text).join("\n");
         case "assistant_message":
-            return `[assistant] ${truncate(entry.message.content, MAX_CONTENT_CHARS)}`;
+            return textLine("assistant", entry.message.content, MAX_CONTENT_CHARS).map(line => line.text).join("\n");
         case "tool_call":
-            return `[tool_call:${entry.toolCall.name}] ${truncate(entry.toolCall.arguments, 1_500)}`;
+            return `[tool_call:${entry.toolCall.name}] ${cleanText(entry.toolCall.arguments, 1_500)}`;
         case "tool_result":
-            return `[tool_result${entry.message.isError ? " error=true" : ""}] ${truncate(entry.message.content, 2_000)}`;
+            return `[tool_result${entry.message.isError ? " error=true" : ""}] ${cleanText(entry.message.content, 2_000)}`;
+        case "context_checkpoint":
+            return ""; // Handled as a segment projection above.
         case "provider_error":
             // Operational diagnostics stay out of the memory-extraction prompt. The
             // structured session record remains available for local debugging.

package/dist/memory/prompts.js

@@ -9,6 +9,9 @@ export function buildStageOneMessages(input) {
                 "Do not include secrets, credentials, API keys, tokens, private keys, or full large logs.",
                 "Prefer concrete project facts, user preferences, workflows, decisions, and gotchas.",
                 "Skip transient progress updates and one-off chatter.",
+                "The transcript is a bounded chronological projection; checkpoint summaries replace superseded originals.",
+                "Conversation segments are separated by context clears, not requests to forget durable memory.",
+                "Prefer later corrections and decisions over earlier claims; do not retain revoked facts as current truth.",
             ].join("\n"),
         },
         {

package/dist/model-catalog.js

@@ -24,6 +24,7 @@ export const BUILTIN_PROVIDERS = [
     { id: "doubao", name: "Doubao (Volcengine Ark)", baseURL: "https://ark.cn-beijing.volces.com/api/v3", protocol: "ark-responses" },
     { id: "minimax", name: "MiniMax Token Plan", baseURL: "https://api.minimaxi.com/anthropic", protocol: "anthropic-messages" },
     { id: "minimax-anthropic", name: "MiniMax API", baseURL: "https://api.minimaxi.com/anthropic", protocol: "anthropic-messages" },
+    { id: "mimo-token-plan", name: "Xiaomi MiMo Token Plan", baseURL: "https://token-plan-cn.xiaomimimo.com/anthropic", protocol: "anthropic-messages" },
     { id: "stepfun", name: "StepFun Step Plan", baseURL: "https://api.stepfun.com/step_plan/v1" },
     { id: "stepfun-api", name: "StepFun API", baseURL: "https://api.stepfun.com/v1", protocol: "openai-chat" },
     { id: "moonshot-cn", name: "Moonshot (国内 platform.moonshot.cn)", baseURL: "https://api.moonshot.cn/v1" },
@@ -78,9 +79,8 @@ const DOUBAO_SEED_REASONING_LEVELS = ["minimal", "low", "medium", "high"];
 const MINIMAX_M3_REASONING_LEVELS = ["off", "medium"];
 const MINIMAX_REASONING_LEVELS = ["medium"];
 // Anthropic exposes reasoning depth through output_config.effort (low | medium
-// | high | xhigh | max), not a token budget. xhigh is Opus 4.7+ only; max is
-// Opus 4.6+/Sonnet 4.6/Fable 5; Haiku 4.5 does not accept the effort param.
-// Fable 5 has thinking always on, so it has no "off". "off" disables thinking.
+// | high | xhigh | max), not a token budget. Sonnet 5 also supports xhigh.
+// Fable 5+ and Opus 5.5 have thinking always on, so they have no "off".
 const ANTHROPIC_OPUS_EFFORT_LEVELS = ["off", "low", "medium", "high", "xhigh", "max"];
 const ANTHROPIC_SONNET_EFFORT_LEVELS = ["off", "low", "medium", "high", "max"];
 const ANTHROPIC_FABLE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
@@ -100,6 +100,9 @@ export const BUILTIN_MODELS = [
     // only Ox Alpha. Discovery refreshes this entry's public metadata without
     // expanding provider membership.
     { id: OPENROUTER_MODEL_ID, name: "Ox Alpha", providerId: "openrouter", tier: "strong", reasoningLevels: OPENROUTER_OX_REASONING_LEVELS, defaultReasoningLevel: "max", contextWindow: 1048576 },
+    // Verified against /codex/models on 2026-09-17: same request shape as gpt-5.6-terra
+    // (responses-lite, six effort levels, 10k tool-output cap); minimal_client_version 0.153.0.
+    { id: "gpt-6-astra", name: "GPT-6-Astra", providerId: "openai-codex", tier: "strong", reasoningLevels: GPT56_LEVELS, defaultReasoningLevel: "medium", contextWindow: 372000, useResponsesLite: true, toolOutputTokenLimit: 10000 },
     { id: "gpt-5.6-sol", name: "GPT-5.6-Sol", providerId: "openai-codex", tier: "balanced", reasoningLevels: GPT56_LEVELS, defaultReasoningLevel: "low", contextWindow: 372000, useResponsesLite: true, toolOutputTokenLimit: 10000 },
     { id: "gpt-5.6-terra", name: "GPT-5.6-Terra", providerId: "openai-codex", tier: "strong", reasoningLevels: GPT56_LEVELS, defaultReasoningLevel: "medium", contextWindow: 372000, useResponsesLite: true, toolOutputTokenLimit: 10000 },
     { id: "gpt-5.6-luna", name: "GPT-5.6-Luna", providerId: "openai-codex", tier: "strong", reasoningLevels: GPT56_LUNA_LEVELS, defaultReasoningLevel: "medium", contextWindow: 372000, useResponsesLite: true, toolOutputTokenLimit: 10000 },
@@ -123,6 +126,13 @@ export const BUILTIN_MODELS = [
     { id: "muse-spark-1.3-contributor-free", name: "Muse Spark 1.3 Free", providerId: "opencode-zen", reasoningLevels: MUSE_SPARK_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
     { id: "muse-spark-1.2", name: "Muse Spark 1.2", providerId: "opencode-zen", reasoningLevels: MUSE_SPARK_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
     { id: "muse-spark-1.2-contributor-free", name: "Muse Spark 1.2 Free", providerId: "opencode-zen", reasoningLevels: MUSE_SPARK_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
+    // Zen /chat/completions; models.dev/opencode metadata checked 2026-09-26.
+    { id: "space-bunny-free", name: "Space Bunny Free", providerId: "opencode-zen", reasoningLevels: ["low", "medium", "high", "xhigh", "max"], defaultReasoningLevel: "high", contextWindow: 1048576 },
+    // Current public lineup, verified against platform.claude.com on 2026-09-23.
+    { id: "claude-fable-5-1", name: "Claude Fable 5.1", providerId: "anthropic", tier: "strong", reasoningLevels: ANTHROPIC_FABLE_EFFORT_LEVELS, defaultReasoningLevel: "high", contextWindow: 1000000 },
+    { id: "claude-opus-5-5", name: "Claude Opus 5.5", providerId: "anthropic", tier: "strong", reasoningLevels: ANTHROPIC_FABLE_EFFORT_LEVELS, defaultReasoningLevel: "medium", contextWindow: 1000000 },
+    { id: "claude-sonnet-5", name: "Claude Sonnet 5", providerId: "anthropic", tier: "balanced", reasoningLevels: ANTHROPIC_OPUS_EFFORT_LEVELS, defaultReasoningLevel: "high", contextWindow: 1000000 },
+    { id: "claude-opus-5", name: "Claude Opus 5", providerId: "anthropic", tier: "strong", reasoningLevels: ANTHROPIC_OPUS_EFFORT_LEVELS, defaultReasoningLevel: "high", contextWindow: 1000000 },
     { id: "claude-fable-5", name: "Claude Fable 5", providerId: "anthropic", tier: "strong", reasoningLevels: ANTHROPIC_FABLE_EFFORT_LEVELS, defaultReasoningLevel: "high", contextWindow: 1000000 },
     { id: "claude-opus-4-8", name: "Claude Opus 4.8", providerId: "anthropic", tier: "strong", reasoningLevels: ANTHROPIC_OPUS_EFFORT_LEVELS, defaultReasoningLevel: "high", contextWindow: 1000000 },
     { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6", providerId: "anthropic", tier: "balanced", reasoningLevels: ANTHROPIC_SONNET_EFFORT_LEVELS, defaultReasoningLevel: "high", contextWindow: 1000000 },
@@ -189,6 +199,12 @@ export const BUILTIN_MODELS = [
     { id: "MiniMax-M3", name: "MiniMax M3", providerId: "minimax-anthropic", tier: "strong", reasoningLevels: MINIMAX_M3_REASONING_LEVELS, contextWindow: 1000000 },
     { id: "MiniMax-M2.7", name: "MiniMax M2.7", providerId: "minimax-anthropic", tier: "balanced", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
     { id: "MiniMax-M2.7-highspeed", name: "MiniMax M2.7 Highspeed", providerId: "minimax-anthropic", tier: "fast", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    // Token Plan's text models; V2.5 remains available until 2026-10-21.
+    // https://mimo.mi.com/docs/zh-CN/tokenplan/integration/claudecode
+    { id: "mimo-v2.6-pro", name: "MiMo V2.6 Pro", providerId: "mimo-token-plan", tier: "strong", reasoningLevels: TOGGLE_THINKING_LEVELS, defaultReasoningLevel: "medium", contextWindow: 1000000 },
+    { id: "mimo-v2.6-flash", name: "MiMo V2.6 Flash", providerId: "mimo-token-plan", tier: "fast", reasoningLevels: TOGGLE_THINKING_LEVELS, defaultReasoningLevel: "medium", contextWindow: 1000000 },
+    { id: "mimo-v2.5-pro", name: "MiMo V2.5 Pro", providerId: "mimo-token-plan", reasoningLevels: TOGGLE_THINKING_LEVELS, defaultReasoningLevel: "medium", contextWindow: 1000000 },
+    { id: "mimo-v2.5", name: "MiMo V2.5", providerId: "mimo-token-plan", reasoningLevels: TOGGLE_THINKING_LEVELS, defaultReasoningLevel: "medium", contextWindow: 1000000 },
     { id: "step-3.7-flash", name: "Step 3.7 Flash", providerId: "stepfun", reasoningLevels: STEPFUN_REASONING_LEVELS, contextWindow: 256000 },
     { id: "step-3.5-flash-2603", name: "Step 3.5 Flash 2603", providerId: "stepfun", reasoningLevels: STEPFUN_REASONING_LEVELS },
     { id: "step-3.5-flash", name: "Step 3.5 Flash", providerId: "stepfun", reasoningLevels: STEPFUN_REASONING_LEVELS },

package/dist/model-config.d.ts

@@ -23,6 +23,7 @@ export interface ModelsConfig {
     providers: Record<string, ProviderModelConfig>;
 }
 export declare class ModelConfig {
+    private readonly modelsPath;
     private data?;
     private loadError?;
     constructor();

package/dist/model-config.js

@@ -6,9 +6,8 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { homedir } from "node:os";
+import { getBubbleHome } from "./bubble-home.js";
 import { filterProviderModels } from "./provider-model-policy.js";
-const MODELS_PATH = join(homedir(), ".bubble", "models.json");
 const MODEL_TIERS = ["fast", "balanced", "strong"];
 function sanitizeTier(value) {
     return typeof value === "string" && MODEL_TIERS.includes(value)
@@ -19,16 +18,17 @@ function sanitizeRoutingPriority(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
 export class ModelConfig {
+    modelsPath = join(getBubbleHome(), "models.json");
     data;
     loadError;
     constructor() {
         this.load();
     }
     load() {
-        if (!existsSync(MODELS_PATH))
+        if (!existsSync(this.modelsPath))
             return;
         try {
-            const raw = readFileSync(MODELS_PATH, "utf-8");
+            const raw = readFileSync(this.modelsPath, "utf-8");
             this.data = JSON.parse(raw);
         }
         catch (err) {
@@ -39,7 +39,7 @@ export class ModelConfig {
         return this.loadError;
     }
     getPath() {
-        return MODELS_PATH;
+        return this.modelsPath;
     }
     getProviderConfig(providerId) {
         return this.data?.providers?.[providerId];

package/dist/model-pricing.js

@@ -30,6 +30,7 @@ export const MODEL_PRICING_OVERRIDES = [
     ...[
         "muse-spark-1.3-contributor-free",
         "muse-spark-1.2-contributor-free",
+        "space-bunny-free",
     ].map((modelId) => ({
         providerId: "opencode-zen",
         modelId,
@@ -87,6 +88,9 @@ export const MODEL_PRICING_OVERRIDES = [
         const prior = kind === "pro"
             ? { inputCacheHitPerMillion: 0.003625, inputCacheMissPerMillion: 0.435, outputPerMillion: 0.87 }
             : { inputCacheHitPerMillion: 0.0028, inputCacheMissPerMillion: 0.14, outputPerMillion: 0.28 };
+        // The 2026-08-16 schedule was already Monday-Friday only; the earlier
+        // every-day model here was an omission, so applying the weekday rule to
+        // this tariff corrects August weekend history rather than repricing it.
         const previous = {
             ...peak,
             peakWindowsUtc: DEEPSEEK_PEAK_WINDOWS_UTC,
@@ -113,8 +117,28 @@ export const MODEL_PRICING_OVERRIDES = [
             }),
         };
     }),
-    // models.dev carries the Sonnet 5 launch-promo rate but not its expiry or
-    // the post-promo price; keep both so cost estimates survive the promo end.
+    // Official current prices, verified 2026-09-23:
+    // https://platform.claude.com/docs/en/about-claude/pricing
+    // Cache reads are 2.5% (Fable 5.1) / 5% (Opus 5.5), not the older 10%.
+    {
+        providerId: "anthropic",
+        modelId: "claude-fable-5-1",
+        currency: "USD",
+        inputCacheHitPerMillion: 0.25,
+        inputCacheMissPerMillion: 10,
+        inputCacheWritePerMillion: 12.5,
+        outputPerMillion: 50,
+    },
+    {
+        providerId: "anthropic",
+        modelId: "claude-opus-5-5",
+        currency: "USD",
+        inputCacheHitPerMillion: 0.2,
+        inputCacheMissPerMillion: 4,
+        inputCacheWritePerMillion: 5,
+        outputPerMillion: 20,
+    },
+    // The current official Sonnet 5 price is $2/$10 without an expiry.
     {
         providerId: "anthropic",
         modelId: "claude-sonnet-5",
@@ -123,13 +147,6 @@ export const MODEL_PRICING_OVERRIDES = [
         inputCacheMissPerMillion: 2,
         inputCacheWritePerMillion: 2.5,
         outputPerMillion: 10,
-        effectiveUntil: "2026-08-31T23:59:00Z",
-        original: {
-            inputCacheHitPerMillion: 0.3,
-            inputCacheMissPerMillion: 3,
-            inputCacheWritePerMillion: 3.75,
-            outputPerMillion: 15,
-        },
     },
     // The StepFun step plan bills in CNY; models.dev normalizes prices to USD.
     {

package/dist/network/provider-transport-log.d.ts

@@ -0,0 +1,12 @@
+import { type ProviderErrorContext } from "../provider-error-record.js";
+export interface ProviderTransportFailureContext extends ProviderErrorContext {
+    sessionId: string;
+    requestId: string;
+    attempt: number;
+    responseStatus?: number;
+    receivedEvents: number;
+    elapsedMs: number;
+    lastEventAgeMs?: number;
+    decision: "retry" | "delegate_retry" | "fail" | "cancelled";
+}
+export declare function logProviderTransportFailure(error: unknown, context: ProviderTransportFailureContext): void;

package/dist/network/provider-transport-log.js

@@ -0,0 +1,32 @@
+import { appendFileSync, existsSync, mkdirSync, renameSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { getBubbleHome } from "../bubble-home.js";
+import { createSanitizedProviderError } from "../provider-error-record.js";
+// Failure-only diagnostics are enabled without BUBBLE_TRACE. Keep at most two
+// 2 MiB files; never persist request/response bodies, headers, or raw errors.
+export function logProviderTransportFailure(error, context) {
+    try {
+        const dir = join(getBubbleHome(), "logs");
+        mkdirSync(dir, { recursive: true });
+        const file = join(dir, "provider-transport.jsonl");
+        if (existsSync(file) && statSync(file).size >= 2 * 1024 * 1024) {
+            renameSync(file, `${file}.1`);
+        }
+        appendFileSync(file, JSON.stringify({
+            timestamp: new Date().toISOString(),
+            phase: "provider_transport_failure",
+            sessionId: context.sessionId,
+            requestId: context.requestId,
+            attempt: context.attempt,
+            responseStatus: context.responseStatus,
+            receivedEvents: context.receivedEvents,
+            elapsedMs: context.elapsedMs,
+            lastEventAgeMs: context.lastEventAgeMs,
+            decision: context.decision,
+            error: createSanitizedProviderError(error, context),
+        }) + "\n", { encoding: "utf8", mode: 0o600 });
+    }
+    catch {
+        // Disk errors and concurrent rotation must never affect the request.
+    }
+}

package/dist/network/provider-transport.js

@@ -229,7 +229,12 @@ function errorMessageChain(error) {
     for (let depth = 0; current && depth < 8; depth++) {
         if (current instanceof Error) {
             messages.push(current.name, current.message);
-            current = current.cause;
+            // Node/undici stores errno on Error.code, including nested causes such
+            // as TypeError("terminated") -> SocketError { code: "UND_ERR_SOCKET" }.
+            const codedError = current;
+            if (typeof codedError.code === "string")
+                messages.push(codedError.code);
+            current = codedError.cause;
             continue;
         }
         if (typeof current === "object") {

package/dist/network/retry.d.ts

@@ -7,7 +7,7 @@
  * signalled with ProviderStreamInterruptedError so the agent loop can
  * discard the partial assistant message and re-issue the whole request.
  */
-export declare const MAX_STREAM_INTERRUPTION_RETRIES = 2;
+export declare const MAX_STREAM_INTERRUPTION_RETRIES = 10;
 export declare class ProviderStreamInterruptedError extends Error {
     readonly isProviderStreamInterruption = true;
     readonly retryAfterMs?: number;

package/dist/network/retry.js

@@ -12,7 +12,7 @@ const MAX_CONFIGURABLE_RETRIES = 10;
 const BASE_DELAY_MS = 1000;
 const MAX_DELAY_MS = 32_000;
 const MAX_RETRY_AFTER_MS = 60_000;
-export const MAX_STREAM_INTERRUPTION_RETRIES = 2;
+export const MAX_STREAM_INTERRUPTION_RETRIES = 10;
 const RETRYABLE_HTTP_STATUSES = new Set([408, 429, 500, 502, 503, 504, 529]);
 export class ProviderStreamInterruptedError extends Error {
     isProviderStreamInterruption = true;

package/dist/oauth/grok.d.ts

@@ -16,6 +16,7 @@ export declare function loginGrok(callbacks?: GrokLoginCallbacks, options?: {
 }): Promise<OAuthTokens>;
 export declare function refreshGrok(refreshToken: string, options?: {
     fetch?: ChatGptFetch;
+    timeoutMs?: number;
 }): Promise<OAuthTokens>;
 /**
  * One-time credential import from the official Grok CLI's auth store (either