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

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/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

@@ -1124,6 +1124,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

package/dist/cli/connect.d.ts

@@ -57,6 +57,7 @@ export interface ConnectDeps {
 }
 export declare function runDeviceFlow(baseUrl: string, appSlug: string, clientArg: string, deps?: ConnectDeps, options?: {
     fullCatalog?: boolean;
+    purpose?: "agent" | "credential";
 }): Promise<{
     token?: string;
     mcpUrl: string;

package/dist/cli/connect.js

@@ -329,7 +329,7 @@ async function resolveHostedAppsFromPrompt(deps) {
     return apps.filter((app) => selected.has(app.name));
 }
 function clientArgForDeviceFlow(clients) {
-    return clients.length === 1 ? clients[0] : "all";
+    return clients.join(",");
 }
 export function supportsRemoteMcpOAuth(client) {
     return REMOTE_MCP_OAUTH_CLIENTS.has(client);
@@ -616,6 +616,7 @@ export async function runDeviceFlow(baseUrl, appSlug, clientArg, deps = {}, opti
                 client: clientArg,
                 app: appSlug,
                 ...(options.fullCatalog ? { fullCatalog: true } : {}),
+                ...(options.purpose ? { purpose: options.purpose } : {}),
             });
             if (status >= 200 && status < 300 && json?.device_code) {
                 start = json;
@@ -1637,7 +1638,9 @@ async function connectOne(rawUrl, parsed, clients, deps) {
         try {
             logOut("");
             logOut(`  Minting a publish token for the local Plans server (device flow)…`);
-            const grant = await runDeviceFlow(baseUrl, appSlug, "codex", deps);
+            const grant = await runDeviceFlow(baseUrl, appSlug, "codex", deps, {
+                purpose: "credential",
+            });
             if (grant?.token) {
                 publishToken = grant.token;
             }
@@ -1781,7 +1784,9 @@ export async function runServiceTokenMint(parsed, deps = {}) {
     logOut("");
     logOut(`  Creating org service token "${serviceName}" on ${baseUrl}`);
     logOut("  First, verify it's you (the token will belong to your org)…");
-    const grant = await runDeviceFlow(baseUrl, appSlug, "codex", deps);
+    const grant = await runDeviceFlow(baseUrl, appSlug, "codex", deps, {
+        purpose: "credential",
+    });
     if (!grant?.token) {
         logErr("  Could not authenticate (the server returned no bearer token).");
         logErr("  Org service tokens require a deployed app with auth configured.");