@codemation/core 0.0.5 → 0.0.7

package/dist/bootstrap/index.cjs

@@ -1,4 +1,4 @@
-const require_RunIntentService = require('../RunIntentService-2ivFmNQh.cjs');
+const require_RunIntentService = require('../RunIntentService-DlQH5eZ2.cjs');
 const require_InMemoryLiveWorkflowRepository = require('../InMemoryLiveWorkflowRepository-BTzHpQ6e.cjs');
 let tsyringe = require("tsyringe");
 tsyringe = require_RunIntentService.__toESM(tsyringe);
@@ -149,6 +149,125 @@ var InMemoryWorkflowExecutionRepository = class {
 	}
 };
 
+//#endregion
+//#region src/orchestration/NodeExecutionRequestHandlerService.ts
+var NodeExecutionRequestHandlerService = class {
+	constructor(workflowExecutionRepository, workflowSnapshotResolver, runDataFactory, runExecutionContextFactory, nodeStatePublisherFactory, nodeActivationRequestComposer, nodeExecutor, continuation, executionLimitsPolicy) {
+		this.workflowExecutionRepository = workflowExecutionRepository;
+		this.workflowSnapshotResolver = workflowSnapshotResolver;
+		this.runDataFactory = runDataFactory;
+		this.runExecutionContextFactory = runExecutionContextFactory;
+		this.nodeStatePublisherFactory = nodeStatePublisherFactory;
+		this.nodeActivationRequestComposer = nodeActivationRequestComposer;
+		this.nodeExecutor = nodeExecutor;
+		this.continuation = continuation;
+		this.executionLimitsPolicy = executionLimitsPolicy;
+	}
+	async handleNodeExecutionRequest(request) {
+		const state = await this.workflowExecutionRepository.load(request.runId);
+		if (!state) throw new Error(`Unknown runId: ${request.runId}`);
+		if (state.workflowId !== request.workflowId) throw new Error(`workflowId mismatch for run ${request.runId}: ${state.workflowId} vs ${request.workflowId}`);
+		if (state.status !== "pending" || !state.pending) return;
+		if (state.pending.activationId !== request.activationId || state.pending.nodeId !== request.nodeId) return;
+		const workflow = this.resolvePersistedWorkflow(state);
+		if (!workflow) throw new Error(`Unknown workflowId: ${state.workflowId}`);
+		const definition = workflow.nodes.find((node) => node.id === request.nodeId);
+		if (!definition) throw new Error(`Unknown nodeId: ${request.nodeId}`);
+		if (definition.kind !== "node") throw new Error(`Node ${request.nodeId} is not runnable`);
+		const resolvedParent = request.parent ?? state.parent;
+		const data = this.runDataFactory.create(state.outputsByNode);
+		const limits = this.resolveEngineLimitsFromState(state);
+		const base = this.runExecutionContextFactory.create({
+			runId: state.runId,
+			workflowId: state.workflowId,
+			nodeId: request.nodeId,
+			parent: resolvedParent,
+			subworkflowDepth: state.executionOptions?.subworkflowDepth ?? 0,
+			engineMaxNodeActivations: limits.engineMaxNodeActivations,
+			engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
+			data,
+			nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, resolvedParent)
+		});
+		const activationRequest = this.nodeActivationRequestComposer.createSingleFromDefinitionWithActivation({
+			activationId: request.activationId,
+			runId: request.runId,
+			workflowId: request.workflowId,
+			parent: resolvedParent,
+			executionOptions: request.executionOptions ?? state.executionOptions,
+			base,
+			data,
+			definition: {
+				id: definition.id,
+				config: definition.config
+			},
+			batchId: state.pending.batchId ?? "batch_1",
+			input: request.input
+		});
+		await this.continuation.markNodeRunning({
+			runId: activationRequest.runId,
+			activationId: activationRequest.activationId,
+			nodeId: activationRequest.nodeId,
+			inputsByPort: { in: activationRequest.input }
+		});
+		let outputs;
+		try {
+			outputs = await this.nodeExecutor.execute(activationRequest);
+		} catch (error) {
+			await this.resumeAfterExecutionError(activationRequest, this.asError(error));
+			return;
+		}
+		await this.resumeAfterExecutionResult(activationRequest, outputs ?? {});
+	}
+	resolvePersistedWorkflow(state) {
+		return this.workflowSnapshotResolver.resolve({
+			workflowId: state.workflowId,
+			workflowSnapshot: state.workflowSnapshot
+		});
+	}
+	resolveEngineLimitsFromState(state) {
+		const fallback = this.executionLimitsPolicy.createRootExecutionOptions();
+		return {
+			engineMaxNodeActivations: state.executionOptions?.maxNodeActivations ?? fallback.maxNodeActivations,
+			engineMaxSubworkflowDepth: state.executionOptions?.maxSubworkflowDepth ?? fallback.maxSubworkflowDepth
+		};
+	}
+	async resumeAfterExecutionResult(request, outputs) {
+		try {
+			await this.continuation.resumeFromNodeResult({
+				runId: request.runId,
+				activationId: request.activationId,
+				nodeId: request.nodeId,
+				outputs
+			});
+		} catch (error) {
+			this.rethrowUnlessIgnorableContinuationError(error);
+		}
+	}
+	async resumeAfterExecutionError(request, error) {
+		try {
+			await this.continuation.resumeFromNodeError({
+				runId: request.runId,
+				activationId: request.activationId,
+				nodeId: request.nodeId,
+				error
+			});
+		} catch (continuationError) {
+			this.rethrowUnlessIgnorableContinuationError(continuationError);
+		}
+	}
+	asError(error) {
+		return error instanceof Error ? error : new Error(String(error));
+	}
+	rethrowUnlessIgnorableContinuationError(error) {
+		if (this.isIgnorableContinuationError(error)) return;
+		throw this.asError(error);
+	}
+	isIgnorableContinuationError(error) {
+		const message = this.asError(error).message;
+		return message.includes(" is not pending") || message.includes("activationId mismatch") || message.includes("nodeId mismatch");
+	}
+};
+
 //#endregion
 //#region src/planning/RunQueuePlanner.ts
 var RunQueuePlanner = class {
@@ -705,6 +824,9 @@ var Engine = class {
 	async waitForWebhookResponse(runId) {
 		return await this.deps.runContinuationService.waitForWebhookResponse(runId);
 	}
+	async handleNodeExecutionRequest(request) {
+		await this.deps.nodeExecutionRequestHandler.handleNodeExecutionRequest(request);
+	}
 };
 
 //#endregion
@@ -735,6 +857,7 @@ var EngineFactory = class {
 		const policyErrorServices = new WorkflowPolicyErrorServices(deps.nodeResolver);
 		const runStartService = new require_RunIntentService.RunStartService(deps.runIdFactory, deps.workflowExecutionRepository, deps.runDataFactory, workflowSnapshotCodec, planningFactory, nodeStatePublisherFactory, runExecutionContextFactory, nodeActivationRequestComposer, activationEnqueueService, semantics, waiters, deps.workflowPolicyRuntimeDefaults, executionLimitsPolicy);
 		const runContinuationService = new require_RunIntentService.RunContinuationService(deps.activationIdFactory, deps.workflowExecutionRepository, deps.runDataFactory, runExecutionContextFactory, workflowSnapshotResolver, planningFactory, nodeStatePublisherFactory, credentialResolverFactory, nodeActivationRequestComposer, persistedRunStateTerminalBuilder, activationEnqueueService, nodeEventPublisher, semantics, waiters, policyErrorServices, terminalPersistence, executionLimitsPolicy);
+		const nodeExecutionRequestHandler = new NodeExecutionRequestHandlerService(deps.workflowExecutionRepository, workflowSnapshotResolver, deps.runDataFactory, runExecutionContextFactory, nodeStatePublisherFactory, nodeActivationRequestComposer, deps.nodeExecutor, runContinuationService, executionLimitsPolicy);
 		const triggerRuntime = new TriggerRuntimeService(deps.workflowRepository, deps.workflowActivationPolicy, deps.runIdFactory, deps.runDataFactory, deps.executionContextFactory, credentialResolverFactory, nodeStatePublisherFactory, deps.nodeResolver, deps.triggerSetupStateRepository, { emit: async (workflow, triggerNodeId, items) => {
 			await runStartService.runWorkflow(workflow, triggerNodeId, items, void 0);
 		} }, executionLimitsPolicy, deps.triggerRuntimeDiagnostics);
@@ -745,7 +868,8 @@ var EngineFactory = class {
 			workflowSnapshotResolver,
 			triggerRuntime,
 			runStartService,
-			runContinuationService
+			runContinuationService,
+			nodeExecutionRequestHandler
 		});
 		deps.activationScheduler.setContinuation?.(engine);
 		return engine;
@@ -903,6 +1027,7 @@ var EngineRuntimeRegistrar = class {
 		this.registerSupportFactories(container);
 		this.registerExecutionLimitsPolicy(container, options);
 		this.ensureWorkflowNodeInstanceFactory(container);
+		this.ensureNodeExecutor(container);
 		this.registerDefaultActivationScheduler(container);
 		this.registerEngine(container, options);
 		this.registerIntentServices(container);
@@ -931,12 +1056,15 @@ var EngineRuntimeRegistrar = class {
 			return dependencyContainer.resolve(require_RunIntentService.NodeInstanceFactoryFactory).create(dependencyContainer.resolve(require_RunIntentService.CoreTokens.NodeResolver));
 		}) });
 	}
