@agent-native/core 0.196.0-nightly-20260928165326 → 0.196.0

package/dist/triggers/dispatcher.js

@@ -1,12 +1,14 @@
 import { getOwnerActiveApiKey } from "../agent/production-agent.js";
 import { automationMatchesEventOwner, resolveAutomationExecutionIdentity, } from "../automations/service.js";
+import { isProductionServerlessFunctionRuntime } from "../db/client.js";
 import { subscribe, unsubscribe } from "../event-bus/index.js";
 import { isBackgroundAutomationRunActive, runBackgroundAutomation, } from "../jobs/background-automation-runner.js";
 import { buildJobResourceContent, jobBelongsToApp, parseJobResource, patchJobFrontmatterFields, } from "../jobs/frontmatter.js";
+import { registerRecurringSweepHandler, } from "../jobs/sweep-hooks.js";
 import { resourceGetByPath, resourceListAllOwners, resourcePutIfCurrent, } from "../resources/store.js";
 import { startIntervalJob } from "../server/interval-job.js";
 import { evaluateCondition } from "./condition-evaluator.js";
-import { AUTOMATION_TRIGGER_EVENT_PURGE_BATCH_SIZE, MAX_AUTOMATION_TRIGGER_EVENT_FAILURES, claimNextAutomationTriggerEvent, completeAutomationTriggerEvent, enqueueAutomationTriggerEvent, ensureAutomationTriggerEventQueue, failAutomationTriggerEvent, listReadyAutomationTriggerIds, purgeExpiredAutomationTriggerEvents, retryAutomationTriggerEvent, } from "./event-queue.js";
+import { AUTOMATION_TRIGGER_EVENT_EXPIRY_BATCH_SIZE, AUTOMATION_TRIGGER_EVENT_PURGE_BATCH_SIZE, MAX_AUTOMATION_TRIGGER_EVENT_FAILURES, claimNextAutomationTriggerEvent, completeAutomationTriggerEvent, enqueueAutomationTriggerEvent, ensureAutomationTriggerEventQueue, expireAutomationTriggerEvent, expireStaleAutomationTriggerEvents, failAutomationTriggerEvent, getAutomationTriggerSweepCursor, listReadyAutomationTriggerIds, purgeExpiredAutomationTriggerEvents, reserveAutomationTriggerEventPurge, retryAutomationTriggerEvent, scheduleAutomationTriggerEventPurge, setAutomationTriggerSweepCursor, } from "./event-queue.js";
 export function parseTriggerFrontmatter(content) {
     const { meta, body } = parseJobResource(content);
     return {
@@ -26,9 +28,16 @@ const _dispatchingTriggers = new Set();
 const _drainingTriggers = new Map();
 const MAX_TRIGGER_PAYLOAD_PROMPT_CHARS = 4_000;
 const MAX_TRIGGER_META_CHARS = 200;
+const DURABLE_TRIGGER_MAX_EVENT_RUN_MS = 60_000;
+const DURABLE_TRIGGER_RUN_CLEANUP_RESERVE_MS = 30_000;
+const DURABLE_TRIGGER_DRAIN_CONCURRENCY = 4;
+const DURABLE_TRIGGER_READY_PAGE_SIZE = 100;
+const MIN_DURABLE_TRIGGER_RUN_MS = 1_000;
+const DB_QUERY_TIMEOUT_MS = 15_000;
+const MAX_MAIL_TRIGGER_EVENT_AGE_MS = 60 * 60_000;
+const MAIL_RECEIVED_EVENT = "mail.message.received";
 let _deps = null;
 let _triggerQueueWorkerStarted = false;
-let _nextTriggerQueueCleanupAt = 0;
 export function buildAutomationTriggerPrompt(input) {
     let payloadStr;
     try {
@@ -109,27 +118,21 @@ export async function initTriggerDispatcher(deps) {
     _deps = deps;
     await ensureAutomationTriggerEventQueue();
     await refreshEventSubscriptions();
+    registerRecurringSweepHandler("automation-trigger-queue", async (context) => {
+        await drainReadyTriggerQueue(context);
+    });
     startTriggerQueueWorker();
 }
 function startTriggerQueueWorker() {
-    if (_triggerQueueWorkerStarted)
+    if (_triggerQueueWorkerStarted || isProductionServerlessFunctionRuntime()) {
         return;
+    }
     _triggerQueueWorkerStarted = true;
     startIntervalJob(async (signal) => {
         const deps = _deps;
         if (!deps || signal.aborted)
             return;
-        const triggerIds = await listReadyAutomationTriggerIds(deps.appId, 100);
-        for (const triggerId of triggerIds)
-            startTriggerDrain(triggerId);
-        if (Date.now() >= _nextTriggerQueueCleanupAt) {
-            const purged = await purgeExpiredAutomationTriggerEvents();
-            _nextTriggerQueueCleanupAt =
-                Date.now() +
-                    (purged === AUTOMATION_TRIGGER_EVENT_PURGE_BATCH_SIZE
-                        ? 60_000
-                        : 24 * 60 * 60_000);
-        }
+        await drainReadyTriggerQueue();
     }, {
         intervalMs: 10_000,
         timeoutMs: 10_000,
@@ -137,6 +140,106 @@ function startTriggerQueueWorker() {
         onError: (error) => console.error("[triggers] Event queue recovery scan failed:", error),
     });
 }
+async function drainReadyTriggerQueue(context) {
+    const deps = _deps;
+    if (!deps)
+        return;
+    if (!context) {
+        const triggerIds = await listReadyAutomationTriggerIds(deps.appId, DURABLE_TRIGGER_READY_PAGE_SIZE);
+        for (const triggerId of triggerIds)
+            void startTriggerDrain(triggerId);
+        return;
+    }
+    const deadline = context.deadlineAt;
+    let expiredCount = 0;
+    if (deps.appId === "mail") {
+        while (Date.now() + DB_QUERY_TIMEOUT_MS < deadline) {
+            const expired = await expireStaleAutomationTriggerEvents({
+                appId: deps.appId,
+                eventName: MAIL_RECEIVED_EVENT,
+                emittedBefore: new Date(Date.now() - MAX_MAIL_TRIGGER_EVENT_AGE_MS).toISOString(),
+                reason: "Expired because the mail event was older than 60 minutes.",
+            });
+            expiredCount += expired;
+            if (expired < AUTOMATION_TRIGGER_EVENT_EXPIRY_BATCH_SIZE)
+                break;
+        }
+    }
+    if (expiredCount > 0) {
+        console.info(`[triggers] Expired ${expiredCount} stale ${MAIL_RECEIVED_EVENT} events.`);
+    }
+    let reclaimedExpiredCount = 0;
+    let cycleStart = await getAutomationTriggerSweepCursor(deps.appId);
+    let cursor = cycleStart;
+    let wrapped = false;
+    let madeProgress = false;
+    try {
+        while (Date.now() +
+            DURABLE_TRIGGER_RUN_CLEANUP_RESERVE_MS +
+            MIN_DURABLE_TRIGGER_RUN_MS <
+            deadline) {
+            const ready = await listReadyAutomationTriggerIds(deps.appId, DURABLE_TRIGGER_READY_PAGE_SIZE, {
+                ...(cursor === null ? {} : { afterTriggerId: cursor }),
+                ...(wrapped && cycleStart !== null
+                    ? { throughTriggerId: cycleStart }
+                    : {}),
+            });
+            if (ready.length === 0) {
+                if (!wrapped && cycleStart !== null) {
+                    wrapped = true;
+                    cursor = null;
+                    continue;
+                }
+                if (madeProgress) {
+                    cycleStart = await getAutomationTriggerSweepCursor(deps.appId);
+                    cursor = cycleStart;
+                    wrapped = false;
+                    madeProgress = false;
+                    continue;
+                }
+                break;
+            }
+            const batch = ready.slice(0, DURABLE_TRIGGER_DRAIN_CONCURRENCY);
+            cursor = batch.at(-1) ?? cursor;
+            if (cursor !== null) {
+                await setAutomationTriggerSweepCursor(deps.appId, cursor);
+            }
+            const outcomes = await Promise.allSettled(batch.map((triggerId) => startTriggerDrain(triggerId, {
+                maxEvents: 1,
+                skipExisting: true,
+                expireStaleMailEvents: true,
+                deadline,
+                onStaleEventExpired: () => {
+                    reclaimedExpiredCount += 1;
+                },
+            })));
+            const failures = outcomes.flatMap((outcome) => outcome.status === "rejected" ? [outcome.reason] : []);
+            if (failures.length === 1)
+                throw failures[0];
+            if (failures.length > 1) {
+                throw new AggregateError(failures, "Failed to drain queued automation trigger events.");
+            }
+            madeProgress ||= outcomes.some((outcome) => outcome.status === "fulfilled" && outcome.value);
+        }
+    }
+    finally {
+        if (reclaimedExpiredCount > 0) {
+            console.info(`[triggers] Expired ${reclaimedExpiredCount} stale ${MAIL_RECEIVED_EVENT} events from reclaimed claims.`);
+        }
+    }
+    if (Date.now() + DB_QUERY_TIMEOUT_MS * 3 < deadline) {
+        const reserved = await reserveAutomationTriggerEventPurge(deps.appId);
+        if (reserved && Date.now() + DB_QUERY_TIMEOUT_MS * 2 < deadline) {
+            const purged = await purgeExpiredAutomationTriggerEvents();
+            if (Date.now() + DB_QUERY_TIMEOUT_MS < deadline) {
+                await scheduleAutomationTriggerEventPurge(deps.appId, Date.now() +
+                    (purged === AUTOMATION_TRIGGER_EVENT_PURGE_BATCH_SIZE
+                        ? 60_000
+                        : 24 * 60 * 60_000));
+            }
+        }
+    }
+}
 export async function refreshEventSubscriptions() {
     try {
         const jobResources = await resourceListAllOwners("jobs/");
@@ -198,7 +301,9 @@ async function handleEvent(eventName, payload, eventMeta) {
                 eventOwner: eventMeta.owner,
                 emittedAt: eventMeta.emittedAt,
             });
-            startTriggerDrain(resource.id);
+            if (!isProductionServerlessFunctionRuntime()) {
+                void startTriggerDrain(resource.id);
+            }
         }
     }
     catch (err) {
@@ -206,37 +311,57 @@ async function handleEvent(eventName, payload, eventMeta) {
         throw err;
     }
 }
-function startTriggerDrain(triggerId) {
-    if (_drainingTriggers.has(triggerId))
-        return;
-    const drain = drainTriggerQueue(triggerId)
-        .catch((error) => {
-        console.error(`[triggers] Failed to drain queued events for trigger ${triggerId}:`, error);
-    })
-        .finally(() => {
-        if (_drainingTriggers.get(triggerId) === drain) {
+function startTriggerDrain(triggerId, options) {
+    const existing = _drainingTriggers.get(triggerId);
+    if (existing)
+        return options?.skipExisting ? Promise.resolve(false) : existing;
+    const drain = drainTriggerQueue(triggerId, options?.maxEvents, options?.expireStaleMailEvents, options?.deadline, options?.onStaleEventExpired).finally(() => {
+        if (_drainingTriggers.get(triggerId) === drain)
             _drainingTriggers.delete(triggerId);
-        }
+    });
+    void drain.catch((error) => {
+        console.error(`[triggers] Failed to drain queued events for trigger ${triggerId}:`, error);
     });
     _drainingTriggers.set(triggerId, drain);
+    return drain;
 }
-async function drainTriggerQueue(triggerId) {
-    for (;;) {
+async function drainTriggerQueue(triggerId, maxEvents = Number.POSITIVE_INFINITY, expireStaleMailEvents = false, deadline, onStaleEventExpired) {
+    let processedEvents = 0;
+    while (processedEvents < maxEvents) {
+        if (deadline !== undefined &&
+            Date.now() +
+                DURABLE_TRIGGER_RUN_CLEANUP_RESERVE_MS +
+                MIN_DURABLE_TRIGGER_RUN_MS >=
+                deadline) {
+            return processedEvents > 0;
+        }
         const deps = _deps;
         if (!deps)
-            return;
+            return processedEvents > 0;
         const queued = await claimNextAutomationTriggerEvent(triggerId, deps.appId);
         if (!queued)
-            return;
+            return processedEvents > 0;
+        processedEvents += 1;
+        if (expireStaleMailEvents &&
+            deps.appId === "mail" &&
+            queued.eventName === MAIL_RECEIVED_EVENT &&
+            Date.parse(queued.emittedAt) < Date.now() - MAX_MAIL_TRIGGER_EVENT_AGE_MS) {
+            await expireAutomationTriggerEvent(queued.id, queued.claimedAt, queued.attempts, "Expired because the mail event was older than 60 minutes.");
+            onStaleEventExpired?.();
+            continue;
+        }
         if (queued.failureAttempts >= MAX_AUTOMATION_TRIGGER_EVENT_FAILURES) {
             await failAutomationTriggerEvent(queued.id, queued.claimedAt, queued.attempts, queued.failureAttempts, new Error("Automation event exceeded its retry limit after worker crashes."));
-            return;
+            return true;
         }
+        const hardDeadlineAt = deadline === undefined
+            ? undefined
+            : Math.min(Date.now() + DURABLE_TRIGGER_MAX_EVENT_RUN_MS, deadline - DURABLE_TRIGGER_RUN_CLEANUP_RESERVE_MS);
         try {
-            const result = await dispatchQueuedAutomationEvent(queued, deps);
+            const result = await dispatchQueuedAutomationEvent(queued, deps, hardDeadlineAt);
             if (result === "retry") {
                 await retryAutomationTriggerEvent(queued.id, queued.claimedAt, queued.attempts, queued.failureAttempts, "Automation trigger is busy; the event remains queued.", { delayMs: 5_000, countFailure: false });
-                return;
+                return true;
             }
             await completeAutomationTriggerEvent(queued.id, queued.claimedAt, queued.attempts);
         }
@@ -250,11 +375,12 @@ async function drainTriggerQueue(triggerId) {
                 await retryAutomationTriggerEvent(queued.id, queued.claimedAt, queued.attempts, queued.failureAttempts, error);
                 console.error(`[triggers] Queued event ${queued.eventId} will be retried:`, error);
             }
-            return;
+            return true;
         }
     }
+    return processedEvents > 0;
 }
-async function dispatchQueuedAutomationEvent(queued, deps) {
+async function dispatchQueuedAutomationEvent(queued, deps, hardDeadlineAt) {
     const resource = await resourceGetByPath(queued.triggerOwner, queued.triggerPath);
     if (!resource || resource.id !== queued.triggerId) {
         return "completed";
@@ -321,13 +447,17 @@ async function dispatchQueuedAutomationEvent(queued, deps) {
     const dispatchKey = `${resource.owner}:${resource.path}`;
     if (_dispatchingTriggers.has(dispatchKey))
         return "retry";
+    if (hardDeadlineAt !== undefined &&
+        hardDeadlineAt - Date.now() < MIN_DURABLE_TRIGGER_RUN_MS) {
+        return "retry";
+    }
     _dispatchingTriggers.add(dispatchKey);
     try {
         const dispatched = await dispatchAgentic(resource, queued.payload, {
             eventId: queued.eventId,
             emittedAt: queued.emittedAt,
             owner: queued.eventOwner,
-        }, identity);
+        }, identity, hardDeadlineAt);
         return dispatched ? "completed" : "retry";
     }
     finally {
@@ -399,7 +529,7 @@ export async function dispatchAutomationWebhookTask(task) {
     }
     return "completed";
 }
-async function dispatchAgentic(resource, payload, eventMeta, identity) {
+async function dispatchAgentic(resource, payload, eventMeta, identity, hardDeadlineAt) {
     if (!_deps)
         return false;
     const triggerName = resource.path.replace(/^jobs\//, "").replace(/\.md$/, "");
@@ -494,6 +624,7 @@ async function dispatchAgentic(resource, payload, eventMeta, identity) {
                 triggerName,
                 policyId: runningMeta.delegatedPolicyId,
             },
+            ...(hardDeadlineAt === undefined ? {} : { hardDeadlineAt }),
         }, _deps);
         await recordTriggerExecutionOutcome(latest, {
             lastStatus: "success",

package/dist/triggers/event-queue.d.ts

@@ -1,6 +1,7 @@
 import { type MigrationEntry } from "../db/migrations.js";
 export declare const AUTOMATION_TRIGGER_EVENT_DEDUPE_RETENTION_MS: number;
 export declare const AUTOMATION_TRIGGER_EVENT_PURGE_BATCH_SIZE = 1000;
+export declare const AUTOMATION_TRIGGER_EVENT_EXPIRY_BATCH_SIZE = 1000;
 export declare const MAX_AUTOMATION_TRIGGER_EVENT_FAILURES = 8;
 declare const CLAIM_LEASE_MS: () => number;
 export declare const AUTOMATION_TRIGGER_EVENT_MIGRATIONS: MigrationEntry[];
@@ -37,9 +38,24 @@ export declare function enqueueAutomationTriggerEvent(input: EnqueueAutomationTr
     id: string;
     inserted: boolean;
 }>;
-export declare function listReadyAutomationTriggerIds(appId?: string | null, limit?: number): Promise<string[]>;
+export declare function listReadyAutomationTriggerIds(appId?: string | null, limit?: number, cursor?: {
+    afterTriggerId?: string;
+    throughTriggerId?: string;
+}): Promise<string[]>;
+export declare function reserveAutomationTriggerEventPurge(appId?: string | null, now?: number): Promise<boolean>;
+export declare function scheduleAutomationTriggerEventPurge(appId: string | null | undefined, nextAt: number): Promise<void>;
+export declare function getAutomationTriggerSweepCursor(appId?: string | null): Promise<string | null>;
+export declare function setAutomationTriggerSweepCursor(appId: string | null | undefined, triggerId: string | null): Promise<void>;
 export declare function claimNextAutomationTriggerEvent(triggerId: string, appId?: string | null): Promise<QueuedAutomationTriggerEvent | null>;
 export declare function completeAutomationTriggerEvent(id: string, claimedAt: number, attempts: number): Promise<void>;
+export declare function expireAutomationTriggerEvent(id: string, claimedAt: number, attempts: number, reason: string): Promise<void>;
+export declare function expireStaleAutomationTriggerEvents(input: {
+    appId: string;
+    eventName: string;
+    emittedBefore: string;
+    reason: string;
+    limit?: number;
+}): Promise<number>;
 export declare function retryAutomationTriggerEvent(id: string, claimedAt: number, attempts: number, failureAttempts: number, error: unknown, options?: {
     delayMs?: number;
     countFailure?: boolean;
@@ -48,6 +64,7 @@ export declare function failAutomationTriggerEvent(id: string, claimedAt: number
 export declare function purgeExpiredAutomationTriggerEvents(now?: number): Promise<number>;
 export declare const __automationTriggerEventQueue: {
     table: string;
+    sweepStateTable: string;
     claimLeaseMs: typeof CLAIM_LEASE_MS;
 };
 export {};

package/dist/triggers/event-queue.js

@@ -4,14 +4,17 @@ import { getDbExec } from "../db/client.js";
 import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../db/ddl-guard.js";
 import { runMigrations } from "../db/migrations.js";
 const TABLE = "automation_trigger_event_queue";
+const SWEEP_STATE_TABLE = "automation_trigger_event_queue_sweep_state";
 const COMPLETED_PAYLOAD = '{"kind":"completed"}';
 const UNIQUE_INDEX = "idx_automation_trigger_event_queue_dedupe";
 const ORDER_INDEX = "idx_automation_trigger_event_queue_order";
 const READY_INDEX = "idx_automation_trigger_event_queue_ready";
 const COMPLETED_INDEX = "idx_automation_trigger_event_queue_completed";
 const FAILED_INDEX = "idx_automation_trigger_event_queue_failed";
+const STALE_EVENT_INDEX = "idx_automation_trigger_event_queue_stale_event";
 export const AUTOMATION_TRIGGER_EVENT_DEDUPE_RETENTION_MS = 7 * 24 * 60 * 60_000;
 export const AUTOMATION_TRIGGER_EVENT_PURGE_BATCH_SIZE = 1_000;
+export const AUTOMATION_TRIGGER_EVENT_EXPIRY_BATCH_SIZE = 1_000;
 export const MAX_AUTOMATION_TRIGGER_EVENT_FAILURES = 8;
 const CLAIM_LEASE_MS = () => Math.ceil(resolveBackgroundRunHardTimeoutMs() * 1.5);
 const CREATE_TABLE_SQL = `CREATE TABLE IF NOT EXISTS ${TABLE} (
@@ -35,6 +38,12 @@ const CREATE_TABLE_SQL = `CREATE TABLE IF NOT EXISTS ${TABLE} (
   completed_at BIGINT,
   last_error TEXT
 )`;
+const CREATE_SWEEP_STATE_TABLE_SQL = `CREATE TABLE IF NOT EXISTS ${SWEEP_STATE_TABLE} (
+  scope_key TEXT PRIMARY KEY,
+  last_trigger_id TEXT,
+  purge_after BIGINT NOT NULL DEFAULT 0,
+  updated_at BIGINT NOT NULL
+)`;
 export const AUTOMATION_TRIGGER_EVENT_MIGRATIONS = [
     {
         version: 1,
@@ -59,6 +68,18 @@ export const AUTOMATION_TRIGGER_EVENT_MIGRATIONS = [
       CREATE INDEX IF NOT EXISTS ${FAILED_INDEX}
         ON ${TABLE} (completed_at) WHERE status = 'failed'`,
     },
+    {
+        version: 3,
+        name: "automation-trigger-event-stale-mail-index",
+        sql: `CREATE INDEX IF NOT EXISTS ${STALE_EVENT_INDEX}
+      ON ${TABLE} (app_id, event_name, emitted_at)
+      WHERE status = 'pending'`,
+    },
+    {
+        version: 4,
+        name: "automation-trigger-event-queue-sweep-state",
+        sql: CREATE_SWEEP_STATE_TABLE_SQL,
+    },
 ];
 export async function runAutomationTriggerEventMigrations(nitroApp) {
     await runMigrations(AUTOMATION_TRIGGER_EVENT_MIGRATIONS, {
@@ -70,6 +91,7 @@ export async function ensureAutomationTriggerEventQueue() {
     if (!_initPromise) {
         _initPromise = (async () => {
             await ensureTableExists(TABLE, CREATE_TABLE_SQL);
+            await ensureTableExists(SWEEP_STATE_TABLE, CREATE_SWEEP_STATE_TABLE_SQL);
             await ensureColumnExists(TABLE, "failure_attempts", `ALTER TABLE ${TABLE}
           ADD COLUMN IF NOT EXISTS failure_attempts BIGINT NOT NULL DEFAULT 0`);
             await ensureIndexExists(UNIQUE_INDEX, `CREATE UNIQUE INDEX IF NOT EXISTS ${UNIQUE_INDEX}
@@ -80,6 +102,9 @@ export async function ensureAutomationTriggerEventQueue() {
           ON ${TABLE} (app_id, status, available_at, claimed_at)`);
             await ensureIndexExists(FAILED_INDEX, `CREATE INDEX IF NOT EXISTS ${FAILED_INDEX}
           ON ${TABLE} (completed_at) WHERE status = 'failed'`);
+            await ensureIndexExists(STALE_EVENT_INDEX, `CREATE INDEX IF NOT EXISTS ${STALE_EVENT_INDEX}
+          ON ${TABLE} (app_id, event_name, emitted_at)
+          WHERE status = 'pending'`);
             await ensureIndexExists(COMPLETED_INDEX, `CREATE INDEX IF NOT EXISTS ${COMPLETED_INDEX}
           ON ${TABLE} (completed_at) WHERE status = 'completed'`);
         })().catch((error) => {
@@ -174,29 +199,89 @@ function appScopePredicate(appId) {
         ? { sql: "app_id = ?", args: [appId.trim()] }
         : { sql: "app_id IS NULL", args: [] };
 }
-export async function listReadyAutomationTriggerIds(appId, limit = 100) {
+export async function listReadyAutomationTriggerIds(appId, limit = 100, cursor = {}) {
     await ensureAutomationTriggerEventQueue();
     const now = Date.now();
     const scope = appScopePredicate(appId);
+    const afterClause = cursor.afterTriggerId === undefined ? "" : "AND trigger_id > ?";
+    const throughClause = cursor.throughTriggerId === undefined ? "" : "AND trigger_id <= ?";
+    const args = [
+        ...scope.args,
+        now,
+        now - CLAIM_LEASE_MS(),
+        ...(cursor.afterTriggerId === undefined ? [] : [cursor.afterTriggerId]),
+        ...(cursor.throughTriggerId === undefined ? [] : [cursor.throughTriggerId]),
+        Math.max(1, Math.min(limit, 500)),
+    ];
     const { rows } = await getDbExec().execute({
-        sql: `SELECT trigger_id, MIN(sequence_id) AS first_sequence
+        sql: `SELECT DISTINCT trigger_id
           FROM ${TABLE}
           WHERE ${scope.sql}
             AND ((status = 'pending' AND available_at <= ?)
               OR (status = 'processing' AND
                 (claimed_at IS NULL OR claimed_at <= ?)))
-          GROUP BY trigger_id
-          ORDER BY first_sequence ASC
+            ${afterClause}
+            ${throughClause}
+          ORDER BY trigger_id ASC
           LIMIT ?`,
-        args: [
-            ...scope.args,
-            now,
-            now - CLAIM_LEASE_MS(),
-            Math.max(1, Math.min(limit, 500)),
-        ],
+        args,
     });
     return rows.map((row) => String(row.trigger_id));
 }
+export async function reserveAutomationTriggerEventPurge(appId, now = Date.now()) {
+    await ensureAutomationTriggerEventQueue();
+    const { rows } = await getDbExec().execute({
+        sql: `INSERT INTO ${SWEEP_STATE_TABLE}
+            (scope_key, last_trigger_id, purge_after, updated_at)
+          VALUES (?, NULL, ?, ?)
+          ON CONFLICT (scope_key) DO UPDATE
+            SET purge_after = excluded.purge_after,
+                updated_at = excluded.updated_at
+            WHERE ${SWEEP_STATE_TABLE}.purge_after <= ?
+          RETURNING scope_key`,
+        args: [appId?.trim() ?? "", now + 60_000, now, now],
+    });
+    return rows.length > 0;
+}
+export async function scheduleAutomationTriggerEventPurge(appId, nextAt) {
+    await ensureAutomationTriggerEventQueue();
+    await getDbExec().execute({
+        sql: `UPDATE ${SWEEP_STATE_TABLE}
+          SET purge_after = ?, updated_at = ?
+          WHERE scope_key = ?`,
+        args: [nextAt, Date.now(), appId?.trim() ?? ""],
+    });
+}
+export async function getAutomationTriggerSweepCursor(appId) {
+    await ensureAutomationTriggerEventQueue();
+    const { rows } = await getDbExec().execute({
+        sql: `SELECT last_trigger_id FROM ${SWEEP_STATE_TABLE} WHERE scope_key = ?`,
+        args: [appId?.trim() ?? ""],
+    });
+    const cursor = rows[0]
+        ?.last_trigger_id;
+    return cursor == null ? null : String(cursor);
+}
+export async function setAutomationTriggerSweepCursor(appId, triggerId) {
+    await ensureAutomationTriggerEventQueue();
+    const scopeKey = appId?.trim() ?? "";
+    if (triggerId === null) {
+        await getDbExec().execute({
+            sql: `DELETE FROM ${SWEEP_STATE_TABLE} WHERE scope_key = ?`,
+            args: [scopeKey],
+        });
+        return;
+    }
+    await getDbExec().execute({
+        sql: `INSERT INTO ${SWEEP_STATE_TABLE}
+            (scope_key, last_trigger_id, updated_at)
+          VALUES (?, ?, ?)
+          ON CONFLICT (scope_key) DO UPDATE
+            SET last_trigger_id = excluded.last_trigger_id,
+                updated_at = excluded.updated_at`,
+        args: [scopeKey, triggerId, Date.now()],
+    });
+}
 export async function claimNextAutomationTriggerEvent(triggerId, appId) {
     await ensureAutomationTriggerEventQueue();
     const now = Date.now();
@@ -247,6 +332,53 @@ export async function completeAutomationTriggerEvent(id, claimedAt, attempts) {
         args: [COMPLETED_PAYLOAD, Date.now(), id, claimedAt, attempts],
     });
 }
+export async function expireAutomationTriggerEvent(id, claimedAt, attempts, reason) {
+    await ensureAutomationTriggerEventQueue();
+    await getDbExec().execute({
+        sql: `UPDATE ${TABLE}
+          SET status = 'completed', payload = ?, claimed_at = NULL,
+              completed_at = ?, last_error = ?
+          WHERE id = ? AND status = 'processing'
+            AND claimed_at = ? AND attempts = ?`,
+        args: [
+            COMPLETED_PAYLOAD,
+            Date.now(),
+            reason.slice(0, 500),
+            id,
+            claimedAt,
+            attempts,
+        ],
+    });
+}
+export async function expireStaleAutomationTriggerEvents(input) {
+    await ensureAutomationTriggerEventQueue();
+    const limit = Math.max(1, Math.min(input.limit ?? AUTOMATION_TRIGGER_EVENT_EXPIRY_BATCH_SIZE, 10_000));
+    const { rowsAffected } = await getDbExec().execute({
+        sql: `WITH expired AS (
+            SELECT id FROM ${TABLE}
+            WHERE app_id = ? AND event_name = ? AND status = 'pending'
+              AND emitted_at < ?
+            ORDER BY emitted_at ASC
+            LIMIT ?
+            FOR UPDATE SKIP LOCKED
+          )
+          UPDATE ${TABLE} AS queued
+          SET status = 'completed', payload = ?, claimed_at = NULL,
+              completed_at = ?, last_error = ?
+          FROM expired
+          WHERE queued.id = expired.id`,
+        args: [
+            input.appId,
+            input.eventName,
+            input.emittedBefore,
+            limit,
+            COMPLETED_PAYLOAD,
+            Date.now(),
+            input.reason.slice(0, 500),
+        ],
+    });
+    return rowsAffected;
+}
 export async function retryAutomationTriggerEvent(id, claimedAt, attempts, failureAttempts, error, options = {}) {
     await ensureAutomationTriggerEventQueue();
     const message = error instanceof Error ? error.message : String(error ?? "Unknown error");
@@ -313,5 +445,6 @@ export async function purgeExpiredAutomationTriggerEvents(now = Date.now()) {
 }
 export const __automationTriggerEventQueue = {
     table: TABLE,
+    sweepStateTable: SWEEP_STATE_TABLE,
     claimLeaseMs: CLAIM_LEASE_MS,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.196.0-nightly-20260928165326",
+  "version": "0.196.0",
   "description": "The agentic application framework for building autonomous agents with intuitive UIs",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -533,9 +533,9 @@
     "yaml": "^2.9.0",
     "yjs": "^13.6.32",
     "zod": "^4.3.6",
-    "@agent-native/recap-cli": "0.5.47",
-    "@agent-native/agentkit": "^0.5.0-nightly-20260928165326",
-    "@agent-native/toolkit": "^0.23.0-nightly-20260928165326"
+    "@agent-native/agentkit": "^0.5.0",
+    "@agent-native/recap-cli": "0.5.48",
+    "@agent-native/toolkit": "^0.23.0"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.71",