@agent-native/core 0.130.0 → 0.130.1

package/dist/integrations/a2a-continuation-processor.js

@@ -5,8 +5,8 @@ import { extractThreadMeta } from "../agent/thread-data-builder.js";
 import { getThread, updateThreadData } from "../chat-threads/store.js";
 import { withConfiguredAppBasePath } from "../server/app-base-path.js";
 import { FRAMEWORK_ROUTE_PREFIX } from "../server/core-routes-plugin.js";
-import { claimA2AContinuation, claimA2AContinuationDelivery, claimDueA2AContinuations, completeA2AContinuation, failA2AContinuationsForIntegrationTask, failA2AContinuation, getA2AContinuation, hasActiveA2AContinuationsForIntegrationTask, listRecoverableA2AIntegrationTasks, recoverDueA2AContinuationIds, rescheduleA2AContinuation, } from "./a2a-continuations-store.js";
-import { completeIntegrationCampaignTaskAfterA2A, failDisabledIntegrationCampaignTask, getIntegrationCampaignForTask, } from "./integration-campaigns-store.js";
+import { claimA2AContinuation, claimA2AContinuationDelivery, claimDueA2AContinuations, failA2AContinuationsForIntegrationTask, failA2AContinuation, finalizeA2ATerminalHistory, getA2AContinuation, getA2AContinuationTaskOutcome, hasOnlyLegacyFailedA2AContinuationsForIntegrationTask, hasPendingConfirmedA2ADeliveryForIntegrationTask, listRecoverableA2AIntegrationTasks, recoverDueA2AContinuationIds, recordA2ATerminalDeliveryReceipt, retainA2AUnconfirmedDeliveryClaim, rescheduleA2AContinuation, saveA2AVerifiedArtifactCheckpoint, } from "./a2a-continuations-store.js";
+import { completeIntegrationCampaignTaskAfterA2A, failDisabledIntegrationCampaignTask, failIntegrationCampaignTaskDeliveryContainment, getIntegrationCampaignForTask, } from "./integration-campaigns-store.js";
 import { dispatchPendingIntegrationTask, isIntegrationDurableDispatchEnabledForTask, } from "./integration-durable-dispatch.js";
 import { signInternalToken } from "./internal-token.js";
 import { getNextPendingTaskForThread, getPendingTask, } from "./pending-tasks-store.js";
@@ -26,6 +26,16 @@ const POLL_REQUEST_TIMEOUT_MS = 8_000;
 const PLATFORM_SEND_TIMEOUT_MS = 12_000;
 const DISPATCH_SETTLE_WAIT_MS = 2_000;
 const COMPLETE_AFTER_DELIVERY_ATTEMPTS = 3;
