fix(feishu): chunk large documents for write/append to avoid API 400 errors by lml2468 · Pull Request #14402 · openclaw/openclaw

lml2468 · 2026-02-12T02:25:38Z

Problem

When writing long documents via feishu_doc tool (action: "write" or action: "append"), the Feishu API returns HTTP 400 errors because:

documentBlockChildren.create is limited to 50 blocks per request
document.convert has content size limits for large markdown input

This makes it impossible to write comprehensive reports or long-form content to Feishu docs in a single operation — users must manually split content and call append multiple times.

Solution

Added three helper functions to extensions/feishu/src/docx.ts:

splitMarkdownByHeadings() — Splits markdown at #/## headings into smaller chunks
chunkedConvertMarkdown() — Converts each chunk independently via the convert API, combining all blocks
chunkedInsertBlocks() — Batches blocks into groups of ≤50 for the insert API

Updated writeDoc and appendDoc to use the chunked helpers. Small documents work exactly as before (single chunk, single batch).

Image processing correctly receives all inserted blocks across batches.

Testing

AI-assisted (Claude Code)
Lightly tested — verified with real Feishu documents that previously failed with 400 errors
Understand what the code does

Changes

extensions/feishu/src/docx.ts: +61/-4 lines

Greptile Overview

Greptile Summary

This PR updates the Feishu feishu_doc write/append implementation to handle large inputs by:

splitting markdown into heading-based chunks before calling docx.document.convert, and
inserting converted blocks in batches of 50 to comply with documentBlockChildren.create limits.

The batching approach fits into the existing convertMarkdown → insertBlocks flow in extensions/feishu/src/docx.ts, with writeDoc/appendDoc now delegating to chunked helpers and passing the aggregated inserted blocks to processImages.

Confidence Score: 3/5

This PR is mergeable after addressing a markdown-splitting edge case that can corrupt output for some inputs.
The core change (batching inserts to ≤50 blocks) is straightforward, but the heading-based markdown splitter is not fence-aware and can change conversion output for long markdown containing fenced code blocks with #/## lines.
extensions/feishu/src/docx.ts

_{(2/5) Greptile learns from your feedback when you react with thumbs up/down!}

greptile-apps

_{1 file reviewed, 1 comment}

_{Edit Code Review Agent Settings | Greptile}

greptile-apps · 2026-02-12T02:34:13Z

extensions/feishu/src/docx.ts

