@codemation/core 0.0.5 → 0.0.11

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import { $ as JsonArray, $n as CurrentStateExecutionRequest, $r as RunEventSubscription, $t as BinaryBody, A as CredentialJsonRecord, An as TriggerRuntimeDiagnostics, Ar as Container, At as TriggerNodeOutputJson, B as CredentialTypeId, Bn as WorkflowSnapshotResolver, Br as injectAll, Bt as WorkflowNodeConnection, C as CredentialBindingKey, Cn as NodeExecutionStatePublisher, Cr as RunStatus, Ct as RunDataSnapshot, D as CredentialHealthTester, Dn as TestableTriggerNode, Dr as WorkflowExecutionListingRepository, Dt as RunnableNodeInputJson, E as CredentialHealthStatus, En as PersistedTriggerSetupState, Er as WebhookRunResult, Et as RunnableNodeConfig, F as CredentialSessionFactoryArgs, Fn as WorkflowNodeInstanceFactory, Fr as RegistrationOptions, Ft as WorkflowErrorHandler, G as BinaryAttachment, Gn as WebhookTriggerMatcher, Gr as registry, Gt as WorkflowStoragePolicyResolver, H as CredentialUnboundError, Hn as TriggerInstanceId, Hr as instanceCachingFactory, Ht as WorkflowPrunePolicySpec, I as CredentialSessionService, In as WorkflowRepository, Ir as TypeToken, It as WorkflowErrorHandlerSpec, J as ExecutionMode, Jn as AllWorkflowsActiveWorkflowActivationPolicy, Jt as runnableNodeInputType, K as BinaryPreviewKind, Kn as WebhookTriggerResolution, Kr as singleton, Kt as WorkflowStoragePolicySpec, L as CredentialSetupStatus, Ln as WorkflowRunnerResolver, Lr as container, Lt as WorkflowGraph, M as CredentialOAuth2AuthDefinition, Mn as TriggerSetupStateFor, Mr as Disposable, Mt as UpstreamRefPlaceholder, N as CredentialRequirement, Nn as TriggerSetupStateRepository, Nr as InjectionToken, Nt as WorkflowDefinition, O as CredentialInstanceId, On as TriggerCleanupHandle, Or as WorkflowExecutionPruneRepository, Ot as RunnableNodeOutputJson, P as CredentialSessionFactory, Pn as TriggerTestItemsContext, Pr as Lifecycle, Pt as WorkflowErrorContext, Q as Items, Qn as ConnectionInvocationRecord, Qr as RunEventBus, Qt as BinaryAttachmentCreateRequest, R as CredentialType, Rn as WorkflowRunnerService, Rr as delay, Rt as WorkflowGraphFactory, S as CredentialBinding, Sn as NodeExecutionScheduler, Sr as RunStateResetRequest, St as RunDataFactory, T as CredentialHealth, Tn as NodeResolver, Tr as RunSummary, Tt as RunIdFactory, U as OAuth2ProviderFromPublicConfig, Un as WebhookControlSignal, Ur as instancePerContainerCachingFactory, Ut as WorkflowStoragePolicyDecisionArgs, V as CredentialTypeRegistry, Vn as HttpMethod, Vr as injectable, Vt as WorkflowPolicyRuntimeDefaults, W as ActivationIdFactory, Wn as WebhookInvocationMatch, Wr as predicateAwareClassFactory, Wt as WorkflowStoragePolicyMode, X as Item, Xn as ConnectionInvocationAppendArgs, Xr as EngineExecutionLimitsPolicyConfig, Xt as triggerNodeOutputType, Y as InputPortKey, Yn as WorkflowActivationPolicy, Yr as EngineExecutionLimitsPolicy, Yt as runnableNodeOutputType, Z as ItemBinary, Zn as ConnectionInvocationId, Zr as RunEvent, Zt as triggerNodeSetupStateType, _ as StepSequenceOutput, _n as NodeActivationRequestBase, _r as RunEventPublisherDeps, _t as OutputPortKey, a as WorkflowExecutableNodeClassifier, ai as NoneRetryPolicySpec, an as EngineDeps, ar as NodeInputsByPort, at as NodeConfigBase, b as AnyCredentialType, bn as NodeExecutionContext, br as RunQueueEntry, bt as PersistedRunPolicySnapshot, c as WorkflowBuilder, cn as ExecutionBinaryService, cr as PersistedMutableRunState, ct as NodeErrorHandler, d as AnyRunnableNodeConfig, dn as LiveWorkflowRepository, dr as PersistedWorkflowSnapshot, dt as NodeId, ei as ExpRetryPolicy, en as BinaryStorage, er as EngineRunCounters, et as JsonObject, f as AnyTriggerNodeConfig, fn as MultiInputNode, fr as PersistedWorkflowSnapshotNode, ft as NodeKind, g as BranchStepsArg, gn as NodeActivationRequest, gr as RunCurrentState, gt as NodeSchedulerDecision, h as BranchOutputGuard, hn as NodeActivationReceipt, hr as RunCompletionNotifier, ht as NodeRef, i as WorkflowExecutableNodeClassifierFactory, ii as FixedRetryPolicySpec, in as BinaryStorageWriteResult, ir as NodeExecutionStatus, it as NodeActivationId, j as CredentialMaterialSourceKind, jn as TriggerSetupContext, jr as DependencyContainer, jt as TriggerNodeSetupState, k as CredentialInstanceRecord, kn as TriggerNode, kr as WorkflowExecutionRepository, kt as TriggerNodeConfig, l as ChainCursor, ln as ExecutionContext, lr as PersistedRunControlState, lt as NodeErrorHandlerArgs, m as BranchMoreArgs, mn as NodeActivationContinuation, mr as PinnedNodeOutputsByPort, mt as NodeOutputs, ni as NoRetryPolicy, nn as BinaryStorageStatResult, nr as NodeExecutionError, nt as JsonValue, o as ConnectionNodeIdFactory, oi as RetryPolicySpec, on as EngineHost, or as PendingNodeExecution, ot as NodeConnectionName, p as BooleanWhenOverloads, pn as Node, pr as PersistedWorkflowTokenRegistryLike, pt as NodeOffloadPolicy, q as Edge, qn as WebhookTriggerRoutingDiagnostics, qr as CoreTokens, qt as branchRef, r as DefaultWorkflowGraphFactory, ri as ExponentialRetryPolicySpec, rn as BinaryStorageWriteRequest, rr as NodeExecutionSnapshot, rt as MutableRunData, s as ConnectionInvocationIdFactory, sn as ExecutableTriggerNode, sr as PersistedMutableNodeState, st as NodeDefinition, t as InMemoryLiveWorkflowRepository, ti as RetryPolicy, tn as BinaryStorageReadResult, tr as ExecutionFrontierPlan, tt as JsonPrimitive, u as WhenBuilder, un as ExecutionContextFactory, ur as PersistedRunState, ut as NodeErrorHandlerSpec, v as ValidStepSequence, vn as NodeActivationScheduler, vr as RunExecutionOptions, vt as PairedItemRef, w as CredentialFieldSchema, wn as NodeExecutor, wr as RunStopCondition, wt as RunId, x as CredentialAuthDefinition, xn as NodeExecutionRequest, xr as RunResult, xt as PersistedTokenId, y as RunFinishedAtFactory, yn as NodeBinaryAttachmentService, yr as RunPruneCandidate, yt as ParentExecutionRef, z as CredentialTypeDefinition, zn as WorkflowSnapshotFactory, zr as inject, zt as WorkflowId } from "./InMemoryLiveWorkflowRepository-DL7LmC9S.js";
-import { A as PersistedRuntimeTypeKind, B as AgentToolCallPlanner, C as node, D as PersistedRuntimeTypeMetadataStore, E as PersistedRuntimeTypeNameResolver, F as AgentCanvasPresentation, G as ChatModelFactory, H as AgentToolExecuteArgs, I as AgentConfigInspector, J as ToolConfig, K as LangChainChatModelLike, L as AgentNodeConfig, M as EventPublishingWorkflowExecutionRepository, N as InMemoryRunEventBus, O as InjectableRuntimeDecoratorComposer, P as AgentAttachmentRole, Q as SystemClock, R as AgentTool, S as getPersistedRuntimeTypeMetadata, T as StackTraceCallSitePathResolver, U as AgentToolToken, V as AgentToolDefinition, W as ChatModelConfig, X as ZodSchemaAny, Y as ToolExecuteArgs, Z as Clock, at as CredentialResolverFactory, b as ItemsInputNormalizer, d as InMemoryRunDataFactory, f as InMemoryBinaryStorage, j as PersistedRuntimeTypeMetadata, k as PersistedRuntimeTypeDecoratorOptions, nt as DefaultExecutionContextFactory, ot as NodeEventPublisher, q as Tool, rt as DefaultAsyncSleeper, s as RunIntentService, tt as InProcessRetryRunner, v as DefaultExecutionBinaryService, w as tool, x as chatModel, y as UnavailableBinaryStorage, z as AgentToolCall } from "./index-9g6Pfe9Z.js";
-export { ActivationIdFactory, AgentAttachmentRole, AgentCanvasPresentation, AgentConfigInspector, AgentNodeConfig, AgentTool, AgentToolCall, AgentToolCallPlanner, AgentToolDefinition, AgentToolExecuteArgs, AgentToolToken, AllWorkflowsActiveWorkflowActivationPolicy, AnyCredentialType, AnyRunnableNodeConfig, AnyTriggerNodeConfig, BinaryAttachment, BinaryAttachmentCreateRequest, BinaryBody, BinaryPreviewKind, BinaryStorage, BinaryStorageReadResult, BinaryStorageStatResult, BinaryStorageWriteRequest, BinaryStorageWriteResult, BooleanWhenOverloads, BranchMoreArgs, BranchOutputGuard, BranchStepsArg, ChainCursor, ChatModelConfig, ChatModelFactory, Clock, ConnectionInvocationAppendArgs, ConnectionInvocationId, ConnectionInvocationIdFactory, ConnectionInvocationRecord, ConnectionNodeIdFactory, Container, CoreTokens, CredentialAuthDefinition, CredentialBinding, CredentialBindingKey, CredentialFieldSchema, CredentialHealth, CredentialHealthStatus, CredentialHealthTester, CredentialInstanceId, CredentialInstanceRecord, CredentialJsonRecord, CredentialMaterialSourceKind, CredentialOAuth2AuthDefinition, CredentialRequirement, CredentialResolverFactory, CredentialSessionFactory, CredentialSessionFactoryArgs, CredentialSessionService, CredentialSetupStatus, CredentialType, CredentialTypeDefinition, CredentialTypeId, CredentialTypeRegistry, CredentialUnboundError, CurrentStateExecutionRequest, DefaultAsyncSleeper, DefaultExecutionBinaryService, DefaultExecutionContextFactory, DefaultWorkflowGraphFactory, DependencyContainer, Disposable, Edge, EngineDeps, EngineExecutionLimitsPolicy, EngineExecutionLimitsPolicyConfig, EngineHost, EngineRunCounters, EventPublishingWorkflowExecutionRepository, ExecutableTriggerNode, ExecutionBinaryService, ExecutionContext, ExecutionContextFactory, ExecutionFrontierPlan, ExecutionMode, ExpRetryPolicy, ExponentialRetryPolicySpec, FixedRetryPolicySpec, HttpMethod, InMemoryBinaryStorage, InMemoryLiveWorkflowRepository, InMemoryRunDataFactory, InMemoryRunEventBus, InProcessRetryRunner, InjectableRuntimeDecoratorComposer, InjectionToken, InputPortKey, Item, ItemBinary, Items, ItemsInputNormalizer, JsonArray, JsonObject, JsonPrimitive, JsonValue, LangChainChatModelLike, Lifecycle, LiveWorkflowRepository, MultiInputNode, MutableRunData, NoRetryPolicy, Node, NodeActivationContinuation, NodeActivationId, NodeActivationReceipt, NodeActivationRequest, NodeActivationRequestBase, NodeActivationScheduler, NodeBinaryAttachmentService, NodeConfigBase, NodeConnectionName, NodeDefinition, NodeErrorHandler, NodeErrorHandlerArgs, NodeErrorHandlerSpec, NodeEventPublisher, NodeExecutionContext, NodeExecutionError, NodeExecutionRequest, NodeExecutionScheduler, NodeExecutionSnapshot, NodeExecutionStatePublisher, NodeExecutionStatus, NodeExecutor, NodeId, NodeInputsByPort, NodeKind, NodeOffloadPolicy, NodeOutputs, NodeRef, NodeResolver, NodeSchedulerDecision, NoneRetryPolicySpec, OAuth2ProviderFromPublicConfig, OutputPortKey, PairedItemRef, ParentExecutionRef, PendingNodeExecution, PersistedMutableNodeState, PersistedMutableRunState, PersistedRunControlState, PersistedRunPolicySnapshot, PersistedRunState, PersistedRuntimeTypeDecoratorOptions, PersistedRuntimeTypeKind, PersistedRuntimeTypeMetadata, PersistedRuntimeTypeMetadataStore, PersistedRuntimeTypeNameResolver, PersistedTokenId, PersistedTriggerSetupState, PersistedWorkflowSnapshot, PersistedWorkflowSnapshotNode, PersistedWorkflowTokenRegistryLike, PinnedNodeOutputsByPort, RegistrationOptions, RetryPolicy, RetryPolicySpec, RunCompletionNotifier, RunCurrentState, RunDataFactory, RunDataSnapshot, RunEvent, RunEventBus, RunEventPublisherDeps, RunEventSubscription, RunExecutionOptions, RunFinishedAtFactory, RunId, RunIdFactory, RunIntentService, RunPruneCandidate, RunQueueEntry, RunResult, RunStateResetRequest, RunStatus, RunStopCondition, RunSummary, RunnableNodeConfig, RunnableNodeInputJson, RunnableNodeOutputJson, StackTraceCallSitePathResolver, StepSequenceOutput, SystemClock, TestableTriggerNode, Tool, ToolConfig, ToolExecuteArgs, TriggerCleanupHandle, TriggerInstanceId, TriggerNode, TriggerNodeConfig, TriggerNodeOutputJson, TriggerNodeSetupState, TriggerRuntimeDiagnostics, TriggerSetupContext, TriggerSetupStateFor, TriggerSetupStateRepository, TriggerTestItemsContext, TypeToken, UnavailableBinaryStorage, UpstreamRefPlaceholder, ValidStepSequence, WebhookControlSignal, WebhookInvocationMatch, WebhookRunResult, WebhookTriggerMatcher, WebhookTriggerResolution, WebhookTriggerRoutingDiagnostics, WhenBuilder, WorkflowActivationPolicy, WorkflowBuilder, WorkflowDefinition, WorkflowErrorContext, WorkflowErrorHandler, WorkflowErrorHandlerSpec, WorkflowExecutableNodeClassifier, WorkflowExecutableNodeClassifierFactory, WorkflowExecutionListingRepository, WorkflowExecutionPruneRepository, WorkflowExecutionRepository, WorkflowGraph, WorkflowGraphFactory, WorkflowId, WorkflowNodeConnection, WorkflowNodeInstanceFactory, WorkflowPolicyRuntimeDefaults, WorkflowPrunePolicySpec, WorkflowRepository, WorkflowRunnerResolver, WorkflowRunnerService, WorkflowSnapshotFactory, WorkflowSnapshotResolver, WorkflowStoragePolicyDecisionArgs, WorkflowStoragePolicyMode, WorkflowStoragePolicyResolver, WorkflowStoragePolicySpec, ZodSchemaAny, branchRef, chatModel, container, delay, getPersistedRuntimeTypeMetadata, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, node, predicateAwareClassFactory, registry, runnableNodeInputType, runnableNodeOutputType, singleton, tool, triggerNodeOutputType, triggerNodeSetupStateType };
+import { $ as JsonArray, $n as ConnectionInvocationRecord, $r as RunEventBus, $t as BinaryBody, A as CredentialJsonRecord, An as TriggerNode, Ar as WorkflowExecutionRepository, At as TriggerNodeOutputJson, B as CredentialTypeId, Bn as WorkflowSnapshotFactory, Br as inject, Bt as WorkflowNodeConnection, C as CredentialBindingKey, Cn as NodeExecutionScheduler, Cr as RunStateResetRequest, Ct as RunDataSnapshot, D as CredentialHealthTester, Dn as PersistedTriggerSetupState, Dr as WebhookRunResult, Dt as RunnableNodeInputJson, E as CredentialHealthStatus, En as NodeResolver, Er as RunSummary, Et as RunnableNodeConfig, F as CredentialSessionFactoryArgs, Fn as TriggerTestItemsContext, Fr as Lifecycle, Ft as WorkflowErrorHandler, G as BinaryAttachment, Gn as WebhookInvocationMatch, Gr as predicateAwareClassFactory, Gt as WorkflowStoragePolicyResolver, H as CredentialUnboundError, Hn as HttpMethod, Hr as injectable, Ht as WorkflowPrunePolicySpec, I as CredentialSessionService, In as WorkflowNodeInstanceFactory, Ir as RegistrationOptions, It as WorkflowErrorHandlerSpec, J as ExecutionMode, Jn as WebhookTriggerRoutingDiagnostics, Jr as CoreTokens, Jt as runnableNodeInputType, K as BinaryPreviewKind, Kn as WebhookTriggerMatcher, Kr as registry, Kt as WorkflowStoragePolicySpec, L as CredentialSetupStatus, Ln as WorkflowRepository, Lr as TypeToken, Lt as WorkflowGraph, M as CredentialOAuth2AuthDefinition, Mn as TriggerSetupContext, Mr as DependencyContainer, Mt as UpstreamRefPlaceholder, N as CredentialRequirement, Nn as TriggerSetupStateFor, Nr as Disposable, Nt as WorkflowDefinition, O as CredentialInstanceId, On as TestableTriggerNode, Or as WorkflowExecutionListingRepository, Ot as RunnableNodeOutputJson, P as CredentialSessionFactory, Pn as TriggerSetupStateRepository, Pr as InjectionToken, Pt as WorkflowErrorContext, Q as Items, Qn as ConnectionInvocationId, Qr as RunEvent, Qt as BinaryAttachmentCreateRequest, R as CredentialType, Rn as WorkflowRunnerResolver, Rr as container, Rt as WorkflowGraphFactory, S as CredentialBinding, Sn as NodeExecutionRequestHandler, Sr as RunResult, St as RunDataFactory, T as CredentialHealth, Tn as NodeExecutor, Tr as RunStopCondition, Tt as RunIdFactory, U as OAuth2ProviderFromPublicConfig, Un as TriggerInstanceId, Ur as instanceCachingFactory, Ut as WorkflowStoragePolicyDecisionArgs, V as CredentialTypeRegistry, Vn as WorkflowSnapshotResolver, Vr as injectAll, Vt as WorkflowPolicyRuntimeDefaults, W as ActivationIdFactory, Wn as WebhookControlSignal, Wr as instancePerContainerCachingFactory, Wt as WorkflowStoragePolicyMode, X as Item, Xn as WorkflowActivationPolicy, Xr as EngineExecutionLimitsPolicy, Xt as triggerNodeOutputType, Y as InputPortKey, Yn as AllWorkflowsActiveWorkflowActivationPolicy, Yt as runnableNodeOutputType, Z as ItemBinary, Zn as ConnectionInvocationAppendArgs, Zr as EngineExecutionLimitsPolicyConfig, Zt as triggerNodeSetupStateType, _ as StepSequenceOutput, _n as NodeActivationRequestBase, _r as RunCurrentState, _t as OutputPortKey, a as WorkflowExecutableNodeClassifier, ai as FixedRetryPolicySpec, an as EngineDeps, ar as NodeExecutionStatus, at as NodeConfigBase, b as AnyCredentialType, bn as NodeExecutionContext, br as RunPruneCandidate, bt as PersistedRunPolicySnapshot, c as WorkflowBuilder, cn as ExecutionBinaryService, cr as PersistedMutableNodeState, ct as NodeErrorHandler, d as AnyRunnableNodeConfig, dn as LiveWorkflowRepository, dr as PersistedRunState, dt as NodeId, ei as RunEventSubscription, en as BinaryStorage, er as CurrentStateExecutionRequest, et as JsonObject, f as AnyTriggerNodeConfig, fn as MultiInputNode, fr as PersistedWorkflowSnapshot, ft as NodeKind, g as BranchStepsArg, gn as NodeActivationRequest, gr as RunCompletionNotifier, gt as NodeSchedulerDecision, h as BranchOutputGuard, hn as NodeActivationReceipt, hr as PinnedNodeOutputsByPort, ht as NodeRef, i as WorkflowExecutableNodeClassifierFactory, ii as ExponentialRetryPolicySpec, in as BinaryStorageWriteResult, ir as NodeExecutionSnapshot, it as NodeActivationId, j as CredentialMaterialSourceKind, jn as TriggerRuntimeDiagnostics, jr as Container, jt as TriggerNodeSetupState, k as CredentialInstanceRecord, kn as TriggerCleanupHandle, kr as WorkflowExecutionPruneRepository, kt as TriggerNodeConfig, l as ChainCursor, ln as ExecutionContext, lr as PersistedMutableRunState, lt as NodeErrorHandlerArgs, m as BranchMoreArgs, mn as NodeActivationContinuation, mr as PersistedWorkflowTokenRegistryLike, mt as NodeOutputs, ni as RetryPolicy, nn as BinaryStorageStatResult, nr as ExecutionFrontierPlan, nt as JsonValue, o as ConnectionNodeIdFactory, oi as NoneRetryPolicySpec, on as EngineHost, or as NodeInputsByPort, ot as NodeConnectionName, p as BooleanWhenOverloads, pn as Node, pr as PersistedWorkflowSnapshotNode, pt as NodeOffloadPolicy, q as Edge, qn as WebhookTriggerResolution, qr as singleton, qt as branchRef, r as DefaultWorkflowGraphFactory, ri as NoRetryPolicy, rn as BinaryStorageWriteRequest, rr as NodeExecutionError, rt as MutableRunData, s as ConnectionInvocationIdFactory, si as RetryPolicySpec, sn as ExecutableTriggerNode, sr as PendingNodeExecution, st as NodeDefinition, t as InMemoryLiveWorkflowRepository, ti as ExpRetryPolicy, tn as BinaryStorageReadResult, tr as EngineRunCounters, tt as JsonPrimitive, u as WhenBuilder, un as ExecutionContextFactory, ur as PersistedRunControlState, ut as NodeErrorHandlerSpec, v as ValidStepSequence, vn as NodeActivationScheduler, vr as RunEventPublisherDeps, vt as PairedItemRef, w as CredentialFieldSchema, wn as NodeExecutionStatePublisher, wr as RunStatus, wt as RunId, x as CredentialAuthDefinition, xn as NodeExecutionRequest, xr as RunQueueEntry, xt as PersistedTokenId, y as RunFinishedAtFactory, yn as NodeBinaryAttachmentService, yr as RunExecutionOptions, yt as ParentExecutionRef, z as CredentialTypeDefinition, zn as WorkflowRunnerService, zr as delay, zt as WorkflowId } from "./InMemoryLiveWorkflowRepository-DxoualoC.js";
+import { A as PersistedRuntimeTypeKind, B as AgentToolCallPlanner, C as node, D as PersistedRuntimeTypeMetadataStore, E as PersistedRuntimeTypeNameResolver, F as AgentCanvasPresentation, G as ChatModelFactory, H as AgentToolExecuteArgs, I as AgentConfigInspector, J as ToolConfig, K as LangChainChatModelLike, L as AgentNodeConfig, M as EventPublishingWorkflowExecutionRepository, N as InMemoryRunEventBus, O as InjectableRuntimeDecoratorComposer, P as AgentAttachmentRole, Q as SystemClock, R as AgentTool, S as getPersistedRuntimeTypeMetadata, T as StackTraceCallSitePathResolver, U as AgentToolToken, V as AgentToolDefinition, W as ChatModelConfig, X as ZodSchemaAny, Y as ToolExecuteArgs, Z as Clock, at as CredentialResolverFactory, b as ItemsInputNormalizer, d as InMemoryRunDataFactory, f as InMemoryBinaryStorage, j as PersistedRuntimeTypeMetadata, k as PersistedRuntimeTypeDecoratorOptions, nt as DefaultExecutionContextFactory, ot as NodeEventPublisher, q as Tool, rt as DefaultAsyncSleeper, s as RunIntentService, tt as InProcessRetryRunner, v as DefaultExecutionBinaryService, w as tool, x as chatModel, y as UnavailableBinaryStorage, z as AgentToolCall } from "./index-CTjfVHJh.js";
+export { ActivationIdFactory, AgentAttachmentRole, AgentCanvasPresentation, AgentConfigInspector, AgentNodeConfig, AgentTool, AgentToolCall, AgentToolCallPlanner, AgentToolDefinition, AgentToolExecuteArgs, AgentToolToken, AllWorkflowsActiveWorkflowActivationPolicy, AnyCredentialType, AnyRunnableNodeConfig, AnyTriggerNodeConfig, BinaryAttachment, BinaryAttachmentCreateRequest, BinaryBody, BinaryPreviewKind, BinaryStorage, BinaryStorageReadResult, BinaryStorageStatResult, BinaryStorageWriteRequest, BinaryStorageWriteResult, BooleanWhenOverloads, BranchMoreArgs, BranchOutputGuard, BranchStepsArg, ChainCursor, ChatModelConfig, ChatModelFactory, Clock, ConnectionInvocationAppendArgs, ConnectionInvocationId, ConnectionInvocationIdFactory, ConnectionInvocationRecord, ConnectionNodeIdFactory, Container, CoreTokens, CredentialAuthDefinition, CredentialBinding, CredentialBindingKey, CredentialFieldSchema, CredentialHealth, CredentialHealthStatus, CredentialHealthTester, CredentialInstanceId, CredentialInstanceRecord, CredentialJsonRecord, CredentialMaterialSourceKind, CredentialOAuth2AuthDefinition, CredentialRequirement, CredentialResolverFactory, CredentialSessionFactory, CredentialSessionFactoryArgs, CredentialSessionService, CredentialSetupStatus, CredentialType, CredentialTypeDefinition, CredentialTypeId, CredentialTypeRegistry, CredentialUnboundError, CurrentStateExecutionRequest, DefaultAsyncSleeper, DefaultExecutionBinaryService, DefaultExecutionContextFactory, DefaultWorkflowGraphFactory, DependencyContainer, Disposable, Edge, EngineDeps, EngineExecutionLimitsPolicy, EngineExecutionLimitsPolicyConfig, EngineHost, EngineRunCounters, EventPublishingWorkflowExecutionRepository, ExecutableTriggerNode, ExecutionBinaryService, ExecutionContext, ExecutionContextFactory, ExecutionFrontierPlan, ExecutionMode, ExpRetryPolicy, ExponentialRetryPolicySpec, FixedRetryPolicySpec, HttpMethod, InMemoryBinaryStorage, InMemoryLiveWorkflowRepository, InMemoryRunDataFactory, InMemoryRunEventBus, InProcessRetryRunner, InjectableRuntimeDecoratorComposer, InjectionToken, InputPortKey, Item, ItemBinary, Items, ItemsInputNormalizer, JsonArray, JsonObject, JsonPrimitive, JsonValue, LangChainChatModelLike, Lifecycle, LiveWorkflowRepository, MultiInputNode, MutableRunData, NoRetryPolicy, Node, NodeActivationContinuation, NodeActivationId, NodeActivationReceipt, NodeActivationRequest, NodeActivationRequestBase, NodeActivationScheduler, NodeBinaryAttachmentService, NodeConfigBase, NodeConnectionName, NodeDefinition, NodeErrorHandler, NodeErrorHandlerArgs, NodeErrorHandlerSpec, NodeEventPublisher, NodeExecutionContext, NodeExecutionError, NodeExecutionRequest, NodeExecutionRequestHandler, NodeExecutionScheduler, NodeExecutionSnapshot, NodeExecutionStatePublisher, NodeExecutionStatus, NodeExecutor, NodeId, NodeInputsByPort, NodeKind, NodeOffloadPolicy, NodeOutputs, NodeRef, NodeResolver, NodeSchedulerDecision, NoneRetryPolicySpec, OAuth2ProviderFromPublicConfig, OutputPortKey, PairedItemRef, ParentExecutionRef, PendingNodeExecution, PersistedMutableNodeState, PersistedMutableRunState, PersistedRunControlState, PersistedRunPolicySnapshot, PersistedRunState, PersistedRuntimeTypeDecoratorOptions, PersistedRuntimeTypeKind, PersistedRuntimeTypeMetadata, PersistedRuntimeTypeMetadataStore, PersistedRuntimeTypeNameResolver, PersistedTokenId, PersistedTriggerSetupState, PersistedWorkflowSnapshot, PersistedWorkflowSnapshotNode, PersistedWorkflowTokenRegistryLike, PinnedNodeOutputsByPort, RegistrationOptions, RetryPolicy, RetryPolicySpec, RunCompletionNotifier, RunCurrentState, RunDataFactory, RunDataSnapshot, RunEvent, RunEventBus, RunEventPublisherDeps, RunEventSubscription, RunExecutionOptions, RunFinishedAtFactory, RunId, RunIdFactory, RunIntentService, RunPruneCandidate, RunQueueEntry, RunResult, RunStateResetRequest, RunStatus, RunStopCondition, RunSummary, RunnableNodeConfig, RunnableNodeInputJson, RunnableNodeOutputJson, StackTraceCallSitePathResolver, StepSequenceOutput, SystemClock, TestableTriggerNode, Tool, ToolConfig, ToolExecuteArgs, TriggerCleanupHandle, TriggerInstanceId, TriggerNode, TriggerNodeConfig, TriggerNodeOutputJson, TriggerNodeSetupState, TriggerRuntimeDiagnostics, TriggerSetupContext, TriggerSetupStateFor, TriggerSetupStateRepository, TriggerTestItemsContext, TypeToken, UnavailableBinaryStorage, UpstreamRefPlaceholder, ValidStepSequence, WebhookControlSignal, WebhookInvocationMatch, WebhookRunResult, WebhookTriggerMatcher, WebhookTriggerResolution, WebhookTriggerRoutingDiagnostics, WhenBuilder, WorkflowActivationPolicy, WorkflowBuilder, WorkflowDefinition, WorkflowErrorContext, WorkflowErrorHandler, WorkflowErrorHandlerSpec, WorkflowExecutableNodeClassifier, WorkflowExecutableNodeClassifierFactory, WorkflowExecutionListingRepository, WorkflowExecutionPruneRepository, WorkflowExecutionRepository, WorkflowGraph, WorkflowGraphFactory, WorkflowId, WorkflowNodeConnection, WorkflowNodeInstanceFactory, WorkflowPolicyRuntimeDefaults, WorkflowPrunePolicySpec, WorkflowRepository, WorkflowRunnerResolver, WorkflowRunnerService, WorkflowSnapshotFactory, WorkflowSnapshotResolver, WorkflowStoragePolicyDecisionArgs, WorkflowStoragePolicyMode, WorkflowStoragePolicyResolver, WorkflowStoragePolicySpec, ZodSchemaAny, branchRef, chatModel, container, delay, getPersistedRuntimeTypeMetadata, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, node, predicateAwareClassFactory, registry, runnableNodeInputType, runnableNodeOutputType, singleton, tool, triggerNodeOutputType, triggerNodeSetupStateType };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { $ as instancePerContainerCachingFactory, B as node, G as PersistedRuntimeTypeNameResolver, H as InjectableRuntimeDecoratorComposer, I as DefaultExecutionBinaryService, J as delay, K as NodeEventPublisher, L as UnavailableBinaryStorage, M as DefaultExecutionContextFactory, N as DefaultAsyncSleeper, P as CredentialResolverFactory, Q as instanceCachingFactory, R as chatModel, U as PersistedRuntimeTypeMetadataStore, V as tool, W as StackTraceCallSitePathResolver, X as injectAll, Y as inject, Z as injectable, at as WorkflowExecutableNodeClassifier, et as predicateAwareClassFactory, i as InMemoryBinaryStorage, it as WorkflowExecutableNodeClassifierFactory, j as InProcessRetryRunner, n as RunFinishedAtFactory, nt as singleton, o as EngineExecutionLimitsPolicy, ot as ConnectionNodeIdFactory, q as container, r as InMemoryRunDataFactory, rt as CoreTokens, t as RunIntentService, tt as registry, z as getPersistedRuntimeTypeMetadata } from "./RunIntentService-BFVbsOcg.js";
+import { $ as instancePerContainerCachingFactory, B as node, G as PersistedRuntimeTypeNameResolver, H as InjectableRuntimeDecoratorComposer, I as DefaultExecutionBinaryService, J as delay, K as NodeEventPublisher, L as UnavailableBinaryStorage, M as DefaultExecutionContextFactory, N as DefaultAsyncSleeper, P as CredentialResolverFactory, Q as instanceCachingFactory, R as chatModel, U as PersistedRuntimeTypeMetadataStore, V as tool, W as StackTraceCallSitePathResolver, X as injectAll, Y as inject, Z as injectable, at as WorkflowExecutableNodeClassifier, et as predicateAwareClassFactory, i as InMemoryBinaryStorage, it as WorkflowExecutableNodeClassifierFactory, j as InProcessRetryRunner, n as RunFinishedAtFactory, nt as singleton, o as EngineExecutionLimitsPolicy, ot as ConnectionNodeIdFactory, q as container, r as InMemoryRunDataFactory, rt as CoreTokens, t as RunIntentService, tt as registry, z as getPersistedRuntimeTypeMetadata } from "./RunIntentService-CYnn140t.js";
 import { t as InMemoryLiveWorkflowRepository } from "./InMemoryLiveWorkflowRepository-BoLNnVLg.js";
 import { randomUUID } from "node:crypto";
 

