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

package/dist/agent/run-store.js

@@ -14,7 +14,7 @@ import { approvalKeyForHistory } from "./approval-key.js";
 import { admitAutoContinue, admitManualContinue, } from "./auto-continue.js";
 import { AGENT_CHAT_RECOVERY_OF_RUN_FIELD } from "./durable-background.js";
 import { LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, } from "./engine/credential-errors.js";
-import { currentExecutionFence, ExecutionFenceError, MissingExecutionFenceError, lockAndAssertCurrentExecutionFences, StaleExecutionFenceError, withFencedExecutionWrite, } from "./execution-fence.js";
+import { currentExecutionFence, currentExecutionFenceForScope, ExecutionFenceError, MissingExecutionFenceError, lockAndAssertCurrentExecutionFences, StaleExecutionFenceError, withFencedExecutionWrite, } from "./execution-fence.js";
 import { AGENT_RUN_MIGRATIONS, AGENT_RUN_MIGRATIONS_TABLE, } from "./run-migrations.js";
 import { isConsistentToolCallInputFingerprint, isUnavailableToolCallInput, toolCallInputFingerprint, } from "./tool-call-journal.js";
 import { CONTINUATION_REASONS, isContinuationTerminalReason } from "./types.js";
@@ -2228,32 +2228,51 @@ export async function reapIfStale(runId, maxStaleMs) {
 export async function reapUnclaimedBackgroundRun(runId) {
     await ensureRunTables();
     const client = getDbExec();
+    if (!client.transaction) {
+        throw new Error("Atomic unclaimed-background reaping requires transaction support");
+    }
     const completedAt = Date.now();
     const cutoff = completedAt - UNCLAIMED_BACKGROUND_RUN_GRACE_MS;
-    const { rowsAffected } = await client.execute({
-        sql: `UPDATE agent_runs
-          SET status = 'errored',
-              completed_at = ?,
-              error_code = ?,
-              error_detail = ?,
-              terminal_reason = ?
-          WHERE id = ?
-            AND status = 'running'
-            AND dispatch_mode = 'background'
-            AND COALESCE(heartbeat_at, started_at) < ?`,
-        args: [
-            completedAt,
-            UNCLAIMED_BACKGROUND_RUN_ERROR_EVENT.errorCode,
-            UNCLAIMED_BACKGROUND_RUN_ERROR_EVENT.details,
-            UNCLAIMED_BACKGROUND_RUN_ERROR_EVENT.errorCode,
-            runId,
-            cutoff,
-        ],
+    const reaped = await client.transaction(async (tx) => {
+        const { rowsAffected } = await tx.execute({
+            sql: `UPDATE agent_runs
+            SET status = 'errored',
+                completed_at = ?,
+                error_code = ?,
+                error_detail = ?,
+                terminal_reason = ?
+            WHERE id = ?
+              AND status = 'running'
+              AND dispatch_mode = 'background'
+              AND COALESCE(heartbeat_at, started_at) < ?`,
+            args: [
+                completedAt,
+                UNCLAIMED_BACKGROUND_RUN_ERROR_EVENT.errorCode,
+                UNCLAIMED_BACKGROUND_RUN_ERROR_EVENT.details,
+                UNCLAIMED_BACKGROUND_RUN_ERROR_EVENT.errorCode,
+                runId,
+                cutoff,
+            ],
+        });
+        const updated = (rowsAffected ?? 0) > 0;
+        if (updated) {
+            await appendTerminalRunEventInTransaction(tx, runId, UNCLAIMED_BACKGROUND_RUN_ERROR_EVENT);
+        }
+        return updated;
     });
-    const reaped = (rowsAffected ?? 0) > 0;
     if (reaped) {
-        await recordRunDiagnostic(runId, RUN_DIAG_STAGE.workerThrew, "unclaimed background dispatch reaped (worker never claimed the run)");
-        await safeAppendTerminalRunEvent(runId, UNCLAIMED_BACKGROUND_RUN_ERROR_EVENT, "reap-unclaimed-background");
+        try {
+            await recordRunDiagnostic(runId, RUN_DIAG_STAGE.workerThrew, "unclaimed background dispatch reaped (worker never claimed the run)");
+        }
+        catch (error) {
+            captureError(error, {
+                tags: {
+                    component: "agent-run-store",
+                    operation: "record-unclaimed-background-reap-diagnostic",
+                },
+                extra: { runId },
+            });
+        }
     }
     return reaped;
 }
@@ -2478,7 +2497,7 @@ export function terminalEventForAbortReason(reason) {
     };
 }
 export async function markRunAborted(runId, reason) {
-    await updateRunAborted(runId, reason, false);
+    return updateRunAborted(runId, reason, false);
 }
 /** Abort only when no model or tool work has crossed its dispatch boundary. */
 export async function markRunAbortedAtSafeBoundary(runId, reason) {
@@ -2486,22 +2505,32 @@ export async function markRunAbortedAtSafeBoundary(runId, reason) {
 }
 async function updateRunAborted(runId, reason, requireSafeBoundary) {
     await ensureRunTables();
+    const fence = currentExecutionFenceForScope({ runId });
     const client = getDbExec();
     if (!client.transaction) {
         throw new Error("Atomic run cancellation requires transaction support");
     }
-    const rowsAffected = await client.transaction(async (tx) => {
+    const abortResult = await client.transaction(async (tx) => {
         await lockExecutionLeasesForRuns(tx, [runId]);
+        await lockAndAssertCurrentExecutionFences(tx);
+        const runResult = await tx.execute({
+            sql: `SELECT thread_id, COALESCE(turn_id, id) AS turn_id,
+                   worker_generation
+            FROM agent_runs WHERE id = ? FOR UPDATE`,
+            args: [runId],
+        });
+        const lockedRun = runResult.rows[0];
+        if (fence &&
+            (lockedRun?.thread_id !== fence.threadId ||
+                lockedRun.turn_id !== fence.turnId ||
+                lockedRun.worker_generation == null ||
+                String(lockedRun.worker_generation) !== fence.generation)) {
+            throw new StaleExecutionFenceError(fence);
+        }
         if (requireSafeBoundary) {
-            const run = await tx.execute({
-                sql: `SELECT thread_id, COALESCE(turn_id, id) AS turn_id
-              FROM agent_runs WHERE id = ?`,
-                args: [runId],
-            });
-            const runRef = run.rows[0];
-            if (runRef) {
-                if (typeof runRef.thread_id !== "string" ||
-                    typeof runRef.turn_id !== "string") {
+            if (lockedRun) {
+                if (typeof lockedRun.thread_id !== "string" ||
+                    typeof lockedRun.turn_id !== "string") {
                     throw new Error(`Run ${runId} has an invalid thread or turn ID`);
                 }
                 const dispatchedStep = await tx.execute({
@@ -2509,10 +2538,11 @@ async function updateRunAborted(runId, reason, requireSafeBoundary) {
                 WHERE thread_id = ? AND turn_id = ? AND status = 'dispatched'
                   AND run_id = ?
                 LIMIT 1`,
-                    args: [runRef.thread_id, runRef.turn_id, runId],
+                    args: [lockedRun.thread_id, lockedRun.turn_id, runId],
                 });
-                if (dispatchedStep.rows.length > 0)
-                    return 0;
+                if (dispatchedStep.rows.length > 0) {
+                    return { rowsAffected: 0, appendTerminalEvent: false };
+                }
             }
         }
         const result = await tx.execute({
@@ -2524,15 +2554,32 @@ async function updateRunAborted(runId, reason, requireSafeBoundary) {
                 runId,
             ],
         });
-        if ((result.rowsAffected ?? 0) > 0) {
+        const rowsAffected = result.rowsAffected ?? 0;
+        if (rowsAffected > 0) {
             await revokeExecutionLeasesForRuns(tx, [runId]);
+            return { rowsAffected, appendTerminalEvent: true };
         }
-        return result.rowsAffected ?? 0;
+        const terminalState = await tx.execute({
+            sql: `SELECT status, terminal_reason, in_flight_since FROM agent_runs WHERE id = ?`,
+            args: [runId],
+        });
+        const terminalRun = terminalState.rows[0];
+        return {
+            rowsAffected,
+            appendTerminalEvent: terminalRun?.status === "aborted" &&
+                terminalRun.terminal_reason === `aborted:${reason ?? "user"}` &&
+                (!requireSafeBoundary || terminalRun.in_flight_since == null),
+        };
     });
-    if ((rowsAffected ?? 0) > 0) {
-        await safeAppendTerminalRunEvent(runId, terminalEventForAbortReason(reason), "mark-aborted");
+    if (abortResult.appendTerminalEvent) {
+        try {
+            await safeAppendTerminalRunEvent(runId, terminalEventForAbortReason(reason), "mark-aborted");
+        }
+        catch (error) {
+            throw new AgentRunEventNotPersistedError(runId, null, true, error);
+        }
     }
-    return (rowsAffected ?? 0) > 0;
+    return abortResult.rowsAffected > 0 || abortResult.appendTerminalEvent;
 }
 async function lockExecutionLeasesForRuns(db, runIds) {
     const ids = [...new Set(runIds)].sort();
@@ -2612,6 +2659,7 @@ export async function markTurnAborted(threadId, turnId, reason = "user") {
             sql: "SELECT pg_advisory_xact_lock(hashtextextended(?, 0::bigint))",
             args: [`agent-native:run-slot:${threadId}`],
         });
+        await lockAndAssertCurrentExecutionFences(tx);
         const lease = await lockTurnExecutionLease(tx, threadId, turnId);
         if (fence &&
             (!lease ||
@@ -2640,7 +2688,7 @@ export async function markTurnAborted(threadId, turnId, reason = "user") {
         }
         if (runIds.length === 0) {
             const existing = await tx.execute({
-                sql: `SELECT id, terminal_reason,
+                sql: `SELECT id, status, terminal_reason,
                      EXISTS (
                        SELECT 1 FROM agent_run_events
                        WHERE agent_run_events.run_id = agent_runs.id
@@ -2661,6 +2709,17 @@ export async function markTurnAborted(threadId, turnId, reason = "user") {
                 ],
             });
             const latest = existing.rows[0];
+            const aborted = await tx.execute({
+                sql: `SELECT id FROM agent_runs
+              WHERE thread_id = ? AND COALESCE(turn_id, id) = ?
+                AND status = 'aborted'
+                AND dispatch_mode IS DISTINCT FROM 'turn-abort'
+                AND terminal_reason = ?`,
+                args: [threadId, turnId, `aborted:${reason}`],
+            });
+            runIds.push(...aborted.rows
+                .map((row) => String(row.id ?? ""))
+                .filter(Boolean));
             if (latest &&
                 latest.continuation_pending !== true &&
                 !isContinuationTerminalReason(latest.terminal_reason ?? "")) {
@@ -2692,8 +2751,6 @@ export async function markTurnAborted(threadId, turnId, reason = "user") {
         });
         return "aborted";
     });
-    if (outcome === "already_terminal")
-        return outcome;
     await Promise.all(runIds.map((runId) => safeAppendTerminalRunEvent(runId, terminalEventForAbortReason(reason), "mark-turn-aborted")));
     return outcome;
 }
@@ -2767,40 +2824,100 @@ function persistedRunEventData(eventData, inputSource) {
     });
 }
 export class AgentRunEventNotPersistedError extends Error {
-    constructor(runId, seq) {
-        super(`Run event was not persisted: ${runId} sequence ${seq}`);
+    terminalRun;
+    constructor(runId, seq, terminalRun = false, cause) {
+        const detail = cause instanceof Error ? `: ${cause.message}` : "";
+        super(seq === null
+            ? `Terminal run event was not persisted: ${runId}${detail}`
+            : `Run event was not persisted: ${runId} sequence ${seq}${detail}`);
         this.name = "AgentRunEventNotPersistedError";
+        this.terminalRun = terminalRun;
+        if (cause !== undefined) {
+            Object.defineProperty(this, "cause", {
+                value: cause,
+                configurable: true,
+            });
+        }
     }
 }
 export async function insertRunEvent(runId, seq, eventData, options) {
     await ensureRunTables();
     const storedEventData = persistedRunEventData(eventData, options?.toolInputSource);
+    const eventAt = options?.eventAt ?? Date.now();
     // The reaper must wait for the marker's commit before exposing a successor.
-    const { rowsAffected } = await withFencedExecutionWrite((tx) => tx.execute({
-        sql: options?.requireInserted
-            ? `WITH running_run AS MATERIALIZED (
+    let result;
+    try {
+        result = await withFencedExecutionWrite(async (tx) => {
+            const { rowsAffected } = await tx.execute({
+                sql: options?.requireInserted
+                    ? `WITH running_run AS MATERIALIZED (
           SELECT id FROM agent_runs WHERE id = ? AND status = 'running' FOR UPDATE
         )
         INSERT INTO agent_run_events (run_id, seq, event_at, event_data)
         SELECT id, ?, ?, ? FROM running_run LIMIT 1
         ON CONFLICT (run_id, seq) DO NOTHING`
-            : `INSERT INTO agent_run_events (run_id, seq, event_at, event_data)
+                    : `INSERT INTO agent_run_events (run_id, seq, event_at, event_data)
       SELECT ?, ?, ?, ?
       WHERE NOT EXISTS (
         SELECT 1 FROM agent_runs
         WHERE id = ? AND status <> 'running'
       )
       ON CONFLICT (run_id, seq) DO NOTHING`,
-        args: [
-            runId,
-            seq,
-            options?.eventAt ?? Date.now(),
-            storedEventData,
-            ...(options?.requireInserted ? [] : [runId]),
-        ],
-    }), { runId });
-    if (options?.requireInserted && rowsAffected !== 1)
-        throw new AgentRunEventNotPersistedError(runId, seq);
+                args: [
+                    runId,
+                    seq,
+                    eventAt,
+                    storedEventData,
+                    ...(options?.requireInserted ? [] : [runId]),
+                ],
+            });
+            if (!options?.requireInserted || rowsAffected === 1)
+                return {
+                    rowsAffected,
+                    terminalRun: false,
+                    persistedIdentically: rowsAffected === 1,
+                };
+            const existing = await tx.execute({
+                sql: `SELECT event_at, event_data FROM agent_run_events
+              WHERE run_id = ? AND seq = ?`,
+                args: [runId, seq],
+            });
+            const existingRow = existing.rows[0];
+            const persistedIdentically = existingRow !== undefined &&
+                Number(existingRow.event_at) === eventAt &&
+                String(existingRow.event_data) === storedEventData;
+            const run = await tx.execute({
+                sql: "SELECT status FROM agent_runs WHERE id = ?",
+                args: [runId],
+            });
+            const status = run.rows[0]?.status;
+            return {
+                rowsAffected,
+                terminalRun: status !== "running",
+                persistedIdentically,
+            };
+        }, { runId });
+    }
+    catch (error) {
+        if (error instanceof StaleExecutionFenceError) {
+            let status;
+            try {
+                status = await getRunStatus(runId);
+            }
+            catch (statusError) {
+                throw new AggregateError([error, statusError], `Could not confirm run status after a stale execution fence: ${runId}`);
+            }
+            if (status !== null && status !== "running") {
+                throw new AgentRunEventNotPersistedError(runId, seq, true, error);
+            }
+        }
+        throw error;
+    }
+    const { rowsAffected, terminalRun, persistedIdentically } = result;
+    if (options?.requireInserted &&
+        rowsAffected !== 1 &&
+        (!persistedIdentically || terminalRun))
+        throw new AgentRunEventNotPersistedError(runId, seq, terminalRun);
 }
 // Stays well under PostgreSQL's 65,535 bind-parameter limit at 4 per row.
 const RUN_EVENT_BATCH_ROWS = 500;
@@ -2812,9 +2929,13 @@ export async function insertRunEvents(runId, events) {
     if (events.length === 0)
         return;
     await ensureRunTables();
-    await withFencedExecutionWrite(async (tx) => {
+    const writeBatch = async (tx) => {
         for (let start = 0; start < events.length; start += RUN_EVENT_BATCH_ROWS) {
             const chunk = events.slice(start, start + RUN_EVENT_BATCH_ROWS);
+            const storedChunk = chunk.map((event) => ({
+                ...event,
+                eventData: persistedRunEventData(event.eventData),
+            }));
             await tx.execute({
                 sql: `INSERT INTO agent_run_events (run_id, seq, event_at, event_data)
         SELECT v.run_id, v.seq, v.event_at, v.event_data
@@ -2827,17 +2948,41 @@ export async function insertRunEvents(runId, events) {
         )
         ON CONFLICT (run_id, seq) DO NOTHING`,
                 args: [
-                    ...chunk.flatMap(({ seq, eventAt, eventData }) => [
+                    ...storedChunk.flatMap(({ seq, eventAt, eventData }) => [
                         runId,
                         seq,
                         eventAt,
-                        persistedRunEventData(eventData),
+                        eventData,
                     ]),
                     runId,
                 ],
             });
+            const persisted = await tx.execute({
+                sql: `SELECT seq, event_at, event_data
+                FROM agent_run_events
+                WHERE run_id = ? AND seq IN (${chunk.map(() => "?").join(", ")})`,
+                args: [runId, ...chunk.map(({ seq }) => seq)],
+            });
+            const persistedBySeq = new Map(persisted.rows.map((row) => [Number(row.seq), row]));
+            for (const event of storedChunk) {
+                const row = persistedBySeq.get(event.seq);
+                if (!row ||
+                    Number(row.event_at) !== event.eventAt ||
+                    String(row.event_data) !== event.eventData) {
+                    const run = await tx.execute({
+                        sql: "SELECT status FROM agent_runs WHERE id = ?",
+                        args: [runId],
+                    });
+                    const status = run.rows[0]
+                        ?.status;
+                    throw new AgentRunEventNotPersistedError(runId, event.seq, status !== "running");
+                }
+            }
         }
-    }, { runId });
+    };
+    await withFencedExecutionWrite((tx) => currentExecutionFence()
+        ? writeBatch(tx)
+        : (tx.transaction?.(writeBatch) ?? writeBatch(tx)), { runId });
 }
 export const CHECKPOINT_TERMINAL_EVENT_SEQ = 1_000_000_000;
 export async function persistRunCheckpointEvent(runId, event, terminalReason) {
@@ -3681,6 +3826,7 @@ async function safeAppendTerminalRunEvent(runId, event, source) {
                 firstError: firstError instanceof Error ? firstError.message : String(firstError),
             },
         });
+        throw retryErr;
     }
 }
 async function appendTerminalRunEvent(runId, event) {
@@ -3707,8 +3853,8 @@ async function appendTerminalRunEvent(runId, event) {
         }
     }
     const nextSeq = last ? Number(last.seq ?? -1) + 1 : 0;
-    await client.execute({
-        sql: `INSERT INTO agent_run_events (run_id, seq, event_at, event_data) VALUES (?, ?, ?, ?) ON CONFLICT (run_id, seq) DO NOTHING`,
+    const inserted = await client.execute({
+        sql: `INSERT INTO agent_run_events (run_id, seq, event_at, event_data) VALUES (?, ?, ?, ?) ON CONFLICT (run_id, seq) DO NOTHING RETURNING seq`,
         args: [
             runId,
             nextSeq,
@@ -3716,4 +3862,7 @@ async function appendTerminalRunEvent(runId, event) {
             stripInlineBytesFromJson(JSON.stringify(event), "placeholder"),
         ],
     });
+    if (inserted.rows.length === 0) {
+        throw new Error(`Run ${runId} terminal event conflicted with sequence ${nextSeq}`);
+    }
 }

package/dist/collab/awareness.d.ts

@@ -38,19 +38,19 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
+    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
-    error?: undefined;
 }>>;
 export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
     users?: undefined;
 } | {
+    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
-    error?: undefined;
 }>>;

package/dist/collab/struct-routes.d.ts

@@ -1,6 +1,6 @@
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/file-upload/actions/upload-image.d.ts

@@ -33,9 +33,9 @@ declare const _default: import("../../action.js").ActionDefinition<{
     idempotencyKey: string;
     deleted: boolean;
 } | {
+    id?: undefined;
     error: string;
     url?: undefined;
-    id?: undefined;
     provider?: undefined;
     configured?: undefined;
 } | {
@@ -45,8 +45,8 @@ declare const _default: import("../../action.js").ActionDefinition<{
     configured?: undefined;
     error?: undefined;
 } | {
-    url?: undefined;
     id?: undefined;
+    url?: undefined;
     provider?: undefined;
     error: string;
     configured: boolean;

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/org/index.d.ts

@@ -164,8 +164,8 @@ export declare const getMyOrgHandler: import("h3").EventHandlerWithFetch<import(
 export declare const createOrgHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     name?: undefined;
     success: boolean;
-    role?: undefined;
     id?: undefined;
+    role?: undefined;
 } | {
     success?: undefined;
     id: string;

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