@assemblyline-agents/runtime 1.0.0 → 3.0.0

package/dist/schedule-execution.js

@@ -4,8 +4,12 @@ import { dueTimeForSchedule, dynamicScheduleMessage, stringValue, timestamp } fr
 import { buildDefaultContextBundle } from "./sandbox-fs.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 { matchingEventAutomations } from "./automation-event-match.js";
 export async function registerManifestSchedulesImpl(host) {
     const records = [];
     for (const schedule of manifestScheduleRegistrations(host)) {
@@ -37,12 +41,27 @@ export async function runDueSchedulesImpl(host, options = {}) {
             continue;
         const dueAtIso = dueAt.toISOString();
         const idempotencyKey = `${schedule.idempotencyKey}:${dueAtIso}`;
+        let job;
+        try {
+            job = await manifestScheduleExecution(host, schedule, dueAtIso, idempotencyKey);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await host.state.recordScheduleRun({
+                scheduleId: schedule.schedule,
+                runAt: dueAtIso,
+                idempotencyKey,
+                status: "failed"
+            });
+            results.push({ schedule: schedule.schedule, dueAt: dueAtIso, idempotencyKey, status: "failed", error: message });
+            continue;
+        }
         // Message schedules run through the bounded semaphore; claim capacity
         // BEFORE reserving the idempotency key so a saturated runtime skips the
         // tick without burning the key (the next sweep retries). Triggered
         // schedules use an existingRun and bypass admission (enter()).
         let admission;
-        if (!schedule.trigger) {
+        if (!schedule.trigger && !schedule.lifecycle) {
             const admitted = host.admitRunOrReject();
             if (admitted instanceof RunCapacityError) {
                 results.push({ schedule: schedule.schedule, dueAt: dueAtIso, idempotencyKey, status: "skipped", error: "run capacity saturated" });
@@ -71,7 +90,6 @@ export async function runDueSchedulesImpl(host, options = {}) {
             admission?.release();
             throw error;
         });
-        const job = manifestScheduleExecution(host, schedule, dueAtIso, idempotencyKey);
         try {
             results.push(await runScheduleExecution(host, job, admission));
         }
@@ -100,13 +118,7 @@ export async function dispatchAutomationEventImpl(host, event) {
         throw new Error("Automation event occurredAt must be a valid ISO timestamp.");
     }
     const results = [];
-    for (const automation of host.manifest.automationRegistrations ?? []) {
-        if (automation.trigger.type !== "event")
-            continue;
-        if (automation.trigger.source !== event.source || automation.trigger.event !== event.event)
-            continue;
-        if (automation.trigger.filter && !jsonSubsetMatches(automation.trigger.filter, event.payload))
-            continue;
+    for (const automation of matchingEventAutomations(host.manifest, event)) {
         const idempotencyKey = `${automation.idempotencyKey}:${event.eventId}`;
         let admission;
         if (!automation.lifecycle) {
@@ -139,6 +151,19 @@ export async function dispatchAutomationEventImpl(host, event) {
         }
         const execution = eventAutomationExecution(host, automation, event, idempotencyKey);
         try {
+            // Schedule-run records use the same durable ledger for schedule and event
+            // automations. Postgres enforces that every ledger row has a registered
+            // parent, so register the event automation before its first dispatch.
+            await host.state.registerSchedule({
+                id: automation.automation,
+                name: `automation:${automation.automation}`,
+                cron: `@event ${automation.trigger.source}:${automation.trigger.event}`,
+                metadata: {
+                    agentRevision: host.manifest.agentRevision,
+                    trigger: safeJson(automation.trigger),
+                    message: automation.message ?? null
+                }
+            });
             const result = await runScheduleExecution(host, execution, admission);
             results.push({
                 automation: automation.automation,
@@ -150,6 +175,10 @@ export async function dispatchAutomationEventImpl(host, event) {
             });
         }
         catch (error) {
+            // No durable evidence of this event exists on a throw (a durable run —
+            // even a failed one — resolves): un-burn the reservation so a provider
+            // retry can redeliver instead of the event being lost forever.
+            await host.state.releaseIdempotencyKey?.(`automation:${automation.automation}:event`, idempotencyKey).catch(() => undefined);
             results.push({
                 automation: automation.automation,
                 eventId: event.eventId,
@@ -164,13 +193,16 @@ export async function dispatchAutomationEventImpl(host, event) {
 function eventAutomationExecution(host, automation, event, idempotencyKey) {
     const eventAt = event.occurredAt ?? timestamp();
     const compiled = host.manifest.automations?.find((candidate) => candidate.name === automation.automation);
-    const trigger = automation.lifecycle
-        ? {
-            handler: automation.lifecycle.handler,
-            ...(automation.target ? { target: automation.target } : {}),
-            ...(automation.metadata ? { metadata: automation.metadata } : {})
-        }
-        : undefined;
+    const principal = event.principal ?? defaultUserPrincipal(event.userId, event.source);
+    const initiator = event.initiator ?? principal;
+    const audience = normalizeAgentAudience(event.audience)
+        ?? (host.manifest.agent.audienceIsolation !== true
+            ? trustedScheduleAudience({ ...(principal ? { principal } : {}), ...(event.conversationId ? { conversationId: event.conversationId } : {}) })
+            : event.conversationId
+                ? { private: false, conversationId: event.conversationId }
+                : principal
+                    ? { private: true, principal }
+                    : { private: true });
     return {
         source: "manifest",
         scheduleId: automation.automation,
@@ -179,7 +211,7 @@ function eventAutomationExecution(host, automation, event, idempotencyKey) {
         idempotencyKey,
         message: automation.message ?? `Handle ${event.event} from ${event.source}.`,
         channel: "automation",
-        ...(trigger ? { trigger } : {}),
+        ...(automation.lifecycle ? { lifecycle: automation.lifecycle } : {}),
         ...(automation.target ? { target: automation.target } : {}),
         automationEvent: event,
         metadata: {
@@ -189,6 +221,9 @@ function eventAutomationExecution(host, automation, event, idempotencyKey) {
         },
         definition: safeJson(compiled ?? automation),
         ...(event.userId ? { userId: event.userId } : {}),
+        ...(principal ? { principal } : {}),
+        ...(initiator ? { initiator } : {}),
+        audience,
         ...(event.conversationId ? { conversationId: event.conversationId } : {}),
         ...(event.projectId ? { projectId: event.projectId } : {}),
         ...(event.delivery ? { delivery: event.delivery } : {}),
@@ -201,19 +236,12 @@ function eventAutomationExecution(host, automation, event, idempotencyKey) {
         }
     };
 }
-function jsonSubsetMatches(expected, actual) {
-    return Object.entries(expected).every(([key, expectedValue]) => {
-        if (!Object.prototype.hasOwnProperty.call(actual, key))
-            return false;
-        const actualValue = actual[key];
-        if (isJsonObject(expectedValue)) {
-            return isJsonObject(actualValue) && jsonSubsetMatches(expectedValue, actualValue);
-        }
-        return JSON.stringify(expectedValue) === JSON.stringify(actualValue);
-    });
-}
-function manifestScheduleExecution(host, schedule, dueAtIso, idempotencyKey) {
-    return {
+async function manifestScheduleExecution(host, schedule, dueAtIso, idempotencyKey) {
+    const compiled = compiledSchedule(host, schedule.schedule);
+    const compiledMetadata = compiled && "metadata" in compiled && isJsonObject(compiled.metadata)
+        ? compiled.metadata
+        : {};
+    const execution = {
         source: "manifest",
         scheduleId: schedule.schedule,
         resultSchedule: schedule.schedule,
@@ -222,17 +250,50 @@ function manifestScheduleExecution(host, schedule, dueAtIso, idempotencyKey) {
         message: scheduleMessage(host, schedule.schedule),
         channel: "schedule",
         ...(schedule.trigger ? { trigger: schedule.trigger } : {}),
+        ...(schedule.lifecycle ? { lifecycle: schedule.lifecycle } : {}),
         ...(schedule.target ? { target: schedule.target } : {}),
         metadata: {
+            ...compiledMetadata,
             schedule: schedule.schedule,
             dueAt: dueAtIso,
             idempotencyKey
         },
-        definition: safeJson(compiledSchedule(host, schedule.schedule) ?? schedule)
+        definition: safeJson(compiled ?? schedule)
     };
+    const channel = host.manifest.agent.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);
+    if (!saved) {
+        throw new Error(`Default outbound channel "${channel}" has no saved route. Send the agent a message on that channel first.`);
+    }
+    execution.channel = channel;
+    if (saved.userId)
+        execution.userId = saved.userId;
+    if (saved.principal)
+        execution.principal = saved.principal;
+    if (saved.initiator)
+        execution.initiator = saved.initiator;
+    execution.audience = saved.audience;
+    if (saved.conversationId)
+        execution.conversationId = saved.conversationId;
+    if (saved.projectId)
+        execution.projectId = saved.projectId;
+    if (saved.workspaceId)
+        execution.workspaceId = saved.workspaceId;
+    if (saved.tenantId)
+        execution.tenantId = saved.tenantId;
+    if (saved.delivery)
+        execution.delivery = saved.delivery;
+    return execution;
 }
 async function runScheduleExecution(host, schedule, admission) {
-    return schedule.trigger ? runTriggeredSchedule(host, schedule) : runMessageSchedule(host, schedule, admission);
+    return schedule.trigger || schedule.lifecycle
+        ? runTriggeredSchedule(host, schedule)
+        : runMessageSchedule(host, schedule, admission);
 }
 async function runMessageSchedule(host, schedule, admission) {
     const overrides = admission ? { admission } : {};
@@ -255,6 +316,7 @@ async function runMessageSchedule(host, schedule, admission) {
     };
 }
 function scheduleRunOptions(host, schedule, message, metadata, overrides = {}) {
+    const audience = resolvedScheduleAudience(host, schedule);
     const options = {
         message,
         channel: schedule.channel,
@@ -264,10 +326,19 @@ function scheduleRunOptions(host, schedule, message, metadata, overrides = {}) {
     };
     if (schedule.userId)
         options.userId = schedule.userId;
+    if (schedule.principal)
+        options.principal = schedule.principal;
+    if (schedule.initiator)
+        options.initiator = schedule.initiator;
+    options.audience = audience;
     if (schedule.conversationId)
         options.conversationId = schedule.conversationId;
     if (schedule.projectId)
         options.projectId = schedule.projectId;
+    if (schedule.workspaceId)
+        options.workspaceId = schedule.workspaceId;
+    if (schedule.tenantId)
+        options.tenantId = schedule.tenantId;
     if (schedule.delivery)
         options.delivery = schedule.delivery;
     if (schedule.conversationId) {
@@ -277,6 +348,9 @@ function scheduleRunOptions(host, schedule, message, metadata, overrides = {}) {
             conversationId: schedule.conversationId,
             message,
             ...(schedule.userId ? { userId: schedule.userId } : {}),
+            ...(schedule.principal ? { principal: schedule.principal } : {}),
+            ...(schedule.initiator ? { initiator: schedule.initiator } : {}),
+            audience,
             ...(schedule.delivery ? { delivery: schedule.delivery } : {}),
             ...(schedule.turnMetadata ? { metadata: schedule.turnMetadata } : {})
         };
@@ -285,11 +359,9 @@ function scheduleRunOptions(host, schedule, message, metadata, overrides = {}) {
 }
 async function runTriggeredSchedule(host, schedule) {
     const trigger = schedule.trigger;
-    if (!trigger)
-        throw new Error(`Schedule ${schedule.resultSchedule} has no trigger definition.`);
-    const handler = automationHandlers(host).find((candidate) => candidate.name === trigger.handler);
+    const handler = resolveAutomationLifecycle(host, schedule);
     if (!handler)
-        throw new Error(`Trigger handler not found: ${trigger.handler}`);
+        throw new Error(`Automation ${schedule.resultSchedule} has no lifecycle definition.`);
     const invocation = {
         kind: schedule.automationEvent ? "event" : "schedule",
         source: schedule.source,
@@ -299,19 +371,25 @@ async function runTriggeredSchedule(host, schedule) {
         handler: handler.name,
         idempotencyKey: schedule.idempotencyKey
     };
-    if (trigger.metadata)
+    if (trigger?.metadata)
         invocation.metadata = trigger.metadata;
+    const audience = resolvedScheduleAudience(host, schedule);
     let run = await host.state.createRun({
         agentRevision: host.manifest.agentRevision,
         status: "created",
         input: {
             message: schedule.message,
-            model: host.manifest.agent.model,
             channel: schedule.channel,
             eventId: schedule.idempotencyKey,
             conversationId: schedule.conversationId ?? null,
+            autoConversation: !schedule.conversationId,
             userId: schedule.userId ?? null,
+            principal: schedule.principal ? safeJson(schedule.principal) : null,
+            initiator: schedule.initiator ? safeJson(schedule.initiator) : null,
+            audience: safeJson(audience),
             projectId: schedule.projectId ?? null,
+            workspaceId: schedule.workspaceId ?? null,
+            tenantId: schedule.tenantId ?? null,
             delivery: schedule.delivery ?? null,
             metadata: {
                 ...schedule.metadata,
@@ -343,7 +421,7 @@ async function runTriggeredSchedule(host, schedule) {
         prepareContext = triggerPrepareContext(run.id, prepareResult);
         await host.state.appendEvent(run.id, "trigger.prepare_completed", {
             handler: handler.name,
-            target: safeJson(prepareResult.target ?? trigger.target ?? null),
+            target: safeJson(prepareResult.target ?? trigger?.target ?? schedule.target ?? null),
             promptContext: safeJson(prepareResult.promptContext ?? {})
         });
         await host.emitSpan("ai.assembly-line.trigger.prepare", prepareStartedAt, host.runSpanAttributes(run, {
@@ -379,7 +457,7 @@ async function runTriggeredSchedule(host, schedule) {
         });
         return { schedule: schedule.resultSchedule, dueAt: schedule.dueAtIso, idempotencyKey: schedule.idempotencyKey, status: "failed", runId: run.id, error: message };
     }
-    const target = prepareResult.target ?? trigger.target ?? schedule.target;
+    const target = prepareResult.target ?? trigger?.target ?? schedule.target;
     const promptContext = {
         triggerKind: invocation.kind,
         triggerSource: invocation.source ?? "manifest",
@@ -511,6 +589,25 @@ 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)];
@@ -525,7 +622,7 @@ export function normalizeScheduleTriggerDefinitionImpl(host, value) {
     const handler = stringValue(value.handler);
     if (!handler)
         throw new Error("Schedule trigger requires handler.");
-    if (!automationHandlers(host).some((candidate) => candidate.name === handler)) {
+    if (!automationLifecycleSources(host).some((candidate) => candidate.name === handler)) {
         throw new Error(`Unknown trigger handler: ${handler}`);
     }
     const trigger = { handler };
@@ -550,13 +647,13 @@ function normalizeTriggerTarget(value) {
         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 model = stringValue(value.model);
         const target = { type };
         if (name)
             target.name = name;
-        if (model)
-            target.model = model;
         if (isJsonObject(value.metadata))
             target.metadata = value.metadata;
         return target;
@@ -577,6 +674,9 @@ function createTriggerHandlerContext(host, run, schedule, trigger, prepare) {
     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),
@@ -721,7 +821,7 @@ async function collectTriggerResources(host, run, input = {}) {
         }
     }
     if (requested.has("skills")) {
-        const skills = (await host.skillStore.list(host.skillScope())).filter((skill) => !skill.pending).slice(0, limit);
+        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,
@@ -759,7 +859,7 @@ async function runDueDynamicSchedules(host, now) {
         const idempotencyKey = `dynamic:${job.id}:${dueAtIso}`;
         const leaseToken = job.leaseToken ?? "";
         try {
-            // openeve_schedule_runs rows reference openeve_schedules; dynamic jobs
+            // 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}`,
@@ -832,6 +932,16 @@ function dynamicScheduleExecution(host, job, dueAtIso, idempotencyKey) {
     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 = {
@@ -860,6 +970,9 @@ function dynamicScheduleExecution(host, job, dueAtIso, idempotencyKey) {
         metadata,
         definition: safeJson(definition),
         ...(job.userId ? { userId: job.userId } : {}),
+        ...(principal ? { principal } : {}),
+        ...(initiator ? { initiator } : {}),
+        audience,
         ...(conversationId ? { conversationId } : {}),
         ...(projectId ? { projectId } : {}),
         ...(delivery ? { delivery } : {})
@@ -915,10 +1028,32 @@ function scheduleMessage(host, name) {
     const compiled = compiledSchedule(host, name);
     return registration?.message ?? compiled?.message ?? compiled?.description ?? `Run schedule ${name}.`;
 }
-function automationHandlers(host) {
-    return host.manifest.automationHandlers?.length
-        ? host.manifest.automationHandlers
-        : host.manifest.triggerHandlers ?? [];
+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]) {
+        if (!sources.has(candidate.name))
+            sources.set(candidate.name, candidate);
+    }
+    return [...sources.values()];
 }
 function manifestScheduleRegistrations(host) {
     if (Array.isArray(host.manifest.automationRegistrations)) {
@@ -936,13 +1071,8 @@ function manifestScheduleRegistrations(host) {
                 registration.message = automation.message;
             if (automation.target)
                 registration.target = automation.target;
-            if (automation.lifecycle) {
-                registration.trigger = {
-                    handler: automation.lifecycle.handler,
-                    ...(automation.target ? { target: automation.target } : {}),
-                    ...(automation.metadata ? { metadata: automation.metadata } : {})
-                };
-            }
+            if (automation.lifecycle)
+                registration.lifecycle = automation.lifecycle;
             return [registration];
         });
     }