miladyai 2.0.0-alpha.27

package/dist/trajectory-routes.js

@@ -0,0 +1,300 @@
+import { readJsonBody, sendJson, sendJsonError } from "./http-helpers.js";
+import { createZipArchive } from "./zip-utils.js";
+
+//#region src/api/trajectory-routes.ts
+function isRouteCompatibleTrajectoryLogger(candidate) {
+	if (!candidate || typeof candidate !== "object") return false;
+	const logger = candidate;
+	return typeof logger.isEnabled === "function" && typeof logger.setEnabled === "function" && typeof logger.listTrajectories === "function" && typeof logger.getTrajectoryDetail === "function" && typeof logger.getStats === "function" && typeof logger.deleteTrajectories === "function" && typeof logger.clearAllTrajectories === "function" && typeof logger.exportTrajectories === "function";
+}
+function getTrajectoryLogger(runtime) {
+	const runtimeLike = runtime;
+	const seen = /* @__PURE__ */ new Set();
+	const candidates = [];
+	const addCandidate = (candidate) => {
+		if (!candidate || seen.has(candidate)) return;
+		seen.add(candidate);
+		candidates.push(candidate);
+	};
+	if (typeof runtimeLike.getServicesByType === "function") {
+		const byType = runtimeLike.getServicesByType("trajectory_logger");
+		if (Array.isArray(byType)) for (const candidate of byType) addCandidate(candidate);
+		else addCandidate(byType);
+	}
+	if (typeof runtimeLike.getService === "function") addCandidate(runtimeLike.getService("trajectory_logger"));
+	for (const candidate of candidates) if (isRouteCompatibleTrajectoryLogger(candidate)) return candidate;
+	return null;
+}
+function toNullableString(value) {
+	return typeof value === "string" ? value : null;
+}
+function listItemToUIRecord(item) {
+	const status = item.status === "timeout" || item.status === "error" ? "error" : item.status;
+	return {
+		id: item.id,
+		agentId: item.agentId,
+		roomId: null,
+		entityId: null,
+		conversationId: null,
+		source: item.source,
+		status,
+		startTime: item.startTime,
+		endTime: item.endTime,
+		durationMs: item.durationMs,
+		llmCallCount: item.llmCallCount,
+		providerAccessCount: 0,
+		totalPromptTokens: item.totalPromptTokens,
+		totalCompletionTokens: item.totalCompletionTokens,
+		metadata: {},
+		createdAt: item.createdAt,
+		updatedAt: item.createdAt
+	};
+}
+function trajectoryToUIDetail(traj) {
+	const finalStatus = traj.metrics?.finalStatus ?? "completed";
+	const normalizedEndTime = typeof traj.endTime === "number" && traj.endTime > 0 ? traj.endTime : null;
+	const status = finalStatus === "timeout" || finalStatus === "terminated" || finalStatus === "error" ? "error" : finalStatus === "completed" ? "completed" : normalizedEndTime ? "completed" : "active";
+	const llmCalls = [];
+	const providerAccesses = [];
+	let totalPromptTokens = 0;
+	let totalCompletionTokens = 0;
+	const steps = traj.steps || [];
+	const trajectoryId = String(traj.trajectoryId);
+	for (let i = 0; i < steps.length; i++) {
+		const step = steps[i];
+		const stepId = typeof step.stepId === "string" ? step.stepId : `step-${i}`;
+		const calls = step.llmCalls || [];
+		for (let j = 0; j < calls.length; j++) {
+			const call = calls[j];
+			llmCalls.push({
+				id: call.callId || `${stepId}-call-${j}`,
+				trajectoryId,
+				stepId,
+				model: call.model || "unknown",
+				systemPrompt: call.systemPrompt || "",
+				userPrompt: call.userPrompt || "",
+				response: call.response || "",
+				temperature: typeof call.temperature === "number" ? call.temperature : 0,
+				maxTokens: typeof call.maxTokens === "number" ? call.maxTokens : 0,
+				purpose: call.purpose || "",
+				actionType: call.actionType || "",
+				latencyMs: call.latencyMs || 0,
+				promptTokens: call.promptTokens,
+				completionTokens: call.completionTokens,
+				timestamp: call.timestamp || step.timestamp,
+				createdAt: new Date(call.timestamp || step.timestamp).toISOString()
+			});
+			totalPromptTokens += call.promptTokens || 0;
+			totalCompletionTokens += call.completionTokens || 0;
+		}
+		const accesses = step.providerAccesses || [];
+		for (let k = 0; k < accesses.length; k++) {
+			const access = accesses[k];
+			providerAccesses.push({
+				id: access.providerId || `${stepId}-provider-${k}`,
+				trajectoryId,
+				stepId,
+				providerName: access.providerName || "unknown",
+				purpose: access.purpose || "",
+				data: access.data || {},
+				query: access.query,
+				timestamp: access.timestamp || step.timestamp,
+				createdAt: new Date(access.timestamp || step.timestamp).toISOString()
+			});
+		}
+	}
+	const metadata = traj.metadata ?? {};
+	const normalizedDurationMs = status === "active" ? null : typeof traj.durationMs === "number" ? traj.durationMs : null;
+	const updatedAtMs = normalizedEndTime ?? (traj.startTime || Date.now());
+	return {
+		trajectory: {
+			id: trajectoryId,
+			agentId: String(traj.agentId),
+			roomId: toNullableString(metadata.roomId),
+			entityId: toNullableString(metadata.entityId),
+			conversationId: toNullableString(metadata.conversationId),
+			source: toNullableString(metadata.source) ?? "chat",
+			status,
+			startTime: traj.startTime,
+			endTime: normalizedEndTime,
+			durationMs: normalizedDurationMs,
+			llmCallCount: llmCalls.length,
+			providerAccessCount: providerAccesses.length,
+			totalPromptTokens,
+			totalCompletionTokens,
+			metadata,
+			createdAt: new Date(traj.startTime).toISOString(),
+			updatedAt: new Date(updatedAtMs).toISOString()
+		},
+		llmCalls,
+		providerAccesses
+	};
+}
+async function handleGetTrajectories(req, res, runtime) {
+	const logger = getTrajectoryLogger(runtime);
+	if (!logger) {
+		sendJsonError(res, "Trajectory logger service not available", 503);
+		return;
+	}
+	const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+	const options = {
+		limit: Math.min(500, Math.max(1, Number(url.searchParams.get("limit")) || 50)),
+		offset: Math.max(0, Number(url.searchParams.get("offset")) || 0),
+		source: url.searchParams.get("source") || void 0,
+		status: url.searchParams.get("status") || void 0,
+		startDate: url.searchParams.get("startDate") || void 0,
+		endDate: url.searchParams.get("endDate") || void 0,
+		search: url.searchParams.get("search") || void 0,
+		scenarioId: url.searchParams.get("scenarioId") || void 0,
+		batchId: url.searchParams.get("batchId") || void 0,
+		isTrainingData: url.searchParams.has("isTrainingData") ? url.searchParams.get("isTrainingData") === "true" : void 0
+	};
+	const result = await logger.listTrajectories(options);
+	sendJson(res, {
+		trajectories: result.trajectories.map(listItemToUIRecord),
+		total: result.total,
+		offset: result.offset,
+		limit: result.limit
+	});
+}
+async function handleGetTrajectoryDetail(_req, res, runtime, trajectoryId) {
+	const logger = getTrajectoryLogger(runtime);
+	if (!logger) {
+		sendJsonError(res, "Trajectory logger service not available", 503);
+		return;
+	}
+	const trajectory = await logger.getTrajectoryDetail(trajectoryId);
+	if (!trajectory) {
+		sendJsonError(res, `Trajectory "${trajectoryId}" not found`, 404);
+		return;
+	}
+	sendJson(res, trajectoryToUIDetail(trajectory));
+}
+async function handleGetStats(_req, res, runtime) {
+	const logger = getTrajectoryLogger(runtime);
+	if (!logger) {
+		sendJsonError(res, "Trajectory logger service not available", 503);
+		return;
+	}
+	sendJson(res, await logger.getStats());
+}
+async function handleGetConfig(_req, res, runtime) {
+	const logger = getTrajectoryLogger(runtime);
+	if (!logger) {
+		sendJsonError(res, "Trajectory logger service not available", 503);
+		return;
+	}
+	sendJson(res, { enabled: logger.isEnabled() });
+}
+async function handlePutConfig(req, res, runtime) {
+	const logger = getTrajectoryLogger(runtime);
+	if (!logger) {
+		sendJsonError(res, "Trajectory logger service not available", 503);
+		return;
+	}
+	const body = await readJsonBody(req, res);
+	if (!body) return;
+	if (typeof body.enabled === "boolean") logger.setEnabled(body.enabled);
+	sendJson(res, { enabled: logger.isEnabled() });
+}
+async function handleExportTrajectories(req, res, runtime) {
+	const logger = getTrajectoryLogger(runtime);
+	if (!logger) {
+		sendJsonError(res, "Trajectory logger service not available", 503);
+		return;
+	}
+	const body = await readJsonBody(req, res);
+	if (!body) return;
+	if (body.format === "zip") {
+		if (typeof logger.exportTrajectoriesZip !== "function") {
+			sendJsonError(res, "Trajectory ZIP export is unavailable in the active logger", 503);
+			return;
+		}
+		const zipOptions = {
+			includePrompts: body.includePrompts,
+			trajectoryIds: body.trajectoryIds,
+			startDate: body.startDate,
+			endDate: body.endDate,
+			scenarioId: body.scenarioId,
+			batchId: body.batchId
+		};
+		const zipResult = await logger.exportTrajectoriesZip(zipOptions);
+		const archive = createZipArchive(zipResult.entries);
+		res.statusCode = 200;
+		res.setHeader("Content-Type", "application/zip");
+		res.setHeader("Content-Disposition", `attachment; filename="${zipResult.filename}"`);
+		res.end(archive);
+		return;
+	}
+	if (body.format !== "json" && body.format !== "csv" && body.format !== "art") {
+		sendJsonError(res, "Format must be 'json', 'csv', 'art', or 'zip'", 400);
+		return;
+	}
+	const result = await logger.exportTrajectories({
+		format: body.format,
+		includePrompts: body.includePrompts,
+		trajectoryIds: body.trajectoryIds,
+		startDate: body.startDate,
+		endDate: body.endDate,
+		scenarioId: body.scenarioId,
+		batchId: body.batchId
+	});
+	res.statusCode = 200;
+	res.setHeader("Content-Type", result.mimeType);
+	res.setHeader("Content-Disposition", `attachment; filename="${result.filename}"`);
+	res.end(result.data);
+}
+async function handleDeleteTrajectories(req, res, runtime) {
+	const logger = getTrajectoryLogger(runtime);
+	if (!logger) {
+		sendJsonError(res, "Trajectory logger service not available", 503);
+		return;
+	}
+	const body = await readJsonBody(req, res);
+	if (!body) return;
+	if (body.all) {
+		sendJson(res, { deleted: await logger.clearAllTrajectories() });
+		return;
+	}
+	if (Array.isArray(body.trajectoryIds) && body.trajectoryIds.length > 0) {
+		sendJson(res, { deleted: await logger.deleteTrajectories(body.trajectoryIds) });
+		return;
+	}
+	sendJson(res, { deleted: 0 });
+}
+async function handleTrajectoryRoute(req, res, runtime, pathname, method) {
+	if (!pathname.startsWith("/api/trajectories")) return false;
+	if (pathname === "/api/trajectories/config" && method === "GET") {
+		await handleGetConfig(req, res, runtime);
+		return true;
+	}
+	if (pathname === "/api/trajectories/config" && method === "PUT") {
+		await handlePutConfig(req, res, runtime);
+		return true;
+	}
+	if (pathname === "/api/trajectories/export" && method === "POST") {
+		await handleExportTrajectories(req, res, runtime);
+		return true;
+	}
+	if (pathname === "/api/trajectories" && method === "DELETE") {
+		await handleDeleteTrajectories(req, res, runtime);
+		return true;
+	}
+	if (pathname === "/api/trajectories/stats" && method === "GET") {
+		await handleGetStats(req, res, runtime);
+		return true;
+	}
+	const detailMatch = pathname.match(/^\/api\/trajectories\/([^/]+)$/);
+	if (detailMatch && method === "GET") {
+		await handleGetTrajectoryDetail(req, res, runtime, detailMatch[1]);
+		return true;
+	}
+	if (pathname === "/api/trajectories" && method === "GET") {
+		await handleGetTrajectories(req, res, runtime);
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleTrajectoryRoute };

package/dist/trigger-routes.js

@@ -0,0 +1,246 @@
+import { DISABLED_TRIGGER_INTERVAL_MS, buildTriggerConfig, buildTriggerMetadata, normalizeTriggerDraft } from "./triggers/scheduling.js";
+import { TRIGGER_TASK_NAME, TRIGGER_TASK_TAGS, executeTriggerTask, getTriggerHealthSnapshot, getTriggerLimit, listTriggerTasks, readTriggerConfig, readTriggerRuns, taskToTriggerSummary, triggersFeatureEnabled } from "./triggers/runtime.js";
+import crypto from "node:crypto";
+import { stringToUuid } from "@elizaos/core";
+
+//#region src/api/trigger-routes.ts
+function trim(s) {
+	return s.trim().replace(/\s+/g, " ");
+}
+async function findTask(runtime, id) {
+	return (await listTriggerTasks(runtime)).find((t) => {
+		return readTriggerConfig(t)?.triggerId === id || t.id === id;
+	}) ?? null;
+}
+async function handleTriggerRoutes(ctx) {
+	const { method, pathname, req, res, runtime, readJsonBody, json, error } = ctx;
+	if (!pathname.startsWith("/api/triggers")) return false;
+	if (!runtime) {
+		error(res, "Agent is not running", 503);
+		return true;
+	}
+	if (!triggersFeatureEnabled(runtime) && pathname !== "/api/triggers/health") {
+		error(res, "Triggers are disabled by configuration", 503);
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/triggers/health") {
+		json(res, await getTriggerHealthSnapshot(runtime));
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/triggers") {
+		json(res, { triggers: (await listTriggerTasks(runtime)).map(taskToTriggerSummary).filter((s) => s !== null).sort((a, b) => a.displayName.localeCompare(b.displayName)) });
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/triggers") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		const creator = trim(body.createdBy ?? "") || "api";
+		const normalized = normalizeTriggerDraft({
+			input: {
+				...body,
+				enabled: body.enabled ?? true,
+				createdBy: creator
+			},
+			fallback: {
+				displayName: trim(body.displayName ?? "") || "New Trigger",
+				instructions: trim(body.instructions ?? ""),
+				triggerType: body.triggerType ?? "interval",
+				wakeMode: body.wakeMode ?? "inject_now",
+				enabled: body.enabled ?? true,
+				createdBy: creator
+			}
+		});
+		if (!normalized.draft) {
+			error(res, normalized.error ?? "Invalid trigger request", 400);
+			return true;
+		}
+		const existingTasks = await listTriggerTasks(runtime);
+		const activeCount = existingTasks.filter((t) => {
+			const tr = readTriggerConfig(t);
+			return tr?.enabled && tr.createdBy === creator;
+		}).length;
+		const limit = getTriggerLimit(runtime);
+		if (activeCount >= limit) {
+			error(res, `Active trigger limit reached (${limit})`, 429);
+			return true;
+		}
+		const triggerId = stringToUuid(crypto.randomUUID());
+		const trigger = buildTriggerConfig({
+			draft: normalized.draft,
+			triggerId
+		});
+		if (existingTasks.find((t) => {
+			const et = readTriggerConfig(t);
+			return et?.enabled && et.dedupeKey && et.dedupeKey === trigger.dedupeKey;
+		})?.id) {
+			error(res, "Equivalent trigger already exists", 409);
+			return true;
+		}
+		const metadata = buildTriggerMetadata({
+			trigger,
+			nowMs: Date.now()
+		});
+		if (!metadata) {
+			error(res, "Unable to compute trigger schedule", 400);
+			return true;
+		}
+		const roomId = runtime.getService("AUTONOMY")?.getAutonomousRoomId?.();
+		const taskId = await runtime.createTask({
+			name: TRIGGER_TASK_NAME,
+			description: trigger.displayName,
+			roomId,
+			tags: [...TRIGGER_TASK_TAGS],
+			metadata
+		});
+		const created = await runtime.getTask(taskId);
+		const summary = created ? taskToTriggerSummary(created) : null;
+		if (!summary) {
+			error(res, "Trigger created but summary could not be generated", 500);
+			return true;
+		}
+		json(res, { trigger: summary }, 201);
+		return true;
+	}
+	const runsMatch = /^\/api\/triggers\/([^/]+)\/runs$/.exec(pathname);
+	if (method === "GET" && runsMatch) {
+		const task = await findTask(runtime, decodeURIComponent(runsMatch[1]));
+		if (!task) {
+			error(res, "Trigger not found", 404);
+			return true;
+		}
+		json(res, { runs: readTriggerRuns(task) });
+		return true;
+	}
+	const execMatch = /^\/api\/triggers\/([^/]+)\/execute$/.exec(pathname);
+	if (method === "POST" && execMatch) {
+		const task = await findTask(runtime, decodeURIComponent(execMatch[1]));
+		if (!task) {
+			error(res, "Trigger not found", 404);
+			return true;
+		}
+		const result = await executeTriggerTask(runtime, task, {
+			source: "manual",
+			force: true
+		});
+		const refreshed = task.id ? await runtime.getTask(task.id) : null;
+		json(res, {
+			ok: true,
+			result,
+			trigger: refreshed ? taskToTriggerSummary(refreshed) : null
+		});
+		return true;
+	}
+	const itemMatch = /^\/api\/triggers\/([^/]+)$/.exec(pathname);
+	if (!itemMatch) return false;
+	const triggerId = decodeURIComponent(itemMatch[1]);
+	if (method === "GET") {
+		const task = await findTask(runtime, triggerId);
+		if (!task) {
+			error(res, "Trigger not found", 404);
+			return true;
+		}
+		const summary = taskToTriggerSummary(task);
+		if (!summary) {
+			error(res, "Trigger metadata is invalid", 500);
+			return true;
+		}
+		json(res, { trigger: summary });
+		return true;
+	}
+	if (method === "DELETE") {
+		const task = await findTask(runtime, triggerId);
+		if (!task?.id) {
+			error(res, "Trigger not found", 404);
+			return true;
+		}
+		await runtime.deleteTask(task.id);
+		json(res, { ok: true });
+		return true;
+	}
+	if (method === "PUT") {
+		const task = await findTask(runtime, triggerId);
+		if (!task?.id) {
+			error(res, "Trigger not found", 404);
+			return true;
+		}
+		const current = readTriggerConfig(task);
+		if (!current) {
+			error(res, "Trigger metadata is invalid", 500);
+			return true;
+		}
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		const normalized = normalizeTriggerDraft({
+			input: {
+				...body,
+				createdBy: current.createdBy,
+				intervalMs: body.intervalMs ?? current.intervalMs,
+				scheduledAtIso: body.scheduledAtIso ?? current.scheduledAtIso,
+				cronExpression: body.cronExpression ?? current.cronExpression,
+				maxRuns: body.maxRuns ?? current.maxRuns
+			},
+			fallback: {
+				displayName: current.displayName,
+				instructions: current.instructions,
+				triggerType: current.triggerType,
+				wakeMode: current.wakeMode,
+				enabled: body.enabled ?? current.enabled,
+				createdBy: current.createdBy
+			}
+		});
+		if (!normalized.draft) {
+			error(res, normalized.error ?? "Invalid update", 400);
+			return true;
+		}
+		const nextTrigger = buildTriggerConfig({
+			draft: normalized.draft,
+			triggerId: current.triggerId,
+			previous: current
+		});
+		const existingMeta = task.metadata ?? {};
+		const existingRuns = readTriggerRuns(task);
+		let nextMeta;
+		if (!nextTrigger.enabled) nextMeta = {
+			...existingMeta,
+			updatedAt: Date.now(),
+			updateInterval: DISABLED_TRIGGER_INTERVAL_MS,
+			trigger: {
+				...nextTrigger,
+				nextRunAtMs: Date.now() + DISABLED_TRIGGER_INTERVAL_MS
+			},
+			triggerRuns: existingRuns
+		};
+		else {
+			const built = buildTriggerMetadata({
+				existingMetadata: existingMeta,
+				trigger: nextTrigger,
+				nowMs: Date.now()
+			});
+			if (!built) {
+				error(res, "Unable to compute trigger schedule", 400);
+				return true;
+			}
+			nextMeta = built;
+		}
+		await runtime.updateTask(task.id, {
+			description: nextTrigger.displayName,
+			metadata: nextMeta
+		});
+		const refreshed = await runtime.getTask(task.id);
+		if (!refreshed) {
+			error(res, "Trigger updated but no longer available", 500);
+			return true;
+		}
+		const summary = taskToTriggerSummary(refreshed);
+		if (!summary) {
+			error(res, "Trigger metadata is invalid", 500);
+			return true;
+		}
+		json(res, { trigger: summary });
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleTriggerRoutes };