@elizaos/agent 2.0.0-alpha.97 → 2.0.0-beta.1

package/dist/packages/agent/src/actions/trigger.js

@@ -0,0 +1,514 @@
+/**
+ * TRIGGER — recurring/scheduled trigger lifecycle as a Pattern-C op-dispatch
+ * action.
+ *
+ * Ops:
+ *   create — create a trigger (interval / once / cron) with instructions and
+ *            wakeMode. Enforces a per-creator limit and dedupes on
+ *            (type, instructions, schedule).
+ *   update — patch displayName / instructions / schedule / wakeMode / maxRuns.
+ *   delete — remove a trigger task.
+ *   run    — fire a trigger immediately (manual run, force=true).
+ *   toggle — flip enabled, or set to a specific value via `enabled`.
+ *
+ * Triggers are persisted as runtime Tasks tagged with TRIGGER_TASK_TAGS and
+ * carry a {@link TriggerConfig} in their metadata. Workbench tasks (TASK
+ * action) and trigger tasks share a table but are kept distinct via tag.
+ */
+import crypto from "node:crypto";
+import { asUUID, stringToUuid, TRIGGER_SCHEMA_VERSION, } from "@elizaos/core";
+import { executeTriggerTask, readTriggerConfig, TRIGGER_TASK_NAME, TRIGGER_TASK_TAGS, } from "../triggers/runtime.js";
+import { buildTriggerMetadata, normalizeTriggerIntervalMs, parseCronExpression, parseScheduledAtIso, } from "../triggers/scheduling.js";
+import { deployTextTriggerWorkflow } from "../triggers/text-to-workflow.js";
+function isAutonomyRoomService(service) {
+    return typeof service === "object" && service !== null;
+}
+const TRIGGER_OPS = ["create", "update", "delete", "run", "toggle"];
+const TRIGGER_ACTION = "TRIGGER";
+const MAX_TRIGGERS_PER_CREATOR = 100;
+const DEFAULT_INTERVAL_MS = 12 * 60 * 60 * 1000;
+function readParams(options) {
+    const raw = options?.parameters;
+    if (!raw || typeof raw !== "object")
+        return {};
+    return raw;
+}
+function readString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function readUuid(value) {
+    const str = readString(value);
+    return str ? asUUID(str) : undefined;
+}
+function readBool(value, fallback = false) {
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "string") {
+        const v = value.trim().toLowerCase();
+        if (v === "true" || v === "1" || v === "yes" || v === "on")
+            return true;
+        if (v === "false" || v === "0" || v === "no" || v === "off")
+            return false;
+    }
+    return fallback;
+}
+function parsePositiveInt(raw) {
+    if (typeof raw === "number") {
+        return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : undefined;
+    }
+    if (typeof raw === "string") {
+        const trimmed = raw.trim();
+        if (!/^\d+$/.test(trimmed))
+            return undefined;
+        const n = Number(trimmed);
+        return Number.isFinite(n) && n > 0 ? n : undefined;
+    }
+    return undefined;
+}
+function failed(op, text, error, data) {
+    const code = `TRIGGER_${op.toUpperCase()}_FAILED`;
+    return {
+        success: false,
+        text,
+        error: error ?? code,
+        values: { op, error: error ?? code },
+        data: { actionName: TRIGGER_ACTION, op, error: error ?? code, ...data },
+    };
+}
+function ok(op, text, data, values) {
+    return {
+        success: true,
+        text,
+        values: { op, ...(values ?? {}) },
+        data: { actionName: TRIGGER_ACTION, op, ...(data ?? {}) },
+    };
+}
+function deriveTriggerType(p) {
+    const t = p.triggerType?.trim().toLowerCase();
+    if (t === "interval" || t === "once" || t === "cron")
+        return t;
+    if (p.cronExpression?.trim())
+        return "cron";
+    if (p.scheduledAtIso?.trim())
+        return "once";
+    return "interval";
+}
+function dedupeHash(input) {
+    let h = 5381;
+    for (const c of input)
+        h = (h * 33) ^ c.charCodeAt(0);
+    return `trigger-${Math.abs(h >>> 0).toString(16)}`;
+}
+function describeSchedule(t) {
+    if (t.triggerType === "interval")
+        return `every ${t.intervalMs ?? DEFAULT_INTERVAL_MS}ms`;
+    if (t.triggerType === "once")
+        return `once at ${t.scheduledAtIso ?? "?"}`;
+    return `cron ${t.cronExpression ?? "* * * * *"}`;
+}
+function triggersDisabled(runtime) {
+    const setting = runtime.getSetting("ELIZA_TRIGGERS_ENABLED");
+    if (setting === false || setting === "false" || setting === "0")
+        return true;
+    const env = process.env.ELIZA_TRIGGERS_ENABLED;
+    return env === "0" || env === "false";
+}
+async function loadTriggerTask(runtime, taskId) {
+    const task = await runtime.getTask(taskId);
+    if (!task?.id)
+        return null;
+    const trigger = readTriggerConfig(task);
+    return trigger ? { task, trigger } : null;
+}
+function isTriggerOp(value) {
+    return TRIGGER_OPS.includes(value);
+}
+async function opCreate(runtime, message, params) {
+    if (!runtime.enableAutonomy) {
+        return failed("create", "Autonomy is disabled.", "AUTONOMY_OFF");
+    }
+    if (triggersDisabled(runtime)) {
+        return failed("create", "Triggers are disabled.", "TRIGGERS_OFF");
+    }
+    const text = readString(message.content.text) ?? "";
+    const instructions = readString(params.instructions) ?? text;
+    if (!instructions) {
+        return failed("create", "instructions is required.", "MISSING_INSTRUCTIONS");
+    }
+    const triggerType = deriveTriggerType(params);
+    const displayName = readString(params.displayName) ?? `Trigger: ${instructions.slice(0, 64)}`;
+    const wakeMode = params.wakeMode?.trim().toLowerCase() === "next_autonomy_cycle"
+        ? "next_autonomy_cycle"
+        : "inject_now";
+    const creatorId = String(message.entityId ?? runtime.agentId);
+    const intervalMs = normalizeTriggerIntervalMs(parsePositiveInt(params.intervalMs) ?? DEFAULT_INTERVAL_MS);
+    const scheduledAtIso = readString(params.scheduledAtIso);
+    const cronExpression = readString(params.cronExpression);
+    const maxRuns = parsePositiveInt(params.maxRuns);
+    if (triggerType === "once" &&
+        (!scheduledAtIso || parseScheduledAtIso(scheduledAtIso) === null)) {
+        return failed("create", "Once trigger requires a valid scheduledAtIso.", "INVALID_SCHEDULE");
+    }
+    if (triggerType === "cron" &&
+        (!cronExpression || !parseCronExpression(cronExpression))) {
+        return failed("create", "Cron trigger requires a valid 5-field cron expression.", "INVALID_CRON");
+    }
+    const dedupeKey = dedupeHash(`${triggerType}|${instructions.toLowerCase()}|${intervalMs}|${scheduledAtIso ?? ""}|${cronExpression ?? ""}`);
+    const existingTasks = await runtime.getTasks({
+        tags: [...TRIGGER_TASK_TAGS],
+        agentIds: [runtime.agentId],
+    });
+    const ownedActive = existingTasks.filter((t) => {
+        const cfg = readTriggerConfig(t);
+        return cfg?.enabled && cfg.createdBy === creatorId;
+    });
+    if (ownedActive.length >= MAX_TRIGGERS_PER_CREATOR) {
+        return failed("create", `Trigger limit reached (${MAX_TRIGGERS_PER_CREATOR}).`, "LIMIT_REACHED");
+    }
+    const duplicate = existingTasks.find((t) => {
+        const cfg = readTriggerConfig(t);
+        if (!cfg?.enabled)
+            return false;
+        if (cfg.dedupeKey)
+            return cfg.dedupeKey === dedupeKey;
+        return (cfg.instructions.trim().toLowerCase() === instructions.toLowerCase() &&
+            cfg.triggerType === triggerType);
+    });
+    if (duplicate?.id) {
+        return ok("create", "An equivalent trigger already exists.", {
+            duplicateTaskId: duplicate.id,
+            dedupeKey,
+        });
+    }
+    // Phase 2E: every trigger persisted to disk is `kind: "workflow"`.
+    // Materialize a single-node `respondToEvent` workflow that wraps the
+    // user's instructions, then bind the trigger to it.
+    const deployedWorkflow = await deployTextTriggerWorkflow(runtime, { displayName, instructions, wakeMode }, creatorId);
+    if (!deployedWorkflow) {
+        return failed("create", "Workflow plugin is not loaded; cannot create text triggers.", "WORKFLOW_SERVICE_UNAVAILABLE");
+    }
+    const triggerId = stringToUuid(crypto.randomUUID());
+    const triggerConfig = {
+        version: TRIGGER_SCHEMA_VERSION,
+        triggerId,
+        displayName,
+        instructions,
+        triggerType,
+        enabled: true,
+        wakeMode,
+        createdBy: creatorId,
+        runCount: 0,
+        intervalMs: triggerType === "interval" ? intervalMs : undefined,
+        scheduledAtIso: triggerType === "once" ? scheduledAtIso : undefined,
+        cronExpression: triggerType === "cron" ? cronExpression : undefined,
+        maxRuns,
+        dedupeKey,
+        kind: "workflow",
+        workflowId: deployedWorkflow.id,
+        workflowName: deployedWorkflow.name,
+    };
+    const metadata = buildTriggerMetadata({
+        trigger: triggerConfig,
+        nowMs: Date.now(),
+    });
+    if (!metadata) {
+        return failed("create", "Failed to compute trigger schedule.", "SCHEDULE_COMPUTE_FAILED");
+    }
+    const service = runtime.getService("AUTONOMY");
+    const autonomyService = isAutonomyRoomService(service) ? service : null;
+    const roomId = autonomyService?.getAutonomousRoomId?.() ?? message.roomId;
+    const taskId = await runtime.createTask({
+        name: TRIGGER_TASK_NAME,
+        description: displayName,
+        roomId,
+        tags: [...TRIGGER_TASK_TAGS],
+        metadata,
+    });
+    return ok("create", `Created trigger "${displayName}" (${describeSchedule(triggerConfig)}).`, {
+        triggerId,
+        taskId,
+        triggerType,
+        wakeMode,
+        dedupeKey,
+        kind: "workflow",
+        workflowId: deployedWorkflow.id,
+        workflowName: deployedWorkflow.name,
+    }, { triggerId, taskId, workflowId: deployedWorkflow.id });
+}
+async function opUpdate(runtime, params) {
+    const taskId = readUuid(params.taskId);
+    if (!taskId)
+        return failed("update", "taskId is required.", "MISSING_TASK_ID");
+    const loaded = await loadTriggerTask(runtime, taskId);
+    if (!loaded)
+        return failed("update", `Trigger task not found: ${taskId}`, "TRIGGER_NOT_FOUND");
+    const { task, trigger } = loaded;
+    if (!task.id)
+        return failed("update", "Task missing id.", "TASK_NOT_FOUND");
+    const next = { ...trigger };
+    const displayName = readString(params.displayName);
+    const instructions = readString(params.instructions);
+    const intervalMs = parsePositiveInt(params.intervalMs);
+    const scheduledAtIso = readString(params.scheduledAtIso);
+    const cronExpression = readString(params.cronExpression);
+    const maxRuns = parsePositiveInt(params.maxRuns);
+    const wakeModeRaw = params.wakeMode?.trim().toLowerCase();
+    if (displayName)
+        next.displayName = displayName;
+    if (instructions)
+        next.instructions = instructions;
+    if (intervalMs !== undefined && next.triggerType === "interval") {
+        next.intervalMs = normalizeTriggerIntervalMs(intervalMs);
+    }
+    if (scheduledAtIso !== undefined && next.triggerType === "once") {
+        if (parseScheduledAtIso(scheduledAtIso) === null) {
+            return failed("update", "Invalid scheduledAtIso.", "INVALID_SCHEDULE");
+        }
+        next.scheduledAtIso = scheduledAtIso;
+    }
+    if (cronExpression !== undefined && next.triggerType === "cron") {
+        if (!parseCronExpression(cronExpression)) {
+            return failed("update", "Invalid cron expression.", "INVALID_CRON");
+        }
+        next.cronExpression = cronExpression;
+    }
+    if (maxRuns !== undefined)
+        next.maxRuns = maxRuns;
+    if (wakeModeRaw === "inject_now" || wakeModeRaw === "next_autonomy_cycle") {
+        next.wakeMode = wakeModeRaw;
+    }
+    const metadata = buildTriggerMetadata({
+        trigger: next,
+        nowMs: Date.now(),
+        existingMetadata: task.metadata,
+    });
+    if (!metadata) {
+        return failed("update", "Failed to recompute trigger schedule.", "SCHEDULE_COMPUTE_FAILED");
+    }
+    await runtime.updateTask(task.id, {
+        description: next.displayName,
+        metadata,
+    });
+    return ok("update", `Updated trigger "${next.displayName}".`, {
+        taskId: String(task.id),
+        triggerId: next.triggerId,
+    });
+}
+async function opDelete(runtime, params) {
+    const taskId = readUuid(params.taskId);
+    if (!taskId)
+        return failed("delete", "taskId is required.", "MISSING_TASK_ID");
+    const loaded = await loadTriggerTask(runtime, taskId);
+    if (!loaded)
+        return failed("delete", `Trigger task not found: ${taskId}`, "TRIGGER_NOT_FOUND");
+    if (!loaded.task.id)
+        return failed("delete", "Task missing id.", "TASK_NOT_FOUND");
+    await runtime.deleteTask(loaded.task.id);
+    return ok("delete", `Deleted trigger "${loaded.trigger.displayName}".`, {
+        taskId: String(loaded.task.id),
+    });
+}
+async function opRun(runtime, params) {
+    const taskId = readUuid(params.taskId);
+    if (!taskId)
+        return failed("run", "taskId is required.", "MISSING_TASK_ID");
+    const loaded = await loadTriggerTask(runtime, taskId);
+    if (!loaded)
+        return failed("run", `Trigger task not found: ${taskId}`, "TRIGGER_NOT_FOUND");
+    const result = await executeTriggerTask(runtime, loaded.task, {
+        source: "manual",
+        force: true,
+    });
+    if (result.status === "error") {
+        return failed("run", `Trigger run failed: ${result.error ?? "unknown error"}`, "RUN_FAILED", { triggerId: loaded.trigger.triggerId });
+    }
+    return ok("run", `Ran trigger "${loaded.trigger.displayName}".`, {
+        taskId: String(loaded.task.id),
+        triggerId: loaded.trigger.triggerId,
+        status: result.status,
+        taskDeleted: result.taskDeleted,
+    });
+}
+async function opToggle(runtime, params) {
+    const taskId = readUuid(params.taskId);
+    if (!taskId)
+        return failed("toggle", "taskId is required.", "MISSING_TASK_ID");
+    const loaded = await loadTriggerTask(runtime, taskId);
+    if (!loaded)
+        return failed("toggle", `Trigger task not found: ${taskId}`, "TRIGGER_NOT_FOUND");
+    const { task, trigger } = loaded;
+    if (!task.id)
+        return failed("toggle", "Task missing id.", "TASK_NOT_FOUND");
+    const enabled = params.enabled === undefined ? !trigger.enabled : readBool(params.enabled);
+    const next = { ...trigger, enabled };
+    const metadata = buildTriggerMetadata({
+        trigger: next,
+        nowMs: Date.now(),
+        existingMetadata: task.metadata,
+    });
+    if (!metadata) {
+        return failed("toggle", "Failed to recompute trigger schedule.", "SCHEDULE_COMPUTE_FAILED");
+    }
+    await runtime.updateTask(task.id, { metadata });
+    return ok("toggle", `${enabled ? "Enabled" : "Disabled"} trigger "${trigger.displayName}".`, { taskId: String(task.id), triggerId: trigger.triggerId, enabled });
+}
+export const triggerAction = {
+    name: TRIGGER_ACTION,
+    contexts: ["automation", "tasks", "agent_internal"],
+    roleGate: { minRole: "ADMIN" },
+    similes: [],
+    description: "Recurring/scheduled trigger lifecycle. Action-based dispatch (create / update / delete / run / toggle). Supports interval, once, and cron schedules with wakeMode control.",
+    descriptionCompressed: "trigger lifecycle: create update delete run toggle (interval|once|cron)",
+    suppressPostActionContinuation: true,
+    validate: async (_runtime, _message, _state, options) => {
+        const params = readParams(options);
+        const op = readString(params.action ?? params.subaction ?? params.op);
+        return op !== undefined && isTriggerOp(op);
+    },
+    handler: async (runtime, message, _state, options, callback) => {
+        const params = readParams(options);
+        const opRaw = readString(params.action ?? params.subaction ?? params.op)?.toLowerCase();
+        if (!opRaw || !isTriggerOp(opRaw)) {
+            const result = failed("invalid", `Invalid action. Expected one of: ${TRIGGER_OPS.join(", ")}.`, "TRIGGER_INVALID");
+            if (callback) {
+                await callback({ text: result.text ?? "", action: TRIGGER_ACTION });
+            }
+            return result;
+        }
+        const op = opRaw;
+        let result;
+        switch (op) {
+            case "create":
+                result = await opCreate(runtime, message, params);
+                break;
+            case "update":
+                result = await opUpdate(runtime, params);
+                break;
+            case "delete":
+                result = await opDelete(runtime, params);
+                break;
+            case "run":
+                result = await opRun(runtime, params);
+                break;
+            case "toggle":
+                result = await opToggle(runtime, params);
+                break;
+        }
+        if (callback) {
+            await callback({
+                text: result.text ?? "",
+                action: TRIGGER_ACTION,
+                metadata: { op, ...(result.values ?? {}) },
+            });
+        }
+        return result;
+    },
+    parameters: [
+        {
+            name: "action",
+            description: `Action: ${TRIGGER_OPS.join(", ")}.`,
+            required: true,
+            schema: { type: "string", enum: [...TRIGGER_OPS] },
+        },
+        {
+            name: "taskId",
+            description: "Trigger task UUID. Required for update / delete / run / toggle.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "triggerType",
+            description: "Trigger schedule type for create.",
+            required: false,
+            schema: {
+                type: "string",
+                enum: ["interval", "once", "cron"],
+            },
+        },
+        {
+            name: "displayName",
+            description: "Trigger display name (create / update).",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "instructions",
+            description: "Trigger instructions (create / update).",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "wakeMode",
+            description: "How the trigger wakes the agent.",
+            required: false,
+            schema: {
+                type: "string",
+                enum: ["inject_now", "next_autonomy_cycle"],
+            },
+        },
+        {
+            name: "intervalMs",
+            description: "Interval frequency in ms.",
+            required: false,
+            schema: { type: "number", minimum: 1 },
+        },
+        {
+            name: "scheduledAtIso",
+            description: "ISO timestamp for once-triggers.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "cronExpression",
+            description: "Five-field cron expression.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "maxRuns",
+            description: "Optional max runs for a trigger.",
+            required: false,
+            schema: { type: "number", minimum: 1 },
+        },
+        {
+            name: "enabled",
+            description: "Enable or disable a trigger (toggle).",
+            required: false,
+            schema: { type: "boolean" },
+        },
+    ],
+    examples: [
+        [
+            {
+                name: "{{user}}",
+                content: {
+                    text: "Create a trigger every 12 hours to review open PRs.",
+                },
+            },
+            {
+                name: "{{agent}}",
+                content: {
+                    text: 'Created trigger "Trigger: review open PRs" (every 43200000ms).',
+                    action: TRIGGER_ACTION,
+                },
+            },
+        ],
+        [
+            {
+                name: "{{user}}",
+                content: { text: "Disable that PR review trigger for now." },
+            },
+            {
+                name: "{{agent}}",
+                content: {
+                    text: 'Disabled trigger "Trigger: review open PRs".',
+                    action: TRIGGER_ACTION,
+                },
+            },
+        ],
+    ],
+};
+export { TRIGGER_OPS };

