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

package/dist/provider-api/actions/provider-api.d.ts

@@ -314,6 +314,7 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         provider?: undefined;
         id?: undefined;
         deleted?: undefined;
+        found?: undefined;
         providers: {
             id: string;
             label: string;
@@ -324,15 +325,14 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
             updatedAt: number;
         }[];
         count: number;
-        found?: undefined;
         registered?: undefined;
         label?: undefined;
         message?: undefined;
     } | {
         id?: undefined;
-        count?: undefined;
         deleted?: undefined;
         providers?: undefined;
+        count?: undefined;
         found: boolean;
         provider: import("../custom-registry.js").CustomProviderConfig;
         registered?: undefined;
@@ -340,9 +340,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         message?: undefined;
     } | {
         provider?: undefined;
-        count?: undefined;
         deleted?: undefined;
         providers?: undefined;
+        count?: undefined;
         found: boolean;
         id: string;
         registered?: undefined;
@@ -350,9 +350,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         message?: undefined;
     } | {
         provider?: undefined;
-        count?: undefined;
-        providers?: undefined;
         found?: undefined;
+        providers?: undefined;
+        count?: undefined;
         deleted: boolean;
         id: string;
         registered?: undefined;
@@ -360,10 +360,10 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         message?: undefined;
     } | {
         provider?: undefined;
-        count?: undefined;
         deleted?: undefined;
-        providers?: undefined;
         found?: undefined;
+        providers?: undefined;
+        count?: undefined;
         registered: boolean;
         id: string;
         label: string;

package/dist/resources/handlers.d.ts

@@ -39,8 +39,8 @@ export declare function handleUpdateResource(event: any): Promise<import("./stor
     error: string;
 }>;
 export declare function handleDeleteResource(event: any): Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/secrets/routes.d.ts

@@ -55,31 +55,31 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
 } | {
     error: string;
     errorCode?: undefined;
-    status?: undefined;
     ok?: undefined;
+    status?: undefined;
 } | {
     error: string;
     errorCode: string;
-    status?: undefined;
     ok?: undefined;
+    status?: undefined;
 } | {
     errorCode?: undefined;
     ok: boolean;
     status: string;
     error?: undefined;
 } | {
+    ok?: undefined;
     error: string;
     removed?: undefined;
-    ok?: undefined;
 } | {
     ok: boolean;
     removed: boolean;
     error?: undefined;
 }>>;
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    ok?: undefined;
     error: string;
     note?: undefined;
-    ok?: undefined;
 } | {
     ok: boolean;
     note?: undefined;

package/dist/server/agent-chat-plugin.js

@@ -33,6 +33,7 @@ import { isProductionServerlessFunctionRuntime, isTransientDatabaseError, } from
 import { filterFrameworkToolGroups, resolveFrameworkTools, } from "../framework-tools.js";
 import { verifyInternalToken, extractBearerToken, } from "../integrations/internal-token.js";
 import { RECURRING_JOBS_SWEEP_PATH, RECURRING_JOBS_SWEEP_TOKEN_SUBJECT, } from "../jobs/scheduler-dispatch.js";
+import { RECURRING_SWEEP_BUDGET_MS } from "../jobs/sweep-hooks.js";
 import { McpClientManager, mcpToolsToActionEntries, syncMcpActionEntries, mountMcpServersRoutes, mountMcpHubRoutes, buildMergedConfig, startMcpConfigRefresh, getHubStatus, isHubServeEnabled, } from "../mcp-client/index.js";
 import { declaredMcpToolNames } from "../mcp/build-server.js";
 import { setProgressPreListHook } from "../progress/store.js";
@@ -5915,6 +5916,9 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                             error: "Recurring-job sweep reached the synchronous server instead of the durable background worker.",
                         };
                     }
+                    const sweepContext = {
+                        deadlineAt: Date.now() + RECURRING_SWEEP_BUDGET_MS,
+                    };
                     // Stale reaping runs FIRST and site-wide, before the open-ended job
                     // sweep can spend the platform wall. It is the durable driver the
                     // in-process fast sweep below cannot be on serverless: that timer is
