@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/tui/wordmark.js

@@ -0,0 +1,208 @@
+// Pixel-style glyphs: each cell is a half-block "pixel" (█ ▀ ▄), giving the
+// wordmark an 8-bit look while staying one terminal row per line.
+const LEAD_B = {
+    tone: "brand",
+    lines: [
+        "█   ",
+        "█   ",
+        "█▀█ ",
+        "█ █ ",
+        "█▄█ ",
+        "    ",
+    ],
+};
+const LOWER_B = {
+    tone: "ink",
+    lines: [
+        "█   ",
+        "█   ",
+        "█▀█ ",
+        "█ █ ",
+        "█▄█ ",
+        "    ",
+    ],
+};
+// Pixel cat mascot, drawn on the same half-block pixel grid as the letters:
+// pointy ears, 2x2-pixel eyes, tiny mouth, round chin (10x14 pixels). It is
+// stacked above the wordmark (icon-over-name lockup) rather than inlined, so
+// its solid fill doesn't compete with the thin letter strokes.
+const CAT_LINES = [
+    " █▄    ▄█ ",
+    " ███▄▄███ ",
+    "██████████",
+    "█  ████  █",
+    "████▀▀████",
+    "██████████",
+    " ▀██████▀ ",
+];
+export const BUBBLE_CAT = CAT_LINES.map((text) => ({
+    text,
+    tone: "brand",
+}));
+export const BUBBLE_CAT_LARGE = CAT_LINES.map((text) => ({
+    text: text.split("").map((ch) => ch + ch).join(""),
+    tone: "brand",
+}));
+const GLYPHS = {
+    u: {
+        tone: "ink",
+        lines: [
+            "    ",
+            "    ",
+            "█ █ ",
+            "█ █ ",
+            "█▄█ ",
+            "    ",
+        ],
+    },
+    l: {
+        tone: "ink",
+        lines: [
+            "█  ",
+            "█  ",
+            "█  ",
+            "█  ",
+            "█▄ ",
+            "   ",
+        ],
+    },
+    e: {
+        tone: "ink",
+        lines: [
+            "    ",
+            "    ",
+            "█▀█ ",
+            "█▀▀ ",
+            "█▄▄ ",
+            "    ",
+        ],
+    },
+    beta: {
+        tone: "brand",
+        lines: [
+            "█▀▀▄ ",
+            "█  █ ",
+            "█▀▀▄ ",
+            "█  █ ",
+            "█▄▄▀ ",
+            "█    ",
+        ],
+    },
+    r: {
+        tone: "ink",
+        lines: [
+            "    ",
+            "    ",
+            "█▀▀ ",
+            "█   ",
+            "█   ",
+            "    ",
+        ],
+    },
+    a: {
+        tone: "ink",
+        lines: [
+            "    ",
+            "    ",
+            "▀▀█ ",
+            "█▀█ ",
+            "█▄█ ",
+            "    ",
+        ],
+    },
+    i: {
+        tone: "ink",
+        lines: [
+            "  ",
+            "▀ ",
+            "█ ",
+            "█ ",
+            "█ ",
+            "  ",
+        ],
+    },
+    n: {
+        tone: "ink",
+        lines: [
+            "    ",
+            "    ",
+            "█▀█ ",
+            "█ █ ",
+            "█ █ ",
+            "    ",
+        ],
+    },
+    space: {
+        tone: "caption",
+        lines: [
+            "  ",
+            "  ",
+            "  ",
+            "  ",
+            "  ",
+            "  ",
+        ],
+    },
+};
+const WORDMARK_GLYPHS = [
+    LEAD_B,
+    GLYPHS.u,
+    LOWER_B,
+    LOWER_B,
+    GLYPHS.l,
+    GLYPHS.e,
+    GLYPHS.space,
+    GLYPHS.beta,
+    GLYPHS.r,
+    GLYPHS.a,
+    GLYPHS.i,
+    GLYPHS.n,
+];
+export const BUBBLE_WORDMARK = buildWordmark(WORDMARK_GLYPHS);
+// Each pixel doubled horizontally: terminal cells are ~2:1 tall, so 2-char
+// pixels render square and the wordmark reads much larger.
+export const BUBBLE_WORDMARK_LARGE = buildWordmark(WORDMARK_GLYPHS.map((glyph) => ({
+    tone: glyph.tone,
+    lines: glyph.lines.map((line) => line.split("").map((ch) => ch + ch).join("")),
+})));
+export const BUBBLE_COMPACT_WORDMARK = [
+    {
+        segments: [
+            { text: "b", tone: "brand" },
+            { text: "ubble ", tone: "ink" },
+            { text: "β", tone: "brand" },
+            { text: "rain", tone: "ink" },
+        ],
+    },
+];
+function buildWordmark(glyphs) {
+    const rows = Math.max(...glyphs.map((glyph) => glyph.lines.length));
+    const widths = glyphs.map((glyph) => Math.max(...glyph.lines.map((line) => line.length)));
+    return Array.from({ length: rows }, (_, rowIndex) => ({
+        segments: glyphs.map((glyph, glyphIndex) => ({
+            text: (glyph.lines[rowIndex] ?? "").padEnd(widths[glyphIndex] ?? 0, " "),
+            tone: glyph.tone,
+        })),
+    }));
+}
+export function bubbleWordmarkLineText(line) {
+    if (line.segments)
+        return line.segments.map((segment) => segment.text).join("");
+    return line.text ?? "";
+}
+export function bubbleWordmarkMaxWidth(lines = BUBBLE_WORDMARK) {
+    return Math.max(...lines.map((line) => bubbleWordmarkLineText(line).length));
+}
+const LOGO_GAP = { text: "", tone: "caption" };
+// Icon-over-name lockup: pixel cat centered above the wordmark. Both render
+// sites center every line independently, which is what stacks the cat over
+// the text without any per-line padding here.
+export function bubbleWordmarkForWidth(width) {
+    if (width >= bubbleWordmarkMaxWidth(BUBBLE_WORDMARK_LARGE) + 4) {
+        return [...BUBBLE_CAT_LARGE, LOGO_GAP, ...BUBBLE_WORDMARK_LARGE];
+    }
+    if (width >= bubbleWordmarkMaxWidth() + 4) {
+        return [...BUBBLE_CAT, LOGO_GAP, ...BUBBLE_WORDMARK];
+    }
+    return BUBBLE_COMPACT_WORDMARK;
+}