package/dist/packages/agent/src/api/accounts-routes.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Multi-account credentials CRUD + OAuth-from-UI routes.
+ *
+ * The HTTP surface this exposes (under `/api/accounts/...`) is the
+ * source of truth for the React settings page. It joins three sources:
+ *
+ *   - on-disk credential records under `~/.eliza/auth/...`
+ *     (`account-storage.ts`),
+ *   - rich `LinkedAccountConfig` records (label / enabled / priority /
+ *     health / usage) owned by `AccountPool` in `@elizaos/app-core`,
+ *   - the in-flight OAuth flow registry (`auth/oauth-flow.ts`) used by
+ *     the `oauth/start` + SSE `oauth/status` + `oauth/cancel` trio.
+ *
+ * The pool is the SINGLE source of truth for `LinkedAccountConfig`. We
+ * never touch `config.linkedAccounts` from these routes — that field
+ * still holds the legacy `LinkedAccountFlagsConfig` (elizacloud
+ * is-linked flags) shape for unrelated consumers.
+ *
+ * Provider-level account selection strategy lives in a dedicated
+ * top-level config key, `accountStrategies` (see `applyStrategyPatch`
+ * below). It's a separate slot from the per-capability
+ * `serviceRouting[capability].strategy` so the UI can express
+ * "always prefer my Pro Anthropic account before falling back to my
+ * Max one" without having to know which capability each provider
+ * powers.
+ */
+import type { RouteRequestContext } from "@elizaos/shared";
+import type { ElizaConfig } from "../config/types.eliza.ts";
+/** Test-only: drop the cached pool reference between tests. */
+export declare function _resetAccountsRoutesPoolCache(): void;
+export interface AccountsRouteContext extends RouteRequestContext {
+    state: {
+        config: ElizaConfig;
+    };
+    saveConfig: (config: ElizaConfig) => void;
+}
+export declare function handleAccountsRoutes(ctx: AccountsRouteContext): Promise<boolean>;
+//# sourceMappingURL=accounts-routes.d.ts.map

package/dist/packages/agent/src/api/accounts-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accounts-routes.d.ts","sourceRoot":"","sources":["../../../../../src/api/accounts-routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAoC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAsC5D,+DAA+D;AAC/D,wBAAgB,6BAA6B,IAAI,IAAI,CAEpD;AAibD,MAAM,WAAW,oBAAqB,SAAQ,mBAAmB;IAC/D,KAAK,EAAE;QAAE,MAAM,EAAE,WAAW,CAAA;KAAE,CAAC;IAC/B,UAAU,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAC;CAC3C;AAKD,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,oBAAoB,GACxB,OAAO,CAAC,OAAO,CAAC,CAoFlB"}