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

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

@@ -1,267 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,322 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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