@agent-native/core 0.203.0-nightly-20261007064822 → 0.203.0

package/dist/agent/thread-data-builder.js

@@ -1165,11 +1165,8 @@ function snapshotEntryId(entry, kind) {
     if (!entry || typeof entry !== "object")
         return undefined;
     if (kind === "widget") {
-        const messageId = entry.messageId;
         const widgetId = entry.widget?.id;
-        return typeof messageId === "string" && typeof widgetId === "string"
-            ? JSON.stringify([messageId, widgetId])
-            : undefined;
+        return typeof widgetId === "string" ? widgetId : undefined;
     }
     return typeof entry.id === "string" ? entry.id : undefined;
 }
@@ -1384,6 +1381,9 @@ function latestSnapshotRun(runs) {
         return latestTime && runTime && runTime < latestTime ? latest : run;
     }, undefined);
 }
+function isTerminalRunStatus(status) {
+    return (status === "completed" || status === "failed" || status === "cancelled");
+}
 function latestStoredUser(repo) {
     return repo?.messages
         ?.map((entry) => getStoredMessage(entry))
@@ -1453,13 +1453,19 @@ export function foldThreadRunSuggestions(repo, run) {
         ? previous.runs
         : [];
     const oldRun = runs.find((entry) => entry.id === run.runId);
+    const previousSequence = oldRun &&
+        Number.isSafeInteger(oldRun.lastSequence) &&
+        oldRun.lastSequence >= 0
+        ? oldRun.lastSequence
+        : 0;
+    const lastSequence = run.events.reduce((maximum, { seq }) => Number.isSafeInteger(seq) && seq >= 0 ? Math.max(maximum, seq) : maximum, previousSequence);
     const snapshot = {
         ...oldRun,
         id: run.runId,
         threadId: run.threadId,
         status,
         startedAt,
-        lastSequence: oldRun?.lastSequence ?? 0,
+        lastSequence,
     };
     return {
         ...repo,
@@ -1471,17 +1477,600 @@ export function foldThreadRunSuggestions(repo, run) {
         },
     };
 }
-function mergeAgentKitHistory(existing, incoming, promptRunIds) {
-    if (!existing ||
-        typeof existing !== "object" ||
-        Array.isArray(existing) ||
-        !incoming ||
-        typeof incoming !== "object" ||
-        Array.isArray(incoming)) {
+function mergeAgentKitEvents(existing, incoming, replacedRunIds = new Set(), staleRunIds = new Set()) {
+    if (!Array.isArray(existing) && !Array.isArray(incoming))
+        return undefined;
+    const incomingEvents = Array.isArray(incoming)
+        ? incoming.filter((event) => typeof event?.runId !== "string" || !staleRunIds.has(event.runId))
+        : [];
+    const merged = Array.isArray(existing)
+        ? existing.filter((event) => typeof event?.runId !== "string" || !replacedRunIds.has(event.runId))
+        : [];
+    const positions = new Map();
+    merged.forEach((event, index) => {
+        if (typeof event?.id === "string" && !positions.has(event.id)) {
+            positions.set(event.id, index);
+        }
+    });
+    for (const event of incomingEvents) {
+        if (typeof event?.id !== "string") {
+            merged.push(event);
+            continue;
+        }
+        const index = positions.get(event.id);
+        if (index === undefined) {
+            positions.set(event.id, merged.length);
+            merged.push(event);
+        }
+        else {
+            merged[index] = event;
+        }
+    }
+    const positionsByRun = new Map();
+    merged.forEach((event, index) => {
+        if (typeof event?.runId !== "string")
+            return;
+        const runPositions = positionsByRun.get(event.runId) ?? [];
+        runPositions.push(index);
+        positionsByRun.set(event.runId, runPositions);
+    });
+    for (const runPositions of positionsByRun.values()) {
+        const runEvents = runPositions.map((index, order) => ({
+            event: merged[index],
+            index,
+            order,
+            sequence: typeof merged[index]?.sequence === "number" &&
+                Number.isFinite(merged[index].sequence)
+                ? merged[index].sequence
+                : Number.NaN,
+        }));
+        runEvents.sort((left, right) => {
+            if (Number.isFinite(left.sequence) &&
+                Number.isFinite(right.sequence) &&
+                left.sequence !== right.sequence) {
+                return left.sequence - right.sequence;
+            }
+            return left.order - right.order;
+        });
+        runPositions.forEach((index, order) => {
+            merged[index] = { ...runEvents[order].event, sequence: order + 1 };
+        });
+    }
+    return merged;
+}
+function mergeAgentKitFullEventSnapshot(existingEvents, incomingEvents, incomingRuns, committedSnapshots) {
+    if (!Array.isArray(incomingEvents))
+        return undefined;
+    const previousEvents = Array.isArray(existingEvents) ? existingEvents : [];
+    const incomingRunSequences = new Map();
+    for (const run of Array.isArray(incomingRuns) ? incomingRuns : []) {
+        if (typeof run?.id === "string" &&
+            typeof run.lastSequence === "number" &&
+            Number.isSafeInteger(run.lastSequence) &&
+            run.lastSequence >= 0) {
+            incomingRunSequences.set(run.id, run.lastSequence);
+        }
+    }
+    const existingEventsByRun = new Map();
+    for (const event of previousEvents) {
+        if (typeof event?.runId !== "string")
+            continue;
+        const events = existingEventsByRun.get(event.runId) ?? [];
+        events.push(event);
+        existingEventsByRun.set(event.runId, events);
+    }
+    const incomingEventsByRun = new Map();
+    for (const event of incomingEvents) {
+        if (typeof event?.runId !== "string")
+            continue;
+        const events = incomingEventsByRun.get(event.runId) ?? [];
+        events.push(event);
+        incomingEventsByRun.set(event.runId, events);
+    }
+    const protectedRunIds = new Set();
+    if (committedSnapshots &&
+        typeof committedSnapshots === "object" &&
+        !Array.isArray(committedSnapshots)) {
+        for (const [runId, value] of Object.entries(committedSnapshots)) {
+            if (!Array.isArray(value))
+                continue;
+            const committedSequence = value.reduce((maxSequence, entry) => {
+                const sequence = entry?.lastSequence;
+                return typeof sequence === "number" &&
+                    Number.isSafeInteger(sequence) &&
+                    sequence >= 0
+                    ? Math.max(maxSequence, sequence)
+                    : maxSequence;
+            }, -1);
+            if (committedSequence < 0)
+                continue;
+            const runEvents = incomingEventsByRun.get(runId) ?? [];
+            const incomingSequence = Math.max(incomingRunSequences.get(runId) ?? 0, ...runEvents.map((event) => {
+                const sequence = event && typeof event === "object"
+                    ? event.sequence
+                    : undefined;
+                return typeof sequence === "number" &&
+                    Number.isSafeInteger(sequence) &&
+                    sequence >= 0
+                    ? sequence
+                    : 0;
+            }));
+            if (runEvents.length === 0 || incomingSequence <= committedSequence) {
+                protectedRunIds.add(runId);
+            }
+        }
+    }
+    if (protectedRunIds.size === 0)
+        return incomingEvents;
+    const merged = [];
+    const insertedProtectedRuns = new Set();
+    for (const event of incomingEvents) {
+        const runId = event?.runId;
+        if (typeof runId === "string" && protectedRunIds.has(runId)) {
+            if (!insertedProtectedRuns.has(runId)) {
+                merged.push(...(existingEventsByRun.get(runId) ?? []));
+                insertedProtectedRuns.add(runId);
+            }
+            continue;
+        }
+        merged.push(event);
+    }
+    for (const runId of protectedRunIds) {
+        if (insertedProtectedRuns.has(runId))
+            continue;
+        merged.push(...(existingEventsByRun.get(runId) ?? []));
+    }
+    return merged;
+}
+const MAX_PENDING_EVENT_RUN_SNAPSHOTS_PER_RUN = 2;
+const MAX_COMMITTED_EVENT_RUN_SNAPSHOTS_PER_RUN = 8;
+function mergeAgentKitEventRunSnapshots(input) {
+    const incomingEvents = Array.isArray(input.incomingEvents)
+        ? input.incomingEvents
+        : [];
+    const batchedRunIds = new Set(input.batches.keys());
+    const unbatchedEvents = Array.isArray(input.incomingEvents)
+        ? incomingEvents.filter((event) => !batchedRunIds.has(event?.runId))
+        : undefined;
+    const previousEvents = Array.isArray(input.existingEvents)
+        ? input.existingEvents
+        : [];
+    const commits = {};
+    if (input.existingCommits &&
+        typeof input.existingCommits === "object" &&
+        !Array.isArray(input.existingCommits)) {
+        for (const [runId, value] of Object.entries(input.existingCommits)) {
+            if (!Array.isArray(value))
+                continue;
+            const entries = value.flatMap((candidate) => {
+                if (!candidate || typeof candidate !== "object")
+                    return [];
+                const commit = candidate;
+                if (typeof commit.snapshotId !== "string" ||
+                    typeof commit.lastSequence !== "number" ||
+                    !Number.isSafeInteger(commit.lastSequence) ||
+                    commit.lastSequence < 0 ||
+                    typeof commit.expectedEventCount !== "number" ||
+                    !Number.isSafeInteger(commit.expectedEventCount) ||
+                    commit.expectedEventCount < 1) {
+                    return [];
+                }
+                return [
+                    {
+                        snapshotId: commit.snapshotId,
+                        lastSequence: commit.lastSequence,
+                        expectedEventCount: commit.expectedEventCount,
+                    },
+                ];
+            });
+            if (entries.length > 0) {
+                commits[runId] = entries.slice(-MAX_COMMITTED_EVENT_RUN_SNAPSHOTS_PER_RUN);
+            }
+        }
+    }
+    const watermarks = new Map(input.existingWatermarks);
+    const replacedRunIds = new Set();
+    const staleRunIds = new Set();
+    for (const [runId, lastSequence] of input.incomingWatermarks) {
+        const storedWatermark = watermarks.get(runId);
+        const storedRunSequence = input.existingRunSequences.get(runId);
+        const hasCommittedSnapshot = (commits[runId]?.length ?? 0) > 0;
+        const committedSequence = Math.max(0, ...(commits[runId] ?? []).map((entry) => entry.lastSequence));
+        const knownSequence = Math.max(storedWatermark ?? 0, storedRunSequence ?? 0, committedSequence);
+        const hasKnownSequence = storedWatermark !== undefined ||
+            storedRunSequence !== undefined ||
+            hasCommittedSnapshot;
+        const hasStoredEvents = previousEvents.some((event) => event?.runId === runId);
+        if ((hasKnownSequence && lastSequence < knownSequence) ||
+            (hasCommittedSnapshot && lastSequence <= committedSequence)) {
+            staleRunIds.add(runId);
+            continue;
+        }
+        if (input.incomingReplacements.has(runId) &&
+            (hasKnownSequence || !hasStoredEvents)) {
+            replacedRunIds.add(runId);
+        }
+        watermarks.set(runId, Math.max(knownSequence, lastSequence));
+    }
+    let events = mergeAgentKitEvents(input.existingEvents, unbatchedEvents, replacedRunIds, staleRunIds);
+    const pending = {};
+    if (input.existingPending &&
+        typeof input.existingPending === "object" &&
+        !Array.isArray(input.existingPending)) {
+        for (const [runId, value] of Object.entries(input.existingPending)) {
+            if (!value || typeof value !== "object" || Array.isArray(value)) {
+                continue;
+            }
+            const batches = {};
+            for (const [snapshotId, candidate] of Object.entries(value)) {
+                if (!candidate || typeof candidate !== "object")
+                    continue;
+                const candidateRecord = candidate;
+                if (Array.isArray(candidate) ||
+                    typeof candidateRecord.lastSequence !== "number" ||
+                    !Number.isSafeInteger(candidateRecord.lastSequence) ||
+                    candidateRecord.lastSequence < 0 ||
+                    typeof candidateRecord.expectedEventCount !== "number" ||
+                    !Number.isSafeInteger(candidateRecord.expectedEventCount) ||
+                    candidateRecord.expectedEventCount < 1 ||
+                    !Array.isArray(candidateRecord.events)) {
+                    continue;
+                }
+                batches[snapshotId] = {
+                    lastSequence: candidateRecord.lastSequence,
+                    expectedEventCount: candidateRecord.expectedEventCount,
+                    events: candidateRecord.events.filter((event) => event?.runId === runId),
+                };
+            }
+            if (Object.keys(batches).length > 0)
+                pending[runId] = batches;
+        }
+    }
+    for (const [runId, batches] of Object.entries(pending)) {
+        const committedSequence = Math.max(watermarks.get(runId) ?? 0, input.existingRunSequences.get(runId) ?? 0);
+        if (!watermarks.has(runId) && !input.existingRunSequences.has(runId)) {
+            continue;
+        }
+        for (const [snapshotId, batch] of Object.entries(batches)) {
+            const supersededByLegacySnapshot = (input.incomingWatermarks.get(runId) ?? -1) >= batch.lastSequence;
+            if (batch.lastSequence < committedSequence ||
+                supersededByLegacySnapshot) {
+                delete batches[snapshotId];
+            }
+        }
+        if (Object.keys(batches).length === 0)
+            delete pending[runId];
+    }
+    for (const [runId, batch] of input.batches) {
+        const committed = commits[runId]?.find((entry) => entry.snapshotId === batch.snapshotId);
+        if (committed) {
+            if (committed.lastSequence !== batch.lastSequence ||
+                committed.expectedEventCount !== batch.expectedEventCount) {
+                throw new TypeError("Agent chat event snapshot id was reused.");
+            }
+            continue;
+        }
+        const knownSequence = Math.max(watermarks.get(runId) ?? 0, input.existingRunSequences.get(runId) ?? 0);
+        const hasKnownSequence = watermarks.has(runId) || input.existingRunSequences.has(runId);
+        const alreadyCommittedAtOrAfter = (commits[runId] ?? []).some((entry) => entry.lastSequence >= batch.lastSequence);
+        if (hasKnownSequence &&
+            (batch.lastSequence < knownSequence || alreadyCommittedAtOrAfter)) {
+            if (pending[runId]) {
+                delete pending[runId][batch.snapshotId];
+                if (Object.keys(pending[runId]).length === 0)
+                    delete pending[runId];
+            }
+            continue;
+        }
+        const current = pending[runId]?.[batch.snapshotId];
+        const matchingCurrent = current?.lastSequence === batch.lastSequence &&
+            current.expectedEventCount === batch.expectedEventCount;
+        const batchEvents = incomingEvents.filter((event) => event?.runId === runId);
+        const stagedEvents = mergeAgentKitEvents(matchingCurrent ? current.events : [], batchEvents) ??
+            [];
+        if (stagedEvents.length > batch.expectedEventCount) {
+            throw new TypeError("Agent chat event snapshot exceeded its event count.");
+        }
+        if (batch.complete && stagedEvents.length < batch.expectedEventCount) {
+            throw new TypeError("Agent chat event snapshot ended before all events arrived.");
+        }
+        if (stagedEvents.length === batch.expectedEventCount) {
+            events = mergeAgentKitEvents(events, stagedEvents, new Set([runId]));
+            watermarks.set(runId, Math.max(knownSequence, batch.lastSequence));
+            commits[runId] = [
+                ...(commits[runId] ?? []).filter((entry) => entry.snapshotId !== batch.snapshotId),
+                {
+                    snapshotId: batch.snapshotId,
+                    lastSequence: batch.lastSequence,
+                    expectedEventCount: batch.expectedEventCount,
+                },
+            ].slice(-MAX_COMMITTED_EVENT_RUN_SNAPSHOTS_PER_RUN);
+            if (pending[runId]) {
+                for (const [snapshotId, pendingBatch] of Object.entries(pending[runId])) {
+                    if (pendingBatch.lastSequence <= batch.lastSequence) {
+                        delete pending[runId][snapshotId];
+                    }
+                }
+                if (Object.keys(pending[runId]).length === 0)
+                    delete pending[runId];
+            }
+            continue;
+        }
+        const runPending = { ...(pending[runId] ?? {}) };
+        if (!matchingCurrent) {
+            while (Object.keys(runPending).length >=
+                MAX_PENDING_EVENT_RUN_SNAPSHOTS_PER_RUN) {
+                const oldestSnapshotId = Object.keys(runPending)[0];
+                if (oldestSnapshotId === undefined)
+                    break;
+                delete runPending[oldestSnapshotId];
+            }
+        }
+        runPending[batch.snapshotId] = {
+            lastSequence: batch.lastSequence,
+            expectedEventCount: batch.expectedEventCount,
+            events: stagedEvents,
+        };
+        pending[runId] = runPending;
+    }
+    return { events, watermarks, pending, commits };
+}
+function mergeAgentKitAnnotations(existing, incoming, replaceMessageIds, removalValuesByMessage, conditionalUpserts, onConflict) {
+    if (!Array.isArray(existing) && !Array.isArray(incoming))
+        return undefined;
+    const annotationKey = (entry) => {
+        const id = entry?.annotation?.id;
+        return typeof id === "string"
+            ? JSON.stringify(["id", id])
+            : JSON.stringify(["value", entry]);
+    };
+    const merged = (Array.isArray(existing) ? existing : []).filter((entry) => {
+        const messageId = entry?.messageId;
+        if (replaceMessageIds.has(messageId))
+            return false;
+        const removalValues = removalValuesByMessage.get(messageId);
+        const baseline = removalValues?.get(annotationKey(entry));
+        if (baseline === undefined)
+            return true;
+        if (JSON.stringify(entry) === baseline)
+            return false;
+        if (typeof messageId === "string") {
+            const annotationId = entry?.annotation?.id;
+            onConflict?.({
+                messageId,
+                ...(typeof annotationId === "string" ? { annotationId } : {}),
+                operation: "remove",
+            });
+        }
+        return true;
+    });
+    const positions = new Map();
+    merged.forEach((entry, index) => {
+        if (typeof entry?.messageId !== "string")
+            return;
+        const key = JSON.stringify([entry.messageId, annotationKey(entry)]);
+        if (!positions.has(key))
+            positions.set(key, index);
+    });
+    if (Array.isArray(conditionalUpserts)) {
+        for (const update of conditionalUpserts) {
+            if (!update ||
+                typeof update !== "object" ||
+                !update.entry ||
+                typeof update.entry !== "object" ||
+                Array.isArray(update.entry) ||
+                (update.baseline !== null &&
+                    (!update.baseline ||
+                        typeof update.baseline !== "object" ||
+                        Array.isArray(update.baseline)))) {
+                continue;
+            }
+            const entry = update.entry;
+            if (typeof entry.messageId !== "string") {
+                merged.push(entry);
+                continue;
+            }
+            const key = JSON.stringify([entry.messageId, annotationKey(entry)]);
+            const index = positions.get(key);
+            if (index === undefined) {
+                if (update.baseline === null) {
+                    positions.set(key, merged.length);
+                    merged.push(entry);
+                }
+                else {
+                    const annotationId = entry.annotation?.id;
+                    onConflict?.({
+                        messageId: entry.messageId,
+                        ...(typeof annotationId === "string" ? { annotationId } : {}),
+                        operation: "upsert",
+                    });
+                }
+                continue;
+            }
+            if (JSON.stringify(merged[index]) === JSON.stringify(entry))
+                continue;
+            if (update.baseline !== null &&
+                JSON.stringify(merged[index]) === JSON.stringify(update.baseline)) {
+                merged[index] = entry;
+            }
+            else {
+                const annotationId = entry.annotation?.id;
+                onConflict?.({
+                    messageId: entry.messageId,
+                    ...(typeof annotationId === "string" ? { annotationId } : {}),
+                    operation: "upsert",
+                });
+            }
+        }
+    }
+    else
+        for (const entry of Array.isArray(incoming) ? incoming : []) {
+            if (typeof entry?.messageId !== "string") {
+                merged.push(entry);
+                continue;
+            }
+            const key = JSON.stringify([entry.messageId, annotationKey(entry)]);
+            const index = positions.get(key);
+            if (index === undefined) {
+                positions.set(key, merged.length);
+                merged.push(entry);
+            }
+            else {
+                merged[index] = entry;
+            }
+        }
+    return merged;
+}
+function mergeAgentKitHistory(existing, incoming, promptRunIds, onAnnotationConflict) {
+    const incomingIsRecord = incoming !== null &&
+        typeof incoming === "object" &&
+        !Array.isArray(incoming);
+    if (!incomingIsRecord)
         return incoming ?? existing;
+    const next = incoming;
+    const existingIsRecord = existing !== null &&
+        typeof existing === "object" &&
+        !Array.isArray(existing);
+    const snapshotDelta = next._snapshotDelta === true;
+    const incomingEventRunIds = new Set((Array.isArray(next.events) ? next.events : []).flatMap((event) => typeof event?.runId === "string" ? [event.runId] : []));
+    const incomingRunStarts = new Set((Array.isArray(next.events) ? next.events : []).flatMap((event) => typeof event?.runId === "string" && event.sequence === 1
+        ? [event.runId]
+        : []));
+    const eventRunSnapshotBatches = new Map();
+    for (const batch of Array.isArray(next.eventRunSnapshotBatches)
+        ? next.eventRunSnapshotBatches
+        : []) {
+        if (typeof batch?.runId === "string" &&
+            typeof batch.snapshotId === "string" &&
+            batch.snapshotId.length > 0 &&
+            typeof batch.lastSequence === "number" &&
+            Number.isSafeInteger(batch.lastSequence) &&
+            batch.lastSequence >= 0 &&
+            typeof batch.expectedEventCount === "number" &&
+            Number.isSafeInteger(batch.expectedEventCount) &&
+            batch.expectedEventCount > 0 &&
+            typeof batch.complete === "boolean" &&
+            incomingEventRunIds.has(batch.runId)) {
+            eventRunSnapshotBatches.set(batch.runId, {
+                runId: batch.runId,
+                snapshotId: batch.snapshotId,
+                lastSequence: batch.lastSequence,
+                expectedEventCount: batch.expectedEventCount,
+                complete: batch.complete,
+            });
+        }
+    }
+    const eventRunSnapshotWatermarks = new Map();
+    for (const watermark of Array.isArray(next.eventRunSnapshotWatermarks)
+        ? next.eventRunSnapshotWatermarks
+        : []) {
+        if (typeof watermark?.runId === "string" &&
+            typeof watermark.lastSequence === "number" &&
+            Number.isSafeInteger(watermark.lastSequence) &&
+            watermark.lastSequence >= 0 &&
+            incomingEventRunIds.has(watermark.runId) &&
+            !eventRunSnapshotBatches.has(watermark.runId)) {
+            eventRunSnapshotWatermarks.set(watermark.runId, Math.max(eventRunSnapshotWatermarks.get(watermark.runId) ?? 0, watermark.lastSequence));
+        }
+    }
+    const eventRunReplacements = new Map();
+    for (const replacement of Array.isArray(next.eventRunReplacements)
+        ? next.eventRunReplacements
+        : []) {
+        if (typeof replacement?.runId === "string" &&
+            typeof replacement.lastSequence === "number" &&
+            Number.isSafeInteger(replacement.lastSequence) &&
+            replacement.lastSequence >= 1 &&
+            incomingRunStarts.has(replacement.runId) &&
+            !eventRunSnapshotBatches.has(replacement.runId)) {
+            eventRunReplacements.set(replacement.runId, Math.max(eventRunReplacements.get(replacement.runId) ?? 0, replacement.lastSequence));
+        }
+    }
+    for (const [runId, lastSequence] of eventRunReplacements) {
+        eventRunSnapshotWatermarks.set(runId, Math.max(eventRunSnapshotWatermarks.get(runId) ?? 0, lastSequence));
+    }
+    const annotationMessageIdsToReplace = new Set();
+    const annotationRemovalValuesByMessage = new Map();
+    for (const replacement of Array.isArray(next.annotationMessageIdsToReplace)
+        ? next.annotationMessageIdsToReplace
+        : []) {
+        if (typeof replacement === "string") {
+            annotationMessageIdsToReplace.add(replacement);
+            continue;
+        }
+        if (!replacement ||
+            typeof replacement !== "object" ||
+            typeof replacement.messageId !== "string" ||
+            !Array.isArray(replacement.annotationsToRemove)) {
+            continue;
+        }
+        const removalValues = new Map();
+        for (const removal of replacement.annotationsToRemove) {
+            if (!removal ||
+                typeof removal !== "object" ||
+                typeof removal.key !== "string" ||
+                !removal.baseline ||
+                typeof removal.baseline !== "object" ||
+                Array.isArray(removal.baseline)) {
+                continue;
+            }
+            const baseline = JSON.stringify(removal.baseline);
+            if (typeof baseline === "string") {
+                removalValues.set(removal.key, baseline);
+            }
+        }
+        if (removalValues.size > 0) {
+            annotationRemovalValuesByMessage.set(replacement.messageId, removalValues);
+        }
+    }
+    if (!existingIsRecord) {
+        const initial = { ...next };
+        delete initial._eventRunWatermarks;
+        if (snapshotDelta) {
+            if (Array.isArray(initial.messages) && initial.messages.length === 0) {
+                delete initial.messages;
+            }
+            const eventSnapshot = mergeAgentKitEventRunSnapshots({
+                existingEvents: undefined,
+                incomingEvents: next.events,
+                existingWatermarks: new Map(),
+                existingRunSequences: new Map(),
+                incomingWatermarks: eventRunSnapshotWatermarks,
+                incomingReplacements: eventRunReplacements,
+                batches: eventRunSnapshotBatches,
+                existingPending: undefined,
+                existingCommits: undefined,
+            });
+            if (eventSnapshot.events)
+                initial.events = eventSnapshot.events;
+            if (eventSnapshot.watermarks.size > 0) {
+                initial._eventRunWatermarks = Object.fromEntries(eventSnapshot.watermarks);
+            }
+            if (Object.keys(eventSnapshot.pending).length > 0) {
+                initial._pendingEventRunSnapshots = eventSnapshot.pending;
+            }
+            else {
+                delete initial._pendingEventRunSnapshots;
+            }
+            if (Object.keys(eventSnapshot.commits).length > 0) {
+                initial._eventRunSnapshotCommits = eventSnapshot.commits;
+            }
+            else {
+                delete initial._eventRunSnapshotCommits;
+            }
+            const annotations = mergeAgentKitAnnotations(undefined, next.annotations, annotationMessageIdsToReplace, annotationRemovalValuesByMessage, next.annotationUpserts, onAnnotationConflict);
+            if (annotations)
+                initial.annotations = annotations;
+        }
+        delete initial._snapshotDelta;
+        delete initial.eventRunReplacements;
+        delete initial.eventRunSnapshotWatermarks;
+        delete initial.eventRunSnapshotBatches;
+        delete initial.annotationMessageIdsToReplace;
+        delete initial.annotationUpserts;
+        return initial;
     }
     const previous = existing;
-    const next = incoming;
     const merged = { ...previous, ...next };
     const runs = new Map();
     for (const run of [
@@ -1496,29 +2085,76 @@ function mergeAgentKitHistory(existing, incoming, promptRunIds) {
             continue;
         }
         const richer = newer.lastSequence >= run.lastSequence ? newer : run;
+        const statusRun = run.lastSequence > newer.lastSequence
+            ? run
+            : newer.lastSequence > run.lastSequence
+                ? newer
+                : isTerminalRunStatus(run.status)
+                    ? run
+                    : newer;
         runs.set(run.id, {
             ...run,
             ...newer,
             ...richer,
             metadata: { ...run.metadata, ...newer.metadata, ...richer.metadata },
             lastSequence: Math.max(newer.lastSequence, run.lastSequence),
-            status: ["completed", "failed", "cancelled"].includes(run.status)
-                ? run.status
-                : newer.status,
+            status: statusRun.status,
         });
     }
     if (runs.size > 0) {
         merged.runs = [...runs.values()];
         const latest = latestSnapshotRun(merged.runs);
+        const incomingLatest = latestSnapshotRun(next.runs);
         const previousLatest = latestSnapshotRun(previous.runs);
-        merged.suggestions =
-            latest?.status !== "completed"
-                ? []
-                : latest.id === previousLatest?.id &&
-                    previousLatest.status === "completed" &&
-                    Array.isArray(previous.suggestions)
-                    ? previous.suggestions
-                    : next.suggestions;
+        const incomingLatestCompleted = incomingLatest?.status === "completed";
+        const incomingLatestIsMergedLatest = incomingLatest?.id === latest?.id && incomingLatestCompleted;
+        const newLatestRunCompletion = incomingLatestIsMergedLatest && latest?.id !== previousLatest?.id;
+        const latestRunJustCompleted = incomingLatestIsMergedLatest &&
+            incomingLatest !== undefined &&
+            latest !== undefined &&
+            previousLatest !== undefined &&
+            previousLatest.id === latest.id &&
+            previousLatest.status !== "completed" &&
+            Number.isSafeInteger(incomingLatest.lastSequence) &&
+            incomingLatest.lastSequence >= 0 &&
+            Number.isSafeInteger(previousLatest.lastSequence) &&
+            previousLatest.lastSequence >= 0 &&
+            incomingLatest.lastSequence >= previousLatest.lastSequence;
+        const sameCompletedRunAdvanced = incomingLatestIsMergedLatest &&
+            incomingLatest !== undefined &&
+            latest !== undefined &&
+            previousLatest !== undefined &&
+            incomingLatest.id === latest.id &&
+            previousLatest.id === latest.id &&
+            previousLatest.status === "completed" &&
+            Number.isSafeInteger(incomingLatest.lastSequence) &&
+            incomingLatest.lastSequence >= 0 &&
+            Number.isSafeInteger(previousLatest.lastSequence) &&
+            previousLatest.lastSequence >= 0 &&
+            incomingLatest.lastSequence > previousLatest.lastSequence;
+        const incomingSuggestionsAreCurrent = Object.prototype.hasOwnProperty.call(next, "suggestions") &&
+            (newLatestRunCompletion ||
+                latestRunJustCompleted ||
+                sameCompletedRunAdvanced);
+        if (latest?.status !== "completed") {
+            merged.suggestions = [];
+        }
+        else if (incomingSuggestionsAreCurrent) {
+            merged.suggestions = next.suggestions;
+        }
+        else if (previousLatest !== undefined &&
+            latest.id === previousLatest.id &&
+            previousLatest.status === "completed") {
+            if (Object.prototype.hasOwnProperty.call(previous, "suggestions")) {
+                merged.suggestions = previous.suggestions;
+            }
+            else {
+                delete merged.suggestions;
+            }
+        }
+        else {
+            merged.suggestions = [];
+        }
         if (Array.isArray(merged.suggestions)) {
             merged.suggestions = merged.suggestions.filter((suggestion) => suggestion?.runId === latest?.id);
         }
@@ -1537,6 +2173,92 @@ function mergeAgentKitHistory(existing, incoming, promptRunIds) {
         if (entries)
             merged[key] = entries;
     }
+    if (snapshotDelta &&
+        Array.isArray(next.messages) &&
+        next.messages.length === 0 &&
+        !Array.isArray(previous.messages)) {
+        delete merged.messages;
+    }
+    if (snapshotDelta) {
+        const previousWatermarks = new Map();
+        const previousWatermarkRecord = previous._eventRunWatermarks;
+        if (previousWatermarkRecord &&
+            typeof previousWatermarkRecord === "object" &&
+            !Array.isArray(previousWatermarkRecord)) {
+            for (const [runId, value] of Object.entries(previousWatermarkRecord)) {
+                if (typeof value === "number" &&
+                    Number.isSafeInteger(value) &&
+                    value >= 0) {
+                    previousWatermarks.set(runId, value);
+                }
+            }
+        }
+        const previousRunSequences = new Map();
+        for (const run of Array.isArray(previous.runs) ? previous.runs : []) {
+            if (typeof run?.id === "string" &&
+                typeof run.lastSequence === "number" &&
+                Number.isSafeInteger(run.lastSequence) &&
+                run.lastSequence >= 0) {
+                previousRunSequences.set(run.id, run.lastSequence);
+            }
+        }
+        const eventSnapshot = mergeAgentKitEventRunSnapshots({
+            existingEvents: previous.events,
+            incomingEvents: next.events,
+            existingWatermarks: previousWatermarks,
+            existingRunSequences: previousRunSequences,
+            incomingWatermarks: eventRunSnapshotWatermarks,
+            incomingReplacements: eventRunReplacements,
+            batches: eventRunSnapshotBatches,
+            existingPending: previous._pendingEventRunSnapshots,
+            existingCommits: previous._eventRunSnapshotCommits,
+        });
+        if (eventSnapshot.events)
+            merged.events = eventSnapshot.events;
+        delete merged._eventRunWatermarks;
+        if (eventSnapshot.watermarks.size > 0) {
+            merged._eventRunWatermarks = Object.fromEntries(eventSnapshot.watermarks);
+        }
+        if (Object.keys(eventSnapshot.pending).length > 0) {
+            merged._pendingEventRunSnapshots = eventSnapshot.pending;
+        }
+        else {
+            delete merged._pendingEventRunSnapshots;
+        }
+        if (Object.keys(eventSnapshot.commits).length > 0) {
+            merged._eventRunSnapshotCommits = eventSnapshot.commits;
+        }
+        else {
+            delete merged._eventRunSnapshotCommits;
+        }
+    }
+    else {
+        const events = mergeAgentKitFullEventSnapshot(previous.events, next.events, next.runs, previous._eventRunSnapshotCommits);
+        if (events)
+            merged.events = events;
+        if (previous._eventRunWatermarks === undefined) {
+            delete merged._eventRunWatermarks;
+        }
+        else {
+            merged._eventRunWatermarks = previous._eventRunWatermarks;
+        }
+    }
+    delete merged._snapshotDelta;
+    delete merged.eventRunReplacements;
+    delete merged.eventRunSnapshotWatermarks;
+    delete merged.eventRunSnapshotBatches;
+    if (snapshotDelta ||
+        annotationMessageIdsToReplace.size > 0 ||
+        annotationRemovalValuesByMessage.size > 0) {
+        const annotations = mergeAgentKitAnnotations(previous.annotations, next.annotations, annotationMessageIdsToReplace, annotationRemovalValuesByMessage, next.annotationUpserts, onAnnotationConflict);
+        if (annotations)
+            merged.annotations = annotations;
+    }
+    else if (Array.isArray(next.annotations)) {
+        merged.annotations = next.annotations;
+    }
+    delete merged.annotationMessageIdsToReplace;
+    delete merged.annotationUpserts;
     return merged;
 }
 function pruneClaimedQueuedMessages(repo) {
@@ -1579,7 +2301,7 @@ export function mergeThreadDataForClientSave(existingRepo, incomingRepo, options
     }
     const promptRunIds = submittedPromptRunIds(existingNormalized?.messages, incomingNormalized?.messages);
     if (merged.agentKit !== undefined) {
-        merged.agentKit = mergeAgentKitHistory(existingNormalized?.agentKit, merged.agentKit, promptRunIds);
+        merged.agentKit = mergeAgentKitHistory(existingNormalized?.agentKit, merged.agentKit, promptRunIds, options.onAnnotationConflict);
     }
     const existingMessages = Array.isArray(existingNormalized?.messages)
         ? existingNormalized.messages