package/dist/types.d.ts

@@ -0,0 +1,503 @@
+/**
+ * Core types for the coding agent.
+ */
+export interface TextContent {
+    type: "text";
+    text: string;
+}
+export interface ImageContent {
+    type: "image_url";
+    image_url: {
+        url: string;
+    };
+}
+export type ContentPart = TextContent | ImageContent;
+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;
+};
+export type ProviderMetadataProvider = "anthropic" | "google" | "openai";
+export interface ProviderContentBlockStore {
+    contentBlocks?: ProviderRawContentBlock[];
+}
+export interface AssistantProviderMetadata {
+    anthropic?: ProviderContentBlockStore;
+    /** OpenAI Responses reasoning items captured for stateless tool-loop replay. */
+    openai?: ProviderContentBlockStore;
+    /**
+     * Gemini raw parts captured for replay: reasoning/tool-call parts carrying
+     * thoughtSignature so multi-turn thinking round-trips through our own
+     * message rebuild (the SDK's automatic replay assumes appending its
+     * response.messages verbatim, which we don't do).
+     */
+    google?: ProviderContentBlockStore;
+}
+export interface UserMessage {
+    role: "user";
+    /** Internal image observation; not an authored user prompt. */
+    toolObservation?: true;
+    content: string | ContentPart[];
+    /** Local presentation metadata; provider adapters intentionally ignore it. */
+    ui?: {
+        /** Exact composer layout, including inline image chips. */
+        displayText: string;
+        /** First [Image #N] label used by this message. */
+        imageDisplayStart?: number;
+    };
+}
+export interface AssistantMessage {
+    role: "assistant";
+    content: string;
+    reasoning?: string;
+    toolCalls?: ToolCall[];
+    providerMetadata?: AssistantProviderMetadata;
+    /** Model metadata captured for local usage statistics. */
+    model?: string;
+    providerId?: string;
+    modelId?: string;
+    usage?: TokenUsage;
+    /** Backend configuration fingerprint reported by the model provider. */
+    systemFingerprint?: string;
+    error?: {
+        name: string;
+        message: string;
+        aborted?: boolean;
+    };
+}
+export interface ToolMessage {
+    role: "tool";
+    toolCallId: string;
+    content: string;
+    metadata?: ToolResultMetadata;
+    isError?: boolean;
+}
+export interface SystemMessage {
+    role: "system";
+    content: string;
+}
+export type MetaMessageKind = "system-reminder" | "runtime-context" | "compaction-summary" | "subturn-compaction-summary";
+export interface MetaMessage {
+    role: "meta";
+    kind: MetaMessageKind;
+    content: string;
+    /**
+     * Runtime metadata is hidden from transcript and session persistence. When
+     * true or omitted, the projector may convert it into model context.
+     */
+    includeInLlm?: boolean;
+}
+export type ProviderMessage = UserMessage | AssistantMessage | ToolMessage | SystemMessage;
+export type Message = ProviderMessage | MetaMessage;
+export interface ToolParameter {
+    type?: string;
+    description?: string;
+    enum?: string[];
+    items?: ToolParameter;
+    properties?: Record<string, ToolParameter>;
+    required?: string[];
+    additionalProperties?: boolean;
+}
+export interface ToolSchema {
+    type: "object";
+    properties: Record<string, ToolParameter>;
+    required?: string[];
+    additionalProperties?: boolean;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: ToolSchema;
+}
+export type ToolChoiceMode = "auto" | "none";
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+    /**
+     * Provider-side flag set when the streamed arguments were unsalvageable
+     * (truncated mid-JSON, malformed snapshot). Persists into history so the
+     * model and the orchestrator can both see the call was rejected upstream
+     * rather than executed silently with empty args.
+     */
+    argsCorrupt?: boolean;
+}
+export interface ParsedToolCall extends ToolCall {
+    parsedArgs: Record<string, any>;
+    /**
+     * Set when the raw `arguments` string failed to JSON.parse, indicating
+     * upstream streaming corruption (truncated chunks, malformed deltas, etc.).
+     * Consumers should refuse to execute the tool and surface a tool_use_error
+     * so the model can re-issue the call.
+     */
+    argsCorrupt?: boolean;
+}
+export type ToolResultStatus = "success" | "no_match" | "partial" | "timeout" | "blocked" | "cancelled" | "command_error";
+export interface ToolResultMetadata {
+    kind?: "search" | "read" | "write" | "edit" | "patch" | "shell" | "server" | "web" | "security" | "lsp" | "question" | "subagent" | "internal";
+    path?: string;
+    pattern?: string;
+    matches?: number;
+    truncated?: boolean;
+    searchSignature?: string;
+    searchFamily?: string;
+    reason?: string;
+    diff?: string;
+    addedLines?: number;
+    removedLines?: number;
+    [key: string]: unknown;
+}
+export interface ToolResult {
+    /** Bounded screenshots, delivered as a model-visible image observation after the tool batch. */
+    images?: {
+        mimeType: "image/png" | "image/jpeg";
+        data: string;
+    }[];
+    content: string;
+    isError?: boolean;
+    status?: ToolResultStatus;
+    metadata?: ToolResultMetadata;
+}
+export type ToolEffect = "read" | "write_patch" | "write_direct" | "unknown";
+export interface ToolUpdate {
+    type: "subagent_update";
+    parentToolCallId: string;
+    runId: string;
+    subAgentId: string;
+    agentName: string;
+    nickname?: string;
+    category?: string;
+    route?: import("./agent/categories.js").ResolvedSubagentRoute;
+    status: "queued" | "running" | "completed" | "failed" | "blocked" | "cancelled";
+    childEvent?: AgentEvent;
+    summaryDelta?: string;
+    toolName?: string;
+    toolCallId?: string;
+    message?: string;
+    metadata?: ToolResultMetadata;
+}
+export type ToolExecutor = (args: Record<string, any>, ctx: ToolContext) => Promise<ToolResult>;
+export interface ToolContext {
+    cwd: string;
+    sessionID?: string;
+    abortSignal?: AbortSignal;
+    toolCall?: {
+        id: string;
+        name: string;
+    };
+    agent?: {
+        /** 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;
+            subAgentId: string;
+            parentToolCallId: string;
+            category?: string;
+            route?: import("./agent/categories.js").ResolvedSubagentRoute;
+            approval?: "fail" | "disabled";
+            emitUpdate?: (update: ToolUpdate) => void;
+            description?: string;
+            abortSignal?: AbortSignal;
+            nickname?: string;
+            forkContext?: boolean;
+        }) => Promise<import("./agent/profiles.js").SubagentRunResult>;
+        spawnSubAgent?: (input: string | ContentPart[], cwd: string, options: {
+            profile: import("./agent/profiles.js").AgentProfile;
+            parentToolCallId: string;
+            category?: string;
+            model?: string;
+            effort?: ThinkingLevel;
+            route?: import("./agent/categories.js").ResolvedSubagentRoute;
+            approval?: "fail" | "disabled";
+            description?: string;
+            abortSignal?: AbortSignal;
+            forkContext?: boolean;
+        }) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot>;
+        waitSubAgents?: (options: {
+            agentIds?: string[];
+            timeoutMs?: number;
+        }) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot[]>;
+        sendSubAgentInput?: (agentId: string, input: string | ContentPart[], cwd: string, options?: {
+            interrupt?: boolean;
+            parentToolCallId?: string;
+            abortSignal?: AbortSignal;
+        }) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot>;
+        closeSubAgent?: (agentId: string) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot>;
+        listSubAgents?: () => 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;
+        };
+        waitWorkflow?: (runId: string, timeoutMs?: number) => Promise<import("./agent/workflow/control.js").WorkflowRunSnapshot | undefined>;
+    };
+    emitUpdate?: (update: ToolUpdate) => void;
+}
+export interface ToolRegistryEntry extends ToolDefinition {
+    execute: ToolExecutor;
+    /**
+     * Optional per-child isolation hook: returns a fresh instance with its own
+     * mutable state (e.g. a FileStateTracker) so concurrent subagents in a
+     * fan-out never share it (design v2 §2). Tools without it are shared as-is.
+     */
+    cloneForChild?: () => ToolRegistryEntry;
+    /**
+     * Optional availability predicate, evaluated on EVERY model call. When it
+     * returns false the tool is omitted from the provider's function list
+     * entirely — the model cannot see or call it — and reappears on the next
+     * call once the predicate flips. For state-gated tools (e.g. update_goal
+     * without an active goal) this removes the affordance itself instead of
+     * relying on description wording, which strong models ignore.
+     */
+    enabled?: () => boolean;
+    /** Optional one-line summary for the Available tools section. */
+    promptSnippet?: string;
+    /** Optional tool-specific rules appended to the system prompt when this tool is active. */
+    promptGuidelines?: string[];
+    /** Optional compatibility shim for provider-specific argument shapes. */
+    prepareArguments?: (args: Record<string, any>) => Record<string, any>;
+    /** Whether this tool is allowed in plan mode. Defaults to false (treated as write-capable). */
+    readOnly?: boolean;
+    /** Capability classification used by subagent profiles. Defaults to "unknown". */
+    effect?: ToolEffect;
+    /** True when the tool may call ApprovalController.request(...) for an interactive decision. */
+    requiresApproval?: boolean;
+    /**
+     * If true, this tool is omitted from the tool list sent to the model on each
+     * turn until unlocked via `tool_search`. Only the tool's name appears in a
+     * startup runtime reminder. Used for MCP tools to keep them out of the
+     * per-turn context cost when not in use.
+     */
+    deferred?: boolean;
+}
+/**
+ * Runtime permission policy for tool execution. Mirrors Claude Code's
+ * `EXTERNAL_PERMISSION_MODES`:
+ *
+ * - `default`         — normal Build mode: edits/writes auto-approve; bash
+ *                       and other destructive tools ask unless allowed by rules.
+ * - `plan`            — read-only tools only; the model must propose via
+ *                       exit_plan_mode and get user approval before executing.
+ * - `bypassPermissions` — everything auto-approves. Must be explicitly enabled
+ *                       via --dangerously-skip-permissions at startup.
+ */
+export type PermissionMode = "default" | "plan" | "bypassPermissions";
+export type PlanDecision = {
+    action: "approve";
+    plan: string;
+} | {
+    action: "reject";
+    reason?: string;
+};
+export type StreamChunk = {
+    type: "text";
+    content: string;
+} | {
+    type: "reasoning_delta";
+    content: string;
+} | {
+    type: "provider_content_block";
+    provider: ProviderMetadataProvider;
+    block: ProviderRawContentBlock;
+} | {
+    type: "tool_call";
+    id: string;
+    name: string;
+    arguments: string;
+    isStart: boolean;
+    isEnd: boolean;
+    argumentsFull?: string;
+    argumentsCorrupt?: boolean;
+} | {
+    type: "usage";
+    usage: TokenUsage;
+} | {
+    type: "response_metadata";
+    systemFingerprint: string;
+} | {
+    type: "done";
+};
+export interface TokenUsage {
+    /** Whether the upstream response explicitly supplied completion_tokens. */
+    outputTokensReported?: boolean;
+    promptTokens: number;
+    completionTokens: number;
+    promptCacheHitTokens?: number;
+    promptCacheMissTokens?: number;
+    cacheCreationTokens?: number;
+    reasoningTokens?: number;
+    totalTokens?: number;
+}
+/**
+ * Priced token usage (see model-pricing.ts). Lives here rather than in
+ * model-pricing.ts because turn_end events carry it and model-pricing
+ * already imports from this module.
+ */
+export interface UsageCost {
+    currency: "USD" | "CNY";
+    cost: number;
+    /** True when the provider gave no cache breakdown and everything was billed at the miss rate. */
+    estimated: boolean;
+}
+export interface Provider {
+    streamChat(messages: ProviderMessage[], options: {
+        model: string;
+        tools?: ToolDefinition[];
+        toolChoice?: ToolChoiceMode;
+        temperature?: number;
+        thinkingLevel?: ThinkingLevel;
+        abortSignal?: AbortSignal;
+        /**
+         * How the transport treats HTTP 429 (design doc §4.5). "handle"
+         * (default): retry inside the transport. "defer": throw a typed
+         * RateLimitError immediately so the caller owns the backoff — used by
+         * subagent routes where the scheduler is the single 429 backoff layer.
+         */
+        rateLimitPolicy?: import("./network/errors.js").RateLimitPolicy;
+    }): AsyncIterable<StreamChunk>;
+    complete(messages: ProviderMessage[], options?: {
+        model?: string;
+        temperature?: number;
+        thinkingLevel?: ThinkingLevel;
+        abortSignal?: AbortSignal;
+    }): Promise<string>;
+}
+export interface AgentRunInput {
+    id: string;
+    content: string;
+    submittedAt?: number;
+}
+export interface AgentInputController {
+    /** Enqueue only while the current run can still accept boundary input. */
+    tryEnqueue?(content: string): AgentRunInput | undefined;
+    drainPendingInputs(): AgentRunInput[];
+    pendingInputCount(): number;
+    /** Atomically stop accepting input and return everything still pending. */
+    closePendingInputs?(): AgentRunInput[];
+}
+export type AgentInputRejectedReason = "no_continuation" | "turn_failed" | "turn_cancelled";
+export type AgentEvent = {
+    type: "turn_start";
+} | {
+    type: "context_usage";
+    usedTokens: number;
+    contextWindow?: number;
+    estimated: boolean;
+} | {
+    type: "context_compaction";
+    status: "started" | "completed" | "failed";
+    compactionId?: string;
+    persisted?: boolean;
+    preTokens: number;
+    postTokens?: number;
+    contextWindow?: number;
+} | {
+    type: "text_delta";
+    content: string;
+} | {
+    type: "reasoning_delta";
+    content: string;
+} | {
+    type: "hook_start";
+    eventName: string;
+    hookId: string;
+    source: string;
+} | {
+    type: "hook_end";
+    eventName: string;
+    hookId: string;
+    source: string;
+    elapsedMs: number;
+    decision: "allow" | "deny";
+    reason?: string;
+} | {
+    type: "hook_error";
+    eventName: string;
+    hookId: string;
+    source: string;
+    elapsedMs?: number;
+    decision?: "allow" | "deny";
+    reason?: string;
+    error: string;
+} | {
+    type: "tool_call_start";
+    id: string;
+    name: string;
+} | {
+    type: "tool_call_delta";
+    id: string;
+    name: string;
+    argumentsDelta: string;
+    arguments: string;
+} | {
+    type: "tool_call_end";
+    id: string;
+    name: string;
+    arguments: string;
+} | {
+    type: "tool_start";
+    id: string;
+    name: string;
+    args: Record<string, any>;
+} | {
+    type: "tool_update";
+    id: string;
+    name: string;
+    update: ToolUpdate;
+} | {
+    type: "tool_end";
+    id: string;
+    name: string;
+    result: ToolResult;
+} | {
+    type: "turn_end";
+    usage?: TokenUsage;
+    cost?: UsageCost;
+    systemFingerprint?: string;
+    willContinue?: boolean;
+} | {
+    type: "context_recovered";
+    droppedMessages: number;
+    reason: "overflow";
+} | {
+    type: "provider_retry";
+    attempt: number;
+    maxAttempts: number;
+    reason: string;
+} | {
+    type: "input_pending_changed";
+    pending: number;
+} | {
+    type: "input_applied";
+    id: string;
+    content: string;
+    target: "current_turn";
+} | {
+    type: "input_queued";
+    id: string;
+    content: string;
+    turnId: string;
+    target: "next_turn";
+} | {
+    type: "input_rejected";
+    id: string;
+    content: string;
+    reason: AgentInputRejectedReason;
+    target: "next_turn";
+} | {
+    type: "mode_changed";
+    mode: PermissionMode;
+} | {
+    type: "agent_end";
+};