@agent-native/core 0.119.4 → 0.119.6

package/dist/integrations/plugin.js

@@ -1,6 +1,7 @@
 import { defineEventHandler, setResponseStatus, setResponseHeader, getMethod, getQuery, sendRedirect, } from "h3";
 import { getRequestHeader } from "h3";
 import { createRemoteJWKSet, jwtVerify } from "jose";
+import { AGENT_BACKGROUND_PROCESSOR_FIELD, AGENT_BACKGROUND_PROCESSOR_INTEGRATION, } from "../agent/durable-background.js";
 import { abortRun } from "../agent/run-manager.js";
 import { getOrgContext, resolveOrgIdForEmail } from "../org/context.js";
 import { loadResourcesForPrompt } from "../server/agent-chat-plugin.js";
@@ -29,10 +30,11 @@ import { claimIntegrationControl } from "./controls-store.js";
 import { startGoogleDocsPoller, handlePushNotification, } from "./google-docs-poller.js";
 import { IntegrationIdentityDeclinedError, resolveDefaultIntegrationExecutionContext, } from "./identity.js";
 import { disconnectIntegrationInstallation, listIntegrationInstallations, resolveIntegrationTokenBundle, updateIntegrationInstallation, upsertIntegrationInstallation, } from "./installations-store.js";
+import { dispatchPendingIntegrationTask, INTEGRATION_RETRY_SWEEP_TOKEN_SUBJECT, integrationDispatchScopeValue, isIntegrationDurableDispatchConfigured, } from "./integration-durable-dispatch.js";
 import { forgetIntegrationMemory, integrationMemoryActions, listIntegrationMemory, rememberForIntegrationScope, } from "./integration-memory.js";
-import { extractBearerToken, signInternalToken, verifyInternalToken, } from "./internal-token.js";
-import { startPendingTasksRetryJob } from "./pending-tasks-retry-job.js";
-import { claimPendingTask, failTaskDeliveryTransition, getNextPendingTaskIdForThread, insertPendingTask, isDuplicateEventError, MAX_PENDING_TASK_ATTEMPTS, markTaskCompleted, markTaskDeliveryRetryable, markTaskFailed, markTaskRetryable, stageTaskDeliveryPayload, } from "./pending-tasks-store.js";
+import { extractBearerToken, verifyInternalToken } from "./internal-token.js";
+import { retryStuckPendingTasks, startPendingTasksRetryJob, } from "./pending-tasks-retry-job.js";
+import { claimPendingTask, failTaskDeliveryTransition, getNextPendingTaskForThread, insertPendingTask, isDuplicateEventError, MAX_PENDING_TASK_ATTEMPTS, markTaskCompleted, markTaskDeliveryRetryable, markTaskFailed, markTaskRetryable, stageTaskDeliveryPayload, } from "./pending-tasks-store.js";
 import { claimNextComputerCommand, claimNextRemoteCommand, enqueueComputerCommand, enqueueRemoteCommand as enqueueRemoteCommandRow, isRemoteCommandKind, listRemoteCommandsForOwner, updateRemoteCommandResult, } from "./remote-commands-store.js";
 import { authenticateRemoteDeviceToken, createRemoteDevice, getRemoteComputerCapabilities, getRemoteDeviceForOwner, listRemoteDevicesForOwner, revokeRemoteDeviceForOwner, toPublicRemoteDevice, unregisterRemoteDevice, updateRemoteDeviceDetails, } from "./remote-devices-store.js";
 import { startRemotePushDeliveryJob } from "./remote-push-delivery-job.js";
