@elizaos/autonomous 2.0.0-alpha.71 → 2.0.0-alpha.72

package/packages/autonomous/src/triggers/action.js

@@ -0,0 +1,267 @@
+import crypto from "node:crypto";
+import { ModelType, stringToUuid, } from "@elizaos/core";
+import { parsePositiveInteger } from "../utils/number-parsing";
+import { getTriggerLimit, listTriggerTasks, readTriggerConfig, TRIGGER_TASK_NAME, TRIGGER_TASK_TAGS, taskToTriggerSummary, triggersFeatureEnabled, } from "./runtime";
+import { buildTriggerConfig, buildTriggerMetadata, normalizeTriggerDraft, } from "./scheduling";
+const CREATE_TRIGGER_TASK_ACTION = "CREATE_TRIGGER_TASK";
+const CREATE_TRIGGER_KEYWORDS = [
+    "create trigger",
+    "create a trigger",
+    "create task",
+    "schedule trigger",
+    "schedule task",
+    "run every",
+    "run at",
+    "every hour",
+    "every day",
+];
+function normalizeText(value) {
+    return value.trim().replace(/\s+/g, " ");
+}
+function parseTag(xml, tag) {
+    const pattern = new RegExp(`<${tag}>([\\s\\S]*?)<\\/${tag}>`, "i");
+    const match = pattern.exec(xml);
+    if (!match?.[1])
+        return undefined;
+    const text = normalizeText(match[1]);
+    return text.length > 0 ? text : undefined;
+}
+function parseExtraction(xml) {
+    return {
+        triggerType: parseTag(xml, "triggerType"),
+        displayName: parseTag(xml, "displayName"),
+        instructions: parseTag(xml, "instructions"),
+        wakeMode: parseTag(xml, "wakeMode"),
+        intervalMs: parseTag(xml, "intervalMs"),
+        scheduledAtIso: parseTag(xml, "scheduledAtIso"),
+        cronExpression: parseTag(xml, "cronExpression"),
+        maxRuns: parseTag(xml, "maxRuns"),
+    };
+}
+function deriveTriggerType(extracted) {
+    const type = extracted.triggerType?.toLowerCase();
+    if (type === "interval" || type === "once" || type === "cron") {
+        return type;
+    }
+    if (extracted.cronExpression)
+        return "cron";
+    if (extracted.scheduledAtIso)
+        return "once";
+    return "interval";
+}
+function extractionPrompt(userText) {
+    return [
+        "Extract trigger details from this request.",
+        "Return only XML with these keys:",
+        "triggerType, displayName, instructions, wakeMode, intervalMs, scheduledAtIso, cronExpression, maxRuns",
+        "Valid triggerType values: interval, once, cron",
+        "Valid wakeMode values: inject_now, next_autonomy_cycle",
+        "",
+        `Request: ${userText}`,
+    ].join("\n");
+}
+function scheduleText(summary) {
+    if (!summary)
+        return "scheduled";
+    if (summary.triggerType === "interval") {
+        return `every ${summary.intervalMs ?? 0} ms`;
+    }
+    if (summary.triggerType === "once") {
+        return `once at ${summary.scheduledAtIso ?? "unknown time"}`;
+    }
+    return `on cron ${summary.cronExpression ?? "* * * * *"}`;
+}
+export const createTriggerTaskAction = {
+    name: CREATE_TRIGGER_TASK_ACTION,
+    similes: ["CREATE_TRIGGER", "SCHEDULE_TRIGGER"],
+    description: "Create an autonomous trigger task that executes interval, once, or cron schedules",
+    validate: async (runtime, message) => {
+        if (!triggersFeatureEnabled(runtime))
+            return false;
+        const text = message.content.text?.toLowerCase() ?? "";
+        if (!text)
+            return false;
+        return CREATE_TRIGGER_KEYWORDS.some((keyword) => text.includes(keyword));
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const text = normalizeText(message.content.text ?? "");
+        if (!text) {
+            return {
+                success: false,
+                text: "Cannot create a trigger from empty text.",
+            };
+        }
+        if (!triggersFeatureEnabled(runtime)) {
+            return {
+                success: false,
+                text: "Triggers are disabled by configuration.",
+            };
+        }
+        try {
+            let extraction = {};
+            let extractionFailed = false;
+            try {
+                const response = await runtime.useModel(ModelType.TEXT_SMALL, {
+                    prompt: extractionPrompt(text),
+                    stopSequences: [],
+                });
+                extraction = parseExtraction(response);
+            }
+            catch (extractionError) {
+                extractionFailed = true;
+                runtime.logger.warn({
+                    src: "trigger-action",
+                    error: extractionError instanceof Error
+                        ? extractionError.message
+                        : String(extractionError),
+                }, "LLM extraction failed, using fallback defaults from user text");
+            }
+            const creator = String(message.entityId ?? runtime.agentId);
+            const triggerType = deriveTriggerType(extraction);
+            const normalized = normalizeTriggerDraft({
+                input: {
+                    displayName: extraction.displayName ?? `Trigger: ${text.slice(0, 64)}`,
+                    instructions: extraction.instructions ?? text,
+                    triggerType,
+                    wakeMode: extraction.wakeMode === "next_autonomy_cycle"
+                        ? "next_autonomy_cycle"
+                        : "inject_now",
+                    enabled: true,
+                    createdBy: creator,
+                    intervalMs: parsePositiveInteger(extraction.intervalMs),
+                    scheduledAtIso: extraction.scheduledAtIso,
+                    cronExpression: extraction.cronExpression,
+                    maxRuns: parsePositiveInteger(extraction.maxRuns),
+                },
+                fallback: {
+                    displayName: `Trigger: ${text.slice(0, 64)}`,
+                    instructions: text,
+                    triggerType: "interval",
+                    wakeMode: "inject_now",
+                    enabled: true,
+                    createdBy: creator,
+                },
+            });
+            if (!normalized.draft) {
+                return {
+                    success: false,
+                    text: normalized.error ?? "Invalid trigger request",
+                };
+            }
+            const existingTasks = await listTriggerTasks(runtime);
+            const limit = getTriggerLimit(runtime);
+            const creatorCount = existingTasks.filter((task) => {
+                const trigger = readTriggerConfig(task);
+                return trigger?.enabled && trigger.createdBy === creator;
+            }).length;
+            if (creatorCount >= limit) {
+                return {
+                    success: false,
+                    text: `Trigger limit reached (${limit} active triggers).`,
+                };
+            }
+            const triggerId = stringToUuid(crypto.randomUUID());
+            const triggerConfig = buildTriggerConfig({
+                draft: normalized.draft,
+                triggerId,
+            });
+            const duplicate = existingTasks.find((task) => {
+                const existingTrigger = readTriggerConfig(task);
+                if (!existingTrigger?.enabled)
+                    return false;
+                if (existingTrigger.dedupeKey && triggerConfig.dedupeKey) {
+                    return existingTrigger.dedupeKey === triggerConfig.dedupeKey;
+                }
+                return (normalizeText(existingTrigger.instructions).toLowerCase() ===
+                    normalizeText(triggerConfig.instructions).toLowerCase() &&
+                    existingTrigger.triggerType === triggerConfig.triggerType &&
+                    (existingTrigger.wakeMode ?? "inject_now") ===
+                        (triggerConfig.wakeMode ?? "inject_now") &&
+                    (existingTrigger.intervalMs ?? 0) ===
+                        (triggerConfig.intervalMs ?? 0) &&
+                    (existingTrigger.scheduledAtIso ?? "") ===
+                        (triggerConfig.scheduledAtIso ?? "") &&
+                    (existingTrigger.cronExpression ?? "") ===
+                        (triggerConfig.cronExpression ?? ""));
+            });
+            if (duplicate?.id) {
+                const summary = taskToTriggerSummary(duplicate);
+                const duplicateText = `Equivalent trigger already exists (${summary?.displayName ?? duplicate.id}).`;
+                if (callback) {
+                    await callback({
+                        text: duplicateText,
+                        action: CREATE_TRIGGER_TASK_ACTION,
+                        metadata: {
+                            duplicateTaskId: duplicate.id,
+                        },
+                    });
+                }
+                return {
+                    success: true,
+                    text: duplicateText,
+                    data: {
+                        duplicateTaskId: duplicate.id,
+                    },
+                };
+            }
+            const metadata = buildTriggerMetadata({
+                trigger: triggerConfig,
+                nowMs: Date.now(),
+            });
+            if (!metadata) {
+                return {
+                    success: false,
+                    text: "Unable to compute trigger schedule.",
+                };
+            }
+            const autonomy = runtime.getService("AUTONOMY");
+            const roomId = autonomy?.getAutonomousRoomId?.() ?? message.roomId;
+            const createdTaskId = await runtime.createTask({
+                name: TRIGGER_TASK_NAME,
+                description: triggerConfig.displayName,
+                roomId,
+                tags: [...TRIGGER_TASK_TAGS],
+                metadata,
+            });
+            const createdTask = await runtime.getTask(createdTaskId);
+            const createdSummary = createdTask
+                ? taskToTriggerSummary(createdTask)
+                : null;
+            const fallbackNote = extractionFailed
+                ? " (Note: AI extraction failed; trigger was created from your raw text with default settings.)"
+                : "";
+            const successText = `Created trigger "${triggerConfig.displayName}" ${scheduleText(createdSummary)}.${fallbackNote}`;
+            if (callback) {
+                await callback({
+                    text: successText,
+                    action: CREATE_TRIGGER_TASK_ACTION,
+                    metadata: {
+                        triggerId,
+                        taskId: String(createdTaskId),
+                        triggerType: triggerConfig.triggerType,
+                    },
+                });
+            }
+            return {
+                success: true,
+                text: successText,
+                values: {
+                    triggerId,
+                    taskId: String(createdTaskId),
+                },
+                data: {
+                    triggerId,
+                    taskId: String(createdTaskId),
+                    triggerType: triggerConfig.triggerType,
+                },
+            };
+        }
+        catch (error) {
+            const messageText = error instanceof Error ? error.message : "Failed to create trigger";
+            return {
+                success: false,
+                text: messageText,
+            };
+        }
+    },
+};

