@agent-native/core 0.153.4 → 0.153.5

package/dist/agent/run-loop-with-resume.js

@@ -24,23 +24,35 @@ import { runAgentLoop, appendAgentLoopContinuation, isResumableEngineError, isTr
 import { resolveRunSoftTimeoutMs } from "./run-manager.js";
 import { getCurrentTurnEventsForThread } from "./run-store.js";
 import { classifyToolCallJournal, buildResumeJournalNote, } from "./tool-call-journal.js";
-async function readCurrentTurnEventsForResume(threadId, localEvents = []) {
+/**
+ * `persisted: false` means the durable half of the turn could not be read, so
+ * `events` holds only what this invocation saw. Callers that decide whether to
+ * DISCARD user-visible output must not read that as "nothing else happened".
+ */
+async function readCurrentTurnEventsForResume(threadId, turnId, localEvents = []) {
     let persistedEvents = [];
+    let persisted = true;
     try {
+        // Without the turnId this can return the PREVIOUS turn's events — see
+        // `getCurrentTurnEventsForThread`, whose run row is written without await.
         persistedEvents = threadId
-            ? await getCurrentTurnEventsForThread(threadId)
+            ? await getCurrentTurnEventsForThread(threadId, turnId)
             : [];
     }
-    catch {
-        persistedEvents = [];
+    catch (err) {
+        persisted = false;
+        console.warn("[run-loop] current-turn ledger read failed:", err instanceof Error ? err.message : String(err));
     }
     if (localEvents.length === 0)
-        return persistedEvents;
+        return { events: persistedEvents, persisted };
     const seen = new Set(persistedEvents.map((event) => JSON.stringify(event)));
-    return [
-        ...persistedEvents,
-        ...localEvents.filter((event) => !seen.has(JSON.stringify(event))),
-    ];
+    return {
+        events: [
+            ...persistedEvents,
+            ...localEvents.filter((event) => !seen.has(JSON.stringify(event))),
+        ],
+        persisted,
+    };
 }
 function actionPreparationContinuationOptions(events) {
     const actionPreparationTool = lastUnfinishedPreparingActionToolFromEvents(events);
@@ -86,8 +98,8 @@ function appendToolCallJournalNote(messages, events) {
         // up — the model still continues, just without the structured journal.
     }
 }
-async function appendContinuationAndJournal(messages, reason, threadId, localEvents = []) {
-    const events = await readCurrentTurnEventsForResume(threadId, localEvents);
+async function appendContinuationAndJournal(messages, reason, threadId, turnId, localEvents = []) {
+    const { events } = await readCurrentTurnEventsForResume(threadId, turnId, localEvents);
     appendAgentLoopContinuation(messages, reason, actionPreparationContinuationOptions(events));
     appendToolCallJournalNote(messages, events);
 }
@@ -95,21 +107,23 @@ async function appendContinuationAndJournal(messages, reason, threadId, localEve
  * Rebuild the same safe continuation context for a logical turn that resumes
  * in a fresh hosted invocation.
  */
-export async function appendDurableContinuationContext(messages, reason, threadId) {
-    await appendContinuationAndJournal(messages, reason, threadId);
+export async function appendDurableContinuationContext(messages, reason, threadId, turnId) {
+    await appendContinuationAndJournal(messages, reason, threadId, turnId);
 }
-async function hasCompletedSideEffectToolCallInCurrentTurn(threadId, localEvents = []) {
-    try {
-        const events = await readCurrentTurnEventsForResume(threadId, localEvents);
-        if (events.length === 0)
-            return false;
-        return events.some((event) => event.type === "tool_done" &&
-            event.completedSideEffect === true &&
-            event.isError !== true);
-    }
-    catch {
-        return false;
-    }
+/**
+ * `"unknown"` is not `"none"`: the only caller uses this to decide whether to
+ * emit `clear`, and `clear` WIPES user-visible output. A transient ledger error
+ * must not delete the tool cards that are the user's only proof a side effect
+ * landed.
+ */
+async function completedSideEffectInCurrentTurn(threadId, turnId, localEvents = []) {
+    const { events, persisted } = await readCurrentTurnEventsForResume(threadId, turnId, localEvents);
+    const found = events.some((event) => event.type === "tool_done" &&
+        event.completedSideEffect === true &&
+        event.isError !== true);
+    if (found)
+        return "some";
+    return persisted ? "none" : "unknown";
 }
 function internalContinuationReasonForAttempt(events) {
     const last = events.at(-1);
@@ -362,15 +376,15 @@ export async function runAgentLoopDirectWithSoftTimeout(opts, softTimeoutMs, tim
             if (internalContinuationReason && !upstreamSignal.aborted) {
                 lastAttemptWasUnfinishedContinuation = true;
                 const continuationEvents = [...localTurnEvents];
-                if (!(await hasCompletedSideEffectToolCallInCurrentTurn(opts.threadId, continuationEvents))) {
+                if ((await completedSideEffectInCurrentTurn(opts.threadId, opts.turnId, continuationEvents)) === "none") {
                     opts.send({ type: "clear" });
                 }
-                await appendContinuationAndJournal(opts.messages, internalContinuationReason, opts.threadId, continuationEvents);
+                await appendContinuationAndJournal(opts.messages, internalContinuationReason, opts.threadId, opts.turnId, continuationEvents);
                 continue;
             }
             if (softTimedOut && !upstreamSignal.aborted) {
                 lastAttemptWasUnfinishedContinuation = true;
-                await appendContinuationAndJournal(opts.messages, "run_timeout", opts.threadId, localTurnEvents);
+                await appendContinuationAndJournal(opts.messages, "run_timeout", opts.threadId, opts.turnId, localTurnEvents);
                 continue;
             }
             reportFinalOutcome(upstreamSignal.aborted
@@ -383,10 +397,10 @@ export async function runAgentLoopDirectWithSoftTimeout(opts, softTimeoutMs, tim
                 // Clear partial text the client received before the abort so the
                 // resumed model doesn't re-emit it and produce duplicated output.
                 lastAttemptWasUnfinishedContinuation = true;
-                if (!(await hasCompletedSideEffectToolCallInCurrentTurn(opts.threadId, localTurnEvents))) {
+                if ((await completedSideEffectInCurrentTurn(opts.threadId, opts.turnId, localTurnEvents)) === "none") {
                     opts.send({ type: "clear" });
                 }
-                await appendContinuationAndJournal(opts.messages, "run_timeout", opts.threadId, localTurnEvents);
+                await appendContinuationAndJournal(opts.messages, "run_timeout", opts.threadId, opts.turnId, localTurnEvents);
                 continue;
             }
             const transientRateLimit = isTransientProviderRateLimitError(err);
@@ -402,10 +416,10 @@ export async function runAgentLoopDirectWithSoftTimeout(opts, softTimeoutMs, tim
                 rateLimitRetryFitsBudget) {
                 lastAttemptWasUnfinishedContinuation = true;
                 backgroundRateLimitContinuations++;
-                if (!(await hasCompletedSideEffectToolCallInCurrentTurn(opts.threadId, localTurnEvents))) {
+                if ((await completedSideEffectInCurrentTurn(opts.threadId, opts.turnId, localTurnEvents)) === "none") {
                     opts.send({ type: "clear" });
                 }
-                await appendContinuationAndJournal(opts.messages, "rate_limited", opts.threadId, localTurnEvents);
+                await appendContinuationAndJournal(opts.messages, "rate_limited", opts.threadId, opts.turnId, localTurnEvents);
                 await waitForBackgroundRateLimitCooldown(upstreamSignal);
                 continue;
             }
@@ -424,10 +438,10 @@ export async function runAgentLoopDirectWithSoftTimeout(opts, softTimeoutMs, tim
             // the in-memory messages array, so the next attempt re-emits it).
             if (!upstreamSignal.aborted && isResumableEngineError(err)) {
                 lastAttemptWasUnfinishedContinuation = true;
-                if (!(await hasCompletedSideEffectToolCallInCurrentTurn(opts.threadId, localTurnEvents))) {
+                if ((await completedSideEffectInCurrentTurn(opts.threadId, opts.turnId, localTurnEvents)) === "none") {
                     opts.send({ type: "clear" });
                 }
-                await appendContinuationAndJournal(opts.messages, continuationReasonForResumableError(err), opts.threadId, localTurnEvents);
+                await appendContinuationAndJournal(opts.messages, continuationReasonForResumableError(err), opts.threadId, opts.turnId, localTurnEvents);
                 continue;
             }
             if (upstreamSignal.aborted) {
@@ -467,7 +481,7 @@ export async function runAgentLoopDirectWithSoftTimeout(opts, softTimeoutMs, tim
         // the terminal message stands alone instead of trailing a half sentence.
         // Preserve completed tool cards: they are the user's only durable proof
         // that a side effect landed before the final assistant note timed out.
-        if (!(await hasCompletedSideEffectToolCallInCurrentTurn(opts.threadId, localTurnEvents))) {
+        if ((await completedSideEffectInCurrentTurn(opts.threadId, opts.turnId, localTurnEvents)) === "none") {
             opts.send({ type: "clear" });
         }
         opts.send({