miladyai 2.0.0-alpha.27

package/dist/triggers/action.js

@@ -0,0 +1,218 @@
+import { buildTriggerConfig, buildTriggerMetadata, normalizeTriggerDraft } from "./scheduling.js";
+import { TRIGGER_TASK_NAME, TRIGGER_TASK_TAGS, getTriggerLimit, listTriggerTasks, readTriggerConfig, taskToTriggerSummary, triggersFeatureEnabled } from "./runtime.js";
+import { parsePositiveInteger } from "../utils/number-parsing.js";
+import { ModelType, stringToUuid } from "@elizaos/core";
+import crypto from "node:crypto";
+
+//#region src/triggers/action.ts
+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 match = new RegExp(`<${tag}>([\\s\\S]*?)<\\/${tag}>`, "i").exec(xml);
+	if (!match?.[1]) return void 0;
+	const text = normalizeText(match[1]);
+	return text.length > 0 ? text : void 0;
+}
+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 ?? "* * * * *"}`;
+}
+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 (!runtime.enableAutonomy) return false;
+		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 (!runtime.enableAutonomy) return {
+			success: false,
+			text: "Autonomy mode is disabled, so trigger creation is unavailable."
+		};
+		if (!triggersFeatureEnabled(runtime)) return {
+			success: false,
+			text: "Triggers are disabled by configuration."
+		};
+		try {
+			let extraction = {};
+			let extractionFailed = false;
+			try {
+				extraction = parseExtraction(await runtime.useModel(ModelType.TEXT_SMALL, {
+					prompt: extractionPrompt(text),
+					stopSequences: []
+				}));
+			} 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);
+			if (existingTasks.filter((task) => {
+				const trigger = readTriggerConfig(task);
+				return trigger?.enabled && trigger.createdBy === creator;
+			}).length >= 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.intervalMs ?? 0) === (triggerConfig.intervalMs ?? 0) && (existingTrigger.scheduledAtIso ?? "") === (triggerConfig.scheduledAtIso ?? "") && (existingTrigger.cronExpression ?? "") === (triggerConfig.cronExpression ?? "");
+			});
+			if (duplicate?.id) {
+				const duplicateText = `Equivalent trigger already exists (${taskToTriggerSummary(duplicate)?.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 roomId = runtime.getService("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) {
+			return {
+				success: false,
+				text: error instanceof Error ? error.message : "Failed to create trigger"
+			};
+		}
+	}
+};
+
+//#endregion
+export { createTriggerTaskAction };

package/dist/triggers/runtime.js

@@ -0,0 +1,281 @@
+import { DISABLED_TRIGGER_INTERVAL_MS, MAX_TRIGGER_RUN_HISTORY, buildTriggerMetadata } from "./scheduling.js";
+import { stringToUuid } from "@elizaos/core";
+import crypto from "node:crypto";
+
+//#region src/triggers/runtime.ts
+const TRIGGER_TASK_NAME = "TRIGGER_DISPATCH";
+const TRIGGER_TASK_TAGS = [
+	"queue",
+	"repeat",
+	"trigger"
+];
+const DEFAULT_MAX_ACTIVE_TRIGGERS = 100;
+/**
+* In-memory trigger execution metrics per agent.
+* These counters are approximations for the /api/triggers/health endpoint
+* and reset on process restart. Durable execution history is stored in
+* task.metadata.triggerRuns (persisted to database via the task system).
+*/
+const metricsByAgent = /* @__PURE__ */ 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 ?? {};
+}
+function readTriggerConfig(task) {
+	const trigger = taskMetadata(task).trigger;
+	if (!trigger || typeof trigger !== "object" || Array.isArray(trigger)) return null;
+	return trigger.triggerId ? trigger : null;
+}
+function readTriggerRuns(task) {
+	const runs = taskMetadata(task).triggerRuns;
+	return Array.isArray(runs) ? runs : [];
+}
+function triggersFeatureEnabled(runtime) {
+	const runtimeSetting = runtime?.getSetting("MILADY_TRIGGERS_ENABLED");
+	if (runtimeSetting === false || runtimeSetting === "false" || runtimeSetting === "0") return false;
+	const env = process.env.MILADY_TRIGGERS_ENABLED;
+	if (!env) return true;
+	const normalized = env.trim().toLowerCase();
+	return normalized !== "0" && normalized !== "false";
+}
+function getTriggerLimit(runtime) {
+	const runtimeSetting = runtime?.getSetting("MILADY_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.MILADY_TRIGGERS_MAX_ACTIVE;
+	if (env && /^\d+$/.test(env)) return Math.max(1, Number(env));
+	return DEFAULT_MAX_ACTIVE_TRIGGERS;
+}
+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() : void 0;
+	await autonomyService.injectAutonomousInstruction({
+		instructions: trigger.instructions,
+		source: "trigger-runtime",
+		wakeMode: trigger.wakeMode,
+		triggerId: trigger.triggerId,
+		triggerTaskId: taskId,
+		taskId,
+		roomId
+	});
+}
+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
+		};
+	}
+	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 || void 0,
+		latencyMs: finishedAt - startedAt,
+		source: options.source
+	};
+	const updatedTrigger = {
+		...trigger,
+		runCount: trigger.runCount + 1,
+		lastRunAtIso: new Date(finishedAt).toISOString(),
+		lastStatus: status,
+		lastError: errorMessage || void 0
+	};
+	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 || void 0,
+			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 || void 0,
+		runRecord,
+		taskDeleted: false
+	};
+}
+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
+			});
+		}
+	});
+}
+async function listTriggerTasks(runtime) {
+	if (!triggersFeatureEnabled(runtime)) return [];
+	return runtime.getTasks({ tags: [...TRIGGER_TASK_TAGS] });
+}
+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
+	};
+}
+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
+	};
+}
+
+//#endregion
+export { TRIGGER_TASK_NAME, TRIGGER_TASK_TAGS, executeTriggerTask, getTriggerHealthSnapshot, getTriggerLimit, listTriggerTasks, readTriggerConfig, readTriggerRuns, registerTriggerTaskWorker, taskToTriggerSummary, triggersFeatureEnabled };