@elizaos/agent 2.0.0-beta.1 → 2.0.11-beta.5

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

@@ -1,514 +0,0 @@
-/**
- * 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

@@ -1,38 +0,0 @@
-/**
- * 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

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