@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/session-log.js

@@ -0,0 +1,444 @@
+import { createHash } from "node:crypto";
+import { sanitizeAssistantProviderMetadata, sanitizeInternalReasoningText, sanitizeInternalReminderBlocks, } from "./agent/internal-reminder-sanitizer.js";
+import { tryCheckpointMessages } from "./context/checkpoint.js";
+import { isPermissionModeReminder, reminderForMode } from "./prompt/reminders.js";
+/** Records that change conversational context or its execution state.
+ * Keep this shared by revision hashing and checkpoint receipt supersession.
+ * Unknown/new markers are conservative: only known diagnostics are excluded.
+ */
+export function affectsContextRevision(entry) {
+    if (entry.type === "metadata" || entry.type === "provider_error")
+        return false;
+    if (entry.type === "marker") {
+        return !["task_started", "task_finished", "task_killed"].includes(entry.kind);
+    }
+    return true;
+}
+export class SessionLog {
+    entries = [];
+    nextId = 1;
+    contextRevision = "empty";
+    allocateId() { return String(this.nextId++); }
+    appendEntries(entries) {
+        this.entries.push(...entries);
+        for (const entry of entries) {
+            this.nextId = Math.max(this.nextId, (parseInt(entry.id, 10) || 0) + 1);
+            if (affectsContextRevision(entry)) {
+                this.contextRevision = createHash("sha256").update(this.contextRevision).update(JSON.stringify(entry)).digest("hex");
+            }
+        }
+    }
+    getRevision() { return this.contextRevision; }
+    load(lines) {
+        this.entries = [];
+        this.nextId = 1;
+        this.contextRevision = "empty";
+        for (const line of lines) {
+            try {
+                const raw = JSON.parse(line);
+                this.appendEntries(normalizeEntry(raw));
+            }
+            catch {
+                // skip corrupt lines
+            }
+        }
+    }
+    replace(entries) {
+        this.entries = [];
+        this.nextId = 1;
+        this.contextRevision = "empty";
+        this.appendEntries(entries);
+    }
+    list() {
+        return [...this.entries];
+    }
+    getMetadata() {
+        let entry;
+        for (let i = this.entries.length - 1; i >= 0; i--) {
+            const item = this.entries[i];
+            if (item.type === "metadata") {
+                entry = item;
+                break;
+            }
+        }
+        const metadata = entry?.metadata ?? {};
+        return {
+            ...metadata,
+            thinkingLevel: metadata.thinkingLevel ?? metadata.reasoningEffort,
+        };
+    }
+    setMetadata(metadata) {
+        const next = [...this.entries];
+        const entry = {
+            id: "metadata",
+            type: "metadata",
+            metadata,
+            timestamp: Date.now(),
+        };
+        const existingIndex = next.findIndex((item) => item.type === "metadata");
+        if (existingIndex >= 0) {
+            next[existingIndex] = entry;
+        }
+        else {
+            next.unshift(entry);
+        }
+        this.entries = next;
+        return next;
+    }
+    appendMessage(message) {
+        const normalized = normalizeMessageToEntries(message, this.allocateId(), Date.now());
+        this.appendEntries(normalized);
+        return normalized;
+    }
+    appendMarker(kind, value) {
+        const entry = {
+            id: this.allocateId(),
+            type: "marker",
+            kind,
+            value,
+            timestamp: Date.now(),
+        };
+        this.appendEntries([entry]);
+        return entry;
+    }
+    appendProviderError(error) {
+        const entry = {
+            id: this.allocateId(),
+            type: "provider_error",
+            error,
+            timestamp: Date.now(),
+        };
+        this.appendEntries([entry]);
+        return entry;
+    }
+    toMessages() {
+        const messages = [];
+        let latestSummaryIndex = -1;
+        let latestClearIndex = -1;
+        // An unreadable checkpoint is skipped, not fatal: its originals are still in
+        // the log, so replay continues from the previous readable boundary.
+        let checkpointProjection;
+        for (let index = this.entries.length - 1; index >= 0; index--) {
+            const entry = this.entries[index];
+            if (entry.type === "context_checkpoint") {
+                checkpointProjection = tryCheckpointMessages(entry.checkpoint);
+                if (!checkpointProjection)
+                    continue;
+            }
+            else if (entry.type !== "summary")
+                continue;
+            latestSummaryIndex = index;
+            break;
+        }
+        for (let index = this.entries.length - 1; index >= 0; index--) {
+            const entry = this.entries[index];
+            if (entry.type === "marker" && entry.kind === "conversation_clear") {
+                latestClearIndex = index;
+                break;
+            }
+        }
+        if (latestSummaryIndex > latestClearIndex) {
+            const entry = this.entries[latestSummaryIndex];
+            if (entry.type === "context_checkpoint") {
+                messages.push(...(checkpointProjection ?? []));
+            }
+            else if (entry.type === "summary") {
+                // Legacy summaries remain readable; already discarded originals cannot be reconstructed.
+                messages.push({ role: "system", content: `Previous conversation summary: ${entry.summary}` });
+            }
+        }
+        const startIndex = Math.max(latestSummaryIndex > latestClearIndex ? latestSummaryIndex + 1 : 0, latestClearIndex + 1);
+        const committedPrefixLength = latestSummaryIndex > latestClearIndex
+            && this.entries[latestSummaryIndex].type === "context_checkpoint" ? messages.length : 0;
+        // Every checkpoint past the readable boundary is unreadable by construction.
+        // Its projection is unusable, but its position still proves the originals
+        // before it were committed at a complete-tool-group model boundary.
+        let unreadableBoundaryLength = 0;
+        // Permission-mode switches become mode reminders where they happened, so
+        // the model reads the mode timeline in order: a later "plan mode is
+        // active" outranks an earlier tool result saying the mode went back to
+        // default. A switch is written out before the next user message (never
+        // inside a tool group); one from before a compaction/clear boundary still
+        // applies and opens the replayed history.
+        let pendingMode = lastModeSwitchBefore(this.entries, startIndex);
+        const flushMode = () => {
+            if (pendingMode === undefined)
+                return;
+            messages.push({ role: "meta", kind: "system-reminder", content: reminderForMode(pendingMode) });
+            pendingMode = undefined;
+        };
+        for (let index = startIndex; index < this.entries.length; index++) {
+            const entry = this.entries[index];
+            switch (entry.type) {
+                case "marker": {
+                    const mode = entry.kind === "mode_switch" ? permissionModeOf(entry.value) : undefined;
+                    if (mode)
+                        pendingMode = mode;
+                    break;
+                }
+                case "context_checkpoint":
+                    unreadableBoundaryLength = messages.length;
+                    break;
+                case "user_message":
+                    flushMode();
+                    messages.push(cloneMessage(entry.message));
+                    break;
+                case "assistant_message":
+                    messages.push({
+                        ...entry.message,
+                        role: "assistant",
+                        content: sanitizeInternalReminderBlocks(entry.message.content),
+                        reasoning: entry.message.reasoning !== undefined
+                            ? sanitizeInternalReasoningText(entry.message.reasoning)
+                            : undefined,
+                        providerMetadata: sanitizeAssistantProviderMetadata(cloneProviderMetadata(entry.message.providerMetadata), entry.message.modelId ?? entry.message.model),
+                    });
+                    break;
+                case "tool_call": {
+                    const last = messages[messages.length - 1];
+                    if (last?.role === "assistant") {
+                        const assistant = last;
+                        assistant.toolCalls = [...(assistant.toolCalls ?? []), { ...entry.toolCall }];
+                    }
+                    else {
+                        messages.push({
+                            role: "assistant",
+                            content: "",
+                            toolCalls: [{ ...entry.toolCall }],
+                        });
+                    }
+                    break;
+                }
+                case "tool_result":
+                    messages.push(cloneMessage(entry.message));
+                    break;
+                default:
+                    break;
+            }
+        }
+        flushMode();
+        retireStaleModeReminders(messages);
+        // A committed checkpoint may end in completed tools without a final text
+        // response. It is a resumable model boundary, not an interrupted user turn.
+        const boundary = Math.max(committedPrefixLength, unreadableBoundaryLength);
+        if (boundary > 0) {
+            let head = messages.slice(0, boundary);
+            if (unreadableBoundaryLength > committedPrefixLength) {
+                // Replayed originals, not a validated projection: hold the turn the
+                // boundary split to complete-tool-group semantics, as its continuation is.
+                let turnStart = head.length;
+                for (let i = head.length - 1; i >= committedPrefixLength; i--) {
+                    if (head[i].role === "user") {
+                        turnStart = i;
+                        break;
+                    }
+                }
+                head = [...head.slice(0, turnStart), ...pruneIncompleteToolGroups(head.slice(turnStart))];
+            }
+            const tail = messages.slice(boundary);
+            const nextUser = tail.findIndex(message => message.role === "user");
+            const continuationEnd = nextUser < 0 ? tail.length : nextUser;
+            return [
+                ...head,
+                ...pruneIncompleteToolGroups(tail.slice(0, continuationEnd)),
+                ...pruneIncompleteTail(tail.slice(continuationEnd)),
+            ];
+        }
+        return pruneIncompleteTail(messages);
+    }
+}
+function normalizeEntry(raw) {
+    if (isSessionLogEntry(raw)) {
+        return [raw];
+    }
+    if (raw.type === "metadata") {
+        return [{
+                id: raw.id,
+                type: "metadata",
+                metadata: raw.metadata ?? {},
+                timestamp: raw.timestamp,
+            }];
+    }
+    if (raw.type === "compaction") {
+        return [{
+                id: raw.id,
+                type: "summary",
+                summary: raw.summary ?? "",
+                timestamp: raw.timestamp,
+            }];
+    }
+    if (raw.type === "message" && raw.data) {
+        return normalizeMessageToEntries(raw.data, raw.id, raw.timestamp);
+    }
+    return [];
+}
+function normalizeMessageToEntries(message, id, timestamp) {
+    switch (message.role) {
+        case "user":
+            return [{ id, type: "user_message", message, timestamp }];
+        case "assistant": {
+            const assistantEntry = {
+                id,
+                type: "assistant_message",
+                message: {
+                    role: "assistant",
+                    content: sanitizeInternalReminderBlocks(message.content),
+                    reasoning: message.reasoning !== undefined
+                        ? sanitizeInternalReasoningText(message.reasoning)
+                        : undefined,
+                    model: message.model,
+                    providerId: message.providerId,
+                    modelId: message.modelId,
+                    usage: message.usage,
+                    systemFingerprint: message.systemFingerprint,
+                    error: message.error,
+                    providerMetadata: sanitizeAssistantProviderMetadata(cloneProviderMetadata(message.providerMetadata), message.modelId ?? message.model),
+                },
+                timestamp,
+            };
+            const toolCallEntries = (message.toolCalls ?? []).map((toolCall, index) => ({
+                id: `${id}:tool:${index + 1}`,
+                type: "tool_call",
+                toolCall,
+                timestamp,
+            }));
+            return [assistantEntry, ...toolCallEntries];
+        }
+        case "tool":
+            return [{ id, type: "tool_result", message, timestamp }];
+        case "meta":
+            return [];
+        case "system":
+            return [{
+                    id,
+                    type: "summary",
+                    summary: message.content,
+                    timestamp,
+                }];
+    }
+}
+function isSessionLogEntry(entry) {
+    return [
+        "metadata",
+        "context_checkpoint",
+        "summary",
+        "marker",
+        "user_message",
+        "assistant_message",
+        "tool_call",
+        "tool_result",
+        "provider_error",
+    ].includes(entry.type);
+}
+function cloneMessage(message) {
+    if (message.role === "assistant") {
+        return {
+            ...message,
+            toolCalls: message.toolCalls?.map((toolCall) => ({ ...toolCall })),
+            providerMetadata: cloneProviderMetadata(message.providerMetadata),
+        };
+    }
+    if (message.role === "user" && Array.isArray(message.content)) {
+        return {
+            ...message,
+            content: message.content.map((part) => ({
+                ...part,
+                ...(part.type === "image_url" ? { image_url: { ...part.image_url } } : {}),
+            })),
+        };
+    }
+    return { ...message };
+}
+function cloneProviderMetadata(metadata) {
+    if (metadata === undefined)
+        return undefined;
+    return JSON.parse(JSON.stringify(metadata));
+}
+// A checkpoint can split a user turn. Its continuation has no user anchor,
+// so validate complete tool groups directly rather than relying on turn pruning.
+const PERMISSION_MODES = new Set(["default", "plan", "bypassPermissions"]);
+function permissionModeOf(value) {
+    return PERMISSION_MODES.has(value) ? value : undefined;
+}
+function lastModeSwitchBefore(entries, end) {
+    for (let index = end - 1; index >= 0; index--) {
+        const entry = entries[index];
+        if (entry.type === "marker" && entry.kind === "mode_switch") {
+            const mode = permissionModeOf(entry.value);
+            if (mode)
+                return mode;
+        }
+    }
+    return undefined;
+}
+/** Only the latest mode reminder speaks to the model, as in a live agent. */
+function retireStaleModeReminders(messages) {
+    let latest = true;
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message.role !== "meta" || message.kind !== "system-reminder" || !isPermissionModeReminder(message.content))
+            continue;
+        if (latest)
+            latest = false;
+        else
+            message.includeInLlm = false;
+    }
+}
+function pruneIncompleteToolGroups(messages) {
+    const pending = new Set();
+    let groupStart = -1;
+    for (let index = 0; index < messages.length; index++) {
+        const message = messages[index];
+        if (message.role === "system" || message.role === "meta")
+            continue;
+        if (message.role === "tool") {
+            if (!pending.delete(message.toolCallId))
+                return messages.slice(0, groupStart < 0 ? index : groupStart);
+            if (pending.size === 0)
+                groupStart = -1;
+        }
+        else {
+            if (pending.size)
+                return messages.slice(0, groupStart);
+            if (message.role === "assistant" && message.toolCalls?.length) {
+                groupStart = index;
+                for (const call of message.toolCalls) {
+                    if (!call.id || pending.has(call.id))
+                        return messages.slice(0, groupStart);
+                    pending.add(call.id);
+                }
+            }
+        }
+    }
+    return pending.size ? messages.slice(0, groupStart) : messages;
+}
+function pruneIncompleteTail(messages) {
+    let currentTurnStart = -1;
+    let hasCompletedAssistant = false;
+    let sawNonUserInCurrentTurn = false;
+    for (let i = 0; i < messages.length; i++) {
+        const message = messages[i];
+        if (message.role === "system" || message.role === "meta")
+            continue;
+        if (message.role === "user") {
+            currentTurnStart = i;
+            hasCompletedAssistant = false;
+            sawNonUserInCurrentTurn = false;
+            continue;
+        }
+        if (currentTurnStart === -1) {
+            continue;
+        }
+        sawNonUserInCurrentTurn = true;
+        if (message.role === "assistant") {
+            const hasPendingTools = !!message.toolCalls && message.toolCalls.length > 0;
+            if (!hasPendingTools) {
+                hasCompletedAssistant = true;
+            }
+        }
+    }
+    if (currentTurnStart >= 0 && sawNonUserInCurrentTurn && !hasCompletedAssistant) {
+        return messages.slice(0, currentTurnStart);
+    }
+    return messages;
+}

