Skip to content

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

feat(parser): honor MinerU formula and table controls (#21109)

Xinliang Zheng713fc2f2b3fa
diff --git a/docs/guides/agent/ingestion_pipeline/configure_parser_component.md b/docs/guides/agent/ingestion_pipeline/configure_parser_component.md
index dd9260ba0f..7205fbf106 100644
--- a/docs/guides/agent/ingestion_pipeline/configure_parser_component.md
+++ b/docs/guides/agent/ingestion_pipeline/configure_parser_component.md
@@ -26,6 +26,39 @@ For PDF files, select one of the following:
![Configure PDF parser method](https://raw.githubusercontent.com/infiniflow/ragflow-docs/main/images/configure_the_parser_component_1.jpg)
+### MinerU formula and table controls
+
+When a MinerU model is selected for PDF, **Formula recognition** and **Table
+recognition** are saved on that Parser component's PDF setup as
+`mineru_formula_enable` and `mineru_table_enable`. Both default to enabled when
+omitted; an explicit `false` requests disabling the corresponding control,
+subject to the API and backend capabilities below.
+
+- **`/file_parse`, pipeline and VLM backends:** RAGFlow forwards both controls
+ as the `formula_enable` and `table_enable` multipart fields.
+- **`/file_parse`, hybrid backends:** Table recognition follows the table
+ control. The formula control applies to **inline formulas only**; MinerU
+ still recognizes block formulas.
+- **V1 upload/job API:** This protocol has no formula/table switches. Omitted
+ or enabled controls keep the existing job request. Disabling either control
+ fails with an explicit error before a file is uploaded or a job is created;
+ use a `/file_parse` server when these controls are required.
+
+For example, the component-scoped PDF configuration below disables formulas
+while retaining table recognition:
+
+```json
+{
+ "pdf": {
+ "parse_method": "<tenant MinerU model ID>",
+ "mineru_formula_enable": false,
+ "mineru_table_enable": true
+ }
+}
+```
+
+### Other file types
+
For image files:
- **OCR** is on by default. **OCR model** starts with **DeepDoc** for local
diff --git a/internal/dao/ingestion_parser_config_migration.go b/internal/dao/ingestion_parser_config_migration.go
index b74c90a76d..0f2b0c97bc 100644
--- a/internal/dao/ingestion_parser_config_migration.go
+++ b/internal/dao/ingestion_parser_config_migration.go
@@ -184,6 +184,8 @@ var (
"layout_recognize",
"mineru_parse_method",
"mineru_lang",
+ "mineru_formula_enable",
+ "mineru_table_enable",
"pages",
"table_result_type",
"markdown_image_response_type",
@@ -220,9 +222,6 @@ var ingestionRetiredFlatKeys = []string{
// Video parsing is rejected at dispatch
// (internal/ingestion/component/media_dispatch.go:maybeDispatchVideo).
"video_prompt",
- // These MinerU toggles have no Go reader; method and language are migrated.
- "mineru_formula_enable",
- "mineru_table_enable",
}
// ingestionOwnedFlatKeys is every flat key this step consumes or retires. A row
@@ -498,6 +497,19 @@ func convertIngestionParser(config map[string]any, target builtinIngestionTarget
}
}
}
+ for _, key := range []string{"mineru_formula_enable", "mineru_table_enable"} {
+ if raw, exists := config[key]; exists && raw != nil {
+ if !target.hasFamily("pdf") {
+ row.retire(key, "the targeted pipeline has no PDF file family")
+ continue
+ }
+ value, ok := raw.(bool)
+ if !ok {
+ return fmt.Errorf("%s must be a boolean, got %T", key, raw)
+ }
+ writes.setSetup(target.parserNode, "pdf", key, value)
+ }
+ }
if err := convertIngestionParserPages(config, target, writes, row); err != nil {
return err
}
diff --git a/internal/dao/ingestion_parser_config_migration_test.go b/internal/dao/ingestion_parser_config_migration_test.go
index fa331c72e9..34849ec583 100644
--- a/internal/dao/ingestion_parser_config_migration_test.go
+++ b/internal/dao/ingestion_parser_config_migration_test.go
@@ -20,6 +20,8 @@ var MigrateIngestionParserConfigsForTest = migrateIngestionParserConfigs
var MigrateParserChunkerTokenizerConfigForTest = migrateParserChunkerTokenizerConfig
var MigrateExtractorConfigForTest = migrateExtractorConfig
+// TestMigrateParserChunkerTokenizerConfig pins component ownership, explicit
+// values, existing scoped precedence and idempotence for each supported shape.
func TestMigrateParserChunkerTokenizerConfig(t *testing.T) {
cases := []struct {
name, parser, input, want string
@@ -43,6 +45,24 @@ func TestMigrateParserChunkerTokenizerConfig(t *testing.T) {
{name: "PDF selector does not mask spreadsheet engine", input: `{"layout_recognize":"TCADP Parser","Parser:HipSignsRhyme":{"pdf":{"parse_method":"plain_text"}}}`, want: `{"Parser:HipSignsRhyme":{"pdf":{"parse_method":"plain_text"},"spreadsheet":{"parse_method":"tcadp"}}}`},
{name: "MinerU options reach the PDF setup", input: `{"layout_recognize":"MinerU","mineru_parse_method":"ocr","mineru_lang":"English"}`, want: `{"Parser:HipSignsRhyme":{"pdf":{"parse_method":"mineru","mineru_parse_method":"ocr","mineru_lang":"English"}}}`},
{name: "existing MinerU options win", input: `{"mineru_lang":"English","Parser:HipSignsRhyme":{"pdf":{"parse_method":"mineru","mineru_lang":"Chinese"}}}`, want: `{"Parser:HipSignsRhyme":{"pdf":{"parse_method":"mineru","mineru_lang":"Chinese"}}}`},
+ {name: "disabled MinerU controls reach the PDF setup", input: `{"layout_recognize":"MinerU","mineru_formula_enable":false,"mineru_table_enable":false}`, want: `{"Parser:HipSignsRhyme":{"pdf":{"parse_method":"mineru","mineru_formula_enable":false,"mineru_table_enable":false}}}`},
+ {name: "enabled MinerU controls reach the PDF setup", input: `{"mineru_formula_enable":true,"mineru_table_enable":true}`, want: `{"Parser:HipSignsRhyme":{"pdf":{"mineru_formula_enable":true,"mineru_table_enable":true}}}`},
+ {name: "MinerU controls remain independent", input: `{"mineru_formula_enable":true,"mineru_table_enable":false}`, want: `{"Parser:HipSignsRhyme":{"pdf":{"mineru_formula_enable":true,"mineru_table_enable":false}}}`},
+ {name: "only formula is disabled", input: `{"mineru_formula_enable":false}`, want: `{"Parser:HipSignsRhyme":{"pdf":{"mineru_formula_enable":false}}}`},
+ {name: "only table is enabled", input: `{"mineru_table_enable":true}`, want: `{"Parser:HipSignsRhyme":{"pdf":{"mineru_table_enable":true}}}`},
+ {name: "null MinerU controls stay omitted", input: `{"mineru_formula_enable":null,"mineru_table_enable":null}`, want: `{}`},
+ {name: "an existing disabled formula wins", input: `{"mineru_formula_enable":true,"mineru_table_enable":false,"Parser:HipSignsRhyme":{"pdf":{"mineru_formula_enable":false}}}`, want: `{"Parser:HipSignsRhyme":{"pdf":{"mineru_formula_enable":false,"mineru_table_enable":false}}}`},
+ {name: "an existing enabled table wins", input: `{"mineru_formula_enable":false,"mineru_table_enable":false,"Parser:HipSignsRhyme":{"pdf":{"mineru_table_enable":true}}}`, want: `{"Parser:HipSignsRhyme":{"pdf":{"mineru_formula_enable":false,"mineru_table_enable":true}}}`},
+ {name: "MinerU controls retain book PDF defaults", parser: "book", input: `{"mineru_formula_enable":false}`, want: `{"Parser:HipSignsRhyme":{"pdf":{"mineru_formula_enable":false,"remove_toc":true}}}`},
+ {name: "MinerU controls retain paper PDF defaults", parser: "paper", input: `{"mineru_table_enable":false}`, want: `{"Parser:HipSignsRhyme":{"pdf":{"mineru_table_enable":false,"enable_multi_column":true}}}`},
+ {name: "MinerU controls need a PDF family", parser: "table", input: `{"mineru_formula_enable":false,"mineru_table_enable":true}`, want: `{}`},
+ {name: "picture does not gain a PDF family", parser: "picture", input: `{"mineru_formula_enable":false,"mineru_table_enable":false}`, want: `{}`},
+ {name: "table retires malformed formula control", parser: "table", input: `{"mineru_formula_enable":"false"}`, want: `{}`},
+ {name: "picture retires malformed table control", parser: "picture", input: `{"mineru_table_enable":0}`, want: `{}`},
+ {name: "audio retires structured controls", parser: "audio", input: `{"mineru_formula_enable":[],"mineru_table_enable":{}}`, want: `{}`},
+ {name: "email retires malformed controls", parser: "email", input: `{"mineru_formula_enable":1,"mineru_table_enable":"true"}`, want: `{}`},
+ {name: "custom canvas MinerU controls are untouched", pipeline: ptrString("canvas-1"), input: `{"mineru_formula_enable":false,"mineru_table_enable":true}`, want: `{"mineru_formula_enable":false,"mineru_table_enable":true}`},
+ {name: "unknown parser MinerU controls are untouched", parser: "knowledge_graph", input: `{"mineru_formula_enable":false,"mineru_table_enable":true}`, want: `{"mineru_formula_enable":false,"mineru_table_enable":true}`},
{name: "picture has no engine path", parser: "picture", input: `{"layout_recognize":"PaddleOCR"}`, want: `{}`},
{name: "audio has no engine path", parser: "audio", input: `{"layout_recognize":true}`, want: `{}`},
{name: "pages are normalized", input: `{"pages":[[3,5],[1,2],[6,7]]}`, want: `{"Parser:HipSignsRhyme":{"pdf":{"pages":[[1,7]]}}}`},
@@ -98,7 +118,7 @@ func TestMigrateParserChunkerTokenizerConfig(t *testing.T) {
input: `{"layout_recognize":true,"Parser:HipSignsRhyme":{"pdf":{"preprocess":["main_content"],"remove_toc":false}}}`,
want: `{"Parser:HipSignsRhyme":{"pdf":{"preprocess":["main_content"],"remove_toc":false,"parse_method":"deepdoc"}}}`,
},
- {name: "retired settings are deleted", input: `{"html4excel":true,"task_page_size":256,"analyze_hyperlink":true,"hyperlink_urls":true,"video_prompt":"x","mineru_formula_enable":true}`, want: `{}`},
+ {name: "retired settings are deleted", input: `{"html4excel":true,"task_page_size":256,"analyze_hyperlink":true,"hyperlink_urls":true,"video_prompt":"x"}`, want: `{}`},
{name: "no owned keys", input: `{"chunk_method":"naive","topn_tags":5}`, want: `{"chunk_method":"naive","topn_tags":5}`},
{name: "empty config", input: `{}`, want: `{}`},
{name: "canvas rows are skipped", pipeline: ptrString("canvas-1"), input: `{"layout_recognize":true,"chunk_token_num":128}`, want: `{"layout_recognize":true,"chunk_token_num":128}`},
@@ -128,6 +148,8 @@ func TestMigrateParserChunkerTokenizerConfig(t *testing.T) {
}
}
+// TestMigrateParserChunkerTokenizerConfigRejectsMalformedValues keeps invalid
+// values for supported PDF settings from modifying the source configuration.
func TestMigrateParserChunkerTokenizerConfigRejectsMalformedValues(t *testing.T) {
for _, raw := range []string{
`{"layout_recognize":"MagicOCR"}`,
@@ -143,6 +165,16 @@ func TestMigrateParserChunkerTokenizerConfigRejectsMalformedValues(t *testing.T)
`{"parent_child":"yes"}`,
`{"parent_child":{"use_parent_child":"true"}}`,
`{"enable_children":"true"}`,
+ `{"mineru_formula_enable":"false"}`,
+ `{"mineru_formula_enable":0}`,
+ `{"mineru_formula_enable":1.5}`,
+ `{"mineru_formula_enable":[]}`,
+ `{"mineru_formula_enable":{}}`,
+ `{"mineru_table_enable":"true"}`,
+ `{"mineru_table_enable":1}`,
+ `{"mineru_table_enable":0.5}`,
+ `{"mineru_table_enable":[]}`,
+ `{"mineru_table_enable":{}}`,
`{"children_delimiter":5}`,
`{"table_column_mode":5}`,
`{"table_column_roles":"a"}`,
@@ -164,23 +196,35 @@ func TestMigrateParserChunkerTokenizerConfigRejectsMalformedValues(t *testing.T)
}
}
+// TestMigrateParserChunkerTokenizerConfigLogsRetiredFields distinguishes actual
+// retired settings from MinerU controls that a PDF setup can now consume.
func TestMigrateParserChunkerTokenizerConfigLogsRetiredFields(t *testing.T) {
- core, logs := observer.New(zap.WarnLevel)
- previous := common.Logger
- common.Logger = zap.New(core)
- t.Cleanup(func() { common.Logger = previous })
- config := decodeIngestionConfig(t, `{"html4excel":true,"task_page_size":12,"mineru_formula_enable":false}`)
- if _, err := migrateParserChunkerTokenizerConfig(config, "general", nil, "document", "doc-1"); err != nil {
- t.Fatal(err)
- }
- for _, field := range []string{"html4excel", "task_page_size", "mineru_formula_enable"} {
- entries := logs.FilterField(zap.String("field", field)).All()
- if len(entries) != 1 || entries[0].ContextMap()["table"] != "document" || entries[0].ContextMap()["row_id"] != "doc-1" {
- t.Errorf("missing row-specific warning for %s: %v", field, entries)
- }
+ for _, parser := range []string{"general", "table"} {
+ t.Run(parser, func(t *testing.T) {
+ core, logs := observer.New(zap.WarnLevel)
+ previous := common.Logger
+ common.Logger = zap.New(core)
+ t.Cleanup(func() { common.Logger = previous })
+ config := decodeIngestionConfig(t, `{"html4excel":true,"task_page_size":12,"mineru_formula_enable":false,"mineru_table_enable":true}`)
+ if _, err := migrateParserChunkerTokenizerConfig(config, parser, nil, "document", "doc-1"); err != nil {
+ t.Fatal(err)
+ }
+ for _, field := range []string{"html4excel", "task_page_size", "mineru_formula_enable", "mineru_table_enable"} {
+ entries := logs.FilterField(zap.String("field", field)).All()
+ if parser == "general" && strings.HasPrefix(field, "mineru_") {
+ if len(entries) != 0 {
+ t.Errorf("migrated %s was reported as retired: %v", field, entries)
+ }
+ } else if len(entries) != 1 || entries[0].ContextMap()["table"] != "document" || entries[0].ContextMap()["row_id"] != "doc-1" {
+ t.Errorf("missing row-specific warning for %s: %v", field, entries)
+ }
+ }
+ })
}
}
+// TestMigrateIngestionParserConfigsBatches checks persisted settings across the
+// 256-row batch boundary in both dataset and document tables.
func TestMigrateIngestionParserConfigsBatches(t *testing.T) {
db := openIngestionMigrationDB(t)
for i := 0; i < 257; i++ {
@@ -214,6 +258,14 @@ func TestMigrateIngestionParserConfigsBatches(t *testing.T) {
if pdf["parse_method"] != "plain_text" {
t.Fatalf("%s.%s: pdf=%v", table, row.ID, pdf)
}
+ for _, key := range []string{"mineru_formula_enable", "mineru_table_enable"} {
+ if value, exists := pdf[key]; !exists || value != false {
+ t.Fatalf("%s.%s: migrated %s=%v, present=%v", table, row.ID, key, value, exists)
+ }
+ if _, remains := config[key]; remains {
+ t.Fatalf("%s.%s: flat %s survived", table, row.ID, key)
+ }
+ }
chunker, _ := config["GeneralChunker:SixApplesFall"].(map[string]any)
if chunker["chunk_token_size"] != float64(256) {
t.Fatalf("%s.%s: chunker=%v", table, row.ID, chunker)
@@ -228,9 +280,13 @@ func TestMigrateIngestionParserConfigsBatches(t *testing.T) {
}
}
+// TestMigrateIngestionParserConfigsRejectsInvalidRows keeps failed batches and
+// their version unchanged when a supported setting cannot be converted.
func TestMigrateIngestionParserConfigsRejectsInvalidRows(t *testing.T) {
for _, raw := range []string{
`{"pages":[[9,2]]}`,
+ `{"mineru_formula_enable":"false"}`,
+ `{"mineru_table_enable":0}`,
`not-json`,
`{"auto_keywords":"8","auto_questions":2}`,
`{"enable_metadata":true,"metadata":[{"name":"author"}]}`,
@@ -257,6 +313,66 @@ func TestMigrateIngestionParserConfigsRejectsInvalidRows(t *testing.T) {
}
}
+// TestMigrateIngestionParserConfigsRetiresMalformedMinerUControlsWithoutPDF
+// exercises real batch commit and row-specific retirement warnings. Values that
+// have no PDF consumer must not prevent an otherwise valid database upgrade.
+func TestMigrateIngestionParserConfigsRetiresMalformedMinerUControlsWithoutPDF(t *testing.T) {
+ core, logs := observer.New(zap.WarnLevel)
+ previous := common.Logger
+ common.Logger = zap.New(core)
+ t.Cleanup(func() { common.Logger = previous })
+ db := openIngestionMigrationDB(t)
+ const raw = `{"mineru_formula_enable":"false","mineru_table_enable":{},"unowned_setting":"retained"}`
+ var parsers []string
+ for parser, target := range ingestionTargets {
+ if target.hasFamily("pdf") {
+ continue
+ }
+ parsers = append(parsers, parser)
+ for _, table := range []string{"knowledgebase", "document"} {
+ insertIngestionConfig(t, db, table, parser, parser, raw)
+ }
+ }
+ if len(parsers) == 0 {
+ t.Fatal("fixture has no non-PDF parser targets")
+ }
+ if err := migrateIngestionParserConfigs(t.Context(), db); err != nil {
+ t.Fatalf("unused malformed controls blocked migration: %v", err)
+ }
+ for _, table := range []string{"knowledgebase", "document"} {
+ var rows []ingestionConfigMigrationRow
+ if err := db.Table(table).Find(&rows).Error; err != nil {
+ t.Fatal(err)
+ }
+ if len(rows) != len(parsers) {
+ t.Fatalf("%s rows=%d; want %d", table, len(rows), len(parsers))
+ }
+ for _, row := range rows {
+ config := decodeIngestionConfig(t, *row.ParserConfig)
+ if !reflect.DeepEqual(config, map[string]any{"unowned_setting": "retained"}) {
+ t.Errorf("%s.%s: unused controls or unwanted setup remain: %v", table, row.ID, config)
+ }
+ for _, field := range []string{"mineru_formula_enable", "mineru_table_enable"} {
+ entries := logs.FilterField(zap.String("field", field)).
+ FilterField(zap.String("table", table)).
+ FilterField(zap.String("row_id", row.ID)).All()
+ if len(entries) != 1 {
+ t.Errorf("%s.%s: expected one retirement warning for %s, got %d", table, row.ID, field, len(entries))
+ }
+ }
+ }
+ }
+ if got := databaseVersion(t, db); got != ingestionParserConfigTargetVersion {
+ t.Fatalf("migration version=%q; want %q", got, ingestionParserConfigTargetVersion)
+ }
+ if err := migrateIngestionParserConfigs(t.Context(), db); err != nil {
+ t.Fatalf("second migration failed: %v", err)
+ }
+ if got, want := logs.Len(), len(parsers)*2*2; got != want {
+ t.Fatalf("retirement logs=%d; want %d without repeat warnings", got, want)
+ }
+}
+
func TestMigrateIngestionParserConfigsVersionAndEmptyRows(t *testing.T) {
for _, tc := range []struct {
version string
@@ -305,7 +421,7 @@ func TestMigrateIngestionParserConfigsVersionAndEmptyRows(t *testing.T) {
// python027IngestionConfig is a dataset parser_config as Python v0.27.2 stored
// it: every value differs from the Go default so a lost field is visible.
-const python027IngestionConfig = `{"auto_keywords":8,"layout_recognize":"plain text","chunk_token_num":256,"delimiter":"\n","overlapped_percent":0.29,"filename_embd_weight":0.2,"pages":[[1,3]],"table_context_size":10,"image_context_size":20,"html4excel":false}`
+const python027IngestionConfig = `{"auto_keywords":8,"layout_recognize":"plain text","chunk_token_num":256,"delimiter":"\n","overlapped_percent":0.29,"filename_embd_weight":0.2,"pages":[[1,3]],"table_context_size":10,"image_context_size":20,"html4excel":false,"mineru_formula_enable":false,"mineru_table_enable":false}`
func openIngestionMigrationDB(t *testing.T) *gorm.DB {
t.Helper()
diff --git a/internal/dao/ingestion_parser_config_runtime_test.go b/internal/dao/ingestion_parser_config_runtime_test.go
index 1c9be4f2f0..3f8a8e9027 100644
--- a/internal/dao/ingestion_parser_config_runtime_test.go
+++ b/internal/dao/ingestion_parser_config_runtime_test.go
@@ -1,14 +1,23 @@
package dao_test
import (
+ "archive/zip"
+ "bytes"
+ "context"
"encoding/json"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
"reflect"
+ "strconv"
"strings"
"testing"
+ "time"
"github.com/glebarez/sqlite"
"gorm.io/gorm"
+ "ragflow/internal/common"
"ragflow/internal/dao"
"ragflow/internal/entity"
"ragflow/internal/ingestion/component"
@@ -23,6 +32,8 @@ import (
// convert, so one run exercises every converter and every target family.
const python027MaximalIngestionConfig = `{
"layout_recognize":"TCADP Parser",
+ "mineru_formula_enable":false,
+ "mineru_table_enable":true,
"pages":[[1,3]],
"table_result_type":"2",
"markdown_image_response_type":"2",
@@ -126,6 +137,122 @@ func TestMigratedIngestionConfigReachesRuntime(t *testing.T) {
})
}
+// TestMigratedMinerUControlsReachRequest runs SQLite migration, stored-config
+// readback, real template cleaning and Parser invocation. Only the MinerU HTTP
+// service is a fixture; no OCR inference runs. Local HTTP requires a scoped,
+// process-wide SSRF bypass, so this test and its subtests must not run in parallel.
+func TestMigratedMinerUControlsReachRequest(t *testing.T) {
+ t.Setenv(common.EnvMineruBackend, "pipeline")
+ previous := common.AllowAnyHostForTest
+ common.AllowAnyHostForTest = true
+ t.Cleanup(func() { common.AllowAnyHostForTest = previous })
+
+ var response bytes.Buffer
+ archive := zip.NewWriter(&response)
+ entry, err := archive.Create("content_list.json")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := entry.Write([]byte(`[{"type":"text","text":"Migrated MinerU controls reached the request."}]`)); err != nil {
+ t.Fatal(err)
+ }
+ if err := archive.Close(); err != nil {
+ t.Fatal(err)
+ }
+ registry, err := pipeline.DefaultRegistry()
+ if err != nil {
+ t.Fatal(err)
+ }
+ template, ok := registry.Get("general")
+ if !ok {
+ t.Fatal("general pipeline template missing")
+ }
+ dsl, err := json.Marshal(template.DSL)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ for _, formula := range []bool{false, true} {
+ for _, table := range []bool{false, true} {
+ t.Run(fmt.Sprintf("formula=%t/table=%t", formula, table), func(t *testing.T) {
+ requests := make(chan [2]string, 1)
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
+ if request.URL.Path != "/file_parse" || request.Method != http.MethodPost {
+ http.NotFound(w, request)
+ return
+ }
+ if err := request.ParseMultipartForm(1 << 20); err != nil {
+ t.Errorf("parse multipart request: %v", err)
+ http.Error(w, "invalid fixture request", http.StatusBadRequest)
+ return
+ }
+ defer request.MultipartForm.RemoveAll()
+ if request.Header.Get("Authorization") != "Bearer synthetic-mineru-key" {
+ t.Error("selected instance credentials were lost")
+ }
+ select {
+ case requests <- [2]string{request.FormValue("formula_enable"), request.FormValue("table_enable")}:
+ default:
+ t.Error("unexpected repeated MinerU submission")
+ }
+ w.Header().Set("Content-Type", "application/zip")
+ _, _ = w.Write(response.Bytes())
+ }))
+ t.Cleanup(server.Close)
+ db := openIngestionRuntimeDB(t)
+ if err := db.AutoMigrate(&entity.TenantModelProvider{}, &entity.TenantModelInstance{}, &entity.TenantModel{}); err != nil {
+ t.Fatal(err)
+ }
+ extra, err := json.Marshal(map[string]string{"base_url": server.URL})
+ if err != nil {
+ t.Fatal(err)
+ }
+ for _, row := range []any{
+ &entity.TenantModelProvider{ID: "provider-mineru", TenantID: "tenant", ProviderName: "MinerU"},
+ &entity.TenantModelInstance{ID: "instance-mineru", ProviderID: "provider-mineru", InstanceName: "default", APIKey: "synthetic-mineru-key", Status: "active", Extra: string(extra)},
+ &entity.TenantModel{ID: "model-mineru", ProviderID: "provider-mineru", InstanceID: "instance-mineru", ModelName: "MinerU-model", ModelType: int(entity.ModelTypeOCR), Status: "active"},
+ } {
+ if err := db.Create(row).Error; err != nil {
+ t.Fatal(err)
+ }
+ }
+ input := fmt.Sprintf(`{"layout_recognize":"MinerU-model@default@MinerU","mineru_formula_enable":%t,"mineru_table_enable":%t}`, formula, table)
+ insertIngestionRuntimeRow(t, db, "kb-mineru", "general", input)
+ if err := dao.MigrateIngestionParserConfigsForTest(t.Context(), db); err != nil {
+ t.Fatal(err)
+ }
+ config := pipeline.BuildParserConfig(dsl, migratedConfig(t, db, "kb-mineru"))
+ effective := effectiveComponentParams(t, "general", config)
+ parser, err := component.NewParserComponent(effective["Parser:HipSignsRhyme"])
+ if err != nil {
+ t.Fatal(err)
+ }
+ ctx, cancel := context.WithTimeout(t.Context(), 20*time.Second)
+ defer cancel()
+ out, err := parser.Invoke(ctx, db, map[string]any{
+ "binary": []byte("%PDF-1.4"), "name": "synthetic.pdf", "file_type": "pdf", "tenant_id": "tenant",
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ encoded, err := json.Marshal(out)
+ if err != nil || !strings.Contains(string(encoded), "Migrated MinerU controls reached the request.") {
+ t.Fatalf("Parser output did not contain fixture text: %s, err=%v", encoded, err)
+ }
+ select {
+ case got := <-requests:
+ want := [2]string{strconv.FormatBool(formula), strconv.FormatBool(table)}
+ if got != want {
+ t.Errorf("migrated formula_enable/table_enable=%v, want %v", got, want)
+ }
+ default:
+ t.Fatal("no MinerU request received")
+ }
+ })
+ }
+ }
+}
+
// TestMigratedParentChildMatchesWritePath asserts the migration derives
// children_delimiters exactly as the API's own ApplyParentChildChunkerConfig
// does for the same setting, so a migrated row and a row saved through the UI
@@ -249,6 +376,11 @@ func TestIngestionMigrationMatchesBuiltinTemplates(t *testing.T) {
config: `{"table_column_mode":"manual","table_column_roles":{"a":"indexing"},"table_column_names":["a"]}`,
families: map[string]bool{"spreadsheet": true},
},
+ {
+ name: "MinerU controls",
+ config: `{"mineru_formula_enable":false,"mineru_table_enable":true}`,
+ families: map[string]bool{"pdf": true},
+ },
{
name: "chunking",
config: `{"chunk_token_num":256,"delimiter":"\n","overlapped_percent":0.29,"enable_children":true}`,
@@ -302,6 +434,14 @@ func TestIngestionMigrationMatchesBuiltinTemplates(t *testing.T) {
if nodeWritten {
assertFamiliesPreserved(t, node, templateFamilies, wantFamilies)
}
+ if (tc.name == "maximal" || tc.name == "MinerU controls") && wantFamilies["pdf"] {
+ pdf := node["pdf"].(map[string]any)
+ for key, want := range map[string]bool{"mineru_formula_enable": false, "mineru_table_enable": true} {
+ if got, exists := pdf[key]; !exists || got != want {
+ t.Errorf("migrated %s=%v, present=%v; want %v", key, got, exists, want)
+ }
+ }
+ }
// The Parser the run compiles must accept the override. The
// merge is applyOverrideParams': the template params with the
// stored component params on top.
diff --git a/internal/ingestion/component/mineru_options_test.go b/internal/ingestion/component/mineru_options_test.go
new file mode 100644
index 0000000000..4e965600de
--- /dev/null
+++ b/internal/ingestion/component/mineru_options_test.go
@@ -0,0 +1,242 @@
+//
+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package component
+
+import (
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "strconv"
+ "strings"
+ "sync/atomic"
+ "testing"
+)
+
+// TestMinerUExtractionSwitches exercises construction, tenant-model resolution
+// and the actual multipart request, including independently omitted switches.
+func TestMinerUExtractionSwitches(t *testing.T) {
+ withSSRFBypass(t)
+ options := []struct {
+ name string
+ value any
+ want bool
+ }{
+ {"omitted", nil, true},
+ {"enabled", true, true},
+ {"disabled", false, false},
+ }
+ backends := []string{
+ "pipeline", "vlm-engine", "vlm-auto-engine", "vlm-http-client",
+ "hybrid-engine", "hybrid-auto-engine", "hybrid-http-client",
+ }
+ for _, backend := range backends {
+ for _, formula := range options {
+ for _, table := range options {
+ t.Run(backend+"/"+formula.name+"/"+table.name, func(t *testing.T) {
+ requests := make(chan [2]string, 1)
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/file_parse" || r.Method != http.MethodPost {
+ http.NotFound(w, r)
+ return
+ }
+ if err := r.ParseMultipartForm(1 << 20); err != nil {
+ t.Errorf("parse multipart form: %v", err)
+ http.Error(w, "bad form", http.StatusBadRequest)
+ return
+ }
+ defer r.MultipartForm.RemoveAll()
+ if got := r.FormValue("backend"); got != backend {
+ t.Errorf("backend = %q, want %q", got, backend)
+ }
+ for key, want := range map[string]string{
+ "parse_method": "ocr", "lang_list": "japan",
+ "return_md": "true", "return_content_list": "true",
+ } {
+ if got := r.FormValue(key); got != want {
+ t.Errorf("%s = %q, want %q", key, got, want)
+ }
+ }
+ if r.Header.Get("Authorization") != "Bearer mineru-secret" {
+ t.Error("tenant instance credentials were not retained")
+ }
+ requests <- [2]string{r.FormValue("formula_enable"), r.FormValue("table_enable")}
+ writeMinerUZipResponse(w, "Extraction switches reached the selected model.")
+ }))
+ defer server.Close()
+ db, modelID := setupMinerUVisionDispatchDB(t, server.URL)
+ pdf := map[string]any{
+ "parse_method": modelID, "mineru_backend": backend,
+ "mineru_server_url": "http://model.invalid",
+ "mineru_parse_method": "ocr", "mineru_lang": "Japanese",
+ }
+ if formula.value != nil {
+ pdf["mineru_formula_enable"] = formula.value
+ }
+ if table.value != nil {
+ pdf["mineru_table_enable"] = table.value
+ }
+ component, err := NewParserComponent(map[string]any{"pdf": pdf})
+ if err != nil {
+ t.Fatal(err)
+ }
+ out, err := component.Invoke(t.Context(), db, map[string]any{
+ "binary": []byte("%PDF-1.4"), "name": "sample.pdf",
+ "file_type": "pdf", "tenant_id": "test-tenant",
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ requireJSONText(t, out, "Extraction switches reached the selected model.")
+ select {
+ case got := <-requests:
+ want := [2]string{strconv.FormatBool(formula.want), strconv.FormatBool(table.want)}
+ if got != want {
+ t.Errorf("formula_enable/table_enable = %v, want %v", got, want)
+ }
+ default:
+ t.Fatal("no /file_parse request")
+ }
+ })
+ }
+ }
+ }
+}
+
+// TestMinerUExtractionSwitchTypes rejects malformed saved values instead of
+// silently converting them to the enabled default.
+func TestMinerUExtractionSwitchTypes(t *testing.T) {
+ for _, key := range []string{"mineru_formula_enable", "mineru_table_enable"} {
+ for _, value := range []any{nil, "false", 0, []any{}, map[string]any{}} {
+ t.Run(fmt.Sprintf("%s/%T", key, value), func(t *testing.T) {
+ _, err := NewParserComponent(map[string]any{
+ "pdf": map[string]any{"parse_method": "mineru", key: value},
+ })
+ if err == nil || !strings.Contains(err.Error(), key+" must be a boolean") {
+ t.Fatalf("invalid switch %v: error = %v", value, err)
+ }
+ })
+ }
+ }
+}
+
+// TestMinerUV1RejectsDisabledExtraction verifies that unsupported preferences
+// fail before creating an upload or job on the V1 protocol.
+func TestMinerUV1RejectsDisabledExtraction(t *testing.T) {
+ withSSRFBypass(t)
+ for _, pdf := range []map[string]any{
+ {"mineru_formula_enable": false},
+ {"mineru_table_enable": false},
+ {"mineru_formula_enable": false, "mineru_table_enable": false},
+ {"mineru_formula_enable": false, "mineru_table_enable": true},
+ {"mineru_formula_enable": true, "mineru_table_enable": false},
+ } {
+ t.Run(fmt.Sprint(pdf), func(t *testing.T) {
+ var submissions atomic.Int32
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path == "/v1/health" && r.Method == http.MethodGet {
+ w.WriteHeader(http.StatusOK)
+ return
+ }
+ submissions.Add(1)
+ http.Error(w, "must reject before upload or job creation", http.StatusBadRequest)
+ }))
+ defer server.Close()
+ db, modelID := setupMinerUVisionDispatchDB(t, server.URL)
+ pdf["parse_method"] = modelID
+ component, err := NewParserComponent(map[string]any{"pdf": pdf})
+ if err != nil {
+ t.Fatal(err)
+ }
+ _, err = component.Invoke(t.Context(), db, map[string]any{
+ "binary": []byte("%PDF-1.4"), "name": "sample.pdf",
+ "file_type": "pdf", "tenant_id": "test-tenant",
+ })
+ if err == nil || !strings.Contains(err.Error(), "V1 does not support disabling formula or table extraction") {
+ t.Errorf("unsupported V1 preference: error = %v", err)
+ }
+ if got := submissions.Load(); got != 0 {
+ t.Errorf("created %d requests after V1 probe; want no upload or job", got)
+ }
+ })
+ }
+}
+
+// TestMinerUV1EnabledExtractionPreservesJob ensures default/enabled switches do
+// not add unsupported fields to V1's strictly validated job request.
+func TestMinerUV1EnabledExtractionPreservesJob(t *testing.T) {
+ withSSRFBypass(t)
+ for _, enabled := range []map[string]any{
+ {},
+ {"mineru_formula_enable": true},
+ {"mineru_table_enable": true},
+ {"mineru_formula_enable": true, "mineru_table_enable": true},
+ } {
+ t.Run(fmt.Sprint(enabled), func(t *testing.T) {
+ var jobs atomic.Int32
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "application/json")
+ switch r.URL.Path {
+ case "/v1/health":
+ _, _ = w.Write([]byte(`{}`))
+ case "/v1/uploads":
+ _, _ = w.Write([]byte(`{"status":"completed","file":{"id":"fixture-file"}}`))
+ case "/v1/parse/jobs":
+ var job map[string]any
+ if err := json.NewDecoder(r.Body).Decode(&job); err != nil {
+ t.Error(err)
+ http.Error(w, "invalid job", http.StatusBadRequest)
+ return
+ }
+ for key := range job {
+ switch key {
+ case "files", "tier", "output_formats", "ocr_mode":
+ default:
+ t.Errorf("unsupported V1 job field %q", key)
+ }
+ }
+ jobs.Add(1)
+ _, _ = w.Write([]byte(`{"job_id":"fixture-job","status":"completed","files":[{"status":"completed","output_files":{"markdown":{"file_id":"fixture-output"}}}]}`))
+ case "/v1/files/fixture-output/content":
+ _, _ = w.Write([]byte("V1 extraction defaults are unchanged."))
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ defer server.Close()
+ db, modelID := setupMinerUVisionDispatchDB(t, server.URL)
+ pdf := map[string]any{"parse_method": modelID}
+ for key, value := range enabled {
+ pdf[key] = value
+ }
+ component, err := NewParserComponent(map[string]any{"pdf": pdf})
+ if err != nil {
+ t.Fatal(err)
+ }
+ out, err := component.Invoke(t.Context(), db, map[string]any{
+ "binary": []byte("%PDF-1.4"), "name": "sample.pdf",
+ "file_type": "pdf", "tenant_id": "test-tenant",
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ requireJSONText(t, out, "V1 extraction defaults are unchanged.")
+ if jobs.Load() != 1 {
+ t.Fatalf("V1 parse jobs = %d, want 1", jobs.Load())
+ }
+ })
+ }
+}
diff --git a/internal/ingestion/component/parser.go b/internal/ingestion/component/parser.go
index 3dc3c4c863..9d0c421d38 100644
--- a/internal/ingestion/component/parser.go
+++ b/internal/ingestion/component/parser.go
@@ -267,6 +267,9 @@ func (c *ParserComponent) Check() error {
if pm, _ := pdf["parse_method"].(string); pm == "" {
return errors.New("parse method abnormal. does not support empty value")
}
+ if _, err := readMinerUExtractionOptions(pdf); err != nil {
+ return err
+ }
}
// The whole image contract keys off whether ocr_enabled is present, so a
// value of the wrong type must not quietly read as "absent" and fall back to
diff --git a/internal/ingestion/component/pdf_vision_dispatch.go b/internal/ingestion/component/pdf_vision_dispatch.go
index 53897b6496..8125ecf213 100644
--- a/internal/ingestion/component/pdf_vision_dispatch.go
+++ b/internal/ingestion/component/pdf_vision_dispatch.go
@@ -476,6 +476,33 @@ func getAnyString(object map[string]any, keys ...string) string {
return ""
}
+type mineruExtractionOptions struct {
+ formulaEnable bool
+ tableEnable bool
+}
+
+// readMinerUExtractionOptions keeps defaults and validation identical for
+// component construction and dispatch. Only absence means "enabled".
+func readMinerUExtractionOptions(setup schema.ParserSetup) (mineruExtractionOptions, error) {
+ options := mineruExtractionOptions{formulaEnable: true, tableEnable: true}
+ for _, field := range []struct {
+ key string
+ value *bool
+ }{
+ {"mineru_formula_enable", &options.formulaEnable},
+ {"mineru_table_enable", &options.tableEnable},
+ } {
+ if raw, exists := setup[field.key]; exists {
+ value, ok := raw.(bool)
+ if !ok {
+ return options, fmt.Errorf("pdf.%s must be a boolean", field.key)
+ }
+ *field.value = value
+ }
+ }
+ return options, nil
+}
+
// dispatchMinerUPDF submits a PDF to the selected MinerU OCR model.
// MinerU 4.0 uses the V1 upload/job API; 3.x still POSTs /file_parse with
// stream=True and returns a zip body (Python mineru_parser.py:parse_PDF).
@@ -488,6 +515,10 @@ func dispatchMinerUPDF(
setup schema.ParserSetup,
modelID string,
) (parser.ParseResult, error) {
+ extraction, err := readMinerUExtractionOptions(setup)
+ if err != nil {
+ return parser.ParseResult{}, err
+ }
driver, _, apiConfig, err := resolveMinerUModelForDispatch(ctx, db, tenantID, modelID)
if err != nil {
return parser.ParseResult{}, fmt.Errorf("parser: MinerU model: %w", err)
@@ -533,6 +564,11 @@ func dispatchMinerUPDF(
}
if v1 {
+ // V1's strict CreateJobRequest has no extraction switches. Reject
+ // unsupported choices before creating an upload or parse job.
+ if !extraction.formulaEnable || !extraction.tableEnable {
+ return parser.ParseResult{}, fmt.Errorf("parser: MinerU V1 does not support disabling formula or table extraction; use a /file_parse server to configure these switches")
+ }
result, err := modelModule.ParseMinerUV1(ctx, baseURL, apiKeyRaw, filename, binary, backend, parseMethod, 0)
if err != nil {
return parser.ParseResult{}, fmt.Errorf("parser: MinerU V1: %w", err)
@@ -557,7 +593,7 @@ func dispatchMinerUPDF(
}
apiURL := strings.TrimRight(baseURL, "/") + "/file_parse"
- zipBytes, err := mineruStreamParse(apiURL, apiKeyRaw, binary, parseMethod, mineruLang, backend, serverURL)
+ zipBytes, err := mineruStreamParse(apiURL, apiKeyRaw, binary, parseMethod, mineruLang, backend, serverURL, extraction)
if err != nil {
return parser.ParseResult{}, fmt.Errorf("parser: MinerU stream: %w", err)
}
@@ -714,7 +750,7 @@ func mineruAPIParseMethod(raw string) string {
// mineruStreamParse POSTs the PDF binary to the MinerU /file_parse
// endpoint with streaming and returns the zip response body.
// Mirrors Python's mineru_parser.py._run_mineru_api with stream=True.
-func mineruStreamParse(apiURL string, apiKey string, binary []byte, parseMethod, lang, backend, serverURL string) ([]byte, error) {
+func mineruStreamParse(apiURL string, apiKey string, binary []byte, parseMethod, lang, backend, serverURL string, extraction mineruExtractionOptions) ([]byte, error) {
var body bytes.Buffer
writer := multipart.NewWriter(&body)
@@ -737,8 +773,8 @@ func mineruStreamParse(apiURL string, apiKey string, binary []byte, parseMethod,
_ = writer.WriteField("return_images", "true")
_ = writer.WriteField("return_middle_json", "true")
_ = writer.WriteField("return_model_output", "true")
- _ = writer.WriteField("formula_enable", "true")
- _ = writer.WriteField("table_enable", "true")
+ _ = writer.WriteField("formula_enable", strconv.FormatBool(extraction.formulaEnable))
+ _ = writer.WriteField("table_enable", strconv.FormatBool(extraction.tableEnable))
if strings.TrimSpace(serverURL) != "" {
_ = writer.WriteField("server_url", strings.TrimRight(strings.TrimSpace(serverURL), "/"))
}
diff --git a/internal/ingestion/pipeline/mineru_config_test.go b/internal/ingestion/pipeline/mineru_config_test.go
new file mode 100644
index 0000000000..21fd73b038
--- /dev/null
+++ b/internal/ingestion/pipeline/mineru_config_test.go
@@ -0,0 +1,82 @@
+//
+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pipeline
+
+import (
+ "encoding/json"
+ "fmt"
+ "testing"
+
+ "ragflow/internal/ingestion/component"
+)
+
+// TestBuildParserConfigPreservesMinerUExtractionSwitches verifies that cleaning,
+// serialization and Parser construction retain independent PDF choices.
+func TestBuildParserConfigPreservesMinerUExtractionSwitches(t *testing.T) {
+ for _, nested := range []bool{false, true} {
+ for _, formula := range []any{nil, true, false} {
+ for _, table := range []any{nil, true, false} {
+ t.Run(fmt.Sprintf("nested=%t/formula=%v/table=%v", nested, formula, table), func(t *testing.T) {
+ pdf := map[string]any{"parse_method": "mineru"}
+ if formula != nil {
+ pdf["mineru_formula_enable"] = formula
+ }
+ if table != nil {
+ pdf["mineru_table_enable"] = table
+ }
+ params := map[string]any{"pdf": pdf}
+ if nested {
+ params = map[string]any{"setups": params}
+ }
+ config := BuildParserConfig(generalDSL(t), map[string]any{
+ "Parser:HipSignsRhyme": params,
+ })
+ // Exercise the serialized shape stored in parser_config, not
+ // just the in-memory map before normalization.
+ encoded, err := json.Marshal(config)
+ if err != nil {
+ t.Fatal(err)
+ }
+ var saved map[string]any
+ if err := json.Unmarshal(encoded, &saved); err != nil {
+ t.Fatal(err)
+ }
+ parser := saved["Parser:HipSignsRhyme"].(map[string]any)
+ if _, exists := parser["setups"]; exists {
+ t.Fatal("nested setups were not normalized")
+ }
+ savedPDF := parser["pdf"].(map[string]any)
+ for key, want := range map[string]any{
+ "mineru_formula_enable": formula,
+ "mineru_table_enable": table,
+ } {
+ got, exists := savedPDF[key]
+ if want == nil {
+ if exists {
+ t.Errorf("%s was materialized as %v", key, got)
+ }
+ } else if !exists || got != want {
+ t.Errorf("%s = %v (present=%t), want %v", key, got, exists, want)
+ }
+ }
+ if _, err := component.NewParserComponent(parser); err != nil {
+ t.Fatalf("saved config cannot construct Parser: %v", err)
+ }
+ })
+ }
+ }
+ }
+}
diff --git a/web/src/components/layout-recognize-form-field.test.tsx b/web/src/components/layout-recognize-form-field.test.tsx
new file mode 100644
index 0000000000..b47464f18f
--- /dev/null
+++ b/web/src/components/layout-recognize-form-field.test.tsx
@@ -0,0 +1,148 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { useForm } from 'react-hook-form';
+import { useFetchAllAddedModels } from '@/hooks/use-llm-request';
+import { LayoutRecognizeFormField } from './layout-recognize-form-field';
+import { Form } from './ui/form';
+import { TooltipProvider } from './ui/tooltip';
+
+jest.mock('@/hooks/common-hooks', () => ({
+ useTranslate: () => ({ t: (key: string) => key }),
+}));
+
+jest.mock('react-i18next', () => ({
+ useTranslation: () => ({
+ t: (key: string, fallback?: string) => fallback ?? key,
+ }),
+}));
+
+jest.mock('@/hooks/use-llm-request', () => ({
+ useFetchAllAddedModels: jest.fn(() => ({
+ data: [
+ { model_id: 'mineru-uuid', provider_name: 'MinerU' },
+ { model_id: 'minerunet-uuid', provider_name: 'MinerU.Net' },
+ { model_id: 'other-uuid', provider_name: 'Other' },
+ ],
+ isFetched: true,
+ isError: false,
+ })),
+}));
+
+jest.mock('./model-tree-select', () => ({ buildModelTree: () => [] }));
+jest.mock('./tree-select', () => {
+ const React = jest.requireActual('react');
+ return {
+ TreeSelect: React.forwardRef(
+ (_: unknown, ref: import('react').ForwardedRef<HTMLButtonElement>) => (
+ <button type="button" ref={ref}>
+ Parser selector
+ </button>
+ ),
+ ),
+ };
+});
+jest.mock('./paddleocr-options-form-field', () => ({
+ PaddleOCROptionsFormField: () => null,
+}));
+
+/** Hosts real options in either the PDF setup or default parser form path. */
+function Fixture({
+ method,
+ showOptions = true,
+ defaultSelector = false,
+ explicit = false,
+}: {
+ method: string;
+ showOptions?: boolean;
+ defaultSelector?: boolean;
+ explicit?: boolean;
+}) {
+ const options = explicit
+ ? { mineru_formula_enable: false, mineru_table_enable: true }
+ : {};
+ const form = useForm({
+ defaultValues: defaultSelector
+ ? { parser_config: { layout_recognize: method, ...options } }
+ : { setups: [{ parse_method: method, ...options }] },
+ });
+ const values = form.watch();
+
+ return (
+ <TooltipProvider>
+ <Form {...form}>
+ <LayoutRecognizeFormField
+ name={
+ defaultSelector
+ ? 'parser_config.layout_recognize'
+ : 'setups.0.parse_method'
+ }
+ ownerTenantId="owner-tenant"
+ showMineruOptions={showOptions}
+ showPaddleocrOptions={false}
+ />
+ <output data-testid="form-values">{JSON.stringify(values)}</output>
+ </Form>
+ </TooltipProvider>
+ );
+}
+
+describe('MinerU PDF options', () => {
+ it.each([
+ 'mineru-uuid',
+ 'minerunet-uuid',
+ 'model@instance@MinerU',
+ 'mineru',
+ ])('recognizes %s without relying on the model name', (method) => {
+ render(<Fixture method={method} />);
+ expect(screen.getByText('MinerU Options')).toBeInTheDocument();
+ expect(
+ screen.getByRole('switch', { name: /Formula Recognition/ }),
+ ).toBeChecked();
+ expect(
+ screen.getByRole('switch', { name: /Table Recognition/ }),
+ ).toBeChecked();
+ expect(useFetchAllAddedModels).toHaveBeenCalledWith(
+ undefined,
+ 'owner-tenant',
+ );
+ });
+
+ it('writes each switch under its PDF setup and preserves explicit false', () => {
+ render(<Fixture method="mineru-uuid" explicit />);
+ const formula = screen.getByRole('switch', { name: /Formula Recognition/ });
+ const table = screen.getByRole('switch', { name: /Table Recognition/ });
+ expect(formula).not.toBeChecked();
+ expect(table).toBeChecked();
+ fireEvent.click(table);
+ expect(table).not.toBeChecked();
+ const values = JSON.parse(screen.getByTestId('form-values').textContent!);
+ expect(values.setups[0]).toMatchObject({
+ mineru_formula_enable: false,
+ mineru_table_enable: false,
+ });
+ expect(values).not.toHaveProperty('parser_config');
+ });
+
+ it('uses the default selector prefix when requested', () => {
+ render(<Fixture method="mineru-uuid" defaultSelector explicit />);
+ fireEvent.click(screen.getByRole('switch', { name: /Table Recognition/ }));
+ const values = JSON.parse(screen.getByTestId('form-values').textContent!);
+ expect(values.parser_config).toMatchObject({
+ mineru_formula_enable: false,
+ mineru_table_enable: false,
+ });
+ });
+
+ it.each(['other-uuid', 'DeepDOC', 'other-mineru-model@instance@Other'])(
+ 'does not expose MinerU controls for %s',
+ (method) => {
+ render(<Fixture method={method} />);
+ expect(screen.queryByText('MinerU Options')).not.toBeInTheDocument();
+ },
+ );
+
+ it('can suppress MinerU options on non-PDF forms', () => {
+ render(<Fixture method="mineru-uuid" showOptions={false} />);
+ expect(screen.queryByText('MinerU Options')).not.toBeInTheDocument();
+ });
+});
diff --git a/web/src/components/layout-recognize-form-field.tsx b/web/src/components/layout-recognize-form-field.tsx
index a426932184..8db5837cbb 100644
--- a/web/src/components/layout-recognize-form-field.tsx
+++ b/web/src/components/layout-recognize-form-field.tsx
@@ -15,8 +15,10 @@
*/
import { useTranslate } from '@/hooks/common-hooks';
+import { LLMFactory } from '@/constants/llm';
import { useFetchAllAddedModels } from '@/hooks/use-llm-request';
import { cn } from '@/lib/utils';
+import { parseModelValue } from '@/utils/llm-util';
import { camelCase } from 'lodash';
import { ReactNode, useMemo } from 'react';
import { useFormContext } from 'react-hook-form';
@@ -41,6 +43,7 @@ export const enum ParseDocumentType {
MonkeyOCRv2 = 'MonkeyOCRv2',
}
+/** Selects a parser model and scopes provider-specific options to its form path. */
export function LayoutRecognizeFormField({
name = 'parser_config.layout_recognize',
horizontal = true,
@@ -112,6 +115,17 @@ export function LayoutRecognizeFormField({
control={form.control}
name={name}
render={({ field }) => {
+ const provider =
+ allAddedModels.find((model) => model.model_id === field.value)
+ ?.provider_name ??
+ parseModelValue(field.value)?.model_provider ??
+ field.value;
+ const isMinerU =
+ typeof provider === 'string' &&
+ [LLMFactory.MinerU, LLMFactory.MinerUNet].some(
+ (factory) => factory.toLowerCase() === provider.toLowerCase(),
+ );
+ const namePrefix = name.split('.').slice(0, -1).join('.');
return (
<>
<FormItem className={'items-center space-y-0 '}>
@@ -151,7 +165,9 @@ export function LayoutRecognizeFormField({
<FormMessage />
</div>
</FormItem>
- {showMineruOptions && <MinerUOptionsFormField />}
+ {showMineruOptions && isMinerU && (
+ <MinerUOptionsFormField namePrefix={namePrefix} />
+ )}
{showPaddleocrOptions && <PaddleOCROptionsFormField />}
</>
);
diff --git a/web/src/components/mineru-options-form-field.tsx b/web/src/components/mineru-options-form-field.tsx
index ebca4e3ab2..0b4e17e6ff 100644
--- a/web/src/components/mineru-options-form-field.tsx
+++ b/web/src/components/mineru-options-form-field.tsx
@@ -17,13 +17,11 @@
import { RAGFlowFormItem } from '@/components/ragflow-form';
import { SelectWithSearch } from './originui/select-with-search';
import { Switch } from '@/components/ui/switch';
-import { LLMFactory } from '@/constants/llm';
import { buildOptions } from '@/utils/form';
-import { useFormContext, useWatch } from 'react-hook-form';
import { useTranslation } from 'react-i18next';
-const parseMethodOptions = buildOptions(['auto', 'txt', 'ocr']);
-const languageOptions = buildOptions([
+const ParseMethodOptions = buildOptions(['auto', 'txt', 'ocr']);
+const LanguageOptions = buildOptions([
'English',
'Chinese',
'Traditional Chinese',
@@ -46,29 +44,19 @@ const languageOptions = buildOptions([
'Hindi',
]);
-export function MinerUOptionsFormField({
- namePrefix = 'parser_config',
-}: {
- namePrefix?: string;
-}) {
- const form = useFormContext();
+/** Edits MinerU PDF options under the parent-selected setup, retaining false. */
+export function MinerUOptionsFormField({ namePrefix }: { namePrefix: string }) {
const { t } = useTranslation();
const buildName = (field: string) =>
namePrefix ? `${namePrefix}.${field}` : field;
-
- const layoutRecognize = useWatch({
- control: form.control,
- name: 'parser_config.layout_recognize',
- });
-
- // Check if MinerU is selected (the value contains 'MinerU' or matches the factory name)
- const isMinerUSelected =
- layoutRecognize?.includes(LLMFactory.MinerU) ||
- layoutRecognize?.toLowerCase()?.includes('mineru');
-
- if (!isMinerUSelected) {
- return null;
- }
+ const formulaLabel = t(
+ 'knowledgeConfiguration.mineruFormulaEnable',
+ 'Formula Recognition',
+ );
+ const tableLabel = t(
+ 'knowledgeConfiguration.mineruTableEnable',
+ 'Table Recognition',
+ );
return (
<div className="space-y-4 border-l-2 border-primary/30 pl-4 ml-2">
@@ -89,7 +77,7 @@ export function MinerUOptionsFormField({
<SelectWithSearch
value={field.value || 'auto'}
onChange={field.onChange}
- options={parseMethodOptions}
+ options={ParseMethodOptions}
placeholder={t('common.selectPlaceholder', 'Select value')}
/>
)}
@@ -108,7 +96,7 @@ export function MinerUOptionsFormField({
<SelectWithSearch
value={field.value || 'English'}
onChange={field.onChange}
- options={languageOptions}
+ options={LanguageOptions}
placeholder={t('common.selectPlaceholder', 'Select value')}
/>
)}
@@ -116,19 +104,18 @@ export function MinerUOptionsFormField({
<RAGFlowFormItem
name={buildName('mineru_formula_enable')}
- label={t(
- 'knowledgeConfiguration.mineruFormulaEnable',
- 'Formula Recognition',
- )}
+ label={formulaLabel}
tooltip={t(
'knowledgeConfiguration.mineruFormulaEnableTip',
- 'Enable formula recognition. Note: This may not work correctly for Cyrillic documents.',
+ 'For /file_parse, enable formula recognition. Hybrid backends apply this switch to inline formulas only; block formulas remain enabled. V1 does not support disabling this option.',
)}
horizontal={true}
- labelClassName="!mb-0"
+ labelClassName="!mb-0 whitespace-nowrap"
+ valueClassName="w-auto shrink-0"
>
{(field) => (
<Switch
+ aria-label={formulaLabel}
checked={field.value ?? true}
onCheckedChange={field.onChange}
/>
@@ -137,19 +124,18 @@ export function MinerUOptionsFormField({
<RAGFlowFormItem
name={buildName('mineru_table_enable')}
- label={t(
- 'knowledgeConfiguration.mineruTableEnable',
- 'Table Recognition',
- )}
+ label={tableLabel}
tooltip={t(
'knowledgeConfiguration.mineruTableEnableTip',
- 'Enable table recognition and extraction.',
+ 'For /file_parse, enable table recognition and extraction. V1 does not support disabling this option.',
)}
horizontal={true}
- labelClassName="!mb-0"
+ labelClassName="!mb-0 whitespace-nowrap"
+ valueClassName="w-auto shrink-0"
>
{(field) => (
<Switch
+ aria-label={tableLabel}
checked={field.value ?? true}
onCheckedChange={field.onChange}
/>
diff --git a/web/src/locales/en.ts b/web/src/locales/en.ts
index a5e0d612c3..e613b68deb 100644
--- a/web/src/locales/en.ts
+++ b/web/src/locales/en.ts
@@ -707,9 +707,10 @@ Example: A 1 KB message with 1024-dim embedding uses ~9 KB. The 5 MB default lim
'Method for parsing PDF: auto (automatic detection), txt (text extraction), ocr (optical character recognition)',
mineruFormulaEnable: 'Formula recognition',
mineruFormulaEnableTip:
- 'Enable formula recognition. Note: This may not work correctly for Cyrillic documents.',
+ 'For /file_parse, enable formula recognition. Hybrid backends apply this switch to inline formulas only; block formulas remain enabled. V1 does not support disabling this option.',
mineruTableEnable: 'Table recognition',
- mineruTableEnableTip: 'Enable table recognition and extraction.',
+ mineruTableEnableTip:
+ 'For /file_parse, enable table recognition and extraction. V1 does not support disabling this option.',
paddleocrOptions: 'PaddleOCR Options',
paddleocrApiUrl: 'PaddleOCR API URL',
paddleocrApiUrlTip: 'The API endpoint URL for PaddleOCR service',
diff --git a/web/src/locales/zh.ts b/web/src/locales/zh.ts
index 531f3c2944..0092e7df72 100644
--- a/web/src/locales/zh.ts
+++ b/web/src/locales/zh.ts
@@ -642,9 +642,10 @@ export default {
'PDF 解析方法:auto(自动检测)、txt(文本提取)、ocr(光学字符识别)',
mineruFormulaEnable: '公式识别',
mineruFormulaEnableTip:
- '启用公式识别。注意:对于西里尔文档可能无法正常工作。',
+ '通过 /file_parse 启用公式识别。Hybrid 后端的此开关仅控制行内公式,块级公式仍会识别。V1 不支持关闭此选项。',
mineruTableEnable: '表格识别',
- mineruTableEnableTip: '启用表格识别和提取。',
+ mineruTableEnableTip:
+ '通过 /file_parse 启用表格识别和提取。V1 不支持关闭此选项。',
paddleocrOptions: 'PaddleOCR 选项',
paddleocrApiUrl: 'PaddleOCR API URL',
paddleocrApiUrlTip: 'PaddleOCR 服务的 API 端点 URL',
diff --git a/web/src/pages/agent/form/parser-form/common-form-fields.tsx b/web/src/pages/agent/form/parser-form/common-form-fields.tsx
index b18bec32c4..b3e8029ed0 100644
--- a/web/src/pages/agent/form/parser-form/common-form-fields.tsx
+++ b/web/src/pages/agent/form/parser-form/common-form-fields.tsx
@@ -62,10 +62,15 @@ export function OutputFormatFormField({
);
}
+/** Uses owner-tenant models, enabling MinerU options only for PDF callers. */
export function ParserMethodFormField({
prefix,
optionsWithoutLLM,
-}: CommonProps & { optionsWithoutLLM?: { value: string; label: string }[] }) {
+ showMineruOptions = false,
+}: CommonProps & {
+ optionsWithoutLLM?: { value: string; label: string }[];
+ showMineruOptions?: boolean;
+}) {
const { t } = useTranslation();
const ownerTenantId = useOwnerTenantId();
return (
@@ -75,6 +80,7 @@ export function ParserMethodFormField({
optionsWithoutLLM={optionsWithoutLLM}
label={t('flow.parserMethod')}
ownerTenantId={ownerTenantId}
+ showMineruOptions={showMineruOptions}
></LayoutRecognizeFormField>
);
}
diff --git a/web/src/pages/agent/form/parser-form/pdf-form-fields.tsx b/web/src/pages/agent/form/parser-form/pdf-form-fields.tsx
index 08ffc33687..c7024ef5af 100644
--- a/web/src/pages/agent/form/parser-form/pdf-form-fields.tsx
+++ b/web/src/pages/agent/form/parser-form/pdf-form-fields.tsx
@@ -15,6 +15,7 @@ import { DynamicPageRange } from './dynamic-page-range';
import { useSetInitialLanguage } from './use-set-initial-language';
import { buildFieldNameWithPrefix } from './utils';
+/** Renders PDF parsing controls shared by canvas and dataset configuration. */
export function PdfFormFields({ prefix }: CommonProps) {
const parseMethodName = buildFieldNameWithPrefix('parse_method', prefix);
const parseMethod = useWatch({
@@ -37,7 +38,7 @@ export function PdfFormFields({ prefix }: CommonProps) {
<TwoColumnCheckFormField prefix={prefix} />
<RmdirFormField prefix={prefix} />
<RemoveHeaderFooterFormField prefix={prefix} />
- <ParserMethodFormField prefix={prefix}></ParserMethodFormField>
+ <ParserMethodFormField prefix={prefix} showMineruOptions />
<DynamicPageRange prefix={prefix} />
{languageShown && <LanguageFormField prefix={prefix}></LanguageFormField>}
diff --git a/web/src/pages/agent/form/parser-form/schema.test.ts b/web/src/pages/agent/form/parser-form/schema.test.ts
index 2d302afb4d..8ec0da5fdd 100644
--- a/web/src/pages/agent/form/parser-form/schema.test.ts
+++ b/web/src/pages/agent/form/parser-form/schema.test.ts
@@ -3,6 +3,50 @@ import { ParserFields } from '../../constant/pipeline';
import { FormSchema } from './schema';
describe('parser FormSchema', () => {
+ it.each([undefined, true, false])(
+ 'retains MinerU extraction switches set to %s',
+ (enabled) => {
+ const result = FormSchema.parse({
+ setups: [
+ {
+ fileFormat: FileType.PDF,
+ parse_method: 'mineru-model-id',
+ mineru_parse_method: 'ocr',
+ mineru_lang: 'Japanese',
+ ...(enabled === undefined
+ ? {}
+ : {
+ mineru_formula_enable: enabled,
+ mineru_table_enable: enabled,
+ }),
+ },
+ ],
+ });
+ expect(result.setups[0]).toMatchObject({
+ mineru_parse_method: 'ocr',
+ mineru_lang: 'Japanese',
+ });
+ if (enabled !== undefined) {
+ expect(result.setups[0]).toMatchObject({
+ mineru_formula_enable: enabled,
+ mineru_table_enable: enabled,
+ });
+ }
+ },
+ );
+
+ it.each(['mineru_formula_enable', 'mineru_table_enable'])(
+ 'rejects non-boolean %s',
+ (key) => {
+ for (const value of [null, 'false', 0, [], {}]) {
+ const result = FormSchema.safeParse({
+ setups: [{ fileFormat: FileType.PDF, [key]: value }],
+ });
+ expect(result.success).toBe(false);
+ }
+ },
+ );
+
it('keeps the explicit image OCR model through schema save/readback', () => {
const values = {
setups: [
@@ -27,6 +71,7 @@ describe('parser FormSchema', () => {
}).success,
).toBe(false);
});
+
it('accepts video and audio setups without a model', () => {
const result = FormSchema.safeParse({
setups: [
diff --git a/web/src/pages/agent/form/parser-form/schema.ts b/web/src/pages/agent/form/parser-form/schema.ts
index ab2d61c0e6..ce405af669 100644
--- a/web/src/pages/agent/form/parser-form/schema.ts
+++ b/web/src/pages/agent/form/parser-form/schema.ts
@@ -8,6 +8,10 @@ export const SetupSchema = z
// preprocess: z.array(z.string()).optional(),
output_format: z.string().optional(),
parse_method: z.string().optional(),
+ mineru_parse_method: z.string().optional(),
+ mineru_lang: z.string().optional(),
+ mineru_formula_enable: z.boolean().optional(),
+ mineru_table_enable: z.boolean().optional(),
// Image OCR runs independently of the global vision-enhancement switch.
// The dropdown used to encode this choice in parse_method; ocr_enabled is
// the new boolean contract. Legacy setups may still carry a parse_method
diff --git a/web/src/pages/agent/utils.test.ts b/web/src/pages/agent/utils.test.ts
index 58edba29a4..c6927b7f70 100644
--- a/web/src/pages/agent/utils.test.ts
+++ b/web/src/pages/agent/utils.test.ts
@@ -1,7 +1,12 @@
import { RAGFlowNodeType } from '@/interfaces/database/agent';
import { FileType } from '@/constants/file';
-import { transformApiConfigToForm } from '@/utils/pipeline-operator';
+import { normalizeParserConfig } from '@/hooks/parser-config-utils';
+import {
+ transformApiConfigToForm,
+ transformSavedParserConfigToForm,
+} from '@/utils/pipeline-operator';
import { Operator } from './constant';
+import { FormSchema } from './form/parser-form/schema';
import {
generateNodeNamesWithIncreasingIndex,
isEmptyMessageContent,
@@ -13,6 +18,139 @@ import {
transformTokenChunkerParams,
} from './utils';
+describe('transformParserParams MinerU settings', () => {
+ it('round-trips component-scoped choices through validation, save and reload', () => {
+ const config = {
+ 'Parser:primary': {
+ pdf: {
+ parse_method: 'mineru-model-id',
+ mineru_formula_enable: false,
+ mineru_table_enable: true,
+ mineru_parse_method: 'ocr',
+ mineru_lang: 'Japanese',
+ },
+ },
+ 'Parser:secondary': {
+ pdf: {
+ parse_method: 'mineru-model-id',
+ mineru_formula_enable: true,
+ mineru_table_enable: false,
+ },
+ },
+ };
+ const form = transformSavedParserConfigToForm(config)!;
+ const saved = Object.fromEntries(
+ Object.entries(form).map(([id, values]) => [
+ id,
+ transformParserParams(FormSchema.parse(values)),
+ ]),
+ );
+ const stored = JSON.parse(JSON.stringify(normalizeParserConfig(saved)));
+ expect(stored).toMatchObject(config);
+ expect(transformSavedParserConfigToForm(stored)).toMatchObject(form);
+ });
+
+ it.each([
+ { modelId: 'model-b', ocrEnabled: true },
+ { modelId: '', ocrEnabled: true },
+ { modelId: 'model-b', ocrEnabled: false },
+ { modelId: '', ocrEnabled: false },
+ ])(
+ 'round-trips MinerU PDF controls alongside image OCR $modelId with OCR enabled=$ocrEnabled',
+ ({ modelId, ocrEnabled }) => {
+ const config = {
+ 'Parser:primary': {
+ enable_vision_enhancement: !ocrEnabled,
+ vlm: {
+ llm_id: 'vision-model-id',
+ system_prompt: 'Describe visible details.',
+ },
+ pdf: {
+ parse_method: 'mineru-model-id',
+ mineru_formula_enable: false,
+ mineru_table_enable: true,
+ mineru_parse_method: 'ocr',
+ mineru_lang: 'Japanese',
+ },
+ image: {
+ ocr_enabled: ocrEnabled,
+ ocr_model_id: modelId,
+ },
+ },
+ };
+ // Exercise the saved-config boundary and schema, not live OCR execution.
+ const form = transformSavedParserConfigToForm(config)!;
+ const saved = {
+ 'Parser:primary': transformParserParams(
+ FormSchema.parse(form['Parser:primary']),
+ ),
+ };
+ const stored = JSON.parse(JSON.stringify(normalizeParserConfig(saved)));
+ expect(stored).toMatchObject(config);
+ expect(stored['Parser:primary'].pdf).not.toHaveProperty('ocr_enabled');
+ expect(stored['Parser:primary'].pdf).not.toHaveProperty('ocr_model_id');
+ for (const key of [
+ 'mineru_formula_enable',
+ 'mineru_table_enable',
+ 'mineru_parse_method',
+ 'mineru_lang',
+ ]) {
+ expect(stored['Parser:primary'].image).not.toHaveProperty(key);
+ }
+
+ const reloaded = transformSavedParserConfigToForm(stored)!;
+ const savedAgain = {
+ 'Parser:primary': transformParserParams(
+ FormSchema.parse(reloaded['Parser:primary']),
+ ),
+ };
+ expect(
+ JSON.parse(JSON.stringify(normalizeParserConfig(savedAgain))),
+ ).toEqual(stored);
+ },
+ );
+
+ it.each([undefined, true, false])(
+ 'preserves independent formula/table choices and engine settings: %s',
+ (formulaEnabled) => {
+ for (const tableEnabled of [undefined, true, false]) {
+ const result = transformParserParams({
+ setups: [
+ {
+ fileFormat: FileType.PDF,
+ parse_method: 'mineru-model-id',
+ mineru_parse_method: 'ocr',
+ mineru_lang: 'Japanese',
+ ...(formulaEnabled === undefined
+ ? {}
+ : { mineru_formula_enable: formulaEnabled }),
+ ...(tableEnabled === undefined
+ ? {}
+ : { mineru_table_enable: tableEnabled }),
+ },
+ ],
+ } as any);
+ const saved = JSON.parse(JSON.stringify(result)).pdf;
+ expect(saved).toMatchObject({
+ parse_method: 'mineru-model-id',
+ mineru_parse_method: 'ocr',
+ mineru_lang: 'Japanese',
+ });
+ if (formulaEnabled === undefined) {
+ expect(saved).not.toHaveProperty('mineru_formula_enable');
+ } else {
+ expect(saved.mineru_formula_enable).toBe(formulaEnabled);
+ }
+ if (tableEnabled === undefined) {
+ expect(saved).not.toHaveProperty('mineru_table_enable');
+ } else {
+ expect(saved.mineru_table_enable).toBe(tableEnabled);
+ }
+ }
+ },
+ );
+});
+
describe('transformParserParams vision settings', () => {
it.each(['model-b', ''])(
'saves the explicit image OCR selection %j',
diff --git a/web/src/pages/agent/utils.ts b/web/src/pages/agent/utils.ts
index 04c51b345b..cb302d0199 100644
--- a/web/src/pages/agent/utils.ts
+++ b/web/src/pages/agent/utils.ts
@@ -204,7 +204,14 @@ function transformObjectArrayToPureArray(
: [];
}
-/** Serializes parser form fields without losing the selected image OCR model. */
+/**
+ * Serializes parser form values into per-file-family API parameters.
+ * Normalizes global vision settings while preserving explicit PDF MinerU
+ * controls (including false) and the independent image OCR switch/model ID.
+ *
+ * @param params - Parser form values, including setups and global vision options.
+ * @returns File-family parameters alongside normalized global vision settings.
+ */
export function transformParserParams(params: ParserFormSchemaType) {
// Save global vision options from the normalized form alongside the
// per-family setups, including nodes whose form has not been opened.
@@ -231,6 +238,10 @@ export function transformParserParams(params: ParserFormSchemaType) {
filteredSetup = {
...filteredSetup,
parse_method: cur.parse_method,
+ mineru_parse_method: cur.mineru_parse_method,
+ mineru_lang: cur.mineru_lang,
+ mineru_formula_enable: cur.mineru_formula_enable,
+ mineru_table_enable: cur.mineru_table_enable,
lang: cur.lang,
enable_multi_column: cur.enable_multi_column,
remove_toc: cur.remove_toc,