Split Node

import { createFlow, split, extract, combine } from '@docloai/flows';
import { createVLMProvider } from '@docloai/providers-llm';

const vlmProvider = createVLMProvider({
  provider: 'google',
  model: 'google/gemini-flash-2.5',
  apiKey: process.env.OPENROUTER_API_KEY!,
  via: 'openrouter'
});

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

const result = await flow.run({ base64: multiDocPdf });
// result.output is an array of extracted documents

split({
  provider: vlmProvider,           // Required: VLM provider
  schemas: {                       // Required: Document type schemas
    invoice: invoiceSchema,
    receipt: receiptSchema,
    contract: contractSchema
  },
  includeOther: true,              // Include uncategorized documents
  consensus: { runs: 3 },          // Multi-run voting for accuracy
  reasoning: { enabled: true }     // Extended thinking
})

interface SplitDocument {
  type: string;           // Document type ('invoice', 'receipt', 'other')
  schema: object;         // Schema for this document type
  pages: number[];        // Page numbers in original PDF
  input: FlowInput;       // Input for processing this document
}

const flow = createFlow()
  .step('split', split({
    provider: vlmProvider,
    schemas: { invoice: invoiceSchema, receipt: receiptSchema }
  }))
  .forEach('process', (doc) =>
    createFlow()
      .step('extract', extract({
        provider: vlmProvider,
        schema: doc.schema  // Uses the matched schema
      }))
  )
  .step('combine', combine())
  .build();

const flow = createFlow()
  .step('split', split({
    provider: vlmProvider,
    schemas: { invoice: invoiceSchema, receipt: receiptSchema }
  }))
  .forEach('process', (doc) =>
    createFlow()
      .conditional('extract', (d) => {
        if (d.type === 'invoice') {
          return extract({ provider: vlmProvider, schema: invoiceSchema });
        } else if (d.type === 'receipt') {
          return extract({ provider: vlmProvider, schema: receiptSchema });
        }
        return extract({ provider: vlmProvider, schema: genericSchema });
      })
  )
  .step('combine', combine())
  .build();

split({
  provider: vlmProvider,
  schemaRef: 'document-types@1.0.0'
})

// Registry entry structure
{
  id: 'document-types',
  version: '1.0.0',
  schema: {
    schemas: {
      invoice: { /* schema */ },
      receipt: { /* schema */ }
    }
  }
}

split({
  provider: vlmProvider,
  schemas: { invoice: invoiceSchema },
  includeOther: true  // Default: true
})

split({
  provider: vlmProvider,
  schemas: { invoice: invoiceSchema },
  includeOther: false  // Skip unrecognized documents
})

split({
  provider: vlmProvider,
  schemas: { invoice: invoiceSchema, receipt: receiptSchema },
  reasoning: {
    enabled: true,
    effort: 'high'
  }
})

const insuranceFlow = createFlow()
  .step('split', split({
    provider: vlmProvider,
    schemas: {
      claim_form: claimSchema,
      medical_report: medicalSchema,
      receipt: receiptSchema,
      id_document: idSchema
    }
  }))
  .forEach('extract', (doc) =>
    createFlow()
      .step('extract', extract({
        provider: vlmProvider,
        schema: doc.schema
      }))
  )
  .step('combine', combine({ strategy: 'merge' }))
  .build();

const result = await insuranceFlow.run({ base64: documentBundle });

// result.output contains all extracted documents
// [
//   { type: 'claim_form', data: { ... } },
//   { type: 'medical_report', data: { ... } },
//   { type: 'receipt', data: { ... } }
// ]