@bubblebrain-ai/bubble 0.0.35 → 0.0.37

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/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;
@@ -35,6 +36,36 @@ export interface SubagentGroup {
     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/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;

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

@@ -15,3 +15,12 @@ export declare function isThinkingOnlyModel(providerId?: string, modelId?: strin
  */
 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

@@ -39,3 +39,20 @@ export function isThinkingToggleModel(providerId = "", modelId = "") {
 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.35",
+  "version": "0.0.37",
   "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",

package/dist/tools/task.d.ts

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

package/dist/tools/task.js

@@ -1,58 +0,0 @@
-export function createTaskTool() {
-    return {
-        name: "task",
-        readOnly: true,
-        effect: "read",
-        description: `Delegate a bounded investigative subtask to a read-only sub-agent and return a concise summary.
-
-Use this when:
-- a search/investigation can be scoped as a sub-problem
-- you want a focused summary before continuing the main task
-- you need to inspect a specific hypothesis or area without polluting the main loop with exploratory churn
-
-Do not use this for edits or shell-heavy workflows. The subtask agent runs in read-only plan mode.`,
-        parameters: {
-            type: "object",
-            properties: {
-                prompt: {
-                    type: "string",
-                    description: "The focused subtask prompt to investigate.",
-                },
-                description: {
-                    type: "string",
-                    description: "Short description of what this subtask is trying to verify.",
-                },
-                subtaskType: {
-                    type: "string",
-                    enum: ["search", "security_investigation", "evidence_correlation", "general_readonly"],
-                    description: "The bounded subtask policy to apply.",
-                },
-            },
-            required: ["prompt"],
-            additionalProperties: false,
-        },
-        async execute(args, ctx) {
-            const prompt = typeof args.prompt === "string" ? args.prompt.trim() : "";
-            const description = typeof args.description === "string" ? args.description.trim() : "";
-            const subtaskType = typeof args.subtaskType === "string" ? args.subtaskType : undefined;
-            if (!prompt) {
-                return { content: "Error: task prompt is required", isError: true };
-            }
-            if (!ctx.agent?.runSubtask) {
-                return { content: "Error: task tool requires an agent runtime", isError: true };
-            }
-            const composed = description
-                ? `${description}\n\n${prompt}\n\nInvestigate this sub-problem in read-only mode and return a concise evidence-based summary.`
-                : `${prompt}\n\nInvestigate this sub-problem in read-only mode and return a concise evidence-based summary.`;
-            const result = await ctx.agent.runSubtask(composed, ctx.cwd, { subtaskType, description });
-            return {
-                ...result,
-                metadata: {
-                    ...result.metadata,
-                    kind: "security",
-                    reason: description || result.metadata?.reason,
-                },
-            };
-        },
-    };
-}