@agent-native/core 0.207.0 → 0.207.1-nightly-20261012011809

package/dist/agent/thread-data-builder.d.ts

@@ -105,6 +105,7 @@ export interface MergeThreadDataOptions {
     preserveExistingQueuedMessages?: boolean;
     preserveExistingTopLevelKeys?: boolean;
     onAnnotationConflict?: (conflict: ThreadAnnotationSnapshotConflict) => void;
+    trustedRunSequenceResetIds?: ReadonlySet<string>;
 }
 export interface ThreadAnnotationSnapshotConflict {
     messageId: string;

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

@@ -1582,13 +1582,18 @@ 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;
-    // Runtime event sequence numbers and AgentKit protocol cursors are separate.
-    const lastSequence = previousSequence;
+    const committedSnapshots = previous._eventRunSnapshotCommits?.[run.runId];
+    const protocolSequences = [
+        previous._eventRunWatermarks?.[run.runId],
+        ...(Array.isArray(committedSnapshots)
+            ? committedSnapshots.map((snapshot) => snapshot?.lastSequence)
+            : []),
+    ];
+    const lastSequence = protocolSequences.reduce((maximum, sequence) => typeof sequence === "number" &&
+        Number.isSafeInteger(sequence) &&
+        sequence >= 0
+        ? Math.max(maximum, sequence)
+        : maximum, 0);
     const snapshot = {
         ...oldRun,
         id: run.runId,
@@ -1653,6 +1658,7 @@ function mergeAgentKitEvents(existing, incoming, replacedRunIds = new Set(), sta
                 Number.isFinite(merged[index].sequence)
                 ? merged[index].sequence
                 : Number.NaN,
+            sequenceEnd: getAgentKitEventSequenceEnd(merged[index]),
         }));
         runEvents.sort((left, right) => {
             if (Number.isFinite(left.sequence) &&
@@ -1662,12 +1668,142 @@ function mergeAgentKitEvents(existing, incoming, replacedRunIds = new Set(), sta
             }
             return left.order - right.order;
         });
-        runPositions.forEach((index, order) => {
-            merged[index] = { ...runEvents[order].event, sequence: order + 1 };
-        });
+        let nextSequence = 1;
+        for (const [order, { event, sequenceEnd, sequence },] of runEvents.entries()) {
+            const index = runPositions[order];
+            if (index === undefined)
+                continue;
+            const span = Number.isSafeInteger(sequenceEnd) &&
+                Number.isSafeInteger(sequence) &&
+                sequenceEnd >= sequence
+                ? sequenceEnd - sequence + 1
+                : 1;
+            if (event?.type === "x-agent-native.persisted-event-omission-range") {
+                const payload = event.payload &&
+                    typeof event.payload === "object" &&
+                    !Array.isArray(event.payload)
+                    ? event.payload
+                    : {};
+                merged[index] = {
+                    ...event,
+                    sequence: nextSequence,
+                    payload: {
+                        ...payload,
+                        lastSequence: nextSequence + span - 1,
+                    },
+                };
+            }
+            else {
+                merged[index] = { ...event, sequence: nextSequence };
+            }
+            nextSequence += span;
+        }
     }
     return merged;
 }
