@invect/core 0.0.1

package/dist/services/flow-orchestration/node-execution-coordinator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-execution-coordinator.js","names":[],"sources":["../../../src/services/flow-orchestration/node-execution-coordinator.ts"],"sourcesContent":["import { NodeExecutionStatus } from 'src/types/base';\nimport { NodeExecutionContext, GraphNodeType } from 'src/types-fresh';\nimport { InvectDefinition, FlowEdge, FlowNodeDefinitions } from '../flow-versions/schemas-fresh';\nimport { NodeOutput, NodeIncomingDataObject } from 'src/types/node-io-types';\nimport { generateNodeSlug } from 'src/utils/node-slug';\nimport type { NodeExecution } from '../node-executions/node-executions.model';\nimport type { NodeExecutionService } from '../node-executions/node-execution.service';\nimport type { NodeDataService } from '../node-data.service';\nimport type { NodeExecutorRegistry } from 'src/nodes/executor-registry';\nimport type { Logger } from 'src/types/schemas';\nimport type { GraphService } from '../graph.service';\nimport type { CredentialsService } from '../credentials/credentials.service';\nimport type { AgentToolExecutionService } from '../agent-tool-executions/agent-tool-execution.service';\nimport type { BaseAIClient } from '../ai/base-client';\nimport { BatchProvider } from '../ai/base-client';\nimport type { PluginHookRunner } from 'src/types/plugin.types';\nimport { detectProviderFromCredential } from 'src/utils/provider-detection';\nimport { TemplateService, createTemplateService } from '../templating/template.service';\nimport { JsExpressionService, JsExpressionError } from '../templating/js-expression.service';\nimport type { MapperConfig } from '../flow-versions/schemas-fresh';\nimport { getGlobalActionRegistry } from 'src/actions/action-registry';\nimport { executeActionAsNode } from 'src/actions/action-executor';\n\nexport type NodeExecutionCoordinatorDeps = {\n  logger: Logger;\n  nodeExecutionService: NodeExecutionService;\n  nodeRegistry: NodeExecutorRegistry;\n  nodeDataService: NodeDataService;\n  graphService: GraphService;\n  credentialsService?: CredentialsService;\n  agentToolExecutionService?: AgentToolExecutionService;\n  templateService?: TemplateService;\n  jsExpressionService?: JsExpressionService;\n  baseAIClient: BaseAIClient;\n  /** Plugin hook runner for node execution hooks (optional for backward compat). */\n  pluginHookRunner?: PluginHookRunner;\n};\n\n/**\n * Coordinates the execution of individual nodes within a flow run.\n */\nexport class NodeExecutionCoordinator {\n  private templateService: TemplateService;\n\n  constructor(private readonly deps: NodeExecutionCoordinatorDeps) {\n    if (deps.templateService) {\n      this.templateService = deps.templateService;\n    } else if (deps.jsExpressionService) {\n      this.templateService = createTemplateService(deps.jsExpressionService, deps.logger);\n    } else {\n      // Fallback: TemplateService requires JsExpressionService. If neither is\n      // provided the service will throw at render time — but construction\n      // should not fail so tests that never call resolveTemplateParams still work.\n      this.templateService = createTemplateService(\n        undefined as unknown as JsExpressionService,\n        deps.logger,\n      );\n    }\n  }\n\n  /**\n   * Ensure a provider adapter is registered in BaseAIClient for the given\n   * provider. If the adapter doesn't exist yet, the credential is resolved\n   * and its API key is used to create one on-the-fly.\n   */\n  private async ensureAdapterRegistered(\n    provider: BatchProvider,\n    credentialId?: string,\n  ): Promise<void> {\n    if (this.deps.baseAIClient.hasAdapter(provider)) {\n      return;\n    }\n\n    if (!credentialId) {\n      throw new Error(\n        `No adapter registered for provider \"${provider}\" and no credentialId provided to create one.`,\n      );\n    }\n\n    const { credentialsService, logger } = this.deps;\n    if (!credentialsService) {\n      throw new Error(\n        'Credentials service not available — cannot resolve API key for adapter registration.',\n      );\n    }\n\n    const credential = await credentialsService.getDecryptedWithRefresh(credentialId);\n    const apiKey = (credential.config as Record<string, unknown>)?.apiKey as string | undefined;\n    if (!apiKey) {\n      throw new Error(\n        `Credential \"${credentialId}\" does not contain an apiKey — cannot register adapter.`,\n      );\n    }\n\n    const detectedProvider = detectProviderFromCredential(credential) ?? provider;\n\n    // Map BatchProvider enum to the string literal registerAdapter expects\n    const providerLabel =\n      detectedProvider === BatchProvider.OPENAI\n        ? 'OPENAI'\n        : detectedProvider === BatchProvider.ANTHROPIC\n          ? 'ANTHROPIC'\n          : detectedProvider === BatchProvider.OPENROUTER\n            ? 'OPENROUTER'\n            : (detectedProvider as 'OPENAI' | 'ANTHROPIC' | 'OPENROUTER');\n\n    logger.debug('Auto-registering adapter from credential', {\n      provider: providerLabel,\n      credentialId,\n    });\n\n    this.deps.baseAIClient.registerAdapter(providerLabel, apiKey);\n  }\n\n  /**\n   * Build the node-keyed incoming data object for template resolution.\n   * This aggregates outputs from all source nodes connected to the target node.\n   *\n   * Structure:\n   * {\n   *   \"source_node_slug\": {\n   *     nodeId: \"abc-123\",\n   *     nodeType: GraphNodeType.TEMPLATE_STRING,\n   *     label: \"Source Node\",\n   *     slug: \"source_node_slug\",\n   *     output: \"the value\",        // flattened from data.variables.output.value\n   *     data: { variables: { ... } },\n   *     _rawOutput: { nodeType: ..., data: { ... } },\n   *     toString(): string          // returns primary output value for direct template use\n   *   },\n   *   ...\n   * }\n   *\n   * Input data structure matches the execution-process.md documentation:\n   * - Keys: upstream node reference_id (or slug from label), normalized to snake_case\n   * - Values: direct output value (the node's primary output, JSON-parsed if valid)\n   *\n   * Example: { \"fetch_user\": { \"id\": 123, \"name\": \"Alice\" }, \"get_config\": \"production\" }\n   *\n   * Template usage:\n   * - {{ fetch_user }} renders the full output object/value\n   * - {{ fetch_user.id }} accesses nested properties directly\n   */\n  buildIncomingDataObject(\n    node: FlowNodeDefinitions,\n    nodeOutputs: Map<FlowNodeDefinitions['id'], NodeOutput | undefined>,\n    edges: readonly FlowEdge[],\n    nodeMap: Map<string, FlowNodeDefinitions>,\n  ): NodeIncomingDataObject {\n    const incomingData: NodeIncomingDataObject = {};\n    const incomingEdges = edges.filter((edge) => edge.target === node.id);\n\n    for (const edge of incomingEdges) {\n      const sourceNode = nodeMap.get(edge.source);\n      const sourceOutput = nodeOutputs.get(edge.source);\n\n      if (!sourceNode) {\n        continue;\n      }\n\n      // Generate slug from label or fall back to node ID\n      const nodeLabel = sourceNode.label ?? '';\n      const referenceId = sourceNode.referenceId ?? '';\n      const nodeId = sourceNode.id;\n      const nodeType = sourceNode.type;\n      const label = nodeLabel || nodeType || nodeId;\n      // Prefer referenceId if available, otherwise generate slug from label\n      const slug = referenceId || generateNodeSlug(label, nodeId);\n\n      // Extract the primary output value directly\n      // Most nodes have a single \"output\" variable - we use that as the direct value\n      let outputValue: unknown = null;\n      const variables = sourceOutput?.data?.variables;\n\n      if (variables && typeof variables === 'object') {\n        // Get the \"output\" variable's value (primary output)\n        const outputVar = (variables as Record<string, { value?: unknown }>).output;\n        if (outputVar && typeof outputVar === 'object' && 'value' in outputVar) {\n          outputValue = outputVar.value;\n        } else if (outputVar !== undefined) {\n          outputValue = outputVar;\n        } else {\n          // If no \"output\" key, try to get the first variable's value\n          const firstKey = Object.keys(variables)[0];\n          if (firstKey) {\n            const firstVar = (variables as Record<string, { value?: unknown }>)[firstKey];\n            if (firstVar && typeof firstVar === 'object' && 'value' in firstVar) {\n              outputValue = firstVar.value;\n            } else {\n              outputValue = firstVar;\n            }\n          }\n        }\n      }\n\n      // Per documentation: \"JSON-parsed if valid, else string\"\n      // If the output is a JSON string, parse it to allow {{ slug.property }} access\n      if (typeof outputValue === 'string') {\n        try {\n          const parsed = JSON.parse(outputValue);\n          // Only use parsed value if it's an object/array (not primitives)\n          if (typeof parsed === 'object' && parsed !== null) {\n            outputValue = parsed;\n          }\n        } catch {\n          // Not valid JSON, keep as string\n        }\n      }\n\n      // Store the direct output value (not a complex wrapper object)\n      // This matches the documentation: { \"fetch_user\": { \"id\": 123 } }\n      incomingData[slug] = outputValue;\n    }\n\n    this.deps.logger.debug('Built incoming data object', {\n      nodeId: node.id,\n      nodeType: node.type,\n      incomingNodeCount: Object.keys(incomingData).length,\n      incomingKeys: Object.keys(incomingData),\n    });\n\n    return incomingData;\n  }\n\n  /**\n   * Resolve {{ expression }} templates in node params using the incoming data context.\n   * Returns the params with all templatable string values resolved.\n   *\n   * @param params - Node parameters to resolve\n   * @param incomingData - Context data keyed by source node reference IDs\n   * @param skipKeys - Param keys to skip (their values should not be resolved as templates)\n   */\n  resolveTemplateParams(\n    params: Record<string, unknown>,\n    incomingData: NodeIncomingDataObject,\n    skipKeys: string[] = [],\n  ): Record<string, unknown> {\n    const resolved: Record<string, unknown> = {};\n\n    for (const [key, value] of Object.entries(params)) {\n      // Skip keys that shouldn't have their templates resolved\n      if (skipKeys.includes(key)) {\n        resolved[key] = value;\n        continue;\n      }\n\n      if (typeof value === 'string' && this.templateService.isTemplate(value)) {\n        try {\n          const renderedValue = this.templateService.render(value, incomingData);\n          resolved[key] = renderedValue;\n          this.deps.logger.debug('Resolved template param', {\n            param: key,\n            template: value,\n            resolved: renderedValue,\n          });\n        } catch (error) {\n          // On error, keep original value and log warning\n          this.deps.logger.warn('Failed to resolve template param', {\n            param: key,\n            template: value,\n            error: error instanceof Error ? error.message : String(error),\n          });\n          resolved[key] = value;\n        }\n      } else {\n        resolved[key] = value;\n      }\n    }\n\n    return resolved;\n  }\n\n  prepareNodeInputs(\n    node: FlowNodeDefinitions,\n    nodeOutputs: Map<FlowNodeDefinitions['id'], NodeOutput | undefined>,\n    edges: readonly FlowEdge[],\n    nodeMap?: Map<string, FlowNodeDefinitions>,\n  ): Record<string, unknown> {\n    const nodeInputs: Record<string, unknown> = {};\n    const missingInputs: string[] = [];\n    const handleValidationErrors: string[] = [];\n\n    const incomingEdges = edges.filter((edge) => edge.target === node.id);\n\n    for (const edge of incomingEdges) {\n      const sourceNodeOutput = nodeOutputs.get(edge.source);\n      const sourceNode = nodeMap?.get(edge.source);\n\n      if (sourceNode) {\n        const validation = this.validateEdgeHandles(edge, sourceNode, node);\n        if (!validation.isValid) {\n          handleValidationErrors.push(...validation.errors);\n        }\n      }\n\n      if (sourceNodeOutput) {\n        const targetInputKey = edge.targetHandle || 'input';\n        const sourceOutputKey = edge.sourceHandle || 'output';\n\n        const outputValue = this.getOutputValue(\n          sourceNodeOutput,\n          sourceOutputKey,\n          sourceNode?.type as GraphNodeType | undefined,\n          edge.source,\n        );\n\n        if (outputValue !== undefined) {\n          nodeInputs[targetInputKey] = outputValue;\n        } else {\n          missingInputs.push(`${edge.source}:${sourceOutputKey} -> ${targetInputKey}`);\n        }\n      } else {\n        missingInputs.push(\n          `${edge.source} (no output available) -> ${edge.targetHandle || 'input'}`,\n        );\n      }\n    }\n\n    if (handleValidationErrors.length > 0) {\n      this.deps.logger.error('Edge handle validation errors detected', {\n        nodeId: node.id,\n        nodeType: node.type,\n        errors: handleValidationErrors,\n      });\n    }\n\n    if (missingInputs.length > 0) {\n      this.deps.logger.warn('Node has missing inputs', {\n        nodeId: node.id,\n        nodeType: node.type,\n        missingInputs,\n        availableInputs: Object.keys(nodeInputs),\n      });\n    }\n\n    this.deps.logger.debug('Prepared node inputs', {\n      nodeId: node.id,\n      nodeType: node.type,\n      incomingEdgeCount: incomingEdges.length,\n      inputKeys: Object.keys(nodeInputs),\n      inputs: nodeInputs,\n      missingInputCount: missingInputs.length,\n      handleValidationErrorCount: handleValidationErrors.length,\n    });\n\n    return nodeInputs;\n  }\n\n  async executeNode(\n    flowRunId: string,\n    node: FlowNodeDefinitions,\n    inputs: Record<string, unknown>,\n    flowInputs: Record<string, unknown> = {},\n    definition?: InvectDefinition,\n    skippedNodeIds?: Set<string>,\n    useBatchProcessing?: boolean,\n    incomingData?: NodeIncomingDataObject,\n  ): Promise<NodeExecution> {\n    const { logger } = this.deps;\n\n    logger.debug('Executing node', { flowRunId: flowRunId, nodeId: node.id, nodeType: node.type });\n\n    // ── Step 1: Check for mapper configuration (new system) ──────────\n    const mapperConfig = node.mapper;\n    if (mapperConfig?.enabled && mapperConfig?.expression && this.deps.jsExpressionService) {\n      logger.debug('Node has mapper configuration, evaluating mapper expression', {\n        flowRunId,\n        nodeId: node.id,\n        mode: mapperConfig.mode,\n      });\n      return this.executeNodeWithMapper(\n        flowRunId,\n        node,\n        inputs,\n        flowInputs,\n        definition,\n        skippedNodeIds,\n        useBatchProcessing,\n        incomingData ?? {},\n        mapperConfig,\n      );\n    }\n\n    // Standard single execution\n    return this.executeNodeOnce(\n      flowRunId,\n      node,\n      inputs,\n      flowInputs,\n      definition,\n      skippedNodeIds,\n      useBatchProcessing,\n      incomingData,\n    );\n  }\n\n  /**\n   * Execute a node once (standard execution without looping).\n   */\n  private async executeNodeOnce(\n    flowRunId: string,\n    node: FlowNodeDefinitions,\n    inputs: Record<string, unknown>,\n    flowInputs: Record<string, unknown> = {},\n    definition?: InvectDefinition,\n    skippedNodeIds?: Set<string>,\n    useBatchProcessing?: boolean,\n    incomingData?: NodeIncomingDataObject,\n  ): Promise<NodeExecution> {\n    const {\n      logger,\n      nodeExecutionService,\n      nodeRegistry,\n      nodeDataService,\n      graphService,\n      credentialsService,\n    } = this.deps;\n\n    const safeInputs = inputs || {};\n\n    // Look up executor / action for this node type.\n    // Legacy executors are only used for AGENT; all others go through the action registry.\n    const executor = nodeRegistry.get(node.type as GraphNodeType);\n    const actionRegistry = getGlobalActionRegistry();\n    const action = !executor ? actionRegistry.get(node.type) : undefined;\n\n    if (!executor && !action) {\n      throw new Error(`No executor or action found for node type: ${node.type}`);\n    }\n\n    // Merge default params with node params (node params take precedence)\n    let defaultParams: Record<string, unknown> = {};\n    if (executor) {\n      defaultParams = executor.getDefinition().defaultParams ?? {};\n    } else if (action) {\n      defaultParams = Object.fromEntries(\n        (action.params.fields ?? [])\n          .filter((f) => f.defaultValue !== undefined)\n          .map((f) => [f.name, f.defaultValue]),\n      );\n    }\n    const nodeParams = { ...defaultParams, ...((node.params ?? {}) as Record<string, unknown>) };\n\n    // Determine which params should NOT be pre-resolved as templates\n    // For Template String node, the 'template' param is the actual template content\n    // that the executor will process - it should not be pre-resolved\n    const skipTemplateResolutionKeys: string[] = [];\n    const nodeTypeStr = node.type as string;\n    if (nodeTypeStr === GraphNodeType.TEMPLATE_STRING || nodeTypeStr === 'core.template_string') {\n      skipTemplateResolutionKeys.push('template');\n    }\n\n    // Resolve templates in node params using incoming data (keyed by source node reference IDs)\n    // Templates should use {{ source_node_ref }} format to access upstream node outputs\n    const resolvedParams = incomingData\n      ? this.resolveTemplateParams(nodeParams, incomingData, skipTemplateResolutionKeys)\n      : nodeParams;\n\n    logger.debug('Resolved node params', {\n      nodeId: node.id,\n      nodeType: node.type,\n      defaultParamKeys: Object.keys(defaultParams),\n      nodeParamKeys: Object.keys(node.params ?? {}),\n      resolvedParamKeys: Object.keys(resolvedParams),\n      skippedKeys: skipTemplateResolutionKeys,\n    });\n\n    // Create a node copy with resolved params for execution\n    const _nodeWithResolvedParams: FlowNodeDefinitions = {\n      ...node,\n      params: resolvedParams,\n    } as FlowNodeDefinitions;\n\n    // Store incomingData in the trace (uses reference_id-based keys like \"user_data\")\n    // This matches what users see in the config panel and use in templates\n    // Fall back to safeInputs only if incomingData is not available\n    const traceInputs =\n      incomingData && Object.keys(incomingData).length > 0\n        ? (incomingData as Record<string, unknown>)\n        : safeInputs;\n\n    const trace = await nodeExecutionService.createNodeExecution(\n      flowRunId,\n      node.id,\n      node.type,\n      traceInputs,\n    );\n\n    try {\n      await nodeExecutionService.updateNodeExecutionStatus(trace.id, NodeExecutionStatus.RUNNING);\n\n      const executionContext: NodeExecutionContext = {\n        nodeId: node.id,\n        flowRunId: flowRunId,\n        logger,\n        globalConfig: {},\n        flowInputs,\n        functions: {\n          markDownstreamNodesAsSkipped: (\n            nodeId: string,\n            edges: readonly FlowEdge[],\n            skippedNodes: Set<string>,\n            isFromIfElse?: boolean,\n          ) => {\n            logger.debug('Marking downstream nodes as skipped', {\n              nodeId,\n              edges: edges.length,\n              skippedNodes: Array.from(skippedNodes),\n              isFromIfElse,\n            });\n\n            graphService.markDownstreamNodesAsSkipped(nodeId, edges, skippedNodes, isFromIfElse);\n          },\n          runTemplateReplacement: (template: string, variables: Record<string, unknown>) => {\n            return nodeDataService.runTemplateReplacement(template, variables);\n          },\n          getCredential: async (credentialId: string) => {\n            if (!credentialsService) {\n              logger.warn('Credentials service not available', { credentialId });\n              return null;\n            }\n            try {\n              // Use getDecryptedWithRefresh for OAuth2 auto-refresh support\n              const credential = await credentialsService.getDecryptedWithRefresh(credentialId);\n              return credential;\n            } catch (error) {\n              logger.error('Failed to retrieve credential', {\n                credentialId,\n                error: error instanceof Error ? error.message : String(error),\n              });\n              return null;\n            }\n          },\n          submitPrompt: async (request) => {\n            logger.debug('Submitting model prompt', {\n              model: request.model,\n              provider: request.provider,\n              useBatchProcessing: request.useBatchProcessing,\n            });\n            await this.ensureAdapterRegistered(request.provider, request.credentialId);\n            return this.deps.baseAIClient.executePrompt(request);\n          },\n          submitAgentPrompt: async (request) => {\n            logger.debug('Submitting agent prompt', {\n              model: request.model,\n              toolCount: request.tools.length,\n              messageCount: request.messages.length,\n            });\n            await this.ensureAdapterRegistered(request.provider, request.credentialId);\n            return this.deps.baseAIClient.runAgentPrompt(request, request.provider);\n          },\n          recordToolExecution: async (input) => {\n            const { agentToolExecutionService } = this.deps;\n            if (!agentToolExecutionService) {\n              logger.warn('Agent tool execution service not available');\n              return null;\n            }\n            try {\n              const record = await agentToolExecutionService.recordToolExecution(input);\n              return { id: record.id };\n            } catch (error) {\n              logger.error('Failed to record tool execution', {\n                toolId: input.toolId,\n                error: error instanceof Error ? error.message : String(error),\n              });\n              return null;\n            }\n          },\n        },\n        nodes: definition?.nodes || [],\n        edges: definition?.edges || [],\n        nodeExecutionResults: new Map(),\n        allNodeOutputs: new Map(),\n        allNodeInputs: new Map(),\n        skippedNodeIds: skippedNodeIds || new Set(),\n        startedAt: new Date(),\n        flowId: '',\n        flowVersion: 1,\n        flowParams: {\n          useBatchProcessing: useBatchProcessing ?? true,\n        },\n        // Incoming data from upstream nodes, keyed by reference ID\n        // Available for nodes that do their own template processing\n        incomingData: incomingData || {},\n      };\n\n      // ── Plugin hook: beforeNodeExecute ───────────────────────────────────\n      let hookResolvedParams = resolvedParams;\n      if (this.deps.pluginHookRunner) {\n        try {\n          const beforeResult = await this.deps.pluginHookRunner.runBeforeNodeExecute({\n            flowRun: {\n              flowId: executionContext.flowId || '',\n              flowRunId: flowRunId,\n              flowVersion: executionContext.flowVersion || 1,\n              inputs: flowInputs,\n            },\n            nodeId: node.id,\n            nodeType: node.type,\n            nodeLabel: node.label,\n            inputs: traceInputs,\n            params: hookResolvedParams,\n          });\n\n          if (beforeResult.skipped) {\n            logger.info('Node execution skipped by plugin hook', { flowRunId, nodeId: node.id });\n            return await nodeExecutionService.updateNodeExecutionStatus(\n              trace.id,\n              NodeExecutionStatus.SKIPPED,\n            );\n          }\n\n          if (beforeResult.params) {\n            hookResolvedParams = beforeResult.params;\n          }\n        } catch (hookError) {\n          logger.warn('beforeNodeExecute plugin hook error (non-fatal)', {\n            nodeId: node.id,\n            error: hookError instanceof Error ? hookError.message : String(hookError),\n          });\n        }\n      }\n\n      // Update nodeWithResolvedParams if hooks modified params\n      const finalNodeWithParams: FlowNodeDefinitions = {\n        ...node,\n        params: hookResolvedParams,\n      } as FlowNodeDefinitions;\n\n      // ── Dispatch: legacy executor vs action ──────────────────────────────\n      let executionResult: import('src/types/node-execution.types').NodeExecutionResult;\n      const dispatchStartTime = Date.now();\n\n      if (executor) {\n        // Legacy path: use the BaseNodeExecutor\n        const inputValidation = executor.validateInputs(inputs);\n        if (!inputValidation.isValid) {\n          throw new Error(`Input validation failed: ${inputValidation.error}`);\n        }\n\n        executionResult = await executor.execute(\n          inputValidation.data,\n          finalNodeWithParams,\n          executionContext,\n        );\n      } else if (action) {\n        // Action path: use the action executor bridge\n        executionResult = await executeActionAsNode(action, hookResolvedParams, executionContext);\n      } else {\n        // Should be unreachable due to the guard above, but satisfies the compiler\n        throw new Error(`No executor or action found for node type: ${node.type}`);\n      }\n\n      const dispatchDuration = Date.now() - dispatchStartTime;\n\n      // ── Plugin hook: afterNodeExecute ────────────────────────────────────\n      // Extract output only from success results (the union doesn't have .output on all variants)\n      const rawOutput =\n        executionResult.state === NodeExecutionStatus.SUCCESS ? executionResult.output : undefined;\n      let finalOutput = rawOutput;\n      if (this.deps.pluginHookRunner && executionResult.state !== NodeExecutionStatus.PENDING) {\n        try {\n          const afterResult = await this.deps.pluginHookRunner.runAfterNodeExecute({\n            flowRun: {\n              flowId: executionContext.flowId || '',\n              flowRunId: flowRunId,\n              flowVersion: executionContext.flowVersion || 1,\n              inputs: flowInputs,\n            },\n            nodeId: node.id,\n            nodeType: node.type,\n            nodeLabel: node.label,\n            inputs: traceInputs,\n            params: hookResolvedParams,\n            status: executionResult.state === NodeExecutionStatus.FAILED ? 'FAILED' : 'SUCCESS',\n            output: rawOutput,\n            error:\n              executionResult.state === NodeExecutionStatus.FAILED\n                ? executionResult.errors.join(', ')\n                : undefined,\n            duration: dispatchDuration,\n          });\n\n          if (afterResult.output !== undefined) {\n            finalOutput = afterResult.output as typeof finalOutput;\n          }\n        } catch (hookError) {\n          logger.warn('afterNodeExecute plugin hook error (non-fatal)', {\n            nodeId: node.id,\n            error: hookError instanceof Error ? hookError.message : String(hookError),\n          });\n        }\n      }\n\n      if (executionResult.state === NodeExecutionStatus.FAILED) {\n        const errorMessage = executionResult.errors.join(', ');\n        logger.error('Node execution failed', {\n          flowRunId: flowRunId,\n          nodeId: node.id,\n          error: errorMessage,\n        });\n\n        return await nodeExecutionService.updateNodeExecutionStatus(\n          trace.id,\n          NodeExecutionStatus.FAILED,\n          {\n            error: errorMessage,\n          },\n        );\n      } else if (executionResult.state === NodeExecutionStatus.PENDING) {\n        logger.debug('Node submitted for batch processing', {\n          flowRunId: flowRunId,\n          nodeId: node.id,\n          batchJobId: executionResult.batchJobId,\n        });\n\n        return await nodeExecutionService.updateNodeExecutionStatus(\n          trace.id,\n          NodeExecutionStatus.BATCH_SUBMITTED,\n        );\n      } else {\n        logger.debug('Node execution completed successfully', {\n          flowRunId: flowRunId,\n          nodeId: node.id,\n          outputKeys: Object.keys(finalOutput || {}),\n        });\n\n        return await nodeExecutionService.updateNodeExecutionStatus(\n          trace.id,\n          NodeExecutionStatus.SUCCESS,\n          {\n            outputs: finalOutput,\n          },\n        );\n      }\n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      logger.error('Node execution failed', {\n        flowRunId: flowRunId,\n        nodeId: node.id,\n        error: errorMessage,\n      });\n\n      return await nodeExecutionService.updateNodeExecutionStatus(\n        trace.id,\n        NodeExecutionStatus.FAILED,\n        {\n          error: errorMessage,\n        },\n      );\n    }\n  }\n\n  // ══════════════════════════════════════════════════════════════════════════\n  // DATA MAPPER — NEW SYSTEM (replaces _loop)\n  // ══════════════════════════════════════════════════════════════════════════\n\n  /**\n   * Execute a node with a data mapper.\n   *\n   * 1. Evaluate the mapper JS expression against upstream data\n   * 2. If result is array + mode allows → iterate (execute once per item)\n   * 3. If result is object → single execution with mapped data as context\n   * 4. Primitives → single execution with { item: value } context\n   */\n  private async executeNodeWithMapper(\n    flowRunId: string,\n    node: FlowNodeDefinitions,\n    inputs: Record<string, unknown>,\n    flowInputs: Record<string, unknown>,\n    definition: InvectDefinition | undefined,\n    skippedNodeIds: Set<string> | undefined,\n    useBatchProcessing: boolean | undefined,\n    incomingData: NodeIncomingDataObject,\n    mapperConfig: MapperConfig,\n  ): Promise<NodeExecution> {\n    const { logger, nodeExecutionService } = this.deps;\n    const jsService = this.deps.jsExpressionService;\n\n    if (!jsService) {\n      throw new Error('JS expression service is required for mapper execution.');\n    }\n\n    // ── Evaluate mapper expression ───────────────────────────────────\n    let mappedResult: unknown;\n    try {\n      mappedResult = jsService.evaluate(mapperConfig.expression, incomingData);\n    } catch (e) {\n      // Mapper expression failed — create a failed trace with the error\n      const errorMessage =\n        e instanceof JsExpressionError ? e.message : `Mapper expression error: ${String(e)}`;\n      logger.error('Mapper expression failed', {\n        flowRunId,\n        nodeId: node.id,\n        expression: mapperConfig.expression,\n        error: errorMessage,\n      });\n\n      const trace = await nodeExecutionService.createNodeExecution(flowRunId, node.id, node.type, {\n        ...incomingData,\n        _mapper: { expression: mapperConfig.expression, error: errorMessage },\n      });\n      return await nodeExecutionService.updateNodeExecutionStatus(\n        trace.id,\n        NodeExecutionStatus.FAILED,\n        { error: errorMessage },\n      );\n    }\n\n    // ── Mode enforcement ─────────────────────────────────────────────\n    const mode = mapperConfig.mode ?? 'auto';\n    const isArray = Array.isArray(mappedResult);\n\n    if (mode === 'iterate' && !isArray) {\n      const errorMessage = `Mapper mode is \"iterate\" but expression returned ${typeof mappedResult}, not an array`;\n      logger.error(errorMessage, { flowRunId, nodeId: node.id });\n      const trace = await nodeExecutionService.createNodeExecution(flowRunId, node.id, node.type, {\n        ...incomingData,\n        _mapper: { expression: mapperConfig.expression, error: errorMessage },\n      });\n      return await nodeExecutionService.updateNodeExecutionStatus(\n        trace.id,\n        NodeExecutionStatus.FAILED,\n        { error: errorMessage },\n      );\n    }\n\n    if (mode === 'reshape' && isArray) {\n      // Reshape mode: wrap array in object to prevent accidental iteration\n      mappedResult = { items: mappedResult };\n    }\n\n    const shouldIterate = mode === 'iterate' || (mode === 'auto' && isArray);\n\n    // ── Branch: iterate vs single ────────────────────────────────────\n    if (shouldIterate) {\n      return this.executeNodeMapperIterating(\n        flowRunId,\n        node,\n        inputs,\n        flowInputs,\n        definition,\n        skippedNodeIds,\n        useBatchProcessing,\n        incomingData,\n        mappedResult as unknown[],\n        mapperConfig,\n      );\n    }\n\n    // Single execution: mapper returned object or primitive\n    let mappedData: NodeIncomingDataObject;\n    if (mappedResult !== null && typeof mappedResult === 'object' && !isArray) {\n      mappedData = mappedResult as NodeIncomingDataObject;\n    } else {\n      // Primitive — wrap in { item: value }\n      mappedData = { item: mappedResult };\n    }\n\n    // Execute once with mapped data as context (replaces incomingData for template resolution)\n    return this.executeNodeOnce(\n      flowRunId,\n      node,\n      inputs,\n      flowInputs,\n      definition,\n      skippedNodeIds,\n      useBatchProcessing,\n      mappedData,\n    );\n  }\n\n  /**\n   * Execute a node repeatedly — once per item from the mapper array result.\n   * Handles concurrency, empty array behavior, and result packaging.\n   */\n  private async executeNodeMapperIterating(\n    flowRunId: string,\n    node: FlowNodeDefinitions,\n    inputs: Record<string, unknown>,\n    flowInputs: Record<string, unknown>,\n    definition: InvectDefinition | undefined,\n    skippedNodeIds: Set<string> | undefined,\n    useBatchProcessing: boolean | undefined,\n    incomingData: NodeIncomingDataObject,\n    items: unknown[],\n    mapperConfig: MapperConfig,\n  ): Promise<NodeExecution> {\n    const { logger, nodeExecutionService } = this.deps;\n\n    // ── Handle empty array ───────────────────────────────────────────\n    if (items.length === 0) {\n      const trace = await nodeExecutionService.createNodeExecution(flowRunId, node.id, node.type, {\n        ...incomingData,\n        _mapper: { expression: mapperConfig.expression, itemCount: 0 },\n      });\n\n      if (mapperConfig.onEmpty === 'error') {\n        return await nodeExecutionService.updateNodeExecutionStatus(\n          trace.id,\n          NodeExecutionStatus.FAILED,\n          { error: 'Mapper returned empty array and onEmpty is \"error\"' },\n        );\n      }\n\n      // Skip: return success with empty output\n      return await nodeExecutionService.updateNodeExecutionStatus(\n        trace.id,\n        NodeExecutionStatus.SUCCESS,\n        {\n          outputs: {\n            nodeType: node.type,\n            data: {\n              variables: {\n                output: { value: [], type: 'object' as const },\n              },\n            },\n          },\n        },\n      );\n    }\n\n    // ── Create parent trace ──────────────────────────────────────────\n    const trace = await nodeExecutionService.createNodeExecution(flowRunId, node.id, node.type, {\n      ...incomingData,\n      _mapper: { expression: mapperConfig.expression, itemCount: items.length },\n    });\n\n    try {\n      await nodeExecutionService.updateNodeExecutionStatus(trace.id, NodeExecutionStatus.RUNNING);\n\n      const results: unknown[] = [];\n      const concurrency = mapperConfig.concurrency ?? 1;\n      let hasFailure = false;\n      let failureError: unknown;\n\n      if (concurrency === 1) {\n        // Sequential — stop on first failure\n        for (let i = 0; i < items.length; i++) {\n          const itemContext = this.buildMapperItemContext(items[i], i, items.length, incomingData);\n          const result = await this.executeSingleMapperIteration(\n            flowRunId,\n            node,\n            inputs,\n            flowInputs,\n            definition,\n            skippedNodeIds,\n            useBatchProcessing,\n            itemContext,\n          );\n          results.push(result);\n        }\n      } else {\n        // Parallel with concurrency limit\n        for (let start = 0; start < items.length; start += concurrency) {\n          const batch = items.slice(start, start + concurrency);\n          const batchResults = await Promise.allSettled(\n            batch.map((item, batchIdx) => {\n              const globalIdx = start + batchIdx;\n              const itemContext = this.buildMapperItemContext(\n                item,\n                globalIdx,\n                items.length,\n                incomingData,\n              );\n              return this.executeSingleMapperIteration(\n                flowRunId,\n                node,\n                inputs,\n                flowInputs,\n                definition,\n                skippedNodeIds,\n                useBatchProcessing,\n                itemContext,\n              );\n            }),\n          );\n\n          for (const r of batchResults) {\n            if (r.status === 'fulfilled') {\n              results.push(r.value);\n            } else {\n              hasFailure = true;\n              failureError = r.reason;\n            }\n          }\n          if (hasFailure) {\n            break;\n          }\n        }\n      }\n\n      if (hasFailure) {\n        const errorMessage =\n          failureError instanceof Error ? failureError.message : String(failureError);\n        return await nodeExecutionService.updateNodeExecutionStatus(\n          trace.id,\n          NodeExecutionStatus.FAILED,\n          { error: `Mapper iteration failed: ${errorMessage}` },\n        );\n      }\n\n      // ── Package results ────────────────────────────────────────────\n      const packagedOutput = this.packageMapperResults(results, mapperConfig);\n\n      return await nodeExecutionService.updateNodeExecutionStatus(\n        trace.id,\n        NodeExecutionStatus.SUCCESS,\n        {\n          outputs: {\n            nodeType: node.type,\n            data: {\n              variables: {\n                output: { value: packagedOutput, type: 'object' as const },\n              },\n              metadata: {\n                mapper: true,\n                iterationCount: items.length,\n                outputMode: mapperConfig.outputMode ?? 'array',\n              },\n            },\n          },\n        },\n      );\n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      logger.error('Mapper iteration failed', { flowRunId, nodeId: node.id, error: errorMessage });\n      return await nodeExecutionService.updateNodeExecutionStatus(\n        trace.id,\n        NodeExecutionStatus.FAILED,\n        { error: errorMessage },\n      );\n    }\n  }\n\n  /**\n   * Execute a single iteration within a mapper loop.\n   * Returns the output value from the node execution.\n   */\n  private async executeSingleMapperIteration(\n    flowRunId: string,\n    node: FlowNodeDefinitions,\n    inputs: Record<string, unknown>,\n    flowInputs: Record<string, unknown>,\n    definition: InvectDefinition | undefined,\n    skippedNodeIds: Set<string> | undefined,\n    useBatchProcessing: boolean | undefined,\n    itemContext: NodeIncomingDataObject,\n  ): Promise<unknown> {\n    // Execute the node with the item context as incomingData\n    // This means {{ }} expressions in config params resolve against the item\n    const trace = await this.executeNodeOnce(\n      flowRunId,\n      node,\n      inputs,\n      flowInputs,\n      definition,\n      skippedNodeIds,\n      useBatchProcessing,\n      itemContext,\n    );\n\n    // Extract the output value from the trace\n    const outputs = trace.outputs as NodeOutput | undefined;\n    const outputVar = outputs?.data?.variables?.output;\n    if (outputVar && typeof outputVar === 'object' && 'value' in outputVar) {\n      return (outputVar as { value: unknown }).value;\n    }\n    return outputs?.data ?? null;\n  }\n\n  /**\n   * Build the context object for a single iteration item.\n   *\n   * Layering (later wins on collision):\n   * 1. incomingData — all upstream outputs preserved\n   * 2. Item properties spread (if object) or { item: value } for primitives\n   * 3. _item metadata (index, total, first/last)\n   */\n  private buildMapperItemContext(\n    item: unknown,\n    index: number,\n    total: number,\n    incomingData: NodeIncomingDataObject,\n  ): NodeIncomingDataObject {\n    const context: NodeIncomingDataObject = { ...incomingData };\n\n    if (item !== null && typeof item === 'object' && !Array.isArray(item)) {\n      Object.assign(context, item);\n    } else {\n      context.item = item;\n    }\n\n    context._item = {\n      value: item,\n      index,\n      iteration: index + 1,\n      first: index === 0,\n      last: index === total - 1,\n      total,\n    };\n\n    return context;\n  }\n\n  /**\n   * Package iteration results according to outputMode.\n   */\n  private packageMapperResults(results: unknown[], config: MapperConfig): unknown {\n    const mode = config.outputMode ?? 'array';\n    switch (mode) {\n      case 'array':\n        return results;\n      case 'object': {\n        const keyField = config.keyField ?? 'id';\n        const obj: Record<string, unknown> = {};\n        for (const r of results) {\n          if (r && typeof r === 'object') {\n            const key = String((r as Record<string, unknown>)[keyField] ?? '');\n            if (key) {\n              obj[key] = r;\n            }\n          }\n        }\n        return obj;\n      }\n      case 'first':\n        return results[0] ?? null;\n      case 'last':\n        return results[results.length - 1] ?? null;\n      case 'concat':\n        return results.map((r) => String(r ?? '')).join('');\n      default:\n        return results;\n    }\n  }\n\n  private validateEdgeHandles(\n    _edge: FlowEdge,\n    _sourceNode: FlowNodeDefinitions,\n    _targetNode: FlowNodeDefinitions,\n  ): { isValid: boolean; errors: string[] } {\n    // Edge handle validation is disabled.\n    // In the current architecture, nodes receive all upstream data via reference IDs,\n    // and params contain {{ expression }} templates that reference that data.\n    // The specific handle IDs on edges are informational only.\n    return {\n      isValid: true,\n      errors: [],\n    };\n  }\n\n  private getOutputValue(\n    nodeOutput: NodeOutput,\n    outputKey: string,\n    sourceNodeType?: GraphNodeType,\n    sourceNodeId?: string,\n  ): unknown {\n    if (!nodeOutput?.data?.variables) {\n      this.deps.logger.debug('getOutputValue: Missing variables in nodeOutput', {\n        outputKey,\n        sourceNodeType,\n        sourceNodeId,\n      });\n      return undefined;\n    }\n\n    const { variables } = nodeOutput.data;\n\n    if (outputKey in variables) {\n      const variable = variables[outputKey];\n      this.deps.logger.debug('getOutputValue: Found variable', {\n        outputKey,\n        valueType: typeof variable.value,\n        sourceNodeType,\n        sourceNodeId,\n      });\n      return variable.value;\n    }\n\n    this.deps.logger.warn('getOutputValue: Variable not found', {\n      outputKey,\n      sourceNodeType,\n      sourceNodeId,\n      availableVariables: Object.keys(variables),\n    });\n\n    return undefined;\n  }\n}\n"],"mappings":"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"}

package/dist/services/flow-orchestration.service.cjs

@@ -0,0 +1,493 @@
+const require_errors_types = require("../types/common/errors.types.cjs");
+const require_base = require("../types/base.cjs");
+const require_ai_types = require("./ai/ai-types.cjs");
+require("./ai/base-client.cjs");
+const require_node_execution_coordinator = require("./flow-orchestration/node-execution-coordinator.cjs");
+const require_flow_run_coordinator = require("./flow-orchestration/flow-run-coordinator.cjs");
+//#region src/services/flow-orchestration.service.ts
+/**
+* Core Flow Orchestration Service implementation
+* Manages the complete flow execution lifecycle using service layer abstractions
+*/
+var FlowOrchestrationService = class {
+	initialized = false;
+	batchPollingInterval;
+	staleRunCheckInterval;
+	isPollingActive = false;
+	nodeExecutionCoordinator;
+	flowRunCoordinator;
+	flowTimeoutMs;
+	staleRunCheckIntervalMs;
+	constructor(logger, flowRunsService, nodeExecutionService, flowsService, nodeDataService, graphService, nodeRegistry, batchJobsService, credentialsService, baseAIClient, agentToolExecutionService, executionConfig, pluginHookRunner, jsExpressionService, templateService) {
+		this.logger = logger;
+		this.flowRunsService = flowRunsService;
+		this.nodeExecutionService = nodeExecutionService;
+		this.flowsService = flowsService;
+		this.nodeDataService = nodeDataService;
+		this.graphService = graphService;
+		this.nodeRegistry = nodeRegistry;
+		this.batchJobsService = batchJobsService;
+		this.credentialsService = credentialsService;
+		this.baseAIClient = baseAIClient;
+		this.agentToolExecutionService = agentToolExecutionService;
+		this.pluginHookRunner = pluginHookRunner;
+		this.jsExpressionService = jsExpressionService;
+		this.templateService = templateService;
+		if (!baseAIClient) throw new Error("BaseAIClient is required for FlowOrchestrationService");
+		this.flowTimeoutMs = executionConfig?.flowTimeoutMs ?? 6e5;
+		this.staleRunCheckIntervalMs = executionConfig?.staleRunCheckIntervalMs ?? 6e4;
+		this.nodeExecutionCoordinator = new require_node_execution_coordinator.NodeExecutionCoordinator({
+			logger,
+			nodeExecutionService,
+			nodeRegistry,
+			nodeDataService,
+			graphService,
+			credentialsService,
+			agentToolExecutionService,
+			templateService,
+			jsExpressionService,
+			baseAIClient,
+			pluginHookRunner
+		});
+		this.flowRunCoordinator = new require_flow_run_coordinator.FlowRunCoordinator({
+			logger,
+			flowRunsService,
+			nodeExecutionCoordinator: this.nodeExecutionCoordinator,
+			graphService,
+			nodeExecutionService,
+			batchJobsService,
+			flowsService,
+			heartbeatIntervalMs: executionConfig?.heartbeatIntervalMs ?? 3e4,
+			pluginHookRunner
+		});
+	}
+	/**
+	* Initialize the service
+	*/
+	async initialize() {
+		if (this.initialized) {
+			this.logger.debug("Flow orchestration service already initialized");
+			return;
+		}
+		this.logger.debug("Initializing flow orchestration service");
+		try {
+			await this.flowsService.initialize();
+			await this.flowRunsService.initialize();
+			await this.nodeExecutionService.initialize();
+			await this.batchJobsService.initialize();
+			await this.recoverStaleRuns();
+			await this.startFlowResumptionPolling();
+			this.startStaleRunDetector();
+			this.initialized = true;
+			this.logger.info("Flow orchestration service initialized successfully");
+		} catch (error) {
+			this.logger.error("Failed to initialize flow orchestration service", { error });
+			throw new require_errors_types.DatabaseError("Failed to initialize flow orchestration service", { error });
+		}
+	}
+	/**
+	* Startup recovery: mark all RUNNING/PENDING runs with stale heartbeats as FAILED.
+	* This handles flows that were mid-execution when the server last stopped.
+	*/
+	async recoverStaleRuns() {
+		try {
+			const failedCount = await this.flowRunsService.failStaleRuns(this.flowTimeoutMs);
+			if (failedCount > 0) this.logger.warn(`Startup recovery: marked ${failedCount} stale flow run(s) as FAILED`);
+		} catch (error) {
+			this.logger.error("Failed to recover stale runs on startup", { error });
+		}
+	}
+	/**
+	* Start a periodic check for stale flow runs.
+	* Runs at the configured `staleRunCheckIntervalMs`.
+	*/
+	startStaleRunDetector() {
+		if (this.staleRunCheckInterval) return;
+		this.logger.info("Starting stale run detector", {
+			flowTimeoutMs: this.flowTimeoutMs,
+			checkIntervalMs: this.staleRunCheckIntervalMs
+		});
+		this.staleRunCheckInterval = setInterval(async () => {
+			try {
+				const failedCount = await this.flowRunsService.failStaleRuns(this.flowTimeoutMs);
+				if (failedCount > 0) this.logger.warn(`Stale run detector: marked ${failedCount} run(s) as FAILED`);
+			} catch (error) {
+				this.logger.error("Error in stale run detector", { error });
+			}
+		}, this.staleRunCheckIntervalMs);
+	}
+	/**
+	* Stop the periodic stale run detector.
+	*/
+	stopStaleRunDetector() {
+		if (this.staleRunCheckInterval) {
+			clearInterval(this.staleRunCheckInterval);
+			this.staleRunCheckInterval = void 0;
+		}
+	}
+	/**
+	* Execute a flow by ID with inputs and options
+	*/
+	async executeFlow(flowId, inputs = {}, options) {
+		this.logger.info("Starting flow execution", {
+			flowId,
+			inputs
+		});
+		try {
+			this.logger.debug("Getting flow", {
+				flowId,
+				options
+			});
+			const flow = await this.flowsService.getFlowById(flowId, { flowVersion: { version: options?.version || "latest" } });
+			if (!flow) throw new require_errors_types.ValidationError(`No flow found with ID: ${flowId}`);
+			this.logger.debug("Flow version found", {
+				flowId,
+				version: flow.flowVersion
+			});
+			return await this.initiateFlowRun(flow, inputs, options?.initiatedBy, options?.useBatchProcessing);
+		} catch (error) {
+			if (error instanceof require_errors_types.ValidationError) throw error;
+			this.logger.error("Failed to execute flow", {
+				flowId,
+				error: error instanceof Error ? error.message : String(error),
+				stack: error instanceof Error ? error.stack : void 0
+			});
+			throw new require_errors_types.DatabaseError("Failed to execute flow", { error });
+		}
+	}
+	/**
+	* Start a flow execution asynchronously - returns immediately with flow run ID.
+	* The flow executes in the background.
+	*/
+	async executeFlowAsync(flowId, inputs = {}, options) {
+		this.logger.info("Starting async flow execution", {
+			flowId,
+			inputs
+		});
+		try {
+			const flow = await this.flowsService.getFlowById(flowId, { flowVersion: { version: options?.version || "latest" } });
+			if (!flow) throw new require_errors_types.ValidationError(`No flow found with ID: ${flowId}`);
+			if (!flow.flowVersion.invectDefinition) throw new require_errors_types.ValidationError("Flow version does not contain a valid flow definition");
+			const execution = await this.flowRunsService.createFlowRun({
+				flowId: flow.id,
+				flowVersion: flow.flowVersion.version,
+				inputs,
+				createdBy: options?.initiatedBy,
+				triggerType: options?.triggerType,
+				triggerId: options?.triggerId,
+				triggerNodeId: options?.triggerNodeId,
+				triggerData: options?.triggerData
+			});
+			this.logger.info("Created execution record for async execution", {
+				flowRunId: execution.id,
+				flowId: flow.id
+			});
+			const typedDefinition = flow.flowVersion.invectDefinition;
+			const augmentedInputs = {
+				...execution.inputs,
+				...execution.triggerData ? {
+					__triggerData: execution.triggerData,
+					__triggerNodeId: execution.triggerNodeId
+				} : {}
+			};
+			this.flowRunCoordinator.executeFlowDefinition(execution, typedDefinition, augmentedInputs, options?.useBatchProcessing).then((result) => {
+				this.logger.info("Async flow execution completed", {
+					flowRunId: execution.id,
+					status: result.status
+				});
+			}).catch(async (error) => {
+				const errorMessage = error instanceof Error ? error.message : String(error);
+				this.logger.error("Async flow execution failed", {
+					flowRunId: execution.id,
+					error: errorMessage
+				});
+				await this.flowRunsService.updateRunStatus(execution.id, require_base.FlowRunStatus.FAILED, { error: errorMessage });
+			});
+			return {
+				flowRunId: execution.id,
+				status: require_base.FlowRunStatus.PENDING,
+				inputs: execution.inputs,
+				outputs: {},
+				startedAt: typeof execution.startedAt === "string" ? new Date(execution.startedAt) : execution.startedAt,
+				traces: []
+			};
+		} catch (error) {
+			if (error instanceof require_errors_types.ValidationError) throw error;
+			this.logger.error("Failed to start async flow execution", {
+				flowId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			throw new require_errors_types.DatabaseError("Failed to start flow execution", { error });
+		}
+	}
+	/**
+	* Execute a complete flow (synchronous - waits for completion)
+	*/
+	async initiateFlowRun(flow, inputs = {}, initiatedBy, useBatchProcessing) {
+		this.logger.info("Starting flow orchestration", {
+			flowId: flow.id,
+			flowVersion: flow.flowVersion.version
+		});
+		if (!flow.flowVersion.invectDefinition) {
+			const error = "Flow version does not contain a valid flow definition";
+			this.logger.error(error, {
+				flowId: flow.id,
+				flowVersion: flow.flowVersion.version
+			});
+			throw new require_errors_types.ValidationError(error);
+		}
+		let execution;
+		let finalExecutionResult;
+		try {
+			execution = await this.flowRunsService.createFlowRun({
+				flowId: flow.id,
+				flowVersion: flow.flowVersion.version,
+				inputs,
+				createdBy: initiatedBy
+			});
+			this.logger.info("Created execution record", {
+				flowRunId: execution.id,
+				flowId: flow.id
+			});
+			const typedDefinition = flow.flowVersion.invectDefinition;
+			finalExecutionResult = await this.flowRunCoordinator.executeFlowDefinition(execution, typedDefinition, execution.inputs, useBatchProcessing);
+			this.logger.info("Flow execution completed", {
+				flowRunId: execution.id,
+				status: finalExecutionResult.status
+			});
+			return finalExecutionResult;
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			this.logger.error("Flow execution failed", {
+				flowRunId: execution?.id,
+				flowId: flow.id,
+				error: errorMessage
+			});
+			if (execution) {
+				await this.flowRunsService.updateRunStatus(execution.id, require_base.FlowRunStatus.FAILED, { error: errorMessage });
+				const traces = await this.nodeExecutionService.listNodeExecutionsByFlowRunId(execution.id);
+				finalExecutionResult = {
+					flowRunId: execution.id,
+					status: require_base.FlowRunStatus.FAILED,
+					inputs: execution.inputs,
+					outputs: {},
+					error: errorMessage,
+					startedAt: typeof execution.startedAt === "string" ? new Date(execution.startedAt) : execution.startedAt,
+					completedAt: /* @__PURE__ */ new Date(),
+					duration: execution.duration || 0,
+					traces
+				};
+				return finalExecutionResult;
+			}
+			throw new require_errors_types.DatabaseError("Failed to orchestrate flow execution", {
+				error,
+				flowId: flow.id
+			});
+		}
+	}
+	/**
+	* Execute a flow definition
+	*/
+	/**
+	* Execute a flow up to a specific target node.
+	* Only executes the upstream nodes required to produce output for the target node.
+	*/
+	async executeFlowToNode(flowId, targetNodeId, inputs = {}, options) {
+		this.logger.info("Starting partial flow execution to node", {
+			flowId,
+			targetNodeId,
+			inputs
+		});
+		try {
+			const flow = await this.flowsService.getFlowById(flowId, { flowVersion: { version: options?.version || "latest" } });
+			if (!flow) throw new require_errors_types.ValidationError(`No flow found with ID: ${flowId}`);
+			if (!flow.flowVersion.invectDefinition) throw new require_errors_types.ValidationError("Flow version does not contain a valid flow definition");
+			const definition = flow.flowVersion.invectDefinition;
+			if (!definition.nodes.find((n) => n.id === targetNodeId)) throw new require_errors_types.ValidationError(`Target node not found in flow: ${targetNodeId}`);
+			const execution = await this.flowRunsService.createFlowRun({
+				flowId: flow.id,
+				flowVersion: flow.flowVersion.version,
+				inputs,
+				createdBy: options?.initiatedBy
+			});
+			this.logger.info("Created execution record for partial flow", {
+				flowRunId: execution.id,
+				flowId: flow.id,
+				targetNodeId
+			});
+			const result = await this.flowRunCoordinator.executeFlowToNode(execution, definition, targetNodeId, execution.inputs, options?.useBatchProcessing);
+			this.logger.info("Partial flow execution completed", {
+				flowRunId: execution.id,
+				targetNodeId,
+				status: result.status
+			});
+			return result;
+		} catch (error) {
+			if (error instanceof require_errors_types.ValidationError) throw error;
+			this.logger.error("Failed to execute partial flow", {
+				flowId,
+				targetNodeId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			throw new require_errors_types.DatabaseError("Failed to execute partial flow", { error });
+		}
+	}
+	/**
+	* Resume flow execution after batch completion
+	*/
+	async resumeFromBatchCompletion(flowRunId, completedBatchNodeId, batchResult, batchError) {
+		return this.flowRunCoordinator.resumeFromBatchCompletion(flowRunId, completedBatchNodeId, batchResult, batchError);
+	}
+	/**
+	* Continue flow execution after batch completion
+	*/
+	async continueFlowRunFromBatch(flowRunId, definition, flowInputs = {}) {
+		return this.flowRunCoordinator.continueFlowRunFromBatch(flowRunId, definition, flowInputs);
+	}
+	/**
+	* Get execution with traces
+	*/
+	async getExecutionWithTraces(flowRunId) {
+		try {
+			const execution = await this.flowRunsService.getRunById(flowRunId);
+			const traces = await this.nodeExecutionService.listNodeExecutionsByFlowRunId(flowRunId);
+			return {
+				flowRunId: execution.id,
+				status: execution.status,
+				inputs: execution.inputs,
+				outputs: execution.outputs || {},
+				error: execution.error,
+				startedAt: typeof execution.startedAt === "string" ? new Date(execution.startedAt) : execution.startedAt,
+				completedAt: execution.completedAt ? typeof execution.completedAt === "string" ? new Date(execution.completedAt) : execution.completedAt : void 0,
+				duration: execution.duration,
+				traces
+			};
+		} catch (error) {
+			this.logger.error("Failed to get execution with traces", {
+				flowRunId,
+				error
+			});
+			throw new require_errors_types.DatabaseError("Failed to get execution with traces", { error });
+		}
+	}
+	/**
+	* Cancel a running execution
+	*/
+	async cancelExecution(flowRunId) {
+		try {
+			const execution = await this.flowRunsService.getRunById(flowRunId);
+			if (execution.status !== "RUNNING" && execution.status !== "PENDING") throw new require_errors_types.DatabaseError(`Cannot cancel execution in ${execution.status} state`);
+			await this.flowRunsService.updateRunStatus(flowRunId, "CANCELLED");
+			this.logger.info("Execution cancelled", { flowRunId });
+		} catch (error) {
+			this.logger.error("Failed to cancel execution", {
+				flowRunId,
+				error
+			});
+			throw error;
+		}
+	}
+	/**
+	* Start polling for completed batch jobs to resume flows
+	*/
+	async startFlowResumptionPolling(intervalMs = 3e4) {
+		if (this.isPollingActive) {
+			this.logger.debug("Flow resumption polling is already active");
+			return;
+		}
+		this.logger.info("Starting flow resumption polling", { intervalMs });
+		this.isPollingActive = true;
+		const pollOnce = async () => {
+			if (!this.isPollingActive) return;
+			try {
+				await this.pollForCompletedBatches();
+			} catch (error) {
+				this.logger.error("Error during flow resumption polling", { error });
+			}
+		};
+		await pollOnce();
+		this.batchPollingInterval = setInterval(pollOnce, intervalMs);
+	}
+	/**
+	* Stop polling for completed batch jobs
+	*/
+	async stopFlowResumptionPolling() {
+		if (!this.isPollingActive) {
+			this.logger.debug("Flow resumption polling is not active");
+			return;
+		}
+		this.logger.info("Stopping flow resumption polling");
+		this.isPollingActive = false;
+		if (this.batchPollingInterval) {
+			clearInterval(this.batchPollingInterval);
+			this.batchPollingInterval = void 0;
+		}
+	}
+	/**
+	* Poll for completed batch jobs and resume corresponding flows
+	*/
+	async pollForCompletedBatches() {
+		try {
+			const flowsToResume = await this.findFlowsReadyForResumption();
+			if (flowsToResume.length === 0) {
+				this.logger.debug("No flows found ready for resumption");
+				return;
+			}
+			this.logger.info("Found flows ready for resumption", {
+				count: flowsToResume.length,
+				flowRunIds: flowsToResume.map((f) => f.flowRunId)
+			});
+			for (const flowResumption of flowsToResume) try {
+				await this.resumeFromBatchCompletion(flowResumption.flowRunId, flowResumption.nodeId, flowResumption.batchResult, flowResumption.batchError);
+				this.logger.info("Flow resumed successfully", {
+					flowRunId: flowResumption.flowRunId,
+					nodeId: flowResumption.nodeId
+				});
+			} catch (error) {
+				this.logger.error("Failed to resume flow", {
+					flowRunId: flowResumption.flowRunId,
+					nodeId: flowResumption.nodeId,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			}
+		} catch (error) {
+			this.logger.error("Error polling for completed batches", { error });
+		}
+	}
+	/**
+	* Find flows that are paused for batch processing but have completed batch jobs
+	*/
+	async findFlowsReadyForResumption() {
+		try {
+			const pausedFlowsResult = await this.flowRunsService.listRuns({ filter: { status: [require_base.FlowRunStatus.PAUSED_FOR_BATCH] } });
+			const flowsToResume = [];
+			for (const flowRun of pausedFlowsResult.data) {
+				const completedBatchJobs = (await this.batchJobsService.getBatchJobsByFlowRunId(flowRun.id)).filter((job) => job.status === require_ai_types.BatchStatus.COMPLETED || job.status === require_ai_types.BatchStatus.FAILED || job.status === require_ai_types.BatchStatus.CANCELLED);
+				for (const batchJob of completedBatchJobs) flowsToResume.push({
+					flowRunId: flowRun.id,
+					nodeId: batchJob.nodeId,
+					batchResult: batchJob.status === require_ai_types.BatchStatus.COMPLETED ? batchJob.responseData : void 0,
+					batchError: batchJob.status === require_ai_types.BatchStatus.FAILED || batchJob.status === require_ai_types.BatchStatus.CANCELLED ? batchJob.error : void 0
+				});
+			}
+			return flowsToResume;
+		} catch (error) {
+			this.logger.error("Failed to find flows ready for resumption", { error });
+			return [];
+		}
+	}
+	/**
+	* Close the service
+	*/
+	async close() {
+		this.logger.debug("Closing flow orchestration service");
+		this.flowRunCoordinator.stopAllHeartbeats();
+		await this.stopFlowResumptionPolling();
+		this.stopStaleRunDetector();
+		this.initialized = false;
+	}
+};
+//#endregion
+exports.FlowOrchestrationService = FlowOrchestrationService;
+
+//# sourceMappingURL=flow-orchestration.service.cjs.map