@assemblyline-agents/runtime 5.0.9 → 6.0.0

package/dist/schedule-execution.js

@@ -1,15 +1,17 @@
-import { isTriggerHandlerDefinition, normalizeRoutineRunRecord, normalizeTriggerPrepareResult, triggerPrepareContext } from "./channel-http-util.js";
+import { normalizeTriggerPrepareResult, triggerPrepareContext } from "./channel-http-util.js";
 import { RunCapacityError } from "./concurrency.js";
-import { dueTimeForSchedule, dynamicScheduleMessage, stringValue, timestamp } from "./runtime-util.js";
-import { buildDefaultContextBundle } from "./sandbox-fs.js";
+import { dueTimeForSchedule, timestamp } from "./runtime-util.js";
 import { isJsonObject, safeJson } from "./json-util.js";
 import { failRun } from "./run-outcome.js";
 import { loadDefaultOutboundRoute } from "./default-outbound-route.js";
 import { isRuntimeSettingsStore } from "./state.js";
-import { memoryBodyText, memoryDocumentSummary, positiveLimit } from "./storage.js";
-import { defaultUserPrincipal, initiatorFromRun, principalFromRun } from "./principals.js";
-import { audienceFromMetadata, audienceFromRun, normalizeAgentAudience } from "./audience.js";
+import { defaultUserPrincipal } from "./principals.js";
+import { normalizeAgentAudience } from "./audience.js";
 import { matchingEventAutomations } from "./automation-event-match.js";
+import { surfaceForPath } from "./agent-surface.js";
+import { createTriggerHandlerContext, loadTriggerHandler, resolvedScheduleAudience, trustedScheduleAudience } from "./schedule-trigger-context.js";
+import { runDueDynamicSchedules } from "./dynamic-schedule-execution.js";
+export { normalizeScheduleTriggerDefinitionImpl } from "./schedule-trigger-context.js";
 export async function registerManifestSchedulesImpl(host) {
     const records = [];
     for (const schedule of manifestScheduleRegistrations(host)) {
@@ -20,14 +22,13 @@ export async function registerManifestSchedulesImpl(host) {
             ...(schedule.timezone ? { timezone: schedule.timezone } : {}),
             metadata: {
                 agentRevision: host.manifest.agentRevision,
-                message: schedule.message ?? compiledSchedule(host, schedule.schedule)?.message ?? null,
-                trigger: schedule.trigger ? safeJson(schedule.trigger) : null
+                message: schedule.message ?? compiledSchedule(host, schedule.schedule)?.message ?? null
             }
         }));
     }
     return records;
 }