+function mergeAgentKitEventSnapshotBatch(existing, incoming) {
+    const merged = Array.isArray(existing) ? [...existing] : [];
+    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 Array.isArray(incoming) ? incoming : []) {
+        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;
+        }
+    }
+    return merged
+        .map((event, order) => ({
+        event,
+        order,
+        sequence: typeof event?.sequence === "number" && Number.isFinite(event.sequence)
+            ? event.sequence
+            : Number.NaN,
+    }))
+        .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;
+    })
+        .map(({ event }) => event);
+}
+const MAX_AGENT_NATIVE_PERSISTED_EVENT_OMISSION_RANGE = 256;
+function getAgentKitEventSequence(event) {
+    if (!event || typeof event !== "object" || Array.isArray(event)) {
+        return undefined;
+    }
+    const sequence = event.sequence;
+    return typeof sequence === "number" && Number.isSafeInteger(sequence)
+        ? sequence
+        : undefined;
+}
+function getAgentKitEventSequenceEnd(event) {
+    const sequence = getAgentKitEventSequence(event);
+    if (sequence === undefined)
+        return undefined;
+    if (!event ||
+        typeof event !== "object" ||
+        event.type !==
+            "x-agent-native.persisted-event-omission-range") {
+        return sequence;
+    }
+    const payload = event.payload;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return undefined;
+    }
+    const lastSequence = payload.lastSequence;
+    return typeof lastSequence === "number" &&
+        Number.isSafeInteger(lastSequence) &&
+        lastSequence >= sequence &&
+        lastSequence - sequence < MAX_AGENT_NATIVE_PERSISTED_EVENT_OMISSION_RANGE
+        ? lastSequence
+        : undefined;
+}
+function hasContiguousAgentKitEventCoverage(events, runId, lastSequence, firstSequence = 1) {
+    const runEvents = events
+        .filter((event) => event !== null &&
+        typeof event === "object" &&
+        !Array.isArray(event) &&
+        event.runId === runId)
+        .map((event, order) => ({
+        event,
+        order,
+        sequence: getAgentKitEventSequence(event),
+        sequenceEnd: getAgentKitEventSequenceEnd(event),
+    }))
+        .sort((left, right) => {
+        if (left.sequence !== undefined &&
+            right.sequence !== undefined &&
+            left.sequence !== right.sequence) {
+            return left.sequence - right.sequence;
+        }
+        return left.order - right.order;
+    });
+    let nextSequence = firstSequence;
+    for (const event of runEvents) {
+        if (event.sequence !== nextSequence ||
+            event.sequenceEnd === undefined ||
+            event.sequenceEnd < event.sequence) {
+            return false;
+        }
+        nextSequence = event.sequenceEnd + 1;
+    }
+    return nextSequence === lastSequence + 1;
+}
 function mergeAgentKitFullEventSnapshot(existingEvents, incomingEvents, incomingRuns, committedSnapshots) {
     if (!Array.isArray(incomingEvents))
         return undefined;
@@ -1715,16 +1851,7 @@ function mergeAgentKitFullEventSnapshot(existingEvents, incomingEvents, incoming
             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;
-            }));
+            const incomingSequence = Math.max(incomingRunSequences.get(runId) ?? 0, ...runEvents.map((event) => getAgentKitEventSequenceEnd(event) ?? 0));
             if (runEvents.length === 0 || incomingSequence <= committedSequence) {
                 protectedRunIds.add(runId);
             }
@@ -1807,11 +1934,24 @@ function mergeAgentKitEventRunSnapshots(input) {
         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);
