Issue while batching list of text string

Use this logic:

a!localVariables(
/* Input: list of items to process */
local!data: ri!items,
/* or pv!allItems */
/* Batch size */
local!batchSize: 50,
/* Compute number of batches */
local!numBatches: tointeger(
if(
mod(length(local!data), local!batchSize) = 0,
length(local!data) / local!batchSize,
(length(local!data) / local!batchSize) + 1
)
),
/* Split manually into batches */
a!forEach(
items: enumerate(local!numBatches),
expression: with(
local!startIndex: fv!item * local!batchSize + 1,
local!endIndex: min(
{
local!startIndex + local!batchSize - 1,
length(local!data)
}
),
/* build the batch */
a!forEach(
items: enumerate(local!endIndex - local!startIndex + 1),
expression: index(local!data, local!startIndex + fv!item, {})
)
)
)
)

The following code turns a list of things into a list of lists of things.

if(
  or(
    a!isNullOrEmpty(ri!items),
    a!isNullOrEmpty(ri!segmentSize)
  ),
  ri!items,
  a!localVariables(
    local!numSegments: ceiling(count(ri!items) / ri!segmentSize),
    if(
      ri!rotate,
      /* WITH ROTATION: segmentSize means the number of segments */
      if(
        ri!enablePadding,
        /* WITH PADDING: Adds type casted NULL values to the last segment to fill up to the size of the segment */
        a!forEach(
          items: enumerate(ri!segmentSize),
          expression: index(
            ri!items,
            1 /* First item in list is at index 1 and enumerate creates numbers starting at 0 */
            + fv!item /* Start number for current segment */
            /* Fix segment size */
            + enumerate(local!numSegments)
            * ri!segmentSize,
            cast(runtimetypeof(ri!items[1]), null)
          )
        ),
        /* WITHOUT PADDING: Only add left over items into the last segment. The last segment might contain less items */
        a!forEach(
          items: enumerate(ri!segmentSize),
          expression: reject(
            a!isNullOrEmpty(_),
            index(
              ri!items,
              1 /* First item in list is at index 1 and enumerate creates numbers starting at 0 */
              + fv!item /* Start number for current segment */
              /* Adjust the size of the segment to either the required size or for the last segment the left over items */
              + enumerate(local!numSegments)
              * ri!segmentSize,
              null
            )
          )
        )
      ),
      /* WITHOUT ROTATION: segmentSize means the number of items per segment */
      if(
        ri!enablePadding,
        /* WITH PADDING: Adds type casted NULL values to the last segment to fill up to the size of the segment */
        a!forEach(
          items: enumerate(local!numSegments),
          expression: index(
            ri!items,
            1 /* First item in list is at index 1 and enumerate creates numbers starting at 0 */
            + (fv!item * ri!segmentSize) /* Start number for current segment */
            /* Fixe segment size */
            + enumerate(ri!segmentSize),
            cast(runtimetypeof(ri!items[1]), null)
          )
        ),
        /* WITHOUT PADDING: Only add left over items into the last segment. The last segment might contain less items */
        a!forEach(
          items: enumerate(local!numSegments),
          expression: index(
            ri!items,
            1 /* First item in list is at index 1 and enumerate creates numbers starting at 0 */
            + (fv!item * ri!segmentSize) /* Start number for current segment */
            /* Adjust the size of the segment to either the required size or for the last segment the left over items */
            + enumerate(min(ri!segmentSize, count(ri!items) - (fv!item * ri!segmentSize))),
            null
          )
        )
      )
    )
  )
)

You can batch a List of Text String (or any list) using a reliable slicing pattern with index().
Range slicing inside a!forEach() often returns only the last item, so this approach avoids that issue.

you can refer this code

a!localVariables(
local!items: local!agreementDocIds,
local!batchSize: 50,

/* total number of batches */
local!numBatches: ceiling(count(local!items) / local!batchSize),

/* list of lists */
a!forEach(
items: enumerate(local!numBatches),
expression: index(
local!items,
1 + (fv!item * local!batchSize),
min((fv!item + 1) * local!batchSize, count(local!items))
)
)
)