@@ -503,6 +505,11 @@ export function createIntegrationsPlugin(options) {
                     externalEventKey: opts?.dedupeKey
                         ? systemNoticeEventKey(opts.dedupeKey, dedupeTtlMs)
                         : undefined,
+                    dispatchScope: integrationDispatchScopeValue({
+                        platform: incoming.platform,
+                        externalThreadId: noticeThreadId,
+                        platformContext: incoming.platformContext,
+                    }),
                 });
             }
             catch (err) {
@@ -510,35 +517,17 @@ export function createIntegrationsPlugin(options) {
                     return;
                 throw err;
             }
-            // The SQL row is the durable source of truth. This best-effort self-call
-            // only reduces latency; the recurring pending-task sweep retries a row
-            // if the serverless host freezes this webhook execution immediately.
-            let token;
-            try {
-                token = signInternalToken(taskId);
-            }
-            catch (err) {
-                if (process.env.NODE_ENV === "production")
-                    throw err;
-            }
-            void fetch(`${getBaseUrl(event)}${P}/process-task`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    ...(token ? { Authorization: `Bearer ${token}` } : {}),
+            await dispatchPendingIntegrationTask({
+                taskId,
+                task: {
+                    platform: incoming.platform,
+                    externalThreadId: noticeThreadId,
+                    platformContext: incoming.platformContext,
                 },
-                body: JSON.stringify({ taskId }),
-            }).catch((err) => {
-                console.warn("[integrations] System notice dispatch failed:", err);
+                event,
+                baseUrl: getBaseUrl(event),
             });
         }
-        async function requireSession(event) {
-            const session = await getSession(event).catch(() => null);
-            if (session?.email)
-                return true;
-            setResponseStatus(event, 401);
-            return false;
-        }
         async function requireSessionContext(event) {
             const session = await getSession(event).catch(() => null);
             if (!session?.email) {
@@ -660,10 +649,11 @@ export function createIntegrationsPlugin(options) {
                 setResponseStatus(event, 405);
                 return { error: "Method not allowed" };
             }
-            if (!(await requireSession(event)))
+            const scope = await requireSessionContext(event);
+            if (!scope)
                 return { error: "unauthorized" };
             try {
-                return await getTaskQueueStats();
+                return await getTaskQueueStats(scope);
             }
             catch (err) {
                 setResponseStatus(event, 500);
@@ -1248,10 +1238,42 @@ export function createIntegrationsPlugin(options) {
             });
             return { ok: true, ...result };
         }));
+        // ─── Durable pending-task recovery sweep ─────────────────────
+        h3.use(`${P}/retry-stuck-tasks`, defineEventHandler(async (event) => {
+            if (getMethod(event) !== "POST") {
+                setResponseStatus(event, 405);
+                return { error: "Method not allowed" };
+            }
+            const body = (await readBody(event));
+            if (body?.taskId !== INTEGRATION_RETRY_SWEEP_TOKEN_SUBJECT) {
+                setResponseStatus(event, 400);
+                return { error: "invalid sweep subject" };
+            }
+            if (!process.env.A2A_SECRET) {
+                setResponseStatus(event, 503);
+                return { error: "durable integration recovery is not configured" };
+            }
+            const token = extractBearerToken(getRequestHeader(event, "authorization"));
+            if (!token ||
+                !verifyInternalToken(INTEGRATION_RETRY_SWEEP_TOKEN_SUBJECT, token)) {
+                setResponseStatus(event, 401);
+                return { error: "Invalid or expired internal token" };
+            }
+            if (!isIntegrationDurableDispatchConfigured()) {
+                return { ok: true, disabled: true };
+            }
+            const result = await retryStuckPendingTasks({
+                webhookBaseUrl: getBaseUrl(event),
+                limit: 20,
+                durableOnly: true,
+            });
+            return { ok: true, ...result };
+        }));
         // ─── Process pending task (cross-platform task queue) ────────
         // POST /_agent-native/integrations/process-task