package/dist/testing.d.cts

@@ -1,5 +1,5 @@
-import { t as InMemoryLiveWorkflowRepository, v as CredentialSessionService } from "./InMemoryLiveWorkflowRepository-D6eiiXxF.cjs";
-import { t as WorkflowSnapshotCodec } from "./WorkflowSnapshotCodec-DNtdrZ7l.cjs";
+import { t as InMemoryLiveWorkflowRepository, v as CredentialSessionService } from "./InMemoryLiveWorkflowRepository-orY1VsWG.cjs";
+import { t as WorkflowSnapshotCodec } from "./WorkflowSnapshotCodec-DSEzKyt3.cjs";
 
 //#region src/testing/RejectingCredentialSessionService.d.ts
 

package/dist/testing.d.ts

@@ -1,4 +1,4 @@
-import { I as CredentialSessionService, n as WorkflowSnapshotCodec, t as InMemoryLiveWorkflowRepository } from "./InMemoryLiveWorkflowRepository-DL7LmC9S.js";
+import { I as CredentialSessionService, n as WorkflowSnapshotCodec, t as InMemoryLiveWorkflowRepository } from "./InMemoryLiveWorkflowRepository-DxoualoC.js";
 
 //#region src/testing/RejectingCredentialSessionService.d.ts
 

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "@codemation/core",
-  "version": "0.0.5",
+  "version": "0.0.11",
   "publishConfig": {
     "access": "public"
   },
   "author": "Made Relevant B.V.",
   "homepage": "https://www.maderelevant.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MadeRelevant/codemation",
