@elizaos/plugin-workflow 2.0.0-beta.1

package/src/services/index.ts

@@ -0,0 +1,17 @@
+export {
+  EMBEDDED_WORKFLOW_SERVICE_TYPE,
+  EmbeddedWorkflowService,
+} from './embedded-workflow-service';
+export { WorkflowCredentialStore } from './workflow-credential-store';
+export {
+  createWorkflowDispatchService,
+  registerWorkflowDispatchService,
+  WORKFLOW_DISPATCH_SERVICE_TYPE,
+  type WorkflowDispatchResult,
+  type WorkflowDispatchService,
+} from './workflow-dispatch';
+export {
+  WORKFLOW_SERVICE_TYPE,
+  WorkflowService,
+  type WorkflowServiceConfig,
+} from './workflow-service';

package/src/services/workflow-credential-store.ts

@@ -0,0 +1,132 @@
+import { type IAgentRuntime, logger, Service } from '@elizaos/core';
+import { and, eq, sql } from 'drizzle-orm';
+import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { credentialMappings } from '../db/schema';
+import type {
+  ConnectorDisconnectedPayload,
+  CredentialMapping,
+  WorkflowCredentialStoreApi,
+} from '../types/index';
+import { CONNECTOR_DISCONNECTED_EVENT, WORKFLOW_CREDENTIAL_STORE_TYPE } from '../types/index';
+
+/**
+ * Default DB-backed credential store.
+ * Maps (userId, credType) → workflows credential ID.
+ *
+ * On the cloud, a different plugin can register its own implementation
+ * under the same service type — runtime.getService() returns the first registered.
+ */
+export class WorkflowCredentialStore extends Service implements WorkflowCredentialStoreApi {
+  static override readonly serviceType = WORKFLOW_CREDENTIAL_STORE_TYPE;
+
+  override capabilityDescription =
+    'Stores workflows credential ID mappings per user and credential type, backed by PostgreSQL.';
+
+  /**
+   * Bound handler for the runtime `connector_disconnected` event. Stored on the
+   * instance so `stop()` can unregister exactly the same reference that
+   * `start()` registered (referential equality matters for unregisterEvent).
+   */
+  private readonly connectorDisconnectedHandler = async (
+    payload: ConnectorDisconnectedPayload
+  ): Promise<void> => {
+    if (!payload?.userId || !Array.isArray(payload.credTypes)) {
+      return;
+    }
+    if (payload.credTypes.length === 0) {
+      return;
+    }
+    await Promise.all(
+      payload.credTypes.map((credType) =>
+        this.delete(payload.userId, credType).catch((err: unknown) => {
+          logger.warn(
+            {
+              src: 'plugin:workflow:service:credential-store',
+              userId: payload.userId,
+              credType,
+              connectorName: payload.connectorName,
+              error: err instanceof Error ? err.message : String(err),
+            },
+            'Failed to purge credential mapping on connector_disconnected'
+          );
+        })
+      )
+    );
+  };
+
+  private getDb(): NodePgDatabase {
+    const db = this.runtime.db;
+    if (!db) {
+      throw new Error('Database not available for WorkflowCredentialStore');
+    }
+    return db as NodePgDatabase;
+  }
+
+  static async start(runtime: IAgentRuntime): Promise<WorkflowCredentialStore> {
+    logger.info(
+      { src: 'plugin:workflow:service:credential-store' },
+      'Starting Workflow Credential Store...'
+    );
+    const service = new WorkflowCredentialStore(runtime);
+    runtime.registerEvent<ConnectorDisconnectedPayload>(
+      CONNECTOR_DISCONNECTED_EVENT,
+      service.connectorDisconnectedHandler
+    );
+    logger.info(
+      { src: 'plugin:workflow:service:credential-store' },
+      'Workflow Credential Store started'
+    );
+    return service;
+  }
+
+  override async stop(): Promise<void> {
+    this.runtime.unregisterEvent<ConnectorDisconnectedPayload>(
+      CONNECTOR_DISCONNECTED_EVENT,
+      this.connectorDisconnectedHandler
+    );
+    logger.info(
+      { src: 'plugin:workflow:service:credential-store' },
+      'Workflow Credential Store stopped'
+    );
+  }
+
+  async get(userId: string, credType: string): Promise<string | null> {
+    const db = this.getDb();
+    const rows = await db
+      .select()
+      .from(credentialMappings)
+      .where(and(eq(credentialMappings.userId, userId), eq(credentialMappings.credType, credType)))
+      .limit(1);
+    return rows[0]?.workflowCredentialId ?? null;
+  }
+
+  async set(userId: string, credType: string, workflowCredId: string): Promise<void> {
+    const db = this.getDb();
+    await db
+      .insert(credentialMappings)
+      .values({ userId, credType, workflowCredentialId: workflowCredId })
+      .onConflictDoUpdate({
+        target: [credentialMappings.userId, credentialMappings.credType],
+        set: { workflowCredentialId: workflowCredId, updatedAt: sql`now()` },
+      });
+  }
+
+  async listByUser(userId: string): Promise<CredentialMapping[]> {
+    const db = this.getDb();
+    const rows = await db
+      .select({
+        credType: credentialMappings.credType,
+        workflowCredentialId: credentialMappings.workflowCredentialId,
+      })
+      .from(credentialMappings)
+      .where(eq(credentialMappings.userId, userId));
+    return rows;
+  }
+
+  async delete(userId: string, credType: string): Promise<void> {
+    const db = this.getDb();
+    await db
+      .delete(credentialMappings)
+      .where(and(eq(credentialMappings.userId, userId), eq(credentialMappings.credType, credType)));
+  }
+}