package/dist/session-title.d.ts

@@ -0,0 +1,16 @@
+import type { SessionManager } from "./session.js";
+import type { ContentPart, Message, ProviderMessage, ThinkingLevel } from "./types.js";
+export interface SessionTitleUpdater {
+    handlePersistedMessage(message: Message): void;
+}
+export declare function createSessionTitleUpdater(options: {
+    sessionManager: SessionManager;
+    complete: (messages: ProviderMessage[], options?: {
+        model?: string;
+        temperature?: number;
+        thinkingLevel?: ThinkingLevel;
+        abortSignal?: AbortSignal;
+    }) => Promise<string>;
+}): SessionTitleUpdater;
+export declare function cleanGeneratedTitle(raw: string): string;
+export declare function deterministicTitleFromUserContent(content: string | ContentPart[]): string;

package/dist/session-title.js

@@ -0,0 +1,131 @@
+import { normalizeSingleLine, truncateVisual } from "./text-display.js";
+import { createPastedContentMarker, shouldCollapsePastedContent } from "./tui/paste-placeholder.js";
+const TITLE_INPUT_MAX_CHARS = 4000;
+const TITLE_MAX_WIDTH = 80;
+const TITLE_SYSTEM_PROMPT = [
+    "You are a title generator. Output ONLY a conversation title.",
+    "",
+    "Rules:",
+    "- Single line only.",
+    "- Use the same language as the user message.",
+    "- Keep it brief and useful for finding this conversation later.",
+    "- Do not answer the user's request.",
+    "- Do not mention tools unless the tool itself is the topic.",
+    "- No explanations, no markdown, no quotes.",
+].join("\n");
+export function createSessionTitleUpdater(options) {
+    let pending;
+    let inFlight = false;
+    const run = async (candidate) => {
+        const raw = await options.complete(buildTitleMessages(candidate.input), {
+            temperature: 0.3,
+            thinkingLevel: "off",
+        });
+        const title = cleanGeneratedTitle(raw);
+        if (!title)
+            return;
+        if (!isCandidateCurrent(options.sessionManager.getEntries(), candidate.userMessageId))
+            return;
+        if (options.sessionManager.getMetadata().title?.trim())
+            return;
+        options.sessionManager.updateMetadata({
+            title,
+            titleSource: "llm",
+            titleUpdatedAt: Date.now(),
+            titleUserMessageId: candidate.userMessageId,
+        });
+    };
+    return {
+        handlePersistedMessage(message) {
+            if (message.role === "user") {
+                if (pending || inFlight)
+                    return;
+                if (options.sessionManager.getMetadata().title?.trim())
+                    return;
+                if (currentUserMessageCount(options.sessionManager.getMessages()) !== 1)
+                    return;
+                const userEntryId = latestUserMessageEntryId(options.sessionManager.getEntries());
+                if (!userEntryId)
+                    return;
+                const input = titleInputFromUserContent(message.content);
+                if (!input)
+                    return;
+                pending = { input, userMessageId: userEntryId };
+                return;
+            }
+            if (message.role !== "assistant" || !pending || inFlight)
+                return;
+            const candidate = pending;
+            pending = undefined;
+            inFlight = true;
+            void run(candidate).catch(() => undefined).finally(() => {
+                inFlight = false;
+            });
+        },
+    };
+}
+export function cleanGeneratedTitle(raw) {
+    const withoutThinking = raw.replace(/<think>[\s\S]*?<\/think>/gi, "");
+    const withoutFences = withoutThinking.replace(/```[a-zA-Z0-9_-]*\s*/g, "").replace(/```/g, "");
+    const line = withoutFences
+        .split(/\r?\n/)
+        .map((item) => item.trim())
+        .find(Boolean);
+    if (!line)
+        return "";
+    const unquoted = line.replace(/^["'“”‘’]+|["'“”‘’]+$/g, "");
+    return truncateVisual(normalizeSingleLine(unquoted), TITLE_MAX_WIDTH);
+}
+export function deterministicTitleFromUserContent(content) {
+    const text = userContentText(content);
+    if (!text)
+        return "User message";
+    if (shouldCollapsePastedContent(text)) {
+        return createPastedContentMarker(text);
+    }
+    return truncateVisual(normalizeSingleLine(text), TITLE_MAX_WIDTH) || "User message";
+}
+function titleInputFromUserContent(content) {
+    const title = deterministicTitleFromUserContent(content);
+    const text = userContentText(content);
+    if (!text)
+        return title;
+    return normalizeSingleLine(text).slice(0, TITLE_INPUT_MAX_CHARS);
+}
+function userContentText(content) {
+    if (typeof content === "string")
+        return content;
+    const text = content.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("\n");
+    if (text.trim())
+        return text;
+    return content.some((part) => part.type === "image_url") ? "Image attachment" : "";
+}
+function buildTitleMessages(input) {
+    return [
+        { role: "system", content: TITLE_SYSTEM_PROMPT },
+        { role: "user", content: `Generate a title for this conversation:\n\n${input}` },
+    ];
+}
+function currentUserMessageCount(messages) {
+    return messages.filter((message) => message.role === "user").length;
+}
+function latestUserMessageEntryId(entries) {
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.type === "user_message")
+            return entry.id;
+    }
+    return undefined;
+}
+function isCandidateCurrent(entries, userMessageId) {
+    let clearIndex = -1;
+    let userIndex = -1;
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        if (entry.type === "marker" && entry.kind === "conversation_clear")
+            clearIndex = i;
+        if (entry.id === userMessageId)
+            userIndex = i;
+    }
+    return userIndex > clearIndex;
+}

