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

package/src/services/embedded-workflow-service.ts

@@ -1,5 +1,13 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { type IAgentRuntime, logger, Service, type Task, type UUID } from '@elizaos/core';
+import {
+  type IAgentRuntime,
+  logger,
+  Service,
+  stringToUuid,
+  TRIGGER_SCHEMA_VERSION,
+  type TriggerConfig,
+  type UUID,
+} from '@elizaos/core';
 import { and, desc, eq, sql } from 'drizzle-orm';
 import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
 import {
@@ -7,6 +15,7 @@ import {
   embeddedExecutions,
   embeddedTags,
   embeddedWorkflows,
+  workflowRevisions,
 } from '../db/schema';
 import type {
   WorkflowCredential,
@@ -14,22 +23,24 @@ import type {
   WorkflowDefinitionResponse,
   WorkflowExecution,
   WorkflowNode,
+  WorkflowRevision,
+  WorkflowRevisionOperation,
   WorkflowTag,
 } from '../types/index';
 import { WorkflowApiError } from '../types/index';
 import { detectHostCapabilities } from '../utils/host-capabilities';
+import { runWorkflowWithSmithers, type SmithersExecutionPlan } 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: readonly string[] = ['queue', 'repeat', 'trigger'];
 
 /** Discriminator on TaskMetadata so the UI can route workflow tasks. */
 export const WORKFLOW_TASK_KIND = 'workflow';
@@ -37,6 +48,15 @@ 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';
+
 type WorkflowExecuteMode = WorkflowExecution['mode'];
 
 interface INodeExecutionData {
@@ -102,8 +122,33 @@ interface StoredWorkflowRow {
   versionId: string;
 }
 
+interface StoredWorkflowRevisionRow extends StoredWorkflowRow {
+  id: string;
+  workflowId: string;
+  capturedAt: string;
+  operation: WorkflowRevisionOperation;
+}
+
 interface ExecuteOptions {
   mode?: WorkflowExecuteMode;
+  /**
+   * Optional payload to seed the start node's first item. Used by the
+   * dispatch service to forward event-bridge data (e.g. `{eventKind,
+   * eventPayload}`) into trigger-mode workflows so `respondToEvent` and
+   * other nodes can read upstream context. Ignored when empty.
+   */
+  triggerData?: Record<string, unknown>;
+  /**
+   * Optional idempotency key. Persisted alongside the resulting
+   * execution row so the dispatch layer can detect duplicates and
+   * short-circuit re-runs (e.g. minute-bucketed schedule fires).
+   */
+  idempotencyKey?: string;
+  /**
+   * When false, failed manual/debug runs are returned as persisted error
+   * executions instead of being thrown away as route-level exceptions.
+   */
+  throwOnError?: boolean;
 }
 
 interface IncomingConnection {
@@ -165,6 +210,21 @@ function responseFromWorkflow(
   };
 }
 
+function revisionFromRow(row: StoredWorkflowRevisionRow): WorkflowRevision {
+  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: unknown, fallback: string): string {
   return typeof value === 'string' && value.length > 0 ? value : fallback;
 }
@@ -173,6 +233,17 @@ function readNumber(value: unknown, fallback: number): number {
   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: string, nextRunAtMs: number): string {
+  const minuteBucket = Math.floor(nextRunAtMs / 60_000);
+  return `${workflowId}:${minuteBucket}`;
+}
+
 function resolveScheduleIntervalMs(parameters: Record<string, unknown>): number {
   const explicitMs = readNumber(parameters.intervalMs, NaN);
   if (Number.isFinite(explicitMs) && explicitMs > 0) return explicitMs;
@@ -882,8 +953,8 @@ function createMergeNode(): INodeType {
       ] as never,
     },
     async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
-      const first = this.getInputData(0) ?? [];
-      const second = this.getInputData(1) ?? [];
+      const first = this.getInputData(0);
+      const second = this.getInputData(1);
       return [[...first, ...second]];
     },
   };
@@ -970,7 +1041,7 @@ function createDateTimeNode(): INodeType {
       const now = new Date().toISOString();
       return [
         inputItems.map((item, index) => ({
-          json: { ...(item.json ?? {}), [fieldName]: now } as INodeExecutionData['json'],
+          json: { ...item.json, [fieldName]: now } as INodeExecutionData['json'],
           pairedItem: item.pairedItem ?? { item: index },
         })),
       ];
@@ -1006,7 +1077,7 @@ function createCryptoNode(): INodeType {
             raw === '' || typeof raw === 'undefined' ? JSON.stringify(item.json) : String(raw);
           return {
             json: {
-              ...(item.json ?? {}),
+              ...item.json,
               [fieldName]: createHash(algorithm).update(source).digest('hex'),
             } as INodeExecutionData['json'],
             pairedItem: item.pairedItem ?? { item: index },
@@ -1070,6 +1141,19 @@ async function runQuickJsCode(jsCode: string, inputItems: INodeExecutionData[]):
   });
 }
 
+/**
+ * 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: string, inputJson?: unknown): Promise<unknown> {
+  const items: INodeExecutionData[] =
+    inputJson === undefined ? [] : [{ json: (inputJson ?? {}) as Record<string, unknown> }];
+  return runQuickJsCode(jsCode, items);
+}
+
 type AutonomyServiceLike = Service & {
   getAutonomousRoomId?(): UUID | undefined;
   getTargetRoomId?(): UUID | undefined;
@@ -1153,7 +1237,7 @@ function createRespondToEventNode(): INodeType {
 
       const autonomyService = resolveAutonomyService(runtime);
       if (!autonomyService) {
-        runtime.logger?.warn?.(
+        runtime.logger.warn(
           { src: 'plugin:workflow:respondToEvent', nodeName: node.name, executionId },
           '[respondToEvent] Autonomy service not registered — skipping injection'
         );
@@ -1162,7 +1246,7 @@ function createRespondToEventNode(): INodeType {
 
       const roomId = resolveAutonomyRoomId(autonomyService);
       if (!roomId) {
-        runtime.logger?.warn?.(
+        runtime.logger.warn(
           { src: 'plugin:workflow:respondToEvent', nodeName: node.name, executionId },
           '[respondToEvent] No autonomy room resolvable — skipping injection'
         );
@@ -1334,7 +1418,6 @@ export class EmbeddedWorkflowService extends Service {
       { src: 'plugin:workflow:embedded' },
       'Embedded workflow service registered (lazy runtime load)'
     );
-    service.registerTaskWorkers();
     if (runtime.db) {
       await service.ensureSchema();
       await service.rehydrateSchedules();
@@ -1347,48 +1430,6 @@ export class EmbeddedWorkflowService extends Service {
     // 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. */
-  private registerTaskWorkers(): void {
-    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: 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: Task) => {
-          const meta = task.metadata as Record<string, unknown> | undefined;
-          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(): string {
     return EMBEDDED_HOST;
   }
@@ -1456,6 +1497,32 @@ export class EmbeddedWorkflowService extends Service {
           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" (
             "id" text PRIMARY KEY,
@@ -1465,9 +1532,15 @@ 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"
           ON "workflow"."embedded_executions" ("workflow_id")
@@ -1480,6 +1553,10 @@ export class EmbeddedWorkflowService extends Service {
           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" (
             "id" text PRIMARY KEY,
@@ -1540,6 +1617,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);
@@ -1598,6 +1676,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);
@@ -1608,6 +1687,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();
@@ -1627,6 +1707,7 @@ export class EmbeddedWorkflowService extends Service {
   async deactivateWorkflow(id: string): Promise<WorkflowDefinitionResponse> {
     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();
@@ -1653,6 +1734,7 @@ export class EmbeddedWorkflowService extends Service {
       if (!tag) 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();
@@ -1667,6 +1749,81 @@ export class EmbeddedWorkflowService extends Service {
     return cloneJson(tags);
   }
 
+  async listWorkflowRevisions(
+    workflowId: string,
+    limit = 20
+  ): Promise<{ data: WorkflowRevision[] }> {
+    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 as WorkflowRevisionOperation,
+        })
+      ),
+    };
+  }
+
+  async restoreWorkflowRevision(
+    workflowId: string,
+    versionId: string
+  ): Promise<WorkflowDefinitionResponse> {
+    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: {
     name: string;
     type: string;
@@ -1778,7 +1935,39 @@ export class EmbeddedWorkflowService extends Service {
 
   async executeWorkflow(id: string, options: ExecuteOptions = {}): Promise<WorkflowExecution> {
     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: string,
+    idempotencyKey: string
+  ): Promise<WorkflowExecution | null> {
+    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(
@@ -1841,6 +2030,29 @@ export class EmbeddedWorkflowService extends Service {
     return executions;
   }
 
+  private async captureWorkflowRevision(
+    workflowId: string,
+    entry: StoredWorkflowRow,
+    operation: WorkflowRevisionOperation
+  ): Promise<void> {
+    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();
+  }
+
   private async getStoredWorkflow(id: string): Promise<StoredWorkflowRow> {
     await this.ensureSchema();
     const rows = await this.getDb()
@@ -1921,9 +2133,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. */
   private async rehydrateSchedules(): Promise<void> {
     await this.ensureSchema();
+    await this.deleteLegacyScheduleTasks();
     const rows = await this.getDb()
       .select()
       .from(embeddedWorkflows)
@@ -1933,9 +2150,73 @@ export class EmbeddedWorkflowService extends Service {
     }
   }
 
-  /** 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. */
+  private async deleteLegacyScheduleTasks(): Promise<number> {
+    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. */
+  private buildScheduleTrigger(
+    workflowId: string,
+    workflowName: string,
+    intervalMs: number
+  ): TriggerConfig {
+    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. */
   private async armSchedules(workflowId: string): Promise<void> {
     await this.clearSchedules(workflowId);
     if (typeof this.runtime.createTask !== 'function') return;
@@ -1945,19 +2226,30 @@ export class EmbeddedWorkflowService extends Service {
     );
     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: TriggerConfig = {
+        ...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,
         },
       });
     }
@@ -1970,7 +2262,7 @@ export class EmbeddedWorkflowService extends Service {
       tags: [WORKFLOW_TASK_TAG],
       agentIds: [this.runtime.agentId],
     });
-    if (!tasks?.length) return;
+    if (!tasks.length) return;
     for (const task of tasks) {
       if (
         task.id &&
@@ -1981,8 +2273,12 @@ export class EmbeddedWorkflowService extends Service {
     }
   }
 
-  private async saveExecution(execution: WorkflowExecution): Promise<void> {
+  private async saveExecution(
+    execution: WorkflowExecution,
+    idempotencyKey?: string
+  ): Promise<void> {
     await this.ensureSchema();
+    const key = idempotencyKey ?? null;
     await this.getDb()
       .insert(embeddedExecutions)
       .values({
@@ -1994,6 +2290,7 @@ export class EmbeddedWorkflowService extends Service {
         startedAt: execution.startedAt,
         stoppedAt: execution.stoppedAt ?? null,
         execution: cloneJson(execution),
+        idempotencyKey: key,
       })
       .onConflictDoUpdate({
         target: embeddedExecutions.id,
@@ -2005,6 +2302,7 @@ export class EmbeddedWorkflowService extends Service {
           startedAt: execution.startedAt,
           stoppedAt: execution.stoppedAt ?? null,
           execution: cloneJson(execution),
+          idempotencyKey: key,
         },
       });
   }
@@ -2013,16 +2311,16 @@ export class EmbeddedWorkflowService extends Service {
     workflowData: WorkflowDefinition
   ): Map<string, IncomingConnection[]> {
     const incoming = new Map<string, IncomingConnection[]>();
-    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);
         }
@@ -2072,21 +2370,51 @@ export class EmbeddedWorkflowService extends Service {
     return start;
   }
 
-  private collectInputData(
-    nodeName: string,
-    incoming: Map<string, IncomingConnection[]>,
-    nodeOutputs: Map<string, INodeExecutionData[][]>
-  ): INodeExecutionData[][] {
-    const inputData: INodeExecutionData[][] = [];
-    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,
-      ];
+  private resolveExecutionPlan(
+    workflowData: WorkflowDefinition,
+    mode: WorkflowExecuteMode
+  ): SmithersExecutionPlan {
+    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: WorkflowNode[] = [];
+    const executed = new Set<string>();
+
+    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()),
+    };
   }
 
   private async executeNode(
@@ -2107,7 +2435,10 @@ export class EmbeddedWorkflowService extends Service {
 
   private async runWorkflow(
     workflowData: WorkflowDefinition,
-    mode: WorkflowExecuteMode
+    mode: WorkflowExecuteMode,
+    triggerData?: Record<string, unknown>,
+    idempotencyKey?: string,
+    throwOnError = true
   ): Promise<WorkflowExecution> {
     const executionId = randomUUID();
     const startedAt = new Date();
@@ -2118,88 +2449,29 @@ 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<string, INodeExecutionData[][]>();
-      const executed = new Set<string>();
-      const runData: Record<string, unknown[]> = {};
-      let lastNodeExecuted: string | undefined;
-
-      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: WorkflowExecution = {
-        ...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) {
       const stoppedAt = new Date();
@@ -2217,7 +2489,10 @@ export class EmbeddedWorkflowService extends Service {
           },
         },
       };
-      await this.saveExecution(execution);
+      await this.saveExecution(execution, idempotencyKey);
+      if (!throwOnError) {
+        return cloneJson(execution);
+      }
       throw error;
     }
   }