+function splitMarkdownByHeadings(markdown: string): string[] {
+  const lines = markdown.split("\n");
+  const chunks: string[] = [];


Splits inside code fences

splitMarkdownByHeadings() splits on any line matching ^#{1,2}\s, without tracking fenced code blocks. If a long markdown contains a fenced code block with lines starting with # / ## (common in shell scripts or embedded markdown examples), this will split inside the fence; chunkedConvertMarkdown() then calls document.convert on partial/unterminated fences, which can change or corrupt the resulting blocks compared to converting the full markdown in one call.

Also affects: extensions/feishu/src/docx.ts:143-152.

Prompt To Fix With AI

This is a comment left during a code review. Path: extensions/feishu/src/docx.ts Line: 124:126 Comment: **Splits inside code fences** `splitMarkdownByHeadings()` splits on any line matching `^#{1,2}\s`, without tracking fenced code blocks. If a long markdown contains a fenced code block with lines starting with `# ` / `## ` (common in shell scripts or embedded markdown examples), this will split *inside* the fence; `chunkedConvertMarkdown()` then calls `document.convert` on partial/unterminated fences, which can change or corrupt the resulting blocks compared to converting the full markdown in one call. Also affects: extensions/feishu/src/docx.ts:143-152. How can I resolve this? If you propose a fix, please make it concise.

Fixed in afc7e54 — splitMarkdownByHeadings() now tracks fenced code blocks and skips heading detection when inside one. Thanks for catching this!

openclaw-barnacle · 2026-02-22T04:21:05Z

This pull request has been automatically marked as stale due to inactivity.
Please add updates or it will be closed.

Takhoffman · 2026-02-28T04:20:57Z

Strong +1 on the problem statement, but this implementation needs rework before merge.

Blocking concerns:

splitMarkdownByHeadings is not a reliable size guard. A single large section (or content without #/##) can still exceed document.convert limits and fail with the same 400.
No targeted tests were added for chunking semantics (no-heading input, very long single section, fenced code edge cases, chunk boundary behavior).

Suggested path:

Add a deterministic fallback splitter by size/token budget when heading-based splitting does not reduce chunk size enough.
Add tests in extensions/feishu/src/docx.test.ts that prove convert-limit resilience and preserve block/image ordering across chunk boundaries.
Keep insert batching (<=50) because that part is directionally correct and low risk.

Happy to re-review once those are in.

…errors The Feishu API limits documentBlockChildren.create to 50 blocks per request and document.convert has content size limits for large markdown. Previously, writeDoc and appendDoc would send the entire content in a single API call, causing HTTP 400 errors for long documents. This commit adds: - splitMarkdownByHeadings(): splits markdown at # or ## headings - chunkedConvertMarkdown(): converts each chunk independently - chunkedInsertBlocks(): batches blocks into groups of ≤50 Both writeDoc and appendDoc now use the chunked helpers while preserving backward compatibility for small documents. Image processing correctly receives all inserted blocks across batches.

Addresses review feedback: splitMarkdownByHeadings() now tracks fenced code blocks (``` or ~~~) and skips heading-based splitting when inside one, preventing corruption of code block content.

…errors (openclaw#14402) * fix(feishu): chunk large documents for write/append to avoid API 400 errors The Feishu API limits documentBlockChildren.create to 50 blocks per request and document.convert has content size limits for large markdown. Previously, writeDoc and appendDoc would send the entire content in a single API call, causing HTTP 400 errors for long documents. This commit adds: - splitMarkdownByHeadings(): splits markdown at # or ## headings - chunkedConvertMarkdown(): converts each chunk independently - chunkedInsertBlocks(): batches blocks into groups of ≤50 Both writeDoc and appendDoc now use the chunked helpers while preserving backward compatibility for small documents. Image processing correctly receives all inserted blocks across batches. * fix(feishu): skip heading detection inside fenced code blocks Addresses review feedback: splitMarkdownByHeadings() now tracks fenced code blocks (``` or ~~~) and skips heading-based splitting when inside one, preventing corruption of code block content. * Feishu/Docx: add convert fallback chunking + tests --------- Co-authored-by: lml2468 <lml2468@users.noreply.github.com> Co-authored-by: Tak Hoffman <781889+Takhoffman@users.noreply.github.com>

…errors (openclaw#14402) * fix(feishu): chunk large documents for write/append to avoid API 400 errors The Feishu API limits documentBlockChildren.create to 50 blocks per request and document.convert has content size limits for large markdown. Previously, writeDoc and appendDoc would send the entire content in a single API call, causing HTTP 400 errors for long documents. This commit adds: - splitMarkdownByHeadings(): splits markdown at # or ## headings - chunkedConvertMarkdown(): converts each chunk independently - chunkedInsertBlocks(): batches blocks into groups of ≤50 Both writeDoc and appendDoc now use the chunked helpers while preserving backward compatibility for small documents. Image processing correctly receives all inserted blocks across batches. * fix(feishu): skip heading detection inside fenced code blocks Addresses review feedback: splitMarkdownByHeadings() now tracks fenced code blocks (``` or ~~~) and skips heading-based splitting when inside one, preventing corruption of code block content. * Feishu/Docx: add convert fallback chunking + tests --------- Co-authored-by: lml2468 <lml2468@users.noreply.github.com> Co-authored-by: Tak Hoffman <781889+Takhoffman@users.noreply.github.com> (cherry picked from commit dff8cc3)

…errors (openclaw#14402) * fix(feishu): chunk large documents for write/append to avoid API 400 errors The Feishu API limits documentBlockChildren.create to 50 blocks per request and document.convert has content size limits for large markdown. Previously, writeDoc and appendDoc would send the entire content in a single API call, causing HTTP 400 errors for long documents. This commit adds: - splitMarkdownByHeadings(): splits markdown at # or ## headings - chunkedConvertMarkdown(): converts each chunk independently - chunkedInsertBlocks(): batches blocks into groups of ≤50 Both writeDoc and appendDoc now use the chunked helpers while preserving backward compatibility for small documents. Image processing correctly receives all inserted blocks across batches. * fix(feishu): skip heading detection inside fenced code blocks Addresses review feedback: splitMarkdownByHeadings() now tracks fenced code blocks (``` or ~~~) and skips heading-based splitting when inside one, preventing corruption of code block content. * Feishu/Docx: add convert fallback chunking + tests --------- Co-authored-by: lml2468 <lml2468@users.noreply.github.com> Co-authored-by: Tak Hoffman <781889+Takhoffman@users.noreply.github.com>

…errors (openclaw#14402) * fix(feishu): chunk large documents for write/append to avoid API 400 errors The Feishu API limits documentBlockChildren.create to 50 blocks per request and document.convert has content size limits for large markdown. Previously, writeDoc and appendDoc would send the entire content in a single API call, causing HTTP 400 errors for long documents. This commit adds: - splitMarkdownByHeadings(): splits markdown at # or ## headings - chunkedConvertMarkdown(): converts each chunk independently - chunkedInsertBlocks(): batches blocks into groups of ≤50 Both writeDoc and appendDoc now use the chunked helpers while preserving backward compatibility for small documents. Image processing correctly receives all inserted blocks across batches. * fix(feishu): skip heading detection inside fenced code blocks Addresses review feedback: splitMarkdownByHeadings() now tracks fenced code blocks (``` or ~~~) and skips heading-based splitting when inside one, preventing corruption of code block content. * Feishu/Docx: add convert fallback chunking + tests --------- Co-authored-by: lml2468 <lml2468@users.noreply.github.com> Co-authored-by: Tak Hoffman <781889+Takhoffman@users.noreply.github.com> (cherry picked from commit 4dc55ea) # Conflicts: # CHANGELOG.md # extensions/feishu/src/docx.ts

…errors (openclaw#14402) Cherry-pick of upstream 4dc55ea.

…errors (openclaw#14402) * fix(feishu): chunk large documents for write/append to avoid API 400 errors The Feishu API limits documentBlockChildren.create to 50 blocks per request and document.convert has content size limits for large markdown. Previously, writeDoc and appendDoc would send the entire content in a single API call, causing HTTP 400 errors for long documents. This commit adds: - splitMarkdownByHeadings(): splits markdown at # or ## headings - chunkedConvertMarkdown(): converts each chunk independently - chunkedInsertBlocks(): batches blocks into groups of ≤50 Both writeDoc and appendDoc now use the chunked helpers while preserving backward compatibility for small documents. Image processing correctly receives all inserted blocks across batches. * fix(feishu): skip heading detection inside fenced code blocks Addresses review feedback: splitMarkdownByHeadings() now tracks fenced code blocks (``` or ~~~) and skips heading-based splitting when inside one, preventing corruption of code block content. * Feishu/Docx: add convert fallback chunking + tests --------- Co-authored-by: lml2468 <lml2468@users.noreply.github.com> Co-authored-by: Tak Hoffman <781889+Takhoffman@users.noreply.github.com>

…errors (openclaw#14402) * fix(feishu): chunk large documents for write/append to avoid API 400 errors The Feishu API limits documentBlockChildren.create to 50 blocks per request and document.convert has content size limits for large markdown. Previously, writeDoc and appendDoc would send the entire content in a single API call, causing HTTP 400 errors for long documents. This commit adds: - splitMarkdownByHeadings(): splits markdown at # or ## headings - chunkedConvertMarkdown(): converts each chunk independently - chunkedInsertBlocks(): batches blocks into groups of ≤50 Both writeDoc and appendDoc now use the chunked helpers while preserving backward compatibility for small documents. Image processing correctly receives all inserted blocks across batches. * fix(feishu): skip heading detection inside fenced code blocks Addresses review feedback: splitMarkdownByHeadings() now tracks fenced code blocks (``` or ~~~) and skips heading-based splitting when inside one, preventing corruption of code block content. * Feishu/Docx: add convert fallback chunking + tests --------- Co-authored-by: lml2468 <lml2468@users.noreply.github.com> Co-authored-by: Tak Hoffman <781889+Takhoffman@users.noreply.github.com> (cherry picked from commit 4dc55ea) # Conflicts: # CHANGELOG.md

…errors (openclaw#14402) * fix(feishu): chunk large documents for write/append to avoid API 400 errors The Feishu API limits documentBlockChildren.create to 50 blocks per request and document.convert has content size limits for large markdown. Previously, writeDoc and appendDoc would send the entire content in a single API call, causing HTTP 400 errors for long documents. This commit adds: - splitMarkdownByHeadings(): splits markdown at # or ## headings - chunkedConvertMarkdown(): converts each chunk independently - chunkedInsertBlocks(): batches blocks into groups of ≤50 Both writeDoc and appendDoc now use the chunked helpers while preserving backward compatibility for small documents. Image processing correctly receives all inserted blocks across batches. * fix(feishu): skip heading detection inside fenced code blocks Addresses review feedback: splitMarkdownByHeadings() now tracks fenced code blocks (``` or ~~~) and skips heading-based splitting when inside one, preventing corruption of code block content. * Feishu/Docx: add convert fallback chunking + tests --------- Co-authored-by: lml2468 <lml2468@users.noreply.github.com> Co-authored-by: Tak Hoffman <781889+Takhoffman@users.noreply.github.com>

…errors (openclaw#14402) Cherry-pick of upstream 4dc55ea.

…errors (openclaw#14402) * fix(feishu): chunk large documents for write/append to avoid API 400 errors The Feishu API limits documentBlockChildren.create to 50 blocks per request and document.convert has content size limits for large markdown. Previously, writeDoc and appendDoc would send the entire content in a single API call, causing HTTP 400 errors for long documents. This commit adds: - splitMarkdownByHeadings(): splits markdown at # or ## headings - chunkedConvertMarkdown(): converts each chunk independently - chunkedInsertBlocks(): batches blocks into groups of ≤50 Both writeDoc and appendDoc now use the chunked helpers while preserving backward compatibility for small documents. Image processing correctly receives all inserted blocks across batches. * fix(feishu): skip heading detection inside fenced code blocks Addresses review feedback: splitMarkdownByHeadings() now tracks fenced code blocks (``` or ~~~) and skips heading-based splitting when inside one, preventing corruption of code block content. * Feishu/Docx: add convert fallback chunking + tests --------- Co-authored-by: lml2468 <lml2468@users.noreply.github.com> Co-authored-by: Tak Hoffman <781889+Takhoffman@users.noreply.github.com>

openclaw-barnacle bot added the channel: feishu Channel integration: feishu label Feb 12, 2026

greptile-apps bot reviewed Feb 12, 2026

View reviewed changes

lml2468 force-pushed the fix/feishu-doc-chunked-write branch from afc7e54 to 596b2b7 Compare February 12, 2026 03:53

openclaw-barnacle bot added the size: S label Feb 12, 2026

lml2468 force-pushed the fix/feishu-doc-chunked-write branch 5 times, most recently from 9ded3d5 to 48256a8 Compare February 14, 2026 19:52

thewilloftheshadow force-pushed the main branch from bfc1ccb to f92900f Compare February 15, 2026 18:46

lml2468 force-pushed the fix/feishu-doc-chunked-write branch from 48256a8 to 9b7fb57 Compare February 16, 2026 07:16

openclaw-barnacle bot added stale Marked as stale due to inactivity and removed stale Marked as stale due to inactivity labels Feb 22, 2026

lml2468 and others added 3 commits February 27, 2026 23:06

fix(feishu): skip heading detection inside fenced code blocks

72ec6d8

Addresses review feedback: splitMarkdownByHeadings() now tracks fenced code blocks (``` or ~~~) and skips heading-based splitting when inside one, preventing corruption of code block content.

Feishu/Docx: add convert fallback chunking + tests

2e101fa

Takhoffman force-pushed the fix/feishu-doc-chunked-write branch from 9b7fb57 to 2e101fa Compare February 28, 2026 05:11

Takhoffman merged commit 4dc55ea into openclaw:main Feb 28, 2026
3 checks passed

openclaw-barnacle bot added size: M and removed size: S labels Feb 28, 2026

github-actions bot mentioned this pull request Feb 28, 2026

📡 Upstream Digest — 2026-02-28 06:28 UTC curtismercier/openclaw-mods#143

Open

github-actions bot mentioned this pull request Mar 1, 2026

cherry-pick: upstream docs commits (2026-03-01-0443) hughdidit/DAISy-Agency#141

Closed

6 tasks

gemini-code-assist bot mentioned this pull request Mar 1, 2026

chore(sync): replay rollup fixes on upstream/main MillionthOdin16/openclaw#111

Merged

zooqueen added a commit to hanzoai/bot that referenced this pull request Mar 1, 2026

fix(feishu): chunk large documents for write/append to avoid API 400 …

41d6a59

…errors (openclaw#14402) Cherry-pick of upstream 4dc55ea.

zooqueen added a commit to hanzoai/bot that referenced this pull request Mar 6, 2026

fix(feishu): chunk large documents for write/append to avoid API 400 …

1fdbc67

…errors (openclaw#14402) Cherry-pick of upstream 4dc55ea.

alexey-pelykh mentioned this pull request Mar 10, 2026

Cherry-pick: Feishu adapter — community PRs and fixes remoteclaw/remoteclaw#678

Open

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

fix(feishu): chunk large documents for write/append to avoid API 400 errors#14402

fix(feishu): chunk large documents for write/append to avoid API 400 errors#14402
Takhoffman merged 3 commits intoopenclaw:mainfrom
lml2468:fix/feishu-doc-chunked-write

lml2468 commented Feb 12, 2026 •

edited by greptile-apps bot

Loading

Uh oh!

greptile-apps bot left a comment

Uh oh!

greptile-apps bot Feb 12, 2026

Uh oh!

lml2468 Feb 12, 2026

Uh oh!

openclaw-barnacle bot commented Feb 22, 2026

Uh oh!

Takhoffman commented Feb 28, 2026

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

Uh oh!

Conversation

lml2468 commented Feb 12, 2026 • edited by greptile-apps bot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Problem

Solution

Testing

Changes

Greptile Overview

Greptile Summary

Confidence Score: 3/5

Uh oh!

greptile-apps bot left a comment

Choose a reason for hiding this comment

Uh oh!

greptile-apps bot Feb 12, 2026

Choose a reason for hiding this comment

Uh oh!

lml2468 Feb 12, 2026

Choose a reason for hiding this comment

Uh oh!

openclaw-barnacle bot commented Feb 22, 2026

Uh oh!

Takhoffman commented Feb 28, 2026

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

lml2468 commented Feb 12, 2026 •

edited by greptile-apps bot

Loading