-export async function runDueSchedulesImpl(host, options = {}) {
+export async function runDueAutomationsImpl(host, options = {}) {
     host.boot();
     if (!(await host.agentEnabled()))
         return [];
@@ -61,7 +62,7 @@ export async function runDueSchedulesImpl(host, options = {}) {
         // tick without burning the key (the next sweep retries). Triggered
         // schedules use an existingRun and bypass admission (enter()).
         let admission;
-        if (!schedule.trigger && !schedule.lifecycle) {
+        if (!schedule.lifecycle) {
             const admitted = host.admitRunOrReject();
             if (admitted instanceof RunCapacityError) {
                 results.push({ schedule: schedule.schedule, dueAt: dueAtIso, idempotencyKey, status: "skipped", error: "run capacity saturated" });
@@ -104,7 +105,7 @@ export async function runDueSchedulesImpl(host, options = {}) {
             results.push({ schedule: schedule.schedule, dueAt: dueAtIso, idempotencyKey, status: "failed", error: message });
         }
     }
-    results.push(...(await runDueDynamicSchedules(host, now)));
+    results.push(...(await runDueDynamicSchedules(host, now, (schedule) => runScheduleExecution(host, schedule))));
     return results;
 }
 export async function dispatchAutomationEventImpl(host, event) {
@@ -213,6 +214,7 @@ function eventAutomationExecution(host, automation, event, idempotencyKey) {
         channel: "automation",
         ...(automation.lifecycle ? { lifecycle: automation.lifecycle } : {}),
         ...(automation.target ? { target: automation.target } : {}),
+        ...(automation.surface ? { surface: automation.surface } : {}),
         automationEvent: event,
         metadata: {
             automation: automation.automation,
@@ -249,9 +251,9 @@ async function manifestScheduleExecution(host, schedule, dueAtIso, idempotencyKe
         idempotencyKey,
         message: scheduleMessage(host, schedule.schedule),
         channel: "schedule",
-        ...(schedule.trigger ? { trigger: schedule.trigger } : {}),
         ...(schedule.lifecycle ? { lifecycle: schedule.lifecycle } : {}),
         ...(schedule.target ? { target: schedule.target } : {}),
+        ...(schedule.surface ? { surface: schedule.surface } : {}),
         metadata: {
             ...compiledMetadata,
             schedule: schedule.schedule,
@@ -260,13 +262,16 @@ async function manifestScheduleExecution(host, schedule, dueAtIso, idempotencyKe
         },
         definition: safeJson(compiled ?? schedule)
     };
-    const channel = host.manifest.agent.defaultOutboundChannel?.trim();
+    if (compiledMetadata.delivery === "silent")
+        return execution;
+    const surface = surfaceForPath(host.manifest, schedule.surface);
+    const channel = surface.defaultOutboundChannel?.trim();
     if (!channel)
         return execution;
     if (!isRuntimeSettingsStore(host.state)) {
         throw new Error(`Default outbound channel "${channel}" requires durable runtime settings.`);
     }
-    const saved = await loadDefaultOutboundRoute(host.state, host.skillScope(), channel);
+    const saved = await loadDefaultOutboundRoute(host.state, host.skillScope(surface.path), channel);
     if (!saved) {
         throw new Error(`Default outbound channel "${channel}" has no saved route. Send the agent a message on that channel first.`);
     }
@@ -341,6 +346,8 @@ function scheduleRunOptions(host, schedule, message, metadata, overrides = {}) {
         options.tenantId = schedule.tenantId;
     if (schedule.delivery)
         options.delivery = schedule.delivery;
+    if (schedule.surface)
+        options.agentSurface = schedule.surface;
     if (schedule.conversationId) {
         options.turn = {
             eventId: schedule.idempotencyKey,
@@ -379,6 +386,7 @@ async function runTriggeredSchedule(host, schedule) {
         status: "created",
         input: {
             message: schedule.message,
+            agentSurface: schedule.surface ?? "root",
             channel: schedule.channel,
             eventId: schedule.idempotencyKey,
             conversationId: schedule.conversationId ?? null,
@@ -589,395 +597,6 @@ async function runTriggeredSchedule(host, schedule) {
         ...(finalizeResult.error ? { error: finalizeResult.error } : {})
     };
 }
-function resolvedScheduleAudience(host, schedule) {
-    if (schedule.audience)
-        return schedule.audience;
-    if (host.manifest.agent.audienceIsolation !== true)
-        return trustedScheduleAudience(schedule);
-    if (schedule.conversationId)
-        return { private: false, conversationId: schedule.conversationId };
-    if (schedule.principal)
-        return { private: true, principal: schedule.principal };
-    return { private: true };
-}
-/** Without audienceIsolation, schedule fallbacks are trusted like every other run. */
-function trustedScheduleAudience(schedule) {
-    return {
-        private: true,
-        ...(schedule.principal ? { principal: schedule.principal } : {}),
-        ...(schedule.conversationId ? { conversationId: schedule.conversationId } : {})
-    };
-}
-async function loadTriggerHandler(host, handler) {
-    const module = await host.sourceLoader.load(handler.source);
-    const candidates = [module.default, module[handler.name], ...Object.values(module)];
-    const definition = candidates.find(isTriggerHandlerDefinition);
-    if (!definition)
-        throw new Error(`Trigger handler ${handler.name} did not export a trigger handler definition.`);
-    return definition;
-}
-export function normalizeScheduleTriggerDefinitionImpl(host, value) {
-    if (!isJsonObject(value))
-        throw new Error("Schedule trigger must be an object.");
-    const handler = stringValue(value.handler);
-    if (!handler)
-        throw new Error("Schedule trigger requires handler.");
-    if (!automationLifecycleSources(host).some((candidate) => candidate.name === handler)) {
-        throw new Error(`Unknown trigger handler: ${handler}`);
-    }
-    const trigger = { handler };
-    if (value.target !== undefined && value.target !== null) {
-        trigger.target = normalizeTriggerTarget(value.target);
-    }
-    if (value.metadata !== undefined) {
-        if (!isJsonObject(value.metadata))
-            throw new Error("Schedule trigger metadata must be an object.");
-        trigger.metadata = value.metadata;
-    }
-    return trigger;
-}
-function normalizeTriggerTarget(value) {
-    if (!isJsonObject(value))
-        throw new Error("Schedule trigger target must be an object.");
-    const type = stringValue(value.type);
-    if (type === "skill") {
-        const name = stringValue(value.name);
-        if (!name)
-            throw new Error("Skill trigger targets require name.");
-        return { type, name, ...(isJsonObject(value.metadata) ? { metadata: value.metadata } : {}) };
-    }
-    if (type === "agent") {
-        if (value.model !== undefined) {
-            throw new Error("Automation targets cannot select a model; use useModel() in agent.ts setup().");
-        }
-        const name = stringValue(value.name);
-        const target = { type };
-        if (name)
-            target.name = name;
-        if (isJsonObject(value.metadata))
-            target.metadata = value.metadata;
-        return target;
-    }
-    if (type === "playbook") {
-        const name = stringValue(value.name);
-        if (!name)
-            throw new Error("Playbook trigger targets require name.");
-        return { type, name, ...(isJsonObject(value.metadata) ? { metadata: value.metadata } : {}) };
-    }
-    throw new Error(`Unsupported schedule trigger target type: ${type || "missing"}`);
-}
-function createTriggerHandlerContext(host, run, schedule, trigger, prepare) {
-    const sandboxHandle = host.createSandboxHandle(() => run, () => undefined, () => buildDefaultContextBundle(host.manifest, {
-        message: typeof run.input.message === "string" ? run.input.message : schedule.message,
-        channel: schedule.channel
-    }));
-    return {
-        runId: run.id,
-        agentRevision: host.manifest.agentRevision,
-        ...(principalFromRun(run) ? { principal: principalFromRun(run) } : {}),
-        ...(initiatorFromRun(run) ? { initiator: initiatorFromRun(run) } : {}),
-        audience: audienceFromRun(run),
-        trigger,
-        state: createTriggerStateApi(host, run),
-        memory: host.createMemoryToolApi(run),
-        resources: createTriggerResourceApi(host, run, sandboxHandle),
-        blob: {
-            put: async (key, value, contentTypeOrOptions) => host.blob.put(key, value, contentTypeOrOptions),
-            get: async (key) => host.blob.get(key)
-        },
-        schedule: {
-            definition: schedule.definition,
-            run: {
-                scheduleId: schedule.resultSchedule,
-                runId: run.id,
-                runAt: trigger.dueAt ?? trigger.event?.occurredAt ?? schedule.dueAtIso,
-                idempotencyKey: trigger.idempotencyKey
-            }
-        },
-        env: host.env,
-        fetch: host.fetch,
-        prepare,
-        emit: async (eventType, data = {}) => {
-            await host.state.appendEvent(run.id, eventType, data);
-        },
-        idempotencyKey: (scope) => `${trigger.idempotencyKey}:${scope}`,
-        step: (key, fn, options) => host.durableStep(run.id, key, fn, options)
-    };
-}
-function createTriggerStateApi(host, run) {
-    const runtime = host;
-    return {
-        async upsertRoutineRun(input) {
-            const current = await runtime.state.getRun(run.id) ?? run;
-            const metadata = isJsonObject(current.input.metadata) ? current.input.metadata : {};
-            const existing = isJsonObject(metadata.routineRun) ? metadata.routineRun : {};
-            const record = normalizeRoutineRunRecord({
-                existing,
-                runId: run.id,
-                kind: input.kind,
-                triggerKey: input.triggerKey,
-                status: input.status ?? (stringValue(existing.status) || current.status),
-                metadata: input.metadata ?? (isJsonObject(existing.metadata) ? existing.metadata : {})
-            });
-            await runtime.state.updateRun(run.id, {
-                input: {
-                    ...current.input,
-                    metadata: {
-                        ...metadata,
-                        routineRun: safeJson(record)
-                    }
-                }
-            });
-            await runtime.state.appendEvent(run.id, "routine.run_upserted", safeJson(record));
-            return record;
-        },
-        async completeRoutineRun(input) {
-            const current = await runtime.state.getRun(run.id) ?? run;
-            const metadata = isJsonObject(current.input.metadata) ? current.input.metadata : {};
-            const existing = isJsonObject(metadata.routineRun) ? metadata.routineRun : {};
-            const completeInput = {
-                existing,
-                runId: input.runId || run.id,
-                kind: stringValue(existing.kind) || "routine",
-                triggerKey: stringValue(existing.triggerKey) || "",
-                status: input.status,
-                metadata: input.metadata ?? (isJsonObject(existing.metadata) ? existing.metadata : {})
-            };
-            if (input.summary)
-                completeInput.summary = input.summary;
-            const record = normalizeRoutineRunRecord(completeInput);
-            await runtime.state.updateRun(run.id, {
-                input: {
-                    ...current.input,
-                    metadata: {
-                        ...metadata,
-                        routineRun: safeJson(record)
-                    }
-                }
-            });
-            await runtime.state.appendEvent(run.id, "routine.run_completed", safeJson(record));
-            return record;
-        }
-    };
-}
-function createTriggerResourceApi(host, run, sandboxHandle) {
-    const base = host.createResourceToolApi(run, sandboxHandle);
-    return {
-        ...base,
-        collect: async (input = {}) => collectTriggerResources(host, run, input)
-    };
-}
-async function collectTriggerResources(host, run, input = {}) {
-    const requested = new Set(input.sources ?? ["memory", "history", "connections"]);
-    const limit = positiveLimit(input.limit, 50);
-    const resources = [];
-    const sections = [];
-    if (requested.has("memory")) {
-        const documents = await host.memoryStore.list(host.memoryScopeForRun(run), { limit });
-        resources.push(...documents.map((document) => memoryDocumentSummary(document)));
-        if (documents.length > 0) {
-            sections.push([
-                "# Memory",
-                ...documents.map((document) => [
-                    `## ${document.path}`,
-                    memoryBodyText(document)
-                ].join("\n"))
-            ].join("\n\n"));
-        }
-    }
-    if (requested.has("history")) {
-        const conversationId = typeof run.input.conversationId === "string" ? run.input.conversationId : undefined;
-        const messages = conversationId ? await host.state.listRecentMessages(conversationId, limit) : [];
-        resources.push(...messages.map((message) => ({
-            kind: "history",
-            role: message.role,
-            createdAt: message.createdAt,
-            runId: message.runId ?? null
-        })));
-        if (messages.length > 0) {
-            sections.push([
-                "# History",
-                ...messages.map((message) => {
-                    const text = typeof message.content.text === "string" ? message.content.text : JSON.stringify(message.content);
-                    return `- ${message.role}: ${text}`;
-                })
-            ].join("\n"));
-        }
-    }
-    if (requested.has("connections")) {
-        const connections = host.mergedConnections().slice(0, limit);
-        resources.push(...connections.map((connection) => ({
-            kind: "connection",
-            name: connection.name,
-            protocol: connection.protocol,
-            provider: connection.provider,
-            required: connection.required
-        })));
-        if (connections.length > 0) {
-            sections.push([
-                "# Connections",
-                ...connections.map((connection) => `- ${connection.name} (${connection.protocol}, ${connection.provider})`)
-            ].join("\n"));
-        }
-    }
-    if (requested.has("skills")) {
-        const skills = (await host.skillStore.list(host.skillScope())).filter((skill) => !skill.pending && !skill.archived).slice(0, limit);
-        resources.push(...skills.map((skill) => ({
-            kind: "skill",
-            name: skill.name,
-            origin: skill.origin,
-            updatedAt: skill.updatedAt
-        })));
-        if (skills.length > 0) {
-            sections.push([
-                "# Skills",
-                ...skills.map((skill) => `- ${skill.name} (${skill.origin})`)
-            ].join("\n"));
-        }
-    }
-    await host.state.appendEvent(run.id, "trigger.resources_collected", {
-        sources: [...requested],
-        count: resources.length,
-        since: input.since ?? null
-    });
-    return {
-        markdown: sections.join("\n\n").trim(),
-        resources
-    };
-}
-/**
- * Dispatch application-managed dynamic schedules: atomically lease due rows
- * and start one durable run per row. At-least-once; tasks should be idempotent.
- */
-async function runDueDynamicSchedules(host, now) {
-    if (!host.schedulesConfig.dynamic)
-        return [];
-    const results = [];
-    const due = await host.scheduleStore.claimDue({ now, limit: 25, leaseForMs: 5 * 60_000 });
-    for (const job of due) {
-        const dueAtIso = job.nextRunAt;
-        const idempotencyKey = `dynamic:${job.id}:${dueAtIso}`;
-        const leaseToken = job.leaseToken ?? "";
-        try {
-            // assembly_line_schedule_runs rows reference assembly_line_schedules; dynamic jobs
-            // live in the schedule store, so upsert a parent row before recording runs.
-            await host.state.registerSchedule({
-                id: `dynamic:${job.id}`,
-                name: `dynamic:${job.id}`,
-                cron: job.cron ?? (job.everyMinutes ? `@every ${job.everyMinutes}m` : `@at ${dueAtIso}`),
-                ...(job.timezone ? { timezone: job.timezone } : {}),
-                metadata: { source: "dynamic", scope: job.scope }
-            });
-            const schedule = dynamicScheduleExecution(host, job, dueAtIso, idempotencyKey);
-            const result = await runScheduleExecution(host, schedule);
-            await host.scheduleStore.complete(job.id, leaseToken, { ranAt: dueAtIso });
-            if (result.runId) {
-                await host.state.appendEvent(result.runId, "schedule.dynamic_dispatched", {
-                    dynamicScheduleId: job.id,
-                    dueAt: dueAtIso,
-                    trigger: job.trigger ? safeJson(job.trigger) : null
-                });
-            }
-            results.push(result);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            try {
-                await host.state.recordScheduleRun({
-                    scheduleId: `dynamic:${job.id}`,
-                    runAt: dueAtIso,
-                    idempotencyKey,
-                    status: "failed"
-                });
-            }
-            catch (recordError) {
-                host.logger.warn("dynamic schedule failure bookkeeping failed", {
-                    dynamicScheduleId: job.id,
-                    error: recordError instanceof Error ? recordError.message : String(recordError)
-                });
-            }
-            // Escalating backoff on the failure streak (5min base, 2x, capped 6h);
-            // the store disables the schedule atomically once the streak hits the
-            // cap so a poison schedule cannot burn a model run every cycle forever.
-            const failureStreak = (job.consecutiveFailures ?? 0) + 1;
-            const retryDelayMs = Math.min(300_000 * 2 ** (failureStreak - 1), 6 * 3_600_000);
-            const disabled = failureStreak >= host.scheduleMaxConsecutiveFailures;
-            await host.scheduleStore.release(job.id, leaseToken, new Date(now.getTime() + retryDelayMs), {
-                maxConsecutiveFailures: host.scheduleMaxConsecutiveFailures
-            });
-            if (disabled) {
-                host.logger.warn("dynamic schedule disabled after consecutive failures", {
-                    dynamicScheduleId: job.id,
-                    scope: job.scope,
-                    consecutiveFailures: failureStreak,
-                    error: message
-                });
-                if (isRuntimeSettingsStore(host.state)) {
-                    await host.state.appendRuntimeControlEvent(job.scope, "schedule.disabled_after_failures", {
-                        dynamicScheduleId: job.id,
-                        consecutiveFailures: failureStreak,
-                        error: message
-                    }).catch(() => undefined);
-                }
-            }
-            results.push({ schedule: `dynamic:${job.id}`, dueAt: dueAtIso, idempotencyKey, status: "failed", error: message });
-        }
-    }
-    return results;
-}
-function dynamicScheduleExecution(host, job, dueAtIso, idempotencyKey) {
-    const target = isJsonObject(job.target) ? job.target : {};
-    const targetConversation = typeof target.conversationId === "string" ? target.conversationId : undefined;
-    const targetProject = typeof target.projectId === "string" ? target.projectId : undefined;
-    const conversationId = job.conversationId ?? targetConversation;
-    const projectId = job.projectId ?? targetProject;
-    const delivery = isJsonObject(job.target) ? job.target : undefined;
-    const principal = job.principal ?? defaultUserPrincipal(job.userId, job.channel);
-    const initiator = job.initiator ?? principal;
-    const audience = audienceFromMetadata(job.metadata)
-        ?? (host.manifest.agent.audienceIsolation !== true
-            ? trustedScheduleAudience({ ...(principal ? { principal } : {}), ...(conversationId ? { conversationId } : {}) })
-            : principal
-                ? { private: true, principal }
-                : conversationId
-                    ? { private: false, conversationId }
-                    : { private: true });
-    const message = dynamicScheduleMessage(job);
-    const trigger = job.trigger ? normalizeScheduleTriggerDefinitionImpl(host, job.trigger) : undefined;
-    const metadata = {
-        ...(job.metadata ?? {}),
-        dynamicScheduleId: job.id,
-        scope: job.scope,
-        source: "dynamic",
-        schedule: `dynamic:${job.id}`,
-        dueAt: dueAtIso,
-        idempotencyKey
-    };
-    if (job.target)
-        metadata.target = safeJson(job.target);
-    const definition = { ...job };
-    if (trigger)
-        definition.trigger = trigger;
-    return {
-        source: "dynamic",
-        scheduleId: job.id,
-        resultSchedule: `dynamic:${job.id}`,
-        dueAtIso,
-        idempotencyKey,
-        message,
-        channel: job.channel,
-        ...(trigger ? { trigger } : {}),
-        metadata,
-        definition: safeJson(definition),
-        ...(job.userId ? { userId: job.userId } : {}),
-        ...(principal ? { principal } : {}),
-        ...(initiator ? { initiator } : {}),
-        audience,
-        ...(conversationId ? { conversationId } : {}),
-        ...(projectId ? { projectId } : {}),
-        ...(delivery ? { delivery } : {})
-    };
-}
 export async function startSchedulerPollingLoopImpl(host) {
     if (!hasScheduledWork(host))
         return undefined;
@@ -988,7 +607,7 @@ export async function startSchedulerPollingLoopImpl(host) {
             return [];
         inFlight = true;
         try {
-            return await runDueSchedulesImpl(host, { now: host.now(), lookbackMs: host.schedulerTickMs });
+            return await runDueAutomationsImpl(host, { now: host.now(), lookbackMs: host.schedulerTickMs });
         }
         catch (error) {
             // The interval invokes tick as a floating promise; a throw here would
@@ -1020,8 +639,7 @@ function hasScheduledWork(host) {
     return manifestScheduleRegistrations(host).length > 0;
 }
 function compiledSchedule(host, name) {
-    return host.manifest.automations?.find((automation) => automation.name === name)
-        ?? host.manifest.schedules.find((schedule) => schedule.name === name);
+    return host.manifest.automations.find((automation) => automation.name === name);
 }
 function scheduleMessage(host, name) {
     const registration = manifestScheduleRegistrations(host).find((schedule) => schedule.schedule === name);
@@ -1030,52 +648,39 @@ function scheduleMessage(host, name) {
 }
 function resolveAutomationLifecycle(host, schedule) {
     const lifecycle = schedule.lifecycle;
-    if (lifecycle?.kind === "inline") {
-        const compiled = host.manifest.automationLifecycles?.find((candidate) => candidate.automation === schedule.resultSchedule) ?? host.manifest.automations?.find((candidate) => candidate.name === schedule.resultSchedule);
-        return compiled ? { name: schedule.resultSchedule, source: compiled.source } : undefined;
-    }
     const handlerName = lifecycle?.handler ?? schedule.trigger?.handler;
     return handlerName
         ? automationLifecycleSources(host).find((candidate) => candidate.name === handlerName)
         : undefined;
 }
 function automationLifecycleSources(host) {
-    const inline = (host.manifest.automationLifecycles ?? []).map((lifecycle) => ({
-        name: lifecycle.automation,
-        source: lifecycle.source
-    }));
-    const legacy = [
-        ...(host.manifest.automationHandlers ?? []),
-        ...(host.manifest.triggerHandlers ?? [])
-    ];
     const sources = new Map();
-    for (const candidate of [...inline, ...legacy]) {
+    for (const candidate of host.manifest.automationHandlers) {
         if (!sources.has(candidate.name))
             sources.set(candidate.name, candidate);
     }
     return [...sources.values()];
 }
 function manifestScheduleRegistrations(host) {
-    if (Array.isArray(host.manifest.automationRegistrations)) {
-        return host.manifest.automationRegistrations.flatMap((automation) => {
-            if (automation.trigger.type !== "schedule")
-                return [];
-            const registration = {
-                schedule: automation.automation,
-                cron: automation.trigger.cron,
-                idempotencyKey: automation.idempotencyKey
-            };
-            if (automation.trigger.timezone)
-                registration.timezone = automation.trigger.timezone;
-            if (automation.message)
-                registration.message = automation.message;
-            if (automation.target)
-                registration.target = automation.target;
-            if (automation.lifecycle)
-                registration.lifecycle = automation.lifecycle;
-            return [registration];
-        });
-    }
-    return host.manifest.scheduleRegistrations ?? [];
+    return host.manifest.automationRegistrations.flatMap((automation) => {
+        if (automation.trigger.type !== "schedule")
+            return [];
+        const registration = {
+            schedule: automation.automation,
+            cron: automation.trigger.cron,
+            idempotencyKey: automation.idempotencyKey
+        };
+        if (automation.trigger.timezone)
+            registration.timezone = automation.trigger.timezone;
+        if (automation.message)
+            registration.message = automation.message;
+        if (automation.target)
+            registration.target = automation.target;
+        if (automation.lifecycle)
+            registration.lifecycle = automation.lifecycle;
+        if (automation.surface)
+            registration.surface = automation.surface;
+        return [registration];
+    });
 }
 //# sourceMappingURL=schedule-execution.js.map