+        if (!input.batches.has(runId) && lastSequence > knownSequence) {
+            const incomingEvents = Array.isArray(input.incomingEvents)
+                ? input.incomingEvents
+                : [];
+            const completeFromStart = hasContiguousAgentKitEventCoverage(incomingEvents, runId, lastSequence);
+            const nextChunk = hasContiguousAgentKitEventCoverage(incomingEvents, runId, lastSequence, knownSequence + 1);
+            if (!completeFromStart && !nextChunk) {
+                throw new TypeError("Agent chat event snapshot did not contain a contiguous sequence range.");
+            }
+        }
         const hasKnownSequence = storedWatermark !== undefined ||
             storedRunSequence !== undefined ||
             hasCommittedSnapshot;
         const hasStoredEvents = previousEvents.some((event) => event?.runId === runId);
         if ((hasKnownSequence && lastSequence < knownSequence) ||
+            (hasKnownSequence &&
+                lastSequence === knownSequence &&
+                !input.incomingReplacements.has(runId)) ||
             (hasCommittedSnapshot && lastSequence <= committedSequence)) {
             staleRunIds.add(runId);
             continue;
@@ -1896,8 +2036,7 @@ function mergeAgentKitEventRunSnapshots(input) {
         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) ??
-            [];
+        const stagedEvents = mergeAgentKitEventSnapshotBatch(matchingCurrent ? current.events : [], batchEvents);
         if (stagedEvents.length > batch.expectedEventCount) {
             throw new TypeError("Agent chat event snapshot exceeded its event count.");
         }
@@ -1905,6 +2044,18 @@ function mergeAgentKitEventRunSnapshots(input) {
             throw new TypeError("Agent chat event snapshot ended before all events arrived.");
         }
         if (stagedEvents.length === batch.expectedEventCount) {
+            const lastEventSequence = stagedEvents.reduce((maximum, event) => {
+                const sequence = getAgentKitEventSequenceEnd(event);
+                return sequence !== undefined && sequence >= 0
+                    ? Math.max(maximum, sequence)
+                    : maximum;
+            }, 0);
+            if (batch.lastSequence !== lastEventSequence) {
+                throw new TypeError(`Agent chat event snapshot cursor ${batch.lastSequence} did not match its last event sequence ${lastEventSequence}.`);
+            }
+            if (!hasContiguousAgentKitEventCoverage(stagedEvents, runId, batch.lastSequence)) {
+                throw new TypeError("Agent chat event snapshot did not include every sequence through its cursor.");
+            }
             events = mergeAgentKitEvents(events, stagedEvents, new Set([runId]));
             watermarks.set(runId, Math.max(knownSequence, batch.lastSequence));
             commits[runId] = [
@@ -2051,7 +2202,7 @@ function mergeAgentKitAnnotations(existing, incoming, replaceMessageIds, removal
         }
     return merged;
 }
-function mergeAgentKitHistory(existing, incoming, promptRunIds, onAnnotationConflict) {
+function mergeAgentKitHistory(existing, incoming, promptRunIds, onAnnotationConflict, trustedRunSequenceResetIds = new Set()) {
     const incomingIsRecord = incoming !== null &&
         typeof incoming === "object" &&
         !Array.isArray(incoming);
@@ -2062,10 +2213,27 @@ function mergeAgentKitHistory(existing, incoming, promptRunIds, onAnnotationConf
         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
+    const incomingEvents = Array.isArray(next.events) ? next.events : [];
+    for (const event of incomingEvents) {
+        if (event?.type === "x-agent-native.persisted-event-omission-range" &&
+            getAgentKitEventSequenceEnd(event) === undefined) {
+            throw new TypeError(`Agent chat persisted omission ranges must cover at most ${MAX_AGENT_NATIVE_PERSISTED_EVENT_OMISSION_RANGE} event sequences.`);
+        }
+    }
+    const incomingEventRunIds = new Set(incomingEvents.flatMap((event) => typeof event?.runId === "string" ? [event.runId] : []));
+    const incomingRunStarts = new Set(incomingEvents.flatMap((event) => typeof event?.runId === "string" && event.sequence === 1
         ? [event.runId]
         : []));
+    const incomingEventSequences = new Map();
+    for (const event of incomingEvents) {
+        if (typeof event?.runId !== "string") {
+            continue;
+        }
+        const sequenceEnd = getAgentKitEventSequenceEnd(event);
+        if (sequenceEnd === undefined || sequenceEnd < 0)
+            continue;
+        incomingEventSequences.set(event.runId, Math.max(incomingEventSequences.get(event.runId) ?? 0, sequenceEnd));
+    }
     const eventRunSnapshotBatches = new Map();
     for (const batch of Array.isArray(next.eventRunSnapshotBatches)
         ? next.eventRunSnapshotBatches
@@ -2091,27 +2259,25 @@ function mergeAgentKitHistory(existing, incoming, promptRunIds, onAnnotationConf
         }
     }
     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));
+    for (const [runId, lastSequence] of incomingEventSequences) {
+        if (incomingEventRunIds.has(runId) && !eventRunSnapshotBatches.has(runId)) {
+            eventRunSnapshotWatermarks.set(runId, lastSequence);
         }
     }
     const eventRunReplacements = new Map();
     for (const replacement of Array.isArray(next.eventRunReplacements)
         ? next.eventRunReplacements
         : []) {
+        const eventSequence = typeof replacement?.runId === "string"
+            ? incomingEventSequences.get(replacement.runId)
+            : undefined;
         if (typeof replacement?.runId === "string" &&
+            incomingRunStarts.has(replacement.runId) &&
             typeof replacement.lastSequence === "number" &&
             Number.isSafeInteger(replacement.lastSequence) &&
             replacement.lastSequence >= 1 &&
-            incomingRunStarts.has(replacement.runId) &&
+            eventSequence === replacement.lastSequence &&
+            hasContiguousAgentKitEventCoverage(incomingEvents, replacement.runId, replacement.lastSequence) &&
             !eventRunSnapshotBatches.has(replacement.runId)) {
             eventRunReplacements.set(replacement.runId, Math.max(eventRunReplacements.get(replacement.runId) ?? 0, replacement.lastSequence));
         }
@@ -2214,20 +2380,29 @@ function mergeAgentKitHistory(existing, incoming, promptRunIds, onAnnotationConf
             runs.set(run.id, run);
             continue;
         }
-        const richer = newer.lastSequence >= run.lastSequence ? newer : run;
-        const statusRun = run.lastSequence > newer.lastSequence
-            ? run
-            : newer.lastSequence > run.lastSequence
+        const trustedReset = trustedRunSequenceResetIds.has(run.id) && newer.lastSequence === 0;
+        const richer = trustedReset
+            ? newer
+            : newer.lastSequence >= run.lastSequence
                 ? newer
-                : isTerminalRunStatus(run.status)
-                    ? run
-                    : newer;
+                : run;
+        const statusRun = trustedReset
+            ? newer
+            : 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),
+            lastSequence: trustedReset
+                ? newer.lastSequence
+                : Math.max(newer.lastSequence, run.lastSequence),
             status: statusRun.status,
         });
     }