package/packages/autonomous/src/triggers/runtime.d.ts

@@ -0,0 +1,24 @@
+import type { IAgentRuntime, Task } from "@elizaos/core";
+import type { TriggerConfig, TriggerHealthSnapshot, TriggerRunRecord, TriggerSummary } from "./types";
+export declare const TRIGGER_TASK_NAME: "TRIGGER_DISPATCH";
+export declare const TRIGGER_TASK_TAGS: readonly ["queue", "repeat", "trigger"];
+export interface TriggerExecutionOptions {
+    source: "scheduler" | "manual";
+    force?: boolean;
+}
+export interface TriggerExecutionResult {
+    status: "success" | "error" | "skipped";
+    error?: string;
+    taskDeleted: boolean;
+    runRecord?: TriggerRunRecord;
+}
+export declare function readTriggerConfig(task: Task): TriggerConfig | null;
+export declare function readTriggerRuns(task: Task): TriggerRunRecord[];
+export declare function triggersFeatureEnabled(runtime?: IAgentRuntime): boolean;
+export declare function getTriggerLimit(runtime?: IAgentRuntime): number;
+export declare function executeTriggerTask(runtime: IAgentRuntime, task: Task, options: TriggerExecutionOptions): Promise<TriggerExecutionResult>;
+export declare function registerTriggerTaskWorker(runtime: IAgentRuntime): void;
+export declare function listTriggerTasks(runtime: IAgentRuntime): Promise<Task[]>;
+export declare function taskToTriggerSummary(task: Task): TriggerSummary | null;
+export declare function getTriggerHealthSnapshot(runtime: IAgentRuntime): Promise<TriggerHealthSnapshot>;
+//# sourceMappingURL=runtime.d.ts.map

