Function compileWorkflowGraph

backend/src/dsl/compiler.ts:61–297

(graph: WorkflowGraphDto)

}

export function compileWorkflowGraph(graph: WorkflowGraphDto): WorkflowDefinition {
  // Filter out UI-only nodes (like text-block) that shouldn't be executed
  const executableNodes = graph.nodes.filter((node: WorkflowNodeDto) => {
    const component = componentRegistry.get(node.type);
    if (!component) {
      return true; // Let validation catch unknown components
    }
    // Skip UI-only components (they're for documentation/notes, not execution)
    const isUiOnly = (component.ui as any)?.uiOnly === true;
    return !isUiOnly;
  });

  const nodeIds = executableNodes.map((node: WorkflowNodeDto) => node.id);

  // Ensure all executable nodes reference registered components.
  for (const node of executableNodes) {
    if (!componentRegistry.get(node.type)) {
      throw new Error(`Component not registered: ${node.type}`);
    }
  }

  const orderedIds = topoSort(nodeIds, graph.edges);
  const incomingEdges = new Map<string, Set<string>>();
  type GraphEdge = (typeof graph.edges)[number];
  const edgesByTarget = new Map<string, GraphEdge[]>();
  for (const nodeId of nodeIds) {
    incomingEdges.set(nodeId, new Set());
    edgesByTarget.set(nodeId, []);
  }
  for (const edge of graph.edges) {
    incomingEdges.get(edge.target)?.add(edge.source);
    edgesByTarget.get(edge.target)?.push(edge);
  }

  const nodesMetadata: Record<string, WorkflowNodeMetadata> = {};
  for (const node of executableNodes) {
    const config = (node.data?.config ?? {}) as Record<string, unknown>;
    const joinStrategyValue = config.joinStrategy;
    const joinStrategy =
      typeof joinStrategyValue === 'string' && ['all', 'any', 'first'].includes(joinStrategyValue)
        ? (joinStrategyValue as WorkflowNodeMetadata['joinStrategy'])
        : undefined;

    const streamIdValue = config.streamId;
    const groupIdValue = config.groupId;
    const maxConcurrencyValue = config.maxConcurrency;

    const mode = (config.mode as WorkflowNodeMetadata['mode']) ?? 'normal';
    const toolConfig = config.toolConfig as WorkflowNodeMetadata['toolConfig'];

    const connectedToolNodeIds = edgesByTarget
      .get(node.id)
      ?.filter((edge) => edge.targetHandle === 'tools')
      .map((edge) => edge.source);

    nodesMetadata[node.id] = {
      ref: node.id,
      mode,