@agent-native/core 0.210.1-nightly-20261020124228 → 0.210.1

package/dist/server/agent-teams.js

@@ -5,7 +5,7 @@ import { resolveMainChatMaxOutputTokens } from "../agent/engine/output-tokens.js
 import { currentExecutionFence, withExecutionFence, withFencedExecutionWrite, } from "../agent/execution-fence.js";
 import { actionsToEngineTools, filterActionsByAllowedNames, filterInitialEngineTools, readPersistedAllowedActionNames, resolveAgentRequestReasoningEffort, } from "../agent/production-agent.js";
 import { runAgentLoop, appendAgentLoopContinuation, } from "../agent/production-agent.js";
-import { abortRun, getActiveRunForThreadAsync, getRun, startRun, subscribeToRun, } from "../agent/run-manager.js";
+import { abortRun, abortRunDurably, getActiveRunForThreadAsync, getRun, startRun, subscribeToRun, } from "../agent/run-manager.js";
 import { ensureRunTables, getRunEventsSince, lockTaskExecutionLease, revokeTaskExecutionLease, } from "../agent/run-store.js";
 import { buildAssistantMessageFromRunJournal } from "../agent/run-thread-projector.js";
 import { resolveMaxSubagentDelegationDepth } from "../agent/runtime-context.js";
