next-workflow-builder 0.4.7 → 0.7.0

package/dist/server/index.js

@@ -1,60 +1 @@
-import {
-  generateWorkflowMetadata
-} from "../chunk-J72T2LRL.js";
-import {
-  discoverPlugins
-} from "../chunk-C7GDB4KC.js";
-import {
-  auth
-} from "../chunk-JUV5RBYM.js";
-import {
-  getErrorMessageAsync
-} from "../chunk-5YYA34YV.js";
-import "../chunk-OQHML4II.js";
-import {
-  fetchCredentials
-} from "../chunk-5H76TY4T.js";
-import {
-  decrypt,
-  encrypt
-} from "../chunk-CKE7ETZL.js";
-import "../chunk-3XFDIK7H.js";
-import {
-  getErrorMessage
-} from "../chunk-O3I2INCD.js";
-import {
-  accounts,
-  apiKeys,
-  db,
-  generateId,
-  integrations,
-  sessions,
-  users,
-  verifications,
-  withStepLogging,
-  workflowExecutionLogs,
-  workflowExecutions,
-  workflowExecutionsRelations
-} from "../chunk-PEVVELQ6.js";
-export {
-  accounts,
-  apiKeys,
-  auth,
-  db,
-  decrypt,
-  discoverPlugins,
-  encrypt,
-  fetchCredentials,
-  generateId,
-  generateWorkflowMetadata,
-  getErrorMessage,
-  getErrorMessageAsync,
-  integrations,
-  sessions,
-  users,
-  verifications,
-  withStepLogging,
-  workflowExecutionLogs,
-  workflowExecutions,
-  workflowExecutionsRelations
-};
+import{a as q}from"../chunk-R5GS6TJS.js";import{a as b}from"../chunk-CYVALTSI.js";import{b as t}from"../chunk-IEOZJAW2.js";import{b as a}from"../chunk-6UXAINJQ.js";import"../chunk-BNX2SV7E.js";import{a as p}from"../chunk-PRVESNIO.js";import{a as n,b as o}from"../chunk-KFTXS23Q.js";import"../chunk-QRG4O4PE.js";import{a as r}from"../chunk-7WFHHPX4.js";import{a as c,b as d,c as e,d as f,e as g,j as h,k as i,l as j,m as k,n as l,o as m,q as s}from"../chunk-5J6TNMJG.js";export{f as accounts,k as apiKeys,t as auth,m as db,o as decrypt,b as discoverPlugins,n as encrypt,p as fetchCredentials,c as generateId,q as generateWorkflowMetadata,r as getErrorMessage,a as getErrorMessageAsync,h as integrations,e as sessions,d as users,g as verifications,s as withStepLogging,j as workflowExecutionLogs,i as workflowExecutions,l as workflowExecutionsRelations};

package/dist/switch-ZPVREROE.js

@@ -0,0 +1 @@
+import"./chunk-R5GS6TJS.js";import"./chunk-CYVALTSI.js";import"./chunk-IEOZJAW2.js";import"./chunk-6UXAINJQ.js";import"./chunk-BNX2SV7E.js";import"./chunk-PRVESNIO.js";import"./chunk-KFTXS23Q.js";import"./chunk-QRG4O4PE.js";import"./chunk-7WFHHPX4.js";import{q as i}from"./chunk-5J6TNMJG.js";import"server-only";function s(t){let u=[];for(let e=0;e<4;e++){let o=t[`routeName${e}`],n=t[`routeCondition${e}`],r=t[`routeCaseValue${e}`];u.push({name:o||`Route ${e+1}`,condition:n,caseValue:r})}return u}function a(t){let u=t.mode||"rules",e=s(t);if(u==="rules"){for(let o=0;o<e.length;o++)if(e[o].condition===!0)return{matchedRouteIndex:o,matchedRouteName:e[o].name,isDefault:!1}}else{let o=String(t.switchValue??"");for(let n=0;n<e.length;n++)if(e[n].caseValue!==void 0&&String(e[n].caseValue)===o)return{matchedRouteIndex:n,matchedRouteName:e[n].name,isDefault:!1}}return{matchedRouteIndex:-1,matchedRouteName:"Default",isDefault:!0}}async function c(t){"use step";return i(t,()=>Promise.resolve(a(t)))}c.maxRetries=0;export{c as switchStep};

