Combine Node

import { createFlow, split, extract, combine } from '@doclo/flows';

const flow = createFlow()
  .step('split', split({
    provider: vlmProvider,
    schemas: { invoice: invoiceSchema, receipt: receiptSchema }
  }))
  .forEach('extract', (doc) =>
    createFlow()
      .step('extract', extract({
        provider: vlmProvider,
        schema: doc.schema
      }))
  )
  .step('combine', combine())  // Merge all extraction results
  .build();

combine({
  strategy: 'merge'  // 'merge' | 'concatenate' | 'first' | 'last'
})

combine({ strategy: 'merge' })

// Arrays
[['a', 'b'], ['c', 'd']] → ['a', 'b', 'c', 'd']

// Objects
[{a: 1}, {b: 2}] → {a: 1, b: 2}

// Mixed
['string', {a: 1}] → ['string', {a: 1}]

combine({ strategy: 'concatenate' })

// All inputs preserved as array
[{a: 1}, {b: 2}] → [{a: 1}, {b: 2}]

combine({ strategy: 'first' })

[null, {a: 1}, {b: 2}] → {a: 1}

combine({ strategy: 'last' })

[{a: 1}, {b: 2}, null] → {b: 2}

const flow = createFlow()
  .step('split', split({
    provider: vlmProvider,
    schemas: { invoice: invoiceSchema }
  }))
  .forEach('extract', (doc) =>
    createFlow()
      .step('extract', extract({
        provider: vlmProvider,
        schema: doc.schema
      }))
  )
  .step('combine', combine({ strategy: 'concatenate' }))
  .build();

// Result: array of extracted invoices
// [{ invoiceNumber: 'INV-001', ... }, { invoiceNumber: 'INV-002', ... }]

const flow = createFlow()
  .parallel('extract', [
    extract({ provider: provider1, schema: schema }),
    extract({ provider: provider2, schema: schema }),
    extract({ provider: provider3, schema: schema })
  ])
  .step('combine', combine({ strategy: 'first' }))
  .build();

// Returns first successful extraction

const flow = createFlow()
  .step('parse', parse({ provider: ocrProvider }))
  .step('chunk', chunk({ strategy: 'page', pagesPerChunk: 5 }))
  .forEach('extract', (chunks) =>
    createFlow()
      .step('extract', extract({
        provider: llmProvider,
        schema: {
          type: 'object',
          properties: {
            items: { type: 'array', items: itemSchema }
          }
        }
      }))
  )
  .step('combine', combine({ strategy: 'merge' }))
  .build();

// Merges items from all chunks into single object

const flow = createFlow()
  .parallel('extract', [
    extract({
      provider: vlmProvider,
      schema: headerSchema  // Extracts header info
    }),
    extract({
      provider: vlmProvider,
      schema: lineItemsSchema  // Extracts line items
    }),
    extract({
      provider: vlmProvider,
      schema: totalsSchema  // Extracts totals
    })
  ])
  .step('combine', combine({ strategy: 'merge' }))
  .build();

// Result: single object with all fields merged
// { header: {...}, lineItems: [...], totals: {...} }

combine()  // No provider needed