@bubblebrain-ai/bubble 0.0.34 → 0.0.36

package/dist/tui-ink/paste-operation-tracker.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Tracks overlapping paste operations by identity. Finishing an older paste
+ * must never clear the pending state of a newer paste.
+ */
+export declare class PasteOperationTracker {
+    private nextId;
+    private readonly active;
+    begin(): number;
+    finish(id: number): void;
+    invalidateAll(): void;
+    get hasPending(): boolean;
+    get pendingCount(): number;
+}

package/dist/tui-ink/paste-operation-tracker.js

@@ -0,0 +1,25 @@
+/**
+ * Tracks overlapping paste operations by identity. Finishing an older paste
+ * must never clear the pending state of a newer paste.
+ */
+export class PasteOperationTracker {
+    nextId = 1;
+    active = new Set();
+    begin() {
+        const id = this.nextId++;
+        this.active.add(id);
+        return id;
+    }
+    finish(id) {
+        this.active.delete(id);
+    }
+    invalidateAll() {
+        this.active.clear();
+    }
+    get hasPending() {
+        return this.active.size > 0;
+    }
+    get pendingCount() {
+        return this.active.size;
+    }
+}

package/dist/tui-ink/plan-confirm.js

@@ -110,6 +110,6 @@ export function PlanConfirm({ initialPlan, onApprove, onReject }) {
                         return (_jsx(Text, { children: line || " " }, index));
                     }
                     const safe = line || " ";
-                    return (_jsxs(Box, { children: [_jsx(Text, { children: safe.slice(0, cursorCol) }), _jsx(Text, { backgroundColor: "white", color: "black", children: safe[cursorCol] || " " }), _jsx(Text, { children: safe.slice(cursorCol + 1) })] }, index));
+                    return (_jsxs(Box, { children: [_jsx(Text, { children: safe.slice(0, cursorCol) }), _jsx(Text, { inverse: true, children: safe[cursorCol] || " " }), _jsx(Text, { children: safe.slice(cursorCol + 1) })] }, index));
                 }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.muted, children: [_jsx(Text, { color: theme.accent, bold: true, children: "\u2303S" }), " save & approve \u00A0\u00A0", _jsx(Text, { color: theme.accent, bold: true, children: "esc" }), " cancel edit"] }) })] }));
 }

package/dist/tui-ink/run.d.ts

@@ -14,6 +14,7 @@ import type { QuestionController } from "../question/index.js";
 import type { MemoryScope } from "../memory/index.js";
 import type { ExternalHookController } from "../hooks/controller.js";
 import type { ResolvedTheme, ThemeMode } from "./theme.js";
