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

package/src/db/schema.ts

@@ -45,6 +45,30 @@ export const embeddedWorkflows = workflowSchema.table(
   })
 );
 
+export const workflowRevisions = workflowSchema.table(
+  'workflow_revisions',
+  {
+    id: text('id').primaryKey(),
+    workflowId: text('workflow_id').notNull(),
+    versionId: text('version_id').notNull(),
+    name: text('name').notNull(),
+    active: boolean('active').default(false).notNull(),
+    workflow: jsonb('workflow').$type<WorkflowDefinition>().notNull(),
+    createdAt: text('created_at').notNull(),
+    updatedAt: text('updated_at').notNull(),
+    capturedAt: text('captured_at').notNull(),
+    operation: text('operation').notNull(),
+  },
+  (table) => ({
+    workflowIdx: index('idx_workflow_revisions_workflow_id').on(table.workflowId),
+    versionIdx: uniqueIndex('idx_workflow_revisions_workflow_version').on(
+      table.workflowId,
+      table.versionId
+    ),
+    capturedAtIdx: index('idx_workflow_revisions_captured_at').on(table.capturedAt),
+  })
+);
+
 export const embeddedExecutions = workflowSchema.table(
   'embedded_executions',
   {
@@ -56,11 +80,18 @@ export const embeddedExecutions = workflowSchema.table(
     startedAt: text('started_at').notNull(),
     stoppedAt: text('stopped_at'),
     execution: jsonb('execution').$type<WorkflowExecution>().notNull(),
+    /**
+     * Per-dispatch idempotency key. Scheduled dispatches use
+     * `${workflowId}:${minuteBucket}` so re-arms inside the same minute
+     * collapse to a single execution. Null for ad-hoc / manual runs.
+     */
+    idempotencyKey: text('idempotency_key'),
   },
   (table) => ({
     workflowIdx: index('idx_embedded_executions_workflow_id').on(table.workflowId),
     statusIdx: index('idx_embedded_executions_status').on(table.status),
     startedAtIdx: index('idx_embedded_executions_started_at').on(table.startedAt),
+    idempotencyKeyIdx: index('idx_embedded_executions_idempotency_key').on(table.idempotencyKey),
   })
 );
 

package/src/index.ts

@@ -1,7 +1,6 @@
 import { type IAgentRuntime, logger, type Plugin } from '@elizaos/core';
-import { workflowAction } from './actions/index';
+import { evalCodeAction, workflowAction } from './actions/index';
 import * as dbSchema from './db/index';
-import { migrateLegacyTextTriggers, migrateLegacyWorkbenchTasks } from './lib/index';
 import {
   activeWorkflowsProvider,
   pendingDraftProvider,
@@ -11,7 +10,6 @@ import { workflowRoutes } from './routes/index';
 import {
   EmbeddedWorkflowService,
   registerWorkflowDispatchService,
-  WORKFLOW_SERVICE_TYPE,
   WorkflowCredentialStore,
   WorkflowService,
 } from './services/index';
@@ -55,9 +53,15 @@ export const workflowPlugin: Plugin = {
 
   services: [EmbeddedWorkflowService, WorkflowService, WorkflowCredentialStore],
 
+  async dispose(runtime: IAgentRuntime) {
+    await runtime.getService<WorkflowService>(WorkflowService.serviceType)?.stop();
+    await runtime.getService<EmbeddedWorkflowService>(EmbeddedWorkflowService.serviceType)?.stop();
+    await runtime.getService<WorkflowCredentialStore>(WorkflowCredentialStore.serviceType)?.stop();
+  },
+
   schema: dbSchema,
 
-  actions: [workflowAction],
+  actions: [workflowAction, evalCodeAction],
 
   providers: [workflowStatusProvider, activeWorkflowsProvider, pendingDraftProvider],
 
@@ -66,7 +70,7 @@ export const workflowPlugin: Plugin = {
   init: async (_config: Record<string, string>, runtime: IAgentRuntime): Promise<void> => {
     // Check for pre-configured credentials (optional)
     // Note: runtime.getSetting() only returns primitives — nested objects must be read directly
-    const workflowSettings = runtime.character?.settings?.workflows as
+    const workflowSettings = runtime.character.settings?.workflows as
       | { credentials?: Record<string, string> }
       | undefined;
     if (workflowSettings?.credentials) {
@@ -83,13 +87,6 @@ export const workflowPlugin: Plugin = {
     // runtime.getService("WORKFLOW_DISPATCH").execute(workflowId).
     registerWorkflowDispatchService(runtime);
 
-    // Schedule one-shot legacy migrations off the init critical path. Service
-    // start-order is not guaranteed at init: WorkflowService may not be in
-    // the registry yet. Poll up to 10 times (1s spacing) and bail quietly
-    // if it never appears. Each migration is idempotent so a duplicate run
-    // on a future boot is harmless.
-    scheduleLegacyMigrations(runtime);
-
     logger.info(
       { src: 'plugin:workflow:plugin:init' },
       'Workflow Plugin initialized successfully (in-process runtime)'
@@ -97,76 +94,6 @@ export const workflowPlugin: Plugin = {
   },
 };
 
-const MIGRATION_RETRY_LIMIT = 10;
-const MIGRATION_RETRY_INTERVAL_MS = 1000;
-
-function scheduleLegacyMigrations(runtime: IAgentRuntime): void {
-  let attempts = 0;
-  const tick = (): void => {
-    attempts += 1;
-    const ready = runtime.getService(WORKFLOW_SERVICE_TYPE);
-    if (!ready) {
-      if (attempts >= MIGRATION_RETRY_LIMIT) {
-        logger.warn(
-          { src: 'plugin:workflow:plugin:migration' },
-          `WorkflowService still not registered after ${MIGRATION_RETRY_LIMIT} retries; legacy migrations will run on next boot`
-        );
-        return;
-      }
-      setTimeout(tick, MIGRATION_RETRY_INTERVAL_MS);
-      return;
-    }
-    void runLegacyMigrations(runtime);
-  };
-  // Defer the first attempt off the init stack so the host runtime can
-  // finish wiring before we probe the service registry.
-  setImmediate(tick);
-}
-
-async function runLegacyMigrations(runtime: IAgentRuntime): Promise<void> {
-  try {
-    const summary = await migrateLegacyWorkbenchTasks(runtime);
-    logger.info(
-      {
-        src: 'plugin:workflow:plugin:migration',
-        migrated: summary.migrated,
-        skipped: summary.skipped,
-        failed: summary.failed,
-      },
-      `Workbench-task migration: ${summary.migrated} migrated, ${summary.skipped} skipped, ${summary.failed} failed`
-    );
-  } catch (err) {
-    logger.warn(
-      {
-        src: 'plugin:workflow:plugin:migration',
-        err: err instanceof Error ? err.message : String(err),
-      },
-      'Workbench-task migration threw; continuing'
-    );
-  }
-
-  try {
-    const summary = await migrateLegacyTextTriggers(runtime);
-    logger.info(
-      {
-        src: 'plugin:workflow:plugin:migration',
-        migrated: summary.migrated,
-        skipped: summary.skipped,
-        failed: summary.failed,
-      },
-      `Text-trigger migration: ${summary.migrated} migrated, ${summary.skipped} skipped, ${summary.failed} failed`
-    );
-  } catch (err) {
-    logger.warn(
-      {
-        src: 'plugin:workflow:plugin:migration',
-        err: err instanceof Error ? err.message : String(err),
-      },
-      'Text-trigger migration threw; continuing'
-    );
-  }
-}
-
 export default workflowPlugin;
 
 export * from './plugin-routes.js';

package/src/lib/automations-builder.ts

@@ -90,35 +90,17 @@ function normalizeDateValue(value: unknown): string | null {
 }
 
 function resolveAgentName(runtime: AgentRuntime): string {
-  return runtime.character?.name?.trim() || 'Eliza';
+  return runtime.character.name?.trim() || 'Eliza';
 }
 
 function isSystemTask(task: WorkbenchTaskView): boolean {
   if (SYSTEM_TASK_NAMES.has(task.name)) {
     return true;
   }
-  const tags = new Set(task.tags ?? []);
+  const tags = new Set(task.tags);
   return tags.has('queue') && tags.has('repeat');
 }
 
-/**
- * True when the raw runtime task carries the `migratedToWorkflowId` metadata
- * flag set by `migrateLegacyWorkbenchTasks`. The workflow representation is
- * already surfaced by the workflow listing path; the original task should not
- * also appear as a coordinator-text item.
- */
-function taskHasMigrationFlag(rawTasks: Task[], taskId: string): boolean {
-  for (const raw of rawTasks) {
-    if (raw.id !== taskId) continue;
-    const meta = isRecord(raw.metadata) ? raw.metadata : null;
-    if (meta && typeof meta.migratedToWorkflowId === 'string') {
-      return true;
-    }
-    return false;
-  }
-  return false;
-}
-
 function choosePreferredSystemTask(
   current: WorkbenchTaskView,
   candidate: WorkbenchTaskView
@@ -263,8 +245,7 @@ async function listTriggerTasks(runtime: AgentRuntime): Promise<Task[]> {
 
   const merged = new Map<string, Task>();
   for (const task of [...triggerTasks, ...heartbeatTasks]) {
-    const key =
-      task.id ?? `${task.name ?? ''}:${task.description ?? ''}:${(task.tags ?? []).join(',')}`;
+    const key = task.id ?? `${task.name}:${task.description ?? ''}:${(task.tags ?? []).join(',')}`;
     if (!merged.has(key)) {
       merged.set(key, task);
     }
@@ -296,7 +277,7 @@ function buildCoordinatorTaskItem(
   };
 }
 
-function buildCoordinatorTriggerItem(
+function _buildCoordinatorTriggerItem(
   trigger: TriggerSummary,
   room: AutomationRoomRecord | undefined
 ): AutomationItem {
@@ -455,7 +436,7 @@ function normalizeLastExecution(raw: WorkflowExecution): AutomationLastExecution
 }
 
 function getWorkflowService(runtime: AgentRuntime): WorkflowService | null {
-  const candidate = runtime.getService?.(WORKFLOW_SERVICE_TYPE);
+  const candidate = runtime.getService(WORKFLOW_SERVICE_TYPE);
   return (candidate as WorkflowService | null) ?? null;
 }
 
@@ -524,7 +505,7 @@ export async function buildAutomationListResponse(
       .filter((room) => room.metadata.taskId)
       .map((room) => [room.metadata.taskId as string, room])
   );
-  const triggerRooms = new Map(
+  const _triggerRooms = new Map(
     rooms
       .filter((room) => room.metadata.triggerId)
       .map((room) => [room.metadata.triggerId as string, room])
@@ -548,11 +529,6 @@ export async function buildAutomationListResponse(
     allTasks
       .map((task) => toWorkbenchTaskView(task))
       .filter((task): task is WorkbenchTaskView => task !== null)
-      // Tasks migrated to workflows by plugin-workflow's boot migration carry
-      // a `migratedToWorkflowId` metadata flag; their workflow representation
-      // is already in the workflowItemsById map below, so skip them here to
-      // avoid duplicate Automations entries.
-      .filter((task) => !taskHasMigrationFlag(allTasks, task.id))
   );
 
   const triggerTaskRecords = await listTriggerTasks(runtime);
@@ -608,7 +584,7 @@ export async function buildAutomationListResponse(
   // current workflow list is an ORPHAN: the workflow was deleted but the chat
   // room/conversation wasn't cleaned up. Surfacing those creates ghost
   // rows the user can't dismiss. Skip them; the UI's deleteWorkflow path
-  // also deletes the conversation now, so future deletions won't leak rooms.
+  // also deletes the conversation, so later deletions won't leak rooms.
   const workflowOffline = workflowFetchError !== null;
   if (workflowOffline) {
     for (const [workflowId, room] of workflowRooms.entries()) {
@@ -642,15 +618,15 @@ export async function buildAutomationListResponse(
     );
   }
 
-  const coordinatorTriggerItems = triggerItems
-    .filter((trigger) => trigger.kind !== 'workflow')
-    .map((trigger) => buildCoordinatorTriggerItem(trigger, triggerRooms.get(trigger.id)));
+  const coordinatorTriggerItems = triggerItems.map((trigger) =>
+    _buildCoordinatorTriggerItem(trigger, _triggerRooms.get(trigger.id))
+  );
 
   const automations = [
     ...automationDraftItems,
     ...workflowDraftItems,
-    ...taskItems,
     ...coordinatorTriggerItems,
+    ...taskItems,
     ...workflowItemsById.values(),
   ].sort(compareAutomationItems);
 

package/src/lib/automations-types.ts

@@ -25,7 +25,6 @@ export type ConversationScope =
   | 'page-connectors'
   | 'page-phone'
   | 'page-plugins'
-  | 'page-lifeops'
   | 'page-settings'
   | 'page-wallet'
   | 'page-browser'
@@ -64,7 +63,7 @@ export function isAutomationConversationMetadata(
 export type TriggerType = 'interval' | 'once' | 'cron' | 'event';
 export type TriggerWakeMode = 'inject_now' | 'next_autonomy_cycle';
 export type TriggerLastStatus = 'success' | 'error' | 'skipped';
-export type TriggerKind = 'text' | 'workflow';
+export type TriggerKind = 'workflow';
 
 export interface TriggerSummary {
   id: string;

package/src/lib/index.ts

@@ -1,8 +0,0 @@
-export {
-  type LegacyTaskMigrationSummary,
-  migrateLegacyWorkbenchTasks,
-} from './legacy-task-migration';
-export {
-  type LegacyTextTriggerMigrationSummary,
-  migrateLegacyTextTriggers,
-} from './legacy-text-trigger-migration';

package/src/lib/workflow-clarification.ts

@@ -41,6 +41,10 @@ type RawStructuredClarification = Partial<WorkflowClarificationRequest> & {
   question: string;
 };
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
 const VALID_KINDS: ReadonlySet<WorkflowClarificationRequest['kind']> = new Set([
   'target_channel',
   'target_server',
@@ -330,24 +334,25 @@ function appendUserNote(draft: Record<string, unknown>, value: string): void {
 
 export function applyResolutions(
   draft: Record<string, unknown>,
-  resolutions: ReadonlyArray<WorkflowClarificationResolution>
+  resolutions: ReadonlyArray<unknown>
 ): { ok: true } | { ok: false; error: string; paramPath?: string } {
   for (const r of resolutions) {
-    if (!r || typeof r.paramPath !== 'string') {
+    if (!isRecord(r) || typeof r.paramPath !== 'string') {
       return { ok: false, error: 'resolution missing paramPath' };
     }
-    if (typeof r.value !== 'string') {
+    const { paramPath, value } = r;
+    if (typeof value !== 'string') {
       return {
         ok: false,
         error: 'resolution value must be a string',
-        paramPath: r.paramPath,
+        paramPath,
       };
     }
-    if (r.paramPath.length === 0) {
+    if (paramPath.length === 0) {
       // Free-form clarification with no field to wire into. Record the user's
       // answer under draft._meta.userNotes so subsequent LLM iterations can
       // consume the context, but don't mutate the workflow itself.
-      appendUserNote(draft, r.value);
+      appendUserNote(draft, value);
       continue;
     }
     // Surface structural parse errors (unterminated bracket, empty
@@ -355,18 +360,18 @@ export function applyResolutions(
     // malformed LLM emission and cannot be silently recovered into
     // userNotes without losing the failure mode in the metrics pipeline.
     try {
-      parseParamPath(r.paramPath);
+      parseParamPath(paramPath);
     } catch (err) {
       return {
         ok: false,
         error: `paramPath is structurally invalid: ${
           err instanceof Error ? err.message : String(err)
         }`,
-        paramPath: r.paramPath,
+        paramPath,
       };
     }
     try {
-      setByDotPath(draft, r.paramPath, r.value);
+      setByDotPath(draft, paramPath, value);
     } catch (err) {
       // Lookup-time failure: the path parsed cleanly but didn't resolve
       // against the current draft (e.g. references a node the LLM didn't
@@ -380,11 +385,11 @@ export function applyResolutions(
         {
           src: 'plugin:workflow:clarification:applyResolutions',
           err: errMsg,
-          paramPath: r.paramPath,
+          paramPath,
         },
-        `setByDotPath failed for paramPath "${r.paramPath}"; recording "${r.value}" as a free-form note instead`
+        `setByDotPath failed for paramPath "${paramPath}"; recording "${value}" as a free-form note instead`
       );
-      appendUserNote(draft, r.value);
+      appendUserNote(draft, value);
     }
   }
   return { ok: true };
@@ -452,7 +457,7 @@ export function pruneResolvedClarifications(
 
 /**
  * Subset of `ElizaConnectorTargetCatalog` used by the route. Declared here
- * (vs. imported from the service) so route tests can stub it without
+ * (vs. imported from the service) so route tests can provide it without
  * spinning up the full service.
  */
 export interface CatalogLike {

package/src/plugin-routes.ts

@@ -145,6 +145,12 @@ const workflowRouteList: Route[] = [
     rawPath: true,
     handler: workflowHandler,
   },
+  {
+    type: 'GET',
+    path: '/api/workflow/workflows/:id/evaluation-samples',
+    rawPath: true,
+    handler: workflowHandler,
+  },
   // Cross-cutting `/api/automations` surface — combines workflows, triggers,
   // workbench tasks, and draft conversations into a single list view.
   {

package/src/providers/activeWorkflows.ts

@@ -44,7 +44,7 @@ export const activeWorkflowsProvider: Provider = {
         .slice(0, 20)
         .map((wf) => {
           const status = wf.active ? 'ACTIVE' : 'INACTIVE';
-          const nodeCount = wf.nodes?.length || 0;
+          const nodeCount = wf.nodes.length || 0;
           return `- **${wf.name}** (ID: ${wf.id}, Status: ${status}, Nodes: ${nodeCount})`;
         })
         .join('\n');
@@ -58,7 +58,7 @@ export const activeWorkflowsProvider: Provider = {
             id: wf.id,
             name: wf.name,
             active: wf.active || false,
-            nodeCount: wf.nodes?.length || 0,
+            nodeCount: wf.nodes.length || 0,
           })),
         },
         values: {

package/src/providers/workflowStatus.ts

@@ -42,7 +42,7 @@ export const workflowStatusProvider: Provider = {
       for (const workflow of workflows.slice(0, 10)) {
         const statusEmoji = workflow.active ? '✅' : '⏸️';
         status += `${statusEmoji} ${workflow.name} (ID: ${workflow.id})\n`;
-        status += `   Nodes: ${workflow.nodes?.length || 0}\n`;
+        status += `   Nodes: ${workflow.nodes.length || 0}\n`;
 
         // Try to get last execution (if possible)
         try {

package/src/routes/workflow-routes.ts

@@ -73,10 +73,13 @@ function getWorkflowService(ctx: WorkflowRouteContext): WorkflowService | null {
   return (ctx.runtime?.getService?.(WORKFLOW_SERVICE_TYPE) as WorkflowService | null) ?? null;
 }
 
+function isCatalogLike(value: unknown): value is CatalogLike {
+  return isRecord(value) && typeof value.listGroups === 'function';
+}
+
 function getConnectorTargetCatalog(ctx: WorkflowRouteContext): CatalogLike | null {
   const raw = ctx.runtime?.getService?.('connector_target_catalog');
-  const candidate = raw as unknown as CatalogLike | undefined;
-  return candidate && typeof candidate.listGroups === 'function' ? candidate : null;
+  return isCatalogLike(raw) ? raw : null;
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -247,6 +250,33 @@ async function handleGet(
   sendJson(ctx, 200, await service.getWorkflow(id));
 }
 
+async function handleListRevisions(
+  ctx: WorkflowRouteContext,
+  service: WorkflowService,
+  id: string
+): Promise<void> {
+  const url = new URL(`http://x${ctx.req.url ?? ''}`);
+  const rawLimit = url.searchParams.get('limit');
+  const limit = Math.min(Math.max(1, Number(rawLimit) || 20), 50);
+  const [workflow, revisions] = await Promise.all([
+    service.getWorkflow(id),
+    service.listWorkflowRevisions(id, limit),
+  ]);
+  sendJson(ctx, 200, {
+    currentVersionId: workflow.versionId,
+    revisions,
+  });
+}
+
+async function handleRestoreRevision(
+  ctx: WorkflowRouteContext,
+  service: WorkflowService,
+  id: string,
+  versionId: string
+): Promise<void> {
+  sendJson(ctx, 200, await service.restoreWorkflowRevision(id, versionId));
+}
+
 async function handleGenerate(ctx: WorkflowRouteContext, service: WorkflowService): Promise<void> {
   const body = await readJsonBody(ctx.req, ctx.res);
   if (!isRecord(body)) {
@@ -392,6 +422,37 @@ async function handleListExecutions(
   sendJson(ctx, 200, { executions: response.data });
 }
 
+async function handleEvaluationSamples(
+  ctx: WorkflowRouteContext,
+  service: WorkflowService,
+  id: string
+): Promise<void> {
+  const url = new URL(`http://x${ctx.req.url ?? ''}`);
+  const rawLimit = url.searchParams.get('limit');
+  const limit = Math.min(Math.max(1, Number(rawLimit) || 10), 50);
+  sendJson(ctx, 200, await service.getWorkflowEvaluationSuite(id, limit));
+}
+
+async function handleRunWorkflow(
+  ctx: WorkflowRouteContext,
+  service: WorkflowService,
+  id: string
+): Promise<void> {
+  const execution = await service.runWorkflow(id, {
+    mode: 'manual',
+    throwOnError: false,
+  });
+  sendJson(ctx, 200, { execution });
+}
+
+async function handleGetExecution(
+  ctx: WorkflowRouteContext,
+  service: WorkflowService,
+  id: string
+): Promise<void> {
+  sendJson(ctx, 200, { execution: await service.getExecutionDetail(id) });
+}
+
 export async function handleWorkflowRoutes(ctx: WorkflowRouteContext): Promise<void> {
   const path = normalizePath(ctx.pathname);
   const method = ctx.method.toUpperCase();
@@ -433,11 +494,36 @@ export async function handleWorkflowRoutes(ctx: WorkflowRouteContext): Promise<v
       return;
     }
 
+    if (method === 'GET' && path.startsWith('/executions/')) {
+      const executionId = decodeURIComponent(path.slice('/executions/'.length));
+      if (executionId) {
+        await handleGetExecution(ctx, service, executionId);
+        return;
+      }
+    }
+
     const id = readId(path);
     if (id && method === 'GET' && path === `/workflows/${encodeURIComponent(id)}`) {
       await handleGet(ctx, service, id);
       return;
     }
+    if (id && method === 'GET' && path === `/workflows/${encodeURIComponent(id)}/revisions`) {
+      await handleListRevisions(ctx, service, id);
+      return;
+    }
+    if (
+      id &&
+      method === 'POST' &&
+      path.startsWith(`/workflows/${encodeURIComponent(id)}/revisions/`)
+    ) {
+      const prefix = `/workflows/${encodeURIComponent(id)}/revisions/`;
+      const suffix = path.slice(prefix.length);
+      const versionId = suffix.endsWith('/restore') ? suffix.slice(0, -'/restore'.length) : '';
+      if (versionId) {
+        await handleRestoreRevision(ctx, service, id, decodeURIComponent(versionId));
+        return;
+      }
+    }
     if (id && method === 'PUT' && path === `/workflows/${encodeURIComponent(id)}`) {
       await handleWrite(ctx, service, id);
       return;
@@ -455,6 +541,18 @@ export async function handleWorkflowRoutes(ctx: WorkflowRouteContext): Promise<v
       await handleToggle(ctx, service, id, false);
       return;
     }
+    if (id && method === 'POST' && path === `/workflows/${encodeURIComponent(id)}/run`) {
+      await handleRunWorkflow(ctx, service, id);
+      return;
+    }
+    if (
+      id &&
+      method === 'GET' &&
+      path === `/workflows/${encodeURIComponent(id)}/evaluation-samples`
+    ) {
+      await handleEvaluationSamples(ctx, service, id);
+      return;
+    }
     if (id && method === 'GET' && path === `/workflows/${encodeURIComponent(id)}/executions`) {
       await handleListExecutions(ctx, service, id);
       return;

package/src/routes/workflows.ts

@@ -44,8 +44,12 @@ async function listWorkflows(
 ): Promise<void> {
   try {
     const userId = req.query?.userId as string | undefined;
+    const q = req.query?.q as string | undefined;
     const service = getService(runtime);
-    const workflows = await service.listWorkflows(userId);
+    // `?q=` performs a ranked free-text search; otherwise list all (#8913).
+    const workflows = q?.trim()
+      ? await service.searchWorkflows(q, userId)
+      : await service.listWorkflows(userId);
     res.json({ success: true, data: workflows });
   } catch (error) {
     res.status(500).json({