-        // Internal endpoint invoked via fire-and-forget self-webhook from the
-        // public webhook handler. Auth: HMAC bearer signed with A2A_SECRET.
+        // Internal endpoint invoked from the public webhook handler through either
+        // the portable self-dispatch path or an acknowledged background handoff.
+        // Auth: HMAC bearer signed with A2A_SECRET.
         // Each invocation runs the agent loop in a fresh function execution.
         h3.use(`${P}/process-task`, defineEventHandler(async (event) => {
             if (getMethod(event) !== "POST") {
@@ -1291,7 +1313,11 @@ export function createIntegrationsPlugin(options) {
                 }
             }
             // Atomic claim: only one invocation gets to process this task
-            const task = await claimPendingTask(taskId);
+            const dispatchOutcome = body[AGENT_BACKGROUND_PROCESSOR_FIELD] ===
+                AGENT_BACKGROUND_PROCESSOR_INTEGRATION
+                ? "background-acknowledged"
+                : "portable-unconfirmed";
+            const task = await claimPendingTask(taskId, { dispatchOutcome });
             if (!task) {
                 setResponseStatus(event, 200);
                 return { ok: true, skipped: "already-claimed-or-missing" };
@@ -1384,18 +1410,19 @@ export function createIntegrationsPlugin(options) {
                     return { ok: true, taskId, retrying: "response-delivery" };
                 }
                 await markTaskCompleted(taskId);
-                const nextTaskId = await getNextPendingTaskIdForThread(task.platform, task.externalThreadId);
-                if (nextTaskId) {
-                    const nextToken = signInternalToken(nextTaskId);
-                    void fetch(`${getBaseUrl(event)}${P}/process-task`, {
-                        method: "POST",
-                        headers: {
-                            "Content-Type": "application/json",
-                            ...(nextToken ? { Authorization: `Bearer ${nextToken}` } : {}),
+                const nextTask = await getNextPendingTaskForThread(task.platform, task.externalThreadId);
+                if (nextTask) {
+                    await dispatchPendingIntegrationTask({
+                        taskId: nextTask.id,
+                        task: {
+                            platform: task.platform,
+                            externalThreadId: task.externalThreadId,
+                            platformContext: nextTask.dispatchScope
+                                ? { channelId: nextTask.dispatchScope }
+                                : undefined,
                         },
-                        body: JSON.stringify({ taskId: nextTaskId }),
-                    }).catch((err) => {
-                        console.error("[integrations] Failed to dispatch queued thread turn:", err);
+                        event,
+                        baseUrl: getBaseUrl(event),
                     });
                 }
                 await processDueA2AContinuations({
@@ -1580,18 +1607,21 @@ export function createIntegrationsPlugin(options) {
                     ownerEmail: control.ownerEmail,
                     orgId: control.orgId,
                     externalEventKey: `control:${control.id}`,
+                    dispatchScope: integrationDispatchScopeValue({
+                        platform: incoming.platform,
+                        externalThreadId: incoming.externalThreadId,
+                        platformContext: incoming.platformContext,
+                    }),
                 });
-                const processUrl = `${getBaseUrl(event)}${P}/process-task`;
-                const token = signInternalToken(taskId);
-                void fetch(processUrl, {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        ...(token ? { Authorization: `Bearer ${token}` } : {}),
+                await dispatchPendingIntegrationTask({
+                    taskId,
+                    task: {
+                        platform: incoming.platform,
+                        externalThreadId: incoming.externalThreadId,
+                        platformContext: incoming.platformContext,
                     },
-                    body: JSON.stringify({ taskId }),
-                }).catch((err) => {
-                    console.error("[slack] Approval dispatch failed:", err);
+                    event,
+                    baseUrl: getBaseUrl(event),
                 });
             }
             catch (err) {
@@ -1943,6 +1973,9 @@ export function createIntegrationsPlugin(options) {
             // Already handled by the dedicated /process-task route above
             if (parts[0] === "process-task")
                 return;
+            // Already handled by the signed durable recovery route above
+            if (parts[0] === "retry-stuck-tasks")
+                return;
             // Already handled by the dedicated /process-a2a-continuation route above
             if (parts[0] === "process-a2a-continuation")
                 return;