@agent-native/core 0.225.0 → 0.225.1-nightly-20261106122820

package/dist/agent/harness/lifecycle.js

@@ -571,6 +571,8 @@ export async function sendAgentHarnessFollowUp(input) {
         let providerDispatchStarted = false;
         const hasFollowUpProviderDispatchStarted = () => providerDispatchStarted;
         let activeRun;
+        let finalizedRejected = false;
+        const hasFinalizedRejection = () => finalizedRejected;
         try {
             const dispatchIntent = await markAgentHarnessSessionFollowUpDispatched(session.id, claimed.generation, claimId);
             if (!dispatchIntent) {
@@ -801,7 +803,10 @@ export async function sendAgentHarnessFollowUp(input) {
                                     rejectFirstDispatch(runFailure ??
                                         new Error("The AgentHarness follow-up run ended before provider dispatch."));
                                 }
-                            }, rejectFirstDispatch);
+                            }, (error) => {
+                                finalizedRejected = true;
+                                rejectFirstDispatch(error);
+                            });
                             if (followUpAbort.signal.aborted)
                                 abortActiveRun();
                             return firstDispatch;
@@ -819,7 +824,13 @@ export async function sendAgentHarnessFollowUp(input) {
                     refreshLiveAgentHarnessSessionGeneration(session.id, acquired.live.session, dispatch.session.generation);
                     if (isAbortRequested(followUpAbort.signal))
                         abortActiveRun();
-                    await activeRun.finalized;
+                    try {
+                        await activeRun.finalized;
+                    }
+                    catch (error) {
+                        finalizedRejected = true;
+                        throw error;
+                    }
                 }
                 finally {
                     followUpAbort.signal.removeEventListener("abort", abortActiveRun);
@@ -994,13 +1005,22 @@ export async function sendAgentHarnessFollowUp(input) {
             if (isAbortRequested(followUpAbort.signal)) {
                 const reason = followUpAbort.signal.reason;
                 if (isAgentHarnessSessionConflictError(reason)) {
-                    const latest = await getAgentHarnessSessionByRunId(input.runId);
                     const cleanupErrors = [];
-                    if (!latest ||
-                        (latest.status === "idle" && latest.followUpClaimId == null) ||
-                        latest.status === "stopped" ||
-                        latest.status === "errored" ||
-                        latest.status === "destroyed") {
+                    let lookupFailed = false;
+                    let latest;
+                    try {
+                        latest = await getAgentHarnessSessionByRunId(input.runId);
+                    }
+                    catch (lookupError) {
+                        lookupFailed = true;
+                        cleanupErrors.push(lookupError);
+                    }
+                    if (latest !== undefined &&
+                        (!latest ||
+                            (latest.status === "idle" && latest.followUpClaimId == null) ||
+                            latest.status === "stopped" ||
+                            latest.status === "errored" ||
+                            latest.status === "destroyed")) {
                         try {
                             await stopAcquiredHarnessSession(session.id, acquired.live.session);
                         }
@@ -1016,12 +1036,26 @@ export async function sendAgentHarnessFollowUp(input) {
                             cleanupErrors.push(closeError);
                         }
                     }
+                    if (lookupFailed &&
+                        !hasFinalizedRejection() &&
+                        cleanupErrors.length === 1) {
+                        throw cleanupErrors[0];
+                    }
                     if (cleanupErrors.length > 0) {
-                        throw new AggregateError([reason, ...cleanupErrors], "Harness follow-up was interrupted and stream cleanup was incomplete.");
+                        throw new AggregateError([
+                            reason,
+                            ...(hasFinalizedRejection() ? [error] : []),
+                            ...cleanupErrors,
+                        ], "Harness follow-up was interrupted and stream cleanup was incomplete.");
                     }
+                    if (hasFinalizedRejection())
+                        throw error;
                     return failure(input.runId, latest ?? session, "unavailable", "The harness follow-up was interrupted because its session claim changed or stopped.");
                 }
-                const failures = [reason ?? error];
+                const failures = [
+                    reason ?? error,
+                    ...(hasFinalizedRejection() ? [error] : []),
+                ];
                 let failedSession = null;
                 try {
                     failedSession = await markOwnedFollowUpErrored(session.id, claimId, acquired.live.session, hasFollowUpProviderDispatchStarted() ? "unknown" : "not_dispatched");
@@ -1046,7 +1080,9 @@ export async function sendAgentHarnessFollowUp(input) {
                     }
                 }
                 if (failures.length > 1) {
-                    throw new AggregateError(failures, "Harness follow-up claim monitoring failed and cleanup was incomplete.");
+                    throw new AggregateError(failures, hasFinalizedRejection()
+                        ? "Harness follow-up claim monitoring failed and finalization or cleanup was incomplete."
+                        : "Harness follow-up claim monitoring failed and cleanup was incomplete.");
                 }
                 const latest = failedSession ?? (await getAgentHarnessSessionByRunId(input.runId));
                 return failure(input.runId, latest ?? session, "unavailable", "The harness follow-up was stopped because its session claim could not be verified.");

package/dist/agent/run-manager.js

@@ -741,6 +741,12 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
     let persistenceFailure;
     let persistenceFailureBlocked = false;
     const flushEventWrites = (retryAfterFailure) => {
+        if (persistenceFailure instanceof AgentRunEventNotPersistedError &&
+            persistenceFailure.terminalRun) {
+            const failed = Promise.reject(persistenceFailure);
+            persistenceChain = failed;
+            return failed;
+        }
         if (persistenceDrain) {
             const activeDrain = persistenceDrain;
             const settledDrain = retryAfterFailure
@@ -779,8 +785,8 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                 catch (error) {
                     const terminalRun = error instanceof AgentRunEventNotPersistedError &&
                         error.terminalRun;
-                    persistenceFailure = terminalRun ? undefined : error;
-                    persistenceFailureBlocked = !terminalRun;
+                    persistenceFailure = error;
+                    persistenceFailureBlocked = true;
                     for (const queued of pendingEventWrites) {
                         for (const publication of queued.publications) {
                             if (publication.settled)
@@ -1527,6 +1533,14 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         return publication;
     };
     const emitRunEvent = (runEvent, options) => {
+        if (persistenceFailure instanceof AgentRunEventNotPersistedError &&
+            persistenceFailure.terminalRun) {
+            const publication = Promise.reject(persistenceFailure);
+            if (!options?.surfacePersistenceError)
+                publication.catch(() => { });
+            void checkSqlAbort();
+            return publication;
+        }
         if (privateTurn && runEvent.event.omitFromPersistedHistory !== true) {
             runEvent = {
                 ...runEvent,
@@ -1722,7 +1736,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         completionInProgress = true;
         let completionError = null;
         let terminalPersistenceError = null;
-        let eventPersistenceError = null;
+        let eventPersistenceFailure = null;
         let runTerminalErrorCode;
         let runTerminalBlockedTool;
         let runTerminalBlockedBy;
@@ -1731,21 +1745,26 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         let suppressContinuationEvent = false;
         try {
             await persistenceChain;
+        }
+        catch (error) {
+            eventPersistenceFailure = { error };
+        }
+        try {
             await run.abortPersistencePromise;
         }
         catch (error) {
-            eventPersistenceError = error;
-            if (run.status !== "aborted") {
-                run.status = "errored";
-                pendingTerminalEvent = {
-                    seq: allocateRunEventSeq(run),
-                    event: {
-                        type: "error",
-                        error: "Agent run ended unexpectedly",
-                        errorCode: "run_event_persistence_failed",
-                    },
-                };
-            }
+            eventPersistenceFailure ??= { error };
+        }
+        if (eventPersistenceFailure && run.status !== "aborted") {
+            run.status = "errored";
+            pendingTerminalEvent = {
+                seq: allocateRunEventSeq(run),
+                event: {
+                    type: "error",
+                    error: "Agent run ended unexpectedly",
+                    errorCode: "run_event_persistence_failed",
+                },
+            };
         }
         if (checkpointStatusReadFailed || checkpointUnknownStatus !== null) {
             const event = checkpointStatusReadFailed
@@ -1754,7 +1773,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
             const abortAlreadyWon = run.status === "aborted" && run.abortReason !== undefined;
             if (!abortAlreadyWon) {
                 run.status = "errored";
-                if (!eventPersistenceError) {
+                if (!eventPersistenceFailure) {
                     pendingTerminalEvent = {
                         seq: peekRunEventSeq(run),
                         event: { ...event },
@@ -1768,7 +1787,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         const resolveTerminalEventForCompletion = () => {
             if (run.status === "aborted" && run.abortReason !== undefined)
                 return null;
-            if (eventPersistenceError) {
+            if (eventPersistenceFailure) {
                 return pendingTerminalEvent
                     ? { ...pendingTerminalEvent, seq: run.events.length }
                     : null;
@@ -1886,7 +1905,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         if (unfinishedTurnContinuationEvent) {
             terminalEvent = unfinishedTurnContinuationEvent;
         }
-        const terminalReason = eventPersistenceError && finalStatus !== "aborted"
+        const terminalReason = eventPersistenceFailure && finalStatus !== "aborted"
             ? "error:run_event_persistence_failed"
             : privateTurn && terminalEvent?.type === "error"
                 ? "error:private_content_omitted"
@@ -1989,7 +2008,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                     : error);
         };
         if (finalStatus === "completed" || finalStatus === "errored") {
-            const terminalEventToEmit = eventPersistenceError
+            const terminalEventToEmit = eventPersistenceFailure
                 ? {
                     type: "error",
                     error: "Agent run ended unexpectedly",
@@ -2048,7 +2067,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                         ? { ...terminalEventToEmit, omitFromPersistedHistory: true }
                         : terminalEventToEmit,
                 };
-                if (eventPersistenceError) {
+                if (eventPersistenceFailure) {
                     volatileTerminalEvent = terminal;
                 }
                 else {
@@ -2100,8 +2119,10 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                 terminalPersistenceEstablished = false;
             }
             else {
+                let abortStatusAttempted = false;
                 try {
                     await insertRunPromise;
+                    abortStatusAttempted = true;
                     const persistAtomicAbort = () => markRunAborted(runId, run.abortReason ?? "execution-lease-claim-failed");
                     const aborted = executionLeaseClaimFailed
                         ? await persistAtomicAbort()
@@ -2113,6 +2134,10 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                 catch (error) {
                     terminalPersistenceEstablished = false;
                     reportTerminalStatusPersistenceError(error);
+                    if (eventPersistenceFailure &&
+                        (abortStatusAttempted || eventPersistenceFailure.error !== error)) {
+                        throw new AggregateError([eventPersistenceFailure.error, error], "Run event and abort status persistence both failed");
+                    }
                     throw error;
                 }
             }
@@ -2136,7 +2161,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                     await insertRunPromise;
                 }
                 if (!continuationStatusPersistedBeforeEvent &&
-                    (!terminalPersistenceError || eventPersistenceError)) {
+                    (!terminalPersistenceError || eventPersistenceFailure)) {
                     let statusUpdated = false;
                     try {
                         statusUpdated = await persistOwnTerminalStatus();
@@ -2208,7 +2233,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
             }
         }
         if (terminalPersistenceError) {
-            const reconciled = eventPersistenceError
+            const reconciled = eventPersistenceFailure
                 ? false
                 : await reconcileTerminalRun();
             if (!reconciled)
@@ -2242,8 +2267,8 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                 attemptCount: options?.attemptCount,
             });
         }
-        if (eventPersistenceError && finalStatus !== "aborted") {
-            throw eventPersistenceError;
+        if (eventPersistenceFailure) {
+            throw eventPersistenceFailure.error;
         }
     })
         .finally(async () => {
@@ -3069,8 +3094,6 @@ export async function abortRunDurably(runId, reason = "user", options) {
             }
             if (run)
                 run.abortPersistenceManaged = abortPersistedDurably;
-            if (eventFlushFailure)
-                throw eventFlushFailure;
         }
         catch (error) {
             if (run)
@@ -3090,8 +3113,13 @@ export async function abortRunDurably(runId, reason = "user", options) {
                 },
             });
             console.error("[run-manager] durable abort persistence failed:", error instanceof Error ? error.message : error);
+            if (eventFlushFailure) {
+                throw new AggregateError([eventFlushFailure, error], "Run abort event flush and marker persistence failed");
+            }
             throw error;
         }
+        if (eventFlushFailure)
+            throw eventFlushFailure;
         return abortedInMemory;
     })();
     if (run) {
@@ -3147,7 +3175,7 @@ export async function abortRunAtSafeBoundaryDurably(runId, reason = "user") {
         throw result.eventFlushFailure;
     return result.aborted;
 }
-export async function abortTurnByRefDurably(threadId, turnId, reason = "user") {
+async function abortTurnByRefDurablyInternal(threadId, turnId, reason, reportedFlushFailure) {
     const fence = currentExecutionFence();
     if (fence && (fence.threadId !== threadId || fence.turnId !== turnId)) {
         throw new StaleExecutionFenceError(fence);
@@ -3161,24 +3189,49 @@ export async function abortTurnByRefDurably(threadId, turnId, reason = "user") {
             runsToFlush.push(run);
         }
     }
-    const flushFailures = await Promise.all(runsToFlush.map((run) => flushRunEventsBeforeAbort(run)));
+    const flushResults = await Promise.allSettled(runsToFlush.map((run) => flushRunEventsBeforeAbort(run)));
+    // Only the same run's repeated flush is already reported by the caller;
+    // a marker write can fail with the very same error object independently.
+    const unreportedFlushFailures = [];
+    let hasRejectedFlush = false;
+    for (const [index, result] of flushResults.entries()) {
+        if (result.status === "rejected") {
+            hasRejectedFlush = true;
+            unreportedFlushFailures.push(result.reason);
+        }
+        else if (result.value &&
+            !(reportedFlushFailure &&
+                runsToFlush[index]?.runId === reportedFlushFailure.runId &&
+                result.value === reportedFlushFailure.error)) {
+            unreportedFlushFailures.push(result.value);
+        }
+    }
+    if (hasRejectedFlush) {
+        if (unreportedFlushFailures.length === 1)
+            throw unreportedFlushFailures[0];
+        throw new AggregateError(unreportedFlushFailures, "Turn abort event flushes failed");
+    }
     let result;
     try {
         result = await markTurnAborted(threadId, turnId, reason);
     }
     catch (error) {
-        const eventFlushFailure = flushFailures.find(Boolean);
-        if (eventFlushFailure) {
-            throw new AggregateError([eventFlushFailure, error], "Turn abort event flush and marker persistence failed");
+        if (unreportedFlushFailures.length) {
+            throw new AggregateError([...unreportedFlushFailures, error], "Turn abort event flush and marker persistence failed");
         }
         throw error;
     }
-    const eventFlushFailure = flushFailures.find(Boolean);
-    if (eventFlushFailure)
-        throw eventFlushFailure;
+    if (unreportedFlushFailures.length === 1)
+        throw unreportedFlushFailures[0];
+    if (unreportedFlushFailures.length > 1) {
+        throw new AggregateError(unreportedFlushFailures, "Turn abort event flushes failed");
+    }
     return result;
 }
-export async function abortTurnDurably(runId, reason = "user") {
+export async function abortTurnByRefDurably(threadId, turnId, reason = "user") {
+    return abortTurnByRefDurablyInternal(threadId, turnId, reason);
+}
+async function abortTurnDurablyInternal(runId, reason, reportedFlushFailure) {
     const memRun = activeRuns.get(runId);
     try {
         const ref = memRun
@@ -3187,7 +3240,7 @@ export async function abortTurnDurably(runId, reason = "user") {
         if (!ref) {
             throw new Error(`Cannot durably abort turn for missing run ${runId}`);
         }
-        return await abortTurnByRefDurably(ref.threadId, ref.turnId, reason);
+        return await abortTurnByRefDurablyInternal(ref.threadId, ref.turnId, reason, reportedFlushFailure);
     }
     catch (error) {
         captureError(error, {
@@ -3199,6 +3252,9 @@ export async function abortTurnDurably(runId, reason = "user") {
         throw error;
     }
 }
+export async function abortTurnDurably(runId, reason = "user") {
+    return abortTurnDurablyInternal(runId, reason);
+}
 /** Persist a Stop's turn marker even when a terminal event flush must be reported. */
 export async function abortRunAndTurnDurably(runId, reason = "user", options) {
     let abortedInMemory = false;
@@ -3222,7 +3278,9 @@ export async function abortRunAndTurnDurably(runId, reason = "user", options) {
     }
     if (!options?.safeBoundary || abortedInMemory) {
         try {
-            await abortTurnDurably(runId, reason);
+            await abortTurnDurablyInternal(runId, reason, terminalFlushFailure
+                ? { runId, error: terminalFlushFailure }
+                : undefined);
         }
         catch (error) {
             if (terminalFlushFailure) {

package/dist/framework-package-versions.json

@@ -1,10 +1,10 @@
 {
-  "@agent-native/agentkit": "0.225.0",
+  "@agent-native/agentkit": "0.225.1-nightly-20261106122820",
   "@agent-native/code-agents-ui": "0.1.75",
-  "@agent-native/core": "0.225.0",
-  "@agent-native/core-corpus": "0.225.0",
+  "@agent-native/core": "0.225.1-nightly-20261106122820",
+  "@agent-native/core-corpus": "0.225.1-nightly-20261106122820",
   "@agent-native/creative-context": "0.8.66",
-  "@agent-native/dispatch": "0.42.1",
+  "@agent-native/dispatch": "0.42.2-nightly-20261106122820",
   "@agent-native/embedding": "0.2.0",
   "@agent-native/migrate": "0.0.7",
   "@agent-native/otel": "0.1.33",
@@ -12,6 +12,6 @@
   "@agent-native/recap-cli": "0.5.97",
   "@agent-native/scheduling": "0.2.53",
   "@agent-native/shared-app-config": "0.1.2",
-  "@agent-native/skills": "0.4.1",
-  "@agent-native/toolkit": "0.225.0"
+  "@agent-native/skills": "0.4.2-nightly-20261106122820",
+  "@agent-native/toolkit": "0.225.1-nightly-20261106122820"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.225.0",
+  "version": "0.225.1-nightly-20261106122820",
   "description": "The agentic application framework for building autonomous agents with intuitive UIs",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -760,8 +760,8 @@
     "yaml": "^2.9.0",
     "yjs": "^13.6.33",
     "zod": "^4.3.6",
-    "@agent-native/agentkit": "^0.225.0",
-    "@agent-native/recap-cli": "^0.5.97"
+    "@agent-native/recap-cli": "^0.5.97",
+    "@agent-native/agentkit": "^0.225.1-nightly-20261106122820"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.71",
@@ -833,7 +833,7 @@
     "xlsx": "^0.18.5"
   },
   "peerDependencies": {
-    "@agent-native/core-corpus": ">=0.196.0",
+    "@agent-native/core-corpus": "0.225.1-nightly-20261106122820",
     "@ai-sdk/anthropic": ">=3",
     "@ai-sdk/cohere": ">=3",
     "@ai-sdk/google": ">=3",