+    "directory": "packages/core"
+  },
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

package/src/bootstrap/runtime/EngineRuntimeRegistrar.ts

@@ -31,6 +31,7 @@ export class EngineRuntimeRegistrar {
     this.registerSupportFactories(container);
     this.registerExecutionLimitsPolicy(container, options);
     this.ensureWorkflowNodeInstanceFactory(container);
+    this.ensureNodeExecutor(container);
     this.registerDefaultActivationScheduler(container);
     this.registerEngine(container, options);
     this.registerIntentServices(container);
@@ -81,8 +82,8 @@ export class EngineRuntimeRegistrar {
     });
   }
 
-  private registerDefaultActivationScheduler(container: DependencyContainer): void {
-    if (container.isRegistered(CoreTokens.NodeActivationScheduler, true)) {
+  private ensureNodeExecutor(container: DependencyContainer): void {
+    if (container.isRegistered(NodeExecutor, true)) {
       return;
     }
     container.register(NodeExecutor, {
@@ -95,6 +96,12 @@ export class EngineRuntimeRegistrar {
           .create(dependencyContainer.resolve(CoreTokens.WorkflowNodeInstanceFactory), retryRunner);
       }),
     });
+  }
+
+  private registerDefaultActivationScheduler(container: DependencyContainer): void {
+    if (container.isRegistered(CoreTokens.NodeActivationScheduler, true)) {
+      return;
+    }
     container.register(InlineDrivingScheduler, {
       useFactory: instanceCachingFactory((dependencyContainer) => {
         return dependencyContainer
@@ -135,6 +142,7 @@ export class EngineRuntimeRegistrar {
           activationScheduler: dependencyContainer.resolve(CoreTokens.NodeActivationScheduler),
           runDataFactory: dependencyContainer.resolve(CoreTokens.RunDataFactory),
           executionContextFactory: dependencyContainer.resolve(CoreTokens.ExecutionContextFactory),
+          nodeExecutor: dependencyContainer.resolve(NodeExecutor),
           eventBus: dependencyContainer.resolve(CoreTokens.RunEventBus),
           tokenRegistry: tokenRegistryLike,
           workflowNodeInstanceFactory,

package/src/contracts/runtimeTypes.ts

@@ -265,6 +265,10 @@ export interface NodeExecutionScheduler {
   cancel?(receiptId: string): Promise<void>;
 }
 
+export interface NodeExecutionRequestHandler {
+  handleNodeExecutionRequest(request: NodeExecutionRequest): Promise<void>;
+}
+
 export type NodeActivationRequestBase = Readonly<{
   runId: RunId;
   activationId: NodeActivationId;
@@ -363,6 +367,7 @@ export interface EngineDeps {
   activationScheduler: NodeActivationScheduler;
   runDataFactory: RunDataFactory;
   executionContextFactory: ExecutionContextFactory;
+  nodeExecutor: NodeExecutor;
   eventBus?: RunEventBus;
   tokenRegistry: PersistedWorkflowTokenRegistryLike;
   workflowNodeInstanceFactory: WorkflowNodeInstanceFactory;

package/src/execution/NodeActivationRequestComposer.ts

@@ -2,6 +2,7 @@ import type {
   ActivationIdFactory,
   ExecutionContextFactory,
   Items,
+  NodeActivationId,
   NodeActivationRequest,
   NodeExecutionContext,
   NodeId,
@@ -47,13 +48,23 @@ export class NodeActivationRequestComposer {
     private readonly credentialResolverFactory: CredentialResolverFactory,
   ) {}
 
-  createSingleFromDefinition(args: SingleDefinitionActivationRequest): NodeActivationRequest {
-    const activationId = this.activationIdFactory.makeActivationId();
-    const ctx = this.createNodeExecutionContext(args, args.definition, activationId);
+  createSingleFromDefinition(
+    args: SingleDefinitionActivationRequest,
+  ): Extract<NodeActivationRequest, { kind: "single" }> {
+    return this.createSingleFromDefinitionWithActivation({
+      ...args,
+      activationId: this.activationIdFactory.makeActivationId(),
+    });
+  }
+
+  createSingleFromDefinitionWithActivation(
+    args: SingleDefinitionActivationRequest & Readonly<{ activationId: NodeActivationId }>,
+  ): Extract<NodeActivationRequest, { kind: "single" }> {
+    const ctx = this.createNodeExecutionContext(args, args.definition, args.activationId);
     return {
       kind: "single",
       runId: args.runId,
-      activationId,
+      activationId: args.activationId,
       workflowId: args.workflowId,
       nodeId: args.definition.id,
       parent: args.parent,

package/src/orchestration/Engine.ts

@@ -4,6 +4,8 @@ import type {
   Items,
   NodeActivationContinuation,
   NodeActivationId,
+  NodeExecutionRequest,
+  NodeExecutionRequestHandler,
   NodeId,
   NodeInputsByPort,
   NodeOutputs,
@@ -79,6 +81,10 @@ interface EngineRunContinuationService {
   waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
 }
 
+interface EngineNodeExecutionRequestHandler {
+  handleNodeExecutionRequest(request: NodeExecutionRequest): Promise<void>;
+}
+
 export interface EngineFacadeDeps {
   liveWorkflowRepository: LiveWorkflowRepository;
   tokenRegistry: PersistedWorkflowTokenRegistryLike;
@@ -87,6 +93,7 @@ export interface EngineFacadeDeps {
   triggerRuntime: EngineTriggerRuntime;
   runStartService: EngineRunStartService;
   runContinuationService: EngineRunContinuationService;
+  nodeExecutionRequestHandler: EngineNodeExecutionRequestHandler;
 }
 
 /**
@@ -94,7 +101,7 @@ export interface EngineFacadeDeps {
  * Prefer {@link import("../intents/RunIntentService").RunIntentService} for host/HTTP invocation boundaries.
  * The class token is exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
  */
-export class Engine implements NodeActivationContinuation {
+export class Engine implements NodeActivationContinuation, NodeExecutionRequestHandler {
   constructor(private readonly deps: EngineFacadeDeps) {}
 
   loadWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void {
@@ -226,4 +233,8 @@ export class Engine implements NodeActivationContinuation {
   async waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult> {
     return await this.deps.runContinuationService.waitForWebhookResponse(runId);
   }
+
+  async handleNodeExecutionRequest(request: NodeExecutionRequest): Promise<void> {
+    await this.deps.nodeExecutionRequestHandler.handleNodeExecutionRequest(request);
+  }
 }

package/src/orchestration/NodeExecutionRequestHandlerService.ts

@@ -0,0 +1,179 @@
+import type {
+  NodeActivationContinuation,
+  NodeExecutor,
+  NodeExecutionRequest,
+  NodeExecutionRequestHandler,
+  PersistedRunState,
+  RunDataFactory,
+  WorkflowDefinition,
+  WorkflowExecutionRepository,
+  WorkflowSnapshotResolver,
+} from "../types";
+import type { EngineExecutionLimitsPolicy } from "../policies/executionLimits/EngineExecutionLimitsPolicy";
+import { NodeActivationRequestComposer } from "../execution/NodeActivationRequestComposer";
+import { NodeRunStateWriterFactory } from "../execution/NodeRunStateWriterFactory";
+import { WorkflowRunExecutionContextFactory } from "../execution/WorkflowRunExecutionContextFactory";
+
+type PersistedWorkflowLike = Readonly<{
+  workflowId: PersistedRunState["workflowId"];
+  workflowSnapshot?: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["workflowSnapshot"];
+}>;
+
+export class NodeExecutionRequestHandlerService implements NodeExecutionRequestHandler {
+  constructor(
+    private readonly workflowExecutionRepository: WorkflowExecutionRepository,
+    private readonly workflowSnapshotResolver: WorkflowSnapshotResolver,
+    private readonly runDataFactory: RunDataFactory,
+    private readonly runExecutionContextFactory: WorkflowRunExecutionContextFactory,
+    private readonly nodeStatePublisherFactory: NodeRunStateWriterFactory,
+    private readonly nodeActivationRequestComposer: NodeActivationRequestComposer,
+    private readonly nodeExecutor: NodeExecutor,
+    private readonly continuation: NodeActivationContinuation,
+    private readonly executionLimitsPolicy: EngineExecutionLimitsPolicy,
+  ) {}
+
+  async handleNodeExecutionRequest(request: NodeExecutionRequest): Promise<void> {
+    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 ?? {});
+  }
+
+  private resolvePersistedWorkflow(state: PersistedWorkflowLike): WorkflowDefinition | undefined {
+    return this.workflowSnapshotResolver.resolve({
+      workflowId: state.workflowId,
+      workflowSnapshot: state.workflowSnapshot,
+    });
+  }
+
+  private resolveEngineLimitsFromState(state: PersistedRunState): {
+    engineMaxNodeActivations: number;
+    engineMaxSubworkflowDepth: number;
+  } {
+    const fallback = this.executionLimitsPolicy.createRootExecutionOptions();
+    return {
+      engineMaxNodeActivations: state.executionOptions?.maxNodeActivations ?? fallback.maxNodeActivations!,
+      engineMaxSubworkflowDepth: state.executionOptions?.maxSubworkflowDepth ?? fallback.maxSubworkflowDepth!,
+    };
+  }
+
+  private async resumeAfterExecutionResult(
+    request: ReturnType<NodeActivationRequestComposer["createSingleFromDefinitionWithActivation"]>,
+    outputs: unknown,
+  ): Promise<void> {
+    try {
+      await this.continuation.resumeFromNodeResult({
+        runId: request.runId,
+        activationId: request.activationId,
+        nodeId: request.nodeId,
+        outputs: outputs as never,
+      });
+    } catch (error) {
+      this.rethrowUnlessIgnorableContinuationError(error);
+    }
+  }
+
+  private async resumeAfterExecutionError(
+    request: ReturnType<NodeActivationRequestComposer["createSingleFromDefinitionWithActivation"]>,
+    error: Error,
+  ): Promise<void> {
+    try {
+      await this.continuation.resumeFromNodeError({
+        runId: request.runId,
+        activationId: request.activationId,
+        nodeId: request.nodeId,
+        error,
+      });
+    } catch (continuationError) {
+      this.rethrowUnlessIgnorableContinuationError(continuationError);
+    }
+  }
+
+  private asError(error: unknown): Error {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+
+  private rethrowUnlessIgnorableContinuationError(error: unknown): void {
+    if (this.isIgnorableContinuationError(error)) {
+      return;
+    }
+    throw this.asError(error);
+  }
+
+  private isIgnorableContinuationError(error: unknown): boolean {
+    const message = this.asError(error).message;
+    return (
+      message.includes(" is not pending") ||
+      message.includes("activationId mismatch") ||
+      message.includes("nodeId mismatch")
+    );
+  }
+}

package/src/runtime/EngineFactory.ts

@@ -7,6 +7,7 @@ import { WorkflowSnapshotResolver } from "../workflowSnapshots/WorkflowSnapshotR
 import { ActivationEnqueueService } from "../execution/ActivationEnqueueService";
 import { NodeActivationRequestComposer } from "../execution/NodeActivationRequestComposer";
 import { PersistedRunStateTerminalBuilder } from "../execution/PersistedRunStateTerminalBuilder";
+import { NodeExecutionRequestHandlerService } from "../orchestration/NodeExecutionRequestHandlerService";
 import { RunContinuationService } from "../orchestration/RunContinuationService";
 import { RunStartService } from "../orchestration/RunStartService";
 import { RunStateSemantics } from "../execution/RunStateSemantics";
@@ -115,6 +116,17 @@ export class EngineFactory {
       terminalPersistence,
       executionLimitsPolicy,
     );
+    const nodeExecutionRequestHandler = new NodeExecutionRequestHandlerService(
+      deps.workflowExecutionRepository,
+      workflowSnapshotResolver,
+      deps.runDataFactory,
+      runExecutionContextFactory,
+      nodeStatePublisherFactory,
+      nodeActivationRequestComposer,
+      deps.nodeExecutor,
+      runContinuationService,
+      executionLimitsPolicy,
+    );
 
     const triggerRuntime = new TriggerRuntimeService(
       deps.workflowRepository,
@@ -143,6 +155,7 @@ export class EngineFactory {
       triggerRuntime,
       runStartService,
       runContinuationService,
+      nodeExecutionRequestHandler,
     });
 
     deps.activationScheduler.setContinuation?.(engine);

package/dist/EngineExecutionLimitsPolicy-8MEFIYx1.d.cts

@@ -1,160 +0,0 @@
-import { En as WebhookTriggerResolution, Jt as NodeActivationContinuation, K as NodeId, N as Items, Nn as CurrentStateExecutionRequest, Qn as RunExecutionOptions, Tn as WebhookTriggerMatcher, Y as NodeOutputs, ar as RunStateStore, at as RunId, bn as WorkflowSnapshotResolver, bt as WorkflowId, et as ParentExecutionRef, lr as WebhookRunResult, mn as WorkflowCatalog, mt as WorkflowDefinition, qn as PersistedWorkflowTokenRegistryLike, rr as RunResult, xn as HttpMethod, z as NodeActivationId, zn as NodeInputsByPort } from "./credentialTypes-B5h3dI7r.cjs";
-
-//#region src/engine/api/Engine.d.ts
-interface EngineTriggerRuntime {
-  startTriggers(): Promise<void>;
-  stop(): Promise<void>;
-  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
-  createTriggerTestItems(args: {
-    workflow: WorkflowDefinition;
-    nodeId: NodeId;
-  }): Promise<Items | undefined>;
-}
-interface EngineWorkflowRunStarter {
-  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
-    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
-    mutableState?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["mutableState"];
-  }>): Promise<RunResult>;
-}
-interface EngineCurrentStateRunStarter {
-  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
-}
-interface EngineRunContinuationService {
-  markNodeRunning(args: {
-    runId: RunId;
-    activationId: NodeActivationId;
-    nodeId: NodeId;
-    inputsByPort: NodeInputsByPort;
-  }): Promise<void>;
-  resumeFromNodeResult(args: {
-    runId: RunId;
-    activationId: NodeActivationId;
-    nodeId: NodeId;
-    outputs: NodeOutputs;
-  }): Promise<RunResult>;
-  resumeFromNodeError(args: {
-    runId: RunId;
-    activationId: NodeActivationId;
-    nodeId: NodeId;
-    error: Error;
-  }): Promise<RunResult>;
-  resumeFromStepResult(args: {
-    runId: RunId;
-    activationId: NodeActivationId;
-    nodeId: NodeId;
-    outputs: NodeOutputs;
-  }): Promise<RunResult>;
-  resumeFromStepError(args: {
-    runId: RunId;
-    activationId: NodeActivationId;
-    nodeId: NodeId;
-    error: Error;
-  }): Promise<RunResult>;
-  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
-    status: "completed" | "failed";
-  }>>;
-  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
-}
-interface EngineFacadeDeps {
-  workflowCatalog: WorkflowCatalog;
-  tokenRegistry: PersistedWorkflowTokenRegistryLike;
-  webhookTriggerMatcher: WebhookTriggerMatcher;
-  workflowSnapshotResolver: WorkflowSnapshotResolver;
-  triggerRuntime: EngineTriggerRuntime;
-  workflowRunStarter: EngineWorkflowRunStarter;
-  currentStateRunStarter: EngineCurrentStateRunStarter;
-  runContinuationService: EngineRunContinuationService;
-}
-/**
- * Runtime facade for orchestration, continuation, triggers, and webhook routing.
- * Prefer {@link import("../intents/RunIntentService").RunIntentService} for host/HTTP invocation boundaries.
- * The class token is exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
- */
-declare class Engine implements NodeActivationContinuation {
-  private readonly deps;
-  constructor(deps: EngineFacadeDeps);
-  loadWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
-  getTokenRegistry(): EngineFacadeDeps["tokenRegistry"];
-  resolveWorkflowSnapshot(args: {
-    workflowId: WorkflowId;
-    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
-  }): WorkflowDefinition | undefined;
-  startTriggers(): Promise<void>;
-  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
-  start(workflows: WorkflowDefinition[]): Promise<void>;
-  stop(): Promise<void>;
-  resolveWebhookTrigger(args: {
-    endpointPath: string;
-    method: HttpMethod;
-  }): WebhookTriggerResolution;
-  createTriggerTestItems(args: {
-    workflow: WorkflowDefinition;
-    nodeId: NodeId;
-  }): Promise<Items | undefined>;
-  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
-    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
-    mutableState?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["mutableState"];
-  }>): Promise<RunResult>;
-  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
-  markNodeRunning(args: {
-    runId: RunId;
-    activationId: NodeActivationId;
-    nodeId: NodeId;
-    inputsByPort: NodeInputsByPort;
-  }): Promise<void>;
-  resumeFromNodeResult(args: {
-    runId: RunId;
-    activationId: NodeActivationId;
-    nodeId: NodeId;
-    outputs: NodeOutputs;
-  }): Promise<RunResult>;
-  resumeFromNodeError(args: {
-    runId: RunId;
-    activationId: NodeActivationId;
-    nodeId: NodeId;
-    error: Error;
-  }): Promise<RunResult>;
-  resumeFromStepResult(args: {
-    runId: RunId;
-    activationId: NodeActivationId;
-    nodeId: NodeId;
-    outputs: NodeOutputs;
-  }): Promise<RunResult>;
-  resumeFromStepError(args: {
-    runId: RunId;
-    activationId: NodeActivationId;
-    nodeId: NodeId;
-    error: Error;
-  }): Promise<RunResult>;
-  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
-    status: "completed" | "failed";
-  }>>;
-  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
-}
-//#endregion
-//#region src/engine/policies/EngineExecutionLimitsPolicy.d.ts
-interface EngineExecutionLimitsPolicyConfig {
-  readonly defaultMaxNodeActivations: number;
-  readonly hardMaxNodeActivations: number;
-  readonly defaultMaxSubworkflowDepth: number;
-  readonly hardMaxSubworkflowDepth: number;
-}
-/** Framework defaults for {@link EngineExecutionLimitsPolicy} (merged with host `runtime.engineExecutionLimits`). */
-declare const ENGINE_EXECUTION_LIMITS_DEFAULTS: EngineExecutionLimitsPolicyConfig;
-/**
- * Resolves per-run execution limits: defaults, hard ceilings, and subworkflow depth for new runs.
- */
-declare class EngineExecutionLimitsPolicy {
-  private readonly config;
-  constructor(config?: EngineExecutionLimitsPolicyConfig);
-  /**
-   * Effective options for a new root run (depth 0): defaults merged with engine ceilings.
-   * Replaces a separate one-method factory for root-run bootstrap.
-   */
-  createRootExecutionOptions(): RunExecutionOptions;
-  mergeExecutionOptionsForNewRun(parent: ParentExecutionRef | undefined, user: RunExecutionOptions | undefined): RunExecutionOptions;
-  private capNumber;
-}
-//#endregion
-export { Engine as i, EngineExecutionLimitsPolicy as n, EngineExecutionLimitsPolicyConfig as r, ENGINE_EXECUTION_LIMITS_DEFAULTS as t };
-//# sourceMappingURL=EngineExecutionLimitsPolicy-8MEFIYx1.d.cts.map