+import type { ExternalRuntimeManager } from "../external-runtime/types.js";
 export interface RunTuiOptions {
     sessionManager?: SessionManager;
     createProvider?: (providerId: string, apiKey: string, baseURL: string) => Provider;
@@ -48,6 +49,8 @@ export interface RunTuiOptions {
     updateNoticeRefresh?: Promise<string | null>;
     /** External lifecycle hooks, threaded into slash-command execution. */
     hookController?: ExternalHookController;
+    /** Subscription-backed external agent runtime used by the interactive TUI. */
+    externalRuntime?: ExternalRuntimeManager;
 }
 export declare function createInkAppElement(agent: Agent, args: CliArgs, options: RunTuiOptions, onExit: (summary: ExitSummary) => void): React.ReactElement;
 export declare function runTui(agent: Agent, args: CliArgs, options?: RunTuiOptions): Promise<ExitSummary | undefined>;

package/dist/tui-ink/run.js

@@ -3,7 +3,7 @@ import { render } from "ink";
 import { App } from "./app.js";
 import { warmHighlighter } from "./code-highlight.js";
 export function createInkAppElement(agent, args, options, onExit) {
-    return (_jsx(App, { agent: agent, args: args, sessionManager: options.sessionManager, switchSession: options.switchSession, createProvider: options.createProvider, registry: options.registry, skillRegistry: options.skillRegistry, planHandlerRef: options.planHandlerRef, approvalHandlerRef: options.approvalHandlerRef, questionController: options.questionController, bashAllowlist: options.bashAllowlist, settingsManager: options.settingsManager, lspService: options.lspService, mcpManager: options.mcpManager, goalStore: options.goalStore, themeMode: options.themeMode, themeOverrides: options.themeOverrides, detectedTheme: options.detectedTheme, onThemeModeChange: options.onThemeModeChange, flushMemory: options.flushMemory, runMemoryCompaction: options.runMemoryCompaction, runMemorySummary: options.runMemorySummary, runMemoryRefresh: options.runMemoryRefresh, bypassEnabled: options.bypassEnabled, updateNotice: options.updateNotice, updateNoticeRefresh: options.updateNoticeRefresh, hookController: options.hookController, onExit: onExit }));
+    return (_jsx(App, { agent: agent, args: args, sessionManager: options.sessionManager, switchSession: options.switchSession, createProvider: options.createProvider, registry: options.registry, skillRegistry: options.skillRegistry, planHandlerRef: options.planHandlerRef, approvalHandlerRef: options.approvalHandlerRef, questionController: options.questionController, bashAllowlist: options.bashAllowlist, settingsManager: options.settingsManager, lspService: options.lspService, mcpManager: options.mcpManager, goalStore: options.goalStore, themeMode: options.themeMode, themeOverrides: options.themeOverrides, detectedTheme: options.detectedTheme, onThemeModeChange: options.onThemeModeChange, flushMemory: options.flushMemory, runMemoryCompaction: options.runMemoryCompaction, runMemorySummary: options.runMemorySummary, runMemoryRefresh: options.runMemoryRefresh, bypassEnabled: options.bypassEnabled, updateNotice: options.updateNotice, updateNoticeRefresh: options.updateNoticeRefresh, hookController: options.hookController, externalRuntime: options.externalRuntime, onExit: onExit }));
 }
 /**
  * Best-effort terminal restore for abnormal exits. Bubble renders into the

package/dist/tui-ink/subagent-view.d.ts

@@ -6,6 +6,7 @@
 import { type SubagentRouteLike } from "../agent/subagent-route-format.js";
 import type { Theme } from "./theme.js";
 import type { DisplayMessage, DisplayToolCall } from "./display-history.js";
+import type { ToolResultMetadata } from "../types.js";
 export interface SubagentDisplay {
     subAgentId?: string;
     agentName?: string;
@@ -26,13 +27,45 @@ export declare function subagentDescriptor(subagent: SubagentDisplay, includeThi
 export declare function subagentStatusColor(status: string | undefined, theme: Theme): string;
 export declare function subagentSummary(subagents: SubagentDisplay[]): string;
 export declare function sortSubagents(subagents: SubagentDisplay[]): SubagentDisplay[];
-/** A spawn_agent (one member), an agent_team/agent_batch, or a run_workflow (a group of members). */
+/** A spawn_agent (one member) or a run_workflow (a group of members). The
+ * "team"/"batch" kinds survive only to render transcripts recorded before
+ * those tools were removed (2026-07-06). */
 export interface SubagentGroup {
     id: string;
     kind: "single" | "team" | "batch" | "workflow";
     label: string;
     members: SubagentDisplay[];
 }
+/**
+ * Merges subagent tool metadata, deduping member snapshots by subAgentId so a
+ * stream of per-child updates accumulates into one member list instead of each
+ * update replacing the last.
+ */
+export declare function mergeToolMetadata(current: ToolResultMetadata | undefined, incoming: ToolResultMetadata | undefined): ToolResultMetadata | undefined;
+/**
+ * Drops accumulator entries whose every member reached a final status: by then
+ * the authoritative snapshot lives in the settled transcript (wait_workflow /
+ * wait_agent result), so the entry is dead weight that would otherwise pile up
+ * for the life of the process. Entries with running/queued members stay — for
+ * a workflow spanning turns they are the only live view. Returns whether the
+ * map changed (callers bump their version counter on true).
+ */
+export declare function pruneSettledLiveSubagentTools(map: Map<string, DisplayToolCall>): boolean;
+/**
+ * Accumulates a subagent tool_update whose originating tool call has already
+ * settled out of the current streaming round. The TUI clears its streaming
+ * toolCalls on every turn_start, but background children keep reporting
+ * against the launching run_workflow/spawn_agent call id across later rounds
+ * (e.g. while a wait_workflow blocks) — without this side-channel those
+ * updates are dropped and traces only appear after the whole team finishes.
+ * Entries act as synthetic tool calls feeding collectSubagentGroups.
+ * Returns true when the update was absorbed.
+ */
+export declare function accumulateLiveSubagentUpdate(map: Map<string, DisplayToolCall>, event: {
+    id: string;
+    name: string;
+    metadata?: ToolResultMetadata;
+}): boolean;
 /**
  * Collects every spawned subagent from the live transcript + streaming tools,
  * grouped by their originating tool call, for the inspector. Pure.

package/dist/tui-ink/subagent-view.js

@@ -75,6 +75,84 @@ function subagentFreshness(member) {
 function memberKey(member) {
     return member.subAgentId || `${member.nickname ?? ""}|${member.task ?? ""}`;
 }
+/**
+ * Merges subagent tool metadata, deduping member snapshots by subAgentId so a
+ * stream of per-child updates accumulates into one member list instead of each
+ * update replacing the last.
+ */
+export function mergeToolMetadata(current, incoming) {
+    if (!incoming)
+        return current;
+    if (current?.kind !== "subagent" || incoming.kind !== "subagent") {
+        return incoming;
+    }
+    const currentSubagents = Array.isArray(current.subagents) ? current.subagents : [];
+    const incomingSubagents = Array.isArray(incoming.subagents) ? incoming.subagents : [];
+    const byId = new Map();
+    for (const item of currentSubagents) {
+        const subAgentId = typeof item === "object" && item !== null && "subAgentId" in item
+            ? String(item.subAgentId)
+            : "";
+        byId.set(subAgentId || `current:${byId.size}`, item);
+    }
+    for (const item of incomingSubagents) {
+        const subAgentId = typeof item === "object" && item !== null && "subAgentId" in item
+            ? String(item.subAgentId)
+            : "";
+        byId.set(subAgentId || `incoming:${byId.size}`, item);
+    }
+    return {
+        ...current,
+        ...incoming,
+        subagents: [...byId.values()],
+    };
+}
+const FINAL_MEMBER_STATUSES = new Set(["completed", "failed", "blocked", "cancelled", "closed"]);
+/**
+ * Drops accumulator entries whose every member reached a final status: by then
+ * the authoritative snapshot lives in the settled transcript (wait_workflow /
+ * wait_agent result), so the entry is dead weight that would otherwise pile up
+ * for the life of the process. Entries with running/queued members stay — for
+ * a workflow spanning turns they are the only live view. Returns whether the
+ * map changed (callers bump their version counter on true).
+ */
+export function pruneSettledLiveSubagentTools(map) {
+    let changed = false;
+    for (const [id, tc] of map) {
+        const members = Array.isArray(tc.metadata?.subagents) ? tc.metadata.subagents : [];
+        const allFinal = members.every((member) => typeof member === "object" && member !== null
+            && FINAL_MEMBER_STATUSES.has(String(member.status)));
+        if (allFinal) {
+            map.delete(id);
+            changed = true;
+        }
+    }
+    return changed;
+}
+/**
+ * Accumulates a subagent tool_update whose originating tool call has already
+ * settled out of the current streaming round. The TUI clears its streaming
+ * toolCalls on every turn_start, but background children keep reporting
+ * against the launching run_workflow/spawn_agent call id across later rounds
+ * (e.g. while a wait_workflow blocks) — without this side-channel those
+ * updates are dropped and traces only appear after the whole team finishes.
+ * Entries act as synthetic tool calls feeding collectSubagentGroups.
+ * Returns true when the update was absorbed.
+ */
+export function accumulateLiveSubagentUpdate(map, event) {
+    if (event.metadata?.kind !== "subagent")
+        return false;
+    const prev = map.get(event.id);
+    const metadata = mergeToolMetadata(prev?.metadata, event.metadata);
+    if (!metadata)
+        return false;
+    // Per-child updates carry no mode; group them under the launching workflow
+    // call rather than falling back to one single-agent group per member.
+    if (event.name === "run_workflow" && metadata.mode === undefined)
+        metadata.mode = "workflow";
+    map.set(event.id, { id: event.id, name: event.name, args: prev?.args ?? {}, metadata });
+    return true;
+}
 /**
  * Collects every spawned subagent from the live transcript + streaming tools,
  * grouped by their originating tool call, for the inspector. Pure.
@@ -159,5 +237,8 @@ export function collectSubagentGroups(messages, streamingTools) {
         kind: g.kind,
         label: g.label,
         members: g.memberKeys.map((k) => freshest.get(k)).filter((m) => !!m),
-    }));
+    }))
+        // A group can end up empty when a later echo of the same run (e.g. the
+        // wait_workflow result vs the live accumulator) claimed all its members.
+        .filter((group) => group.members.length > 0);
 }

package/dist/tui-ink/theme.d.ts

@@ -15,7 +15,13 @@ export interface Theme {
     error: string;
     warning: string;
     success: string;
-    background: string;
+    /**
+     * Painted canvas color. `undefined` means "do not paint" — the terminal's
+     * own background shows through, so the app never fights the user's terminal
+     * palette (e.g. forcing pure black inside a soft-dark terminal). Users can
+     * still force a painted canvas via `theme.overrides.background` in config.
+     */
+    background: string | undefined;
     accent: string;
     /** Welcome banner border. */
     bannerBorder: string;
@@ -40,7 +46,8 @@ export interface Theme {
     toolResult: string;
     toolError: string;
     toolPending: string;
-    code: string;
+    /** Markdown inline `code` spans. */
+    inlineCode: string;
     traceAction: string;
     traceCount: string;
     traceDetail: string;
@@ -50,8 +57,10 @@ export interface Theme {
     userMessageBg: string;
     userMessageText: string;
     userRail: string;
+    /** Painted band backgrounds for diff lines inside user-message cards. */
     diffAdd: string;
     diffRemove: string;
+    /** Foregrounds for +/- diff lines rendered without a painted background. */
     diffAddFg: string;
     diffRemoveFg: string;
 }
@@ -62,6 +71,14 @@ export declare const darkTheme: Theme;
  * terminal background.
  */
 export declare const lightTheme: Theme;
+/**
+ * Decide whether the canvas needs painting. Auto mode always inherits the
+ * terminal's own background, and so does a forced theme that matches the
+ * detected terminal. A forced theme that mismatches (e.g. `/theme light`
+ * inside a dark terminal) paints its canvas, because its foregrounds are
+ * tuned for the opposite background and would otherwise be unreadable.
+ */
+export declare function canvasBackgroundFor(mode: ThemeMode, resolved: ResolvedTheme, terminalTheme: ResolvedTheme): string | undefined;
 export declare const ThemeProvider: import("react").Provider<Theme>;
 export declare function useTheme(): Theme;
 /** Build the active palette given a resolved mode and optional overrides. */

package/dist/tui-ink/theme.js

@@ -14,7 +14,7 @@ export const darkTheme = {
     error: "red",
     warning: "yellow",
     success: "green",
-    background: "#0A0A0A",
+    background: undefined,
     accent: "cyan",
     bannerBorder: "#38bdf8",
     bannerGradientFrom: "#67e8f9",
@@ -37,7 +37,7 @@ export const darkTheme = {
     toolResult: "gray",
     toolError: "red",
     toolPending: "yellow",
-    code: "yellow",
+    inlineCode: "#a78bfa",
     traceAction: "#E89A6B",
     traceCount: "#c9c1bd",
     traceDetail: "gray",
@@ -49,8 +49,8 @@ export const darkTheme = {
     userRail: "#8A7FC6",
     diffAdd: "#1a3d1a",
     diffRemove: "#3d1a1a",
-    diffAddFg: "#9CDCFE",
-    diffRemoveFg: "#F48771",
+    diffAddFg: "green",
+    diffRemoveFg: "red",
 };
 /**
  * Light palette tuned for paper-neutral surfaces, blue focus/user rails, warm
@@ -63,7 +63,7 @@ export const lightTheme = {
     error: "#B62633",
     warning: "#8B4A00",
     success: "#2F7D4A",
-    background: "#FCFCFA",
+    background: undefined,
     accent: "#8B4A00",
     bannerBorder: "#356FD2",
     bannerGradientFrom: "#0E7490",
@@ -86,7 +86,7 @@ export const lightTheme = {
     toolResult: "#171717",
     toolError: "#B62633",
     toolPending: "#8B4A00",
-    code: "#2F7D4A",
+    inlineCode: "#6D28D9",
     traceAction: "#8B4A00",
     traceCount: "#6F7377",
     traceDetail: "#8B9094",
@@ -98,9 +98,26 @@ export const lightTheme = {
     userRail: "#356FD2",
     diffAdd: "#D7E8D8",
     diffRemove: "#F7DADC",
-    diffAddFg: "#173D2D",
-    diffRemoveFg: "#5D1922",
+    diffAddFg: "#2F7D4A",
+    diffRemoveFg: "#B62633",
 };
+/** Canvas colors painted only when a forced theme mismatches the terminal. */
+const paintedCanvas = {
+    dark: "#0A0A0A",
+    light: "#FCFCFA",
+};
+/**
+ * Decide whether the canvas needs painting. Auto mode always inherits the
+ * terminal's own background, and so does a forced theme that matches the
+ * detected terminal. A forced theme that mismatches (e.g. `/theme light`
+ * inside a dark terminal) paints its canvas, because its foregrounds are
+ * tuned for the opposite background and would otherwise be unreadable.
+ */
+export function canvasBackgroundFor(mode, resolved, terminalTheme) {
+    if (mode === "auto" || resolved === terminalTheme)
+        return undefined;
+    return paintedCanvas[resolved];
+}
 const ThemeContext = createContext(darkTheme);
 export const ThemeProvider = ThemeContext.Provider;
 export function useTheme() {

package/dist/tui-ink/welcome.d.ts

@@ -9,6 +9,7 @@ interface WelcomeBannerProps {
     /** Session identifier (session file basename). */
     sessionLabel?: string;
     providerId?: string;
+    modelId?: string;
     modelLabel?: string;
     /** Active thinking level, rendered as part of the model unit (e.g. "xhigh"). */
     thinkingLabel?: string;
@@ -19,6 +20,6 @@ interface WelcomeVisibilityInput {
 }
 export declare function shouldShowWelcomeBanner({ startedWithVisibleHistory, }: WelcomeVisibilityInput): boolean;
 export declare function lerpColor(from: string, to: string, t: number): string;
-export declare function WelcomeBanner({ terminalColumns, tips, updateNotice, cwd, sessionLabel, providerId, modelLabel, thinkingLabel, }: WelcomeBannerProps): import("react/jsx-runtime").JSX.Element;
-export declare function formatModelLine({ providerId, modelLabel, thinkingLabel, tips, }: Pick<WelcomeBannerProps, "providerId" | "modelLabel" | "thinkingLabel" | "tips">): string;
+export declare function WelcomeBanner({ terminalColumns, tips, updateNotice, cwd, sessionLabel, providerId, modelId, modelLabel, thinkingLabel, }: WelcomeBannerProps): import("react/jsx-runtime").JSX.Element;
+export declare function formatModelLine({ providerId, modelId, modelLabel, thinkingLabel, tips, }: Pick<WelcomeBannerProps, "providerId" | "modelId" | "modelLabel" | "thinkingLabel" | "tips">): string;
 export {};

package/dist/tui-ink/welcome.js

@@ -2,6 +2,7 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
 import { Box, Text } from "ink";
 import { createRequire } from "node:module";
 import { useTheme } from "./theme.js";
+import { isThinkingOnlyModel, isThinkingToggleModel } from "../provider-transform.js";
 const require = createRequire(import.meta.url);
 const PACKAGE_VERSION = readPackageVersion();
 const COMPACT_LOGO = [
@@ -28,11 +29,12 @@ function GradientText({ text, from, to }) {
     const chars = [...text];
     return (_jsx(_Fragment, { children: chars.map((ch, i) => (_jsx(Text, { bold: true, color: lerpColor(from, to, chars.length <= 1 ? 0 : i / (chars.length - 1)), children: ch }, `ch-${i}`))) }));
 }
-export function WelcomeBanner({ terminalColumns, tips, updateNotice, cwd, sessionLabel, providerId, modelLabel, thinkingLabel, }) {
+export function WelcomeBanner({ terminalColumns, tips, updateNotice, cwd, sessionLabel, providerId, modelId, modelLabel, thinkingLabel, }) {
     const theme = useTheme();
     const effectiveWidth = Math.max(24, Math.min(terminalColumns - 2, 96));
     const modelLine = formatModelLine({
         providerId,
+        modelId,
         modelLabel,
         thinkingLabel,
         tips,
@@ -48,14 +50,16 @@ export function WelcomeBanner({ terminalColumns, tips, updateNotice, cwd, sessio
     const labelWidth = Math.max(...infoRows.map((row) => row.label.length)) + 1;
     return (_jsxs(Box, { width: effectiveWidth, flexDirection: "column", marginBottom: 1, borderStyle: "round", borderColor: theme.bannerBorder, paddingX: 2, children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { flexDirection: "column", marginRight: 2, flexShrink: 0, children: COMPACT_LOGO.map((line, rowIndex) => (_jsx(Text, { bold: true, color: lerpColor(theme.bannerGradientFrom, theme.bannerGradientTo, COMPACT_LOGO.length <= 1 ? 0 : rowIndex / (COMPACT_LOGO.length - 1)), children: line }, `logo-row-${rowIndex}`))) }), _jsxs(Box, { flexDirection: "column", marginTop: 1, flexGrow: 1, flexShrink: 1, children: [_jsx(Box, { children: _jsx(GradientText, { text: "Welcome to Bubble!", from: theme.bannerGradientFrom, to: theme.bannerGradientTo }) }), _jsx(Text, { color: theme.muted, wrap: "wrap", children: "I am a cat and you can send /help for help information." })] })] }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: infoRows.map((row) => (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { flexShrink: 0, children: _jsx(Text, { color: theme.dim, children: row.label.padEnd(labelWidth) }) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, children: _jsx(Text, { color: row.color, wrap: "wrap", children: row.value }) })] }, row.label))) }), updateNotice && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.accent, children: updateNotice }) }))] }));
 }
