@elizaos/plugin-workflow 2.0.0-beta.1

package/src/data/schemaIndex.json

@@ -0,0 +1 @@
+{}

package/src/data/triggerSchemaIndex.json

@@ -0,0 +1 @@
+{}

package/src/db/index.ts

@@ -0,0 +1,8 @@
+export {
+  credentialMappings,
+  embeddedCredentials,
+  embeddedExecutions,
+  embeddedTags,
+  embeddedWorkflows,
+  workflowSchema,
+} from './schema';

package/src/db/schema.ts

@@ -0,0 +1,94 @@
+import { sql } from 'drizzle-orm';
+import {
+  boolean,
+  index,
+  jsonb,
+  pgSchema,
+  text,
+  timestamp,
+  uniqueIndex,
+  uuid,
+} from 'drizzle-orm/pg-core';
+import type { WorkflowDefinition, WorkflowExecution } from '../types/index';
+
+export const workflowSchema = pgSchema('workflow');
+
+export const credentialMappings = workflowSchema.table(
+  'credential_mappings',
+  {
+    id: uuid('id').primaryKey().defaultRandom(),
+    userId: text('user_id').notNull(),
+    credType: text('cred_type').notNull(),
+    workflowCredentialId: text('workflow_credential_id').notNull(),
+    createdAt: timestamp('created_at').default(sql`now()`).notNull(),
+    updatedAt: timestamp('updated_at').default(sql`now()`).notNull(),
+  },
+  (table) => ({
+    userCredIdx: uniqueIndex('idx_user_cred').on(table.userId, table.credType),
+  })
+);
+
+export const embeddedWorkflows = workflowSchema.table(
+  'embedded_workflows',
+  {
+    id: text('id').primaryKey(),
+    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(),
+    versionId: text('version_id').notNull(),
+  },
+  (table) => ({
+    activeIdx: index('idx_embedded_workflows_active').on(table.active),
+    updatedAtIdx: index('idx_embedded_workflows_updated_at').on(table.updatedAt),
+  })
+);
+
+export const embeddedExecutions = workflowSchema.table(
+  'embedded_executions',
+  {
+    id: text('id').primaryKey(),
+    workflowId: text('workflow_id').notNull(),
+    status: text('status').notNull(),
+    mode: text('mode').notNull(),
+    finished: boolean('finished').default(false).notNull(),
+    startedAt: text('started_at').notNull(),
+    stoppedAt: text('stopped_at'),
+    execution: jsonb('execution').$type<WorkflowExecution>().notNull(),
+  },
+  (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),
+  })
+);
+
+export const embeddedCredentials = workflowSchema.table(
+  'embedded_credentials',
+  {
+    id: text('id').primaryKey(),
+    name: text('name').notNull(),
+    type: text('type').notNull(),
+    data: jsonb('data').$type<Record<string, unknown>>().notNull(),
+    isResolvable: boolean('is_resolvable').default(true).notNull(),
+    createdAt: text('created_at').notNull(),
+    updatedAt: text('updated_at').notNull(),
+  },
+  (table) => ({
+    typeIdx: index('idx_embedded_credentials_type').on(table.type),
+  })
+);
+
+export const embeddedTags = workflowSchema.table(
+  'embedded_tags',
+  {
+    id: text('id').primaryKey(),
+    name: text('name').notNull(),
+    createdAt: text('created_at').notNull(),
+    updatedAt: text('updated_at').notNull(),
+  },
+  (table) => ({
+    nameIdx: uniqueIndex('idx_embedded_tags_name').on(table.name),
+  })
+);

package/src/index.ts

@@ -0,0 +1,179 @@
+import { type IAgentRuntime, logger, type Plugin } from '@elizaos/core';
+import { workflowAction } from './actions/index';
+import * as dbSchema from './db/index';
+import { migrateLegacyTextTriggers, migrateLegacyWorkbenchTasks } from './lib/index';
+import {
+  activeWorkflowsProvider,
+  pendingDraftProvider,
+  workflowStatusProvider,
+} from './providers/index';
+import { workflowRoutes } from './routes/index';
+import {
+  EmbeddedWorkflowService,
+  registerWorkflowDispatchService,
+  WORKFLOW_SERVICE_TYPE,
+  WorkflowCredentialStore,
+  WorkflowService,
+} from './services/index';
+// Side-effect: register the rawPath route plugin
+// (`@elizaos/plugin-workflow:routes`) with the app-route-plugin-registry so
+// the runtime mounts /api/workflow/* on the host HTTP server. Without this
+// import the registry call in register-routes.ts never fires and every
+// /api/workflow/* request returns 404.
+import './register-routes';
+
+/**
+ * Workflow Plugin for ElizaOS
+ *
+ * Generate and manage workflows from natural language using a RAG pipeline.
+ * Supports workflow CRUD, execution management, and credential resolution.
+ *
+ * **Optional Configuration:**
+ * - `workflows.credentials`: Pre-configured credential IDs for local mode
+ *
+ * **Example Character Configuration:**
+ * ```json
+ * {
+ *   "name": "AI Workflow Builder",
+ *   "plugins": ["@elizaos/plugin-workflow"],
+ *   "settings": {
+ *     "workflows": {
+ *       "credentials": {
+ *         "gmailOAuth2": "cred_gmail_123",
+ *         "stripeApi": "cred_stripe_456"
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export const workflowPlugin: Plugin = {
+  name: 'workflow',
+  description:
+    'Generate and deploy workflows from natural language. ' +
+    'Runs supported workflow nodes in-process with credential resolution.',
+
+  services: [EmbeddedWorkflowService, WorkflowService, WorkflowCredentialStore],
+
+  schema: dbSchema,
+
+  actions: [workflowAction],
+
+  providers: [workflowStatusProvider, activeWorkflowsProvider, pendingDraftProvider],
+
+  routes: workflowRoutes,
+
+  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
+      | { credentials?: Record<string, string> }
+      | undefined;
+    if (workflowSettings?.credentials) {
+      const credCount = Object.keys(workflowSettings.credentials).filter(
+        (k) => workflowSettings.credentials?.[k]
+      ).length;
+      logger.info(
+        { src: 'plugin:workflow:plugin:init' },
+        `Pre-configured credentials: ${credCount} credential types`
+      );
+    }
+
+    // Register WORKFLOW_DISPATCH so trigger-kind=workflow tasks can call
+    // 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)'
+    );
+  },
+};
+
+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';
+export * from './register-routes.js';
+export * from './services/workflow-dispatch.js';
+export {
+  handleTriggerRoutes,
+  type TriggerRouteContext,
+  type TriggerRouteHelpers,
+} from './trigger-routes.js';