@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/scheduler/journal-transaction.js

@@ -1,4 +1,5 @@
 import { parseStoredJob, parseStoredRun } from "./snapshot-validation.js";
+import { hasAutomationTransactionChanges, parseAutomationTransaction, } from "./journal-automation-transaction.js";
 export function parseSchedulerTransaction(value) {
     if (!isSchedulerTransactionRecord(value))
         throw new Error("scheduler_store_corrupt");
@@ -6,7 +7,7 @@ export function parseSchedulerTransaction(value) {
     if (!hasSchedulerTransactionCollections(raw))
         throw new Error("scheduler_store_corrupt");
     const transaction = {
-        version: 1,
+        version: raw.version,
         jobs: raw.jobs.map(parseStoredJob),
         runs: raw.runs.map(parseStoredRun),
         deletedJobs: requireJournalIds(raw.deletedJobs),
@@ -17,6 +18,9 @@ export function parseSchedulerTransaction(value) {
         ...(raw.runOrder === undefined
             ? {}
             : { runOrder: requireJournalIds(raw.runOrder) }),
+        ...(raw.version === 2
+            ? { automation: parseAutomationTransaction(raw.automation ?? {}) }
+            : {}),
     };
     assertJournalTransactionIds(transaction);
     return transaction;
@@ -27,10 +31,12 @@ function isSchedulerTransactionRecord(value) {
     return !Array.isArray(value);
 }
 function hasSchedulerTransactionCollections(value) {
-    if (value.version !== 1)
+    if (value.version !== 1 && value.version !== 2)
         return false;
     if (!Array.isArray(value.jobs))
         return false;
+    if (value.version === 1 && value.automation !== undefined)
+        return false;
     return Array.isArray(value.runs);
 }
 export function assertJournalTransactionIds(transaction) {
@@ -100,5 +106,10 @@ export function hasSchedulerTransactionChanges(value) {
         return true;
     if (value.deletedJobs.length || value.deletedRuns.length)
         return true;
+    if (value.automation && hasAutomationTransactionChanges(value.automation))
+        return true;
     return value.jobOrder !== undefined || value.runOrder !== undefined;
 }
+export function withAutomationTransaction(scheduler, automation) {
+    return { ...scheduler, version: 2, automation };
+}

package/dist/src/runtime/scheduler/next-occurrence.js

@@ -4,6 +4,8 @@ import { addCalendarDays, calendarDateAt, calendarWeekday, resolveCalendarTime,
 /** Strictly after the supplied instant. Never shifts missing calendar dates or times. */
 export function nextSchedulerOccurrence(schedule, timeZone, after) {
     switch (schedule.kind) {
+        case "manual":
+            return null;
         case "timer":
         case "once":
             return Date.parse(schedule.at) > after ? schedule.at : null;

package/dist/src/runtime/scheduler/run-completion.js

@@ -1,3 +1,4 @@
+import { isRequestSchedulerRun } from "./scheduler-target.js";
 export async function settleSchedulerRun(context, run, generation, execution, release) {
     const identity = {
         runId: run.id,
@@ -67,7 +68,7 @@ function canPersistCompletion(context, completion) {
     return !context.deletedSessions.has(completion.sessionId);
 }
 function isUnsettledCapturedRun(run, completion) {
-    if (!run)
+    if (!run || !isRequestSchedulerRun(run))
         return false;
     if (run.status !== "running")
         return false;

package/dist/src/runtime/scheduler/run-records.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { isRequestSchedulerJob, isRequestSchedulerRun, } from "./scheduler-target.js";
 export function makeSchedulerRun(job, scheduledAt, trigger) {
     return {
         id: randomUUID(),
@@ -19,7 +20,9 @@ export function makeSchedulerRun(job, scheduledAt, trigger) {
     };
 }
 export function findPendingRun(state, jobId) {
-    return state.runs.find((run) => run.jobId === jobId && run.status === "pending");
+    return state.runs.find((run) => isRequestSchedulerRun(run) &&
+        run.jobId === jobId &&
+        run.status === "pending");
 }
 export function cancelPendingRuns(state, jobId, at) {
     for (const run of state.runs) {
@@ -32,11 +35,13 @@ export function cancelPendingRuns(state, jobId, at) {
     }
 }
 export function requireSchedulerJob(state, jobId) {
-    const job = state.jobs.find((candidate) => candidate.id === jobId);
+    const job = state.jobs.find((candidate) => isRequestSchedulerJob(candidate) && candidate.id === jobId);
     if (!job)
         throw new Error("scheduler_job_not_found");
     return job;
 }
 export function hasRunningSession(state, sessionId) {
-    return state.runs.some((run) => run.sessionId === sessionId && run.status === "running");
+    return state.runs.some((run) => isRequestSchedulerRun(run) &&
+        run.sessionId === sessionId &&
+        run.status === "running");
 }

package/dist/src/runtime/scheduler/schedule-update.d.ts

@@ -1,3 +1,3 @@
-import type { SchedulerSchedule, SchedulerScheduleInput } from "./contracts.js";
+import type { SchedulerScheduleInput, SchedulerTimedSchedule } from "./contracts.js";
 /** PATCH preserves omitted or exact stored timing; actual edits are new input. */
-export declare function normalizeSchedulerScheduleUpdate(stored: SchedulerSchedule, input: SchedulerScheduleInput | undefined, now: number): SchedulerSchedule;
+export declare function normalizeSchedulerScheduleUpdate(stored: SchedulerTimedSchedule, input: SchedulerScheduleInput | undefined, now: number): SchedulerTimedSchedule;

package/dist/src/runtime/scheduler/schedule-validation.d.ts

@@ -1,10 +1,10 @@
-import type { CreateSchedulerJobInput, SchedulerSchedule, SchedulerScheduleInput } from "./contracts.js";
+import type { CreateSchedulerJobInput, SchedulerSchedule, SchedulerScheduleInput, SchedulerTimedSchedule } from "./contracts.js";
 export { SchedulerValidationError } from "./validation-error.js";
 export { parseSchedulerInstant } from "./instant-validation.js";
 export declare function requireSchedulerText(value: unknown, field: string): string;
 export declare function validateSchedulerJobInput(input: CreateSchedulerJobInput): void;
 export declare function validateTimeZone(timeZone: string): void;
 export declare function requireCalendarHour(value: unknown): string;
-export declare function normalizeSchedulerSchedule(input: SchedulerScheduleInput, now: number): SchedulerSchedule;
+export declare function normalizeSchedulerSchedule(input: SchedulerScheduleInput, now: number): SchedulerTimedSchedule;
 /** Stored timer deadlines are canonical state, not new relative timer input. */
 export declare function normalizeStoredSchedulerSchedule(schedule: SchedulerSchedule): SchedulerSchedule;

package/dist/src/runtime/scheduler/schedule-validation.js

@@ -98,6 +98,8 @@ export function normalizeSchedulerSchedule(input, now) {
 }
 /** Stored timer deadlines are canonical state, not new relative timer input. */
 export function normalizeStoredSchedulerSchedule(schedule) {
+    if (schedule?.kind === "manual")
+        return { kind: "manual" };
     if (schedule?.kind !== "timer")
         return normalizeSchedulerSchedule(schedule, 0);
     return {

package/dist/src/runtime/scheduler/scheduler-engine.js

@@ -1,26 +1,38 @@
+import { dispatchPendingAutomationRun, enqueueDueAutomationOccurrences, } from "./automation-scheduler-engine.js";
+import { reconcileAutomationSchedulerCompletions } from "./automation-run-completion.js";
 import { nextSchedulerOccurrence } from "./next-occurrence.js";
 import { reconcileSchedulerCompletions, settleSchedulerRun, } from "./run-completion.js";
 import { findPendingRun, hasRunningSession, makeSchedulerRun, } from "./run-records.js";
-import { canBeginSchedulerRun, jobEpoch, } from "./service-context.js";
+import { canBeginRequestSchedulerRun, jobEpoch, } from "./service-context.js";
+import { isAutomationSchedulerRun, isRequestSchedulerJob, isRequestSchedulerRun, } from "./scheduler-target.js";
 export async function tickScheduler(context) {
     if (!context.running)
         return;
     await reconcileSchedulerCompletions(context);
+    await reconcileAutomationSchedulerCompletions(context);
     if (!context.running)
         return;
     const now = context.now();
+    await context.automationExecutor?.maintainRetention?.(now);
     const snapshot = await context.store.read();
     const hasDue = snapshot.jobs.some((job) => isDueJob(job, now));
     if (hasDue)
         await enqueueDueOccurrences(context, now);
+    await enqueueDueAutomationOccurrences(context, now);
     const pending = (await context.store.read()).runs.filter((run) => run.status === "pending");
     for (const run of pending) {
         if (!context.running)
             return;
+        if (isAutomationSchedulerRun(run)) {
+            await dispatchPendingAutomationRun(context, run);
+            continue;
+        }
         await dispatchPendingRun(context, run);
     }
 }
 function isDueJob(job, now) {
+    if (!isRequestSchedulerJob(job))
+        return false;
     if (job.state !== "active")
         return false;
     if (!job.nextRunAt)
@@ -30,6 +42,8 @@ function isDueJob(job, now) {
 async function enqueueDueOccurrences(context, now) {
     await context.store.update((state) => {
         for (const job of state.jobs) {
+            if (!isRequestSchedulerJob(job))
+                continue;
             if (!isDueJob(job, now))
                 continue;
             const pending = findPendingRun(state, job.id);
@@ -61,7 +75,7 @@ async function dispatchPendingRun(context, pending) {
         await removeDeletedSession(context, pending.sessionId);
         return;
     }
-    if (!canBeginSchedulerRun(context, pending.jobId, pending.sessionId, epoch))
+    if (!canBeginRequestSchedulerRun(context, pending.jobId, pending.sessionId, epoch))
         return;
     const release = await context.executor.tryReserve(pending.sessionId);
     if (!release)
@@ -72,7 +86,7 @@ async function dispatchPendingRun(context, pending) {
         if (!claimed)
             return;
         // Last validity guard and start invocation are in the same synchronous turn.
-        if (!canBeginSchedulerRun(context, pending.jobId, pending.sessionId, epoch)) {
+        if (!canBeginRequestSchedulerRun(context, pending.jobId, pending.sessionId, epoch)) {
             await cancelClaimedRun(context, pending.id);
             return;
         }
@@ -120,15 +134,17 @@ async function lookupPendingRunSession(context, pending) {
 }
 async function claimPendingRun(context, pending, epoch) {
     return context.store.update((state) => {
-        if (!canBeginSchedulerRun(context, pending.jobId, pending.sessionId, epoch))
+        if (!canBeginRequestSchedulerRun(context, pending.jobId, pending.sessionId, epoch))
             return null;
         const job = state.jobs.find((item) => item.id === pending.jobId);
-        if (!job)
+        if (!job || !isRequestSchedulerJob(job))
             return null;
         if (job.state === "cancelled")
             return null;
         const run = state.runs.find((item) => item.id === pending.id);
-        if (!run || run.status !== "pending")
+        if (!run || !isRequestSchedulerRun(run))
+            return null;
+        if (run.status !== "pending")
             return null;
         if (job.state === "paused" && run.trigger !== "manual")
             return null;
@@ -169,7 +185,7 @@ async function cancelClaimedRun(context, runId) {
 }
 async function removeDeletedSession(context, sessionId) {
     await context.store.update((state) => {
-        state.jobs = state.jobs.filter((job) => job.sessionId !== sessionId);
-        state.runs = state.runs.filter((run) => run.sessionId !== sessionId);
+        state.jobs = state.jobs.filter((job) => !isRequestSchedulerJob(job) || job.sessionId !== sessionId);
+        state.runs = state.runs.filter((run) => !isRequestSchedulerRun(run) || run.sessionId !== sessionId);
     });
 }

package/dist/src/runtime/scheduler/scheduler-service.d.ts

@@ -1,10 +1,13 @@
-import type { SchedulerExecutor, SchedulerService, SchedulerStore } from "./contracts.js";
+import type { SchedulerAutomationExecutor, SchedulerExecutor, SchedulerService, SchedulerStore } from "./contracts.js";
+import { type AutomationRunChange } from "./automation-run-change-events.js";
 export interface SchedulerServiceOptions {
     environmentId: string;
     store: SchedulerStore;
     executor: SchedulerExecutor;
+    automationExecutor?: SchedulerAutomationExecutor;
     now?: () => number;
     tickIntervalMs?: number;
     onError?: (error: unknown) => void;
+    onAutomationRunChange?: (change: AutomationRunChange) => void;
 }
 export declare function createSchedulerService(options: SchedulerServiceOptions): SchedulerService;

package/dist/src/runtime/scheduler/scheduler-service.js

@@ -1,10 +1,15 @@
+import { changeAutomationSchedulerJobState, createAutomationSchedulerJob, requestAutomationSchedulerRunNow, updateAutomationSchedulerJob, } from "./automation-job-management.js";
+import { stopAutomationSchedulerRun } from "./automation-run-control.js";
+import { requestAutomationSchedulerRerun } from "./automation-rerun.js";
 import { changeSchedulerJobState, createSchedulerJob, deleteSchedulerSession, matchesSchedulerFilter, requestSchedulerRunNow, updateSchedulerJob, } from "./job-management.js";
 import { tickScheduler } from "./scheduler-engine.js";
 import { requireRunningScheduler, } from "./service-context.js";
 import { recoverSchedulerSnapshot } from "./startup-recovery.js";
 import { querySchedulerRuns } from "./run-list-query.js";
 import { createSchedulerWorkingStore } from "./working-store.js";
+import { observeAutomationRunChanges } from "./automation-run-change-events.js";
 import { SchedulerSessionDeletionState } from "./session-deletion-state.js";
+import { isAutomationSchedulerJob, isAutomationSchedulerRun, isRequestSchedulerJob, isRequestSchedulerRun, } from "./scheduler-target.js";
 export function createSchedulerService(options) {
     let tail = Promise.resolve();
     let releaseOwner;
@@ -12,8 +17,11 @@ export function createSchedulerService(options) {
     let ticking;
     const context = {
         environmentId: options.environmentId,
-        store: createSchedulerWorkingStore(options.store),
+        store: options.onAutomationRunChange
+            ? observeAutomationRunChanges(createSchedulerWorkingStore(options.store), options.onAutomationRunChange)
+            : createSchedulerWorkingStore(options.store),
         executor: options.executor,
+        automationExecutor: options.automationExecutor,
         now: options.now ?? Date.now,
         running: false,
         generation: 0,
@@ -21,6 +29,7 @@ export function createSchedulerService(options) {
         pendingJobMutations: new Set(),
         deletedSessions: new SchedulerSessionDeletionState(),
         pendingCompletions: new Map(),
+        pendingAutomationCompletions: new Map(),
         enqueue: (operation) => {
             const result = tail.then(operation);
             tail = result.catch(() => undefined);
@@ -39,9 +48,25 @@ export function createSchedulerService(options) {
                 const release = await options.store.acquire();
                 releaseOwner = release;
                 try {
-                    await context.store.update((state) => {
-                        recoverSchedulerSnapshot(state, options.environmentId, context.now());
-                    });
+                    const automationExecutor = options.automationExecutor;
+                    if (automationExecutor) {
+                        const update = context.store.updateWithAutomations;
+                        if (!update)
+                            throw new Error("automation_store_unavailable");
+                        await update((state, automations) => {
+                            const recovered = recoverSchedulerSnapshot(state, options.environmentId, context.now());
+                            automationExecutor.recover(state, automations, recovered);
+                            requireRecoveredAutomationReports(state, automations, recovered);
+                        });
+                        await automationExecutor.reconcileSessions?.().catch(context.onError);
+                    }
+                    else {
+                        await context.store.update((state) => {
+                            if (state.jobs.some(isAutomationSchedulerJob))
+                                throw new Error("automation_executor_unavailable");
+                            recoverSchedulerSnapshot(state, options.environmentId, context.now());
+                        });
+                    }
                     if (requestedGeneration !== context.generation) {
                         await release();
                         releaseOwner = undefined;
@@ -65,6 +90,7 @@ export function createSchedulerService(options) {
             context.generation += 1;
             context.running = false;
             context.pendingCompletions.clear();
+            context.pendingAutomationCompletions.clear();
             if (timer)
                 clearInterval(timer);
             timer = undefined;
@@ -90,11 +116,13 @@ export function createSchedulerService(options) {
         create: (input) => createSchedulerJob(context, input),
         list: (filter = {}) => context.enqueue(async () => {
             requireRunningScheduler(context);
-            return (await context.store.read()).jobs.filter((job) => matchesSchedulerFilter(job, filter));
+            return (await context.store.read()).jobs
+                .filter(isRequestSchedulerJob)
+                .filter((job) => matchesSchedulerFilter(job, filter));
         }),
         get: (jobId) => context.enqueue(async () => {
             requireRunningScheduler(context);
-            return ((await context.store.read()).jobs.find((job) => job.id === jobId) ??
+            return ((await context.store.read()).jobs.find((job) => isRequestSchedulerJob(job) && job.id === jobId) ??
                 null);
         }),
         update: (jobId, patch) => updateSchedulerJob(context, jobId, patch),
@@ -105,11 +133,56 @@ export function createSchedulerService(options) {
         deleteSession: (sessionId) => deleteSchedulerSession(context, sessionId),
         listRuns: (jobId, query) => context.enqueue(async () => {
             requireRunningScheduler(context);
-            if (options.store.readRuns)
-                return options.store.readRuns(jobId, query);
-            const runs = (await options.store.read()).runs;
-            return querySchedulerRuns(runs, jobId, query);
+            const runs = options.store.readRuns
+                ? await options.store.readRuns(jobId, query, "request")
+                : (await options.store.read()).runs;
+            return querySchedulerRuns(runs.filter(isRequestSchedulerRun), jobId, options.store.readRuns ? undefined : query);
+        }),
+        createAutomationJob: (input, commitPublication) => createAutomationSchedulerJob(context, input, commitPublication),
+        getAutomationJob: (automationId) => context.enqueue(async () => {
+            requireRunningScheduler(context);
+            return ((await context.store.read()).jobs.find((job) => isAutomationSchedulerJob(job) &&
+                job.target.automationId === automationId) ?? null);
+        }),
+        listAutomationJobs: () => context.enqueue(async () => {
+            requireRunningScheduler(context);
+            return (await context.store.read()).jobs.filter(isAutomationSchedulerJob);
+        }),
+        updateAutomationJob: (jobId, patch, commitPublication) => updateAutomationSchedulerJob(context, jobId, patch, commitPublication),
+        pauseAutomationJob: (jobId) => changeAutomationSchedulerJobState(context, jobId, "paused"),
+        resumeAutomationJob: (jobId) => changeAutomationSchedulerJobState(context, jobId, "active"),
+        runNowAutomation: (jobId, runOptions) => requestAutomationSchedulerRunNow(context, jobId, runOptions),
+        rerunAutomationRun: (previousRunId, runOptions) => requestAutomationSchedulerRerun(context, previousRunId, runOptions),
+        stopAutomationRun: (runId) => stopAutomationSchedulerRun(context, runId),
+        listAutomationRuns: (automationId, query) => context.enqueue(async () => {
+            requireRunningScheduler(context);
+            const job = (await context.store.read()).jobs.find((item) => isAutomationSchedulerJob(item) &&
+                item.target.automationId === automationId);
+            if (!job)
+                return [];
+            const boundedQuery = query ?? { limit: 100 };
+            const runs = options.store.readRuns
+                ? await options.store.readRuns(job.id, boundedQuery, "automation")
+                : (await options.store.read()).runs;
+            return querySchedulerRuns(runs.filter(isAutomationSchedulerRun), job.id, options.store.readRuns ? undefined : boundedQuery);
+        }),
+        getAutomationRun: (runId) => context.enqueue(async () => {
+            requireRunningScheduler(context);
+            const run = options.store.readRun
+                ? await options.store.readRun(runId)
+                : (await options.store.read()).runs.find((item) => item.id === runId);
+            return run && isAutomationSchedulerRun(run) ? run : null;
         }),
     };
     return service;
 }
+function requireRecoveredAutomationReports(scheduler, automations, runIds) {
+    for (const runId of runIds) {
+        const run = scheduler.runs.find((item) => item.id === runId);
+        if (!run || !isAutomationSchedulerRun(run) || !run.reportRef)
+            throw new Error("automation_report_missing");
+        const execution = automations.executions.find((item) => item.id === runId);
+        if (execution?.reportRef !== run.reportRef)
+            throw new Error("automation_report_missing");
+    }
+}

package/dist/src/runtime/scheduler/scheduler-target.d.ts

@@ -0,0 +1,9 @@
+import type { SchedulerAutomationJob, SchedulerAutomationRun, SchedulerJob, SchedulerRun, SchedulerStoredJob, SchedulerStoredRun } from "./contracts.js";
+export declare function isAutomationSchedulerJob(job: SchedulerStoredJob): job is SchedulerAutomationJob;
+export declare function isRequestSchedulerJob(job: SchedulerStoredJob): job is SchedulerJob;
+export declare function isAutomationSchedulerRun(run: SchedulerStoredRun): run is SchedulerAutomationRun;
+export declare function isRequestSchedulerRun(run: SchedulerStoredRun): run is SchedulerRun;
+export declare function requireRequestSchedulerJob(job: SchedulerStoredJob): SchedulerJob;
+export declare function requireRequestSchedulerRun(run: SchedulerStoredRun): SchedulerRun;
+export declare function sameSchedulerTarget(job: SchedulerStoredJob, run: SchedulerStoredRun): boolean;
+export declare function schedulerTargetKey(value: SchedulerStoredJob | SchedulerStoredRun): string;

package/dist/src/runtime/scheduler/scheduler-target.js

@@ -0,0 +1,41 @@
+export function isAutomationSchedulerJob(job) {
+    return job.target?.kind === "automation";
+}
+export function isRequestSchedulerJob(job) {
+    return !isAutomationSchedulerJob(job);
+}
+export function isAutomationSchedulerRun(run) {
+    return run.target?.kind === "automation";
+}
+export function isRequestSchedulerRun(run) {
+    return !isAutomationSchedulerRun(run);
+}
+export function requireRequestSchedulerJob(job) {
+    if (!isRequestSchedulerJob(job))
+        throw new Error("scheduler_request_job_required");
+    return job;
+}
+export function requireRequestSchedulerRun(run) {
+    if (!isRequestSchedulerRun(run))
+        throw new Error("scheduler_request_run_required");
+    return run;
+}
+export function sameSchedulerTarget(job, run) {
+    if (isAutomationSchedulerJob(job)) {
+        if (!isAutomationSchedulerRun(run))
+            return false;
+        if (job.target.automationId !== run.target.automationId)
+            return false;
+        return run.target.definitionRevision <= job.target.definitionRevision;
+    }
+    if (!isRequestSchedulerRun(run))
+        return false;
+    return job.sessionId === run.sessionId;
+}
+export function schedulerTargetKey(value) {
+    if (value.target?.kind === "automation")
+        return `automation:${value.target.automationId}`;
+    if (!("sessionId" in value))
+        throw new Error("scheduler_store_corrupt");
+    return `session:${value.sessionId}`;
+}

package/dist/src/runtime/scheduler/service-context.d.ts

@@ -1,10 +1,12 @@
-import type { SchedulerExecutor, SchedulerStore } from "./contracts.js";
+import type { SchedulerAutomationExecutor, SchedulerExecutor, SchedulerStore } from "./contracts.js";
 import type { SchedulerRunCompletion } from "./run-completion.js";
+import type { AutomationSchedulerRunCompletion } from "./automation-run-completion.js";
 import type { SchedulerSessionDeletionState } from "./session-deletion-state.js";
 export interface SchedulerContext {
     environmentId: string;
     store: SchedulerStore;
     executor: SchedulerExecutor;
+    automationExecutor?: SchedulerAutomationExecutor;
     now(): number;
     running: boolean;
     generation: number;
@@ -12,10 +14,12 @@ export interface SchedulerContext {
     pendingJobMutations: Set<string>;
     deletedSessions: SchedulerSessionDeletionState;
     pendingCompletions: Map<string, SchedulerRunCompletion>;
+    pendingAutomationCompletions: Map<string, AutomationSchedulerRunCompletion>;
     enqueue<T>(operation: () => Promise<T>): Promise<T>;
     onError(error: unknown): void;
 }
 export declare function requireRunningScheduler(context: SchedulerContext): void;
 export declare function jobEpoch(context: SchedulerContext, jobId: string): number;
 export declare function invalidateJob(context: SchedulerContext, jobId: string): () => void;
-export declare function canBeginSchedulerRun(context: SchedulerContext, jobId: string, sessionId: string, epoch: number): boolean;
+export declare function canBeginSchedulerRun(context: SchedulerContext, jobId: string, epoch: number): boolean;
+export declare function canBeginRequestSchedulerRun(context: SchedulerContext, jobId: string, sessionId: string, epoch: number): boolean;

package/dist/src/runtime/scheduler/service-context.js

@@ -15,12 +15,15 @@ export function invalidateJob(context, jobId) {
         context.pendingJobMutations.delete(jobId);
     };
 }
-export function canBeginSchedulerRun(context, jobId, sessionId, epoch) {
+export function canBeginSchedulerRun(context, jobId, epoch) {
     if (!context.running)
         return false;
-    if (context.deletedSessions.has(sessionId))
-        return false;
     if (context.pendingJobMutations.has(jobId))
         return false;
     return jobEpoch(context, jobId) === epoch;
 }
+export function canBeginRequestSchedulerRun(context, jobId, sessionId, epoch) {
+    if (context.deletedSessions.has(sessionId))
+        return false;
+    return canBeginSchedulerRun(context, jobId, epoch);
+}

package/dist/src/runtime/scheduler/snapshot-validation.d.ts

@@ -1,4 +1,4 @@
-import type { SchedulerJob, SchedulerRun, SchedulerSnapshot } from "./contracts.js";
-export declare function parseStoredJob(value: unknown): SchedulerJob;
-export declare function parseStoredRun(value: unknown): SchedulerRun;
+import type { SchedulerSnapshot, SchedulerStoredJob, SchedulerStoredRun } from "./contracts.js";
+export declare function parseStoredJob(value: unknown): SchedulerStoredJob;
+export declare function parseStoredRun(value: unknown): SchedulerStoredRun;
 export declare function parseSchedulerSnapshot(value: unknown): SchedulerSnapshot;

package/dist/src/runtime/scheduler/snapshot-validation.js

@@ -1,3 +1,5 @@
+import { parseStoredAutomationJob, parseStoredAutomationRun, } from "./automation-snapshot-validation.js";
+import { sameSchedulerTarget } from "./scheduler-target.js";
 import { normalizeStoredSchedulerSchedule, validateSchedulerJobInput, validateTimeZone, } from "./schedule-validation.js";
 import { isSchedulerToolPermissionMode, requireSchedulerToolPermissionMode, } from "./tool-permission-mode.js";
 function isRecord(value) {
@@ -17,6 +19,10 @@ function requireSnapshotInstant(value) {
 export function parseStoredJob(value) {
     if (!isRecord(value))
         failSnapshot();
+    if (isAutomationTarget(value.target))
+        return parseStoredAutomationJob(value);
+    if (!isRequestTarget(value.target))
+        failSnapshot();
     const job = value;
     validateSchedulerJobInput(job);
     if (!job.id || !job.environmentId)
@@ -37,11 +43,17 @@ export function parseStoredJob(value) {
     if (job.schedule?.kind === "interval" && !job.schedule.anchorAt)
         failSnapshot();
     const normalized = normalizeStoredSchedulerSchedule(job.schedule);
+    if (normalized.kind === "manual")
+        failSnapshot();
     return { ...job, schedule: normalized };
 }
 export function parseStoredRun(value) {
     if (!isRecord(value))
         failSnapshot();
+    if (isAutomationTarget(value.target))
+        return parseStoredAutomationRun(value);
+    if (!isRequestTarget(value.target))
+        failSnapshot();
     for (const field of [
         "id",
         "jobId",
@@ -103,7 +115,7 @@ export function parseSchedulerSnapshot(value) {
         const owner = jobs.find((job) => job.id === run.jobId);
         if (!owner)
             failSnapshot();
-        if (owner.sessionId !== run.sessionId)
+        if (!sameSchedulerTarget(owner, run))
             failSnapshot();
         if (owner.environmentId !== run.environmentId)
             failSnapshot();
@@ -112,3 +124,11 @@ export function parseSchedulerSnapshot(value) {
     }
     return { schemaVersion: 1, jobs, runs };
 }
+function isAutomationTarget(value) {
+    return isRecord(value) && value.kind === "automation";
+}
+function isRequestTarget(value) {
+    if (value === undefined)
+        return true;
+    return isRecord(value) && value.kind === "request";
+}

package/dist/src/runtime/scheduler/startup-recovery.d.ts

@@ -1,2 +1,2 @@
 import type { SchedulerSnapshot } from "./contracts.js";
-export declare function recoverSchedulerSnapshot(state: SchedulerSnapshot, environmentId: string, now: number): void;
+export declare function recoverSchedulerSnapshot(state: SchedulerSnapshot, environmentId: string, now: number): string[];

package/dist/src/runtime/scheduler/startup-recovery.js

@@ -1,16 +1,22 @@
+import { randomUUID } from "node:crypto";
+import { makeAutomationSchedulerRun } from "./automation-run-records.js";
 import { nextSchedulerOccurrence } from "./next-occurrence.js";
 import { makeSchedulerRun } from "./run-records.js";
+import { isAutomationSchedulerJob, isAutomationSchedulerRun, } from "./scheduler-target.js";
 export function recoverSchedulerSnapshot(state, environmentId, now) {
     const at = new Date(now).toISOString();
+    const recoveredAutomationRuns = [];
     for (const job of state.jobs) {
         if (job.environmentId !== environmentId)
             throw new Error("scheduler_environment_mismatch");
     }
     for (const run of state.runs) {
-        if (run.status === "running") {
+        if (run.status === "running" || run.status === "stopping") {
             run.status = "interrupted";
             run.finishedAt = at;
             run.error = "scheduler_process_stopped";
+            if (isAutomationSchedulerRun(run))
+                recoveredAutomationRuns.push(run.id);
             continue;
         }
         if (run.status !== "pending")
@@ -18,6 +24,8 @@ export function recoverSchedulerSnapshot(state, environmentId, now) {
         run.status = "missed";
         run.finishedAt = at;
         run.error = "scheduler_offline_no_catchup";
+        if (isAutomationSchedulerRun(run))
+            recoveredAutomationRuns.push(run.id);
     }
     for (const job of state.jobs) {
         if (job.state !== "active")
@@ -26,13 +34,18 @@ export function recoverSchedulerSnapshot(state, environmentId, now) {
             continue;
         if (Date.parse(job.nextRunAt) > now)
             continue;
-        const missed = makeSchedulerRun(job, job.nextRunAt, "schedule");
+        const missed = isAutomationSchedulerJob(job)
+            ? makeAutomationSchedulerRun(job, randomUUID(), job.nextRunAt, "schedule")
+            : makeSchedulerRun(job, job.nextRunAt, "schedule");
         missed.status = "missed";
         missed.finishedAt = at;
         missed.error = "scheduler_offline_no_catchup";
         state.runs.push(missed);
+        if (isAutomationSchedulerRun(missed))
+            recoveredAutomationRuns.push(missed.id);
         job.nextRunAt = nextSchedulerOccurrence(job.schedule, job.timeZone, now);
         if (!job.nextRunAt)
             job.state = "completed";
     }
+    return recoveredAutomationRuns;
 }

package/dist/src/runtime/scheduler/working-store.js

@@ -3,6 +3,14 @@ export function createSchedulerWorkingStore(store) {
     return {
         acquire: () => store.acquire(),
         read: () => store.read("active"),
+        readRun: store.readRun?.bind(store),
+        readAutomationRunByKey: store.readAutomationRunByKey?.bind(store),
+        countAutomationRunsOnDay: store.countAutomationRunsOnDay?.bind(store),
         update: (mutate) => store.update(mutate, "active"),
+        readAutomations: store.readAutomations?.bind(store),
+        updateAutomations: store.updateAutomations?.bind(store),
+        updateWithAutomations: store.updateWithAutomations
+            ? (mutate) => store.updateWithAutomations(mutate, "active")
+            : undefined,
     };
 }

package/dist/src/runtime/session/request-session.d.ts

@@ -28,6 +28,7 @@ export declare function initializeRequestSession(params: {
     sessionStore: RequestSessionStore;
     attachmentStore?: RuntimeAttachmentStore;
     events: EventSink;
+    onUserMessagePersisted?(): void;
     schedule?: import("../../sessions/schedule-metadata.js").ScheduleMessageReference;
 }): Promise<Readonly<{
     prompt: string;