@bubblebrain-ai/bubble 0.0.52 → 0.0.53

package/dist/tui/controller/agent-event-reducer.js

@@ -0,0 +1,238 @@
+import { tokenUsageTotal } from "../../goal/usage.js";
+import { appendTextPart, appendToolPart, contentFromParts, nextDisplayMessageKey, snapshotDisplayParts, toolCallsFromParts, } from "../model/display-history.js";
+import { parsePartialArgs } from "../formatting/summary.js";
+import { mergeToolMetadata } from "../model/subagent-view.js";
+export const STREAMING_FLUSH_INTERVAL_MS = 40;
+/** Grok external-runtime whitelist (app.tsx:1642-1656). */
+const GROK_ALLOWED_EVENTS = new Set([
+    "turn_start",
+    "text_delta",
+    "reasoning_delta",
+    "tool_start",
+    "tool_update",
+    "tool_end",
+    "turn_end",
+]);
+export function createRunState(runId) {
+    return {
+        accumulator: {
+            runId,
+            content: "",
+            reasoning: "",
+            toolCalls: [],
+            parts: [],
+            usageTokens: 0,
+            usageReported: false,
+        },
+        dirty: { content: false, reasoning: false, parts: false, tools: false },
+        outcome: "running",
+    };
+}
+/** Grok policy guard: events outside the whitelist abort the session. */
+export function grokEventAllowed(event) {
+    return GROK_ALLOWED_EVENTS.has(event.type);
+}
+export function reduceAgentEvent(state, event, ctx) {
+    const effects = [];
+    const acc = state.accumulator;
+    if (ctx.external && !grokEventAllowed(event)) {
+        // app.tsx:1647-1656 — cancel the external session and fail the run.
+        effects.push({ kind: "external-cancel-policy" });
+        return { state, effects };
+    }
+    switch (event.type) {
+        case "turn_start": {
+            // app.tsx:1658-1666 — a fresh provider call discards any half-built
+            // retry buffer so the retry never re-streams the same opening text.
+            effects.push({ kind: "stream-cleared" });
+            const fresh = createRunState(acc.runId);
+            return {
+                // A new provider attempt discards both the half-built accumulator and
+                // its pending paint bits. Carrying dirty across retries schedules a
+                // stale flush for content that no longer exists.
+                state: { ...fresh, outcome: state.outcome },
+                effects,
+            };
+        }
+        case "text_delta": {
+            acc.content += event.content;
+            appendTextPart(acc.parts, event.content);
+            return { state: { ...state, dirty: { ...state.dirty, content: true, parts: true } }, effects };
+        }
+        case "reasoning_delta": {
+            acc.reasoning += event.content;
+            return { state: { ...state, dirty: { ...state.dirty, reasoning: true } }, effects };
+        }
+        case "tool_call_start": {
+            if (!acc.toolCalls.some((t) => t.id === event.id)) {
+                const toolCall = {
+                    id: event.id,
+                    name: event.name,
+                    args: {},
+                    status: "pending",
+                    startedAt: ctx.now(),
+                };
+                acc.toolCalls.push(toolCall);
+                appendToolPart(acc.parts, toolCall);
+                effects.push({ kind: "tools-updated" });
+                return { state: { ...state, dirty: { ...state.dirty, parts: true, tools: true } }, effects };
+            }
+            return { state, effects };
+        }
+        case "tool_call_delta": {
+            const tc = acc.toolCalls.find((t) => t.id === event.id);
+            if (tc) {
+                tc.rawArguments = event.arguments;
+                tc.args = parsePartialArgs(event.arguments, tc.args);
+                effects.push({ kind: "tools-updated" });
+                return { state: { ...state, dirty: { ...state.dirty, tools: true } }, effects };
+            }
+            return { state, effects };
+        }
+        case "tool_call_end": {
+            // app.tsx:1723-1729 — nothing visual; tool_start refreshes canonical args.
+            return { state, effects };
+        }
+        case "tool_start": {
+            const existing = acc.toolCalls.find((t) => t.id === event.id);
+            if (existing) {
+                existing.args = event.args;
+                existing.status = "running";
+                existing.startedAt = existing.startedAt ?? ctx.now();
+            }
+            else {
+                const toolCall = {
+                    id: event.id,
+                    name: event.name,
+                    args: event.args,
+                    status: "running",
+                    startedAt: ctx.now(),
+                };
+                acc.toolCalls.push(toolCall);
+                appendToolPart(acc.parts, toolCall);
+            }
+            effects.push({ kind: "tools-updated" });
+            return { state: { ...state, dirty: { ...state.dirty, parts: true, tools: true } }, effects };
+        }
+        case "tool_end": {
+            const tc = acc.toolCalls.find((t) => t.id === event.id);
+            if (tc) {
+                tc.result = event.result.content;
+                const failedStatus = event.result.status === "blocked"
+                    || event.result.status === "cancelled"
+                    || event.result.status === "command_error";
+                tc.isError = !!event.result.isError || failedStatus;
+                tc.metadata = event.result.metadata;
+                tc.status = event.result.status === "blocked" || event.result.status === "cancelled"
+                    ? event.result.status
+                    : tc.isError
+                        ? "failed"
+                        : "completed";
+                effects.push({ kind: "tools-updated" });
+                return { state: { ...state, dirty: { ...state.dirty, tools: true } }, effects };
+            }
+            return { state, effects };
+        }
+        case "tool_update": {
+            const tc = acc.toolCalls.find((t) => t.id === event.id);
+            if (tc) {
+                if (event.update.metadata) {
+                    // Subagent updates arrive one member at a time. A shallow merge
+                    // replaces metadata.subagents and silently drops earlier children.
+                    tc.metadata = mergeToolMetadata(tc.metadata, event.update.metadata);
+                }
+                if (event.update.message) {
+                    tc.result = event.update.message;
+                }
+                tc.status = event.update.status;
+                tc.isError = event.update.status === "failed" || event.update.status === "blocked" || event.update.status === "cancelled";
+                effects.push({ kind: "tools-updated" });
+                return { state: { ...state, dirty: { ...state.dirty, tools: true } }, effects };
+            }
+            // app.tsx:1741-1753 — the launching call already settled; a live
+            // subagent update routes to the cross-round accumulator.
+            effects.push({ kind: "live-subagent-changed" });
+            return { state, effects };
+        }
+        case "mode_changed": {
+            effects.push({ kind: "permission-mode-changed", mode: event.mode });
+            return { state, effects };
+        }
+        case "input_applied": {
+            const steer = ctx.pendingSteers.get(event.id);
+            if (steer) {
+                effects.push({ kind: "steer-applied", id: event.id, displayKey: steer.displayKey });
+            }
+            return { state, effects };
+        }
+        case "input_rejected": {
+            const steer = ctx.pendingSteers.get(event.id);
+            if (steer) {
+                effects.push({ kind: "steer-requeued", id: event.id, displayKey: steer.displayKey });
+            }
+            return { state, effects };
+        }
+        case "input_pending_changed": {
+            effects.push({ kind: "queue-updated", pending: event.pending });
+            return { state, effects };
+        }
+        case "turn_end": {
+            if (event.usage) {
+                acc.usageReported = true;
+                acc.usageTokens += tokenUsageTotal(event.usage);
+            }
+            acc.systemFingerprint = event.systemFingerprint ?? acc.systemFingerprint;
+            if (event.willContinue) {
+                effects.push({ kind: "assistant-committed" });
+                effects.push({ kind: "stream-cleared" });
+                return { state, effects };
+            }
+            const elapsed = ctx.runStartedAt != null ? ctx.now() - ctx.runStartedAt : undefined;
+            effects.push({ kind: "assistant-committed", taskElapsedMs: elapsed });
+            effects.push({ kind: "stream-cleared" });
+            return { state, effects };
+        }
+        default:
+            // hook_*, context_recovered, provider_retry, agent_end: silently
+            // ignored today (app.tsx has no cases for them).
+            return { state, effects };
+    }
+}
+/** finally-block semantics (app.tsx:1888-1958) as a pure transition. */
+export function reduceRunFinish(state, opts) {
+    const effects = [];
+    const cancelled = opts.cancelled;
+    const outcome = cancelled ? "cancelled" : opts.errored ? "errored" : "running";
+    if (opts.leftoverSteers.length > 0) {
+        effects.push({ kind: "steers-drained", cancelled, leftovers: opts.leftoverSteers });
+    }
+    if (opts.ownsCurrentGeneration) {
+        effects.push({ kind: "queue-updated", pending: 0 });
+        effects.push({ kind: "run-finished", cancelled, errored: opts.errored });
+    }
+    return { state: { ...state, outcome }, effects };
+}
+/** Build the committed assistant message from the accumulator (app.tsx:1567-1607). */
+export function buildAssistantMessage(state, taskElapsedMs) {
+    const acc = state.accumulator;
+    const hasOutput = !!acc.content || !!acc.reasoning || acc.toolCalls.length > 0 || acc.parts.length > 0;
+    if (!hasOutput)
+        return null;
+    const currentParts = snapshotDisplayParts(acc.parts);
+    const currentToolCalls = [...acc.toolCalls];
+    const partContent = acc.content || contentFromParts(currentParts);
+    const partToolCalls = currentToolCalls.length > 0 ? currentToolCalls : toolCallsFromParts(currentParts);
+    const message = { key: nextDisplayMessageKey("asst"), role: "assistant", content: partContent };
+    if (acc.reasoning)
+        message.reasoning = acc.reasoning;
+    if (partToolCalls.length > 0)
+        message.toolCalls = partToolCalls;
+    if (currentParts.length > 0)
+        message.parts = currentParts;
+    if (taskElapsedMs !== undefined && Number.isFinite(taskElapsedMs) && taskElapsedMs > 0) {
+        message.taskElapsedMs = taskElapsedMs;
+    }
+    if (acc.systemFingerprint)
+        message.systemFingerprint = acc.systemFingerprint;
+    return message;
+}