@@ -2437,7 +2612,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, options.onAnnotationConflict);
+        merged.agentKit = mergeAgentKitHistory(existingNormalized?.agentKit, merged.agentKit, promptRunIds, options.onAnnotationConflict, options.trustedRunSequenceResetIds);
     }
     const existingMessages = Array.isArray(existingNormalized?.messages)
         ? existingNormalized.messages

package/dist/agent/thread-message-projection.d.ts

@@ -1,3 +1,5 @@
+export declare function failedRunIdsWithError(runs: unknown): Set<string>;
+export declare function isRenderedRunNotStartedNotice(value: unknown, failedRunIds: ReadonlySet<string>): boolean;
 export declare function threadMessageRecord(value: unknown): Record<string, unknown> | undefined;
 /** AgentKit messages that represent durable root assistant messages. */
 export declare function projectRootAssistantMessages(input: {
@@ -10,6 +12,7 @@ export declare function projectRootAssistantMessages(input: {
     representedRootMessageIds: Set<string>;
     snapshotMessageIdsByRootMessageId: Map<string, string>;
     snapshotRunIdsByMessageId: Map<string, string>;
+    supersededSnapshotMessageIds: Set<string>;
 };
 /** Root assistant IDs represented by the AgentKit snapshot. */
 export declare function representedRootAssistantMessageIds(input: {

package/dist/agent/thread-message-projection.js

@@ -1,9 +1,28 @@
+import { RUN_NOT_STARTED_METADATA_KEY } from "../shared/agent-chat-run-not-started.js";
 const REPOSITORY_PART_MEDIA_TYPE = "application/x-agent-native-repository-part";
 function record(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value
         : undefined;
 }
+export function failedRunIdsWithError(runs) {
+    return new Set((Array.isArray(runs) ? runs : []).flatMap((value) => {
+        const run = record(value);
+        return run?.status === "failed" &&
+            record(run.error) &&
+            typeof run.id === "string"
+            ? [run.id]
+            : [];
+    }));
+}
+export function isRenderedRunNotStartedNotice(value, failedRunIds) {
+    const entry = message(value);
+    const metadata = record(entry?.metadata);
+    return (entry?.role === "assistant" &&
+        record(metadata?.custom)?.[RUN_NOT_STARTED_METADATA_KEY] === true &&
+        typeof metadata?.runId === "string" &&
+        failedRunIds.has(metadata.runId));
+}
 function message(value) {
     const outer = record(value);
     return record(outer?.message) ?? outer;
@@ -37,6 +56,15 @@ function explicitRunId(value) {
     const runId = record(value.metadata)?.runId;
     return typeof runId === "string" ? runId : undefined;
 }
+function isTerminalAssistant(value) {
+    const status = value.status;
+    const type = record(status)?.type;
+    return (status === "complete" ||
+        status === "error" ||
+        type === "complete" ||
+        type === "error" ||
+        type === "incomplete");
+}
 function foldedRunIds(value) {
     const custom = record(record(value.metadata)?.custom);
     const folded = Array.isArray(custom?.foldedRunIds)
@@ -115,6 +143,26 @@ function reasoning(value) {
 function isPrefixCompatible(left, right) {
     return left.startsWith(right) || right.startsWith(left);
 }
+function isRepeatedAnswerSnapshot(answer, candidateText) {
+    if (!answer || !candidateText.startsWith(answer))
+        return false;
+    let offset = answer.length;
+    let repeatedAnswers = 0;
+    while (offset < candidateText.length) {
+        while (offset < candidateText.length &&
+            /\s/u.test(candidateText[offset])) {
+            offset += 1;
+        }
+        if (offset === candidateText.length)
+            return repeatedAnswers > 0;
+        if (!candidateText.startsWith(answer, offset)) {
+            return false;
+        }
+        offset += answer.length;
+        repeatedAnswers += 1;
+    }
+    return repeatedAnswers > 0;
+}
 function rootToolCalls(value) {
     return parts(value).flatMap((part) => {
         if (part.type !== "data" || part.mediaType !== REPOSITORY_PART_MEDIA_TYPE) {
@@ -124,6 +172,39 @@ function rootToolCalls(value) {
         return data?.type === "tool-call" ? [data] : [];
     });
 }
+function sameToolCallIdentity(left, right) {
+    const id = (call) => typeof call.toolCallId === "string" ? call.toolCallId : call.id;
+    const name = (call) => typeof call.toolName === "string" ? call.toolName : call.name;
+    const args = (call) => Object.prototype.hasOwnProperty.call(call, "args") ? call.args : call.input;
+    const hasArgs = (call) => Object.prototype.hasOwnProperty.call(call, "args") ||
+        Object.prototype.hasOwnProperty.call(call, "input");
+    return (typeof id(left) === "string" &&
+        id(left) === id(right) &&
+        typeof name(left) === "string" &&
+        name(left) === name(right) &&
+        hasArgs(left) &&
+        hasArgs(right) &&
+        sameValue(args(left), args(right)));
+}
+function snapshotAdditionalContentIsRepresented(root, candidate) {
+    const candidateReasoning = reasoning(candidate);
+    if (candidateReasoning && candidateReasoning !== reasoning(root)) {
+        return false;
+    }
+    const rootCalls = rootToolCalls(root);
+    return rootToolCalls(candidate).every((candidateCall) => rootCalls.some((rootCall) => sameToolCallIdentity(rootCall, candidateCall)));
+}
+function snapshotRepresentsRootContent(root, candidate, toolMessageIds) {
+    const rootCalls = rootToolCalls(root);
+    const candidateCalls = rootToolCalls(candidate);
+    if (rootCalls.every((rootCall) => candidateCalls.some((candidateCall) => sameToolCallIdentity(rootCall, candidateCall)))) {
+        return true;
+    }
+    return (rootCalls.length > 0 &&
+        typeof candidate.id === "string" &&
+        toolMessageIds?.size === 1 &&
+        toolMessageIds.has(candidate.id));
+}
 function sameValue(left, right) {
     if (Object.is(left, right))
         return true;
@@ -294,17 +375,68 @@ export function projectRootAssistantMessages(input) {
     }
     const represented = new Set();
     const directMatches = new Map();
+    const rootAssistantCountsByRun = new Map();
+    for (const root of rootMessages) {
+        const runId = assistantRunId(root, runIdsByMessageId);
+        if (!runId)
+            continue;
+        rootAssistantCountsByRun.set(runId, (rootAssistantCountsByRun.get(runId) ?? 0) + 1);
+    }
+    const supersededSnapshotMessageIds = new Set();
     for (const root of rootMessages) {
         if (root.role !== "assistant" || typeof root.id !== "string")
             continue;
-        const runId = explicitRunId(root);
+        const runId = assistantRunId(root, runIdsByMessageId);
         if (!runId)
             continue;
         const toolMessageIds = representedToolCallMessageIds(root, input.toolCalls);
         const sameRunCandidates = (snapshotMessagesByRunId.get(runId) ?? []).filter((candidate) => candidate.id !== root.id);
         const sameRunMatches = sameRunCandidates.filter((candidate) => contentMatches(root, candidate, toolMessageIds));
         const rootText = text(root);
-        const matchingCandidate = sameRunMatches[0];
+        const exactTextMatches = sameRunMatches.filter((candidate) => rootText !== undefined && text(candidate) === rootText);
+        const duplicateCandidates = rootText && isTerminalAssistant(root)
+            ? sameRunCandidates.filter((candidate) => {
+                const candidateText = text(candidate);
+                return (candidateText === rootText ||
+                    Boolean(candidateText &&
+                        isRepeatedAnswerSnapshot(rootText, candidateText)));
+            })
+            : [];
+        if (rootText &&
+            isTerminalAssistant(root) &&
+            rootAssistantCountsByRun.get(runId) === 1 &&
+            duplicateCandidates.length > 0) {
+            const matchingCandidate = exactTextMatches.find((candidate) => snapshotRepresentsRootContent(root, candidate, toolMessageIds) &&
+                snapshotAdditionalContentIsRepresented(root, candidate));
+            if (matchingCandidate && typeof matchingCandidate.id === "string") {
+                represented.add(root.id);
+                directMatches.set(root.id, matchingCandidate.id);
+            }
+            for (const candidate of duplicateCandidates) {
+                if (matchingCandidate && candidate.id === matchingCandidate.id) {
+                    continue;
+                }
+                const candidateText = text(candidate);
+                if (candidateText &&
+                    snapshotAdditionalContentIsRepresented(root, candidate) &&
+                    typeof candidate.id === "string") {
+                    supersededSnapshotMessageIds.add(candidate.id);
+                }
+            }
+            continue;
+        }
+        const matchingCandidates = rootText && isTerminalAssistant(root)
+            ? sameRunMatches.filter((candidate) => {
+                const candidateText = text(candidate);
+                return (!candidateText ||
+                    !isRepeatedAnswerSnapshot(rootText, candidateText));
+            })
+            : sameRunMatches;
+        const fallbackExactMatches = matchingCandidates.filter((candidate) => rootText !== undefined && text(candidate) === rootText);
+        const candidateMatches = fallbackExactMatches.length > 0
+            ? fallbackExactMatches
+            : matchingCandidates;
+        const matchingCandidate = candidateMatches[0];
         const exactTextMatch = matchingCandidate !== undefined &&
             rootText !== undefined &&
             text(matchingCandidate) === rootText;
@@ -314,7 +446,7 @@ export function projectRootAssistantMessages(input) {
                     (snapshotRunIdsByMessageId.get(matchingCandidate.id) === runId ||
                         (runIdsByMessageId.get(matchingCandidate.id)?.size === 1 &&
                             messageIdsByRun.get(runId)?.size === 1))));
-        if (sameRunMatches.length === 1 &&
+        if (candidateMatches.length === 1 &&
             (exactTextMatch ||
                 (sameRunCandidates.length === 1 && clientCanMatchPartial))) {
             represented.add(root.id);
@@ -344,6 +476,7 @@ export function projectRootAssistantMessages(input) {
         representedRootMessageIds: represented,
         snapshotMessageIdsByRootMessageId,
         snapshotRunIdsByMessageId,
+        supersededSnapshotMessageIds,
     };
 }
 /** Root assistant IDs represented by the AgentKit snapshot. */

package/dist/automation/index.d.ts

@@ -139,8 +139,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
-    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
+    error?: undefined;
 }>;

package/dist/chat-threads/store.d.ts

@@ -189,6 +189,7 @@ export interface UpdateThreadDataOptions {
     preserveExistingTopLevelKeys?: boolean;
     preserveCurrentMetadata?: boolean;
     preserveCurrentTitleAndPreview?: boolean;
+    trustedRunSequenceResetIds?: ReadonlySet<string>;
     onAnnotationConflict?: (conflict: ThreadAnnotationSnapshotConflict) => void;
     transformThreadData?: (currentThreadData: string) => string | {
         threadData: string;

package/dist/chat-threads/store.js

@@ -1,7 +1,7 @@
 import crypto from "node:crypto";
 import { parseQueueMessageInput, } from "@agent-native/agentkit/protocol";
 import { extractThreadMeta, mergeThreadDataForClientSave, normalizeThreadRepository, normalizeThreadTitle, } from "../agent/thread-data-builder.js";
-import { representedRootAssistantMessageIds, threadMessageRecord, } from "../agent/thread-message-projection.js";
+import { failedRunIdsWithError, isRenderedRunNotStartedNotice, projectRootAssistantMessages, threadMessageRecord, } from "../agent/thread-message-projection.js";
 import { getDbExec } from "../db/client.js";
 import { createGetDb } from "../db/create-get-db.js";
 import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../db/ddl-guard.js";
@@ -293,17 +293,20 @@ function countThreadMessages(value, fallback) {
     if (repoMessageCount === undefined && agentKitMessageCount === undefined) {
         return fallback;
     }
-    const rootMessages = Array.isArray(repo.messages) ? repo.messages : [];
+    const failedRunIds = failedRunIdsWithError(repo.agentKit?.runs);
+    const rootMessages = (Array.isArray(repo.messages) ? repo.messages : []).filter((entry) => !isRenderedRunNotStartedNotice(entry, failedRunIds));
     const agentKitMessages = Array.isArray(repo.agentKit?.messages)
         ? repo.agentKit.messages
         : [];
-    const mirroredRootIds = representedRootAssistantMessageIds({
+    const assistantProjection = projectRootAssistantMessages({
         rootMessages,
         snapshotMessages: agentKitMessages,
         events: repo.agentKit?.events,
         runs: repo.agentKit?.runs,
         toolCalls: repo.agentKit?.toolCalls,
     });
+    const mirroredRootIds = assistantProjection.representedRootMessageIds;
+    const supersededSnapshotMessageIds = assistantProjection.supersededSnapshotMessageIds;
     const agentKitUserMessageId = (entry) => {
         const message = threadMessageRecord(entry);
         if (message?.role !== "user")
@@ -362,8 +365,14 @@ function countThreadMessages(value, fallback) {
         }
         countMessage(entry);
     }
-    for (const entry of agentKitMessages)
+    for (const entry of agentKitMessages) {
+        const message = threadMessageRecord(entry);
+        if (typeof message?.id === "string" &&
+            supersededSnapshotMessageIds.has(message.id)) {
+            continue;
+        }
         countMessage(entry);
+    }
     return messageIds.size + unkeyedMessages;
 }
 function forkThreadData(threadData, forkId, fromMessageId) {
@@ -1124,6 +1133,7 @@ export async function updateThreadData(id, threadData, title, preview, messageCo
             const merged = mergeThreadDataForClientSave(safeCurrentThreadData, parseThreadData(incomingThreadData), {
                 preserveExistingQueuedMessages: options.preserveExistingQueuedMessages ?? true,
                 preserveExistingTopLevelKeys: options.preserveExistingTopLevelKeys ?? true,
+                trustedRunSequenceResetIds: options.trustedRunSequenceResetIds,
                 onAnnotationConflict: (conflict) => annotationConflicts.push(conflict),
             });
             // Client snapshots can predate their upload URL, so inline bytes become a