package/packages/autonomous/src/triggers/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../../src/triggers/runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAW,IAAI,EAAQ,MAAM,eAAe,CAAC;AAOxE,OAAO,KAAK,EACV,aAAa,EACb,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EAEf,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,iBAAiB,EAAG,kBAA2B,CAAC;AAC7D,eAAO,MAAM,iBAAiB,yCAA0C,CAAC;AAWzE,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAC;IAC/B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAC9B;AAgDD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,aAAa,GAAG,IAAI,CAOlE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,gBAAgB,EAAE,CAG9D;AAED,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAavE;AAED,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAa/D;AAmED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,sBAAsB,CAAC,CA2JjC;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CActE;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,EAAE,CAAC,CAMjB;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,cAAc,GAAG,IAAI,CA0BtE;AAED,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,qBAAqB,CAAC,CAsChC"}

package/packages/autonomous/src/triggers/runtime.js

@@ -0,0 +1,322 @@
+import crypto from "node:crypto";
+import { stringToUuid } from "@elizaos/core";
+import { buildTriggerMetadata, DISABLED_TRIGGER_INTERVAL_MS, MAX_TRIGGER_RUN_HISTORY, } from "./scheduling";
+export const TRIGGER_TASK_NAME = "TRIGGER_DISPATCH";
+export const TRIGGER_TASK_TAGS = ["queue", "repeat", "trigger"];
+const DEFAULT_MAX_ACTIVE_TRIGGERS = 100;
+const metricsByAgent = new Map();
+function getMetrics(agentId) {
+    const current = metricsByAgent.get(agentId);
+    if (current)
+        return current;
+    const created = {
+        totalExecutions: 0,
+        totalFailures: 0,
+        totalSkipped: 0,
+    };
+    metricsByAgent.set(agentId, created);
+    return created;
+}
+function recordExecutionMetric(agentId, status, ts) {
+    const metrics = getMetrics(agentId);
+    if (status === "success" || status === "error") {
+        metrics.totalExecutions += 1;
+        metrics.lastExecutionAt = ts;
+    }
+    if (status === "error") {
+        metrics.totalFailures += 1;
+    }
+    if (status === "skipped") {
+        metrics.totalSkipped += 1;
+    }
+}
+function appendRunRecord(existing, record) {
+    const runs = [...(existing ?? []), record];
+    return runs.length <= MAX_TRIGGER_RUN_HISTORY
+        ? runs
+        : runs.slice(runs.length - MAX_TRIGGER_RUN_HISTORY);
+}
+function taskMetadata(task) {
+    return (task.metadata ?? {});
+}
+export function readTriggerConfig(task) {
+    const trigger = taskMetadata(task).trigger;
+    if (!trigger || typeof trigger !== "object" || Array.isArray(trigger))
+        return null;
+    return trigger.triggerId
+        ? trigger
+        : null;
+}
+export function readTriggerRuns(task) {
+    const runs = taskMetadata(task).triggerRuns;
+    return Array.isArray(runs) ? runs : [];
+}
+export function triggersFeatureEnabled(runtime) {
+    const runtimeSetting = runtime?.getSetting("ELIZA_TRIGGERS_ENABLED");
+    if (runtimeSetting === false ||
+        runtimeSetting === "false" ||
+        runtimeSetting === "0") {
+        return false;
+    }
+    const env = process.env.ELIZA_TRIGGERS_ENABLED;
+    if (!env)
+        return true;
+    const normalized = env.trim().toLowerCase();
+    return normalized !== "0" && normalized !== "false";
+}
+export function getTriggerLimit(runtime) {
+    const runtimeSetting = runtime?.getSetting("ELIZA_TRIGGERS_MAX_ACTIVE");
+    if (typeof runtimeSetting === "number" && Number.isFinite(runtimeSetting)) {
+        return Math.max(1, Math.floor(runtimeSetting));
+    }
+    if (typeof runtimeSetting === "string" && /^\d+$/.test(runtimeSetting)) {
+        return Math.max(1, Number(runtimeSetting));
+    }
+    const env = process.env.ELIZA_TRIGGERS_MAX_ACTIVE;
+    if (env && /^\d+$/.test(env)) {
+        return Math.max(1, Number(env));
+    }
+    return DEFAULT_MAX_ACTIVE_TRIGGERS;
+}
+async function isAutonomyServiceAvailable(runtime) {
+    const svc = (await runtime.getService("autonomy")) ??
+        (await runtime.getService("AUTONOMY"));
+    return typeof svc?.injectAutonomousInstruction === "function";
+}
+async function dispatchInstruction(runtime, taskId, trigger) {
+    const autonomyService = runtime.getService("autonomy") ??
+        runtime.getService("AUTONOMY");
+    if (!autonomyService?.injectAutonomousInstruction) {
+        runtime.logger.warn?.(`Autonomy service missing injectAutonomousInstruction (taskId=${taskId}, triggerId=${trigger.triggerId})`);
+        throw new Error("Autonomy service unavailable for trigger dispatch");
+    }
+    const roomId = typeof autonomyService.getAutonomousRoomId === "function"
+        ? autonomyService.getAutonomousRoomId()
+        : undefined;
+    await autonomyService.injectAutonomousInstruction({
+        instructions: trigger.instructions,
+        source: "trigger-runtime",
+        wakeMode: trigger.wakeMode,
+        triggerId: trigger.triggerId,
+        triggerTaskId: taskId,
+        taskId,
+        roomId,
+    });
+}
+export async function executeTriggerTask(runtime, task, options) {
+    if (!task.id) {
+        return { status: "skipped", taskDeleted: false };
+    }
+    const trigger = readTriggerConfig(task);
+    if (!trigger) {
+        recordExecutionMetric(runtime.agentId, "skipped", Date.now());
+        return { status: "skipped", taskDeleted: false };
+    }
+    if (!trigger.enabled && !options.force) {
+        recordExecutionMetric(runtime.agentId, "skipped", Date.now());
+        return { status: "skipped", taskDeleted: false };
+    }
+    if (typeof trigger.maxRuns === "number" &&
+        trigger.maxRuns > 0 &&
+        trigger.runCount >= trigger.maxRuns) {
+        await runtime.deleteTask(task.id);
+        recordExecutionMetric(runtime.agentId, "skipped", Date.now());
+        return { status: "skipped", taskDeleted: true };
+    }
+    if (!(await isAutonomyServiceAvailable(runtime)) &&
+        options.source !== "manual") {
+        runtime.logger.warn?.({
+            src: "trigger-runtime",
+            taskId: task.id,
+            triggerId: trigger.triggerId,
+        }, "Autonomy service unavailable — skipping trigger (will retry next cycle)");
+        recordExecutionMetric(runtime.agentId, "skipped", Date.now());
+        return { status: "skipped", taskDeleted: false };
+    }
+    const startedAt = Date.now();
+    let status = "success";
+    let errorMessage = "";
+    try {
+        await dispatchInstruction(runtime, task.id, trigger);
+    }
+    catch (error) {
+        status = "error";
+        errorMessage = error instanceof Error ? error.message : String(error);
+        runtime.logger.error({
+            src: "trigger-runtime",
+            agentId: runtime.agentId,
+            taskId: task.id,
+            triggerId: trigger.triggerId,
+            error: errorMessage,
+        }, "Trigger execution failed");
+    }
+    if (status === "success") {
+        runtime.logger.info({
+            src: "trigger-runtime",
+            triggerId: trigger.triggerId,
+            triggerName: trigger.displayName,
+            triggerType: trigger.triggerType,
+            source: options.source,
+            latencyMs: Date.now() - startedAt,
+        }, `Trigger "${trigger.displayName}" executed successfully`);
+    }
+    const finishedAt = Date.now();
+    const runRecord = {
+        triggerRunId: stringToUuid(crypto.randomUUID()),
+        triggerId: trigger.triggerId,
+        taskId: task.id,
+        startedAt,
+        finishedAt,
+        status,
+        error: errorMessage || undefined,
+        latencyMs: finishedAt - startedAt,
+        source: options.source,
+    };
+    const updatedTrigger = {
+        ...trigger,
+        runCount: trigger.runCount + 1,
+        lastRunAtIso: new Date(finishedAt).toISOString(),
+        lastStatus: status,
+        lastError: errorMessage || undefined,
+    };
+    if (updatedTrigger.triggerType === "once" ||
+        (typeof updatedTrigger.maxRuns === "number" &&
+            updatedTrigger.maxRuns > 0 &&
+            updatedTrigger.runCount >= updatedTrigger.maxRuns)) {
+        await runtime.deleteTask(task.id);
+        recordExecutionMetric(runtime.agentId, status, finishedAt);
+        return {
+            status,
+            error: errorMessage || undefined,
+            runRecord,
+            taskDeleted: true,
+        };
+    }
+    const existingMetadata = taskMetadata(task);
+    const nextMetadata = buildTriggerMetadata({
+        existingMetadata,
+        trigger: updatedTrigger,
+        nowMs: finishedAt,
+    });
+    let metadataToPersist;
+    if (!nextMetadata) {
+        metadataToPersist = {
+            ...existingMetadata,
+            updatedAt: finishedAt,
+            updateInterval: DISABLED_TRIGGER_INTERVAL_MS,
+            trigger: {
+                ...updatedTrigger,
+                enabled: false,
+                nextRunAtMs: finishedAt + DISABLED_TRIGGER_INTERVAL_MS,
+                lastError: updatedTrigger.lastError ?? "Failed to compute next trigger schedule",
+            },
+            triggerRuns: appendRunRecord(existingMetadata.triggerRuns, runRecord),
+        };
+    }
+    else {
+        metadataToPersist = {
+            ...nextMetadata,
+            triggerRuns: appendRunRecord(existingMetadata.triggerRuns, runRecord),
+        };
+    }
+    await runtime.updateTask(task.id, {
+        description: metadataToPersist.trigger?.displayName ?? task.description,
+        metadata: metadataToPersist,
+    });
+    recordExecutionMetric(runtime.agentId, status, finishedAt);
+    return {
+        status,
+        error: errorMessage || undefined,
+        runRecord,
+        taskDeleted: false,
+    };
+}
+export function registerTriggerTaskWorker(runtime) {
+    if (runtime.getTaskWorker(TRIGGER_TASK_NAME))
+        return;
+    runtime.registerTaskWorker({
+        name: TRIGGER_TASK_NAME,
+        validate: async () => true,
+        execute: async (rt, options, task) => {
+            await executeTriggerTask(rt, task, {
+                source: options.source === "manual" ? "manual" : "scheduler",
+                force: options.force === true,
+            });
+            return {};
+        },
+    });
+}
+export async function listTriggerTasks(runtime) {
+    if (!triggersFeatureEnabled(runtime))
+        return [];
+    return runtime.getTasks({
+        tags: [...TRIGGER_TASK_TAGS],
+        agentIds: [runtime.agentId],
+    });
+}
+export function taskToTriggerSummary(task) {
+    const trigger = readTriggerConfig(task);
+    if (!trigger || !task.id)
+        return null;
+    const metadata = taskMetadata(task);
+    return {
+        id: trigger.triggerId,
+        taskId: task.id,
+        displayName: trigger.displayName,
+        instructions: trigger.instructions,
+        triggerType: trigger.triggerType,
+        enabled: trigger.enabled,
+        wakeMode: trigger.wakeMode,
+        createdBy: trigger.createdBy,
+        timezone: trigger.timezone,
+        intervalMs: trigger.intervalMs,
+        scheduledAtIso: trigger.scheduledAtIso,
+        cronExpression: trigger.cronExpression,
+        maxRuns: trigger.maxRuns,
+        runCount: trigger.runCount,
+        nextRunAtMs: trigger.nextRunAtMs,
+        lastRunAtIso: trigger.lastRunAtIso,
+        lastStatus: trigger.lastStatus,
+        lastError: trigger.lastError,
+        updatedAt: metadata.updatedAt,
+        updateInterval: metadata.updateInterval,
+    };
+}
+export async function getTriggerHealthSnapshot(runtime) {
+    const tasks = await listTriggerTasks(runtime);
+    let activeTriggers = 0;
+    let disabledTriggers = 0;
+    let durableExecutions = 0;
+    let durableFailures = 0;
+    let durableLastExecAt;
+    for (const task of tasks) {
+        const trigger = readTriggerConfig(task);
+        if (!trigger)
+            continue;
+        if (trigger.enabled) {
+            activeTriggers += 1;
+        }
+        else {
+            disabledTriggers += 1;
+        }
+        const runs = readTriggerRuns(task);
+        for (const run of runs) {
+            durableExecutions += 1;
+            if (run.status === "error")
+                durableFailures += 1;
+            if (!durableLastExecAt || run.finishedAt > durableLastExecAt) {
+                durableLastExecAt = run.finishedAt;
+            }
+        }
+    }
+    const inMemory = getMetrics(runtime.agentId);
+    return {
+        triggersEnabled: triggersFeatureEnabled(runtime),
+        activeTriggers,
+        disabledTriggers,
+        totalExecutions: Math.max(inMemory.totalExecutions, durableExecutions),
+        totalFailures: Math.max(inMemory.totalFailures, durableFailures),
+        totalSkipped: inMemory.totalSkipped,
+        lastExecutionAt: inMemory.lastExecutionAt ?? durableLastExecAt,
+    };
+}

