Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

fix(agent): render and constrain generated PDF content (#20604)

Sbaaoui Idrissa25976b5fd9d
diff --git a/internal/agent/component/io/pdf_writer.go b/internal/agent/component/io/pdf_writer.go
index f5dc750fca..2c090111f4 100644
--- a/internal/agent/component/io/pdf_writer.go
+++ b/internal/agent/component/io/pdf_writer.go
@@ -32,6 +32,9 @@ import (
"unicode"
"github.com/signintech/gopdf"
+ "github.com/yuin/goldmark"
+ "github.com/yuin/goldmark/ast"
+ gmtext "github.com/yuin/goldmark/text"
)
// PDFOptions is the public contract for the PDF writer.
@@ -72,6 +75,14 @@ type pdfFontSet struct {
hasCJK bool
}
+type pdfBlock struct {
+ text string
+ fontSize int
+ indent float64
+ spaceBefore float64
+ spaceAfter float64
+}
+
// WritePDF renders the content to a PDF byte stream.
func WritePDF(content string, opts PDFOptions) ([]byte, error) {
if opts.FontSize <= 0 {
@@ -87,53 +98,153 @@ func WritePDF(content string, opts PDFOptions) ([]byte, error) {
return nil, err
}
- drawHeader(pdf, fonts, opts)
-
bodyX := 36.0
- bodyY := 72.0
- lineHeight := float64(opts.FontSize) * 1.5
+ baseLineHeight := float64(opts.FontSize) * 1.5
+ bodyTop := max(72.0, 36+baseLineHeight)
+ bodyBottom := 760.0
+ if bodyTop+baseLineHeight > bodyBottom {
+ return nil, fmt.Errorf("PDF: font size %d leaves no usable body area", opts.FontSize)
+ }
+ if err := drawHeader(pdf, fonts, opts); err != nil {
+ return nil, err
+ }
+ bodyY := bodyTop
+ bodyWidth := gopdf.PageSizeA4.W - 2*bodyX
pdf.SetX(bodyX)
pdf.SetY(bodyY)
pageNumber := 1
- closePage := func() {
- drawWatermark(pdf, fonts, opts)
- drawFooter(pdf, fonts, opts, pageNumber)
- }
-
- for _, line := range splitLines(content) {
- if line == "" {
- bodyY += lineHeight
- if bodyY > 760 {
- closePage()
- pdf.AddPage()
- drawHeader(pdf, fonts, opts)
- bodyY = 72.0
- pageNumber++
- }
- pdf.SetX(bodyX)
- pdf.SetY(bodyY)
- continue
+ closePage := func() error {
+ if err := drawWatermark(pdf, fonts, opts); err != nil {
+ return err
+ }
+ return drawFooter(pdf, fonts, opts, pageNumber)
+ }
+ newPage := func() error {
+ if err := closePage(); err != nil {
+ return err
+ }
+ pdf.AddPage()
+ if err := drawHeader(pdf, fonts, opts); err != nil {
+ return err
+ }
+ bodyY = bodyTop
+ pageNumber++
+ return nil
+ }
+
+ for _, block := range markdownPDFBlocks(content, opts.FontSize) {
+ lineHeight := float64(block.fontSize) * 1.5
+ if bodyTop+lineHeight > bodyBottom {
+ return nil, fmt.Errorf("PDF: font size %d leaves no usable body area", block.fontSize)
}
- if bodyY > 760 {
- closePage()
- pdf.AddPage()
- drawHeader(pdf, fonts, opts)
- bodyY = 72.0
- pageNumber++
+ if bodyY > bodyTop {
+ bodyY += block.spaceBefore
}
- pdf.SetX(bodyX)
- pdf.SetY(bodyY)
- if err := drawPDFText(pdf, fonts, line, opts.FontSize); err != nil {
- return nil, fmt.Errorf("PDF: body text: %w", err)
+ for _, line := range splitLines(block.text) {
+ if line == "" {
+ bodyY += lineHeight
+ continue
+ }
+ width := bodyWidth - block.indent
+ wrapped, err := wrapPDFText(pdf, fonts, line, block.fontSize, width)
+ if err != nil {
+ return nil, fmt.Errorf("PDF: wrap body text: %w", err)
+ }
+ for _, visualLine := range wrapped {
+ if bodyY > bodyTop && bodyY+lineHeight > bodyBottom {
+ if err := newPage(); err != nil {
+ return nil, err
+ }
+ }
+ pdf.SetX(bodyX + block.indent)
+ pdf.SetY(bodyY)
+ if err := drawPDFText(pdf, fonts, visualLine, block.fontSize); err != nil {
+ return nil, fmt.Errorf("PDF: body text: %w", err)
+ }
+ bodyY += lineHeight
+ }
}
- bodyY += lineHeight
+ bodyY += block.spaceAfter
}
- closePage()
+ if err := closePage(); err != nil {
+ return nil, err
+ }
return writePDFToBytes(pdf)
}
+func markdownPDFBlocks(content string, baseSize int) []pdfBlock {
+ source := []byte(content)
+ document := goldmark.DefaultParser().Parse(gmtext.NewReader(source))
+ blocks := make([]pdfBlock, 0, document.ChildCount())
+ for node := document.FirstChild(); node != nil; node = node.NextSibling() {
+ switch n := node.(type) {
+ case *ast.Heading:
+ sizes := [...]int{8, 6, 4, 2, 1, 0}
+ blocks = append(blocks, pdfBlock{
+ text: inlinePDFText(n, source), fontSize: baseSize + sizes[n.Level-1],
+ spaceBefore: float64(baseSize) * 0.6, spaceAfter: float64(baseSize) * 0.5,
+ })
+ case *ast.Paragraph:
+ blocks = append(blocks, pdfBlock{text: inlinePDFText(n, source), fontSize: baseSize, spaceAfter: float64(baseSize)})
+ case *ast.List:
+ index := n.Start
+ for item := n.FirstChild(); item != nil; item = item.NextSibling() {
+ prefix := "• "
+ if n.IsOrdered() {
+ prefix = fmt.Sprintf("%d. ", index)
+ index++
+ }
+ blocks = append(blocks, pdfBlock{text: prefix + inlinePDFText(item, source), fontSize: baseSize, indent: 12, spaceAfter: float64(baseSize) * 0.35})
+ }
+ case *ast.Blockquote:
+ blocks = append(blocks, pdfBlock{text: "| " + inlinePDFText(n, source), fontSize: baseSize, indent: 12, spaceAfter: float64(baseSize)})
+ case *ast.CodeBlock:
+ blocks = append(blocks, pdfBlock{text: rawPDFBlockText(n, source), fontSize: baseSize, indent: 12, spaceAfter: float64(baseSize)})
+ case *ast.FencedCodeBlock:
+ blocks = append(blocks, pdfBlock{text: rawPDFBlockText(n, source), fontSize: baseSize, indent: 12, spaceAfter: float64(baseSize)})
+ case *ast.ThematicBreak:
+ blocks = append(blocks, pdfBlock{fontSize: baseSize, spaceAfter: float64(baseSize)})
+ default:
+ if text := inlinePDFText(n, source); text != "" {
+ blocks = append(blocks, pdfBlock{text: text, fontSize: baseSize, spaceAfter: float64(baseSize)})
+ }
+ }
+ }
+ return blocks
+}
+
+func inlinePDFText(node ast.Node, source []byte) string {
+ var text strings.Builder
+ _ = ast.Walk(node, func(node ast.Node, entering bool) (ast.WalkStatus, error) {
+ if !entering {
+ return ast.WalkContinue, nil
+ }
+ switch n := node.(type) {
+ case *ast.Text:
+ text.Write(n.Text(source))
+ if n.SoftLineBreak() || n.HardLineBreak() {
+ text.WriteByte('\n')
+ }
+ case *ast.String:
+ text.Write(n.Text(source))
+ }
+ return ast.WalkContinue, nil
+ })
+ return strings.TrimSpace(text.String())
+}
+
+func rawPDFBlockText(node ast.Node, source []byte) string {
+ var text strings.Builder
+ lines := node.Lines()
+ for i := 0; i < lines.Len(); i++ {
+ line := lines.At(i)
+ text.Write(line.Value(source))
+ }
+ return strings.TrimRight(text.String(), "\r\n")
+}
+
func ensurePDFFonts(pdf *gopdf.GoPdf, size int) (pdfFontSet, error) {
latinPath := resolvePDFLatinFontPath()
if latinPath == "" {
@@ -207,23 +318,18 @@ func normalizeExistingFontPath(candidate string) string {
return ""
}
-func drawHeader(pdf *gopdf.GoPdf, fonts pdfFontSet, opts PDFOptions) {
+func drawHeader(pdf *gopdf.GoPdf, fonts pdfFontSet, opts PDFOptions) error {
if opts.HeaderText == "" {
- return
+ return nil
}
- size := overlayFontSize(opts)
- pdf.SetX(36)
- pdf.SetY(24)
- _ = drawPDFText(pdf, fonts, opts.HeaderText, size)
+ return drawPDFTextFitted(pdf, fonts, opts.HeaderText, min(overlayFontSize(opts), 20), 36, 24, gopdf.PageSizeA4.W-72)
}
-func drawFooter(pdf *gopdf.GoPdf, fonts pdfFontSet, opts PDFOptions, pageNumber int) {
+func drawFooter(pdf *gopdf.GoPdf, fonts pdfFontSet, opts PDFOptions, pageNumber int) error {
if opts.FooterText == "" && !opts.AddTimestamp && !opts.AddPageNumbers {
- return
+ return nil
}
size := overlayFontSize(opts)
- pdf.SetX(36)
- pdf.SetY(800)
parts := []string{}
if opts.FooterText != "" {
parts = append(parts, opts.FooterText)
@@ -234,18 +340,17 @@ func drawFooter(pdf *gopdf.GoPdf, fonts pdfFontSet, opts PDFOptions, pageNumber
if opts.AddPageNumbers {
parts = append(parts, fmt.Sprintf("Pages %d", pageNumber))
}
- _ = drawPDFText(pdf, fonts, strings.Join(parts, " | "), size)
+ return drawPDFTextFitted(pdf, fonts, strings.Join(parts, " | "), min(size, 42), 36, 800, gopdf.PageSizeA4.W-72)
}
-func drawWatermark(pdf *gopdf.GoPdf, fonts pdfFontSet, opts PDFOptions) {
+func drawWatermark(pdf *gopdf.GoPdf, fonts pdfFontSet, opts PDFOptions) error {
if opts.WatermarkText == "" {
- return
+ return nil
}
pdf.SetTextColor(200, 200, 200)
- pdf.SetX(120)
- pdf.SetY(360)
- _ = drawPDFText(pdf, fonts, opts.WatermarkText, 48)
+ err := drawPDFTextFitted(pdf, fonts, opts.WatermarkText, 48, 120, 360, gopdf.PageSizeA4.W-156)
pdf.SetTextColor(0, 0, 0)
+ return err
}
func overlayFontSize(opts PDFOptions) int {
@@ -275,6 +380,89 @@ func drawPDFText(pdf *gopdf.GoPdf, fonts pdfFontSet, text string, size int) erro
return nil
}
+func drawPDFTextFitted(pdf *gopdf.GoPdf, fonts pdfFontSet, text string, size int, x, y, width float64) error {
+ for ; size > 0; size-- {
+ measured := 0.0
+ for _, segment := range splitByPDFFont(text) {
+ family := fonts.latinFamily
+ if segment.cjk && fonts.hasCJK {
+ family = fonts.cjkFamily
+ }
+ if err := pdf.SetFont(family, "", size); err != nil {
+ return err
+ }
+ segmentWidth, err := pdf.MeasureTextWidth(segment.text)
+ if err != nil {
+ return err
+ }
+ measured += segmentWidth
+ }
+ if measured <= width {
+ pdf.SetX(x)
+ pdf.SetY(y)
+ return drawPDFText(pdf, fonts, text, size)
+ }
+ }
+ return fmt.Errorf("PDF: decoration text is too long for the page")
+}
+
+func wrapPDFText(pdf *gopdf.GoPdf, fonts pdfFontSet, text string, size int, width float64) ([]string, error) {
+ lines := []string{}
+ current := ""
+ currentWidth := 0.0
+ for _, segment := range splitByPDFFont(text) {
+ family := fonts.latinFamily
+ if segment.cjk && fonts.hasCJK {
+ family = fonts.cjkFamily
+ }
+ if err := pdf.SetFont(family, "", size); err != nil {
+ return nil, err
+ }
+ segmentWidth, err := pdf.MeasureTextWidth(segment.text)
+ if err != nil {
+ return nil, err
+ }
+ if currentWidth+segmentWidth <= width {
+ current += segment.text
+ currentWidth += segmentWidth
+ continue
+ }
+ if current != "" {
+ lines = append(lines, current)
+ current = ""
+ currentWidth = 0
+ }
+ if segmentWidth <= width {
+ current = segment.text
+ currentWidth = segmentWidth
+ continue
+ }
+ for _, r := range segment.text {
+ runeWidth, err := pdf.MeasureTextWidth(string(r))
+ if err != nil {
+ return nil, err
+ }
+ if runeWidth > width {
+ return nil, fmt.Errorf("font size %d is too large for the PDF body width", size)
+ }
+ }
+ wrapped, err := pdf.SplitTextWithWordWrap(segment.text, width)
+ if err != nil {
+ return nil, err
+ }
+ lines = append(lines, wrapped[:len(wrapped)-1]...)
+ current = wrapped[len(wrapped)-1]
+ currentWidth, err = pdf.MeasureTextWidth(current)
+ if err != nil {
+ return nil, err
+ }
+ }
+ if current != "" {
+ lines = append(lines, current)
+ }
+ return lines, nil
+}
+
type pdfTextSegment struct {
text string
cjk bool
diff --git a/internal/agent/component/io/pdf_writer_test.go b/internal/agent/component/io/pdf_writer_test.go
index 7ae221e646..c171a437cb 100644
--- a/internal/agent/component/io/pdf_writer_test.go
+++ b/internal/agent/component/io/pdf_writer_test.go
@@ -18,11 +18,13 @@ package io
import (
"bytes"
+ "encoding/xml"
"image"
_ "image/png"
"os"
"os/exec"
"path/filepath"
+ "strings"
"testing"
)
@@ -98,6 +100,238 @@ func TestWritePDF_RendersVisibleText(t *testing.T) {
}
}
+func TestWritePDF_WrapsAndPaginatesWithinMargins(t *testing.T) {
+ requirePDFLatinFont(t)
+ if _, err := exec.LookPath("pdftotext"); err != nil {
+ t.Skip("pdftotext not available")
+ }
+
+ content := "First marker.\n\nSecond marker. " +
+ strings.Repeat("This paragraph must wrap inside the page margins. ", 8) + "\n" +
+ strings.Repeat("Mixed English and 中文内容 must use measured fallback glyph widths. ", 8) + "\n" +
+ strings.Repeat("UNBROKEN", 80) + "\n" +
+ strings.Repeat("A final line forces pagination while preserving every word.\n", 80)
+ out, err := WritePDF(content, PDFOptions{})
+ if err != nil {
+ t.Fatalf("WritePDF: %v", err)
+ }
+
+ pdfPath := filepath.Join(t.TempDir(), "wrapped.pdf")
+ if err := os.WriteFile(pdfPath, out, 0o600); err != nil {
+ t.Fatalf("WriteFile pdf: %v", err)
+ }
+ bbox, err := exec.Command("pdftotext", "-bbox-layout", pdfPath, "-").CombinedOutput()
+ if err != nil {
+ t.Fatalf("pdftotext: %v: %s", err, bbox)
+ }
+
+ var document struct {
+ Pages []struct {
+ Width float64 `xml:"width,attr"`
+ Height float64 `xml:"height,attr"`
+ Words []struct {
+ Text string `xml:",chardata"`
+ XMax float64 `xml:"xMax,attr"`
+ YMin float64 `xml:"yMin,attr"`
+ YMax float64 `xml:"yMax,attr"`
+ } `xml:"flow>block>line>word"`
+ } `xml:"body>doc>page"`
+ }
+ if err := xml.Unmarshal(bbox, &document); err != nil {
+ t.Fatalf("parse bbox output: %v", err)
+ }
+ if len(document.Pages) < 2 {
+ t.Fatalf("pages = %d, want at least 2", len(document.Pages))
+ }
+ extracted, err := exec.Command("pdftotext", pdfPath, "-").CombinedOutput()
+ if err != nil {
+ t.Fatalf("pdftotext text: %v: %s", err, extracted)
+ }
+ for _, marker := range []string{"First marker.", "Second marker.", "Mixed English and", "中文内容", "UNBROKEN"} {
+ if !bytes.Contains(extracted, []byte(marker)) {
+ t.Fatalf("extracted PDF text missing %q", marker)
+ }
+ }
+ compact := strings.Join(strings.Fields(string(extracted)), "")
+ if got := strings.Count(compact, "UNBROKEN"); got != 80 {
+ t.Fatalf("unbroken token count = %d, want 80", got)
+ }
+ if got := strings.Count(string(extracted), "A final line forces pagination while preserving every word."); got != 80 {
+ t.Fatalf("final line count = %d, want 80", got)
+ }
+
+ var firstY, secondY float64
+ for _, page := range document.Pages {
+ for _, word := range page.Words {
+ if word.XMax > page.Width-36 || word.YMin < 0 || word.YMax > page.Height {
+ t.Fatalf("word %q bounds exceed page: xMax=%.2f y=%.2f..%.2f page=%.2fx%.2f", word.Text, word.XMax, word.YMin, word.YMax, page.Width, page.Height)
+ }
+ switch word.Text {
+ case "First":
+ firstY = word.YMin
+ case "Second":
+ secondY = word.YMin
+ }
+ }
+ }
+ if firstY == 0 || secondY-firstY < 30 {
+ t.Fatalf("blank line not preserved: first y=%.2f second y=%.2f", firstY, secondY)
+ }
+}
+
+func TestWritePDF_LargeFontStartsInsidePage(t *testing.T) {
+ requirePDFLatinFont(t)
+ if _, err := exec.LookPath("pdftotext"); err != nil {
+ t.Skip("pdftotext not available")
+ }
+
+ out, err := WritePDF("BodyMarker 中文 Ẫ", PDFOptions{
+ FontSize: 48,
+ HeaderText: "HeaderMarker 标题 Ẫ",
+ FooterText: "Large footer",
+ AddPageNumbers: true,
+ })
+ if err != nil {
+ t.Fatalf("WritePDF: %v", err)
+ }
+ pdfPath := filepath.Join(t.TempDir(), "large-font.pdf")
+ if err := os.WriteFile(pdfPath, out, 0o600); err != nil {
+ t.Fatalf("WriteFile pdf: %v", err)
+ }
+ bbox, err := exec.Command("pdftotext", "-bbox-layout", pdfPath, "-").CombinedOutput()
+ if err != nil {
+ t.Fatalf("pdftotext: %v: %s", err, bbox)
+ }
+ var document struct {
+ Pages []struct {
+ Height float64 `xml:"height,attr"`
+ Words []struct {
+ Text string `xml:",chardata"`
+ YMin float64 `xml:"yMin,attr"`
+ YMax float64 `xml:"yMax,attr"`
+ } `xml:"flow>block>line>word"`
+ } `xml:"body>doc>page"`
+ }
+ if err := xml.Unmarshal(bbox, &document); err != nil {
+ t.Fatalf("parse bbox output: %v", err)
+ }
+ if len(document.Pages) != 1 || len(document.Pages[0].Words) == 0 {
+ t.Fatalf("unexpected bbox output: %+v", document)
+ }
+ headerBottom := 0.0
+ bodyTop := document.Pages[0].Height
+ for _, word := range document.Pages[0].Words {
+ if word.YMin < 0 || word.YMax > document.Pages[0].Height {
+ t.Fatalf("word vertical bounds %.2f..%.2f exceed page height %.2f", word.YMin, word.YMax, document.Pages[0].Height)
+ }
+ switch word.Text {
+ case "HeaderMarker":
+ headerBottom = max(headerBottom, word.YMax)
+ case "BodyMarker":
+ bodyTop = min(bodyTop, word.YMin)
+ }
+ }
+ if bodyTop <= headerBottom {
+ t.Fatalf("body starts at %.2f before header ends at %.2f", bodyTop, headerBottom)
+ }
+}
+
+func TestWritePDF_LongDecorationsFitPage(t *testing.T) {
+ requirePDFLatinFont(t)
+ if _, err := exec.LookPath("pdftotext"); err != nil {
+ t.Skip("pdftotext not available")
+ }
+
+ longText := strings.Repeat("Long decoration text ", 12)
+ out, err := WritePDF("Body", PDFOptions{
+ HeaderText: longText,
+ FooterText: longText,
+ WatermarkText: longText,
+ })
+ if err != nil {
+ t.Fatalf("WritePDF: %v", err)
+ }
+ pdfPath := filepath.Join(t.TempDir(), "decorations.pdf")
+ if err := os.WriteFile(pdfPath, out, 0o600); err != nil {
+ t.Fatalf("WriteFile pdf: %v", err)
+ }
+ bbox, err := exec.Command("pdftotext", "-bbox-layout", pdfPath, "-").CombinedOutput()
+ if err != nil {
+ t.Fatalf("pdftotext: %v: %s", err, bbox)
+ }
+ var document struct {
+ Pages []struct {
+ Width float64 `xml:"width,attr"`
+ Words []struct {
+ Text string `xml:",chardata"`
+ XMax float64 `xml:"xMax,attr"`
+ } `xml:"flow>block>line>word"`
+ } `xml:"body>doc>page"`
+ }
+ if err := xml.Unmarshal(bbox, &document); err != nil {
+ t.Fatalf("parse bbox output: %v", err)
+ }
+ for _, page := range document.Pages {
+ for _, word := range page.Words {
+ if word.XMax > page.Width-36 {
+ t.Fatalf("word %q ends at %.2f, beyond right margin %.2f", word.Text, word.XMax, page.Width-36)
+ }
+ }
+ }
+}
+
+func TestWritePDF_RejectsFontTooLargeForBody(t *testing.T) {
+ requirePDFLatinFont(t)
+ _, err := WritePDF("Body", PDFOptions{FontSize: 1_000_000_000, HeaderText: "Header"})
+ if err == nil || !strings.Contains(err.Error(), "leaves no usable body area") {
+ t.Fatalf("WritePDF error = %v, want unusable body area", err)
+ }
+}
+
+func TestWritePDF_RendersMarkdownHeadings(t *testing.T) {
+ requirePDFLatinFont(t)
+ if _, err := exec.LookPath("pdftotext"); err != nil {
+ t.Skip("pdftotext not available")
+ }
+
+ out, err := WritePDF("# TitleMarker\n\n## SectionMarker\n\nBodyMarker paragraph.", PDFOptions{FontSize: 12})
+ if err != nil {
+ t.Fatalf("WritePDF: %v", err)
+ }
+ pdfPath := filepath.Join(t.TempDir(), "markdown.pdf")
+ if err := os.WriteFile(pdfPath, out, 0o600); err != nil {
+ t.Fatalf("WriteFile pdf: %v", err)
+ }
+ bbox, err := exec.Command("pdftotext", "-bbox-layout", pdfPath, "-").CombinedOutput()
+ if err != nil {
+ t.Fatalf("pdftotext: %v: %s", err, bbox)
+ }
+ var document struct {
+ Pages []struct {
+ Words []struct {
+ Text string `xml:",chardata"`
+ YMin float64 `xml:"yMin,attr"`
+ YMax float64 `xml:"yMax,attr"`
+ } `xml:"flow>block>line>word"`
+ } `xml:"body>doc>page"`
+ }
+ if err := xml.Unmarshal(bbox, &document); err != nil {
+ t.Fatalf("parse bbox output: %v", err)
+ }
+ heights := map[string]float64{}
+ for _, page := range document.Pages {
+ for _, word := range page.Words {
+ if word.Text == "#" || word.Text == "##" {
+ t.Fatalf("rendered literal Markdown marker %q", word.Text)
+ }
+ heights[word.Text] = word.YMax - word.YMin
+ }
+ }
+ if heights["TitleMarker"] <= heights["BodyMarker"] || heights["SectionMarker"] <= heights["BodyMarker"] {
+ t.Fatalf("heading heights = title %.2f section %.2f body %.2f", heights["TitleMarker"], heights["SectionMarker"], heights["BodyMarker"])
+ }
+}
+
func TestResolvePDFLatinFontPathHonorsEnv(t *testing.T) {
dir := t.TempDir()
fontPath := filepath.Join(dir, "custom.ttf")
diff --git a/web/src/pages/agent/form/doc-generator-form/index.tsx b/web/src/pages/agent/form/doc-generator-form/index.tsx
index fa8b45759f..c9e975bfc4 100644
--- a/web/src/pages/agent/form/doc-generator-form/index.tsx
+++ b/web/src/pages/agent/form/doc-generator-form/index.tsx
@@ -6,7 +6,7 @@ import { SelectWithSearch } from '@/components/originui/select-with-search';
import { SwitchFormField } from '@/components/switch-form-field';
import { zodResolver } from '@hookform/resolvers/zod';
import i18n from '@/locales/config';
-import { memo, useMemo } from 'react';
+import { type ComponentProps, memo, useCallback, useMemo } from 'react';
import { useForm } from 'react-hook-form';
import { useTranslation } from 'react-i18next';
import { z } from 'zod';
@@ -31,7 +31,8 @@ const FormSchema = z.object({
watermark_text: z.string().optional(),
add_page_numbers: z.boolean(),
add_timestamp: z.boolean(),
- font_size: z.coerce.number().min(12, i18n.t('flow.fontSizeMin')),
+ include_download_info_in_content: z.boolean(),
+ font_size: z.coerce.number().int().min(12, i18n.t('flow.fontSizeMin')),
outputs: z.object({
doc_id: z.object({ type: z.string() }),
filename: z.object({ type: z.string() }),
@@ -60,6 +61,18 @@ function DocGeneratorForm({ node }: INextOperatorForm) {
return transferOutputs(values.outputs);
}, [values.outputs]);
+ const handleFontSizeChange: NonNullable<
+ ComponentProps<typeof NumberInput>['onChange']
+ > = useCallback(
+ (value) => {
+ form.setValue('font_size', Math.trunc(Number(value)), {
+ shouldDirty: true,
+ shouldValidate: true,
+ });
+ },
+ [form],
+ );
+
useWatchFormChange(node?.id, form);
return (
@@ -86,7 +99,14 @@ function DocGeneratorForm({ node }: INextOperatorForm) {
{supportsDocumentDecorations && (
<>
<RAGFlowFormItem label={t('flow.fontSize')} name="font_size">
- {(field) => <NumberInput min={12} {...field}></NumberInput>}
+ {(field) => (
+ <NumberInput
+ min={12}
+ step={1}
+ {...field}
+ onChange={handleFontSizeChange}
+ ></NumberInput>
+ )}
</RAGFlowFormItem>
<RAGFlowFormItem label={t('flow.headerText')} name="header_text">