package/dist/tui/controller/composer-controller.d.ts

@@ -0,0 +1,95 @@
+import type { Editor } from "@bubblebrain-ai/pi-tui";
+import { type HistoryScope } from "../model/input-history.js";
+import type { ImageAttachment } from "../model/image-attachment.js";
+import type { SubmitPayload } from "../model/composer-types.js";
+import { type Theme } from "../model/theme.js";
+interface ComposerControllerOptions {
+    editor: Editor;
+    scope: HistoryScope;
+    nextImageLabelStart: number;
+    onSubmit(payload: SubmitPayload): void;
+    onNotice(message: string): void;
+    onStateChange(): void;
+    onOpenImage?(attachment: ComposerDraftAttachment): void;
+    allowImageAttachments?: () => boolean;
+    readClipboardImage?: ClipboardImageReader;
+    historyFilePath?: string;
+    persistHistory?: boolean;
+    getTheme?: () => Theme;
+}
+export type ClipboardImageReader = () => Promise<{
+    attachment?: ImageAttachment;
+    error?: string;
+}>;
+export interface ComposerDraftAttachment {
+    attachment: ImageAttachment;
+    label: string;
+}
+export interface ComposerDraftSnapshot {
+    text: string;
+    attachments: ComposerDraftAttachment[];
+    imageDisplayStart?: number;
+}
+/**
+ * Owns semantic composer state that Pi Editor deliberately does not know about:
+ * image attachments, asynchronous paste operations and scoped persistent
+ * history. Text editing and cursor mechanics remain inside Editor.
+ */
+export declare class ComposerController {
+    private readonly options;
+    private editor;
+    private scope;
+    private history;
+    private historyIndex;
+    private historyDraft;
+    private attachments;
+    private imageDisplayStart;
+    private nextImageLabelStart;
+    private readonly pasteOperations;
+    private draftGeneration;
+    private applyingEditorState;
+    private historyNavigationChangePending;
+    private editorSubmitting;
+    private disposed;
+    private recentPreviewLabel?;
+    private recentPreviewCursorOffset?;
+    private openImageHandler?;
+    constructor(options: ComposerControllerOptions);
+    attachEditor(editor: Editor): void;
+    private detachEditor;
+    dispose(): void;
+    pendingImageCount(): number;
+    setOpenImageHandler(handler?: (attachment: ComposerDraftAttachment) => void): void;
+    private syncOpenImageActivation;
+    /**
+     * Explicit keyboard-driven clipboard probe. Image-only clipboards do not
+     * produce text for many terminals, so Cmd+V may have no bracketed-paste body
+     * and Ctrl+V arrives as a key chord instead of a paste event.
+     */
+    requestClipboardImagePaste(): void;
+    historyTexts(): string[];
+    getText(): string;
+    snapshotDraft(): ComposerDraftSnapshot;
+    /** Image whose chip was just inserted, is under the cursor, or is hovered. */
+    previewAttachment(): ComposerDraftAttachment | undefined;
+    restoreDraft(snapshot: ComposerDraftSnapshot): void;
+    /** Replace the complete draft and invalidate attachments/pastes/history browse. */
+    replaceDraft(text: string): void;
+    /** Rebind persistent history after a successful session transition. */
+    setScope(scope: HistoryScope, nextImageLabelStart: number): void;
+    private reloadHistory;
+    private handleEditorChange;
+    private handleEditorSubmit;
+    private resetAfterSubmit;
+    private navigateHistory;
+    private handlePaste;
+    private beginPastePlaceholder;
+    private finishPaste;
+    private replacePasteMarker;
+    private startClipboardPaste;
+    private startPathPaste;
+    private registerAttachment;
+    private syncEditorDecorations;
+    private invalidateDraftAsyncWork;
+}
+export {};