@elizaos/plugin-workflow 2.0.0-beta.1 → 2.0.3-beta.6

package/dist/services/embedded-workflow-service.js

@@ -1,22 +1,31 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { logger, Service } from '@elizaos/core';
+import { logger, Service, stringToUuid, TRIGGER_SCHEMA_VERSION, } from '@elizaos/core';
 import { and, desc, eq, sql } from 'drizzle-orm';
-import { embeddedCredentials, embeddedExecutions, embeddedTags, embeddedWorkflows, } from '../db/schema';
+import { embeddedCredentials, embeddedExecutions, embeddedTags, embeddedWorkflows, workflowRevisions, } from '../db/schema';
 import { WorkflowApiError } from '../types/index';
 import { detectHostCapabilities } from '../utils/host-capabilities';
+import { runWorkflowWithSmithers } from './smithers-runtime';
 export const EMBEDDED_WORKFLOW_SERVICE_TYPE = 'embedded_workflow_service';
-/** TaskWorker name for scheduled workflow runs. Tasks created with this name
- *  carry metadata.workflowId + metadata.kind = 'workflow' and get fired by
- *  the core TaskService on the configured updateInterval. */
-export const WORKFLOW_RUN_TASK_WORKER_NAME = 'workflow.run';
-/** TaskWorker name for one-shot webhook-triggered workflow runs. A future
- *  webhook trigger provider creates a one-shot Task pointing at this worker;
- *  payload travels in metadata.payload. */
-export const WORKFLOW_WEBHOOK_TASK_WORKER_NAME = 'workflow.webhook';
+/**
+ * Task name + tag contract for scheduled workflow runs. Mirrored from
+ * `packages/agent/src/triggers/runtime.ts` because plugin-workflow can't
+ * import @elizaos/agent (would create a dep cycle). The agent's
+ * `registerTriggerTaskWorker` consumes tasks with this name.
+ */
+export const TRIGGER_TASK_NAME = 'TRIGGER_DISPATCH';
+export const TRIGGER_TASK_TAGS = ['queue', 'repeat', 'trigger'];
 /** Discriminator on TaskMetadata so the UI can route workflow tasks. */
 export const WORKFLOW_TASK_KIND = 'workflow';
 /** Stable tag used on every workflow-backed Task so we can list+delete them. */
 const WORKFLOW_TASK_TAG = 'workflow';
+/**
+ * Legacy task names retained only for rehydration cleanup. `workflow.run`
+ * was the prior scheduled-dispatch path; it bypassed `executeTriggerTask`
+ * and accumulated no run history. `workflow.webhook` had no producer and
+ * was dead from the start. Both are migrated/removed on service start.
+ */
+const LEGACY_WORKFLOW_RUN_TASK_NAME = 'workflow.run';
+const LEGACY_WORKFLOW_WEBHOOK_TASK_NAME = 'workflow.webhook';
 const EMBEDDED_HOST = 'embedded://local';
 const DEFAULT_SCHEDULE_INTERVAL_MS = 60_000;
 let loadedQuickJs = null;
@@ -53,12 +62,36 @@ function responseFromWorkflow(workflow, createdAt, updatedAt, versionId) {
         versionId,
     };
 }
+function revisionFromRow(row) {
+    return {
+        id: row.id,
+        workflowId: row.workflowId,
+        versionId: row.versionId,
+        name: row.workflow.name,
+        active: row.workflow.active === true,
+        workflow: cloneJson(row.workflow),
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+        capturedAt: row.capturedAt,
+        operation: row.operation,
+    };
+}
 function readString(value, fallback) {
     return typeof value === 'string' && value.length > 0 ? value : fallback;
 }
 function readNumber(value, fallback) {
     return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
 }
+/**
+ * Build the per-dispatch idempotency key used to dedup back-to-back
+ * scheduled fires for the same workflow within the same minute. Shared
+ * by `armSchedules` (which writes it into the task metadata) and
+ * `WorkflowDispatchService.execute` (which looks it up before running).
+ */
+export function buildScheduleIdempotencyKey(workflowId, nextRunAtMs) {
+    const minuteBucket = Math.floor(nextRunAtMs / 60_000);
+    return `${workflowId}:${minuteBucket}`;
+}
 function resolveScheduleIntervalMs(parameters) {
     const explicitMs = readNumber(parameters.intervalMs, NaN);
     if (Number.isFinite(explicitMs) && explicitMs > 0)
@@ -726,8 +759,8 @@ function createMergeNode() {
             ],
         },
         async execute() {
-            const first = this.getInputData(0) ?? [];
-            const second = this.getInputData(1) ?? [];
+            const first = this.getInputData(0);
+            const second = this.getInputData(1);
             return [[...first, ...second]];
         },
     };