package/src/services/workflow-dispatch.ts

@@ -0,0 +1,121 @@
+/**
+ * Workflow dispatch service - executes a workflow by id via the in-process
+ * EmbeddedWorkflowService registered by `@elizaos/plugin-workflow`.
+ *
+ * Consumed by the trigger dispatcher: triggers carrying `kind: "workflow"`
+ * resolve a workflow id and call
+ *   runtime.getService("WORKFLOW_DISPATCH").execute(workflowId).
+ *
+ * Registered into the runtime services map by the plugin's `init` (see
+ * `plugins/plugin-workflow/src/index.ts`).
+ *
+ * The dispatch service is a thin routing layer - it looks up the embedded
+ * workflow service on the runtime and delegates to its `executeWorkflow`
+ * method. There is no HTTP boundary and no sidecar lifecycle.
+ */
+
+import type { IAgentRuntime } from '@elizaos/core';
+import { logger } from '@elizaos/core';
+import {
+  EMBEDDED_WORKFLOW_SERVICE_TYPE,
+  type EmbeddedWorkflowService,
+} from './embedded-workflow-service';
+
+export const WORKFLOW_DISPATCH_SERVICE_TYPE = 'WORKFLOW_DISPATCH' as const;
+
+export interface WorkflowDispatchResult {
+  ok: boolean;
+  error?: string;
+  executionId?: string;
+}
+
+export interface WorkflowDispatchService {
+  execute(workflowId: string, payload?: Record<string, unknown>): Promise<WorkflowDispatchResult>;
+}
+
+interface WorkflowDispatchServiceEntry extends WorkflowDispatchService {
+  stop(): Promise<void>;
+  capabilityDescription: string;
+}
+
+interface RuntimeServiceRegistry {
+  set(serviceType: string, services: WorkflowDispatchServiceEntry[]): void;
+}
+
+function resolveEmbeddedService(runtime: IAgentRuntime): EmbeddedWorkflowService | null {
+  const service = runtime.getService<EmbeddedWorkflowService>(EMBEDDED_WORKFLOW_SERVICE_TYPE);
+  if (service && typeof service.executeWorkflow === 'function') {
+    return service;
+  }
+  return null;
+}
+
+function getRuntimeServiceRegistry(runtime: IAgentRuntime): RuntimeServiceRegistry | null {
+  const services: unknown = Reflect.get(runtime, 'services');
+  if (!services || typeof services !== 'object') {
+    return null;
+  }
+
+  const set: unknown = Reflect.get(services, 'set');
+  if (typeof set !== 'function') {
+    return null;
+  }
+
+  return {
+    set(serviceType, serviceEntries) {
+      Reflect.apply(set, services, [serviceType, serviceEntries]);
+    },
+  };
+}
+
+/**
+ * Construct the dispatch service. Registered under `WORKFLOW_DISPATCH` on the
+ * runtime by the plugin's `init` lifecycle hook.
+ */
+export function createWorkflowDispatchService(runtime: IAgentRuntime): WorkflowDispatchService {
+  return {
+    async execute(
+      workflowId: string,
+      _payload: Record<string, unknown> = {}
+    ): Promise<WorkflowDispatchResult> {
+      const id = workflowId.trim();
+      if (!id) {
+        return { ok: false, error: 'workflow id required' };
+      }
+      const service = resolveEmbeddedService(runtime);
+      if (!service) {
+        return { ok: false, error: 'embedded workflow service not registered' };
+      }
+      try {
+        const execution = await service.executeWorkflow(id, { mode: 'trigger' });
+        return execution.id ? { ok: true, executionId: execution.id } : { ok: true };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger.warn(
+          { src: 'plugin:workflow:dispatch' },
+          `Workflow execution failed for ${id}: ${message}`
+        );
+        return { ok: false, error: message };
+      }
+    },
+  };
+}
+
+/**
+ * Register the dispatch service in the runtime services map under
+ * `WORKFLOW_DISPATCH`. Called from the plugin's `init`.
+ *
+ * The runtime's `registerService(ServiceClass)` API expects a class with a
+ * static `start()`. The dispatch is a closure-based singleton, so we set the
+ * services map slot directly (mirrors `runtime/plugin-lifecycle.ts` and
+ * `test/scripts/*.ts`).
+ */
+export function registerWorkflowDispatchService(runtime: IAgentRuntime): void {
+  const dispatch = createWorkflowDispatchService(runtime);
+  const serviceEntry: WorkflowDispatchServiceEntry = {
+    execute: dispatch.execute,
+    stop: async () => {},
+    capabilityDescription: 'Executes embedded workflows by id via the in-process workflow service.',
+  };
+  getRuntimeServiceRegistry(runtime)?.set(WORKFLOW_DISPATCH_SERVICE_TYPE, [serviceEntry]);
+}