@beeuni/sdk 0.1.0 → 0.3.0

package/dist/browser/cache/idb-sync-cache.js

@@ -23,11 +23,21 @@ function openDB() {
     const pending = new Promise((resolve, reject) => {
         const request = idb.open(DB_NAME, DB_VERSION);
         request.onupgradeneeded = () => {
-            const db = request.result;
-            if (db.objectStoreNames.contains(RETIRED_STORE_NAME))
-                db.deleteObjectStore(RETIRED_STORE_NAME);
-            if (!db.objectStoreNames.contains(STORE_NAME))
-                db.createObjectStore(STORE_NAME);
+            try {
+                const db = request.result;
+                if (db.objectStoreNames.contains(RETIRED_STORE_NAME))
+                    db.deleteObjectStore(RETIRED_STORE_NAME);
+                if (!db.objectStoreNames.contains(STORE_NAME))
+                    db.createObjectStore(STORE_NAME);
+            }
+            catch (error) {
+                reject(error);
+                try {
+                    request.transaction?.abort();
+                }
+                catch {
+                }
+            }
         };
         request.onsuccess = () => {
             const db = request.result;

package/dist/browser/session-sync/server-transcript-mirror.d.ts

@@ -18,7 +18,6 @@ export declare function parseBeeuniSessionScope(scope: string | undefined): {
 } | null;
 export declare function loadSessionTranscriptMirror(input: {
     beeuniSessionScope: string | undefined;
-    limit?: number;
     signal?: AbortSignal;
     child?: string;
 }): Promise<SessionTranscriptSyncEnvelope | null>;
@@ -29,5 +28,12 @@ export declare function loadOlderSessionTranscriptMirror(input: {
     signal?: AbortSignal;
     child?: string;
 }): Promise<SessionTranscriptSyncEnvelope | null>;
+export declare function loadSavedSessionTranscriptMessages(scope: {
+    projectId: string;
+    sessionId: string;
+}, signal?: AbortSignal): Promise<Array<{
+    info: Message;
+    parts: Part[];
+}>>;
 export declare const SAVED_COPY_REFRESH_DELAY_MS = 3000;
 export declare function refreshSavedCopy(store: SavedCopyStore, projectId: string, sessionId: string): Promise<void>;

package/dist/browser/session-sync/server-transcript-mirror.js

@@ -1,5 +1,5 @@
 import { getSessionTranscriptSync, } from "../../core/rest/projects-client/sessions.js";
-import { claimOpenBundle, takeOpenBundleTranscript, takeOpenBundleTranscriptAbsence, } from "../../core/session/open-bundle.js";
+import { loadSavedTranscript } from "../../core/session-sync/saved-transcript.js";
 export const MIRROR_HYDRATE_LIMIT = 40;
 export function shouldHydrateFromMirror(input) {
     const { envelope, runtimeSessionId, hasMessages } = input;
@@ -52,31 +52,14 @@ export async function loadSessionTranscriptMirror(input) {
     const scope = parseBeeuniSessionScope(input.beeuniSessionScope);
     if (!scope)
         return null;
-    if (input.child) {
-        try {
-            return await getSessionTranscriptSync(scope.projectId, scope.sessionId, {
-                limit: input.limit ?? MIRROR_HYDRATE_LIMIT,
+    try {
+        return input.child
+            ? await getSessionTranscriptSync(scope.projectId, scope.sessionId, {
+                limit: MIRROR_HYDRATE_LIMIT,
                 signal: input.signal,
                 child: input.child,
-            });
-        }
-        catch {
-            return null;
-        }
-    }
-    const claimed = claimOpenBundle(scope.projectId, scope.sessionId);
-    if (claimed)
-        await claimed;
-    const stashed = takeOpenBundleTranscript(scope.projectId, scope.sessionId);
-    if (stashed)
-        return stashed;
-    if (takeOpenBundleTranscriptAbsence(scope.projectId, scope.sessionId))
-        return null;
-    try {
-        return await getSessionTranscriptSync(scope.projectId, scope.sessionId, {
-            limit: input.limit ?? MIRROR_HYDRATE_LIMIT,
-            signal: input.signal,
-        });
+            })
+            : await loadSavedTranscript(scope.projectId, scope.sessionId, { signal: input.signal });
     }
     catch {
         return null;
@@ -98,6 +81,29 @@ export async function loadOlderSessionTranscriptMirror(input) {
         return null;
     }
 }
+const SAVED_EXPORT_WINDOW = 500;
+export async function loadSavedSessionTranscriptMessages(scope, signal) {
+    const windows = [];
+    const seen = new Set();
+    let before = null;
+    do {
+        const envelope = await getSessionTranscriptSync(scope.projectId, scope.sessionId, {
+            limit: SAVED_EXPORT_WINDOW,
+            history: true,
+            before,
+            signal,
+        });
+        if (!envelope.available)
+            break;
+        windows.unshift(mirrorMessagesForHydrate(envelope));
+        before = envelope.next_cursor ?? null;
+        if (before !== null && seen.has(before))
+            break;
+        if (before !== null)
+            seen.add(before);
+    } while (before !== null);
+    return windows.flat();
+}
 export const SAVED_COPY_REFRESH_DELAY_MS = 3_000;
 export async function refreshSavedCopy(store, projectId, sessionId) {
     try {

package/dist/browser/session-sync/session-sync-registry.d.ts

@@ -1,5 +1,5 @@
 import type { Message, Part, SessionStatus } from '../../core/runtime/runtime-types.js';
-import { SessionSyncController, type SessionSyncPage, type SessionSyncReason } from '../../core/session-sync/session-sync-controller.js';
+import { SessionSyncController, type SessionSyncPage, type SessionSyncReason, type SessionSyncTelemetryEvent } from '../../core/session-sync/session-sync-controller.js';
 interface MessagesResponse {
     data?: Array<{
         info: Message;
@@ -28,6 +28,7 @@ export declare function readSessionMessagePage(client: SessionMessageClient, ses
     limit: number;
     before?: string;
 }, signal?: AbortSignal): Promise<SessionSyncPage>;
+export declare function reportTelemetry(sessionId: string, event: SessionSyncTelemetryEvent): void;
 export declare function getSessionSyncController(sessionId: string, client?: SessionMessageClient, runtimeScope?: string): SessionSyncController;
 export declare function prefetchSessionSyncOnce(sessionId: string, source: SessionPrefetchSource, client?: SessionMessageClient): Promise<boolean>;
 export declare function clearActiveSessionPrefetches(): void;
@@ -35,6 +36,7 @@ export declare function retainSessionSyncController(sessionId: string, runtimeSc
 export declare function reconcileSessionTail(sessionId: string, reason: SessionSyncReason, runtimeScope?: string): Promise<void>;
 export declare function loadSessionRuntimeStatus(sessionId: string, client?: SessionMessageClient): Promise<SessionStatus | null>;
 export declare function loadSessionTranscriptMessages(sessionId: string): Promise<SessionSyncPage['messages']>;
+export declare function loadSessionExportMessages(sessionId: string, beeuniSessionScope?: string): Promise<SessionSyncPage['messages']>;
 export declare function noteSessionSyncEvent(event: {
     type?: string;
     properties?: unknown;

package/dist/browser/session-sync/session-sync-registry.js

@@ -4,8 +4,10 @@ import { ApiError } from '../../core/http/api/errors.js';
 import { SessionSyncController, loadCompleteSessionHistory, } from '../../core/session-sync/session-sync-controller.js';
 import { getCurrentRuntimeSandboxId, getCurrentRuntimeUrl } from '../../core/session/current-runtime.js';
 import { useSyncStore } from '../stores/sync-store.js';
+import { loadSavedSessionTranscriptMessages, parseBeeuniSessionScope } from './server-transcript-mirror.js';
 export const ACTIVE_SESSION_PREFETCH_SOURCE = Symbol('active-session-prefetch');
 const MAX_CONTROLLERS = 20;
+const IDLE_BEFORE_EVICT_MS = 30_000;
 const controllers = new Map();
 function runtimeScopeKey(runtimeScope) {
     return runtimeScope ?? getCurrentRuntimeSandboxId() ?? 'none';
@@ -83,7 +85,14 @@ export async function readSessionMessagePage(client, sessionId, request, signal)
         nextCursor: result.response?.headers.get('x-next-cursor') || undefined,
     };
 }
-function reportTelemetry(sessionId, event) {
+export function reportTelemetry(sessionId, event) {
+    try {
+        if (!globalThis.localStorage?.getItem('beeuni:debug'))
+            return;
+    }
+    catch {
+        return;
+    }
     console.debug('[session-sync]', { sessionId, ...event });
 }
 function resolveClient(key) {
@@ -118,8 +127,11 @@ function createController(sessionId, key) {
 function evictInactiveControllers(protectedKey) {
     if (controllers.size <= MAX_CONTROLLERS)
         return;
+    const now = Date.now();
     const inactive = [...controllers.entries()]
-        .filter(([key, entry]) => entry.consumers === 0 && key !== protectedKey)
+        .filter(([key, entry]) => entry.consumers === 0 &&
+        key !== protectedKey &&
+        now - entry.lastUsedAt > IDLE_BEFORE_EVICT_MS)
         .sort((a, b) => a[1].lastUsedAt - b[1].lastUsedAt);
     for (const [key, entry] of inactive) {
         entry.controller.destroy();
@@ -128,6 +140,21 @@ function evictInactiveControllers(protectedKey) {
             return;
     }
 }
+let evictionTimer;
+function scheduleEviction(delayMs = IDLE_BEFORE_EVICT_MS + 1) {
+    if (evictionTimer !== undefined)
+        return;
+    evictionTimer = setTimeout(() => {
+        evictionTimer = undefined;
+        evictInactiveControllers();
+        if (controllers.size <= MAX_CONTROLLERS)
+            return;
+        const idleSince = Math.min(...[...controllers.values()].filter((entry) => entry.consumers === 0).map((entry) => entry.lastUsedAt));
+        if (Number.isFinite(idleSince))
+            scheduleEviction(Math.max(1, idleSince + IDLE_BEFORE_EVICT_MS + 1 - Date.now()));
+    }, delayMs);
+    evictionTimer.unref?.();
+}
 function getOrCreateRegistryEntry(sessionId, client, initialConsumers = 0, runtimeScope) {
     const key = controllerKey(sessionId, runtimeScope);
     const existing = controllers.get(key);
@@ -197,8 +224,10 @@ export function retainSessionSyncController(sessionId, runtimeScope) {
             return;
         current.consumers = Math.max(0, current.consumers - 1);
         current.lastUsedAt = Date.now();
-        if (current.consumers === 0)
+        if (current.consumers === 0) {
             controller.setBusy(false);
+            scheduleEviction();
+        }
         evictInactiveControllers();
     };
 }
@@ -217,6 +246,20 @@ export async function loadSessionRuntimeStatus(sessionId, client = getClient())
 export function loadSessionTranscriptMessages(sessionId) {
     return loadCompleteSessionHistory((request) => readSessionMessagePage(getClient(), sessionId, request));
 }
+export async function loadSessionExportMessages(sessionId, beeuniSessionScope) {
+    const saved = parseBeeuniSessionScope(beeuniSessionScope);
+    let live = [];
+    try {
+        live = await loadSessionTranscriptMessages(sessionId);
+    }
+    catch (error) {
+        if (!saved)
+            throw error;
+    }
+    if (live.length > 0 || !saved)
+        return live;
+    return loadSavedSessionTranscriptMessages(saved);
+}
 const TRANSCRIPT_EVENT_TYPES = new Set([
     'message.updated',
     'message.part.updated',
@@ -242,6 +285,8 @@ export function resetSessionSyncControllers() {
     for (const entry of controllers.values())
         entry.controller.destroy();
     controllers.clear();
+    clearTimeout(evictionTimer);
+    evictionTimer = undefined;
 }
 export function resetSessionSyncControllersForSession(sessionId, keepRuntimeScope) {
     for (const [key, entry] of controllers) {

package/dist/browser/stores/sync-store/keep-unchanged.d.ts

@@ -0,0 +1,4 @@
+export declare function sameValue(a: unknown, b: unknown): boolean;
+export declare function keepUnchanged<M extends {
+    id: string;
+}, P>(previous: readonly M[] | undefined, next: M[], previousParts: Record<string, P[] | undefined>, nextParts: Record<string, P[] | undefined>): M[];

package/dist/browser/stores/sync-store/keep-unchanged.js

@@ -0,0 +1,34 @@
+export function sameValue(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+        return false;
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
+            return false;
+        return a.every((value, index) => sameValue(value, b[index]));
+    }
+    const left = a;
+    const right = b;
+    const keys = Object.keys(left);
+    if (keys.length !== Object.keys(right).length)
+        return false;
+    return keys.every((key) => Object.hasOwn(right, key) && sameValue(left[key], right[key]));
+}
+export function keepUnchanged(previous, next, previousParts, nextParts) {
+    const byId = new Map((previous ?? []).map((message) => [message.id, message]));
+    const shared = next.map((message) => {
+        const old = byId.get(message.id);
+        return old && sameValue(old, message) ? old : message;
+    });
+    for (const message of shared) {
+        const before = previousParts[message.id];
+        const after = nextParts[message.id];
+        if (before && after && before !== after && sameValue(before, after))
+            nextParts[message.id] = before;
+    }
+    const unchanged = previous !== undefined &&
+        previous.length === shared.length &&
+        shared.every((message, index) => message === previous[index]);
+    return unchanged ? previous : shared;
+}

package/dist/browser/stores/sync-store.d.ts

@@ -1,4 +1,6 @@
 import type { Message, Event as RuntimeEvent, Part, SessionStatus, Todo } from "../../core/runtime/runtime-types.js";
+import type { SessionLogPage } from "../../core/session-log/source.js";
+import { type SessionLogEventInput, type SessionLogState } from "../../core/session-log/store.js";
 import { ascendingId } from "./sync-store/ascending-id.js";
 import { Binary } from "./sync-store/binary.js";
 import type { FileDiff, MessageError, MessageWithParts, SessionRewindState } from "./sync-store/types.js";
@@ -16,7 +18,11 @@ interface SyncState {
     todos: Record<string, Todo[]>;
     sessionRevert: Record<string, SessionRewindState | null>;
     sessionRevertNeedsTailReconcile: Record<string, boolean>;
+    sessionLogs: Record<string, SessionLogState>;
     applyEvent: (event: RuntimeEvent) => void;
+    applySessionLogPage: (sessionId: string, page: SessionLogPage) => void;
+    applySessionLogEvent: (sessionId: string, event: SessionLogEventInput) => void;
+    dropSessionLog: (sessionId: string) => void;
     upsertMessage: (sessionID: string, message: Message) => void;
     removeMessage: (sessionID: string, messageID: string) => void;
     upsertPart: (messageID: string, part: Part, sessionID?: string) => void;
@@ -62,4 +68,5 @@ interface SyncState {
     statuses: Record<string, SessionStatus>;
 }
 export declare function hasOnlyCacheSourcedMessages(sessionID: string): boolean;
+export declare function hasRuntimeConfirmedMessage(sessionID: string, messageID: string): boolean;
 export declare const useSyncStore: import("zustand").UseBoundStore<import("zustand").StoreApi<SyncState>>;

package/dist/browser/stores/sync-store.js

@@ -1,11 +1,13 @@
 "use client";
 import { create } from "zustand";
 import { commitSessionRewind, isWithinRewindWindow, stageSessionRewind, } from "../../core/session/rewind.js";
+import { EMPTY_SESSION_LOG_STATE, applySessionLogEvent, applySessionLogPage, } from "../../core/session-log/store.js";
 import { isRetryableTurnError } from "../../core/turns/open-turn.js";
 import { ascendingId } from "./sync-store/ascending-id.js";
 import { Binary } from "./sync-store/binary.js";
 import { DELTA_EVENT_TAIL_LIMIT } from "./sync-store/delta-event-window.js";
 import { reconcileHydratedParts } from "./sync-store/reconcile-parts.js";
+import { keepUnchanged } from "./sync-store/keep-unchanged.js";
 export { ascendingId, Binary };
 export function sameSessionStatus(a, b) {
     if (a === b)
@@ -81,6 +83,16 @@ export function hasOnlyCacheSourcedMessages(sessionID) {
         return false;
     return messages.every((message) => cached.has(message.id));
 }
+export function hasRuntimeConfirmedMessage(sessionID, messageID) {
+    const messages = useSyncStore.getState().messages[sessionID];
+    if (!messages)
+        return false;
+    let ids = messageIdSets.get(messages);
+    if (!ids)
+        messageIdSets.set(messages, (ids = new Set(messages.map((message) => message.id))));
+    return ids.has(messageID) && !cacheSourcedIds.get(sessionID)?.has(messageID);
+}
+const messageIdSets = new WeakMap();
 function recordOptimisticEcho(sessionID, optimisticID, echoID) {
     if (optimisticID === echoID)
         return;
@@ -138,6 +150,7 @@ function forgetSessionIds(sessionID) {
     deltaActiveParts.delete(sessionID);
     bridgedPartIds.delete(sessionID);
     deltaEventTails.delete(sessionID);
+    deltaOffsets.delete(sessionID);
     stubAssistantIds.delete(sessionID);
 }
 const isOptimistic = (sessionID, messageID) => hasTrackedId(optimisticIds, sessionID, messageID);
@@ -160,6 +173,15 @@ const awaitsUserEcho = (sessionID, messageID) => {
 const bridgedPartIds = new Map();
 const deltaActiveParts = new Map();
 const deltaEventTails = new Map();
+const deltaOffsets = new Map();
+function setDeltaOffset(sessionID, key, offset) {
+    let bucket = deltaOffsets.get(sessionID);
+    if (!bucket) {
+        bucket = new Map();
+        deltaOffsets.set(sessionID, bucket);
+    }
+    bucket.set(key, offset);
+}
 const stubAssistantIds = new Map();
 function trackStub(sessionID, stubId, parentId) {
     const bucket = stubAssistantIds.get(sessionID);
@@ -223,6 +245,7 @@ const DETACHED_SESSION_LIMIT = 8;
 const MESSAGE_ROWS_LIMIT = 20;
 const sessionMessageRows = new Map();
 const EMPTY_MESSAGE_ROWS = [];
+const rowsByMessages = new WeakMap();
 function touchSessionMessageRows(sessionID, entry) {
     sessionMessageRows.delete(sessionID);
     sessionMessageRows.set(sessionID, entry);
@@ -280,6 +303,41 @@ function pruneDetachedSessions(messages) {
     }
     return evicted;
 }
+function takeDeltaEventId(sessionID, tailKey, id) {
+    let sessionTails = deltaEventTails.get(sessionID);
+    if (!sessionTails) {
+        sessionTails = new Map();
+        deltaEventTails.set(sessionID, sessionTails);
+    }
+    let appliedIds = sessionTails.get(tailKey);
+    if (appliedIds?.has(id))
+        return false;
+    if (!appliedIds) {
+        appliedIds = new Set();
+        sessionTails.set(tailKey, appliedIds);
+    }
+    appliedIds.add(id);
+    if (appliedIds.size > DELTA_EVENT_TAIL_LIMIT) {
+        const oldest = appliedIds.values().next().value;
+        if (oldest !== undefined)
+            appliedIds.delete(oldest);
+    }
+    return true;
+}
+function applySessionLogFrame(sessionId, event) {
+    const state = useSyncStore.getState();
+    const current = state.sessionLogs[sessionId] ?? EMPTY_SESSION_LOG_STATE;
+    const next = applySessionLogEvent(current, event);
+    if (next === current)
+        return;
+    if (event.type === "log.block.delta") {
+        const p = event.properties;
+        if (event.id && !takeDeltaEventId(p.thread_id, `${p.message_id}:${p.block_id}:log`, event.id))
+            return;
+        state.noteSessionActivity(p.thread_id);
+    }
+    useSyncStore.setState((s) => ({ sessionLogs: { ...s.sessionLogs, [sessionId]: next } }));
+}
 function appendPartDeltas(sessionID, messageID, partID, field, pieces) {
     trackId(deltaActiveParts, sessionID, partID);
     let applied = false;
@@ -290,38 +348,38 @@ function appendPartDeltas(sessionID, messageID, partID, field, pieces) {
         const result = Binary.search(list, partID, (p) => p.id);
         if (!result.found)
             return s;
-        let delta = "";
+        const messages = s.messages[sessionID] ?? [];
+        let message;
+        for (let i = messages.length - 1; i >= 0 && !message; i--)
+            if (messages[i].id === messageID)
+                message = messages[i];
+        if (message?.role === "assistant" && message.time?.completed)
+            return s;
+        const existing = list[result.index][field] ?? "";
+        const offsetKey = `${messageID}:${partID}:${field}`;
+        let offset = deltaOffsets.get(sessionID)?.get(offsetKey) ?? existing.length;
+        let text = existing;
         for (const piece of pieces) {
-            if (piece.id) {
-                const tailKey = `${messageID}:${partID}:${field}`;
-                let sessionTails = deltaEventTails.get(sessionID);
-                if (!sessionTails) {
-                    sessionTails = new Map();
-                    deltaEventTails.set(sessionID, sessionTails);
-                }
-                let appliedIds = sessionTails.get(tailKey);
-                if (appliedIds?.has(piece.id))
-                    continue;
-                if (!appliedIds) {
-                    appliedIds = new Set();
-                    sessionTails.set(tailKey, appliedIds);
-                }
-                appliedIds.add(piece.id);
-                if (appliedIds.size > DELTA_EVENT_TAIL_LIMIT) {
-                    const oldest = appliedIds.values().next().value;
-                    if (oldest !== undefined)
-                        appliedIds.delete(oldest);
-                }
+            if (piece.id && !takeDeltaEventId(sessionID, offsetKey, piece.id)) {
+                if (offset < text.length && text.startsWith(piece.delta, offset))
+                    offset += piece.delta.length;
+                continue;
             }
-            delta += piece.delta;
+            if (offset < text.length && text.startsWith(piece.delta, offset)) {
+                offset += piece.delta.length;
+                continue;
+            }
+            const held = offset < text.length && piece.delta.startsWith(text.slice(offset)) ? text.length - offset : 0;
+            text += piece.delta.slice(held);
+            offset = text.length;
             applied = true;
         }
+        setDeltaOffset(sessionID, offsetKey, offset);
         if (!applied)
             return s;
         const next = [...list];
         const part = { ...next[result.index] };
-        const existing = part[field];
-        part[field] = (existing ?? "") + delta;
+        part[field] = text;
         next[result.index] = part;
         return { parts: { ...s.parts, [messageID]: next } };
     });
@@ -339,6 +397,7 @@ export const useSyncStore = create()((set, get) => ({
     todos: {},
     sessionRevert: {},
     sessionRevertNeedsTailReconcile: {},
+    sessionLogs: {},
     get statuses() {
         return get().sessionStatus;
     },
@@ -346,15 +405,15 @@ export const useSyncStore = create()((set, get) => ({
         const list = s.messages[sessionID] ?? [];
         const result = Binary.search(list, message.id, (m) => m.id);
         const bsValid = result.found && list[result.index]?.id === message.id;
-        if (bsValid) {
-            const next = [...list];
-            next[result.index] = message;
-            return { messages: { ...s.messages, [sessionID]: next } };
-        }
-        const linearIdx = list.findIndex((m) => m.id === message.id);
-        if (linearIdx !== -1) {
+        const index = bsValid ? result.index : list.findIndex((m) => m.id === message.id);
+        if (index !== -1) {
+            const previous = list[index];
+            const completed = previous.role === "assistant" ? previous.time?.completed : undefined;
+            const kept = completed && message.role === "assistant" && message.time && !message.time.completed
+                ? { ...message, time: { ...message.time, completed } }
+                : message;
             const next = [...list];
-            next[linearIdx] = message;
+            next[index] = kept;
             return { messages: { ...s.messages, [sessionID]: next } };
         }
         const next = [...list];
@@ -405,6 +464,9 @@ export const useSyncStore = create()((set, get) => ({
                 prevText.length > 0) {
                 const isPrefixGrowth = incomingText.startsWith(prevText);
                 if (!isPrefixGrowth) {
+                    if (partSessionID && prevText.startsWith(incomingText)) {
+                        setDeltaOffset(partSessionID, `${messageID}:${part.id}:text`, incomingText.length);
+                    }
                     if (!bridgeCleared)
                         return s;
                     const next = [...list];
@@ -413,9 +475,15 @@ export const useSyncStore = create()((set, get) => ({
                 }
             }
         }
+        const followStream = () => {
+            if (partSessionID && isTextLikePart(part)) {
+                setDeltaOffset(partSessionID, `${messageID}:${part.id}:text`, part.text.length);
+            }
+        };
         const next = [...list];
         if (result.found) {
             next[result.index] = part;
+            followStream();
         }
         else {
             if (hasTrackedId(deltaActiveParts, partSessionID, part.id) && isTextLikePart(part)) {
@@ -427,6 +495,7 @@ export const useSyncStore = create()((set, get) => ({
                 }
             }
             next.splice(result.index, 0, part);
+            followStream();
         }
         return { parts: { ...s.parts, [messageID]: next } };
     }),
@@ -729,7 +798,7 @@ export const useSyncStore = create()((set, get) => ({
     buildSessionMessages: (sessionID, msgs, parts) => {
         if (!msgs || msgs.length === 0)
             return EMPTY_MESSAGE_ROWS;
-        const cached = sessionMessageRows.get(sessionID);
+        const cached = rowsByMessages.get(msgs) ?? sessionMessageRows.get(sessionID);
         if (cached && cached.msgs === msgs) {
             let same = cached.partRefs.length === msgs.length;
             if (same) {
@@ -775,7 +844,9 @@ export const useSyncStore = create()((set, get) => ({
             }
             result.push(reuse ?? { info, parts: messageParts ?? [] });
         }
-        touchSessionMessageRows(sessionID, { msgs, partRefs, result });
+        const entry = { msgs, partRefs, result };
+        touchSessionMessageRows(sessionID, entry);
+        rowsByMessages.set(msgs, entry);
         return result;
     },
     hydrate: (sessionID, msgs, opts) => {
@@ -1008,8 +1079,9 @@ export const useSyncStore = create()((set, get) => ({
                 clearBridge: (id) => untrackId(bridgedPartIds, sessionID, id),
                 isDeltaActive: (id) => hasTrackedId(deltaActiveParts, sessionID, id),
             });
+            const kept = keepUnchanged(s.messages[sessionID], merged, s.parts, newParts);
             return {
-                messages: { ...s.messages, [sessionID]: merged },
+                messages: kept === s.messages[sessionID] ? s.messages : { ...s.messages, [sessionID]: kept },
                 parts: newParts,
             };
         });
@@ -1025,6 +1097,7 @@ export const useSyncStore = create()((set, get) => ({
         bridgedPartIds.clear();
         deltaActiveParts.clear();
         deltaEventTails.clear();
+        deltaOffsets.clear();
         stubAssistantIds.clear();
         sessionConsumers.clear();
         detachedSessions.clear();
@@ -1041,8 +1114,21 @@ export const useSyncStore = create()((set, get) => ({
             todos: {},
             sessionRevert: {},
             sessionRevertNeedsTailReconcile: {},
+            sessionLogs: {},
         });
     },
+    applySessionLogPage: (sessionId, page) => set((s) => {
+        const current = s.sessionLogs[sessionId] ?? EMPTY_SESSION_LOG_STATE;
+        const next = applySessionLogPage(current, { ...page, session: { session_id: sessionId, ...page.session } });
+        return next === current ? s : { sessionLogs: { ...s.sessionLogs, [sessionId]: next } };
+    }),
+    applySessionLogEvent: (sessionId, event) => applySessionLogFrame(sessionId, event),
+    dropSessionLog: (sessionId) => set((s) => {
+        if (!(sessionId in s.sessionLogs))
+            return s;
+        const { [sessionId]: _dropped, ...rest } = s.sessionLogs;
+        return { sessionLogs: rest };
+    }),
     hasOptimisticMessages: (sessionID) => {
         const list = get().messages[sessionID];
         if (!list || list.length === 0)
@@ -1252,6 +1338,7 @@ export const useSyncStore = create()((set, get) => ({
                 }
                 deltaActiveParts.delete(sid);
                 deltaEventTails.delete(sid);
+                deltaOffsets.delete(sid);
                 set((s) => {
                     const msgs = s.messages[sid] ?? [];
                     let userIdx = -1;

package/dist/core/attachments/prompt-attachments.d.ts

@@ -21,6 +21,10 @@ export interface PromptAttachmentControllerOptions {
 export interface PromptAttachmentController {
     add(file: File): string;
     addMany(files: readonly File[]): string[];
+    restore(uploads: readonly {
+        attachment: PromptAttachment;
+        file?: File;
+    }[]): (string | undefined)[];
     retry(id: string): void;
     remove(id: string): Promise<void>;
     abort(id: string): void;

package/dist/core/attachments/prompt-attachments.js

@@ -216,6 +216,39 @@ export function createPromptAttachmentController(projectId, options = {}) {
         pump();
         return ids;
     }
+    function restore(uploads) {
+        const valid = uploads.map(({ attachment, file }) => {
+            try {
+                return { attachment: completedMetadata(attachment), file };
+            }
+            catch {
+                return undefined;
+            }
+        });
+        validateSizes(valid.flatMap((upload) => (upload ? [upload.attachment.size] : [])));
+        const ids = valid.map((upload) => {
+            if (!upload)
+                return undefined;
+            const id = `attachment-${++lastAttachmentId}`;
+            const { attachment, file } = upload;
+            entries.set(id, {
+                generation: 0,
+                item: {
+                    id,
+                    ...(file ? { file } : {}),
+                    filename: attachment.filename,
+                    mime: attachment.mime,
+                    size: attachment.size,
+                    status: 'ready',
+                    receivedBytes: attachment.size,
+                    attachment,
+                },
+            });
+            return id;
+        });
+        emit();
+        return ids;
+    }
     function abort(id) {
         const entry = entries.get(id);
         if (!entry || entry.item.status === 'ready')
@@ -284,6 +317,7 @@ export function createPromptAttachmentController(projectId, options = {}) {
     return {
         add: (file) => addMany([file])[0],
         addMany,
+        restore,
         retry(id) {
             const entry = entries.get(id);
             if (!entry?.handedOff)