@agent-native/core 0.186.0 → 0.187.0-nightly-20260923203303

package/dist/agent/jev-tool-prefetch.js

@@ -1,3 +1,4 @@
+import { getBuilderProxyOrigin, } from "../server/credential-provider.js";
 import { getBuilderGatewayRequestHeaders } from "./engine/builder-gateway-headers.js";
 import { searchToolRegistry, TOOL_SEARCH_ACTION_NAME } from "./tool-search.js";
 const MAX_JEV_CANDIDATES = 128;
@@ -5,7 +6,6 @@ const DEFAULT_PREFETCH_LIMIT = 3;
 const MAX_PREFETCH_LIMIT = 5;
 const JEV_TIMEOUT_MS = 750;
 const JEV_MODEL = "jev-latest";
-export const BUILDER_JEV_PROXY_ENABLED = true;
 /**
  * Rank a bounded metadata-only catalog with Jev. A missing key, malformed
  * response, timeout, or provider failure returns no ranking so callers keep
@@ -13,8 +13,8 @@ export const BUILDER_JEV_PROXY_ENABLED = true;
  */
 export async function rankJevCandidates(options) {
     const request = options.request.trim();
-    const apiKey = options.apiKey?.trim();
-    const builderAuth = BUILDER_JEV_PROXY_ENABLED ? options.builderAuth : null;
+    const apiKey = options.personalApiKey?.trim();
+    const builderAuth = options.builderAuth;
     if (!request ||
         (!apiKey && !builderAuth) ||
         options.candidates.length === 0) {
@@ -51,6 +51,7 @@ export async function rankJevCandidates(options) {
         };
         const response = await requestJev({
             apiKey,
+            personalApiKey: options.personalApiKey,
             builderAuth,
             request: jevRequest,
         });
@@ -111,8 +112,8 @@ export function shortlistJevCandidates(request, candidates) {
  */
 export async function preloadJevTools(options) {
     const request = options.request.trim();
-    const apiKey = options.apiKey?.trim();
-    const builderAuth = BUILDER_JEV_PROXY_ENABLED ? options.builderAuth : null;
+    const apiKey = options.personalApiKey?.trim();
+    const builderAuth = options.builderAuth;
     if (!request || (!apiKey && !builderAuth)) {
         return options.initialTools;
     }
@@ -142,6 +143,7 @@ export async function preloadJevTools(options) {
     const selectedNames = await rankJevCandidates({
         request,
         apiKey,
+        personalApiKey: options.personalApiKey,
         candidates: candidates.map((candidate) => ({
             id: candidate.name,
             description: candidate.description,
@@ -158,63 +160,141 @@ export async function preloadJevTools(options) {
         : options.initialTools;
 }
 async function requestJev(options) {
-    if (BUILDER_JEV_PROXY_ENABLED && options.builderAuth) {
+    const personalApiKey = options.personalApiKey?.trim();
+    if (options.builderAuth) {
         try {
             return await requestJevThroughBuilder(options.builderAuth, options.request);
         }
         catch (error) {
-            if (!options.apiKey)
+            if (!personalApiKey)
                 throw error;
             console.warn("[agent] Builder Jev proxy unavailable; falling back to the direct Jev API.", error instanceof Error ? error.message : "unknown error");
+            return requestJevDirect(personalApiKey, options.request);
         }
     }
-    if (!options.apiKey) {
+    if (!personalApiKey) {
         throw new Error("Builder Jev proxy is unavailable.");
     }
+    return requestJevDirect(personalApiKey, options.request);
+}
+async function requestJevDirect(apiKey, request) {
     const { choice, TypeSafeClient } = await import("@typesafe-ai/sdk");
     const client = new TypeSafeClient({
-        apiKey: options.apiKey,
+        apiKey,
         timeout: JEV_TIMEOUT_MS,
         retry: { maxRetries: 0 },
     });
     const systemOne = client.systemOne.bind(client);
     return (await systemOne({
-        ...options.request,
+        ...request,
         questions: {
-            [Object.keys(options.request.questions)[0]]: choice(Object.values(options.request.questions)[0].instructions, Object.values(options.request.questions)[0].criteria),
+            [Object.keys(request.questions)[0]]: choice(Object.values(request.questions)[0].instructions, Object.values(request.questions)[0].criteria),
         },
     }));
 }
-async function requestJevThroughBuilder(auth, request) {
-    const { getBuilderProxyOrigin } = await import("../server/credential-provider.js");
+export async function requestJevThroughBuilder(auth, request, options = {}) {
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), JEV_TIMEOUT_MS);
+    const signal = options.signal
+        ? AbortSignal.any([options.signal, controller.signal])
+        : controller.signal;
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? JEV_TIMEOUT_MS);
     try {
-        const response = await fetch(`${getBuilderProxyOrigin().replace(/\/+$/, "")}/agent-native/jev/v1/system-one`, {
-            method: "POST",
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            signal.throwIfAborted();
+            const response = await fetch(`${getBuilderProxyOrigin().replace(/\/+$/, "")}/agent-native/jev/v1/system-one`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: auth.authorization,
+                    ...(auth.spaceId ? { "x-builder-api-key": auth.spaceId } : {}),
+                    ...(auth.userId ? { "x-builder-user-id": auth.userId } : {}),
+                    ...getBuilderGatewayRequestHeaders(),
+                },
+                body: JSON.stringify(request),
+                signal,
+            });
+            if (!response.ok) {
+                if (attempt === 0 && [429, 529].includes(response.status)) {
+                    await response.body?.cancel().catch(() => undefined);
+                    await waitForJevRetry(signal);
+                    continue;
+                }
+                throw new Error(`Builder Jev proxy returned HTTP ${response.status}.`);
+            }
+            const result = (await response.json());
+            if (!isJevResponse(result)) {
+                throw new Error("Builder Jev proxy returned an invalid response.");
+            }
+            return result;
+        }
+        throw new Error("Builder Jev proxy request failed.");
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function waitForJevRetry(signal) {
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+        };
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, 200);
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+    });
+}
+export async function isBuilderJevEnabled(auth, options = {}) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 3_000);
+    try {
+        const response = await fetch(`${getBuilderProxyOrigin().replace(/\/+$/, "")}/agent-native/jev/v1/status`, {
+            method: "GET",
             headers: {
-                "Content-Type": "application/json",
                 Authorization: auth.authorization,
                 ...(auth.spaceId ? { "x-builder-api-key": auth.spaceId } : {}),
                 ...(auth.userId ? { "x-builder-user-id": auth.userId } : {}),
                 ...getBuilderGatewayRequestHeaders(),
             },
-            body: JSON.stringify(request),
-            signal: controller.signal,
+            signal: options.signal
+                ? AbortSignal.any([options.signal, controller.signal])
+                : controller.signal,
         });
+        if (response.status === 403)
+            return false;
         if (!response.ok) {
-            throw new Error(`Builder Jev proxy returned HTTP ${response.status}.`);
+            throw new Error(`Builder Jev status returned HTTP ${response.status}.`);
         }
         const result = (await response.json());
-        if (!isJevResponse(result)) {
-            throw new Error("Builder Jev proxy returned an invalid response.");
+        if (typeof result !== "object" ||
+            result === null ||
+            !("enabled" in result) ||
+            typeof result.enabled !== "boolean") {
+            throw new Error("Builder Jev status returned an invalid response.");
         }
-        return result;
+        return result.enabled;
     }
     finally {
         clearTimeout(timeout);
     }
 }
+export async function isJevEnabled(credentials) {
+    if (credentials.personalApiKey)
+        return true;
+    if (credentials.builderAuth) {
+        const enabled = await isBuilderJevEnabled(credentials.builderAuth);
+        if (enabled || !credentials.apiKeyLookupFailed)
+            return enabled;
+    }
+    if (credentials.apiKeyLookupFailed || credentials.builderAuthLookupFailed) {
+        throw new Error("Could not check Jev credentials or Builder entitlement.");
+    }
+    return false;
+}
 function isJevResponse(value) {
     return (typeof value === "object" &&
         value !== null &&

package/dist/agent/production-agent.d.ts

@@ -4,6 +4,7 @@ import type { Task } from "../a2a/types.js";
 import { type ActionAutomationContext, type ActionCaller } from "../action.js";
 import { type ArtifactReceipt } from "../artifacts/detect.js";
 import type { AgentNativeHarnessSetting } from "../config.js";
+import { type BuilderGatewayAuth } from "../server/credential-provider.js";
 import { fireInternalDispatch } from "../server/self-dispatch.js";
 import { type ReasoningEffort } from "../shared/reasoning-effort.js";
 import { type ResolveEngineConfig } from "./engine/index.js";
@@ -115,6 +116,14 @@ export declare function getOwnerApiKey(provider: string, ownerEmail: string | nu
  * staleness without adding a secret-store read to every request.
  */
 export declare function getOwnerJevApiKey(ownerEmail: string | null | undefined): Promise<string | undefined>;
+export interface JevContextCredentials {
+    apiKey: string | undefined;
+    personalApiKey: string | undefined;
+    builderAuth: BuilderGatewayAuth | null;
+    apiKeyLookupFailed?: boolean;
+    builderAuthLookupFailed?: boolean;
+}
+export declare function getJevContextCredentials(ownerEmail: string | null | undefined): Promise<JevContextCredentials>;
 /**
  * Derive the provider name from the active engine setting.
  * "ai-sdk:openai" → "openai", "anthropic" → "anthropic"

package/dist/agent/production-agent.js

@@ -47,7 +47,7 @@ import { loadPriorTurnToolCallJournal } from "./engine/tool-call-journal-seed.js
 import { backfillEngineMessagesToolResults, stringifyToolUseInputForGateway, unmatchedToolResultReplayText, } from "./engine/translate-anthropic.js";
 import { EngineError } from "./engine/types.js";
 import { filterHostedHarnessToolNames, normalizeHostedHarnessRuntime, } from "./harness/hosted.js";
-import { BUILDER_JEV_PROXY_ENABLED, preloadJevTools, } from "./jev-tool-prefetch.js";
+import { preloadJevTools } from "./jev-tool-prefetch.js";
 import { getDefaultMaxIterations, getDefaultMaxRunInputTokens, MAX_AGENT_MAX_ITERATIONS, MIN_AGENT_MAX_ITERATIONS, normalizeMaxIterations, normalizeMaxRunInputTokens, readAgentLoopSettings, } from "./loop-settings.js";
 import { getContextWindowForModel, resolveFallbackModel, } from "./model-config.js";
 import { maybeCompactThread, buildObservationalContext, hasObservationalMemory, serializeObservationalMemoryBlock, } from "./observational-memory/index.js";
@@ -375,17 +375,31 @@ export async function getOwnerApiKey(provider, ownerEmail, options) {
  * staleness without adding a secret-store read to every request.
  */
 export async function getOwnerJevApiKey(ownerEmail) {
+    return (await getOwnerJevApiKeyCredential(ownerEmail)).credential?.apiKey;
+}
+async function getOwnerJevApiKeyCredential(ownerEmail) {
     if (!ownerEmail)
-        return undefined;
+        return { credential: null, lookupFailed: false };
     const cacheKey = [
-        "jev",
+        "jev-source-v1",
         ownerEmail,
         getRequestOrgId() ?? `solo:${ownerEmail}`,
         getRequestContext()?.isSyntheticTraffic === true ? "synthetic" : "normal",
     ].join("\u0000");
     const cached = readOptionalKeyCache(cacheKey);
-    if (cached.hit)
-        return cached.value;
+    if (cached.hit) {
+        if (!cached.value)
+            return { credential: null, lookupFailed: false };
+        const separator = cached.value.indexOf(":");
+        const source = cached.value.slice(0, separator);
+        const apiKey = cached.value.slice(separator + 1);
+        return {
+            credential: (source === "user" || source === "deployment") && apiKey
+                ? { apiKey, source }
+                : null,
+            lookupFailed: false,
+        };
+    }
     let lookupFailed = false;
     const value = await getOwnerApiKey("jev", ownerEmail, {
         onLookupFailure: () => {
@@ -394,11 +408,14 @@ export async function getOwnerJevApiKey(ownerEmail) {
     });
     if (value) {
         if (!lookupFailed)
-            writeOptionalKeyCache(cacheKey, value);
-        return value;
+            writeOptionalKeyCache(cacheKey, `user:${value}`);
+        return {
+            credential: { apiKey: value, source: "user" },
+            lookupFailed,
+        };
     }
     if (lookupFailed)
-        return undefined;
+        return { credential: null, lookupFailed: true };
     const deployKey = canUseDeployCredentialFallbackForRequest("JEV_API_KEY")
         ? readDeployCredentialEnv("JEV_API_KEY")?.trim()
         : undefined;
@@ -407,24 +424,37 @@ export async function getOwnerJevApiKey(ownerEmail) {
             key: "JEV_API_KEY",
             value: deployKey,
         }))) {
-        if (!lookupFailed)
-            writeOptionalKeyCache(cacheKey, deployKey);
-        return deployKey;
+        if (!lookupFailed) {
+            writeOptionalKeyCache(cacheKey, `deployment:${deployKey}`);
+        }
+        return {
+            credential: { apiKey: deployKey, source: "deployment" },
+            lookupFailed: false,
+        };
     }
     if (!lookupFailed)
         writeOptionalKeyCache(cacheKey, undefined);
-    return undefined;
+    return { credential: null, lookupFailed: false };
 }
-async function getJevContextCredentials(ownerEmail) {
-    const apiKey = await getOwnerJevApiKey(ownerEmail);
-    if (!BUILDER_JEV_PROXY_ENABLED)
-        return { apiKey, builderAuth: null };
-    try {
-        return { apiKey, builderAuth: await resolveBuilderGatewayAuth() };
-    }
-    catch {
-        return { apiKey, builderAuth: null };
-    }
+export async function getJevContextCredentials(ownerEmail) {
+    const requestContext = getRequestContext();
+    const [lookup, builderAuthLookup] = await Promise.all([
+        getOwnerJevApiKeyCredential(ownerEmail),
+        resolveBuilderGatewayAuth({
+            userEmail: ownerEmail,
+            orgId: requestContext?.orgScope === "personal" ? null : getRequestOrgId(),
+        }).then((builderAuth) => ({ builderAuth, lookupFailed: false }), () => ({ builderAuth: null, lookupFailed: true })),
+    ]);
+    const credential = lookup.credential;
+    return {
+        apiKey: credential?.apiKey,
+        personalApiKey: credential?.source === "user" ? credential.apiKey : undefined,
+        builderAuth: builderAuthLookup.builderAuth,
+        ...(lookup.lookupFailed ? { apiKeyLookupFailed: true } : {}),
+        ...(builderAuthLookup.lookupFailed
+            ? { builderAuthLookupFailed: true }
+            : {}),
+    };
 }
 /**
  * Derive the provider name from the active engine setting.
@@ -8040,7 +8070,7 @@ export function createProductionAgentHandler(options) {
             presendCap("files", filesContextThunk, "", 12000),
             presendCap("loopSettings", loopSettingsThunk, fallbackLoopSettings, 9000),
             presendCap("enrichedMessage", enrichedMessageThunk, requestMessage, 9000),
-            presendCap("jevContextCredentials", () => getJevContextCredentials(ownerEmail ?? getRequestUserEmail()), { apiKey: undefined, builderAuth: null }, 9000),
+            presendCap("jevContextCredentials", () => getJevContextCredentials(ownerEmail ?? getRequestUserEmail()), { apiKey: undefined, personalApiKey: undefined, builderAuth: null }, 9000),
         ]);
         setupMark("ctxAll");
         // DIAGNOSTIC-ONLY: all parallel context gathering (system prompt, screen,
@@ -8086,6 +8116,7 @@ export function createProductionAgentHandler(options) {
             preloadJevTools({
                 request: requestMessage,
                 apiKey: jevContextCredentials.apiKey,
+                personalApiKey: jevContextCredentials.personalApiKey,
                 builderAuth: jevContextCredentials.builderAuth,
                 registry: requestActions,
                 initialTools: curatedRequestTools,
@@ -8095,6 +8126,7 @@ export function createProductionAgentHandler(options) {
             preloadJevContextForPrompt({
                 request: requestMessage,
                 apiKey: jevContextCredentials.apiKey,
+                personalApiKey: jevContextCredentials.personalApiKey,
                 builderAuth: jevContextCredentials.builderAuth,
                 compact: options.jevContextCompact,
                 maxChars: jevContextMaxChars,

package/dist/app-config/integrations.d.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 /** Inbound integration webhook policy. */
 export declare const integrationsConfig: z.ZodObject<{
+    durableDispatch: z.ZodOptional<z.ZodBoolean>;
     allowUnverifiedWebhooks: z.ZodDefault<z.ZodBoolean>;
     webhookBaseUrl: z.ZodOptional<z.ZodString>;
     platforms: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/app-config/integrations.js

@@ -1,6 +1,13 @@
 import { z } from "zod";
 /** Inbound integration webhook policy. */
 export const integrationsConfig = z.object({
+    durableDispatch: z
+        .boolean()
+        .optional()
+        .meta({
+        env: ["AGENT_INTEGRATION_DURABLE_DISPATCH"],
+        doc: "Use a durable background function for integration work. Explicit false stops an enabled rollout; unset leaves it unavailable.",
+    }),
     allowUnverifiedWebhooks: z
         .boolean()
         .default(false)

package/dist/app-config/schema.d.ts

@@ -76,6 +76,7 @@ export declare const appConfigSchema: z.ZodObject<{
         requireEmailVerification: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     integrations: z.ZodPrefault<z.ZodObject<{
+        durableDispatch: z.ZodOptional<z.ZodBoolean>;
         allowUnverifiedWebhooks: z.ZodDefault<z.ZodBoolean>;
         webhookBaseUrl: z.ZodOptional<z.ZodString>;
         platforms: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/automation/index.d.ts

@@ -186,8 +186,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
+    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
-    error?: undefined;
 }>;

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

@@ -7,9 +7,9 @@ import { resolveArtifactBaseUrl } from "../server/agent-chat/action-filters-a2a.
 import { withConfiguredAppBasePath } from "../server/app-base-path.js";
 import { FRAMEWORK_ROUTE_PREFIX } from "../server/core-routes-plugin.js";
 import { resolveSelfDispatchBaseUrl } from "../server/self-dispatch.js";
-import { claimA2AContinuation, claimA2AContinuationDelivery, claimDueA2AContinuations, failA2AContinuationsForIntegrationTask, failA2AContinuation, finalizeA2ATerminalHistory, getA2AContinuation, getA2AContinuationTaskOutcome, hasOnlyLegacyFailedA2AContinuationsForIntegrationTask, hasPendingConfirmedA2ADeliveryForIntegrationTask, listRecoverableA2AIntegrationTasks, recoverDueA2AContinuationIds, recordA2ATerminalDeliveryReceipt, retainA2AUnconfirmedDeliveryClaim, rescheduleA2AContinuation, saveA2AVerifiedArtifactCheckpoint, } from "./a2a-continuations-store.js";
+import { claimA2AContinuation, claimA2AContinuationDelivery, claimDueA2AContinuations, failA2AContinuationsForIntegrationTask, failA2AContinuation, finalizeA2ATerminalHistory, getA2AContinuation, getA2AContinuationTaskOutcome, hasOnlyLegacyFailedA2AContinuationsForIntegrationTask, hasPendingConfirmedA2ADeliveryForIntegrationTask, listRecoverableA2AIntegrationTasks, deferA2AContinuationsForRuntime, recoverDueA2AContinuationIds, recordA2ATerminalDeliveryReceipt, retainA2AUnconfirmedDeliveryClaim, rescheduleA2AContinuation, pauseA2AContinuationForRuntime, 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 { dispatchPendingIntegrationTask, integrationDurableDispatchRuntimeUnavailableReasons, isIntegrationDurableDispatchEnabledForTask, isIntegrationDurableDispatchExplicitlyDisabledForTask, } from "./integration-durable-dispatch.js";
 import { signInternalToken } from "./internal-token.js";
 import { getNextPendingTaskForThread, getPendingTask, } from "./pending-tasks-store.js";
 import { getThreadMapping } from "./thread-mapping-store.js";
@@ -186,6 +186,7 @@ export async function recoverDueA2AContinuations(options) {
     const candidateTasks = await listRecoverableA2AIntegrationTasks(200);
     const eligibleTaskIds = [];
     const confirmedHistoryTaskIds = [];
+    const unavailableTaskIds = [];
     for (const task of candidateTasks) {
         const enabled = isIntegrationDurableDispatchEnabledForTask({
             platform: task.platform,
@@ -200,12 +201,22 @@ export async function recoverDueA2AContinuations(options) {
         else if (task.hasPendingConfirmedDelivery) {
             confirmedHistoryTaskIds.push(task.id);
         }
-        else {
+        else if (isIntegrationDurableDispatchExplicitlyDisabledForTask({
+            platform: task.platform,
+            externalThreadId: task.externalThreadId,
+            platformContext: task.dispatchScope
+                ? { channelId: task.dispatchScope }
+                : undefined,
+        })) {
             await failDisabledDurableA2ATask(task);
         }
+        else {
+            unavailableTaskIds.push(task.id);
+        }
         if (eligibleTaskIds.length + confirmedHistoryTaskIds.length >= limit)
             break;
     }
+    await deferA2AContinuationsForRuntime(unavailableTaskIds, 2 * 60_000);
     const ids = await recoverDueA2AContinuationIds(limit, eligibleTaskIds);
     const remaining = Math.max(0, limit - ids.length);
     const confirmedHistoryIds = remaining > 0 && confirmedHistoryTaskIds.length > 0
@@ -341,6 +352,18 @@ async function durableContinuationScopeStillEnabled(continuation) {
         });
     if (enabled)
         return true;
+    if (task?.status === "processing" &&
+        !isIntegrationDurableDispatchExplicitlyDisabledForTask({
+            platform: task.platform,
+            externalThreadId: task.externalThreadId,
+            platformContext: task.dispatchScope
+                ? { channelId: task.dispatchScope }
+                : undefined,
+        })) {
+        await pauseA2AContinuationForRuntime(continuation.id, continuation.attempts, RESCHEDULE_DELAY_MS);
+        console.warn(`[integrations] A2A continuation ${continuation.id} paused: durable dispatch runtime unavailable`, integrationDurableDispatchRuntimeUnavailableReasons());
+        return false;
+    }
     if (await hasPendingConfirmedA2ADeliveryForIntegrationTask(continuation.integrationTaskId)) {
         await failA2AContinuation(continuation.id, "Durable integration campaign was disabled before this continuation delivered");
         await reconcileTerminalA2AParentIfDisabled(continuation.integrationTaskId);
@@ -393,6 +416,15 @@ export async function reconcileTerminalA2AParentIfDisabled(integrationTaskId) {
         })) {
         return false;
     }
+    if (!isIntegrationDurableDispatchExplicitlyDisabledForTask({
+        platform: task.platform,
+        externalThreadId: task.externalThreadId,
+        platformContext: task.dispatchScope
+            ? { channelId: task.dispatchScope }
+            : undefined,
+    })) {
+        return false;
+    }
     await failDisabledDurableA2ATask({
         id: task.id,
         platform: task.platform,

package/dist/integrations/a2a-continuations-store.d.ts

@@ -86,8 +86,10 @@ export interface RecoverableA2AIntegrationTask {
  * can filter the canary in memory without an N+1 pending-task lookup loop.
  */
 export declare function listRecoverableA2AIntegrationTasks(limit?: number): Promise<RecoverableA2AIntegrationTask[]>;
+export declare function deferA2AContinuationsForRuntime(integrationTaskIds: string[], delayMs: number): Promise<void>;
 export declare function claimA2AContinuationDelivery(id: string): Promise<A2AContinuation | null>;
 export declare function rescheduleA2AContinuation(id: string, delayMs: number): Promise<void>;
+export declare function pauseA2AContinuationForRuntime(id: string, claimedAttempts: number, delayMs: number): Promise<boolean>;
 export declare function retainA2AUnconfirmedDeliveryClaim(id: string): Promise<void>;
 export declare function saveA2AVerifiedArtifactCheckpoint(id: string, checkpoint: string): Promise<string | null>;
 export declare function recordA2ATerminalDeliveryReceipt(id: string, kind: A2ATerminalDeliveryKind, historyPayload: A2ATerminalHistoryPayload, errorMessage?: string): Promise<A2AContinuation>;

package/dist/integrations/a2a-continuations-store.js

@@ -544,7 +544,7 @@ export async function listRecoverableA2AIntegrationTasks(limit = 50) {
     await ensureTable();
     const now = Date.now();
     const { rows } = await getDbExec().execute({
-        sql: `SELECT DISTINCT c.integration_task_id, t.platform,
+        sql: `SELECT c.integration_task_id, t.platform,
                  t.external_thread_id, t.dispatch_scope, t.status,
                  EXISTS (
                    SELECT 1 FROM integration_a2a_continuations receipt
@@ -562,7 +562,10 @@ export async function listRecoverableA2AIntegrationTasks(limit = 50) {
              OR (c.status = 'delivering' AND
                  ((c.terminal_delivery_confirmed_at IS NOT NULL AND c.next_check_at <= ?)
                    OR c.updated_at <= ?)))
-          ORDER BY c.integration_task_id ASC
+          GROUP BY c.integration_task_id, t.platform, t.external_thread_id,
+                   t.dispatch_scope, t.status
+          ORDER BY has_pending_confirmed_delivery DESC,
+                   MIN(c.next_check_at) ASC, c.integration_task_id ASC
           LIMIT ?`,
         args: [
             now,
@@ -583,6 +586,32 @@ export async function listRecoverableA2AIntegrationTasks(limit = 50) {
             Number(row.has_pending_confirmed_delivery ?? 0) === 1,
     }));
 }
+export async function deferA2AContinuationsForRuntime(integrationTaskIds, delayMs) {
+    if (integrationTaskIds.length === 0)
+        return;
+    await ensureTable();
+    const now = Date.now();
+    const taskFilter = integrationTaskIds.map(() => "?").join(", ");
+    await getDbExec().execute({
+        sql: `UPDATE integration_a2a_continuations
+          SET next_check_at = ?, updated_at = ?
+          WHERE integration_task_id IN (${taskFilter})
+            AND terminal_delivery_confirmed_at IS NULL
+            AND ((status = 'pending' AND next_check_at <= ?)
+              OR (status = 'processing' AND
+                  (updated_at <= ? OR next_check_at <= ?))
+              OR (status = 'delivering' AND updated_at <= ?))`,
+        args: [
+            now + delayMs,
+            now,
+            ...integrationTaskIds,
+            now,
+            now - PROCESSING_STUCK_AFTER_MS,
+            now - PROCESSING_NEXT_CHECK_STALE_AFTER_MS,
+            now - PROCESSING_STUCK_AFTER_MS,
+        ],
+    });
+}
 export async function claimA2AContinuationDelivery(id) {
     await ensureTable();
     const client = getDbExec();
@@ -608,6 +637,19 @@ export async function rescheduleA2AContinuation(id, delayMs) {
         args: ["pending", now + delayMs, now, id],
     });
 }
+export async function pauseA2AContinuationForRuntime(id, claimedAttempts, delayMs) {
+    await ensureTable();
+    const now = Date.now();
+    const result = await getDbExec().execute({
+        sql: `UPDATE integration_a2a_continuations
+          SET status = 'pending', attempts = attempts - 1,
+              next_check_at = ?, updated_at = ?
+          WHERE id = ? AND status = 'processing' AND attempts = ?
+          RETURNING id`,
+        args: [now + delayMs, now, id, claimedAttempts],
+    });
+    return (result.rows?.length ?? 0) > 0;
+}
 export async function retainA2AUnconfirmedDeliveryClaim(id) {
     await ensureTable();
     const now = Date.now();

package/dist/integrations/integration-campaign-recovery.js

@@ -1,6 +1,6 @@
 import { getA2AContinuationTaskOutcome } from "./a2a-continuations-store.js";
-import { getIntegrationCampaign, failDisabledIntegrationCampaignTask, listDueIntegrationCampaignIds, } from "./integration-campaigns-store.js";
-import { dispatchPendingIntegrationTask, isIntegrationDurableDispatchEnabledForTask, } from "./integration-durable-dispatch.js";
+import { getIntegrationCampaign, failDisabledIntegrationCampaignTask, listDueIntegrationCampaignIds, deferIntegrationCampaignForRuntime, } from "./integration-campaigns-store.js";
+import { dispatchPendingIntegrationTask, isIntegrationDurableDispatchEnabledForTask, isIntegrationDurableDispatchExplicitlyDisabledForTask, } from "./integration-durable-dispatch.js";
 import { getNextPendingTaskForThread, getPendingTask, } from "./pending-tasks-store.js";
 function hasConfirmedDeliveryReceipt(payload) {
     try {
@@ -46,6 +46,17 @@ export async function recoverDueIntegrationCampaigns(options) {
             const confirmedReceipt = hasConfirmedDeliveryReceipt(task.payload) ||
                 (await getA2AContinuationTaskOutcome(task.id)) === "terminal-delivered";
             if (!durableDispatchEnabled && !confirmedReceipt) {
+                if (!isIntegrationDurableDispatchExplicitlyDisabledForTask({
+                    platform: task.platform,
+                    externalThreadId: task.externalThreadId,
+                    platformContext: task.dispatchScope
+                        ? { channelId: task.dispatchScope }
+                        : undefined,
+                })) {
+                    await deferIntegrationCampaignForRuntime(campaign.id, 60_000);
+                    result.skipped += 1;
+                    continue;
+                }
                 await failDisabledIntegrationCampaignTask(task.id);
                 const nextTask = await getNextPendingTaskForThread(task.platform, task.externalThreadId);
                 if (nextTask) {

package/dist/integrations/integration-campaigns-store.d.ts

@@ -116,5 +116,6 @@ export declare function refreshIntegrationCampaignTaskA2AReceiptRetry(integratio
     errorMessage: string;
 }): Promise<boolean>;
 export declare function completeIntegrationCampaignTaskAfterA2A(integrationTaskId: string): Promise<boolean>;
+export declare function deferIntegrationCampaignForRuntime(id: string, delayMs: number): Promise<boolean>;
 export declare function listDueIntegrationCampaignIds(limit?: number): Promise<string[]>;
 export declare function hasActiveIntegrationCampaign(integrationTaskId: string): Promise<boolean>;

package/dist/integrations/integration-campaigns-store.js

@@ -725,6 +725,24 @@ export async function completeIntegrationCampaignTaskAfterA2A(integrationTaskId)
     }
     throw new Error("Database does not support atomic A2A parent completion");
 }
+export async function deferIntegrationCampaignForRuntime(id, delayMs) {
+    await ensureTable();
+    const now = Date.now();
+    const nextRunAt = now + delayMs;
+    const result = await getDbExec().execute({
+        sql: `UPDATE integration_campaigns
+          SET next_run_at = ?,
+              lease_expires_at = CASE WHEN status = 'processing' THEN ? ELSE lease_expires_at END,
+              updated_at = ?
+          WHERE id = ? AND (
+            (status IN ('pending', 'waiting') AND next_run_at <= ?)
+            OR (status = 'processing' AND lease_expires_at IS NOT NULL AND lease_expires_at <= ?)
+          )
+          RETURNING id`,
+        args: [nextRunAt, nextRunAt, now, id, now, now],
+    });
+    return (result.rows?.length ?? 0) > 0;
+}
 export async function listDueIntegrationCampaignIds(limit = 25) {
     await ensureTable();
     const boundedLimit = Math.max(1, Math.min(Math.floor(limit), MAX_DUE_LIST_LIMIT));