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

package/dist/observability/routes.d.ts

@@ -27,39 +27,39 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
-    ok?: undefined;
     error: string;
     message: string;
     summary?: undefined;
     spans?: undefined;
+    ok?: undefined;
 } | {
     error?: undefined;
-    ok?: undefined;
     message?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
+    ok?: undefined;
 } | {
     error?: undefined;
-    ok?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing: true;
     id: string;
+    ok?: undefined;
 } | {
     error?: undefined;
-    ok?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing?: undefined;
     id: string;
-} | {
     ok?: undefined;
+} | {
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     error: any;
+    ok?: undefined;
 } | {
     error?: undefined;
     message?: undefined;

package/dist/progress/routes.d.ts

@@ -2,6 +2,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;

package/dist/secrets/routes.d.ts

@@ -57,31 +57,31 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
 } | {
     error: string;
     errorCode?: undefined;
-    ok?: undefined;
     status?: undefined;
+    ok?: undefined;
 } | {
     error: string;
     errorCode: string;
-    ok?: undefined;
     status?: undefined;
+    ok?: undefined;
 } | {
     error?: undefined;
     errorCode?: undefined;
     ok: boolean;
     status: string;
 } | {
-    ok?: undefined;
     error: string;
     removed?: undefined;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;
     removed: boolean;
 }>>;
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
     note?: undefined;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/server/agent-chat-plugin.js

@@ -20,7 +20,7 @@ import { SYSTEM_PROMPT_CACHE_SPLIT } from "../agent/engine/prompt-cache.js";
 import { PROVIDER_TO_ENV } from "../agent/engine/provider-env-vars.js";
 import { currentExecutionFence, withExecutionFence, } from "../agent/execution-fence.js";
 import { hostedHarnessSystemPrompt } from "../agent/harness/hosted.js";
-import { createProductionAgentHandler, endsAtContinuationBoundary, actionsToEngineTools, executeAgentToolCall, filterActionsByAllowedNames, normalizeAgentActionSurfaceResolution, getActiveRunForThreadAsync, abortRunDurably, abortRunAtSafeBoundaryDurably, abortTurnByRefDurably, abortTurnDurably, subscribeToRun, } from "../agent/production-agent.js";
+import { createProductionAgentHandler, endsAtContinuationBoundary, actionsToEngineTools, executeAgentToolCall, filterActionsByAllowedNames, normalizeAgentActionSurfaceResolution, getActiveRunForThreadAsync, abortRunDurably, abortRunAndTurnDurably, abortRunAtSafeBoundaryDurably, abortTurnByRefDurably, abortTurnDurably, subscribeToRun, } from "../agent/production-agent.js";
 import { applyProviderModelSelection, providerForEngineName, resolveProviderModelSelectionAtScope, } from "../agent/provider-model-selection.js";
 import { startRun } from "../agent/run-manager.js";
 import { callerHasRunAccess, callerHasThreadAccess, } from "../agent/run-ownership.js";
@@ -420,7 +420,7 @@ export async function runA2AAgentLoopWithRunManager(runOptions, pluginOptions, t
         model: runOptions.model,
         engineName: runOptions.engine.name,
     });