-	registerDefaultActivationScheduler(container) {
-		if (container.isRegistered(require_RunIntentService.CoreTokens.NodeActivationScheduler, true)) return;
+	ensureNodeExecutor(container) {
+		if (container.isRegistered(require_RunIntentService.NodeExecutor, true)) return;
 		container.register(require_RunIntentService.NodeExecutor, { useFactory: (0, tsyringe.instanceCachingFactory)((dependencyContainer) => {
 			const retryRunner = dependencyContainer.resolve(require_RunIntentService.InProcessRetryRunnerFactory).create(dependencyContainer.resolve(require_RunIntentService.DefaultAsyncSleeper));
 			return dependencyContainer.resolve(require_RunIntentService.NodeExecutorFactory).create(dependencyContainer.resolve(require_RunIntentService.CoreTokens.WorkflowNodeInstanceFactory), retryRunner);
 		}) });
+	}
+	registerDefaultActivationScheduler(container) {
+		if (container.isRegistered(require_RunIntentService.CoreTokens.NodeActivationScheduler, true)) return;
 		container.register(require_RunIntentService.InlineDrivingScheduler, { useFactory: (0, tsyringe.instanceCachingFactory)((dependencyContainer) => {
 			return dependencyContainer.resolve(InlineDrivingSchedulerFactory).create(dependencyContainer.resolve(require_RunIntentService.NodeExecutor));
 		}) });
@@ -969,6 +1097,7 @@ var EngineRuntimeRegistrar = class {
 				activationScheduler: dependencyContainer.resolve(require_RunIntentService.CoreTokens.NodeActivationScheduler),
 				runDataFactory: dependencyContainer.resolve(require_RunIntentService.CoreTokens.RunDataFactory),
 				executionContextFactory: dependencyContainer.resolve(require_RunIntentService.CoreTokens.ExecutionContextFactory),
+				nodeExecutor: dependencyContainer.resolve(require_RunIntentService.NodeExecutor),
 				eventBus: dependencyContainer.resolve(require_RunIntentService.CoreTokens.RunEventBus),
 				tokenRegistry: tokenRegistryLike,
 				workflowNodeInstanceFactory,