package/packages/autonomous/src/triggers/scheduling.d.ts

@@ -0,0 +1,70 @@
+import type { UUID } from "@elizaos/core";
+import { type NormalizedTriggerDraft, type TriggerConfig, type TriggerTaskMetadata, type TriggerType, type TriggerWakeMode } from "./types";
+export declare const MIN_TRIGGER_INTERVAL_MS = 60000;
+export declare const MAX_TRIGGER_INTERVAL_MS: number;
+export declare const DISABLED_TRIGGER_INTERVAL_MS: number;
+export declare const MAX_TRIGGER_RUN_HISTORY = 100;
+interface CronSchedule {
+    minute: Set<number>;
+    hour: Set<number>;
+    dayOfMonth: Set<number>;
+    month: Set<number>;
+    dayOfWeek: Set<number>;
+}
+export interface TriggerTiming {
+    updatedAt: number;
+    updateIntervalMs: number;
+    nextRunAtMs: number;
+}
+interface DraftInput {
+    displayName?: string;
+    instructions?: string;
+    triggerType?: TriggerType;
+    wakeMode?: TriggerWakeMode;
+    enabled?: boolean;
+    createdBy?: string;
+    timezone?: string;
+    intervalMs?: number;
+    scheduledAtIso?: string;
+    cronExpression?: string;
+    maxRuns?: number;
+}
+export declare function parseCronExpression(expression: string): CronSchedule | null;
+export declare function computeNextCronRunAtMs(expression: string, fromMs: number, timezone?: string): number | null;
+export declare function parseScheduledAtIso(scheduledAtIso: string): number | null;
+export declare function normalizeTriggerIntervalMs(intervalMs: number): number;
+export declare function resolveTriggerTiming(trigger: TriggerConfig, nowMs: number): TriggerTiming | null;
+export declare function buildTriggerMetadata(params: {
+    existingMetadata?: TriggerTaskMetadata;
+    trigger: TriggerConfig;
+    nowMs: number;
+}): TriggerTaskMetadata | null;
+export declare function buildTriggerDedupeKey(parts: {
+    triggerType: TriggerType;
+    instructions: string;
+    intervalMs?: number;
+    scheduledAtIso?: string;
+    cronExpression?: string;
+    wakeMode: TriggerWakeMode;
+}): string;
+export declare function buildTriggerConfig(params: {
+    draft: NormalizedTriggerDraft;
+    triggerId: UUID;
+    previous?: TriggerConfig;
+}): TriggerConfig;
+export declare function normalizeTriggerDraft(params: {
+    input: DraftInput;
+    fallback: {
+        displayName: string;
+        instructions: string;
+        triggerType: TriggerType;
+        wakeMode: TriggerWakeMode;
+        enabled: boolean;
+        createdBy: string;
+    };
+}): {
+    draft?: NormalizedTriggerDraft;
+    error?: string;
+};
+export {};
+//# sourceMappingURL=scheduling.d.ts.map