@bubblebrain-ai/bubble 0.0.34 → 0.0.36

package/dist/tui-ink/markdown.js

@@ -320,16 +320,17 @@ function appendInlineSegment(segments, text, style) {
         segments.push(next);
     }
 }
-function renderSegmentNodes(segments, keyPrefix) {
-    return segments.map((segment, index) => (_jsx(Text, { bold: segment.bold, italic: segment.italic, color: segment.code ? "#a78bfa" : undefined, children: segment.text }, `${keyPrefix}-${index}`)));
+function renderSegmentNodes(segments, keyPrefix, codeColor) {
+    return segments.map((segment, index) => (_jsx(Text, { bold: segment.bold, italic: segment.italic, color: segment.code ? codeColor : undefined, children: segment.text }, `${keyPrefix}-${index}`)));
 }
-function renderInlineSegments(text, keyPrefix, style = {}) {
-    return renderSegmentNodes(parseMarkdownInlineSegments(text, style), keyPrefix);
+function renderInlineSegments(text, keyPrefix, codeColor, style = {}) {
+    return renderSegmentNodes(parseMarkdownInlineSegments(text, style), keyPrefix, codeColor);
 }
 function inlinePlainText(text) {
     return parseMarkdownInlineSegments(text).map((segment) => segment.text).join("");
 }
 function InlineText({ text, maxWidth }) {
+    const theme = useTheme();
     const { columns } = useTerminalSize();
     // Pre-wrap CJK-aware so Ink's space-only wrap-ansi can't chop "、"-joined runs
     // mid-token. A caller-supplied maxWidth is exact (it already nets out the
@@ -338,10 +339,10 @@ function InlineText({ text, maxWidth }) {
     // wrapping a few cells early is invisible, a mid-token chop is not.
     const effectiveWidth = maxWidth ?? (columns ? Math.max(20, columns - 10) : undefined);
     if (effectiveWidth === undefined) {
-        return _jsx(Text, { children: renderInlineSegments(text, "inline") });
+        return _jsx(Text, { children: renderInlineSegments(text, "inline", theme.inlineCode) });
     }
     const wrapped = wrapInlineSegments(parseMarkdownInlineSegments(text), effectiveWidth);
-    return (_jsx(_Fragment, { children: wrapped.map((segments, li) => (_jsx(Text, { children: segments.length ? renderSegmentNodes(segments, `inline-${li}`) : " " }, li))) }));
+    return (_jsx(_Fragment, { children: wrapped.map((segments, li) => (_jsx(Text, { children: segments.length ? renderSegmentNodes(segments, `inline-${li}`, theme.inlineCode) : " " }, li))) }));
 }
 function CodeBlock({ lang, lines }) {
     const theme = useTheme();
@@ -378,6 +379,7 @@ function CodeBlock({ lang, lines }) {
     return (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [lang && _jsx(Text, { color: theme.muted, children: lang }), _jsx(Box, { flexDirection: "column", children: highlighted.map((line, i) => (_jsx(Text, { children: line || " " }, i))) })] }));
 }
 function TableBlock({ headers, rows, maxWidth, }) {
+    const theme = useTheme();
     const { columns: termWidth } = useTerminalSize();
     const colCount = headers.length;
     // Reserve a buffer so the table fits even when wrapped inside an indented
@@ -425,7 +427,7 @@ function TableBlock({ headers, rows, maxWidth, }) {
             return lines;
         });
         const height = Math.max(1, ...wrapped.map((lines) => lines.length));
-        return (_jsx(Box, { flexDirection: "column", children: Array.from({ length: height }, (_, line) => (_jsxs(Text, { children: [`${g.v} `, wrapped.map((cellLines, i) => (_jsxs(React.Fragment, { children: [renderCellLine(cellLines[line] ?? [], widths[i] ?? 4, `${keyPrefix}-cell-${i}-${line}`), i < colCount - 1 ? ` ${g.v} ` : ` ${g.v}`] }, i)))] }, `${keyPrefix}-line-${line}`))) }, keyPrefix));
+        return (_jsx(Box, { flexDirection: "column", children: Array.from({ length: height }, (_, line) => (_jsxs(Text, { children: [`${g.v} `, wrapped.map((cellLines, i) => (_jsxs(React.Fragment, { children: [renderCellLine(cellLines[line] ?? [], widths[i] ?? 4, `${keyPrefix}-cell-${i}-${line}`, theme.inlineCode), i < colCount - 1 ? ` ${g.v} ` : ` ${g.v}`] }, i)))] }, `${keyPrefix}-line-${line}`))) }, keyPrefix));
     };
     return (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { children: top }), renderRow(headers, "header", true), _jsx(Text, { children: mid }), rows.map((row, ri) => renderRow(row, `row-${ri}`)), _jsx(Text, { children: bot })] }));
 }