package/dist/session-types.d.ts

@@ -0,0 +1,86 @@
+import type { AssistantMessage, Message, ThinkingLevel, ToolCall, ToolMessage, UserMessage } from "./types.js";
+import type { GoalState } from "./goal/store.js";
+import type { SanitizedProviderError } from "./provider-error-record.js";
+export interface ExternalRuntimeSessionMetadata {
+    /** External agent runtime that owns the conversational state. */
+    id: "grok";
+    /** Opaque ACP session identifier. Never contains credentials. */
+    sessionId?: string;
+    /** Server-selected model, when the runtime reports one. */
+    modelId?: string;
+    /** Reasoning effort selected for the external runtime. */
+    reasoningEffort?: ThinkingLevel;
+    /** Exact external runtime version used to create the session. */
+    version?: string;
+}
+export interface SessionMetadata {
+    model?: string;
+    thinkingLevel?: ThinkingLevel;
+    reasoningEffort?: ThinkingLevel;
+    cwd?: string;
+    title?: string;
+    titleSource?: "llm" | "manual";
+    titleUpdatedAt?: number;
+    titleUserMessageId?: string;
+    promptCacheKey?: string;
+    /** Persisted autonomous goal (see src/goal). Survives /session resume. */
+    goal?: GoalState;
+    /**
+     * External runtimes keep their own conversation state. Bubble persists only
+     * the opaque session binding and a UI transcript mirror; it never stores the
+     * runtime's OAuth credentials.
+     */
+    externalRuntime?: ExternalRuntimeSessionMetadata;
+}
+export type SessionMarkerKind = "model_switch" | "provider_switch" | "thinking_level_switch" | "skill_activated" | "mode_switch" | "runtime_switch" | "conversation_clear" | "task_started" | "task_finished" | "task_killed";
+interface BaseSessionLogEntry {
+    id: string;
+    timestamp: number;
+}
+export interface SessionMetadataEntry extends BaseSessionLogEntry {
+    type: "metadata";
+    metadata: SessionMetadata;
+}
+export interface SessionContextCheckpointEntry extends BaseSessionLogEntry {
+    type: "context_checkpoint";
+    checkpoint: import("./context/checkpoint.js").ContextCheckpoint;
+}
+export interface SessionSummaryEntry extends BaseSessionLogEntry {
+    type: "summary";
+    summary: string;
+}
+export interface SessionMarkerEntry extends BaseSessionLogEntry {
+    type: "marker";
+    kind: SessionMarkerKind;
+    value: string;
+}
+export interface SessionUserMessageEntry extends BaseSessionLogEntry {
+    type: "user_message";
+    message: UserMessage;
+}
+export interface SessionAssistantMessageEntry extends BaseSessionLogEntry {
+    type: "assistant_message";
+    message: Omit<AssistantMessage, "toolCalls">;
+}
+export interface SessionToolCallEntry extends BaseSessionLogEntry {
+    type: "tool_call";
+    toolCall: ToolCall;
+}
+export interface SessionToolResultEntry extends BaseSessionLogEntry {
+    type: "tool_result";
+    message: ToolMessage;
+}
+export interface SessionProviderErrorEntry extends BaseSessionLogEntry {
+    type: "provider_error";
+    error: SanitizedProviderError;
+}
+export type SessionLogEntry = SessionMetadataEntry | SessionSummaryEntry | SessionContextCheckpointEntry | SessionMarkerEntry | SessionUserMessageEntry | SessionAssistantMessageEntry | SessionToolCallEntry | SessionToolResultEntry | SessionProviderErrorEntry;
+export interface LegacySessionEntry {
+    id: string;
+    type: "metadata" | "message" | "compaction";
+    data?: Message;
+    summary?: string;
+    metadata?: SessionMetadata;
+    timestamp: number;
+}
+export {};

package/dist/session-types.js

@@ -0,0 +1 @@
+export {};