RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
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.mdindex 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:+### 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 localdiff --git a/internal/dao/ingestion_parser_config_migration.go b/internal/dao/ingestion_parser_config_migration.goindex 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.goindex 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 = migrateIngestionParserConfigsvar MigrateParserChunkerTokenizerConfigForTest = migrateParserChunkerTokenizerConfigvar 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.goindex 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_testimport (+ "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.gonew file mode 100644index 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.goindex 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 todiff --git a/internal/ingestion/component/pdf_vision_dispatch.go b/internal/ingestion/component/pdf_vision_dispatch.goindex 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.Bufferwriter := 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.gonew file mode 100644index 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.tsxnew file mode 100644index 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',+ '[email protected]',+ '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.tsxindex 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.tsxindex 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({<SelectWithSearchvalue={field.value || 'auto'}onChange={field.onChange}- options={parseMethodOptions}+ options={ParseMethodOptions}placeholder={t('common.selectPlaceholder', 'Select value')}/>)}@@ -108,7 +96,7 @@ export function MinerUOptionsFormField({<SelectWithSearchvalue={field.value || 'English'}onChange={field.onChange}- options={languageOptions}+ options={LanguageOptions}placeholder={t('common.selectPlaceholder', 'Select value')}/>)}@@ -116,19 +104,18 @@ export function MinerUOptionsFormField({<RAGFlowFormItemname={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({<RAGFlowFormItemname={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.tsindex 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.tsindex 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.tsxindex 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.tsxindex 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.tsindex 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.tsindex 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_methoddiff --git a/web/src/pages/agent/utils.test.ts b/web/src/pages/agent/utils.test.tsindex 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.tsindex 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,