@solidxai/core 0.1.12 → 0.1.13-beta.10

package/dist/services/workflow/workflow-runtime.service.js

@@ -0,0 +1,706 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var WorkflowRuntimeService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowRuntimeService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const workflow_definition_entity_1 = require("../../entities/workflow-definition.entity");
+const workflow_execution_entity_1 = require("../../entities/workflow-execution.entity");
+const workflow_step_execution_entity_1 = require("../../entities/workflow-step-execution.entity");
+const workflow_execution_writer_service_1 = require("./workflow-execution-writer.service");
+const workflow_expression_service_1 = require("./workflow-expression.service");
+const workflow_definition_validator_service_1 = require("./workflow-definition-validator.service");
+const workflow_node_registry_service_1 = require("./workflow-node-registry.service");
+const workflow_secret_service_1 = require("../workflow-secret.service");
+const publisher_factory_service_1 = require("../queues/publisher-factory.service");
+const yaml_1 = __importDefault(require("yaml"));
+let WorkflowRuntimeService = WorkflowRuntimeService_1 = class WorkflowRuntimeService {
+    constructor(entityManager, registry, expression, writer, validator, workflowSecretService, workflowExecutionPublisherFactory) {
+        this.entityManager = entityManager;
+        this.registry = registry;
+        this.expression = expression;
+        this.writer = writer;
+        this.validator = validator;
+        this.workflowSecretService = workflowSecretService;
+        this.workflowExecutionPublisherFactory = workflowExecutionPublisherFactory;
+        this.logger = new common_1.Logger(WorkflowRuntimeService_1.name);
+    }
+    async executeDefinitionById(id, request) {
+        const definition = await this.entityManager.findOne(workflow_definition_entity_1.WorkflowDefinition, {
+            where: { id },
+        });
+        return this.executeDefinition(definition, request);
+    }
+    async executeDefinitionByIdAsync(id, request = {}) {
+        const definition = await this.entityManager.findOne(workflow_definition_entity_1.WorkflowDefinition, {
+            where: { id },
+        });
+        return this.enqueueDefinition(definition, request);
+    }
+    async executeDefinitionByKey(key, request) {
+        const definition = await this.entityManager.findOne(workflow_definition_entity_1.WorkflowDefinition, {
+            where: { key },
+        });
+        return this.executeDefinition(definition, request);
+    }
+    async executeDefinitionByKeyAsync(key, request = {}) {
+        const definition = await this.entityManager.findOne(workflow_definition_entity_1.WorkflowDefinition, {
+            where: { key },
+        });
+        return this.enqueueDefinition(definition, request);
+    }
+    async queueWorkflowExecution(payload) {
+        const messageId = await this.workflowExecutionPublisherFactory.publish({
+            payload,
+            parentEntityId: payload.executionId,
+            parentEntity: 'workflowExecution',
+            retryCount: 0,
+            retryInterval: 1000,
+        }, 'WorkflowExecutionPublisher');
+        this.logger.log(`Queued workflow execution message ${messageId} for execution id ${payload.executionId}.`);
+        return messageId;
+    }
+    async enqueueDefinition(definition, request) {
+        if (!definition) {
+            throw new common_1.BadRequestException('Workflow definition not found.');
+        }
+        this.validator.validate(this.assertDefinitionYaml(definition.definitionYaml));
+        const execution = await this.writer.createEnqueuedExecution(definition, request);
+        await this.queueWorkflowExecution({
+            executionId: execution.id,
+        });
+        return this.toResponse(execution);
+    }
+    async executeEnqueuedExecution(executionId) {
+        const execution = await this.entityManager.findOne(workflow_execution_entity_1.WorkflowExecution, {
+            where: { id: executionId },
+            relations: ['workflowDefinition'],
+        });
+        if (!execution) {
+            throw new common_1.NotFoundException(`Workflow execution ${executionId} not found.`);
+        }
+        if (execution.status !== 'enqueued') {
+            throw new common_1.BadRequestException(`Workflow execution ${executionId} is ${execution.status}; expected enqueued.`);
+        }
+        const request = this.readEnqueuedExecutionRequest(execution);
+        return this.executeDefinition(execution.workflowDefinition, request, execution);
+    }
+    async executeDefinition(definition, request, existingExecution) {
+        if (!definition) {
+            throw new common_1.BadRequestException('Workflow definition not found.');
+        }
+        const definitionDsl = this.assertDefinitionYaml(definition.definitionYaml);
+        this.validator.validate(definitionDsl);
+        const secrets = await this.workflowSecretService.getWorkflowSecretsContext();
+        const input = this.resolveWorkflowInput(definitionDsl, request, secrets);
+        const variables = this.resolveWorkflowVariables(definitionDsl, request, input, secrets);
+        const effectiveRequest = {
+            ...request,
+            input,
+            variables,
+        };
+        const execution = existingExecution
+            ? await this.writer.startExecution(existingExecution, effectiveRequest)
+            : await this.writer.createExecution(definition, effectiveRequest);
+        const nodeCount = this.countNodes([
+            ...(definitionDsl.nodes ?? []),
+            ...(definitionDsl.errors ?? []),
+            ...(definitionDsl.finally ?? []),
+        ]);
+        const outputs = {};
+        const runtimeContext = {
+            execution,
+            input,
+            variables,
+            secrets,
+            outputs,
+            counters: {
+                step: 0,
+                log: 0,
+            },
+        };
+        this.logger.log(`Starting workflow execution ${execution.executionIdentifier} for ${definition.key} with ${nodeCount} node(s).`);
+        await this.writer.writeLog(execution, undefined, {
+            level: 'info',
+            eventType: 'execution.started',
+            message: `Workflow execution started for ${definition.key}.`,
+            metadata: {
+                executionIdentifier: execution.executionIdentifier,
+                workflowKey: definition.key,
+                triggerType: execution.triggerType,
+                nodeCount,
+                inputKeys: Object.keys(runtimeContext.input ?? {}),
+                variableKeys: Object.keys(runtimeContext.variables ?? {}),
+            },
+        }, this.nextLogSequence(runtimeContext));
+        let executionError;
+        try {
+            await this.runNodes(definitionDsl.nodes, runtimeContext);
+        }
+        catch (error) {
+            executionError = error;
+            await this.runGlobalErrorHandlers(definitionDsl, runtimeContext, error);
+        }
+        try {
+            await this.runFinallyHandlers(definitionDsl, runtimeContext);
+        }
+        catch (finallyError) {
+            await this.writer.writeLog(execution, undefined, {
+                level: 'error',
+                eventType: 'finally.failed',
+                message: `Finally handler failed: ${this.errorMessage(finallyError)}.`,
+                context: this.summarizeError(finallyError),
+                metadata: {
+                    originalError: executionError
+                        ? this.summarizeError(executionError)
+                        : undefined,
+                },
+            }, this.nextLogSequence(runtimeContext));
+            if (!executionError) {
+                executionError = finallyError;
+            }
+        }
+        if (!executionError) {
+            const completed = await this.writer.completeExecution(execution, outputs);
+            this.logger.log(`Completed workflow execution ${completed.executionIdentifier} for ${definition.key} in ${completed.durationMs ?? 0} ms.`);
+            await this.writer.writeLog(completed, undefined, {
+                level: 'info',
+                eventType: 'execution.completed',
+                message: `Workflow execution completed for ${definition.key}.`,
+                metadata: {
+                    executionIdentifier: completed.executionIdentifier,
+                    durationMs: completed.durationMs,
+                    outputNodeIds: Object.keys(outputs),
+                },
+            }, this.nextLogSequence(runtimeContext));
+            return this.toResponse(completed);
+        }
+        const failed = await this.writer.failExecution(execution, executionError);
+        this.logger.error(`Failed workflow execution ${failed.executionIdentifier} for ${definition.key}: ${failed.errorSummary}`, executionError instanceof Error ? executionError.stack : undefined);
+        await this.writer.writeLog(failed, undefined, {
+            level: 'error',
+            eventType: 'execution.failed',
+            message: failed.errorSummary,
+            context: this.summarizeError(executionError),
+            metadata: {
+                executionIdentifier: failed.executionIdentifier,
+                durationMs: failed.durationMs,
+            },
+        }, this.nextLogSequence(runtimeContext));
+        return this.toResponse(failed);
+    }
+    async getExecutionStatus(executionId) {
+        const execution = await this.findExecutionOrThrow(executionId);
+        return this.toResponse(execution);
+    }
+    async getLastStepOutput(executionId) {
+        await this.findExecutionOrThrow(executionId);
+        const step = await this.entityManager.findOne(workflow_step_execution_entity_1.WorkflowStepExecution, {
+            where: { workflowExecution: { id: executionId } },
+            order: {
+                sequenceNumber: 'DESC',
+                id: 'DESC',
+            },
+        });
+        if (!step) {
+            throw new common_1.NotFoundException(`No step executions found for workflow execution ${executionId}.`);
+        }
+        return this.toStepOutputResponse(step);
+    }
+    async getStepOutput(executionId, stepNameOrId, options = {}) {
+        await this.findExecutionOrThrow(executionId);
+        const qb = this.entityManager
+            .createQueryBuilder(workflow_step_execution_entity_1.WorkflowStepExecution, 'step')
+            .innerJoin('step.workflowExecution', 'execution')
+            .where('execution.id = :executionId', { executionId })
+            .andWhere('(step.nodeId = :stepNameOrId OR step.nodeName = :stepNameOrId OR step.stepExecutionKey = :stepNameOrId)', { stepNameOrId })
+            .orderBy('step.sequenceNumber', options.latest === false ? 'ASC' : 'DESC')
+            .addOrderBy('step.id', options.latest === false ? 'ASC' : 'DESC');
+        if (options.latest !== false && options.limit === undefined && options.offset === undefined) {
+            const step = await qb.getOne();
+            if (!step) {
+                throw new common_1.NotFoundException(`No step output found for '${stepNameOrId}' in workflow execution ${executionId}.`);
+            }
+            return this.toStepOutputResponse(step);
+        }
+        const limit = Math.max(1, Math.min(Number(options.limit ?? 50), 200));
+        const offset = Math.max(0, Number(options.offset ?? 0));
+        const [steps, totalRecords] = await qb.limit(limit).offset(offset).getManyAndCount();
+        return {
+            meta: this.buildPagedMeta(offset, limit, totalRecords),
+            records: steps.map((step) => this.toStepOutputResponse(step)),
+        };
+    }
+    resolveWorkflowInput(definitionDsl, request, secrets) {
+        const requestedInput = request.input ?? {};
+        const defaultInput = Object.entries(definitionDsl.inputs ?? {}).reduce((acc, [key, inputDefinition]) => {
+            if (inputDefinition &&
+                typeof inputDefinition === 'object' &&
+                !Array.isArray(inputDefinition) &&
+                Object.prototype.hasOwnProperty.call(inputDefinition, 'default')) {
+                acc[key] = inputDefinition.default;
+                return acc;
+            }
+            if (inputDefinition === null ||
+                inputDefinition === undefined ||
+                (typeof inputDefinition === 'object' && !Array.isArray(inputDefinition))) {
+                return acc;
+            }
+            acc[key] = inputDefinition;
+            return acc;
+        }, {});
+        const rawInput = {
+            ...defaultInput,
+            ...requestedInput,
+        };
+        return this.expression.interpolate(rawInput, {
+            execution: undefined,
+            input: rawInput,
+            variables: definitionDsl.variables ?? {},
+            secrets,
+            outputs: {},
+        });
+    }
+    resolveWorkflowVariables(definitionDsl, request, input, secrets) {
+        const rawVariables = {
+            ...(definitionDsl.variables ?? {}),
+            ...(request.variables ?? {}),
+        };
+        return this.expression.interpolate(rawVariables, {
+            execution: undefined,
+            input,
+            variables: rawVariables,
+            secrets,
+            outputs: {},
+        });
+    }
+    async runNodes(nodes, context) {
+        const nodeOutputs = {};
+        for (const node of nodes ?? []) {
+            nodeOutputs[node.id] = await this.runNode(node, context);
+        }
+        return nodeOutputs;
+    }
+    async runNode(node, context) {
+        const inputPayload = {
+            configuration: node.configuration,
+            input: context.input,
+            variables: context.variables,
+            item: context.item,
+            index: context.index,
+        };
+        const step = await this.writer.createStep(context.execution, node, this.nextStepSequence(context), inputPayload, context.parentNodeId, context.parentStepExecutionKey);
+        if (node.disabled) {
+            context.outputs[node.id] = { skipped: true };
+            await this.writer.completeStep(step, 'skipped', context.outputs[node.id]);
+            await this.writer.writeLog(context.execution, step, {
+                level: 'debug',
+                eventType: 'node.skipped',
+                message: `Skipped disabled node ${node.id}.`,
+                metadata: this.nodeLogMetadata(node, context, step),
+            }, this.nextLogSequence(context));
+            return context.outputs[node.id];
+        }
+        try {
+            await this.writer.writeLog(context.execution, step, {
+                level: 'debug',
+                eventType: 'node.started',
+                message: `Starting node ${node.id} (${node.type}).`,
+                metadata: this.nodeLogMetadata(node, context, step),
+            }, this.nextLogSequence(context));
+            this.logger.debug(`Starting workflow node ${node.id} (${node.type}) for execution ${context.execution.executionIdentifier}.`);
+            const startedAtMs = Date.now();
+            const handler = this.registry.get(node.type);
+            const result = await handler.execute({
+                ...context,
+                node,
+                stepExecution: step,
+                expression: this.expression,
+                runNodes: async (childNodes, options = {}) => this.runNodes(childNodes, {
+                    ...context,
+                    ...options,
+                    execution: context.execution,
+                    outputs: options.outputs ?? context.outputs,
+                    parentNodeId: node.id,
+                    parentStepExecutionKey: step.stepExecutionKey,
+                }),
+                emitLog: async (entry) => {
+                    await this.writer.writeLog(context.execution, step, entry, this.nextLogSequence(context));
+                },
+                emitArtifact: async (entry) => {
+                    await this.writer.writeArtifact(context.execution, step, entry);
+                },
+            });
+            const output = result.output ?? {};
+            context.outputs[node.id] = this.getRuntimeContextOutput(node, output);
+            for (const artifact of result.artifacts ?? []) {
+                await this.writer.writeArtifact(context.execution, step, artifact);
+            }
+            await this.writer.completeStep(step, result.status ?? 'success', output, {
+                item: context.item,
+                index: context.index,
+            });
+            await this.writer.writeLog(context.execution, step, {
+                level: 'debug',
+                eventType: 'node.completed',
+                message: `Completed node ${node.id} (${node.type}).`,
+                metadata: {
+                    ...this.nodeLogMetadata(node, context, step),
+                    status: result.status ?? 'success',
+                    durationMs: Date.now() - startedAtMs,
+                    outputSummary: this.summarizeValue(output),
+                    artifactCount: result.artifacts?.length ?? 0,
+                },
+            }, this.nextLogSequence(context));
+            return output;
+        }
+        catch (error) {
+            await this.writer.failStep(step, error);
+            if (node.onError === 'continue') {
+                context.outputs[node.id] = {
+                    error: error instanceof Error ? error.message : String(error),
+                };
+                await this.writer.writeLog(context.execution, step, {
+                    level: 'warn',
+                    eventType: 'node.failed.continued',
+                    message: `Node ${node.id} failed but workflow continued: ${this.errorMessage(error)}.`,
+                    context: this.summarizeError(error),
+                    metadata: this.nodeLogMetadata(node, context, step),
+                }, this.nextLogSequence(context));
+                return context.outputs[node.id];
+            }
+            await this.writer.writeLog(context.execution, step, {
+                level: 'error',
+                eventType: 'node.failed',
+                message: `Node ${node.id} failed: ${this.errorMessage(error)}.`,
+                context: this.summarizeError(error),
+                metadata: this.nodeLogMetadata(node, context, step),
+            }, this.nextLogSequence(context));
+            await this.runLocalErrorHandlers(node, context, error);
+            throw error;
+        }
+    }
+    async runGlobalErrorHandlers(definitionDsl, context, error) {
+        const errorNodes = definitionDsl.errors ?? [];
+        if (!errorNodes.length) {
+            return;
+        }
+        await this.runErrorHandlers(errorNodes, context, error, 'global', undefined, undefined);
+    }
+    async runFinallyHandlers(definitionDsl, context) {
+        const finallyNodes = definitionDsl.finally ?? [];
+        if (!finallyNodes.length) {
+            return;
+        }
+        await this.writer.writeLog(context.execution, undefined, {
+            level: 'info',
+            eventType: 'finally.started',
+            message: 'Running workflow finally handlers.',
+            metadata: {
+                handlerNodeCount: finallyNodes.length,
+            },
+        }, this.nextLogSequence(context));
+        await this.runNodes(finallyNodes, context);
+        await this.writer.writeLog(context.execution, undefined, {
+            level: 'info',
+            eventType: 'finally.completed',
+            message: 'Workflow finally handlers completed.',
+            metadata: {
+                handlerNodeCount: finallyNodes.length,
+            },
+        }, this.nextLogSequence(context));
+    }
+    async runLocalErrorHandlers(node, context, error) {
+        const errorNodes = node.errors ?? [];
+        if (!errorNodes.length) {
+            return;
+        }
+        await this.runErrorHandlers(errorNodes, context, error, 'local', node.id, context.stepExecution?.stepExecutionKey);
+    }
+    async runErrorHandlers(errorNodes, context, error, scope, sourceNodeId, sourceStepExecutionKey) {
+        const errorContext = this.buildErrorContext(error, sourceNodeId, sourceStepExecutionKey);
+        await this.writer.writeLog(context.execution, undefined, {
+            level: 'warn',
+            eventType: `error-handler.${scope}.started`,
+            message: scope === 'global'
+                ? 'Running workflow-level error handlers.'
+                : `Running local error handlers for node ${sourceNodeId}.`,
+            context: errorContext,
+            metadata: {
+                sourceNodeId,
+                sourceStepExecutionKey,
+                handlerNodeCount: errorNodes.length,
+            },
+        }, this.nextLogSequence(context));
+        try {
+            await this.runNodes(errorNodes, {
+                ...context,
+                error: errorContext,
+                parentNodeId: sourceNodeId ?? context.parentNodeId,
+                parentStepExecutionKey: sourceStepExecutionKey ?? context.parentStepExecutionKey,
+            });
+        }
+        catch (handlerError) {
+            await this.writer.writeLog(context.execution, undefined, {
+                level: 'error',
+                eventType: `error-handler.${scope}.failed`,
+                message: `Error handler failed: ${this.errorMessage(handlerError)}.`,
+                context: this.summarizeError(handlerError),
+                metadata: {
+                    originalError: errorContext,
+                    sourceNodeId,
+                    sourceStepExecutionKey,
+                },
+            }, this.nextLogSequence(context));
+            return;
+        }
+        await this.writer.writeLog(context.execution, undefined, {
+            level: 'info',
+            eventType: `error-handler.${scope}.completed`,
+            message: scope === 'global'
+                ? 'Workflow-level error handlers completed.'
+                : `Local error handlers completed for node ${sourceNodeId}.`,
+            context: errorContext,
+            metadata: {
+                sourceNodeId,
+                sourceStepExecutionKey,
+            },
+        }, this.nextLogSequence(context));
+    }
+    buildErrorContext(error, nodeId, stepExecutionKey) {
+        const summary = this.summarizeError(error);
+        return {
+            ...summary,
+            message: this.errorMessage(error),
+            nodeId,
+            stepExecutionKey,
+        };
+    }
+    assertDefinitionYaml(value) {
+        if (!value || typeof value !== 'string') {
+            throw new common_1.BadRequestException('Workflow definition YAML must be stored as a string.');
+        }
+        let parsed;
+        try {
+            parsed = yaml_1.default.parse(value);
+        }
+        catch (error) {
+            throw new common_1.BadRequestException(error?.message ?? 'Workflow definition YAML could not be parsed.');
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new common_1.BadRequestException('Workflow definition YAML must resolve to an object with a nodes array.');
+        }
+        if (!Array.isArray(parsed.nodes)) {
+            throw new common_1.BadRequestException('Workflow definition YAML must include a nodes array.');
+        }
+        return parsed;
+    }
+    readEnqueuedExecutionRequest(execution) {
+        const payload = execution.inputPayload;
+        if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+            return {
+                triggerType: execution.triggerType,
+                requestedByUserId: execution.requestedByUserId,
+            };
+        }
+        return {
+            ...payload,
+            triggerType: payload.triggerType ?? execution.triggerType,
+            requestedByUserId: payload.requestedByUserId ??
+                execution.requestedByUserId,
+        };
+    }
+    async findExecutionOrThrow(executionId) {
+        const execution = await this.entityManager.findOne(workflow_execution_entity_1.WorkflowExecution, {
+            where: { id: executionId },
+        });
+        if (!execution) {
+            throw new common_1.NotFoundException(`Workflow execution ${executionId} not found.`);
+        }
+        return execution;
+    }
+    toStepOutputResponse(step) {
+        return {
+            id: step.id,
+            stepExecutionKey: step.stepExecutionKey,
+            nodeId: step.nodeId,
+            nodeName: step.nodeName,
+            nodeType: step.nodeType,
+            nodeKind: step.nodeKind,
+            sequenceNumber: step.sequenceNumber,
+            attemptNumber: step.attemptNumber,
+            status: step.status,
+            startedAt: step.startedAt,
+            finishedAt: step.finishedAt,
+            durationMs: step.durationMs,
+            runtimeContext: step.runtimeContext,
+            outputPayload: step.outputPayload,
+            errorSummary: step.errorSummary,
+        };
+    }
+    buildPagedMeta(offset, limit, totalRecords) {
+        const currentPage = limit ? Math.floor(offset / limit) + 1 : 1;
+        const totalPages = limit ? Math.max(1, Math.ceil(totalRecords / limit)) : 1;
+        return {
+            totalRecords,
+            currentPage,
+            nextPage: currentPage < totalPages ? currentPage + 1 : null,
+            prevPage: currentPage > 1 ? currentPage - 1 : null,
+            totalPages,
+            perPage: limit,
+        };
+    }
+    toResponse(execution) {
+        return {
+            id: execution.id,
+            executionIdentifier: execution.executionIdentifier,
+            workflowKey: execution.workflowKey,
+            status: execution.status,
+            startedAt: execution.startedAt,
+            finishedAt: execution.finishedAt,
+            durationMs: execution.durationMs,
+            outputPayload: execution.outputPayload,
+            errorSummary: execution.errorSummary,
+        };
+    }
+    nextStepSequence(context) {
+        context.counters = context.counters ?? { step: 0, log: 0 };
+        context.counters.step += 1;
+        return context.counters.step;
+    }
+    nextLogSequence(context) {
+        context.counters = context.counters ?? { step: 0, log: 0 };
+        context.counters.log += 1;
+        return context.counters.log;
+    }
+    countNodes(nodes = []) {
+        return nodes.reduce((count, node) => {
+            const nestedNodes = [
+                ...(node.tasks ?? []),
+                ...(node.then ?? []),
+                ...(node.else ?? []),
+                ...(node.defaults ?? []),
+                ...(node.errors ?? []),
+                ...Object.values(node.cases ?? {}).flat(),
+            ];
+            return count + 1 + this.countNodes(nestedNodes);
+        }, 0);
+    }
+    nodeLogMetadata(node, context, step) {
+        return {
+            executionIdentifier: context.execution.executionIdentifier,
+            stepExecutionKey: step?.stepExecutionKey,
+            nodeId: node.id,
+            nodeName: node.name,
+            nodeType: node.type,
+            nodeKind: node.kind,
+            parentNodeId: context.parentNodeId,
+            parentStepExecutionKey: context.parentStepExecutionKey,
+            index: context.index,
+            hasItem: context.item !== undefined,
+            configurationKeys: node.configuration && typeof node.configuration === 'object'
+                ? Object.keys(node.configuration)
+                : [],
+            availableInputKeys: Object.keys(context.input ?? {}),
+            availableVariableKeys: Object.keys(context.variables ?? {}),
+            availableOutputNodeIds: Object.keys(context.outputs ?? {}),
+        };
+    }
+    getRuntimeContextOutput(node, output) {
+        const hiddenOutputPaths = this.registry
+            .getMetadata(node.type)
+            .authoring?.outputs?.filter((definition) => definition.includeInRuntimeContext === false)
+            .map((definition) => definition.path ?? definition.key)
+            .filter(Boolean) ?? [];
+        if (!hiddenOutputPaths.length || !output || typeof output !== 'object') {
+            return output;
+        }
+        const runtimeOutput = this.cloneOutput(output);
+        hiddenOutputPaths.forEach((path) => {
+            this.deletePath(runtimeOutput, path);
+        });
+        return runtimeOutput;
+    }
+    cloneOutput(output) {
+        if (typeof structuredClone === 'function') {
+            return structuredClone(output);
+        }
+        return JSON.parse(JSON.stringify(output));
+    }
+    deletePath(target, path) {
+        const parts = path.split('.').filter(Boolean);
+        if (!parts.length) {
+            return;
+        }
+        let cursor = target;
+        for (let index = 0; index < parts.length - 1; index += 1) {
+            cursor = cursor?.[parts[index]];
+            if (!cursor || typeof cursor !== 'object') {
+                return;
+            }
+        }
+        if (cursor && typeof cursor === 'object') {
+            delete cursor[parts[parts.length - 1]];
+        }
+    }
+    summarizeValue(value) {
+        if (Array.isArray(value)) {
+            return {
+                type: 'array',
+                length: value.length,
+            };
+        }
+        if (value && typeof value === 'object') {
+            return {
+                type: 'object',
+                keys: Object.keys(value),
+            };
+        }
+        return {
+            type: value === null ? 'null' : typeof value,
+            empty: value === undefined || value === null || value === '',
+        };
+    }
+    errorMessage(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+    summarizeError(error) {
+        if (error instanceof Error) {
+            return {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+            };
+        }
+        return { error };
+    }
+};
+exports.WorkflowRuntimeService = WorkflowRuntimeService;
+exports.WorkflowRuntimeService = WorkflowRuntimeService = WorkflowRuntimeService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectEntityManager)('default')),
+    __metadata("design:paramtypes", [typeorm_2.EntityManager,
+        workflow_node_registry_service_1.WorkflowNodeRegistryService,
+        workflow_expression_service_1.WorkflowExpressionService,
+        workflow_execution_writer_service_1.WorkflowExecutionWriterService,
+        workflow_definition_validator_service_1.WorkflowDefinitionValidatorService,
+        workflow_secret_service_1.WorkflowSecretService,
+        publisher_factory_service_1.PublisherFactory])
+], WorkflowRuntimeService);
+//# sourceMappingURL=workflow-runtime.service.js.map