@elizaos/plugin-workflow 2.0.0-beta.1

package/src/routes/nodes.ts

@@ -0,0 +1,211 @@
+import type { IAgentRuntime, Route, RouteRequest, RouteResponse } from '@elizaos/core';
+import {
+  EMBEDDED_WORKFLOW_SERVICE_TYPE,
+  type EmbeddedWorkflowService,
+} from '../services/embedded-workflow-service';
+import type { NodeSearchResult } from '../types/index';
+import { isCredentialProvider, WORKFLOW_CREDENTIAL_PROVIDER_TYPE } from '../types/index';
+import {
+  filterNodesByIntegrationSupport,
+  getAllNodes,
+  getNodeDefinition,
+  searchNodes,
+} from '../utils/catalog';
+import { validateLimit } from './_helpers';
+
+function getRegisteredEmbeddedNodes(runtime: IAgentRuntime): Set<string> | null {
+  const service = runtime.getService(
+    EMBEDDED_WORKFLOW_SERVICE_TYPE
+  ) as EmbeddedWorkflowService | null;
+  const names = service?.getRegisteredNodeTypes?.();
+  return names?.length ? new Set(names) : null;
+}
+
+function filterEmbeddedResults(
+  results: NodeSearchResult[],
+  runtime: IAgentRuntime
+): NodeSearchResult[] {
+  const registered = getRegisteredEmbeddedNodes(runtime);
+  return registered ? results.filter((result) => registered.has(result.node.name)) : results;
+}
+
+/**
+ * GET /nodes?q=gmail,email&limit=20
+ */
+async function listNodes(
+  req: RouteRequest,
+  res: RouteResponse,
+  runtime: IAgentRuntime
+): Promise<void> {
+  try {
+    const q = req.query?.q as string | undefined;
+    const limit = validateLimit(req.query?.limit, 20, 100);
+
+    if (!q) {
+      res.status(400).json({
+        success: false,
+        error: 'q parameter is required (comma-separated keywords)',
+      });
+      return;
+    }
+
+    const keywords = q
+      .split(',')
+      .map((k) => k.trim())
+      .filter(Boolean);
+    const results = filterEmbeddedResults(searchNodes(keywords, limit), runtime);
+
+    res.json({
+      success: true,
+      data: results.map(formatSearchResult),
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: 'failed_to_search_nodes',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+}
+
+/**
+ * GET /nodes/available
+ * Full catalog split by cloud integration support.
+ * Returns { supported, unsupported, utility }.
+ */
+async function listAvailableNodes(
+  _req: RouteRequest,
+  res: RouteResponse,
+  runtime: IAgentRuntime
+): Promise<void> {
+  try {
+    const registered = getRegisteredEmbeddedNodes(runtime);
+    const catalog = registered
+      ? getAllNodes().filter((node) => registered.has(node.name))
+      : getAllNodes();
+    const allResults: NodeSearchResult[] = catalog
+      .filter((n) => n.name && n.displayName)
+      .map((node) => ({ node, score: 0, matchReason: 'catalog' }));
+
+    const rawProvider = runtime.getService(WORKFLOW_CREDENTIAL_PROVIDER_TYPE);
+    const credProvider = isCredentialProvider(rawProvider) ? rawProvider : null;
+
+    if (!credProvider?.checkCredentialTypes) {
+      const utility = allResults.filter((r) => !r.node.credentials?.length);
+      const services = allResults.filter((r) => (r.node.credentials?.length ?? 0) > 0);
+      res.json({
+        success: true,
+        data: {
+          supported: services.map(formatCatalogNode),
+          unsupported: [],
+          utility: utility.map(formatCatalogNode),
+        },
+      });
+      return;
+    }
+
+    const credTypes = new Set<string>();
+    for (const { node } of allResults) {
+      for (const cred of node.credentials ?? []) {
+        credTypes.add(cred.name);
+      }
+    }
+
+    const checkResult = credProvider.checkCredentialTypes([...credTypes]);
+    const supportedSet = new Set(checkResult.supported);
+    const { remaining, removed } = filterNodesByIntegrationSupport(allResults, supportedSet);
+
+    const utility = remaining.filter((r) => !r.node.credentials?.length);
+    const supported = remaining.filter((r) => (r.node.credentials?.length ?? 0) > 0);
+
+    res.json({
+      success: true,
+      data: {
+        supported: supported.map(formatCatalogNode),
+        unsupported: removed.map((r) => ({
+          ...formatCatalogNode(r),
+          missingCredentials: r.node.credentials?.map((c) => c.name) ?? [],
+        })),
+        utility: utility.map(formatCatalogNode),
+      },
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: 'failed_to_list_nodes',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+}
+
+/**
+ * GET /nodes/:type
+ * Full node definition (properties/schema) for the visual editor.
+ */
+async function getNode(
+  req: RouteRequest,
+  res: RouteResponse,
+  runtime: IAgentRuntime
+): Promise<void> {
+  try {
+    const type = req.params?.type;
+    if (!type) {
+      res.status(400).json({ success: false, error: 'node_type_required' });
+      return;
+    }
+
+    const registered = getRegisteredEmbeddedNodes(runtime);
+    if (registered && !registered.has(type)) {
+      res.status(404).json({ success: false, error: `node_type_not_available: ${type}` });
+      return;
+    }
+
+    const definition = getNodeDefinition(type);
+    if (!definition) {
+      res.status(404).json({ success: false, error: `node_type_not_found: ${type}` });
+      return;
+    }
+
+    res.json({ success: true, data: definition });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: 'failed_to_get_node',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+}
+
+/** For search results — includes score and matchReason. */
+function formatSearchResult(r: NodeSearchResult) {
+  return {
+    name: r.node.name,
+    displayName: r.node.displayName,
+    description: r.node.description,
+    icon: r.node.icon,
+    iconUrl: r.node.iconUrl,
+    group: r.node.group,
+    credentials: r.node.credentials,
+    score: r.score,
+    matchReason: r.matchReason,
+  };
+}
+
+/** For catalog listings — no search metadata. */
+function formatCatalogNode(r: NodeSearchResult) {
+  return {
+    name: r.node.name,
+    displayName: r.node.displayName,
+    description: r.node.description,
+    icon: r.node.icon,
+    iconUrl: r.node.iconUrl,
+    group: r.node.group,
+    credentials: r.node.credentials,
+  };
+}
+
+export const nodeRoutes: Route[] = [
+  { type: 'GET', path: '/nodes/available', handler: listAvailableNodes },
+  { type: 'GET', path: '/nodes/:type', handler: getNode },
+  { type: 'GET', path: '/nodes', handler: listNodes },
+];

package/src/routes/validation.ts

@@ -0,0 +1,51 @@
+import type { IAgentRuntime, Route, RouteRequest, RouteResponse } from '@elizaos/core';
+import type { WorkflowDefinition } from '../types/index';
+import { validateNodeInputs, validateNodeParameters, validateWorkflow } from '../utils/workflow';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isWorkflowDefinition(value: unknown): value is WorkflowDefinition {
+  return isRecord(value) && Array.isArray(value.nodes) && isRecord(value.connections);
+}
+
+/**
+ * POST /workflows/validate
+ * Validate a workflow without deploying.
+ *
+ * Body: { nodes: [...], connections: {...}, ... }
+ */
+async function validate(
+  req: RouteRequest,
+  res: RouteResponse,
+  _runtime: IAgentRuntime
+): Promise<void> {
+  try {
+    if (!isWorkflowDefinition(req.body)) {
+      res.status(400).json({ success: false, error: 'nodes and connections are required' });
+      return;
+    }
+    const workflow = req.body;
+
+    const result = validateWorkflow(workflow);
+    const paramWarnings = validateNodeParameters(workflow);
+    const inputWarnings = validateNodeInputs(workflow);
+
+    res.json({
+      valid: result.valid,
+      errors: result.errors,
+      warnings: [...result.warnings, ...paramWarnings, ...inputWarnings],
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: 'failed_to_validate_workflow',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+}
+
+export const validationRoutes: Route[] = [
+  { type: 'POST', path: '/workflows/validate', handler: validate },
+];