@@ -466,6 +466,8 @@ async function failReconciledTask(task, ownerEmail, message, progressStatus = "f
             ? undefined
             : structuredClone(currentTask);
         Object.assign(task, currentTask);
+        if (task.stopRequestedAt !== undefined)
+            return false;
         cancelled ||= isCancelledAgentTask(task);
         terminalProgressStatus = cancelled ? "cancelled" : progressStatus;
         task.status = "errored";
@@ -1407,6 +1409,9 @@ async function stopAgentTeamRunAfterActionPersistenceError(task, claimedAttempts
 }
 async function finalizeAgentTeamRun(task, run, ownerEmail, fullText, options) {
     const result = await withCurrentAgentTeamRunAttempt(task.taskId, options.claimedAttempts, async () => {
+        const currentTask = await loadTask(task.taskId);
+        if (currentTask && currentTask.stopRequestedAt !== undefined)
+            return null;
         if (options.hitContinuationLimit) {
             await bumpAgentTeamContinuation(task.taskId, options.claimedAttempts, {
                 requeue: false,
@@ -1573,6 +1578,13 @@ export async function processAgentTeamRun(opts) {
             await completeAgentTeamRun(opts.taskId, task.status === "completed" ? "done" : "failed", claimed.attempts);
             return { ok: true, skipped: "task-terminal" };
         }
+        if (task.stopRequestedAt !== undefined) {
+            const stopped = await stopAgentTeamBackgroundRun(runId, task.stopRequestedReason ?? "user");
+            if (!stopped.ok) {
+                throw new Error("The persisted agent task stop could not be resumed.");
+            }
+            return { ok: true, skipped: "stop-reconciled" };
+        }
         const ownerEmail = claimed.ownerEmail ?? getRequestUserEmail() ?? "";
         const orgId = claimed.orgId;
         const turnId = payload.turnId || taskRunId(opts.taskId);
@@ -1591,6 +1603,11 @@ export async function processAgentTeamRun(opts) {
                 ? `Failed to prepare sub-agent: ${err.message}`
                 : "Failed to prepare sub-agent.";
             await failReconciledTask(task, ownerEmail || null, message, "failed", claimed, false);
+            const latestTask = await loadTask(opts.taskId);
+            if (latestTask?.stopRequestedAt !== undefined ||
+                latestTask?.terminalProgressStatus === "cancelled") {
+                return { ok: true, skipped: "stop-requested" };
+            }
             return { ok: false, skipped: "config-failed" };
         }
         const mode = opts.mode ?? (claimed.continuationCount > 0 ? "continue" : "start");
@@ -1630,19 +1647,54 @@ export async function processAgentTeamRun(opts) {
         if (leaseLost)
             return { ok: true, skipped: "superseded" };
         const started = await withCurrentAgentTeamRunAttempt(opts.taskId, claimedAttempts, async () => {
-            task.currentStep =
-                mode === "continue"
-                    ? "Continuing sub-agent"
-                    : "Working on response";
-            task.startedAt = task.startedAt ?? Date.now();
-            await saveTask(task);
-            if (ownerEmail)
-                await updateTaskProgressRun(task, ownerEmail);
+            for (let attempt = 0; attempt < 3; attempt += 1) {
+                const currentTask = await loadTask(opts.taskId);
+                if (!currentTask || currentTask.status !== "running") {
+                    return { saved: false, task: currentTask };
+                }
+                if (currentTask.stopRequestedAt !== undefined) {
+                    return { saved: false, task: currentTask };
+                }
+                const expectedTask = structuredClone(currentTask);
+                const transcriptRunIds = [
+                    ...new Set([
+                        ...(currentTask.transcriptRunIds ?? []),
+                        ...(task.transcriptRunIds ?? []),
+                    ]),
+                ];
+                if (transcriptRunIds.length > 0) {
+                    currentTask.transcriptRunIds = transcriptRunIds;
+                }
+                currentTask.currentStep =
+                    mode === "continue"
+                        ? "Continuing sub-agent"
+                        : "Working on response";
+                currentTask.startedAt = currentTask.startedAt ?? Date.now();
+                if (await saveTaskIfCurrent(currentTask, expectedTask)) {
+                    Object.assign(task, currentTask);
+                    if (ownerEmail) {
+                        await updateTaskProgressRun(currentTask, ownerEmail);
+                    }
+                    return { saved: true, task: currentTask };
+                }
+            }
+            const currentTask = await loadTask(opts.taskId);
+            return { saved: false, task: currentTask };
         });
         if (!started.current) {
             markLeaseLost();
             return { ok: true, skipped: "superseded" };
         }
+        if (!started.value?.saved) {
+            const currentTask = started.value?.task;
+            if (currentTask?.stopRequestedAt !== undefined) {
+                return { ok: true, skipped: "stop-requested" };
+            }
+            if (currentTask?.status !== "running") {
+                return { ok: true, skipped: "task-terminal" };
+            }
+            throw new Error("The agent task changed repeatedly before the worker could start.");
+        }
         let accumulatedText = "";
         let lastProgressSent = 0;
         const PROGRESS_INTERVAL_MS = 2000;
@@ -1651,21 +1703,28 @@ export async function processAgentTeamRun(opts) {
         let progressWriteChain = Promise.resolve();
         let continuationDispatch;
         const scheduleProgressWrite = () => {
-            const snapshot = {
-                ...task,
-                ...(task.transcriptRunIds
-                    ? { transcriptRunIds: [...task.transcriptRunIds] }
-                    : {}),
+            const progress = {
+                preview: task.preview,
+                currentStep: task.currentStep,
             };
             progressWriteChain = progressWriteChain
                 .then(async () => {
                 if (leaseLost)
                     return;
                 const result = await withCurrentAgentTeamRunAttempt(opts.taskId, claimedAttempts, async () => {
-                    await saveTask(snapshot);
-                    if (ownerEmail) {
-                        await updateTaskProgressRun(snapshot, ownerEmail);
+                    const currentTask = await loadTask(opts.taskId);
+                    if (!currentTask || currentTask.status !== "running") {
+                        return false;
                     }
+                    const expectedTask = structuredClone(currentTask);
+                    currentTask.preview = progress.preview;
+                    currentTask.currentStep = progress.currentStep;
+                    if (!(await saveTaskIfCurrent(currentTask, expectedTask))) {
+                        return false;
+                    }
+                    if (ownerEmail)
+                        await updateTaskProgressRun(currentTask, ownerEmail);
+                    return true;
                 });
                 if (!result.current)
                     markLeaseLost();
@@ -1677,6 +1736,25 @@ export async function processAgentTeamRun(opts) {
         await new Promise((resolve) => {
             const startedRun = startRun(runId, task.threadId, async (send, signal, control) => {
                 workerExecutionFence = currentExecutionFence();
+                const dispatchReady = await withCurrentAgentTeamRunAttempt(opts.taskId, claimedAttempts, async () => {
+                    const currentTask = await loadTask(opts.taskId);
+                    return {
+                        allowed: currentTask?.status === "running" &&
+                            currentTask.stopRequestedAt === undefined,
+                        stopRequested: currentTask?.stopRequestedAt !== undefined,
+                        stopReason: currentTask?.stopRequestedReason,
+                    };
+                });
+                if (!dispatchReady.current || !dispatchReady.value.allowed) {
+                    const currentTask = await loadTask(opts.taskId);
+                    const reason = dispatchReady.current && dispatchReady.value.stopRequested
+                        ? (dispatchReady.value.stopReason ?? "user")
+                        : currentTask && isCancelledAgentTask(currentTask)
+                            ? (currentTask?.stopRequestedReason ?? "user")
+                            : "superseded";
+                    markLeaseLost(reason);
+                    return;
+                }
                 const wrappedSend = (event) => {
                     if (leaseLost)
                         return Promise.resolve();
@@ -1730,6 +1808,34 @@ export async function processAgentTeamRun(opts) {
                         actions: messageAwareActions,
                         send: wrappedSend,
                         beforeWrite: control.flushEvents,
+                        beforeModelDispatch: async (dispatch) => {
+                            const current = await withCurrentAgentTeamRunAttempt(opts.taskId, claimedAttempts, async () => {
+                                const currentTask = await loadTask(opts.taskId);
+                                if (currentTask?.status === "running" &&
+                                    currentTask.stopRequestedAt === undefined) {
+                                    return {
+                                        allowed: true,
+                                        result: {
+                                            started: true,
+                                            value: dispatch(),
+                                        },
+                                    };
+                                }
+                                return { allowed: false, task: currentTask };
+                            });
+                            if (current.current && current.value.allowed)
+                                return current.value.result;
+                            const currentTask = current.current
+                                ? current.value.task
+                                : await loadTask(opts.taskId);
+                            const reason = currentTask &&
+                                (currentTask.stopRequestedAt !== undefined ||
+                                    isCancelledAgentTask(currentTask))
+                                ? (currentTask.stopRequestedReason ?? "user")
+                                : "superseded";
+                            markLeaseLost(reason);
+                            return { started: false };
+                        },
                         signal,
                         finalResponseGuard: createTaskMessageFinalGuard(opts.taskId),
                     };
@@ -2146,10 +2252,13 @@ async function controlAgentTeamBackgroundAgentRun(input) {
 export async function stopAgentTeamBackgroundRun(runId, reason = "user", scope) {
     const taskId = await resolveTaskIdFromBackgroundRunId(runId);
     const ownerScope = resolveOwnerScope(scope);
-    const markStopped = (currentTask) => {
+    const markStopped = (currentTask, stopReason) => {
+        delete currentTask.stopRequestedAt;
+        delete currentTask.stopRequestedRunId;
+        delete currentTask.stopRequestedReason;
         currentTask.status = "errored";
         currentTask.summary =
-            reason === "user" ? "Task stopped." : `Task stopped: ${reason}`;
+            stopReason === "user" ? "Task stopped." : `Task stopped: ${stopReason}`;
         currentTask.error = currentTask.summary;
         currentTask.currentStep = "";
         currentTask.completedAt = Date.now();
@@ -2159,7 +2268,6 @@ export async function stopAgentTeamBackgroundRun(runId, reason = "user", scope)
         currentTask.parentCompletionEnqueued = !currentTask.parentThreadId;
     };
     let stoppedTask = null;
-    let stoppedDispatch = null;
     for (let retry = 0; retry < 3 && !stoppedTask; retry += 1) {
         const task = await loadTask(taskId);
         if (!task || !taskMatchesOwnerScope(task, ownerScope)) {
@@ -2175,15 +2283,54 @@ export async function stopAgentTeamBackgroundRun(runId, reason = "user", scope)
             return { ok: false, error: "Task is not running" };
         }
         if (dispatch) {
+            const runId = taskRunChunkId(taskId, dispatch.continuationCount, dispatch.attempts);
+            let stopRequestedAt;
+            let stopRequestedRunId;
+            let stopRequestedReason;
+            const current = await withCurrentAgentTeamRunAttempt(taskId, dispatch.attempts, async () => {
+                const currentTask = await loadTask(taskId);
+                if (currentTask &&
+                    taskMatchesOwnerScope(currentTask, ownerScope) &&
+                    currentTask.status === "running") {
+                    const expectedTask = structuredClone(currentTask);
+                    currentTask.stopRequestedAt ??= Date.now();
+                    stopRequestedAt = currentTask.stopRequestedAt;
+                    currentTask.stopRequestedRunId ??= runId;
+                    stopRequestedRunId = currentTask.stopRequestedRunId;
+                    currentTask.stopRequestedReason ??= reason;
+                    stopRequestedReason = currentTask.stopRequestedReason;
+                    return saveTaskIfCurrent(currentTask, expectedTask);
+                }
+                return false;
+            }, { statuses: ["queued", "running"] });
+            if (!current.current ||
+                !current.value ||
+                stopRequestedAt === undefined ||
+                stopRequestedRunId === undefined ||
+                stopRequestedReason === undefined)
+                continue;
+            const requestedAt = stopRequestedAt;
+            const requestedRunId = stopRequestedRunId;
+            const requestedReason = stopRequestedReason;
+            // Keep retries pointed at the original run after the queue attempt is reclaimed.
+            await abortRunDurably(requestedRunId, requestedReason, {
+                allowNotStarted: true,
+            });
             const result = await withCurrentAgentTeamRunAttempt(taskId, dispatch.attempts, async () => {
                 const currentTask = await loadTask(taskId);
                 if (!currentTask ||
                     !taskMatchesOwnerScope(currentTask, ownerScope) ||
-                    currentTask.status !== "running") {
+                    currentTask.status !== "running" ||
+                    currentTask.stopRequestedAt !== requestedAt ||
+                    currentTask.stopRequestedRunId !== requestedRunId ||
+                    currentTask.stopRequestedReason !== requestedReason) {
+                    return null;
+                }
+                const expectedTask = structuredClone(currentTask);
+                markStopped(currentTask, requestedReason);
+                if (!(await saveTaskIfCurrent(currentTask, expectedTask))) {
                     return null;
                 }
-                markStopped(currentTask);
-                await saveTask(currentTask);
                 if (!(await completeAgentTeamRun(taskId, "failed", dispatch.attempts))) {
                     throw new Error("The agent task run changed before it could stop.");
                 }
@@ -2191,22 +2338,37 @@ export async function stopAgentTeamBackgroundRun(runId, reason = "user", scope)
             }, { statuses: ["queued", "running"] });
             if (result.current && result.value) {
                 stoppedTask = result.value;
-                stoppedDispatch = dispatch;
             }
             continue;
         }
         const expectedTask = structuredClone(task);
-        markStopped(task);
-        if (await saveTaskIfCurrent(task, expectedTask)) {
-            stoppedTask = task;
+        const stopRequestedTask = {
+            ...task,
+            stopRequestedAt: task.stopRequestedAt ?? Date.now(),
+            stopRequestedRunId: task.stopRequestedRunId ?? runningInMemoryTaskRunId(taskId),
+            stopRequestedReason: task.stopRequestedReason ?? reason,
+        };
+        if (!(await saveTaskIfCurrent(stopRequestedTask, expectedTask)))
+            continue;
+        await abortRunDurably(stopRequestedTask.stopRequestedRunId, stopRequestedTask.stopRequestedReason, { allowNotStarted: true });
+        const currentTask = await loadTask(taskId);
+        if (!currentTask ||
+            !taskMatchesOwnerScope(currentTask, ownerScope) ||
+            currentTask.status !== "running" ||
+            currentTask.stopRequestedAt !== stopRequestedTask.stopRequestedAt ||
+            currentTask.stopRequestedRunId !== stopRequestedTask.stopRequestedRunId ||
+            currentTask.stopRequestedReason !== stopRequestedTask.stopRequestedReason) {
+            return { ok: false, error: "Task is not running" };
+        }
+        const expectedStopRequestedTask = structuredClone(currentTask);
+        markStopped(currentTask, stopRequestedTask.stopRequestedReason);
+        if (await saveTaskIfCurrent(currentTask, expectedStopRequestedTask)) {
+            stoppedTask = currentTask;
         }
     }
     if (!stoppedTask) {
         return { ok: false, error: "Task is not running" };
     }
-    abortRun(stoppedDispatch
-        ? taskRunChunkId(taskId, stoppedDispatch.continuationCount, stoppedDispatch.attempts)
-        : runningInMemoryTaskRunId(taskId), reason);
     const ownerEmail = getRequestUserEmail();
     if (ownerEmail) {
         await completeTaskProgressRun(stoppedTask, ownerEmail, "cancelled", stoppedTask.summary);

package/package.json

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