@@ -807,7 +840,7 @@ function createDateTimeNode() {
             const now = new Date().toISOString();
             return [
                 inputItems.map((item, index) => ({
-                    json: { ...(item.json ?? {}), [fieldName]: now },
+                    json: { ...item.json, [fieldName]: now },
                     pairedItem: item.pairedItem ?? { item: index },
                 })),
             ];
@@ -841,7 +874,7 @@ function createCryptoNode() {
                     const source = raw === '' || typeof raw === 'undefined' ? JSON.stringify(item.json) : String(raw);
                     return {
                         json: {
-                            ...(item.json ?? {}),
+                            ...item.json,
                             [fieldName]: createHash(algorithm).update(source).digest('hex'),
                         },
                         pairedItem: item.pairedItem ?? { item: index },
@@ -902,6 +935,17 @@ async function runQuickJsCode(jsCode, inputItems) {
         memoryLimitBytes: 32 * 1024 * 1024,
     });
 }
+/**
+ * Evaluate a snippet of JavaScript in the same isolated QuickJS sandbox the
+ * Code node uses (5s deadline, 32 MiB cap, no host/network/fs access). Optional
+ * `inputJson` is exposed to the snippet as `$json` / `item.json` / `$input[0]`.
+ * The snippet body runs inside an IIFE, so `return <value>` yields the result.
+ * Public entry point for the EVAL_CODE action (#8914).
+ */
+export async function evalQuickJsCode(jsCode, inputJson) {
+    const items = inputJson === undefined ? [] : [{ json: (inputJson ?? {}) }];
+    return runQuickJsCode(jsCode, items);
+}
 function resolveAutonomyService(runtime) {
     const svc = runtime.getService('AUTONOMY') ??
         runtime.getService('autonomy');
@@ -969,12 +1013,12 @@ function createRespondToEventNode() {
             }
             const autonomyService = resolveAutonomyService(runtime);
             if (!autonomyService) {
-                runtime.logger?.warn?.({ src: 'plugin:workflow:respondToEvent', nodeName: node.name, executionId }, '[respondToEvent] Autonomy service not registered — skipping injection');
+                runtime.logger.warn({ src: 'plugin:workflow:respondToEvent', nodeName: node.name, executionId }, '[respondToEvent] Autonomy service not registered — skipping injection');
                 return failure('autonomy_service_unavailable');
             }
             const roomId = resolveAutonomyRoomId(autonomyService);
             if (!roomId) {
-                runtime.logger?.warn?.({ src: 'plugin:workflow:respondToEvent', nodeName: node.name, executionId }, '[respondToEvent] No autonomy room resolvable — skipping injection');
+                runtime.logger.warn({ src: 'plugin:workflow:respondToEvent', nodeName: node.name, executionId }, '[respondToEvent] No autonomy room resolvable — skipping injection');
                 return failure('no_autonomy_room');
             }
             const event = extractEventFromInputItems(inputItems);
@@ -1118,7 +1162,6 @@ export class EmbeddedWorkflowService extends Service {
     static async start(runtime) {
         const service = new EmbeddedWorkflowService(runtime);
         logger.info({ src: 'plugin:workflow:embedded' }, 'Embedded workflow service registered (lazy runtime load)');
-        service.registerTaskWorkers();
         if (runtime.db) {
             await service.ensureSchema();
             await service.rehydrateSchedules();
@@ -1129,41 +1172,6 @@ export class EmbeddedWorkflowService extends Service {
         // Scheduling lives in core's TaskService. Tasks persist across restart;
         // there is nothing in-process to tear down here.
     }
-    /** Register the workflow.run + workflow.webhook task workers with the
-     *  runtime's TaskService. Idempotent — safe to call once per service start. */
-    registerTaskWorkers() {
-        if (typeof this.runtime.registerTaskWorker !== 'function')
-            return;
-        if (!this.runtime.getTaskWorker?.(WORKFLOW_RUN_TASK_WORKER_NAME)) {
-            this.runtime.registerTaskWorker({
-                name: WORKFLOW_RUN_TASK_WORKER_NAME,
-                execute: async (_rt, _opts, task) => {
-                    const workflowId = typeof task.metadata?.workflowId === 'string' ? task.metadata.workflowId : null;
-                    if (!workflowId) {
-                        throw new Error(`${WORKFLOW_RUN_TASK_WORKER_NAME} task ${task.id ?? '?'} missing metadata.workflowId`);
-                    }
-                    await this.executeWorkflow(workflowId, { mode: 'trigger' });
-                    return undefined;
-                },
-            });
-        }
-        if (!this.runtime.getTaskWorker?.(WORKFLOW_WEBHOOK_TASK_WORKER_NAME)) {
-            this.runtime.registerTaskWorker({
-                name: WORKFLOW_WEBHOOK_TASK_WORKER_NAME,
-                execute: async (_rt, _opts, task) => {
-                    const meta = task.metadata;
-                    const path = typeof meta?.path === 'string' ? meta.path : null;
-                    const method = typeof meta?.method === 'string' ? meta.method : 'POST';
-                    const payload = isRecord(meta?.payload) ? meta.payload : {};
-                    if (!path) {
-                        throw new Error(`${WORKFLOW_WEBHOOK_TASK_WORKER_NAME} task ${task.id ?? '?'} missing metadata.path`);
-                    }
-                    await this.executeWebhook(path, payload, method);
-                    return undefined;
-                },
-            });
-        }
-    }
     get host() {
         return EMBEDDED_HOST;
     }
@@ -1223,6 +1231,32 @@ export class EmbeddedWorkflowService extends Service {
                 await db.execute(sql `
           CREATE INDEX IF NOT EXISTS "idx_embedded_workflows_updated_at"
           ON "workflow"."embedded_workflows" ("updated_at")
+        `);
+                await db.execute(sql `
+          CREATE TABLE IF NOT EXISTS "workflow"."workflow_revisions" (
+            "id" text PRIMARY KEY,
+            "workflow_id" text NOT NULL,
+            "version_id" text NOT NULL,
+            "name" text NOT NULL,
+            "active" boolean DEFAULT false NOT NULL,
+            "workflow" jsonb NOT NULL,
+            "created_at" text NOT NULL,
+            "updated_at" text NOT NULL,
+            "captured_at" text NOT NULL,
+            "operation" text NOT NULL
+          )
+        `);
+                await db.execute(sql `
+          CREATE INDEX IF NOT EXISTS "idx_workflow_revisions_workflow_id"
+          ON "workflow"."workflow_revisions" ("workflow_id")
+        `);
+                await db.execute(sql `
+          CREATE UNIQUE INDEX IF NOT EXISTS "idx_workflow_revisions_workflow_version"
+          ON "workflow"."workflow_revisions" ("workflow_id", "version_id")
+        `);
+                await db.execute(sql `
+          CREATE INDEX IF NOT EXISTS "idx_workflow_revisions_captured_at"
+          ON "workflow"."workflow_revisions" ("captured_at")
         `);
                 await db.execute(sql `
           CREATE TABLE IF NOT EXISTS "workflow"."embedded_executions" (
@@ -1233,8 +1267,14 @@ export class EmbeddedWorkflowService extends Service {
             "finished" boolean DEFAULT false NOT NULL,
             "started_at" text NOT NULL,
             "stopped_at" text,
-            "execution" jsonb NOT NULL
+            "execution" jsonb NOT NULL,
+            "idempotency_key" text
           )
+        `);
+                // Online migration: add idempotency_key to pre-existing tables.
+                await db.execute(sql `
+          ALTER TABLE "workflow"."embedded_executions"
+          ADD COLUMN IF NOT EXISTS "idempotency_key" text
         `);
                 await db.execute(sql `
           CREATE INDEX IF NOT EXISTS "idx_embedded_executions_workflow_id"
@@ -1247,6 +1287,10 @@ export class EmbeddedWorkflowService extends Service {
                 await db.execute(sql `
           CREATE INDEX IF NOT EXISTS "idx_embedded_executions_started_at"
           ON "workflow"."embedded_executions" ("started_at")
+        `);
+                await db.execute(sql `
+          CREATE INDEX IF NOT EXISTS "idx_embedded_executions_idempotency_key"
+          ON "workflow"."embedded_executions" ("idempotency_key")
         `);
                 await db.execute(sql `
           CREATE TABLE IF NOT EXISTS "workflow"."embedded_credentials" (
@@ -1303,6 +1347,7 @@ export class EmbeddedWorkflowService extends Service {
         this.assertRegisteredNodes(workflow);
         const existing = await this.getStoredWorkflow(id);
         const db = this.getDb();
+        await this.captureWorkflowRevision(id, existing, 'update');
         const updatedAt = nowIso();
         const versionId = randomUUID();
         const stored = normalizeWorkflowPayload(workflow, id, existing.workflow.active ?? false);
@@ -1353,6 +1398,7 @@ export class EmbeddedWorkflowService extends Service {
         this.clearSchedules(id);
         const existing = await this.getStoredWorkflow(id);
         const db = this.getDb();
+        await this.captureWorkflowRevision(id, existing, 'delete');
         await db.delete(embeddedWorkflows).where(eq(embeddedWorkflows.id, id));
         if (!existing) {
             throw new WorkflowApiError(`Workflow not found: ${id}`, 404);
@@ -1362,6 +1408,7 @@ export class EmbeddedWorkflowService extends Service {
         const entry = await this.getStoredWorkflow(id);
         this.assertHostSupports(entry.workflow);
         const db = this.getDb();
+        await this.captureWorkflowRevision(id, entry, 'activate');
         entry.workflow.active = true;
         entry.updatedAt = nowIso();
         entry.versionId = randomUUID();
@@ -1380,6 +1427,7 @@ export class EmbeddedWorkflowService extends Service {
     async deactivateWorkflow(id) {
         const entry = await this.getStoredWorkflow(id);
         const db = this.getDb();
+        await this.captureWorkflowRevision(id, entry, 'deactivate');
         entry.workflow.active = false;
         entry.updatedAt = nowIso();
         entry.versionId = randomUUID();
@@ -1406,6 +1454,7 @@ export class EmbeddedWorkflowService extends Service {
                 throw new WorkflowApiError(`Tag not found: ${tagId}`, 404);
             tags.push({ id: tag.id, name: tag.name, createdAt: tag.createdAt, updatedAt: tag.updatedAt });
         }
+        await this.captureWorkflowRevision(id, entry, 'tags');
         entry.workflow.tags = cloneJson(tags);
         entry.updatedAt = nowIso();
         entry.versionId = randomUUID();
@@ -1419,6 +1468,65 @@ export class EmbeddedWorkflowService extends Service {
             .where(eq(embeddedWorkflows.id, id));
         return cloneJson(tags);
     }
+    async listWorkflowRevisions(workflowId, limit = 20) {
+        await this.ensureSchema();
+        const db = this.getDb();
+        const rows = await db
+            .select()
+            .from(workflowRevisions)
+            .where(eq(workflowRevisions.workflowId, workflowId))
+            .orderBy(desc(workflowRevisions.capturedAt))
+            .limit(Math.min(Math.max(1, limit), 50));
+        return {
+            data: rows.map((row) => revisionFromRow({
+                id: row.id,
+                workflowId: row.workflowId,
+                workflow: row.workflow,
+                createdAt: row.createdAt,
+                updatedAt: row.updatedAt,
+                versionId: row.versionId,
+                capturedAt: row.capturedAt,
+                operation: row.operation,
+            })),
+        };
+    }
+    async restoreWorkflowRevision(workflowId, versionId) {
+        await this.ensureSchema();
+        const db = this.getDb();
+        const revisionRows = await db
+            .select()
+            .from(workflowRevisions)
+            .where(and(eq(workflowRevisions.workflowId, workflowId), eq(workflowRevisions.versionId, versionId)))
+            .limit(1);
+        const revision = revisionRows[0];
+        if (!revision) {
+            throw new WorkflowApiError(`Workflow revision not found: ${workflowId}/${versionId}`, 404);
+        }
+        const current = await this.getStoredWorkflow(workflowId);
+        const restored = normalizeWorkflowPayload(revision.workflow, workflowId, revision.active);
+        this.assertRegisteredNodes(restored);
+        this.assertHostSupports(restored);
+        await this.captureWorkflowRevision(workflowId, current, 'restore');
+        const updatedAt = nowIso();
+        const nextVersionId = randomUUID();
+        await db
+            .update(embeddedWorkflows)
+            .set({
+            name: restored.name,
+            active: restored.active ?? false,
+            workflow: restored,
+            updatedAt,
+            versionId: nextVersionId,
+        })
+            .where(eq(embeddedWorkflows.id, workflowId));
+        if (restored.active) {
+            await this.armSchedules(workflowId);
+        }
+        else {
+            await this.clearSchedules(workflowId);
+        }
+        return responseFromWorkflow(restored, current.createdAt, updatedAt, nextVersionId);
+    }
     async createCredential(credential) {
         await this.ensureSchema();
         const db = this.getDb();
@@ -1510,7 +1618,24 @@ export class EmbeddedWorkflowService extends Service {
     }
     async executeWorkflow(id, options = {}) {
         const entry = await this.getStoredWorkflow(id);
-        return this.runWorkflow(entry.workflow, options.mode ?? 'manual');
+        return this.runWorkflow(entry.workflow, options.mode ?? 'manual', options.triggerData, options.idempotencyKey, options.throwOnError ?? true);
+    }
+    /**
+     * Look up the most recent execution row tagged with this idempotency
+     * key for the given workflow. Returns null when none exists. The
+     * dispatch layer uses this to dedup back-to-back schedule fires that
+     * share a minute bucket — see WorkflowDispatchService.execute.
+     */
+    async findExecutionByIdempotencyKey(workflowId, idempotencyKey) {
+        await this.ensureSchema();
+        const rows = await this.getDb()
+            .select()
+            .from(embeddedExecutions)
+            .where(and(eq(embeddedExecutions.workflowId, workflowId), eq(embeddedExecutions.idempotencyKey, idempotencyKey)))
+            .orderBy(desc(embeddedExecutions.startedAt))
+            .limit(1);
+        const row = rows[0];
+        return row ? cloneJson(row.execution) : null;
     }
     async executeWebhook(path, payload, method = 'POST') {
         await this.ensureSchema();
@@ -1567,6 +1692,24 @@ export class EmbeddedWorkflowService extends Service {
         }
         return executions;
     }
+    async captureWorkflowRevision(workflowId, entry, operation) {
+        await this.ensureSchema();
+        await this.getDb()
+            .insert(workflowRevisions)
+            .values({
+            id: randomUUID(),
+            workflowId,
+            versionId: entry.versionId,
+            name: entry.workflow.name,
+            active: entry.workflow.active === true,
+            workflow: cloneJson(entry.workflow),
+            createdAt: entry.createdAt,
+            updatedAt: entry.updatedAt,
+            capturedAt: nowIso(),
+            operation,
+        })
+            .onConflictDoNothing();
+    }
     async getStoredWorkflow(id) {
         await this.ensureSchema();
         const rows = await this.getDb()
@@ -1632,9 +1775,14 @@ export class EmbeddedWorkflowService extends Service {
     /** Re-create core Tasks for every active workflow on service start.
      *  Tasks themselves persist across restart; this is a reconcile step that
      *  ensures workflows whose schedule changed (or whose tasks were never
-     *  created in the first place) end up correctly scheduled. */
+     *  created in the first place) end up correctly scheduled.
+     *
+     *  Also performs a one-shot migration: any pre-existing legacy
+     *  `workflow.run` / `workflow.webhook` task rows are deleted so the new
+     *  `TRIGGER_DISPATCH` path is the single source of scheduled runs. */
     async rehydrateSchedules() {
         await this.ensureSchema();
+        await this.deleteLegacyScheduleTasks();
         const rows = await this.getDb()
             .select()
             .from(embeddedWorkflows)
@@ -1643,9 +1791,62 @@ export class EmbeddedWorkflowService extends Service {
             await this.armSchedules(row.id);
         }
     }
-    /** Create one recurring core Task per scheduleTrigger node on the workflow.
-     *  Idempotent: existing tasks for this workflow are removed first so the
-     *  task set always reflects the current workflow definition. */
+    /** Remove legacy `workflow.run` / `workflow.webhook` Tasks left behind
+     *  by earlier service versions. Returns the count so callers (and the
+     *  migration log) can verify the cleanup. */
+    async deleteLegacyScheduleTasks() {
+        if (typeof this.runtime.getTasks !== 'function' ||
+            typeof this.runtime.deleteTask !== 'function') {
+            return 0;
+        }
+        const tasks = await this.runtime.getTasks({
+            tags: [WORKFLOW_TASK_TAG],
+            agentIds: [this.runtime.agentId],
+        });
+        if (!tasks.length)
+            return 0;
+        let removed = 0;
+        for (const task of tasks) {
+            if (!task.id)
+                continue;
+            if (task.name === LEGACY_WORKFLOW_RUN_TASK_NAME ||
+                task.name === LEGACY_WORKFLOW_WEBHOOK_TASK_NAME) {
+                await this.runtime.deleteTask(task.id);
+                removed += 1;
+            }
+        }
+        if (removed > 0) {
+            logger.info({ src: 'plugin:workflow:embedded', removed }, `Removed ${removed} legacy workflow task row(s); schedules will re-arm via TRIGGER_DISPATCH`);
+        }
+        return removed;
+    }
+    /** Build a `TriggerConfig` for a workflow schedule node. The resulting
+     *  config is what the agent's `executeTriggerTask` reads off the task
+     *  metadata when the scheduler fires. */
+    buildScheduleTrigger(workflowId, workflowName, intervalMs) {
+        const triggerId = stringToUuid(`${workflowId}:schedule:${randomUUID()}`);
+        return {
+            version: TRIGGER_SCHEMA_VERSION,
+            triggerId,
+            displayName: `Scheduled workflow run: ${workflowName}`,
+            instructions: `Run workflow ${workflowName}`,
+            triggerType: 'interval',
+            enabled: true,
+            wakeMode: 'inject_now',
+            createdBy: 'workflow.schedule',
+            intervalMs,
+            runCount: 0,
+            kind: 'workflow',
+            workflowId,
+            workflowName,
+        };
+    }
+    /** Create one recurring `TRIGGER_DISPATCH` Task per scheduleTrigger
+     *  node on the workflow. Idempotent: existing tasks for this workflow
+     *  are removed first so the task set always reflects the current
+     *  workflow definition. Each task carries an idempotency key derived
+     *  from `(workflowId, nextRunAt-minute-bucket)` so that simultaneous
+     *  fires within the same minute deduplicate at dispatch. */
     async armSchedules(workflowId) {
         await this.clearSchedules(workflowId);
         if (typeof this.runtime.createTask !== 'function')
@@ -1654,19 +1855,30 @@ export class EmbeddedWorkflowService extends Service {
         const scheduleNodes = entry.workflow.nodes.filter((node) => !node.disabled && node.type === 'workflows-nodes-base.scheduleTrigger');
         if (scheduleNodes.length === 0)
             return;
+        const nowMs = Date.now();
         for (const node of scheduleNodes) {
             const intervalMs = resolveScheduleIntervalMs(node.parameters);
+            const trigger = this.buildScheduleTrigger(workflowId, entry.workflow.name, intervalMs);
+            const nextRunAtMs = nowMs + intervalMs;
+            const triggerWithSchedule = {
+                ...trigger,
+                nextRunAtMs,
+            };
+            const idempotencyKey = buildScheduleIdempotencyKey(workflowId, nextRunAtMs);
             await this.runtime.createTask({
-                name: WORKFLOW_RUN_TASK_WORKER_NAME,
-                description: `Scheduled workflow run: ${entry.workflow.name}`,
-                tags: ['queue', 'repeat', WORKFLOW_TASK_TAG],
+                name: TRIGGER_TASK_NAME,
+                description: trigger.displayName,
+                tags: [...TRIGGER_TASK_TAGS, WORKFLOW_TASK_TAG],
                 metadata: {
+                    blocking: true,
+                    updatedAt: nowMs,
+                    updateInterval: intervalMs,
+                    baseInterval: intervalMs,
                     kind: WORKFLOW_TASK_KIND,
                     workflowId,
                     scheduleNodeId: node.id,
-                    updateInterval: intervalMs,
-                    baseInterval: intervalMs,
-                    updatedAt: Date.now(),
+                    idempotencyKey,
+                    trigger: triggerWithSchedule,
                 },
             });
         }
@@ -1679,7 +1891,7 @@ export class EmbeddedWorkflowService extends Service {
             tags: [WORKFLOW_TASK_TAG],
             agentIds: [this.runtime.agentId],
         });
-        if (!tasks?.length)
+        if (!tasks.length)
             return;
         for (const task of tasks) {
             if (task.id &&
@@ -1688,8 +1900,9 @@ export class EmbeddedWorkflowService extends Service {
             }
         }
     }
-    async saveExecution(execution) {
+    async saveExecution(execution, idempotencyKey) {
         await this.ensureSchema();
+        const key = idempotencyKey ?? null;
         await this.getDb()
             .insert(embeddedExecutions)
             .values({
@@ -1701,6 +1914,7 @@ export class EmbeddedWorkflowService extends Service {
             startedAt: execution.startedAt,
             stoppedAt: execution.stoppedAt ?? null,
             execution: cloneJson(execution),
+            idempotencyKey: key,
         })
             .onConflictDoUpdate({
             target: embeddedExecutions.id,
@@ -1712,22 +1926,23 @@ export class EmbeddedWorkflowService extends Service {
                 startedAt: execution.startedAt,
                 stoppedAt: execution.stoppedAt ?? null,
                 execution: cloneJson(execution),
+                idempotencyKey: key,
             },
         });
     }
     buildIncomingConnections(workflowData) {
         const incoming = new Map();
-        for (const [source, outputsByType] of Object.entries(workflowData.connections ?? {})) {
-            const mainOutputs = outputsByType.main ?? [];
+        for (const [source, outputsByType] of Object.entries(workflowData.connections)) {
+            const mainOutputs = outputsByType.main;
             mainOutputs.forEach((connections, sourceOutputIndex) => {
-                for (const connection of connections ?? []) {
+                for (const connection of connections) {
                     if (connection.type !== 'main')
                         continue;
                     const destination = incoming.get(connection.node) ?? [];
                     destination.push({
                         source,
                         sourceOutputIndex,
-                        destinationInputIndex: connection.index ?? 0,
+                        destinationInputIndex: connection.index,
                     });
                     incoming.set(connection.node, destination);
                 }
@@ -1772,17 +1987,40 @@ export class EmbeddedWorkflowService extends Service {
         }
         return start;
     }
-    collectInputData(nodeName, incoming, nodeOutputs) {
-        const inputData = [];
-        for (const connection of incoming.get(nodeName) ?? []) {
-            const sourceOutputs = nodeOutputs.get(connection.source) ?? [];
-            const sourceItems = sourceOutputs[connection.sourceOutputIndex] ?? [];
-            inputData[connection.destinationInputIndex] = [
-                ...(inputData[connection.destinationInputIndex] ?? []),
-                ...sourceItems,
-            ];
+    resolveExecutionPlan(workflowData, mode) {
+        const enabledNodes = workflowData.nodes.filter((node) => !node.disabled);
+        const nodeByName = new Map(enabledNodes.map((node) => [node.name, node]));
+        const incoming = this.buildIncomingConnections(workflowData);
+        const startNodes = this.resolveStartNodes(workflowData, mode, incoming);
+        const orderedNodes = [];
+        const executed = new Set();
+        while (executed.size < enabledNodes.length) {
+            let progressed = false;
+            for (const node of enabledNodes) {
+                if (executed.has(node.name))
+                    continue;
+                const incomingConnections = incoming.get(node.name)?.filter((connection) => nodeByName.has(connection.source)) ?? [];
+                const isStartNode = startNodes.has(node.name);
+                const dependenciesComplete = incomingConnections.every((connection) => executed.has(connection.source));
+                if (!isStartNode && !dependenciesComplete)
+                    continue;
+                orderedNodes.push(node);
+                executed.add(node.name);
+                progressed = true;
+            }
+            if (!progressed) {
+                const unresolved = enabledNodes
+                    .filter((node) => !executed.has(node.name))
+                    .map((node) => node.name)
+                    .join(', ');
+                throw new Error(`Unable to resolve workflow execution order for node(s): ${unresolved}`);
+            }
         }
-        return inputData.length > 0 ? inputData : [[]];
+        return {
+            enabledNodes: orderedNodes,
+            startNodes: [...startNodes],
+            incoming: Object.fromEntries(incoming.entries()),
+        };
     }
     async executeNode(node, inputData, executionId) {
         const nodeType = this.nodeTypes.getByNameAndVersion(node.type);
@@ -1795,7 +2033,7 @@ export class EmbeddedWorkflowService extends Service {
         const output = await nodeType.execute.call(context);
         return output.length > 0 ? output : [[]];
     }
-    async runWorkflow(workflowData, mode) {
+    async runWorkflow(workflowData, mode, triggerData, idempotencyKey, throwOnError = true) {
         const executionId = randomUUID();
         const startedAt = new Date();
         const pending = {
@@ -1805,75 +2043,28 @@ export class EmbeddedWorkflowService extends Service {
             startedAt: startedAt.toISOString(),
             workflowId: workflowData.id ?? '',
             status: 'running',
+            ...(triggerData || idempotencyKey
+                ? {
+                    customData: {
+                        ...(triggerData ? { triggerData } : {}),
+                        ...(idempotencyKey ? { idempotencyKey } : {}),
+                    },
+                }
+                : {}),
         };
-        await this.saveExecution(pending);
+        await this.saveExecution(pending, idempotencyKey);
         try {
-            const enabledNodes = workflowData.nodes.filter((node) => !node.disabled);
-            const nodeByName = new Map(enabledNodes.map((node) => [node.name, node]));
-            const incoming = this.buildIncomingConnections(workflowData);
-            const startNodes = this.resolveStartNodes(workflowData, mode, incoming);
-            const nodeOutputs = new Map();
-            const executed = new Set();
-            const runData = {};
-            let lastNodeExecuted;
-            while (executed.size < enabledNodes.length) {
-                let progressed = false;
-                for (const node of enabledNodes) {
-                    if (executed.has(node.name))
-                        continue;
-                    const incomingConnections = incoming.get(node.name)?.filter((connection) => nodeByName.has(connection.source)) ??
-                        [];
-                    const isStartNode = startNodes.has(node.name);
-                    const dependenciesComplete = incomingConnections.every((connection) => executed.has(connection.source));
-                    if (!isStartNode && !dependenciesComplete)
-                        continue;
-                    const inputData = isStartNode && incomingConnections.length === 0
-                        ? [[]]
-                        : this.collectInputData(node.name, incoming, nodeOutputs);
-                    const hasInputItems = inputData.some((items) => items.length > 0);
-                    const started = Date.now();
-                    const outputData = !isStartNode && incomingConnections.length > 0 && !hasInputItems
-                        ? [[]]
-                        : await this.executeNode(node, inputData, executionId);
-                    nodeOutputs.set(node.name, outputData);
-                    runData[node.name] = [
-                        {
-                            startTime: started,
-                            executionTime: Date.now() - started,
-                            data: { main: cloneJson(outputData) },
-                            source: incomingConnections.map((connection) => ({
-                                previousNode: connection.source,
-                                previousNodeOutput: connection.sourceOutputIndex,
-                                previousNodeRun: 0,
-                            })),
-                        },
-                    ];
-                    executed.add(node.name);
-                    lastNodeExecuted = node.name;
-                    progressed = true;
-                }
-                if (!progressed) {
-                    const unresolved = enabledNodes
-                        .filter((node) => !executed.has(node.name))
-                        .map((node) => node.name)
-                        .join(', ');
-                    throw new Error(`Unable to resolve workflow execution order for node(s): ${unresolved}`);
-                }
-            }
-            const stoppedAt = new Date();
-            const execution = {
-                ...pending,
-                finished: true,
-                status: 'success',
-                stoppedAt: stoppedAt.toISOString(),
-                data: {
-                    resultData: {
-                        runData,
-                        lastNodeExecuted,
-                    },
-                },
-            };
-            await this.saveExecution(execution);
+            const plan = this.resolveExecutionPlan(workflowData, mode);
+            const execution = await runWorkflowWithSmithers({
+                workflow: workflowData,
+                executionId,
+                pending,
+                mode,
+                triggerData,
+                plan,
+                runNode: (node, inputData) => this.executeNode(node, inputData, executionId),
+            });
+            await this.saveExecution(execution, idempotencyKey);
             return cloneJson(execution);
         }
         catch (error) {
@@ -1892,7 +2083,10 @@ export class EmbeddedWorkflowService extends Service {
                     },
                 },
             };
-            await this.saveExecution(execution);
+            await this.saveExecution(execution, idempotencyKey);
+            if (!throwOnError) {
+                return cloneJson(execution);
+            }
             throw error;
         }
     }