-    let cancellation = Promise.resolve(false);
+    let cancellation = Promise.resolve({ status: "fulfilled", aborted: false });
     const abortFromTask = () => {
         const reason = taskSignal?.reason;
         const reasonCode = reason && typeof reason === "object" && "code" in reason
@@ -431,7 +431,7 @@ export async function runA2AAgentLoopWithRunManager(runOptions, pluginOptions, t
             run.abort.abort("execution_lease_lost");
             return;
         }
-        cancellation = abortRunDurably(runId, clientAbortReason(reason));
+        cancellation = abortRunDurably(runId, clientAbortReason(reason)).then((aborted) => ({ status: "fulfilled", aborted }), (error) => ({ status: "rejected", error }));
     };
     if (taskSignal?.aborted) {
         abortFromTask();
@@ -440,8 +440,17 @@ export async function runA2AAgentLoopWithRunManager(runOptions, pluginOptions, t
         taskSignal?.addEventListener("abort", abortFromTask, { once: true });
     }
     try {
-        await run.finalized;
-        await cancellation;
+        const finalization = await run.finalized.then(() => ({ status: "fulfilled" }), (error) => ({ status: "rejected", error }));
+        const cancellationResult = await cancellation;
+        if (finalization.status === "rejected" &&
+            cancellationResult.status === "rejected") {
+            throw new AggregateError([finalization.error, cancellationResult.error], "A2A run finalization and durable cancellation both failed");
+        }
+        if (finalization.status === "rejected")
+            throw finalization.error;
+        if (cancellationResult.status === "rejected") {
+            throw cancellationResult.error;
+        }
     }
     finally {
         taskSignal?.removeEventListener("abort", abortFromTask);
@@ -5262,10 +5271,15 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                         // Empty/invalid body — keep the default user abort reason.
                     }
                     if (safeBoundary) {
-                        const aborted = await abortRunAtSafeBoundaryDurably(runId, reason);
-                        if (USER_STOP_ABORT_REASONS.has(reason)) {
-                            const latest = aborted ? null : await getRunById(runId);
-                            if (aborted || latest?.status === "aborted") {
+                        const isUserStop = USER_STOP_ABORT_REASONS.has(reason);
+                        const aborted = isUserStop
+                            ? await abortRunAndTurnDurably(runId, reason, {
+                                safeBoundary: true,
+                            })
+                            : await abortRunAtSafeBoundaryDurably(runId, reason);
+                        if (isUserStop && !aborted) {
+                            const latest = await getRunById(runId);
+                            if (latest?.status === "aborted") {
                                 await abortTurnDurably(runId, reason);
                             }
                         }
@@ -5274,9 +5288,11 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     // Recovery starts as soon as this response resolves, so wait for
                     // the cross-isolate abort + terminal event to be durable. Returning
                     // early lets Retry collide with the still-running row.
-                    await abortRunDurably(runId, reason);
                     if (USER_STOP_ABORT_REASONS.has(reason)) {
-                        await abortTurnDurably(runId, reason);
+                        await abortRunAndTurnDurably(runId, reason);
+                    }
+                    else {
+                        await abortRunDurably(runId, reason);
                     }
                     return { ok: true };
                 }

package/dist/server/agent-engine-api-key-route.d.ts

@@ -66,6 +66,7 @@ export declare function createAgentEngineApiKeyHandler(): import("h3").EventHand
     error: any;
     code: any;
 } | {
+    error?: undefined;
     errorCode?: undefined;
     code?: undefined;
     ok: boolean;
@@ -73,6 +74,5 @@ export declare function createAgentEngineApiKeyHandler(): import("h3").EventHand
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
     defaultModel?: import("./agent-engine-default-model-route.js").SavedKeyDefaultModelOutcome;
-    error?: undefined;
 }>>;
 export {};

package/dist/server/agent-engine-default-model-route.d.ts

@@ -8,8 +8,8 @@ export declare const AGENT_ENGINE_API_KEY_ACTION_NAME = "agent-engine-api-key";
  * resolveEngine's credential detection.
  */
 export declare function createAgentEngineDisconnectHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
     scope?: undefined;
 } | {
     ok: boolean;

package/dist/server/agent-engine-ollama-models-route.d.ts

@@ -1,9 +1,9 @@
 export declare function createAgentEngineOllamaModelsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    ok?: undefined;
     models?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     models: string[];
+    error?: undefined;
 }>>;

package/dist/server/agent-teams.d.ts

@@ -44,6 +44,9 @@ export interface AgentTask {
     terminalEffectsVersion?: 1;
     terminalEffectsReconciled?: boolean;
     terminalProgressStatus?: TerminalProgressStatus;
+    stopRequestedAt?: number;
+    stopRequestedRunId?: string;
+    stopRequestedReason?: string;
 }
 export interface AgentTeamOwnerScope {
     ownerEmail: string | null;

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.2",
   "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.2",
+    "@agent-native/recap-cli": "^0.5.77"
   },
   "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",