package/drizzle.config.ts

@@ -0,0 +1,9 @@
+/** @type {import("drizzle-kit").Config} */
+export default {
+  schema: "node_modules/next-workflow-builder/src/server/db/schema.ts",
+  out: "./drizzle",
+  dialect: "postgresql",
+  dbCredentials: {
+    url: process.env.DATABASE_URL || "postgres://localhost:5432/workflow",
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-workflow-builder",
-  "version": "0.4.7",
+  "version": "0.7.0",
   "type": "module",
   "description": "Next.js plugin for Workflow Builder",
   "repository": "https://github.com/emulienfou/next-workflow-builder",
@@ -46,12 +46,37 @@
   "bin": {
     "nwb": "src/scripts/nwb.ts"
   },
+  "keywords": [
+    "nextjs",
+    "workflow",
+    "workflow-builder",
+    "react",
+    "drag-and-drop",
+    "react-flow",
+    "automation",
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "plugins",
+    "better-auth",
+    "drizzle",
+    "visual-editor",
+    "low-code",
+    "no-code"
+  ],
   "files": [
-    "dist"
+    "dist",
+    "drizzle.config.ts",
+    "src/server/db/schema.ts",
+    "src/server/lib/utils/id.ts",
+    "src/plugins/types.ts",
+    "README.md",
+    "CHANGELOG.md"
   ],
   "dependencies": {
     "@daveyplate/better-auth-ui": "^3.3.15",
     "@inquirer/prompts": "^8.0.1",
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "@monaco-editor/react": "^4.7.0",
     "@radix-ui/react-checkbox": "^1.3.3",
     "@radix-ui/react-collapsible": "^1.1.12",

package/src/plugins/types.ts

@@ -0,0 +1,31 @@
+// Integration type union - plugins + system integrations
+export type IntegrationType =
+  | "database"
+  | "loop"
+  | "switch"
+  | string;
+
+// Generic config type - plugins define their own keys via formFields[].configKey
+export type IntegrationConfig = Record<string, string | undefined>;
+
+/**
+ * Output Display Config (serializable subset for built-in types only)
+ */
+export type SerializableOutputDisplayConfig = {
+  type: "image" | "video" | "url";
+  field: string;
+};
+
+/** Analysis result type for step file parsing */
+export type StepFileAnalysis = {
+  hasExportCore: boolean;
+  integrationType: string | null;
+  coreFunction: {
+    name: string;
+    params: string;
+    returnType: string;
+    body: string;
+  } | null;
+  inputTypes: string[];
+  imports: string[];
+};

package/src/server/db/schema.ts

@@ -0,0 +1,228 @@
+import { relations } from "drizzle-orm";
+import { boolean, jsonb, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { generateId } from "../lib/utils/id";
+import type { IntegrationType } from "../../plugins/types";
+
+// Better Auth tables
+export const users = pgTable("users", {
+  id: text("id").primaryKey(),
+  name: text("name"),
+  email: text("email").unique(),
+  emailVerified: boolean("email_verified").notNull().default(false),
+  image: text("image"),
+  createdAt: timestamp("created_at").notNull(),
+  updatedAt: timestamp("updated_at").notNull(),
+  // Anonymous user tracking
+  isAnonymous: boolean("is_anonymous").default(false),
+});
+
+export const sessions = pgTable("sessions", {
+  id: text("id").primaryKey(),
+  expiresAt: timestamp("expires_at").notNull(),
+  token: text("token").notNull().unique(),
+  createdAt: timestamp("created_at").notNull(),
+  updatedAt: timestamp("updated_at").notNull(),
+  ipAddress: text("ip_address"),
+  userAgent: text("user_agent"),
+  userId: text("user_id")
+    .notNull()
+    .references(() => users.id),
+});
+
+export const accounts = pgTable("accounts", {
+  id: text("id").primaryKey(),
+  accountId: text("account_id").notNull(),
+  providerId: text("provider_id").notNull(),
+  userId: text("user_id")
+    .notNull()
+    .references(() => users.id),
+  accessToken: text("access_token"),
+  refreshToken: text("refresh_token"),
+  idToken: text("id_token"),
+  accessTokenExpiresAt: timestamp("access_token_expires_at"),
+  refreshTokenExpiresAt: timestamp("refresh_token_expires_at"),
+  scope: text("scope"),
+  password: text("password"),
+  createdAt: timestamp("created_at").notNull(),
+  updatedAt: timestamp("updated_at").notNull(),
+});
+
+export const verifications = pgTable("verifications", {
+  id: text("id").primaryKey(),
+  identifier: text("identifier").notNull(),
+  value: text("value").notNull(),
+  expiresAt: timestamp("expires_at").notNull(),
+  createdAt: timestamp("created_at"),
+  updatedAt: timestamp("updated_at"),
+});
+
+// Better Auth MCP OAuth tables
+export const oauthApplication = pgTable("oauth_application", {
+  id: text("id").primaryKey(),
+  name: text("name"),
+  icon: text("icon"),
+  metadata: text("metadata"),
+  clientId: text("client_id").notNull().unique(),
+  clientSecret: text("client_secret"),
+  redirectUrls: text("redirect_urls").notNull(),
+  type: text("type").notNull(),
+  disabled: boolean("disabled").default(false),
+  authenticationScheme: text("authentication_scheme"),
+  userId: text("user_id").references(() => users.id, { onDelete: "cascade" }),
+  createdAt: timestamp("created_at").notNull(),
+  updatedAt: timestamp("updated_at").notNull(),
+});
+
+export const oauthAccessToken = pgTable("oauth_access_token", {
+  id: text("id").primaryKey(),
+  accessToken: text("access_token").notNull().unique(),
+  refreshToken: text("refresh_token").notNull().unique(),
+  accessTokenExpiresAt: timestamp("access_token_expires_at").notNull(),
+  refreshTokenExpiresAt: timestamp("refresh_token_expires_at").notNull(),
+  clientId: text("client_id").notNull().references(() => oauthApplication.clientId, { onDelete: "cascade" }),
+  userId: text("user_id").references(() => users.id, { onDelete: "cascade" }),
+  scopes: text("scopes").notNull(),
+  createdAt: timestamp("created_at").notNull(),
+  updatedAt: timestamp("updated_at").notNull(),
+});
+
+export const oauthConsent = pgTable("oauth_consent", {
+  id: text("id").primaryKey(),
+  clientId: text("client_id").notNull().references(() => oauthApplication.clientId, { onDelete: "cascade" }),
+  userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+  scopes: text("scopes").notNull(),
+  createdAt: timestamp("created_at").notNull(),
+  updatedAt: timestamp("updated_at").notNull(),
+  consentGiven: boolean("consent_given").notNull().default(false),
+});
+
+// Workflow visibility type
+export type WorkflowVisibility = "private" | "public";
+
+// Workflows table with user association
+export const workflows = pgTable("workflows", {
+  id: text("id")
+    .primaryKey()
+    .$defaultFn(() => generateId()),
+  name: text("name").notNull(),
+  description: text("description"),
+  userId: text("user_id")
+    .notNull()
+    .references(() => users.id),
+  // biome-ignore lint/suspicious/noExplicitAny: JSONB type - structure validated at application level
+  nodes: jsonb("nodes").notNull().$type<any[]>(),
+  // biome-ignore lint/suspicious/noExplicitAny: JSONB type - structure validated at application level
+  edges: jsonb("edges").notNull().$type<any[]>(),
+  visibility: text("visibility")
+    .notNull()
+    .default("private")
+    .$type<WorkflowVisibility>(),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+  updatedAt: timestamp("updated_at").notNull().defaultNow(),
+});
+
+// Integrations table for storing user credentials
+export const integrations = pgTable("integrations", {
+  id: text("id")
+    .primaryKey()
+    .$defaultFn(() => generateId()),
+  userId: text("user_id")
+    .notNull()
+    .references(() => users.id),
+  name: text("name").notNull(),
+  type: text("type").notNull().$type<IntegrationType>(),
+  // biome-ignore lint/suspicious/noExplicitAny: JSONB type - encrypted credentials stored as JSON
+  config: jsonb("config").notNull().$type<any>(),
+  // Whether this integration was created via OAuth (managed by app) vs manual entry
+  isManaged: boolean("is_managed").default(false),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+  updatedAt: timestamp("updated_at").notNull().defaultNow(),
+});
+
+// Workflow executions table to track workflow runs
+export const workflowExecutions = pgTable("workflow_executions", {
+  id: text("id")
+    .primaryKey()
+    .$defaultFn(() => generateId()),
+  workflowId: text("workflow_id")
+    .notNull()
+    .references(() => workflows.id),
+  userId: text("user_id")
+    .notNull()
+    .references(() => users.id),
+  status: text("status")
+    .notNull()
+    .$type<"pending" | "running" | "success" | "error" | "cancelled">(),
+  // biome-ignore lint/suspicious/noExplicitAny: JSONB type - structure validated at application level
+  input: jsonb("input").$type<Record<string, any>>(),
+  // biome-ignore lint/suspicious/noExplicitAny: JSONB type - structure validated at application level
+  output: jsonb("output").$type<any>(),
+  error: text("error"),
+  startedAt: timestamp("started_at").notNull().defaultNow(),
+  completedAt: timestamp("completed_at"),
+  duration: text("duration"), // Duration in milliseconds
+});
+
+// Workflow execution logs to track individual node executions
+export const workflowExecutionLogs = pgTable("workflow_execution_logs", {
+  id: text("id")
+    .primaryKey()
+    .$defaultFn(() => generateId()),
+  executionId: text("execution_id")
+    .notNull()
+    .references(() => workflowExecutions.id),
+  nodeId: text("node_id").notNull(),
+  nodeName: text("node_name").notNull(),
+  nodeType: text("node_type").notNull(),
+  status: text("status")
+    .notNull()
+    .$type<"pending" | "running" | "success" | "error">(),
+  // biome-ignore lint/suspicious/noExplicitAny: JSONB type - structure validated at application level
+  input: jsonb("input").$type<any>(),
+  // biome-ignore lint/suspicious/noExplicitAny: JSONB type - structure validated at application level
+  output: jsonb("output").$type<any>(),
+  error: text("error"),
+  startedAt: timestamp("started_at").notNull().defaultNow(),
+  completedAt: timestamp("completed_at"),
+  duration: text("duration"), // Duration in milliseconds
+  timestamp: timestamp("timestamp").notNull().defaultNow(),
+});
+
+// API Keys table for webhook authentication
+export const apiKeys = pgTable("api_keys", {
+  id: text("id")
+    .primaryKey()
+    .$defaultFn(() => generateId()),
+  userId: text("user_id")
+    .notNull()
+    .references(() => users.id),
+  name: text("name"), // Optional label for the API key
+  keyHash: text("key_hash").notNull(), // Store hashed version of the key
+  keyPrefix: text("key_prefix").notNull(), // Store first few chars for display (e.g., "wf_abc...")
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+  lastUsedAt: timestamp("last_used_at"),
+});
+
+// Relations
+export const workflowExecutionsRelations = relations(
+  workflowExecutions,
+  ({ one }) => ({
+    workflow: one(workflows, {
+      fields: [workflowExecutions.workflowId],
+      references: [workflows.id],
+    }),
+  }),
+);
+
+export type User = typeof users.$inferSelect;
+export type Session = typeof sessions.$inferSelect;
+export type Workflow = typeof workflows.$inferSelect;
+export type NewWorkflow = typeof workflows.$inferInsert;
+export type Integration = typeof integrations.$inferSelect;
+export type NewIntegration = typeof integrations.$inferInsert;
+export type WorkflowExecution = typeof workflowExecutions.$inferSelect;
+export type NewWorkflowExecution = typeof workflowExecutions.$inferInsert;
+export type WorkflowExecutionLog = typeof workflowExecutionLogs.$inferSelect;
+export type NewWorkflowExecutionLog = typeof workflowExecutionLogs.$inferInsert;
+export type ApiKey = typeof apiKeys.$inferSelect;
+export type NewApiKey = typeof apiKeys.$inferInsert;

package/src/server/lib/utils/id.ts

@@ -0,0 +1,26 @@
+import { webcrypto } from "node:crypto";
+
+const ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
+const ID_LENGTH = 21;
+
+/**
+ * Generate a random ID string of the specified length.
+ * Similar to nanoid package
+ */
+export function generateId(): string {
+  const mask = 63; // smallest bitmask >= 35 (2^6 - 1)
+  const bytes = webcrypto.getRandomValues(new Uint8Array(ID_LENGTH * 2)); // extra bytes for rejections
+  let id = "";
+  let cursor = 0;
+  while (id.length < ID_LENGTH) {
+    const val = bytes[cursor++] & mask;
+    if (val < ALPHABET.length) {
+      id += ALPHABET[val];
+    }
+    if (cursor >= bytes.length) {
+      webcrypto.getRandomValues(bytes);
+      cursor = 0;
+    }
+  }
+  return id;
+}

package/dist/chunk-3XFDIK7H.js

@@ -1,251 +0,0 @@
-// src/plugins/index.ts
-var integrationRegistry = /* @__PURE__ */ new Map();
-var codegenTemplateRegistry = /* @__PURE__ */ new Map();
-var outputDisplayConfigRegistry = /* @__PURE__ */ new Map();
-function registerCodegenTemplates(templates) {
-  for (const [actionId, template] of Object.entries(templates)) {
-    codegenTemplateRegistry.set(actionId, template);
-  }
-}
-function getCodegenTemplate(actionId) {
-  return codegenTemplateRegistry.get(actionId);
-}
-function registerOutputDisplayConfigs(configs) {
-  for (const [actionId, config] of Object.entries(configs)) {
-    outputDisplayConfigRegistry.set(actionId, config);
-  }
-}
-function getOutputDisplayConfig(actionId) {
-  return outputDisplayConfigRegistry.get(actionId);
-}
-function computeActionId(integrationType, actionSlug) {
-  return `${integrationType}/${actionSlug}`;
-}
-function parseActionId(actionId) {
-  if (!actionId || typeof actionId !== "string") {
-    return null;
-  }
-  const parts = actionId.split("/");
-  if (parts.length !== 2) {
-    return null;
-  }
-  return { integration: parts[0], slug: parts[1] };
-}
-function registerIntegration(plugin) {
-  integrationRegistry.set(plugin.type, plugin);
-}
-function getIntegration(type) {
-  return integrationRegistry.get(type);
-}
-function getAllIntegrations() {
-  return Array.from(integrationRegistry.values());
-}
-function getIntegrationTypes() {
-  return Array.from(integrationRegistry.keys());
-}
-function getAllActions() {
-  const actions = [];
-  for (const plugin of integrationRegistry.values()) {
-    for (const action of plugin.actions) {
-      actions.push({
-        ...action,
-        id: computeActionId(plugin.type, action.slug),
-        integration: plugin.type
-      });
-    }
-  }
-  return actions;
-}
-function getActionsByCategory() {
-  const categories = {};
-  for (const plugin of integrationRegistry.values()) {
-    for (const action of plugin.actions) {
-      if (!categories[action.category]) {
-        categories[action.category] = [];
-      }
-      categories[action.category].push({
-        ...action,
-        id: computeActionId(plugin.type, action.slug),
-        integration: plugin.type
-      });
-    }
-  }
-  return categories;
-}
-function findActionById(actionId) {
-  if (!actionId) {
-    return void 0;
-  }
-  const parsed = parseActionId(actionId);
-  if (parsed) {
-    const plugin = integrationRegistry.get(parsed.integration);
-    if (plugin) {
-      const action = plugin.actions.find((a) => a.slug === parsed.slug);
-      if (action) {
-        return {
-          ...action,
-          id: actionId,
-          integration: plugin.type
-        };
-      }
-    }
-  }
-  for (const plugin of integrationRegistry.values()) {
-    const action = plugin.actions.find((a) => a.label === actionId);
-    if (action) {
-      return {
-        ...action,
-        id: computeActionId(plugin.type, action.slug),
-        integration: plugin.type
-      };
-    }
-  }
-  return void 0;
-}
-function getIntegrationLabels() {
-  const labels = {};
-  for (const plugin of integrationRegistry.values()) {
-    labels[plugin.type] = plugin.label;
-  }
-  return labels;
-}
-function getIntegrationDescriptions() {
-  const descriptions = {};
-  for (const plugin of integrationRegistry.values()) {
-    descriptions[plugin.type] = plugin.description;
-  }
-  return descriptions;
-}
-function getSortedIntegrationTypes() {
-  return Array.from(integrationRegistry.keys()).sort();
-}
-function getAllDependencies() {
-  const deps = {};
-  for (const plugin of integrationRegistry.values()) {
-    if (plugin.dependencies) {
-      Object.assign(deps, plugin.dependencies);
-    }
-  }
-  return deps;
-}
-function getDependenciesForActions(actionIds) {
-  const deps = {};
-  const integrations = /* @__PURE__ */ new Set();
-  for (const actionId of actionIds) {
-    const action = findActionById(actionId);
-    if (action) {
-      integrations.add(action.integration);
-    }
-  }
-  for (const integrationType of integrations) {
-    const plugin = integrationRegistry.get(integrationType);
-    if (plugin?.dependencies) {
-      Object.assign(deps, plugin.dependencies);
-    }
-  }
-  return deps;
-}
-function getPluginEnvVars(plugin) {
-  const envVars = [];
-  for (const field of plugin.formFields) {
-    if (field.envVar) {
-      envVars.push({
-        name: field.envVar,
-        description: field.helpText || field.label
-      });
-    }
-  }
-  return envVars;
-}
-function getAllEnvVars() {
-  const envVars = [];
-  for (const plugin of integrationRegistry.values()) {
-    envVars.push(...getPluginEnvVars(plugin));
-  }
-  return envVars;
-}
-function getCredentialMapping(plugin, config) {
-  const creds = {};
-  for (const field of plugin.formFields) {
-    if (field.envVar && config[field.configKey]) {
-      creds[field.envVar] = String(config[field.configKey]);
-    }
-  }
-  return creds;
-}
-function isFieldGroup(field) {
-  return field.type === "group";
-}
-function flattenConfigFields(fields) {
-  const result = [];
-  for (const field of fields) {
-    if (isFieldGroup(field)) {
-      result.push(...field.fields);
-    } else {
-      result.push(field);
-    }
-  }
-  return result;
-}
-function generateAIActionPrompts() {
-  const lines = [];
-  for (const plugin of integrationRegistry.values()) {
-    for (const action of plugin.actions) {
-      const fullId = computeActionId(plugin.type, action.slug);
-      const exampleConfig = {
-        actionType: fullId
-      };
-      const flatFields = flattenConfigFields(action.configFields);
-      for (const field of flatFields) {
-        if (field.showWhen) continue;
-        if (field.example !== void 0) {
-          exampleConfig[field.key] = field.example;
-        } else if (field.defaultValue !== void 0) {
-          exampleConfig[field.key] = field.defaultValue;
-        } else if (field.type === "number") {
-          exampleConfig[field.key] = 10;
-        } else if (field.type === "select" && field.options?.[0]) {
-          exampleConfig[field.key] = field.options[0].value;
-        } else {
-          exampleConfig[field.key] = `Your ${field.label.toLowerCase()}`;
-        }
-      }
-      lines.push(
-        `- ${action.label} (${fullId}): ${JSON.stringify(exampleConfig)}`
-      );
-    }
-  }
-  return lines.join("\n");
-}
-function integrationRequiresCredentials(type) {
-  const plugin = integrationRegistry.get(type);
-  return !!plugin && plugin.formFields.length > 0;
-}
-
-export {
-  registerCodegenTemplates,
-  getCodegenTemplate,
-  registerOutputDisplayConfigs,
-  getOutputDisplayConfig,
-  computeActionId,
-  parseActionId,
-  registerIntegration,
-  getIntegration,
-  getAllIntegrations,
-  getIntegrationTypes,
-  getAllActions,
-  getActionsByCategory,
-  findActionById,
-  getIntegrationLabels,
-  getIntegrationDescriptions,
-  getSortedIntegrationTypes,
-  getAllDependencies,
-  getDependenciesForActions,
-  getPluginEnvVars,
-  getAllEnvVars,
-  getCredentialMapping,
-  isFieldGroup,
-  flattenConfigFields,
-  generateAIActionPrompts,
-  integrationRequiresCredentials
-};