@@ -5941,6 +5945,8 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                         console.error("[agent-chat] durable stale-run reap failed:", error);
                         return null;
                     });
+                    const { runRecurringSweepHandlers } = await import("../jobs/sweep-hooks.js");
+                    const appSweepHandlers = await runRecurringSweepHandlers(sweepContext);
                     // Rides the same site-tick as the reap above, for the same reason:
                     // it is the only durable driver on serverless. Never fatal to the
                     // job sweep, and its own failure is a distinguishable outcome
@@ -5961,8 +5967,6 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                         console.error("[agent-chat] durable unclaimed-run sweep failed:", error);
                         return null;
                     });
-                    const { runRecurringSweepHandlers } = await import("../jobs/sweep-hooks.js");
-                    const appSweepHandlers = await runRecurringSweepHandlers();
                     const triggerAvailability = scheduledTriggerAvailability();
                     if (unclaimedBackgroundRuns === null) {
                         setResponseStatus(event, 500);

package/dist/server/agent-engine-api-key-route.d.ts

@@ -65,6 +65,7 @@ export declare function createAgentEngineApiKeyHandler(): import("h3").EventHand
     error: any;
     code: any;
 } | {
+    error?: undefined;
     errorCode?: undefined;
     code?: undefined;
     ok: boolean;
@@ -72,6 +73,5 @@ export declare function createAgentEngineApiKeyHandler(): import("h3").EventHand
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
     defaultModel?: import("./agent-engine-default-model-route.js").SavedKeyDefaultModelOutcome;
-    error?: undefined;
 }>>;
 export {};

package/dist/server/agent-engine-default-model-route.d.ts

@@ -8,8 +8,8 @@ export declare const AGENT_ENGINE_API_KEY_ACTION_NAME = "agent-engine-api-key";
  * resolveEngine's credential detection.
  */
 export declare function createAgentEngineDisconnectHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
     scope?: undefined;
 } | {
     ok: boolean;

package/dist/server/agent-engine-ollama-models-route.d.ts

@@ -1,7 +1,7 @@
 export declare function createAgentEngineOllamaModelsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    ok?: undefined;
     models?: undefined;
+    ok?: undefined;
 } | {
     ok: boolean;
     models: string[];

package/dist/server/index.d.ts

@@ -97,7 +97,7 @@ export { sendEmail, isEmailConfigured, getEmailReadiness, getEmailProvider, type
 export { defineTransactionalEmail, defineTransactionalEmails, replaceTransactionalEmails, listTransactionalEmails, getTransactionalEmail, renderTransactionalEmailPreview, type TransactionalEmailDefinition, type RegisteredTransactionalEmail, } from "../email-catalog/registry.js";
 export { notifyActivity, runActivityNotification, resolveActivityRecipients, type ActivityDeliveryFailure, type ActivityNotificationResult, type ActivityNotificationStatus, type NotifyActivityInput, type ResolveActivityRecipientsInput, } from "./activity-notifications.js";
 export { renderEmail, emailStrong, emailQuote, emailLink, type RenderEmailArgs, type RenderedEmail, type EmailCta, } from "./email-template.js";
-export { hasRecurringSweepHandler, registerRecurringSweepHandler, runRecurringSweepHandlers, type RecurringSweepHandler, } from "../jobs/sweep-hooks.js";
+export { hasRecurringSweepHandler, registerRecurringSweepHandler, runRecurringSweepHandlers, type RecurringSweepContext, type RecurringSweepHandler, } from "../jobs/sweep-hooks.js";
 export { scheduledTriggerAvailability, type ScheduledTriggerAvailability, } from "./agent-chat/recurring-jobs-runtime.js";
 export { getAppProductionUrl, getFirstPartyProdUrl, resolveAppRuntimeUrl, } from "./app-url.js";
 export { getConfiguredAppBasePath, normalizeAppBasePath, withConfiguredAppBasePath, } from "./app-base-path.js";

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