+function logA2AContinuationTransition(event, continuation) {
+    console.info("[integrations] a2a-continuation-transition", {
+        event,
+        continuationId: continuation.id,
+        integrationTaskId: continuation.integrationTaskId,
+        downstreamTaskId: continuation.a2aTaskId,
+        attempt: continuation.attempts,
+        status: continuation.status,
+    });
+}
 export async function dispatchA2AContinuation(continuationId, webhookBaseUrl) {
     const baseUrl = webhookBaseUrl ||
         process.env.WEBHOOK_BASE_URL ||
@@ -87,10 +97,74 @@ export async function processA2AContinuationById(continuationId, options) {
         return;
     await processClaimedContinuation(continuation, options);
 }
+export async function recoverA2AContinuationAfterProcessorFailure(continuationId, options) {
+    const continuation = await getA2AContinuation(continuationId);
+    if (!continuation ||
+        continuation.status === "completed" ||
+        continuation.status === "failed") {
+        return;
+    }
+    if (continuation.terminalDeliveryConfirmedAt != null &&
+        continuation.terminalHistoryPayload) {
+        await persistAndFinalizeConfirmedA2ADelivery(continuation);
+        return;
+    }
+    const adapter = options.adapters.get(continuation.platform);
+    if (continuation.attempts < MAX_ATTEMPTS) {
+        logA2AContinuationTransition("processor_released", continuation);
+        await rescheduleAndRedispatchA2AContinuation(continuation.id);
+        return;
+    }
+    if (!adapter) {
+        const reason = `Unknown platform: ${continuation.platform}`;
+        logA2AContinuationTransition("processor_exhausted_without_adapter", continuation);
+        await failA2AContinuationsForIntegrationTask(continuation.integrationTaskId, reason);
+        if (await hasPendingConfirmedA2ADeliveryForIntegrationTask(continuation.integrationTaskId)) {
+            await dispatchPendingIntegrationTask({
+                taskId: continuation.integrationTaskId,
+                task: {
+                    platform: continuation.platform,
+                    externalThreadId: continuation.externalThreadId,
+                    platformContext: continuation.incoming.platformContext,
+                },
+                campaignContinuation: true,
+                allowPortableConfirmedReceiptReconciliation: true,
+            }).catch((err) => {
+                console.error(`[integrations] Failed to wake confirmed sibling history for ${continuation.integrationTaskId}:`, err);
+            });
+            return;
+        }
+        await failIntegrationCampaignTaskDeliveryContainment(continuation.integrationTaskId, reason);
+        return;
+    }
+    const progress = await resumeA2AContinuationProgress(continuation, adapter);
+    if (continuation.verifiedArtifactCheckpoint) {
+        logA2AContinuationTransition("processor_exhausted_checkpoint_delivery", continuation);
+        await deliverAndCompleteA2AContinuation(continuation, adapter, formatRecoverableArtifactFallbackText(continuation.verifiedArtifactCheckpoint), progress);
+        return;
+    }
+    logA2AContinuationTransition("processor_exhausted_failure_notice", continuation);
+    await notifyAndFailA2AContinuation(continuation, adapter, options.reason, progress);
+}
 export async function processDueA2AContinuations(options) {
     const continuations = await claimDueA2AContinuations(options.limit ?? 5);
     for (const continuation of continuations) {
-        await processClaimedContinuation(continuation, options).catch((err) => console.error(`[integrations] A2A continuation ${continuation.id} failed:`, err));
+        await processClaimedContinuation(continuation, options).catch(async (err) => {
+            console.error(`[integrations] A2A continuation ${continuation.id} failed; durable recovery requested`);
+            try {
+                await recoverA2AContinuationAfterProcessorFailure(continuation.id, {
+                    adapters: options.adapters,
+                    reason: err instanceof Error
+                        ? err.message.slice(0, 500)
+                        : "continuation processing failed",
+                });
+            }
+            catch (recoveryError) {
+                console.error(`[integrations] A2A continuation ${continuation.id} recovery failed; later continuations will continue`, recoveryError instanceof Error
+                    ? recoveryError.name
+                    : "recovery_error");
+            }
+        });
     }
 }
 /**
@@ -104,6 +178,7 @@ export async function recoverDueA2AContinuations(options) {
     const limit = options?.limit ?? 5;
     const candidateTasks = await listRecoverableA2AIntegrationTasks(200);
     const eligibleTaskIds = [];
+    const confirmedHistoryTaskIds = [];
     for (const task of candidateTasks) {
         const enabled = isIntegrationDurableDispatchEnabledForTask({
             platform: task.platform,
@@ -114,14 +189,22 @@ export async function recoverDueA2AContinuations(options) {
         });
         if (enabled) {
             eligibleTaskIds.push(task.id);
-            if (eligibleTaskIds.length >= limit)
-                break;
+        }
+        else if (task.hasPendingConfirmedDelivery) {
+            confirmedHistoryTaskIds.push(task.id);
         }
         else {
             await failDisabledDurableA2ATask(task);
         }
+        if (eligibleTaskIds.length + confirmedHistoryTaskIds.length >= limit)
+            break;
     }
     const ids = await recoverDueA2AContinuationIds(limit, eligibleTaskIds);
+    const remaining = Math.max(0, limit - ids.length);
+    const confirmedHistoryIds = remaining > 0 && confirmedHistoryTaskIds.length > 0
+        ? await recoverDueA2AContinuationIds(remaining, confirmedHistoryTaskIds, true)
+        : [];
+    ids.push(...confirmedHistoryIds);
     let dispatched = 0;
     let failed = 0;
     await Promise.all(ids.map(async (id) => {
@@ -137,6 +220,11 @@ export async function recoverDueA2AContinuations(options) {
     return { dispatched, failed };
 }
 async function processClaimedContinuation(continuation, options) {
+    if (continuation.terminalDeliveryConfirmedAt != null &&
+        continuation.terminalHistoryPayload) {
+        await persistAndFinalizeConfirmedA2ADelivery(continuation);
+        return;
+    }
     if (!(await durableContinuationScopeStillEnabled(continuation)))
         return;
     const adapter = options.adapters.get(continuation.platform);
@@ -153,13 +241,16 @@ async function processClaimedContinuation(continuation, options) {
     const deadline = Date.now() + PROCESSOR_WAIT_MS;
     const recoverableArtifactSecrets = await resolveContinuationArtifactSecrets(continuation);
     let task = null;
-    let latestRecoverableArtifactText = null;
+    let latestRecoverableArtifactText = continuation.verifiedArtifactCheckpoint;
     try {
         while (Date.now() < deadline) {
             task = await client.getTask(continuation.a2aTaskId);
             const recoverableArtifactText = extractVerifiedRecoverableArtifactText(task, continuation.agentUrl, recoverableArtifactSecrets);
             if (recoverableArtifactText) {
-                latestRecoverableArtifactText = recoverableArtifactText;
+                latestRecoverableArtifactText = await saveA2AVerifiedArtifactCheckpoint(continuation.id, recoverableArtifactText);
+                if (latestRecoverableArtifactText) {
+                    logA2AContinuationTransition("checkpoint_persisted", continuation);
+                }
             }
             if (TERMINAL_STATES.has(task.status.state))
                 break;
@@ -181,6 +272,10 @@ async function processClaimedContinuation(continuation, options) {
             return;
         }
         if (continuation.attempts >= MAX_ATTEMPTS) {
+            if (latestRecoverableArtifactText) {
+                await deliverAndCompleteA2AContinuation(continuation, adapter, formatRecoverableArtifactFallbackText(latestRecoverableArtifactText), progress);
+                return;
+            }
             await notifyAndFailA2AContinuation(continuation, adapter, err instanceof Error ? err.message : String(err), progress);
             return;
         }
@@ -239,6 +334,11 @@ async function durableContinuationScopeStillEnabled(continuation) {
         });
     if (enabled)
         return true;
+    if (await hasPendingConfirmedA2ADeliveryForIntegrationTask(continuation.integrationTaskId)) {
+        await failA2AContinuation(continuation.id, "Durable integration campaign was disabled before this continuation delivered");
+        await reconcileTerminalA2AParentIfDisabled(continuation.integrationTaskId);
+        return false;
+    }
     await failDisabledDurableA2ATask({
         id: continuation.integrationTaskId,
         platform: task?.platform ?? continuation.platform,
@@ -266,6 +366,35 @@ async function failDisabledDurableA2ATask(task) {
         });
     }
 }
+export async function reconcileTerminalA2AParentIfDisabled(integrationTaskId) {
+    if ((await getA2AContinuationTaskOutcome(integrationTaskId)) !==
+        "terminal-without-delivery") {
+        return false;
+    }
+    if (await hasOnlyLegacyFailedA2AContinuationsForIntegrationTask(integrationTaskId)) {
+        await failIntegrationCampaignTaskDeliveryContainment(integrationTaskId, "Legacy A2A continuation ended without durable delivery proof");
+        return true;
+    }
+    const task = await getPendingTask(integrationTaskId);
+    if (!task ||
+        isIntegrationDurableDispatchEnabledForTask({
+            platform: task.platform,
+            externalThreadId: task.externalThreadId,
+            platformContext: task.dispatchScope
+                ? { channelId: task.dispatchScope }
+                : undefined,
+        })) {
+        return false;
+    }
+    await failDisabledDurableA2ATask({
+        id: task.id,
+        platform: task.platform,
+        externalThreadId: task.externalThreadId,
+        dispatchScope: task.dispatchScope,
+        status: task.status,
+    });
+    return true;
+}
 async function resumeA2AContinuationProgress(continuation, adapter) {
     if (!continuation.progressRef || !adapter.resumeRunProgress)
         return null;
@@ -322,23 +451,23 @@ async function notifyAndFailA2AContinuation(continuation, adapter, reason, progr
     const deliveryContinuation = await claimA2AContinuationDelivery(continuation.id);
     if (!deliveryContinuation)
         return;
+    logA2AContinuationTransition("failure_delivery_claimed", deliveryContinuation);
     const message = formatContinuationFailureMessage(deliveryContinuation, reason);
+    let outgoing;
+    let deliveryReceipt;
     try {
-        const outgoing = adapter.formatAgentResponse(message);
-        await withTimeout(deliverA2AContinuationResponse(adapter, deliveryContinuation, outgoing, progress, "error"), PLATFORM_SEND_TIMEOUT_MS, `${deliveryContinuation.platform} failure notification timed out`);
+        outgoing = adapter.formatAgentResponse(message);
+        deliveryReceipt = await withTimeout((signal) => deliverA2AContinuationResponse(adapter, deliveryContinuation, outgoing, progress, "error", signal), PLATFORM_SEND_TIMEOUT_MS, `${deliveryContinuation.platform} failure notification timed out`);
     }
     catch (err) {
         console.error(`[integrations] Failed to notify ${deliveryContinuation.platform} about failed A2A continuation ${deliveryContinuation.id}:`, err);
-        if (deliveryContinuation.attempts >= MAX_ATTEMPTS) {
-            await failA2AContinuation(deliveryContinuation.id, reason);
-            await completeParentCampaignAfterTerminalA2A(deliveryContinuation);
-            return;
-        }
         await rescheduleAndRedispatchA2AContinuation(deliveryContinuation.id);
         return;
     }
-    await failA2AContinuation(deliveryContinuation.id, reason);
-    await completeParentCampaignAfterTerminalA2A(deliveryContinuation);
+    const confirmed = await recordTerminalA2ADelivery(deliveryContinuation, "failure", outgoing, deliveryReceipt, [], reason);
+    if (!confirmed)
+        return;
+    await persistAndFinalizeConfirmedA2ADelivery(confirmed);
 }
 async function deliverAndCompleteA2AContinuation(continuation, adapter, text, progress = null) {
     if (!(await durableContinuationScopeStillEnabled(continuation)))
@@ -346,77 +475,76 @@ async function deliverAndCompleteA2AContinuation(continuation, adapter, text, pr
     const deliveryContinuation = await claimA2AContinuationDelivery(continuation.id);
     if (!deliveryContinuation)
         return;
+    logA2AContinuationTransition("response_delivery_claimed", deliveryContinuation);
+    let outgoing;
+    let deliveryReceipt;
+    const artifactSecrets = await resolveContinuationArtifactSecrets(deliveryContinuation);
+    const artifacts = extractA2AArtifactIdentities([{ tool: "call-agent", result: text }], { persistedArtifactSecrets: artifactSecrets });
     try {
-        const outgoing = adapter.formatAgentResponse(stripA2APersistedArtifactMarkers(text));
-        const deliveryReceipt = await withTimeout(deliverA2AContinuationResponse(adapter, deliveryContinuation, outgoing, progress, "done"), PLATFORM_SEND_TIMEOUT_MS, `${deliveryContinuation.platform} response delivery timed out`);
-        let persistenceError;
-        const artifactSecrets = await resolveContinuationArtifactSecrets(deliveryContinuation);
-        for (let attempt = 0; attempt < 3; attempt += 1) {
-            try {
-                await persistA2AContinuationDelivery(deliveryContinuation, outgoing, deliveryReceipt, text, artifactSecrets);
-                persistenceError = undefined;
-                break;
-            }
-            catch (err) {
-                persistenceError = err;
-            }
-        }
-        if (persistenceError) {
-            console.error(`[integrations] Delivered A2A continuation ${deliveryContinuation.id} but could not persist its thread history:`, persistenceError);
-        }
-    }
-    catch (err) {
-        if (deliveryContinuation.attempts >= MAX_ATTEMPTS) {
-            await failA2AContinuation(deliveryContinuation.id, err instanceof Error ? err.message : String(err));
+        outgoing = adapter.formatAgentResponse(stripA2APersistedArtifactMarkers(text));
+        deliveryReceipt = await withTimeout((signal) => deliverA2AContinuationResponse(adapter, deliveryContinuation, outgoing, progress, "done", signal), PLATFORM_SEND_TIMEOUT_MS, `${deliveryContinuation.platform} response delivery timed out`);
+        const confirmed = await recordTerminalA2ADelivery(deliveryContinuation, "success", outgoing, deliveryReceipt, artifacts);
+        if (!confirmed)
             return;
-        }
+        await persistAndFinalizeConfirmedA2ADelivery(confirmed);
+    }
+    catch {
         await rescheduleAndRedispatchA2AContinuation(deliveryContinuation.id);
         return;
     }
-    await completeAfterSuccessfulDelivery(deliveryContinuation);
 }
-async function deliverA2AContinuationResponse(adapter, continuation, message, progress, status) {
+async function deliverA2AContinuationResponse(adapter, continuation, message, progress, status, signal) {
     if (progress) {
         try {
             await progress.onEvent({
                 type: "agent_call",
                 agent: continuation.agentName,
                 status,
-            });
-            const receipt = await progress.complete(message);
+            }, { signal });
+            throwIfAborted(signal);
+            const receipt = await progress.complete(message, { signal });
             if (receipt?.status === "delivered")
                 return receipt;
             throw new Error("Continuation progress completed without delivery proof");
         }
         catch {
+            throwIfAborted(signal);
             // A resumed Slack stream can no longer be finalized (for example when
             // chat.stopStream rejects). Preserve the final answer with the same
             // thread reply fallback used by the initial webhook run. Also ask the
             // adapter to terminate the native stream: otherwise Slack can keep the
             // task card in its working state after the thread fallback succeeds.
             try {
-                await progress.fail?.("I couldn't update the live response, but I posted the final result in this thread.");
+                await progress.fail?.("I couldn't update the live response, but I posted the final result in this thread.", { signal });
             }
             catch {
                 // The thread reply below is still the authoritative final answer.
             }
+            logA2AContinuationTransition("native_progress_fallback", continuation);
         }
     }
+    throwIfAborted(signal);
     const receipt = await adapter.sendResponse(message, continuation.incoming, {
-        placeholderRef: continuation.placeholderRef ?? undefined,
+        idempotencyKey: `a2a-continuation:${continuation.id}`,
+        reconcileAfter: continuation.createdAt,
+        signal,
+        placeholderRef: progress?.responseTargetRef ?? continuation.placeholderRef ?? undefined,
+        strictTargetRef: true,
     });
     if (receipt?.status !== "delivered") {
         throw new Error("Continuation response completed without delivery proof");
     }
     return receipt;
 }
-async function persistA2AContinuationDelivery(continuation, outgoing, receipt, artifactText, artifactSecrets) {
+async function persistA2AContinuationDelivery(continuation, history) {
     const mapping = await getThreadMapping(continuation.platform, continuation.externalThreadId);
-    if (!mapping)
-        return;
+    if (!mapping) {
+        throw new Error("Integration thread mapping is not available");
+    }
     const thread = await getThread(mapping.internalThreadId);
-    if (!thread)
-        return;
+    if (!thread) {
+        throw new Error("Integration chat thread is not available");
+    }
     let repo;
     try {
         repo = JSON.parse(thread.threadData || "{}");
@@ -426,30 +554,31 @@ async function persistA2AContinuationDelivery(continuation, outgoing, receipt, a
     }
     if (!Array.isArray(repo.messages))
         repo.messages = [];
-    const artifacts = extractA2AArtifactIdentities([{ tool: "call-agent", result: artifactText }], {
-        persistedArtifactSecrets: artifactSecrets,
-    });
     const metadata = {
         integrationDeliveryAttempted: true,
         integrationDelivery: {
             platform: continuation.platform,
             status: "delivered",
-            text: outgoing.text,
-            deliveredAt: new Date().toISOString(),
-            ...(receipt.messageRefs?.length
-                ? { messageRefs: receipt.messageRefs }
+            text: history.text,
+            deliveredAt: history.deliveredAt,
+            ...(history.messageRefs.length
+                ? { messageRefs: history.messageRefs }
                 : {}),
         },
     };
-    if (artifacts.length > 0)
-        metadata.integrationArtifacts = artifacts;
-    repo.messages.push({
-        id: `msg-${Date.now()}-assistant-continuation`,
-        role: "assistant",
-        content: [{ type: "text", text: outgoing.text }],
-        createdAt: new Date().toISOString(),
-        metadata,
-    });
+    if (history.artifacts.length > 0) {
+        metadata.integrationArtifacts = history.artifacts;
+    }
+    const messageId = `msg-${continuation.id}-assistant-continuation`;
+    if (!repo.messages.some((message) => message?.id === messageId)) {
+        repo.messages.push({
+            id: messageId,
+            role: "assistant",
+            content: [{ type: "text", text: history.text }],
+            createdAt: history.deliveredAt,
+            metadata,
+        });
+    }
     const meta = extractThreadMeta(repo);
     await updateThreadData(mapping.internalThreadId, JSON.stringify(repo), meta.title || thread.title || "Integration Chat", meta.preview || thread.preview || "", repo.messages.length);
 }
@@ -459,31 +588,100 @@ async function rescheduleAndRedispatchA2AContinuation(continuationId) {
         console.error(`[integrations] Failed to redispatch A2A continuation ${continuationId}:`, err);
     });
 }
-async function completeAfterSuccessfulDelivery(continuation) {
-    let lastError;
+async function recordTerminalA2ADelivery(continuation, kind, outgoing, receipt, artifacts, errorMessage) {
+    const historyPayload = {
+        text: outgoing.text,
+        deliveredAt: new Date().toISOString(),
+        messageRefs: receipt.messageRefs ?? [],
+        artifacts,
+    };
     for (let attempt = 0; attempt < COMPLETE_AFTER_DELIVERY_ATTEMPTS; attempt++) {
         try {
-            await completeA2AContinuation(continuation.id);
-            await completeParentCampaignAfterTerminalA2A(continuation);
+            const confirmed = await recordA2ATerminalDeliveryReceipt(continuation.id, kind, historyPayload, errorMessage);
+            logA2AContinuationTransition(kind === "success"
+                ? "response_delivery_confirmed"
+                : "failure_delivery_confirmed", continuation);
+            return confirmed;
+        }
+        catch { }
+    }
+    console.error(`[integrations] ${continuation.platform} accepted terminal A2A delivery for ${continuation.id}, ` +
+        `but recording its receipt failed after ${COMPLETE_AFTER_DELIVERY_ATTEMPTS} attempts. Leaving it in delivering for stale recovery.`);
+    try {
+        await retainA2AUnconfirmedDeliveryClaim(continuation.id);
+    }
+    catch (err) {
+        console.error(`[integrations] Failed to retain unconfirmed A2A delivery claim ${continuation.id}:`, err instanceof Error ? err.name : "receipt_recovery_error");
+    }
+    return null;
+}
+async function persistAndFinalizeConfirmedA2ADelivery(continuation) {
+    const history = continuation.terminalHistoryPayload;
+    if (!history || continuation.terminalDeliveryConfirmedAt == null) {
+        throw new Error("Confirmed A2A delivery is missing durable history");
+    }
+    let lastError;
+    let historyFinalized = false;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        try {
+            if (!historyFinalized) {
+                await persistA2AContinuationDelivery(continuation, history);
+                await finalizeA2ATerminalHistory(continuation.id);
+                historyFinalized = true;
+                logA2AContinuationTransition("terminal_history_persisted", continuation);
+            }
+            await completeParentCampaignAfterTerminalA2A({
+                ...continuation,
+                status: continuation.terminalDeliveryKind === "success"
+                    ? "completed"
+                    : "failed",
+            });
             return;
         }
         catch (err) {
             lastError = err;
         }
     }
-    console.error(`[integrations] ${continuation.platform} accepted A2A continuation ${continuation.id}, ` +
-        "but marking it completed failed. Leaving it in delivering for stale-delivery recovery.", lastError);
+    console.error(historyFinalized
+        ? `[integrations] A2A continuation ${continuation.id} finalized history but parent completion remains retryable:`
+        : `[integrations] A2A continuation ${continuation.id} has a provider receipt but its history remains retryable:`, lastError instanceof Error ? lastError.name : "persistence_error");
+    if (historyFinalized) {
+        await dispatchPendingIntegrationTask({
+            taskId: continuation.integrationTaskId,
+            task: {
+                platform: continuation.platform,
+                externalThreadId: continuation.externalThreadId,
+                platformContext: continuation.incoming.platformContext,
+            },
+            campaignContinuation: true,
+            allowPortableConfirmedReceiptReconciliation: true,
+        }).catch((err) => {
+            console.error(`[integrations] Failed to wake A2A parent ${continuation.integrationTaskId} after terminal history finalization:`, err);
+        });
+        return;
+    }
+    await rescheduleAndRedispatchA2AContinuation(continuation.id);
 }
 async function completeParentCampaignAfterTerminalA2A(continuation) {
     const campaign = await getIntegrationCampaignForTask(continuation.integrationTaskId);
     if (!campaign)
         return;
-    if (await hasActiveA2AContinuationsForIntegrationTask(continuation.integrationTaskId)) {
+    const outcome = await getA2AContinuationTaskOutcome(continuation.integrationTaskId);
+    if (outcome !== "terminal-delivered") {
+        if (outcome === "terminal-without-delivery") {
+            if (await reconcileTerminalA2AParentIfDisabled(continuation.integrationTaskId)) {
+                return;
+            }
+        }
+        if (outcome !== "active") {
+            console.warn(`[integrations] Refusing to complete A2A parent ${continuation.integrationTaskId} with outcome ${outcome}`);
+        }
         return;
     }
     const completed = await completeIntegrationCampaignTaskAfterA2A(continuation.integrationTaskId);
     if (!completed)
         return;
+    logA2AContinuationTransition("parent_completed", continuation);
     const nextTask = await getNextPendingTaskForThread(continuation.platform, continuation.externalThreadId);
     if (!nextTask)
         return;
@@ -550,21 +748,37 @@ function remotePollFailureReason(continuation) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function withTimeout(promise, timeoutMs, message) {
+async function withTimeout(operation, timeoutMs, message) {
+    const controller = new AbortController();
     let timer;
+    let timedOut = false;
     try {
-        return await Promise.race([
-            promise,
-            new Promise((_, reject) => {
-                timer = setTimeout(() => reject(new Error(message)), timeoutMs);
-            }),
-        ]);
+        timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort(new Error(message));
+        }, timeoutMs);
+        const result = await operation(controller.signal);
+        if (timedOut)
+            throw new Error(message);
+        return result;
+    }
+    catch (error) {
+        if (timedOut)
+            throw new Error(message);
+        throw error;
     }
     finally {
         if (timer)
             clearTimeout(timer);
     }
 }
+function throwIfAborted(signal) {
+    if (!signal.aborted)
+        return;
+    throw signal.reason instanceof Error
+        ? signal.reason
+        : new Error("Platform delivery was aborted");
+}
 function sanitizeFailureReason(reason) {
     const oneLine = reason.replace(/\s+/g, " ").trim();
     const withoutEnvNames = oneLine.replace(/\b[A-Z][A-Z0-9_]*(?:API_KEY|PRIVATE_KEY|SECRET|TOKEN)\b/g, "a required credential");