-export function formatModelLine({ providerId, modelLabel, thinkingLabel, tips, }) {
+export function formatModelLine({ providerId, modelId, modelLabel, thinkingLabel, tips, }) {
     const parts = [];
-    // MiniMax thinking is a binary toggle (adaptive thinking), so label it
-    // "thinking mode" rather than "<level> effort"; and its provider id
-    // ("minimax-anthropic") is redundant with the model name, so omit it.
+    // Binary thinking toggles use an internal placeholder level, so label them
+    // "thinking mode" rather than "<level> effort". MiniMax provider ids are
+    // redundant with the model name, so omit them.
     const isMiniMax = (providerId || "").toLowerCase().includes("minimax");
+    const isThinkingToggle = isThinkingToggleModel(providerId, modelId);
+    const isThinkingOnly = isThinkingOnlyModel(providerId, modelId);
     if (modelLabel) {
-        if (thinkingLabel && isMiniMax)
+        if (thinkingLabel && (isThinkingToggle || isThinkingOnly))
             parts.push(modelLabel, "thinking mode");
         else if (thinkingLabel)
             parts.push(`${modelLabel} with ${thinkingLabel} effort`);

package/dist/types.d.ts

@@ -12,7 +12,8 @@ export interface ImageContent {
     };
 }
 export type ContentPart = TextContent | ImageContent;
-export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export declare const THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
 export type ReasoningEffort = ThinkingLevel;
 export type ProviderRawContentBlock = Record<string, unknown> & {
     type: string;
@@ -169,10 +170,9 @@ export interface ToolContext {
         name: string;
     };
     agent?: {
-        runSubtask: (input: string | ContentPart[], cwd: string, options?: {
-            subtaskType?: string;
-            description?: string;
-        }) => Promise<ToolResult>;
+        /** Deferred-tool surface; backs tool_search when no controller is wired. */
+        listDeferredTools?: () => ToolRegistryEntry[];
+        unlockDeferredTools?: (names: string[]) => void;
         runSubAgent?: (input: string | ContentPart[], cwd: string, options: {
             profile: import("./agent/profiles.js").AgentProfile;
             runId: string;
@@ -210,38 +210,15 @@ export interface ToolContext {
         }) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot>;
         closeSubAgent?: (agentId: string) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot>;
         listSubAgents?: () => import("./agent/subagent-control.js").SubagentThreadSnapshot[];
-        runAgentTeam?: (cwd: string, options: {
-            profile: import("./agent/profiles.js").AgentProfile;
-            category?: string;
-            model?: string;
-            effort?: ThinkingLevel;
-            promptTemplate: string;
-            items: string[];
-            parentToolCallId: string;
-            emitUpdate?: (update: ToolUpdate) => void;
-            abortSignal?: AbortSignal;
-            approval?: "fail" | "disabled";
-        }) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot[]>;
-        runAgentBatch?: (cwd: string, options: {
-            specs: Array<{
-                task: string;
-                profile: import("./agent/profiles.js").AgentProfile;
-                category?: string;
-                model?: string;
-                effort?: ThinkingLevel;
-                outputSchema?: unknown;
-            }>;
-            parentToolCallId: string;
-            emitUpdate?: (update: ToolUpdate) => void;
-            abortSignal?: AbortSignal;
-            approval?: "fail" | "disabled";
-        }) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot[]>;
         startWorkflow?: (cwd: string, options: {
             script: string;
             args?: unknown;
             title?: string;
             parentToolCallId: string;
             abortSignal?: AbortSignal;
+            ensureProfileTrusted?: (profile: import("./agent/profiles.js").AgentProfile) => Promise<{
+                content: string | unknown;
+            } | undefined>;
         }) => {
             runId: string;
             title: string;

package/dist/types.js

@@ -1,4 +1,4 @@
 /**
  * Core types for the coding agent.
  */
-export {};
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];

package/dist/variant/thinking-level.d.ts

@@ -1,5 +1,5 @@
-import type { ThinkingLevel } from "../types.js";
-export declare const THINKING_LEVELS: ThinkingLevel[];
+import { type ThinkingLevel } from "../types.js";
+export { THINKING_LEVELS } from "../types.js";
 export declare function isThinkingLevel(value: string | undefined): value is ThinkingLevel;
 export declare function clampThinkingLevel(requestedLevel: ThinkingLevel, supportedLevels: readonly ThinkingLevel[]): ThinkingLevel;
 export declare function getNextThinkingLevel(currentLevel: ThinkingLevel, supportedLevels: readonly ThinkingLevel[]): ThinkingLevel;

package/dist/variant/thinking-level.js

@@ -1,4 +1,5 @@
-export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+import { THINKING_LEVELS } from "../types.js";
+export { THINKING_LEVELS } from "../types.js";
 export function isThinkingLevel(value) {
     return !!value && THINKING_LEVELS.includes(value);
 }

package/dist/variant/variant-resolver.d.ts

@@ -1,4 +1,26 @@
 import type { ThinkingLevel } from "../types.js";
 export declare function getAvailableThinkingLevels(providerId: string, modelId: string): ThinkingLevel[];
 export declare function getDefaultThinkingLevel(providerId: string, modelId: string): ThinkingLevel;
+/**
+ * A single non-"off" level means the model is always in thinking mode with no
+ * user-facing grades (e.g. kimi-k2.7-code) — the level value is an internal
+ * placeholder and must not be shown to the user as an effort grade.
+ */
+export declare function isThinkingOnlyLevels(levels: readonly ThinkingLevel[]): boolean;
+export declare function isThinkingOnlyModel(providerId?: string, modelId?: string): boolean;
+/**
+ * Some providers expose thinking as a true enabled/disabled switch. We may store
+ * the enabled state as "medium" internally for compatibility with ThinkingLevel,
+ * but it is not a real user-facing effort grade.
+ */
+export declare function isThinkingToggleModel(providerId?: string, modelId?: string): boolean;
 export declare function normalizeThinkingLevel(level: ThinkingLevel, supportedLevels: readonly ThinkingLevel[]): ThinkingLevel;
+/**
+ * Normalizes effort inherited from a previous model or restored session.
+ *
+ * Unlike an explicit CLI/config choice, an inherited unsupported value does
+ * not express a direction the user just chose for the target model. Prefer the
+ * target model's declared default in that case, then fall back to the canonical
+ * downward clamp for legacy models without an explicit default.
+ */
+export declare function normalizeInheritedThinkingLevel(providerId: string, modelId: string, inheritedLevel: ThinkingLevel): ThinkingLevel;

package/dist/variant/variant-resolver.js

@@ -1,5 +1,7 @@
 import { getBuiltinModel, getModelDefaultReasoningLevel } from "../model-catalog.js";
 import { clampThinkingLevel } from "./thinking-level.js";
+const KIMI_TOGGLE_PROVIDER_IDS = new Set(["moonshot-cn", "moonshot-intl", "kimi-for-coding"]);
+const KIMI_THINKING_TOGGLE_MODELS = new Set(["kimi-k2.5", "kimi-k2.6"]);
 export function getAvailableThinkingLevels(providerId, modelId) {
     return getBuiltinModel(providerId, modelId)?.reasoningLevels ?? ["off"];
 }
@@ -10,6 +12,47 @@ export function getDefaultThinkingLevel(providerId, modelId) {
         return explicitDefault;
     return levels.includes("medium") ? "medium" : levels[0] || "off";
 }
+/**
+ * A single non-"off" level means the model is always in thinking mode with no
+ * user-facing grades (e.g. kimi-k2.7-code) — the level value is an internal
+ * placeholder and must not be shown to the user as an effort grade.
+ */
+export function isThinkingOnlyLevels(levels) {
+    return levels.length === 1 && levels[0] !== "off";
+}
+export function isThinkingOnlyModel(providerId = "", modelId = "") {
+    return isThinkingOnlyLevels(getAvailableThinkingLevels(providerId, modelId));
+}
+/**
+ * Some providers expose thinking as a true enabled/disabled switch. We may store
+ * the enabled state as "medium" internally for compatibility with ThinkingLevel,
+ * but it is not a real user-facing effort grade.
+ */
+export function isThinkingToggleModel(providerId = "", modelId = "") {
+    const normalizedProvider = providerId.toLowerCase();
+    const normalizedModel = modelId.toLowerCase();
+    if (normalizedProvider.includes("minimax") || normalizedModel.includes("minimax"))
+        return true;
+    return KIMI_TOGGLE_PROVIDER_IDS.has(normalizedProvider)
+        && KIMI_THINKING_TOGGLE_MODELS.has(normalizedModel);
+}
 export function normalizeThinkingLevel(level, supportedLevels) {
     return clampThinkingLevel(level, supportedLevels);
 }
+/**
+ * Normalizes effort inherited from a previous model or restored session.
+ *
+ * Unlike an explicit CLI/config choice, an inherited unsupported value does
+ * not express a direction the user just chose for the target model. Prefer the
+ * target model's declared default in that case, then fall back to the canonical
+ * downward clamp for legacy models without an explicit default.
+ */
+export function normalizeInheritedThinkingLevel(providerId, modelId, inheritedLevel) {
+    const supportedLevels = getAvailableThinkingLevels(providerId, modelId);
+    if (supportedLevels.includes(inheritedLevel))
+        return inheritedLevel;
+    const modelDefault = getModelDefaultReasoningLevel(providerId, modelId);
+    if (modelDefault && supportedLevels.includes(modelDefault))
+        return modelDefault;
+    return clampThinkingLevel(inheritedLevel, supportedLevels);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.34",
+  "version": "0.0.36",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {
@@ -24,6 +24,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
+    "@agentclientprotocol/sdk": "1.2.1",
     "@ai-sdk/google": "^3.0.88",
     "@ai-sdk/provider": "^3.0.13",
     "@larksuiteoapi/node-sdk": "^1.65.0",
@@ -59,6 +60,9 @@
   "overrides": {
     "axios": "^1.17.0",
     "postcss": "^8.5.15",
-    "ws": "^8.21.0"
+    "ws": "^8.21.0",
+    "openai": {
+      "zod": "$zod"
+    }
   }
 }

package/dist/tools/task.d.ts

@@ -1,2 +0,0 @@
-import type { ToolRegistryEntry } from "../types.js";
-export declare function createTaskTool(): ToolRegistryEntry;