@invect/core 0.0.1

package/dist/invect-core.js

@@ -0,0 +1,1688 @@
+import { DatabaseError, ValidationError } from "./types/common/errors.types.js";
+import { FlowRunStatus, NodeExecutionStatus } from "./types/base.js";
+import { BatchProvider } from "./services/ai/ai-types.js";
+import "./services/ai/base-client.js";
+import { GraphNodeType } from "./types/graph-node-types.js";
+import "./types-fresh.js";
+import { detectProviderFromCredential } from "./utils/provider-detection.js";
+import { getTemplateService } from "./services/templating/template.service.js";
+import { JsExpressionService } from "./services/templating/js-expression.service.js";
+import { initializeGlobalActionRegistry } from "./actions/action-registry.js";
+import { createToolExecutorForAction } from "./actions/action-executor.js";
+import { LoggerManager } from "./utils/logger.js";
+import { QueryOptionsSchema } from "./types/schemas/pagination-sort-filter.js";
+import { createFlowVersionRequestSchema, invectDefinitionSchema } from "./services/flow-versions/schemas-fresh.js";
+import { createFlowRequestSchema } from "./types/schemas/flow/create-flow.schema.js";
+import { FlowIdParamsSchema } from "./types/schemas/flow/flow-executions.schema.js";
+import { InvectConfigSchema } from "./types/schemas-fresh/invect-config.js";
+import "./types/schemas/index.js";
+import { ServiceFactory } from "./services/service-factory.js";
+import { getGlobalToolRegistry, initializeGlobalToolRegistry } from "./services/agent-tools/agent-tool-registry.js";
+import { DefaultNodeRegistryFactory } from "./nodes/executor-registry.js";
+import { FlowValidator } from "./services/flow-validator.js";
+import "./services/templating/index.js";
+import "./services/agent-tools/index.js";
+import { PluginManager } from "./services/plugin-manager.js";
+import { registerBuiltinActions } from "./actions/index.js";
+import { createAuthorizationService } from "./services/auth/authorization.service.js";
+//#region src/invect-core.ts
+function createPluginDatabaseApi(connection) {
+	const normalizeSql = (statement) => {
+		if (connection.type !== "postgresql") return statement;
+		let index = 0;
+		return statement.replace(/\?/g, () => `$${++index}`);
+	};
+	const query = async (statement, params = []) => {
+		switch (connection.type) {
+			case "postgresql": return connection.db.$client.unsafe(normalizeSql(statement), params);
+			case "sqlite": return connection.db.$client.prepare(statement).all(...params);
+			case "mysql": {
+				const [rows] = await connection.db.$client.execute(statement, params);
+				return Array.isArray(rows) ? rows : [];
+			}
+		}
+	};
+	return {
+		type: connection.type,
+		query,
+		async execute(statement, params = []) {
+			switch (connection.type) {
+				case "postgresql":
+					await connection.db.$client.unsafe(normalizeSql(statement), params);
+					return;
+				case "sqlite": {
+					const client = connection.db.$client;
+					const coerced = params.map((param) => typeof param === "boolean" ? param ? 1 : 0 : param);
+					client.prepare(statement).run(...coerced);
+					return;
+				}
+				case "mysql":
+					await connection.db.$client.execute(statement, params);
+					return;
+			}
+		}
+	};
+}
+GraphNodeType.GMAIL;
+/**
+* Main Invect Core class
+*
+* Provides a high-level API for flow operations with comprehensive lifecycle management.
+* This class orchestrates all flow-related operations including:
+* - Flow and flow version management
+* - Flow execution and monitoring
+* - Node execution tracking
+* - AI batch operations
+* - Testing and development utilities
+*
+* @example
+* ```typescript
+* const invect = new Invect(config);
+* await invect.initialize();
+*
+* const flow = await invect.createFlow({ name: "My Flow", description: "..." });
+* const result = await invect.startFlowRun(flow.id, inputs);
+*
+* await invect.shutdown();
+* ```
+*/
+var Invect = class {
+	serviceFactory = null;
+	nodeRegistry = null;
+	actionRegistry = null;
+	jsExpressionService = null;
+	templateService = null;
+	pluginManager;
+	initialized = false;
+	loggerManager;
+	authService;
+	/**
+	* Creates a new Invect instance
+	*
+	* @param config - Invect configuration object
+	*/
+	constructor(config) {
+		this.config = config;
+		this.config = InvectConfigSchema.parse(config);
+		this.loggerManager = new LoggerManager({
+			level: this.config.logging?.level || "info",
+			scopes: this.config.logging?.scopes
+		});
+		this.config.logger = this.loggerManager.getBasicLogger();
+		this.authService = createAuthorizationService({
+			config: this.config.auth,
+			logger: this.config.logger
+		});
+		this.pluginManager = new PluginManager(this.config.plugins ?? []);
+	}
+	/**
+	* Authorize an action for an identity.
+	*
+	* This is the main entry point for authorization checks. Framework adapters
+	* (Express, NestJS, Next.js) should call this method to check permissions.
+	*
+	* @param context - Authorization context with identity, action, and optional resource
+	* @returns Authorization result with allowed flag and optional reason
+	*
+	* @example
+	* ```typescript
+	* const result = await invect.authorize({
+	*   identity: { id: 'user_123', role: 'editor' },
+	*   action: 'flow:create',
+	* });
+	*
+	* if (!result.allowed) {
+	*   throw new ForbiddenError(result.reason);
+	* }
+	* ```
+	*/
+	async authorize(context) {
+		const hookResult = await this.pluginManager.runOnAuthorize({
+			...context,
+			database: this.serviceFactory ? createPluginDatabaseApi(this.serviceFactory.getDatabaseService().getConnection()) : void 0
+		});
+		if (hookResult) return hookResult;
+		return this.authService.authorize(context);
+	}
+	/**
+	* Check if a specific identity has a permission.
+	* Convenience method that wraps authorize().
+	*/
+	hasPermission(identity, permission) {
+		return this.authService.hasPermission(identity, permission);
+	}
+	/**
+	* Get all permissions for an identity.
+	*/
+	getPermissions(identity) {
+		return this.authService.getPermissions(identity);
+	}
+	/**
+	* Check if a plugin is registered by ID.
+	*/
+	hasPlugin(pluginId) {
+		return this.pluginManager.hasPlugin(pluginId);
+	}
+	/**
+	* Get a registered plugin by ID.
+	*/
+	getPlugin(pluginId) {
+		return this.pluginManager.getPlugin(pluginId);
+	}
+	/**
+	* Get all registered plugins.
+	*/
+	getPlugins() {
+		return this.pluginManager.getPlugins();
+	}
+	/**
+	* Get all plugin-defined API endpoints.
+	* Framework adapters use this to mount plugin routes.
+	*/
+	getPluginEndpoints() {
+		return this.pluginManager.getPluginEndpoints();
+	}
+	/**
+	* Get the plugin hook runner for framework adapters.
+	* Used to run onRequest/onResponse/onAuthorize hooks.
+	*/
+	getPluginHookRunner() {
+		return this.pluginManager;
+	}
+	/**
+	* Get the initialized host database connection.
+	* Framework adapters use this to expose a narrow database API to plugins.
+	*/
+	getDatabaseConnection() {
+		if (!this.serviceFactory) throw new Error("ServiceFactory not initialized");
+		return this.serviceFactory.getDatabaseService().getConnection();
+	}
+	/**
+	* Check if authentication is enabled.
+	*/
+	isAuthEnabled() {
+		return this.authService.isEnabled();
+	}
+	/**
+	* Check if a route is public (no auth required).
+	*/
+	isPublicRoute(path) {
+		return this.authService.isPublicRoute(path);
+	}
+	/**
+	* Get the authorization service for advanced use cases.
+	* The service extends EventEmitter and emits auth events.
+	*/
+	getAuthService() {
+		return this.authService;
+	}
+	/**
+	* Get available roles and their permissions.
+	* Useful for admin UIs to show role options.
+	*/
+	getAvailableRoles() {
+		return this.authService.getAvailableRoles();
+	}
+	/**
+	* Subscribe to auth events for audit logging.
+	*
+	* @example
+	* ```typescript
+	* invect.onAuthEvent('auth:forbidden', (event) => {
+	*   auditLogger.warn('Access denied', event);
+	* });
+	* ```
+	*/
+	onAuthEvent(event, listener) {
+		this.authService.on(event, listener);
+	}
+	/**
+	* Check if flow access table is enabled.
+	*/
+	isFlowAccessTableEnabled() {
+		return !!this.config.auth?.useFlowAccessTable;
+	}
+	/**
+	* Grant access to a flow for a user or team.
+	* Requires useFlowAccessTable: true in config.
+	*
+	* @example
+	* ```typescript
+	* // Grant editor access to a user
+	* await invect.grantFlowAccess({
+	*   flowId: 'flow_123',
+	*   userId: 'user_456',
+	*   permission: 'editor',
+	*   grantedBy: currentUser.id,
+	* });
+	*
+	* // Grant viewer access to a team
+	* await invect.grantFlowAccess({
+	*   flowId: 'flow_123',
+	*   teamId: 'team_abc',
+	*   permission: 'viewer',
+	* });
+	* ```
+	*/
+	async grantFlowAccess(input) {
+		this.ensureInitialized();
+		const flowAccessService = this.serviceFactory.getFlowAccessService();
+		if (!flowAccessService) throw new Error("Flow access table not enabled. Set auth.useFlowAccessTable: true in config.");
+		return flowAccessService.grantAccess(input);
+	}
+	/**
+	* Revoke a specific flow access record.
+	* Requires useFlowAccessTable: true in config.
+	*/
+	async revokeFlowAccess(accessId) {
+		this.ensureInitialized();
+		const flowAccessService = this.serviceFactory.getFlowAccessService();
+		if (!flowAccessService) throw new Error("Flow access table not enabled. Set auth.useFlowAccessTable: true in config.");
+		return flowAccessService.revokeAccess(accessId);
+	}
+	/**
+	* Revoke all access to a flow for a specific user or team.
+	* Requires useFlowAccessTable: true in config.
+	*/
+	async revokeFlowAccessForUserOrTeam(flowId, userId, teamId) {
+		this.ensureInitialized();
+		const flowAccessService = this.serviceFactory.getFlowAccessService();
+		if (!flowAccessService) throw new Error("Flow access table not enabled. Set auth.useFlowAccessTable: true in config.");
+		return flowAccessService.revokeAccessForUserOrTeam(flowId, userId, teamId);
+	}
+	/**
+	* List all access records for a flow.
+	* Requires useFlowAccessTable: true in config.
+	*/
+	async listFlowAccess(flowId) {
+		this.ensureInitialized();
+		const flowAccessService = this.serviceFactory.getFlowAccessService();
+		if (!flowAccessService) throw new Error("Flow access table not enabled. Set auth.useFlowAccessTable: true in config.");
+		return flowAccessService.listFlowAccess(flowId);
+	}
+	/**
+	* Get all flows a user has access to (directly or via teams).
+	* Requires useFlowAccessTable: true in config.
+	*/
+	async getAccessibleFlowIds(userId, teamIds = []) {
+		this.ensureInitialized();
+		const flowAccessService = this.serviceFactory.getFlowAccessService();
+		if (!flowAccessService) throw new Error("Flow access table not enabled. Set auth.useFlowAccessTable: true in config.");
+		return flowAccessService.getAccessibleFlowIds(userId, teamIds);
+	}
+	/**
+	* Check if a user has access to a flow with at least the required permission.
+	* Requires useFlowAccessTable: true in config.
+	*/
+	async hasFlowAccess(flowId, userId, teamIds = [], requiredPermission = "viewer") {
+		this.ensureInitialized();
+		const flowAccessService = this.serviceFactory.getFlowAccessService();
+		if (!flowAccessService) throw new Error("Flow access table not enabled. Set auth.useFlowAccessTable: true in config.");
+		return flowAccessService.hasFlowAccess(flowId, userId, teamIds, requiredPermission);
+	}
+	/**
+	* Get the highest permission level a user has for a flow.
+	* Requires useFlowAccessTable: true in config.
+	*/
+	async getFlowPermission(flowId, userId, teamIds = []) {
+		this.ensureInitialized();
+		const flowAccessService = this.serviceFactory.getFlowAccessService();
+		if (!flowAccessService) throw new Error("Flow access table not enabled. Set auth.useFlowAccessTable: true in config.");
+		return flowAccessService.getFlowPermission(flowId, userId, teamIds);
+	}
+	/**
+	* Get a scoped logger for a specific feature area.
+	*
+	* Scoped loggers have independent log levels that can be configured
+	* per scope via the logging.scopes configuration.
+	*
+	* @param scope - The scope/feature area (use LogScope constants)
+	* @param context - Optional additional context (e.g., class name)
+	* @returns A ScopedLogger instance
+	*
+	* @example
+	* ```typescript
+	* const logger = invect.getLogger('execution', 'MyService');
+	* logger.debug('Starting execution'); // Only logs if execution scope is 'debug'
+	* ```
+	*/
+	getLogger(scope, context) {
+		return this.loggerManager.getLogger(scope, context);
+	}
+	/**
+	* Get the logger manager for advanced logging configuration
+	*/
+	getLoggerManager() {
+		return this.loggerManager;
+	}
+	/**
+	* Update the log level for a specific scope at runtime
+	*
+	* @example
+	* ```typescript
+	* // Enable debug logging for execution during troubleshooting
+	* invect.setLogLevel('execution', 'debug');
+	* ```
+	*/
+	setLogLevel(scope, level) {
+		this.loggerManager.setLogLevel(scope, level);
+	}
+	/**
+	* Initialize Invect Core
+	*/
+	async initialize() {
+		if (this.initialized) {
+			this.config.logger.debug("Invect Core already initialized");
+			return;
+		}
+		if (this.isBuildTime()) {
+			this.config.logger.info("Skipping Invect Core initialization during build time");
+			throw new DatabaseError("Invect Core initialization skipped during build", {
+				reason: "build_time_skip",
+				phase: process.env.NEXT_PHASE || "unknown"
+			});
+		}
+		this.config.logger.info("Initializing Invect Core...");
+		try {
+			this.actionRegistry = initializeGlobalActionRegistry(this.config.logger);
+			registerBuiltinActions(this.actionRegistry);
+			this.config.logger.info(`Registered ${this.actionRegistry.size} built-in actions from ${this.actionRegistry.getProviders().length} providers`);
+			const actionRegistry = this.actionRegistry;
+			await this.pluginManager.initializePlugins({
+				config: this.config,
+				logger: this.config.logger,
+				registerAction: (action) => {
+					actionRegistry.register(action);
+				}
+			});
+			if (this.pluginManager.getPlugins().length > 0) this.config.logger.info(`Initialized ${this.pluginManager.getPlugins().length} plugin(s): ${this.pluginManager.getPlugins().map((p) => p.id).join(", ")}`);
+			this.nodeRegistry = await this.initializeNodes();
+			try {
+				this.jsExpressionService = new JsExpressionService({}, this.config.logger);
+				await this.jsExpressionService.initialize();
+				this.templateService = getTemplateService(this.jsExpressionService, this.config.logger);
+				this.config.logger.debug("JS expression engine + template service initialized");
+			} catch (error) {
+				this.jsExpressionService = null;
+				this.templateService = null;
+				this.config.logger.warn("JS expression engine unavailable; continuing without data mapper and template expression support", { error: error instanceof Error ? error.stack ?? error.message : String(error) });
+			}
+			this.registerActionsAsTools();
+			await this.initializeServices(this.nodeRegistry);
+			this.initialized = true;
+			if (this.config.defaultCredentials?.length) this.ensureDefaultCredentials().catch((err) => {
+				this.config.logger.error("Default credential seeding failed", err);
+			});
+		} catch (error) {
+			if (error instanceof DatabaseError) throw error;
+			this.config.logger.error("Failed to initialize Invect Core", error);
+			throw new DatabaseError("Invect Core initialization failed", { error });
+		}
+	}
+	/**
+	* Check if we're in a build-time environment where database connections should be avoided
+	*/
+	isBuildTime() {
+		if (process.env.NEXT_PHASE === "phase-production-build") return true;
+		if (process.env.VERCEL_ENV && process.env.CI) return true;
+		if (process.env.CI && (process.env.NODE_ENV === "production" || process.env.BUILD_PHASE || process.argv.includes("build"))) return true;
+		return false;
+	}
+	/**
+	* Gracefully shutdown Invect Core.
+	* Marks any in-progress flow runs as FAILED before closing services.
+	*/
+	async shutdown() {
+		this.config.logger.info("Shutting down Invect Core...");
+		try {
+			if (this.serviceFactory?.isInitialized()) try {
+				const failedCount = await this.serviceFactory.getFlowRunsService().failStaleRuns(0);
+				if (failedCount > 0) this.config.logger.warn(`Graceful shutdown: marked ${failedCount} in-progress flow run(s) as FAILED`);
+			} catch (error) {
+				this.config.logger.error("Failed to mark in-progress runs during shutdown", error);
+			}
+			await this.pluginManager.shutdownPlugins(this.config.logger);
+			if (this.serviceFactory) {
+				await this.serviceFactory.close();
+				this.serviceFactory = null;
+			}
+			this.nodeRegistry = null;
+			this.actionRegistry = null;
+			if (this.jsExpressionService) {
+				this.jsExpressionService.dispose();
+				this.jsExpressionService = null;
+			}
+			this.templateService = null;
+			this.initialized = false;
+			this.config.logger.info("Invect Core shutdown completed");
+		} catch (error) {
+			this.config.logger.error("Error during Invect Core shutdown", error);
+			throw new DatabaseError("Invect Core shutdown failed", { error });
+		}
+	}
+	/**
+	* Check if core is initialized
+	*/
+	isInitialized() {
+		return this.initialized;
+	}
+	/**
+	* Run health check on all services
+	*/
+	async healthCheck() {
+		this.ensureInitialized();
+		return (await this.serviceFactory.healthCheck()).services;
+	}
+	/**
+	* Create a new flow
+	*/
+	async createFlow(flowData) {
+		this.config.logger.debug("createFlow called with arguments:", JSON.stringify(flowData, null, 2));
+		const data = createFlowRequestSchema.parse(flowData);
+		return this.flowService.createFlow(data);
+	}
+	/**
+	* Get all flows with optional filtering, sorting, and pagination
+	*/
+	async listFlows(options) {
+		this.config.logger.debug("listFlows called with arguments:", JSON.stringify(options, null, 2));
+		if (options) QueryOptionsSchema.parse(options);
+		return await this.flowService.listFlows(options);
+	}
+	/**
+	* Get flow by ID
+	*/
+	async getFlow(flowId) {
+		this.config.logger.debug("getFlow called with arguments:", JSON.stringify({ flowId }, null, 2));
+		const validatedParams = FlowIdParamsSchema.parse({ flowId });
+		return this.flowService.getFlowById(validatedParams.flowId);
+	}
+	/**
+	* Update an existing flow
+	*/
+	async updateFlow(flowId, updateData) {
+		this.config.logger.debug("updateFlow called with arguments:", JSON.stringify({
+			flowId,
+			updateData
+		}, null, 2));
+		const validatedParams = FlowIdParamsSchema.parse({ flowId });
+		return this.flowService.updateFlow(validatedParams.flowId, updateData);
+	}
+	/**
+	* Delete a flow
+	*/
+	async deleteFlow(flowId) {
+		this.config.logger.debug("deleteFlow called with arguments:", JSON.stringify({ flowId }, null, 2));
+		const validatedParams = FlowIdParamsSchema.parse({ flowId });
+		return this.flowService.deleteFlow(validatedParams.flowId);
+	}
+	/**
+	* Validate flow definition
+	*/
+	async validateFlowDefinition(flowId, flowDefinition) {
+		this.config.logger.debug("validateFlowDefinition called with arguments:", JSON.stringify({
+			flowId,
+			flowDefinition
+		}, null, 2));
+		this.ensureInitialized();
+		const validatedParams = FlowIdParamsSchema.parse({ flowId });
+		const typedDefinition = invectDefinitionSchema.parse(flowDefinition);
+		this.config.logger.debug("Validating flow definition", { flowId: validatedParams.flowId });
+		try {
+			const validationResult = FlowValidator.validateFlowDefinition(typedDefinition);
+			this.config.logger.debug("Flow validation completed", validationResult);
+			return validationResult;
+		} catch (error) {
+			this.config.logger.error("Flow validation failed", {
+				flowId: validatedParams.flowId,
+				error
+			});
+			throw error;
+		}
+	}
+	/**
+	* Create flow version and sync trigger registrations (D3: sync on publish)
+	*/
+	async createFlowVersion(flowId, versionData) {
+		this.config.logger.debug("createFlowVersion called with arguments:", JSON.stringify({
+			flowId,
+			versionData
+		}, null, 2));
+		const validatedParams = FlowIdParamsSchema.parse({ flowId });
+		const data = createFlowVersionRequestSchema.parse(versionData);
+		const version = await this.flowVersionsService.createFlowVersion(validatedParams.flowId, data);
+		try {
+			if (data.invectDefinition?.nodes) {
+				await this.triggersService.syncTriggersForFlow(validatedParams.flowId, data.invectDefinition);
+				this.config.logger.debug("Trigger registrations synced after version creation", {
+					flowId: validatedParams.flowId,
+					versionNumber: version.version
+				});
+			}
+		} catch (error) {
+			this.config.logger.error("Failed to sync triggers after version creation", {
+				flowId: validatedParams.flowId,
+				error
+			});
+		}
+		return version;
+	}
+	/**
+	* Get flow versions with optional filtering, sorting, and pagination
+	*/
+	async listFlowVersions(flowId, options) {
+		this.config.logger.debug("listFlowVersions called with arguments:", JSON.stringify({
+			flowId,
+			options
+		}, null, 2));
+		const validatedParams = FlowIdParamsSchema.parse({ flowId });
+		return await this.flowVersionsService.listFlowVersionsByFlowId(validatedParams.flowId, options);
+	}
+	/**
+	* Get specific flow version by version number or 'latest'
+	*/
+	async getFlowVersion(flowId, version) {
+		this.config.logger.debug("getFlowVersion called with arguments:", JSON.stringify({
+			flowId,
+			version
+		}, null, 2));
+		const validatedParams = FlowIdParamsSchema.parse({ flowId });
+		return await this.flowVersionsService.getFlowVersion(validatedParams.flowId, version);
+	}
+	/**
+	* Execute a flow (synchronous - waits for completion)
+	*/
+	async startFlowRun(flowId, inputs = {}, options) {
+		this.config.logger.debug("startFlowRun called with arguments:", JSON.stringify({
+			flowId,
+			inputs,
+			options
+		}, null, 2));
+		return this.orchestrationService.executeFlow(flowId, inputs, options);
+	}
+	/**
+	* Start a flow execution asynchronously - returns immediately with flow run ID.
+	* The flow executes in the background. Use this for UI-initiated runs where
+	* you want to redirect the user immediately without waiting for completion.
+	*/
+	async startFlowRunAsync(flowId, inputs = {}, options) {
+		this.config.logger.debug("startFlowRunAsync called with arguments:", JSON.stringify({
+			flowId,
+			inputs,
+			options
+		}, null, 2));
+		return this.orchestrationService.executeFlowAsync(flowId, inputs, options);
+	}
+	/**
+	* Execute a flow up to a specific target node.
+	* Only executes the upstream nodes required to produce output for the target node.
+	* This is useful for testing a specific node with its real upstream dependencies.
+	*
+	* @param flowId - The flow to execute
+	* @param targetNodeId - The node to execute up to (this node will also be executed)
+	* @param inputs - Flow-level inputs
+	* @param options - Execution options (version, batch processing, etc.)
+	* @returns The flow run result with the target node's output
+	*/
+	async executeFlowToNode(flowId, targetNodeId, inputs = {}, options) {
+		this.config.logger.debug("executeFlowToNode called with arguments:", JSON.stringify({
+			flowId,
+			targetNodeId,
+			inputs,
+			options
+		}, null, 2));
+		return this.orchestrationService.executeFlowToNode(flowId, targetNodeId, inputs, options);
+	}
+	/**
+	* Resume execution
+	*/
+	async resumeExecution(executionId) {
+		this.config.logger.debug("resumeExecution called with arguments:", JSON.stringify({ executionId }, null, 2));
+		return this.flowRunsService.resumeRun(executionId);
+	}
+	/**
+	* Get all Flow Runs
+	*/
+	async listFlowRuns(options) {
+		this.config.logger.debug("listFlowRuns called with arguments:", JSON.stringify(options, null, 2));
+		return await this.flowRunsService.listRuns(options);
+	}
+	/**
+	* Get flow executions for a specific flow
+	*/
+	async listFlowRunsByFlowId(flowId) {
+		this.config.logger.debug("listFlowRunsByFlowId called with arguments:", JSON.stringify({ flowId }, null, 2));
+		const validatedParams = FlowIdParamsSchema.parse({ flowId });
+		return this.flowRunsService.listRuns({ filter: { flowId: [validatedParams.flowId] } });
+	}
+	/**
+	* Get a specific flow run by ID
+	*/
+	async getFlowRunById(flowRunId) {
+		this.config.logger.debug("getFlowRunById called with arguments:", JSON.stringify({ flowRunId }, null, 2));
+		return this.flowRunsService.getRunById(flowRunId);
+	}
+	/**
+	* Cancel a flow run
+	*/
+	async cancelFlowRun(flowRunId) {
+		this.config.logger.debug("cancelFlowRun called with arguments:", JSON.stringify({ flowRunId }, null, 2));
+		return this.flowRunsService.cancelRun(flowRunId);
+	}
+	/**
+	* Pause a flow run
+	*/
+	async pauseFlowRun(flowRunId, reason) {
+		this.config.logger.debug("pauseFlowRun called with arguments:", JSON.stringify({
+			flowRunId,
+			reason
+		}, null, 2));
+		return this.flowRunsService.pauseRun(flowRunId, reason);
+	}
+	/**
+	* Get dashboard statistics: flow counts, run counts by status, recent activity.
+	*/
+	async getDashboardStats() {
+		this.config.logger.debug("getDashboardStats called");
+		const [flowsResponse, runStats, recentRunsResponse] = await Promise.all([
+			this.flowService.listFlows({ pagination: {
+				page: 1,
+				limit: 1
+			} }),
+			this.flowRunsService.getStats(),
+			this.flowRunsService.listRuns({
+				pagination: {
+					page: 1,
+					limit: 10
+				},
+				sort: {
+					sortBy: "startedAt",
+					sortOrder: "desc"
+				}
+			})
+		]);
+		const totalRunsAll = Object.values(runStats.totalRuns).reduce((sum, c) => sum + c, 0);
+		const totalSuccess = runStats.totalRuns[FlowRunStatus.SUCCESS] ?? 0;
+		const successRate = totalRunsAll > 0 ? Math.round(totalSuccess / totalRunsAll * 100) : 0;
+		const activeCount = (runStats.totalRuns[FlowRunStatus.RUNNING] ?? 0) + (runStats.totalRuns[FlowRunStatus.PENDING] ?? 0) + (runStats.totalRuns[FlowRunStatus.PAUSED_FOR_BATCH] ?? 0);
+		const recentRunsAll = Object.values(runStats.recentRuns).reduce((sum, c) => sum + c, 0);
+		return {
+			totalFlows: flowsResponse.pagination.totalPages,
+			totalRuns: totalRunsAll,
+			runsLast24h: recentRunsAll,
+			activeRuns: activeCount,
+			successRate,
+			failedRunsLast24h: runStats.recentRuns[FlowRunStatus.FAILED] ?? 0,
+			runsByStatus: runStats.totalRuns,
+			recentRuns: recentRunsResponse.data
+		};
+	}
+	/**
+	* Create a credential
+	*/
+	async createCredential(input) {
+		this.config.logger.debug("createCredential called");
+		return this.credentialsService.create(input);
+	}
+	/**
+	* List credentials with optional filters
+	*/
+	async listCredentials(filters) {
+		this.config.logger.debug("listCredentials called", { filters });
+		return this.credentialsService.list(filters);
+	}
+	/**
+	* Retrieve a credential by id
+	*/
+	async getCredential(id) {
+		this.config.logger.debug("getCredential called", { id });
+		return this.credentialsService.get(id);
+	}
+	/**
+	* Update credential
+	*/
+	async updateCredential(id, input) {
+		this.config.logger.debug("updateCredential called", { id });
+		return this.credentialsService.update(id, input);
+	}
+	/**
+	* Delete credential
+	*/
+	async deleteCredential(id) {
+		this.config.logger.debug("deleteCredential called", { id });
+		return this.credentialsService.delete(id);
+	}
+	/**
+	* Test credential validity
+	*/
+	async testCredential(id) {
+		this.config.logger.debug("testCredential called", { id });
+		return this.credentialsService.test(id);
+	}
+	/**
+	* Update credential last used timestamp
+	*/
+	async updateCredentialLastUsed(id) {
+		this.config.logger.debug("updateCredentialLastUsed called", { id });
+		return this.credentialsService.updateLastUsed(id);
+	}
+	/**
+	* Get expiring credentials helper
+	*/
+	async getExpiringCredentials(daysUntilExpiry) {
+		this.config.logger.debug("getExpiringCredentials called", { daysUntilExpiry });
+		return this.credentialsService.getExpiringCredentials(daysUntilExpiry);
+	}
+	/**
+	* Get node executions by flow run ID
+	*/
+	async getNodeExecutionsByRunId(flowRunId) {
+		this.config.logger.debug("getNodeExecutionsByRunId called with arguments:", JSON.stringify({ flowRunId }, null, 2));
+		return this.nodeExecutionsService.listNodeExecutionsByFlowRunId(flowRunId);
+	}
+	/**
+	* Get all node executions with optional filtering, sorting, and pagination
+	*/
+	async listNodeExecutions(options) {
+		this.config.logger.debug("listNodeExecutions called with arguments:", JSON.stringify(options, null, 2));
+		return await this.nodeExecutionsService.listNodeExecutions(options);
+	}
+	/**
+	* Create an async iterable that yields execution events for a flow run.
+	*
+	* The first event is always a "snapshot" with the current FlowRun and all
+	* NodeExecutions.  Subsequent events are incremental updates.  The stream
+	* ends automatically when the flow run reaches a terminal status.
+	*
+	* Consumers (Express/NestJS/Next.js adapters) iterate this with
+	* `for await (const event of stream)` and write SSE frames.
+	*/
+	async *createFlowRunEventStream(flowRunId) {
+		const bus = this.serviceFactory?.getExecutionEventBus();
+		if (!bus) throw new Error("ServiceFactory not initialized");
+		const flowRun = await this.flowRunsService.getRunById(flowRunId);
+		yield {
+			type: "snapshot",
+			flowRun,
+			nodeExecutions: await this.nodeExecutionsService.listNodeExecutionsByFlowRunId(flowRunId)
+		};
+		const terminalStatuses = new Set([
+			FlowRunStatus.SUCCESS,
+			FlowRunStatus.FAILED,
+			FlowRunStatus.CANCELLED
+		]);
+		if (terminalStatuses.has(flowRun.status)) {
+			yield {
+				type: "end",
+				flowRun
+			};
+			return;
+		}
+		const queue = [];
+		let resolve = null;
+		let done = false;
+		const unsubscribe = bus.subscribe(flowRunId, (event) => {
+			queue.push(event);
+			if (event.type === "flow_run.updated" && terminalStatuses.has(event.flowRun.status)) {
+				queue.push({
+					type: "end",
+					flowRun: event.flowRun
+				});
+				done = true;
+			}
+			const wakeUp = resolve;
+			if (wakeUp) {
+				resolve = null;
+				wakeUp();
+			}
+		});
+		const heartbeatTimer = setInterval(() => {
+			queue.push({ type: "heartbeat" });
+			if (resolve) {
+				resolve();
+				resolve = null;
+			}
+		}, 15e3);
+		try {
+			while (!done) {
+				while (queue.length > 0) {
+					const event = queue.shift();
+					yield event;
+					if (event.type === "end") return;
+				}
+				await new Promise((r) => {
+					resolve = r;
+				});
+			}
+		} finally {
+			clearInterval(heartbeatTimer);
+			unsubscribe();
+		}
+	}
+	/**
+	* Start batch polling for automatic batch completion handling
+	*/
+	async startBatchPolling() {
+		await this.baseAIClient.startBatchPolling();
+	}
+	/**
+	* Stop batch polling
+	*/
+	async stopBatchPolling() {
+		await this.baseAIClient.stopBatchPolling();
+	}
+	/**
+	* Start the cron scheduler for automatic cron trigger execution.
+	* Call after initialize() — typically in your server startup code.
+	* If cronEnabled is false in InvectConfig.triggers, this is a no-op.
+	*/
+	async startCronScheduler() {
+		if (!(this.config.triggers?.cronEnabled ?? true)) {
+			this.config.logger.info("Cron scheduler disabled via config");
+			return;
+		}
+		this.config.logger.info("Starting cron scheduler");
+		const scheduler = this.serviceFactory?.getCronScheduler();
+		if (!scheduler) throw new Error("ServiceFactory not initialized");
+		await scheduler.start();
+	}
+	/**
+	* Stop the cron scheduler. Call during graceful shutdown.
+	*/
+	stopCronScheduler() {
+		this.config.logger.info("Stopping cron scheduler");
+		const scheduler = this.serviceFactory?.getCronScheduler();
+		if (!scheduler) throw new Error("ServiceFactory not initialized");
+		scheduler.stop();
+	}
+	/**
+	* Refresh cron jobs from the database (e.g. after trigger registrations change).
+	*/
+	async refreshCronScheduler() {
+		const scheduler = this.serviceFactory?.getCronScheduler();
+		if (!scheduler) throw new Error("ServiceFactory not initialized");
+		await scheduler.refresh();
+	}
+	/**
+	* Execute a SQL query for node testing purposes
+	*/
+	async executeSqlQuery(request) {
+		this.config.logger.debug("executeSqlQuery called with arguments:", JSON.stringify(request, null, 2));
+		return this.nodeDataService.runSqlQuery(request);
+	}
+	/**
+	* Test a JS expression in the QuickJS sandbox.
+	* Used by the frontend data mapper preview.
+	*/
+	async testJsExpression(request) {
+		this.ensureInitialized();
+		if (!this.jsExpressionService) return {
+			success: false,
+			error: "JS expression engine not initialized"
+		};
+		try {
+			return {
+				success: true,
+				result: this.jsExpressionService.evaluate(request.expression, request.context)
+			};
+		} catch (e) {
+			return {
+				success: false,
+				error: e instanceof Error ? e.message : String(e)
+			};
+		}
+	}
+	/**
+	* Test a mapper expression — returns the result plus metadata about how
+	* the node would behave (iterate vs single, item count).
+	* Used by the frontend Data Mapper pane live preview.
+	*/
+	async testMapper(request) {
+		this.ensureInitialized();
+		if (!this.jsExpressionService) return {
+			success: false,
+			error: "JS expression engine not initialized"
+		};
+		try {
+			const result = this.jsExpressionService.evaluate(request.expression, request.incomingData);
+			const mode = request.mode ?? "auto";
+			const isArray = Array.isArray(result);
+			let resultType;
+			if (isArray) resultType = "array";
+			else if (result !== null && typeof result === "object") resultType = "object";
+			else resultType = "primitive";
+			if (mode === "iterate" && !isArray) return {
+				success: false,
+				error: `Mode is "iterate" but expression returned ${resultType}, not an array`
+			};
+			return {
+				success: true,
+				result,
+				resultType,
+				itemCount: isArray ? result.length : void 0
+			};
+		} catch (e) {
+			return {
+				success: false,
+				error: e instanceof Error ? e.message : String(e)
+			};
+		}
+	}
+	/**
+	* Test a model prompt
+	*/
+	async testModelPrompt(request) {
+		this.config.logger.debug("testModelPrompt called with arguments:", JSON.stringify(request, null, 2));
+		if (request.credentialId) await this.ensureAdapterForCredential(request.credentialId, request.provider);
+		return this.baseAIClient.executePrompt(request);
+	}
+	/**
+	* Get available AI models
+	*/
+	async getAvailableModels() {
+		return this.nodeDataService.getAvailableModels();
+	}
+	/**
+	* Get models for a specific provider
+	*/
+	async getModelsForProvider(provider) {
+		if (!provider) throw new ValidationError("Provider is required to list models");
+		return {
+			provider,
+			...await this.nodeDataService.getModelsForProvider(provider)
+		};
+	}
+	/**
+	* Get models for a credential by detecting its provider
+	*/
+	async getModelsForCredential(credentialId) {
+		if (!credentialId) throw new ValidationError("credentialId is required to list models");
+		const provider = detectProviderFromCredential(await this.credentialsService.get(credentialId));
+		if (!provider) throw new ValidationError("Unable to detect provider from credential. Ensure the credential has an API URL or provider hint.");
+		return {
+			provider,
+			...await this.nodeDataService.getModelsForProvider(provider)
+		};
+	}
+	/**
+	* Get available databases
+	*/
+	getAvailableDatabases() {
+		return this.nodeDataService.getAvailableDatabases();
+	}
+	/**
+	* Get definitions for all available nodes.
+	* Returns both legacy node definitions and action-based node definitions.
+	*/
+	getAvailableNodes() {
+		this.ensureInitialized();
+		const actionDefs = this.actionRegistry ? this.actionRegistry.getAllNodeDefinitions() : [];
+		const actionTypes = new Set(actionDefs.map((d) => d.type));
+		const legacyDefs = this.nodeRegistry.getAllDefinitions().filter((d) => !actionTypes.has(d.type));
+		const allDefs = [...actionDefs, ...legacyDefs];
+		for (const def of allDefs) if (!def.provider) def.provider = {
+			id: "core",
+			name: "Invect Core",
+			icon: "Blocks"
+		};
+		return allDefs;
+	}
+	/** Get the TemplateService or throw if not initialized. */
+	getTemplateServiceOrThrow() {
+		if (!this.templateService) throw new Error("TemplateService not available — JS expression engine failed to initialize");
+		return this.templateService;
+	}
+	/**
+	* Resolve {{ expression }} templates in params using the provided context.
+	* Used for test node execution where we need to resolve templates before running.
+	*
+	* @param params - The node parameters to resolve
+	* @param context - The context to use for template resolution
+	* @param skipKeys - Keys to skip (their values should not be resolved as templates)
+	*/
+	resolveTemplateParams(params, context, skipKeys = []) {
+		const templateService = this.getTemplateServiceOrThrow();
+		const resolved = {};
+		for (const [key, value] of Object.entries(params)) {
+			if (skipKeys.includes(key)) {
+				resolved[key] = value;
+				continue;
+			}
+			if (typeof value === "string" && templateService.isTemplate(value)) try {
+				const renderedValue = templateService.render(value, context);
+				resolved[key] = renderedValue;
+				this.config.logger.debug("Resolved template param for test", {
+					param: key,
+					template: value,
+					resolved: renderedValue
+				});
+			} catch (error) {
+				this.config.logger.warn("Failed to resolve template param for test", {
+					param: key,
+					template: value,
+					error: error instanceof Error ? error.message : String(error)
+				});
+				resolved[key] = value;
+			}
+			else resolved[key] = value;
+		}
+		return resolved;
+	}
+	/**
+	* Test/execute a single node with the provided params and input data.
+	* This is useful for testing node configuration in isolation.
+	*
+	* Templates in params (e.g., {{ some_input.data.variables.output.value }})
+	* are resolved using the inputData as context before execution.
+	*
+	* @param nodeType - The type of node to execute
+	* @param params - The node's configuration parameters (may contain {{ }} templates)
+	* @param inputData - Mock input data used both as node inputs and as template context
+	* @returns The node execution result
+	*/
+	async testNode(nodeType, params, inputData = {}) {
+		this.ensureInitialized();
+		const executor = this.nodeRegistry.get(nodeType);
+		const action = !executor && this.actionRegistry ? this.actionRegistry.get(nodeType) : void 0;
+		if (!executor && !action) throw new ValidationError(`Unknown node type: ${nodeType}`);
+		let defaultParams = {};
+		if (executor) defaultParams = executor.getDefinition().defaultParams ?? {};
+		else if (action) defaultParams = Object.fromEntries((action.params.fields ?? []).filter((f) => f.defaultValue !== void 0).map((f) => [f.name, f.defaultValue]));
+		const mergedParams = {
+			...defaultParams,
+			...params
+		};
+		const skipTemplateResolutionKeys = [];
+		if (nodeType === GraphNodeType.TEMPLATE_STRING || nodeType === "core.template_string") skipTemplateResolutionKeys.push("template");
+		const resolvedParams = this.resolveTemplateParams(mergedParams, inputData, skipTemplateResolutionKeys);
+		this.config.logger.debug("Test node with resolved params", {
+			nodeType,
+			defaultParams,
+			originalParams: params,
+			mergedParams,
+			resolvedParams,
+			inputDataKeys: Object.keys(inputData)
+		});
+		try {
+			if (action) {
+				const { executeActionAsNode } = await import("./actions/action-executor.js");
+				const result = await executeActionAsNode(action, resolvedParams, {
+					nodeId: `test-${Date.now()}`,
+					flowRunId: `test-run-${Date.now()}`,
+					logger: this.config.logger,
+					globalConfig: {},
+					flowInputs: {},
+					flowParams: { useBatchProcessing: false },
+					incomingData: inputData,
+					functions: {
+						markDownstreamNodesAsSkipped: () => {},
+						runTemplateReplacement: (template, variables) => this.nodeDataService.runTemplateReplacement(template, variables),
+						submitPrompt: async (request) => this.baseAIClient.executePrompt(request),
+						getCredential: async (credentialId) => this.credentialsService.get(credentialId)
+					},
+					allNodeOutputs: /* @__PURE__ */ new Map()
+				});
+				if (result.state === NodeExecutionStatus.SUCCESS) {
+					let output;
+					if (result.output?.data?.variables) output = Object.fromEntries(Object.entries(result.output.data.variables).map(([k, v]) => [k, v.value]));
+					else if (result.output) output = result.output;
+					return {
+						success: true,
+						output
+					};
+				} else if (result.state === NodeExecutionStatus.FAILED) return {
+					success: false,
+					error: result.errors?.join(", ") || "Node execution failed"
+				};
+				else return {
+					success: true,
+					output: { status: "pending" }
+				};
+			}
+			const mockNode = {
+				id: `test-${Date.now()}`,
+				type: nodeType,
+				params: resolvedParams,
+				position: {
+					x: 0,
+					y: 0
+				}
+			};
+			const context = {
+				nodeId: mockNode.id,
+				flowRunId: `test-run-${Date.now()}`,
+				logger: this.config.logger,
+				globalConfig: {},
+				flowInputs: {},
+				flowParams: { useBatchProcessing: false },
+				incomingData: inputData,
+				functions: {
+					markDownstreamNodesAsSkipped: () => {},
+					testJsonLogic: (conditionLogic, evaluationData) => {
+						return this.nodeDataService.testJsonLogic(conditionLogic, evaluationData);
+					},
+					runSqlQuery: (request) => {
+						return this.nodeDataService.runSqlQuery(request);
+					},
+					runTemplateReplacement: (template, variables) => {
+						return this.nodeDataService.runTemplateReplacement(template, variables);
+					},
+					submitPrompt: async (request) => {
+						this.config.logger.debug("Test node submitting prompt", { request });
+						return this.baseAIClient.executePrompt(request);
+					},
+					getCredential: async (credentialId) => {
+						return this.credentialsService.get(credentialId);
+					}
+				},
+				allNodeOutputs: /* @__PURE__ */ new Map()
+			};
+			const effectiveInputs = { ...inputData };
+			const result = await executor.execute(effectiveInputs, mockNode, context);
+			if (result.state === NodeExecutionStatus.SUCCESS) {
+				let output;
+				if (result.output?.data?.variables) output = Object.fromEntries(Object.entries(result.output.data.variables).map(([k, v]) => [k, v.value]));
+				else if (result.output) output = result.output;
+				return {
+					success: true,
+					output
+				};
+			} else if (result.state === NodeExecutionStatus.FAILED) return {
+				success: false,
+				error: result.errors?.join(", ") || "Node execution failed"
+			};
+			else return {
+				success: true,
+				output: { status: "pending" }
+			};
+		} catch (error) {
+			this.config.logger.error("Test node execution failed", {
+				error,
+				nodeType
+			});
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+	}
+	/**
+	* Handle node configuration update events coming from the frontend.
+	* Supports both legacy executors (AGENT) and action-based nodes.
+	*/
+	async handleNodeConfigUpdate(event) {
+		this.ensureInitialized();
+		if (!event?.nodeType) throw new ValidationError("nodeType is required for node config updates");
+		if (!event.params || typeof event.params !== "object") event.params = {};
+		const configContext = {
+			logger: this.config.logger,
+			services: {
+				credentials: this.credentialsService,
+				baseAIClient: this.baseAIClient
+			}
+		};
+		const executor = this.nodeRegistry.get(event.nodeType);
+		if (executor) try {
+			return await executor.handleConfigUpdate(event, configContext);
+		} catch (error) {
+			this.config.logger.error("Node config update handler failed", {
+				error,
+				nodeType: event.nodeType,
+				nodeId: event.nodeId
+			});
+			throw error;
+		}
+		const nodeTypeStr = event.nodeType;
+		const action = this.actionRegistry?.get(nodeTypeStr);
+		if (action) {
+			if (action.onConfigUpdate) try {
+				return await action.onConfigUpdate({
+					...event,
+					nodeType: nodeTypeStr
+				}, configContext);
+			} catch (error) {
+				this.config.logger.error("Action config update handler failed", {
+					error,
+					nodeType: nodeTypeStr,
+					nodeId: event.nodeId
+				});
+				throw error;
+			}
+			const definition = this.actionRegistry.toNodeDefinition(nodeTypeStr);
+			if (definition) return {
+				definition,
+				params: event.params
+			};
+		}
+		throw new ValidationError(`Unknown node type '${event.nodeType}' for config update`);
+	}
+	/**
+	* Resolve dynamic options for a specific field on an action.
+	*
+	* Called by: `GET /actions/:actionId/fields/:fieldName/options?deps={...}`
+	*
+	* The action's `ParamField.loadOptions.handler` is invoked server-side with
+	* the dependency values and returns an options list + optional default value.
+	*/
+	async resolveFieldOptions(actionId, fieldName, dependencyValues) {
+		this.ensureInitialized();
+		if (!this.actionRegistry) throw new ValidationError("Action registry not initialised");
+		const context = {
+			logger: this.config.logger,
+			services: { credentials: this.credentialsService }
+		};
+		return this.actionRegistry.resolveFieldOptions(actionId, fieldName, dependencyValues, context);
+	}
+	/**
+	* Render flow to React Flow format
+	*/
+	async renderToReactFlow(flowId, options) {
+		this.config.logger.debug("renderToReactFlow called with arguments:", JSON.stringify({
+			flowId,
+			options
+		}, null, 2));
+		return this.reactFlowRendererService.renderToReactFlow(flowId, options);
+	}
+	/**
+	* Get flow service with initialization check
+	*/
+	get flowService() {
+		this.ensureInitialized();
+		return this.serviceFactory.getFlowService();
+	}
+	/**
+	* Get flow versions service with initialization check
+	*/
+	get flowVersionsService() {
+		this.ensureInitialized();
+		return this.serviceFactory.getFlowVersionsService();
+	}
+	/**
+	* Get flow runs service with initialization check
+	*/
+	get flowRunsService() {
+		this.ensureInitialized();
+		return this.serviceFactory.getFlowRunsService();
+	}
+	/**
+	* Get orchestration service with initialization check
+	*/
+	get orchestrationService() {
+		this.ensureInitialized();
+		return this.serviceFactory.getOrchestrationService();
+	}
+	/**
+	* Get node executions service with initialization check
+	*/
+	get nodeExecutionsService() {
+		this.ensureInitialized();
+		return this.serviceFactory.getNodeExecutionsService();
+	}
+	/**
+	* Get node data service with initialization check
+	*/
+	get nodeDataService() {
+		this.ensureInitialized();
+		return this.serviceFactory.getNodeDataService();
+	}
+	/**
+	* Get base AI client with initialization check
+	*/
+	get baseAIClient() {
+		this.ensureInitialized();
+		return this.serviceFactory.getBaseAIClient();
+	}
+	/**
+	* Ensure a provider adapter is registered for the given credential.
+	* Resolves the credential, extracts the API key, detects the provider,
+	* and calls registerAdapter() if not already present.
+	*/
+	async ensureAdapterForCredential(credentialId, providerHint) {
+		const client = this.baseAIClient;
+		if (providerHint && client.hasAdapter(providerHint)) return;
+		const credential = await this.credentialsService.getDecryptedWithRefresh(credentialId);
+		const apiKey = credential.config?.apiKey;
+		if (!apiKey) throw new Error(`Credential "${credentialId}" does not contain an apiKey.`);
+		const detected = detectProviderFromCredential(credential);
+		if (!detected) throw new Error(`Unable to detect AI provider from credential "${credentialId}".`);
+		if (client.hasAdapter(detected)) return;
+		const label = detected === BatchProvider.OPENAI ? "OPENAI" : detected === BatchProvider.ANTHROPIC ? "ANTHROPIC" : "OPENROUTER";
+		client.registerAdapter(label, apiKey);
+	}
+	/**
+	* Get React Flow renderer service with initialization check
+	*/
+	get reactFlowRendererService() {
+		this.ensureInitialized();
+		return this.serviceFactory.getReactFlowRendererService();
+	}
+	/**
+	* Get credentials service with initialization check
+	*/
+	get credentialsService() {
+		this.ensureInitialized();
+		return this.serviceFactory.getCredentialsService();
+	}
+	/**
+	* Get triggers service with initialization check
+	*/
+	get triggersService() {
+		this.ensureInitialized();
+		return this.serviceFactory.getTriggersService();
+	}
+	/**
+	* Get credentials service (public accessor)
+	*/
+	getCredentialsService() {
+		return this.credentialsService;
+	}
+	/**
+	* Ensure default credentials exist.
+	* Runs once after initialization completes — skips any that already exist by name.
+	*/
+	async ensureDefaultCredentials() {
+		const seeds = this.config.defaultCredentials;
+		if (!seeds?.length) return;
+		const existing = await this.listCredentials();
+		const existingNames = new Set(existing.map((c) => c.name));
+		for (const seed of seeds) {
+			if (existingNames.has(seed.name)) {
+				this.config.logger.debug(`Seed credential "${seed.name}" already exists — skipping`);
+				continue;
+			}
+			try {
+				const created = await this.createCredential(seed);
+				console.log(`🔐 Seeded credential: ${created.name} (${created.id})`);
+			} catch (error) {
+				this.config.logger.warn(`Failed to seed credential "${seed.name}"`, error);
+			}
+		}
+	}
+	/**
+	* Initialize services
+	*/
+	async initializeServices(nodeRegistry) {
+		this.config.logger.debug("Initializing service factory...");
+		this.serviceFactory = new ServiceFactory(this.config, nodeRegistry, this, this.actionRegistry, this.pluginManager, this.jsExpressionService ?? void 0, this.templateService ?? void 0);
+		await this.serviceFactory.initialize();
+	}
+	/**
+	* Initialize node registry with tool registry
+	*/
+	async initializeNodes() {
+		this.config.logger.debug("Initializing node registry...");
+		const nodeRegistry = await DefaultNodeRegistryFactory.createDefault(this.config.logger);
+		const toolRegistry = await initializeGlobalToolRegistry(this.config.logger);
+		this.config.logger.debug(`Initialized agent tool registry with ${toolRegistry.size} tools`);
+		const agentExecutor = nodeRegistry.get(GraphNodeType.AGENT);
+		if (agentExecutor && "setToolRegistry" in agentExecutor) agentExecutor.setToolRegistry(toolRegistry);
+		return nodeRegistry;
+	}
+	/**
+	* Register all actions in the ActionRegistry as agent tools.
+	*/
+	registerActionsAsTools() {
+		if (!this.actionRegistry) return;
+		let toolRegistry;
+		try {
+			toolRegistry = getGlobalToolRegistry();
+		} catch {
+			return;
+		}
+		for (const action of this.actionRegistry.getAll()) {
+			const toolDef = this.actionRegistry.toAgentToolDefinition(action.id);
+			if (toolDef && !toolRegistry.has(toolDef.id)) toolRegistry.register(toolDef, createToolExecutorForAction(action));
+		}
+	}
+	/**
+	* Ensure core is initialized
+	*/
+	ensureInitialized() {
+		if (!this.initialized || !this.serviceFactory || !this.nodeRegistry) throw new DatabaseError("Invect Core not initialized. Call initialize() first.");
+	}
+	/**
+	* Get the action registry.
+	*/
+	getActionRegistry() {
+		this.ensureInitialized();
+		if (!this.actionRegistry) throw new DatabaseError("Action registry not initialized");
+		return this.actionRegistry;
+	}
+	/**
+	* Register an action at runtime (e.g. from a plugin or external package).
+	*/
+	registerAction(action) {
+		this.ensureInitialized();
+		if (!this.actionRegistry) throw new DatabaseError("Action registry not initialized");
+		this.actionRegistry.register(action);
+		const toolDef = this.actionRegistry.toAgentToolDefinition(action.id);
+		if (toolDef) getGlobalToolRegistry().register(toolDef, createToolExecutorForAction(action));
+	}
+	/**
+	* Get all registered providers.
+	*/
+	getProviders() {
+		this.ensureInitialized();
+		if (!this.actionRegistry) return [];
+		return this.actionRegistry.getProviders();
+	}
+	/**
+	* Get all actions for a specific provider.
+	*/
+	getActionsForProvider(providerId) {
+		this.ensureInitialized();
+		if (!this.actionRegistry) return [];
+		return this.actionRegistry.getActionsForProvider(providerId);
+	}
+	/**
+	* Get all available agent tools
+	*/
+	getAgentTools() {
+		this.ensureInitialized();
+		return getGlobalToolRegistry().getDefinitions();
+	}
+	/**
+	* Execute agent prompt with tools
+	*/
+	async submitAgentPrompt(request) {
+		this.ensureInitialized();
+		await this.ensureAdapterForCredential(request.credentialId, request.provider);
+		return await this.baseAIClient.runAgentPrompt(request, request.provider);
+	}
+	/**
+	* Create a streaming chat session.
+	*
+	* Returns an AsyncGenerator<ChatStreamEvent> that framework adapters
+	* serialize to SSE. The generator handles the full LLM loop including
+	* tool calls.
+	*
+	* @example
+	* ```typescript
+	* const stream = await invect.createChatStream({
+	*   messages: [{ role: 'user', content: 'Add a Gmail node' }],
+	*   context: { flowId: 'flow_123' },
+	* });
+	*
+	* for await (const event of stream) {
+	*   // event.type: 'text_delta' | 'tool_call_start' | 'tool_call_result' | 'done' | 'error'
+	* }
+	* ```
+	*/
+	async createChatStream(options) {
+		this.ensureInitialized();
+		return this.serviceFactory.getChatStreamService().createStream({
+			messages: options.messages,
+			context: options.context,
+			identity: options.identity
+		});
+	}
+	/**
+	* Check if the chat assistant feature is enabled and configured.
+	*/
+	isChatEnabled() {
+		this.ensureInitialized();
+		return this.serviceFactory.getChatStreamService().isEnabled();
+	}
+	/**
+	* Get all persisted chat messages for a flow (ordered by creation time).
+	*/
+	async getChatMessages(flowId) {
+		this.ensureInitialized();
+		return this.serviceFactory.getDatabaseService().chatMessages.getByFlowId(flowId);
+	}
+	/**
+	* Save chat messages for a flow (replaces existing messages).
+	*/
+	async saveChatMessages(flowId, messages) {
+		this.ensureInitialized();
+		const db = this.serviceFactory.getDatabaseService();
+		await db.chatMessages.deleteByFlowId(flowId);
+		return db.chatMessages.createMany(messages.map((m) => ({
+			flowId,
+			role: m.role,
+			content: m.content,
+			toolMeta: m.toolMeta
+		})));
+	}
+	/**
+	* Delete all chat messages for a flow.
+	*/
+	async deleteChatMessages(flowId) {
+		this.ensureInitialized();
+		await this.serviceFactory.getDatabaseService().chatMessages.deleteByFlowId(flowId);
+	}
+	/**
+	* List all trigger registrations for a flow.
+	*/
+	async listTriggersForFlow(flowId) {
+		this.config.logger.debug("listTriggersForFlow called", { flowId });
+		return this.triggersService.listTriggersForFlow(flowId);
+	}
+	/**
+	* Get a single trigger registration by ID.
+	*/
+	async getTrigger(triggerId) {
+		this.config.logger.debug("getTrigger called", { triggerId });
+		return this.triggersService.getTrigger(triggerId);
+	}
+	/**
+	* Create a trigger registration.
+	*/
+	async createTrigger(input) {
+		this.config.logger.debug("createTrigger called", {
+			flowId: input.flowId,
+			type: input.type
+		});
+		return this.triggersService.createTrigger(input);
+	}
+	/**
+	* Update a trigger registration.
+	*/
+	async updateTrigger(triggerId, input) {
+		this.config.logger.debug("updateTrigger called", { triggerId });
+		return this.triggersService.updateTrigger(triggerId, input);
+	}
+	/**
+	* Delete a trigger registration.
+	*/
+	async deleteTrigger(triggerId) {
+		this.config.logger.debug("deleteTrigger called", { triggerId });
+		return this.triggersService.deleteTrigger(triggerId);
+	}
+	/**
+	* Sync trigger registrations for a flow from its definition.
+	* Call this after publishing a new flow version. Also refreshes
+	* the cron scheduler if any cron triggers were changed.
+	*/
+	async syncTriggersForFlow(flowId, definition) {
+		this.config.logger.debug("syncTriggersForFlow called", { flowId });
+		const result = await this.triggersService.syncTriggersForFlow(flowId, definition);
+		try {
+			const scheduler = this.serviceFactory?.getCronScheduler();
+			if (scheduler?.isRunning()) await scheduler.refresh();
+		} catch {}
+		return result;
+	}
+	/**
+	* Get all enabled cron triggers (for scheduler initialization).
+	*/
+	async getEnabledCronTriggers() {
+		this.config.logger.debug("getEnabledCronTriggers called");
+		return this.triggersService.getEnabledCronTriggers();
+	}
+	/**
+	* Execute a cron trigger (called by the cron scheduler).
+	*/
+	async executeCronTrigger(triggerId) {
+		this.config.logger.debug("executeCronTrigger called", { triggerId });
+		return this.triggersService.executeCronTrigger(triggerId);
+	}
+	/**
+	* Get all available OAuth2 providers
+	*/
+	getOAuth2Providers() {
+		this.ensureInitialized();
+		return this.serviceFactory.getCredentialsService().getOAuth2Service().getProviders();
+	}
+	/**
+	* Get a specific OAuth2 provider by ID
+	*/
+	getOAuth2Provider(providerId) {
+		this.ensureInitialized();
+		return this.serviceFactory.getCredentialsService().getOAuth2Service().getProvider(providerId);
+	}
+	/**
+	* Start an OAuth2 authorization flow
+	* Returns the authorization URL and state to redirect the user to
+	*/
+	startOAuth2Flow(providerId, appConfig, options) {
+		this.ensureInitialized();
+		return this.serviceFactory.getCredentialsService().getOAuth2Service().startAuthorizationFlow(providerId, appConfig, options);
+	}
+	/**
+	* Get pending OAuth2 state (for verifying callback)
+	*/
+	getOAuth2PendingState(state) {
+		this.ensureInitialized();
+		return this.serviceFactory.getCredentialsService().getOAuth2Service().getPendingState(state);
+	}
+	/**
+	* Handle OAuth2 callback - exchange code for tokens and create credential
+	*/
+	async handleOAuth2Callback(code, state, appConfig) {
+		this.ensureInitialized();
+		const credentialsService = this.serviceFactory.getCredentialsService();
+		const oauth2Service = credentialsService.getOAuth2Service();
+		const { tokens, pendingState } = await oauth2Service.exchangeCodeForTokens(code, state, appConfig);
+		const provider = oauth2Service.getProvider(pendingState.providerId);
+		if (!provider) throw new Error(`Unknown OAuth2 provider: ${pendingState.providerId}`);
+		const config = oauth2Service.buildCredentialConfig(tokens, pendingState.providerId, appConfig);
+		const credential = await credentialsService.create({
+			name: pendingState.credentialName || provider.name,
+			type: "http-api",
+			authType: "oauth2",
+			config,
+			description: `OAuth2 credential for ${provider.name}`,
+			metadata: {
+				oauth2Provider: pendingState.providerId,
+				scopes: tokens.scope?.split(" ") || provider.defaultScopes
+			}
+		});
+		this.loggerManager.getBasicLogger().info("Created OAuth2 credential", {
+			credentialId: credential.id,
+			providerId: pendingState.providerId
+		});
+		return credential;
+	}
+	/**
+	* Refresh an OAuth2 credential's access token
+	*/
+	async refreshOAuth2Credential(credentialId) {
+		this.ensureInitialized();
+		return this.serviceFactory.getCredentialsService().getDecryptedWithRefresh(credentialId);
+	}
+};
+//#endregion
+export { Invect };
+
+//# sourceMappingURL=invect-core.js.map