@@ -491,10 +493,10 @@ export function allocateColumnWidths(natural, available) {
     }
     return widths;
 }
-function renderCellLine(segments, width, keyPrefix) {
+function renderCellLine(segments, width, keyPrefix, codeColor) {
     const padding = " ".repeat(Math.max(0, width - inlineSegmentsWidth(segments)));
     return [
-        ...segments.map((segment, index) => (_jsx(Text, { bold: segment.bold, italic: segment.italic, color: segment.code ? "#a78bfa" : undefined, children: segment.text }, `${keyPrefix}-${index}`))),
+        ...renderSegmentNodes(segments, keyPrefix, codeColor),
         _jsx(Text, { children: padding }, `${keyPrefix}-pad`),
     ];
 }

package/dist/tui-ink/message-list.d.ts

@@ -31,7 +31,11 @@ interface MessageListProps {
      * a freshly-cleared screen instead of appending duplicates.
      */
     staticGeneration?: number;
-    /** Horizontal padding applied inside each committed/streaming row. */
+    /**
+     * Horizontal padding applied inside each committed/streaming row. Wrap
+     * budgets net this out via TRANSCRIPT_ROW_PADDING (= both sides of the
+     * default of 1) — keep the two in sync if this ever changes.
+     */
     paddingX?: number;
     /**
      * Maximum height (rows) for the live/dynamic region. The in-progress turn is

package/dist/tui-ink/message-list.js

@@ -12,6 +12,16 @@ import { latestSubagentNote, sortSubagents, subagentDescriptor, subagentLabel, s
 import { sanitizeInternalReminderBlocks } from "../agent/internal-reminder-sanitizer.js";
 import { splitImageDisplayContent } from "../tui/image-display.js";
 const EXECUTE_COMMAND_BLOCK_MAX_LINES = 4;
+/**
+ * Every transcript row — each committed <Static> item and the DynamicClamp
+ * live region — wraps its content in paddingX={1}: one column of inset on
+ * EACH side. Any wrap budget derived from terminalColumns inside a row must
+ * net out these two columns. Forgetting them hands the pre-wrapper a budget
+ * two columns wider than the real room, and a dense CJK line that packs flush
+ * against that budget renders past the terminal edge — the terminal then
+ * hard-wraps the last glyph onto a stray row at column 0.
+ */
+const TRANSCRIPT_ROW_PADDING = 2;
 export function MessageList({ messages, streamingContent, streamingReasoning, streamingTools, streamingParts, terminalColumns, showThinking = false, verboseTrace, pendingApproval, nowTick, welcomeBanner, staticGeneration = 0, paddingX = 1, maxStreamRows, }) {
     const theme = useTheme();
     const hasStreaming = !!(streamingContent ||
@@ -195,7 +205,9 @@ function TimelineText({ content, compactTop, terminalColumns, streaming = false,
     // cell right and would overflow. Reserve that extra cell up front so the
     // pre-wrap never packs a line the terminal then hard-wraps.
     const gutter = ambiguousIsWide() ? 6 : 5;
-    const available = terminalColumns ? Math.max(20, terminalColumns - gutter) : undefined;
+    const available = terminalColumns
+        ? Math.max(20, terminalColumns - gutter - TRANSCRIPT_ROW_PADDING)
+        : undefined;
     const trimmed = visible.trim();
     return (_jsxs(Box, { marginLeft: 2, marginTop: compactTop ? 0 : 1, children: [_jsx(Text, { color: theme.agent, children: "\u25CF  " }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: streaming ? (_jsx(StreamingMarkdown, { content: trimmed, maxWidth: available })) : (_jsx(MarkdownContent, { content: trimmed, maxWidth: available })) })] }));
 }
@@ -347,7 +359,8 @@ function UserMessageBlock({ content, terminalColumns, inputStatus, separateFromP
 }
 function PendingInputMessagesBlock({ messages, terminalColumns, title, hint, bulletColor, }) {
     const theme = useTheme();
-    const contentWidth = Math.max(20, terminalColumns - 5);
+    // Inset per row: marginLeft (2) + "↳ " (2) + the transcript row padding.
+    const contentWidth = Math.max(20, terminalColumns - 4 - TRANSCRIPT_ROW_PADDING);
     return (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: bulletColor, children: "\u2022 " }), _jsxs(Text, { bold: true, color: theme.inputText, children: [title, " "] }), _jsxs(Text, { color: theme.dim, children: ["(", hint, ")"] })] }), messages.flatMap((message, messageIndex) => {
                 const { bodyLines, referenceLines } = splitImageDisplayContent(message.content || " ");
                 const wrappedBody = bodyLines.flatMap((line) => wrapByVisualWidth(line || " ", contentWidth));

package/dist/tui-ink/model-picker.d.ts

@@ -1,4 +1,4 @@
-import { ProviderRegistry } from "../provider-registry.js";
+import { ProviderRegistry, type ModelDiscoverySource, type ModelInfo, type ProviderProfile } from "../provider-registry.js";
 import type { ThinkingLevel } from "../types.js";
 export { padVisual, truncateVisual } from "../text-display.js";
 export interface ModelPickerOption {
@@ -7,6 +7,25 @@ export interface ModelPickerOption {
     group: string;
     providerBadge: string;
     reasoningLevels: ThinkingLevel[];
+    defaultReasoningLevel?: ThinkingLevel;
+    contextWindow?: number;
+    toolOutputTokenLimit?: number;
+    available: boolean;
+    pending: boolean;
+}
+export type ModelPickerPhase = {
+    kind: "model";
+} | {
+    kind: "effort";
+    model: ModelPickerOption;
+    selectedIndex: number;
+};
+export interface ModelProviderDiscoveryState {
+    status: "pending" | "complete";
+    models: ModelInfo[];
+    source?: ModelDiscoverySource;
+    authoritative: boolean;
+    error?: string;
 }
 export type PickerKeyAction = "up" | "down" | "enter" | "escape" | "backspace" | "delete";
 export declare function resolvePickerKeyAction(input: string, key: {
@@ -26,13 +45,36 @@ export declare function formatSkillPickerRow(skill: {
     width: number;
 }): string;
 export declare const MODEL_PICKER_MAX_BODY_ROWS = 10;
-export declare const MODEL_PICKER_CHROME_ROWS = 13;
+export declare const MODEL_PICKER_CHROME_ROWS = 14;
+export declare const MODEL_PICKER_RECENT_FAMILY_LIMIT = 3;
+export type ModelPickerDisplayItem = {
+    kind: "header";
+    key: string;
+    label: string;
+} | {
+    kind: "model";
+    key: string;
+    option: ModelPickerOption;
+};
 export declare function modelPickerBodyRows(termHeight: number): number;
 export declare function clampPickerIndex(index: number, length: number): number;
 export declare function pickerWindowStart(selectedIndex: number, length: number, visibleRows: number): number;
 export declare function padPickerRows(rows: string[], bodyRows: number, width: number): string[];
+export declare function modelPickerRecentKey(recent: readonly string[]): string;
+/**
+ * Returns a provider-scoped family key for model ordering.
+ *
+ * Keep this deliberately conservative: suffixes such as `mini`, `codex`,
+ * `spark`, or `highspeed` often describe distinct products rather than
+ * interchangeable siblings. The Codex Sol/Terra/Luna trio is the one family
+ * whose relationship is explicitly declared by the provider catalog.
+ */
+export declare function modelPickerFamilyKey(provider: Pick<ProviderProfile, "id" | "authType">, modelId: string): string;
+export declare function buildModelPickerDisplayItems(options: readonly ModelPickerOption[]): ModelPickerDisplayItem[];
+export declare function resolveModelPickerDisplayIndex(items: readonly ModelPickerDisplayItem[], selectedId: string | undefined): number;
+export declare function filterAndRankModelPickerOptions(options: readonly ModelPickerOption[], query: string): ModelPickerOption[];
 export declare function formatReasoningLevelsLabel(levels: readonly ThinkingLevel[], asToggle?: boolean): string;
-export declare function formatModelPickerRow(option: Pick<ModelPickerOption, "id" | "label" | "providerBadge" | "reasoningLevels">, options: {
+export declare function formatModelPickerRow(option: Pick<ModelPickerOption, "id" | "label" | "providerBadge" | "reasoningLevels"> & Partial<Pick<ModelPickerOption, "available" | "pending">>, options: {
     selected: boolean;
     current: boolean;
     width: number;
@@ -43,8 +85,12 @@ export declare function formatEffortPickerRow(level: ThinkingLevel, options: {
     asToggle?: boolean;
 }): string;
 export declare function formatNoModelResultsRow(query: string, width: number): string;
-export declare function preferredEffortIndex(option: Pick<ModelPickerOption, "reasoningLevels">, currentThinkingLevel: ThinkingLevel): number;
+export declare function preferredEffortIndex(option: Pick<ModelPickerOption, "reasoningLevels" | "defaultReasoningLevel">, currentThinkingLevel: ThinkingLevel): number;
 export declare function shouldOpenEffortPicker(option: Pick<ModelPickerOption, "reasoningLevels">): boolean;
+export declare function isModelOptionSelectable(option: Pick<ModelPickerOption, "available" | "pending" | "reasoningLevels">): boolean;
+export declare function resolveSelectedModelId(options: readonly ModelPickerOption[], selectedId: string | undefined): string | undefined;
+export declare function moveModelSelection(options: readonly ModelPickerOption[], selectedId: string | undefined, direction: -1 | 1): string | undefined;
+export declare function reconcileModelPickerPhase(phase: ModelPickerPhase, options: readonly ModelPickerOption[], currentThinkingLevel: ThinkingLevel): ModelPickerPhase;
 export interface ModelPickerProps {
     registry: ProviderRegistry;
     current: string;
@@ -55,6 +101,17 @@ export interface ModelPickerProps {
 }
 export declare function ModelPicker({ registry, current, currentThinkingLevel, recent, onSelect, onCancel }: ModelPickerProps): import("react/jsx-runtime").JSX.Element;
 export declare function buildLocalModelOptions(registry: ProviderRegistry, current: string, recent: string[]): ModelPickerOption[];
+export declare function buildMergedModelOptions(input: {
+    providers: ReturnType<ProviderRegistry["getEnabled"]>;
+    localModelsByProvider: ReadonlyMap<string, readonly ModelInfo[]>;
+    discoveries: ReadonlyMap<string, ModelProviderDiscoveryState>;
+    current: string;
+    recent: readonly string[];
+}): ModelPickerOption[];
+export declare function formatModelDiscoveryStatus(providers: readonly Pick<ReturnType<ProviderRegistry["getEnabled"]>[number], "id" | "name">[], discoveries: ReadonlyMap<string, ModelProviderDiscoveryState>): {
+    text: string;
+    hasError: boolean;
+};
 export interface ProviderPickerProps {
     providers: Array<{
         id: string;